diff --git a/.gitignore b/.gitignore index bfd75f0..9f3e9b4 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,13 @@ *.xml productions/._Ds_eepi_data.py *.root +*.png +._*.py +tools/*.pyc +tools/utils/*.pyc + +._*.sh productions/local_test_data/._Ds_eepi_data_local.py productions/local_test_data/._Ds_mumupi_data_local.py productions/local_test_mc/._Ds_eepi_mc_local.py @@ -13,7 +19,11 @@ productions/online_test_mc/._Ds_eepi_mc_online.py productions/online_test_mc/._Ds_mumupi_mc_online.py +*e +*mu + architectures/* *test* .ipynb_checkpoints/* +building_blocks/*.ipynb_checkpoints *example* diff --git a/BDT_select_and_fit.ipynb b/BDT_select_and_fit.ipynb new file mode 100644 index 0000000..c31424a --- /dev/null +++ b/BDT_select_and_fit.ipynb @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hep/davide/miniconda3/envs/root_env/lib/ROOT.py:301: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility\n", + " return _orig_ihook( name, *args, **kwds )\n" + ] + } + ], + "source": [ + "import ROOT as r\n", + "import root_numpy as rn\n", + "import pickle\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import array as array\n", + "from xgboost import XGBClassifier\n", + "from tools.data_processing import *\n", + "from tools.select_and_fit_funct import select_and_fit, plot_MC_vs_data\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#b = r.TBrowser()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PATHs" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "test=1\n", + "l_index=0\n", + "trig_index=5\n", + "mother_index_fit=2\n", + "\n", + "\n", + "l_flv=['e','mu']\n", + "mother_ID=[\"Ds\",\"Dplus\",\"both\"]\n", + "trig_cat=[\"Any\",\"L0l_TOS\",\"TISnotTOS\",\"L0G_TIS\",\"TISorTOS\",\"TOSnotTIS\",\"TOSandTIS\"]\n", + "\n", + "\n", + "BDT_PATH=l_flv[l_index]+'/BDTs/test_'+str(test)\n", + "FIT_PATH=l_flv[l_index]+'/fits'\n", + "with open(BDT_PATH+'/variables_used.pickle', 'rb') as f: \n", + " branches_needed_0 = pickle.load(f)\n", + " \n", + "branches_needed_BDT=['cos_thetal']+branches_needed_0\n", + "branches_old = ['cos_thetal'] + return_branches(data_index=1,mother_index=0,l_index=l_index,meson_index=0)\n", + "branches=[]\n", + "for label in branches_old:\n", + " if 'NDOF' not in label:\n", + " branches.append(label)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data loading, applying mass cuts, preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14942\n", + "(13679, 1155, 1280)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#MC_Dplus_sig_dict, MC_Ds_sig_dict, _ = load_datasets(l_index)\n", + "\"\"\"\n", + "Data\n", + "\n", + "\"\"\"\n", + "if l_flv[l_index]=='e' and trig_cat[trig_index]!='Any':\n", + " with open('/disk/lhcb_data/davide/Rphipi/data_for_BDT_selection/'+l_flv[l_index]+l_flv[l_index]+'/TrigCats/data_for_BDT_selection_'+l_flv[l_index]+l_flv[l_index]+'_'+trig_cat[trig_index]+'.pickle', 'rb') as f:\n", + " data_dict=pickle.load(f)\n", + " \n", + "# with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/TrigCats/'+l_flv[l_index]+l_flv[l_index]+'/'+'MC_Dplus_'+l_flv[l_index]+l_flv[l_index]+'_'+trig_cat[trig_index]+'.pickle', 'rb') as f:\n", + "# MC_Dplus_tuple_dict=pickle.load(f)\n", + "# \n", + "# with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/TrigCats/'+l_flv[l_index]+l_flv[l_index]+'/'+'MC_Ds_'+l_flv[l_index]+l_flv[l_index]+'_'+trig_cat[trig_index]+'.pickle', 'rb') as f:\n", + "# MC_Ds_tuple_dict=pickle.load(f)\n", + " \n", + "elif l_flv[l_index]=='e' and trig_cat[trig_index]=='Any':\n", + " with open('/disk/lhcb_data/davide/Rphipi/data_for_BDT_selection/'+l_flv[l_index]+l_flv[l_index]+'/'+'data_for_BDT_selection_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f:\n", + " data_dict=pickle.load(f)\n", + " \n", + "if l_flv[l_index]=='mu' and trig_cat[trig_index]!='Any':\n", + " with open('/disk/lhcb_data/davide/Rphipi/data_for_BDT_selection/'+l_flv[l_index]+l_flv[l_index]+'/TrigCats/data_for_BDT_selection_'+l_flv[l_index]+l_flv[l_index]+'_'+trig_cat[trig_index]+'.pickle', 'rb') as f:\n", + " data_dict=pickle.load(f)\n", + " \n", + "# with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/TrigCats/'+l_flv[l_index]+l_flv[l_index]+'/'+'MC_Dplus_'+l_flv[l_index]+l_flv[l_index]+'_'+trig_cat[trig_index]+'.pickle', 'rb') as f:\n", + "# MC_Dplus_tuple_dict=pickle.load(f)\n", + "# \n", + "# with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/TrigCats/'+l_flv[l_index]+l_flv[l_index]+'/'+'MC_Ds_'+l_flv[l_index]+l_flv[l_index]+'_'+trig_cat[trig_index]+'.pickle', 'rb') as f:\n", + "# MC_Ds_tuple_dict=pickle.load(f)\n", + " \n", + "elif l_flv[l_index]=='mu' and trig_cat[trig_index]=='Any':\n", + " with open('/disk/lhcb_data/davide/Rphipi/data_for_BDT_selection/'+l_flv[l_index]+l_flv[l_index]+'/'+'data_for_BDT_selection_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f:\n", + " data_dict=pickle.load(f)\n", + "\n", + "print(data_dict[\"Ds_ConsD_M\"].shape[0])\n", + "\"\"\"\n", + "MC signal\n", + "\n", + "\"\"\" \n", + "\n", + "with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_'+mother_ID[1]+'_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f:\n", + " MC_Dplus_tuple_dict=pickle.load(f)\n", + "with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_'+mother_ID[0]+'_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f:\n", + " MC_Ds_tuple_dict=pickle.load(f)\n", + "\n", + "\"\"\"\n", + "MC MISID bkg\n", + "\n", + "\"\"\" \n", + "\n", + "mc_Ds_MISID_mass=rn.root2array(\n", + " \n", + " filenames=\"/disk/lhcb_data/davide/Rphipi/MC/mc_MISID/\"+l_flv[l_index]+l_flv[l_index]+\"/\"+mother_ID[0]+\"23pi_\"+l_flv[l_index]+\"MISID.root\",\n", + " treename = 'DecayTree',\n", + " branches = 'Dsp_0_M',\n", + " )*1000\n", + "\n", + "mc_Dplus_MISID_mass=rn.root2array(\n", + " \n", + " filenames=\"/disk/lhcb_data/davide/Rphipi/MC/mc_MISID/\"+l_flv[l_index]+l_flv[l_index]+\"/\"+mother_ID[1]+\"23pi_\"+l_flv[l_index]+\"MISID.root\",\n", + " treename = 'DecayTree',\n", + " branches = 'Dp_0_M',\n", + " )*1000\n", + "\n", + "\"\"\"\n", + "Normalising the chi2s in data and MC\n", + "\n", + "\"\"\"\n", + "\n", + "MC_Dplus_tuple_dict, MC_Ds_tuple_dict, data_dict = norm_chi2(MC_Dplus_tuple_dict, MC_Ds_tuple_dict, data_dict)\n", + "\n", + "\n", + "\"\"\"\n", + "Applying mass cuts on data, \n", + "retrieving mass distributions for sig MC and data\n", + "\n", + "\"\"\"\n", + "\n", + "if l_index==1:\n", + " if mother_index_fit==0:\n", + " #fitting only the Ds\n", + " lower_cut=1930\n", + " upper_cut=2010\n", + " if mother_index_fit==1:\n", + " #fitting only the Dplus\n", + " lower_cut=1860\n", + " upper_cut=1880\n", + " if mother_index_fit==2:\n", + " lower_cut=1820\n", + " upper_cut=2040\n", + "\n", + "if l_index==0:\n", + " if mother_index_fit==0:\n", + " #fitting only the Ds\n", + " lower_cut=1900\n", + " upper_cut=2040\n", + " if mother_index_fit==1:\n", + " #fitting only the Dplus\n", + " lower_cut=1820\n", + " upper_cut=1920\n", + " if mother_index_fit==2:\n", + " lower_cut=1750\n", + " upper_cut=2100\n", + " \n", + " \n", + "data_mass, mc_Dplus_mass, mc_Ds_mass, data_dict = mass_cut_for_fit(lower_cut, upper_cut, mother_index_fit=mother_index_fit, l_index=l_index,\n", + " branches_needed=branches_needed_BDT, \n", + " data_dict=data_dict, MC_Dplus_dict=MC_Dplus_tuple_dict, MC_Ds_dict=MC_Ds_tuple_dict)\n", + "\n", + "\n", + "\"\"\"\n", + "Preprocessing\n", + "\n", + "\"\"\"\n", + "\n", + "\n", + "\n", + "data_to_select, mc_Dplus_to_select, mc_Ds_to_select = preprocess_for_XGBoost(MC_Dplus_tuple_dict, MC_Ds_tuple_dict, data_dict, branches_needed_BDT, mother_index_fit=mother_index_fit)\n", + "\n", + "\n", + "plt.hist(np.concatenate((mc_Dplus_MISID_mass, mc_Ds_MISID_mass)),bins=70,density=True,alpha=0.7,label=\"MC MISID bkg\");\n", + "plt.hist(np.concatenate((mc_Dplus_mass, mc_Ds_mass)),bins=70,density=True,alpha=0.7,label=\"MC\");\n", + "plt.hist(data_mass,bins=70,density=True,alpha=0.4,label=\"Data\");\n", + "plt.legend();\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Just RooFit it!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BDT cut at 0.0615789473684 fit\n", + "BDT selection..\n", + "(499, 474)\n", + "BDT Signal selection efficiency: 0.399589322382\n", + "chi2 0.747467122077\n", + "Saving fit results...\n" + ] + } + ], + "source": [ + "#Just fit it!\n", + "\n", + "#if __name__=='__main__':\n", + "\n", + " # parser = argparse.ArgumentParser(description='Fit at different BDT cuts')\n", + " # parser.add_argument('-x_cut', metavar='BDT cut', type =float, help='BDT cut')\n", + " # args = parser.parse_args()\n", + " \n", + "x_cut_values = np.linspace(0.01,0.99,num=20)\n", + "data={}\n", + "MC_Dplus={}\n", + "MC_Ds={}\n", + "fit_results={}\n", + "#Just fit it!\n", + "for i, x_cut in enumerate(x_cut_values[1:2]):\n", + " \n", + " if not os.path.exists(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}/'.format(i)):\n", + " os.mkdir(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}/'.format(i))\n", + " \n", + " fit_results[i], data[i], MC_Dplus[i], MC_Ds[i] = select_and_fit(BDT_PATH, mother_index_fit, l_index, trig_index, lower_cut, upper_cut,\n", + " data_mass, mc_Dplus_mass, mc_Ds_mass, mc_Dplus_MISID_mass, mc_Ds_MISID_mass,\n", + " data_to_select, mc_Dplus_to_select, mc_Ds_to_select,\n", + " data_dict, MC_Dplus_tuple_dict, MC_Ds_tuple_dict, branches_needed_BDT, branches, \n", + " x_cut, i, test, plots=True)\n", + " if l_flv[l_index]=='mu':\n", + " with open(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}/fit_results_{1}.txt'.format(i, i), 'w') as f:\n", + " print('Saving fit results...')\n", + " for key, value in fit_results[i].items():\n", + " f.write('%s:%s\\n' % (key, value))\n", + " \n", + " elif l_flv[l_index]=='e' and trig_cat[trig_index]=='Any':\n", + " with open(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}/fit_results_{1}.txt'.format(i, i), 'w') as f:\n", + " print('Saving fit results...')\n", + " for key, value in fit_results[i].items():\n", + " f.write('%s:%s\\n' % (key, value))\n", + " elif l_flv[l_index]=='e' and trig_cat[trig_index]!='Any':\n", + " with open(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}'.format(i)+'/TrigCats/'+trig_cat[trig_index]+'/fit_results_{0}.txt'.format(i), 'w') as f:\n", + " print('Saving fit results...')\n", + " for key, value in fit_results[i].items():\n", + " f.write('%s:%s\\n' % (key, value))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(range(9),[fit_results[i][\"punzi_fom\"] for i in range(9)])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(data[0][\"cos_thetal\"],density=True,bins=40);\n", + "plt.hist(data_dict[\"cos_thetal\"],alpha=0.7,density=True,bins=40);" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "iteration=0\n", + "variable=\"Ds_ConsD_M\"\n", + "\n", + "variable_MC_Ds=variable\n", + "variable_MC_Dplus=variable_MC_Ds.replace(\"Ds\",\"Dplus\")\n", + "\n", + "inf=data[iteration][variable].min()\n", + "sup=data[iteration][variable].max()\n", + "\n", + "data_entries=data[iteration][variable].shape[0]\n", + "\n", + "mc_Ds_entries=MC_Ds[iteration][variable_MC_Ds].shape[0]\n", + "mc_Dplus_entries=MC_Dplus[iteration][variable_MC_Dplus].shape[0]\n", + "\n", + "f=r.TFile(\"test.root\",\"RECREATE\")\n", + "t=r.TTree(\"histo\",\"histo\")\n", + "\n", + "data_hist = r.TH1F(\"sWeighted data \"+ variable, \n", + " \"sWeighted data \"+ variable, \n", + " 70,inf,sup)\n", + "data_hist.Sumw2()\n", + "\n", + "mc_hist = r.TH1F(\"MC \"+ variable, \n", + " \"MC \"+ variable, \n", + " 70,inf,sup)\n", + "mc_hist.Sumw2()\n", + "\n", + "for i in range(data_entries):\n", + " data_hist.Fill(data[iteration][variable][i],data[iteration][\"nDs_sw\"][i])\n", + " \n", + "for i in range(mc_Ds_entries): \n", + " mc_hist.Fill(MC_Ds[iteration][variable_MC_Ds][i])\n", + " \n", + "for i in range(mc_Dplus_entries): \n", + " mc_hist.Fill(MC_Dplus[iteration][variable_MC_Dplus][i])\n", + "\n", + "\n", + "n1 = data_hist.Integral(\"width\") \n", + "data_hist.Scale(1/n1)\n", + "n2 = mc_hist.Integral(\"width\")\n", + "mc_hist.Scale(1/n2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "data_hist.Draw(\"E\")\n", + "#mc_hist.Draw(\"E Same\")\n", + "data_hist.GetXaxis().SetTitle(variable)\n", + "data_hist.GetYaxis().SetTitleOffset(1.5)\n", + "data_hist.GetYaxis().SetTitle(\"distr dN/d\"+variable)\n", + "data_hist.SetLineColor(r.kRed)\n", + "r.gStyle.SetOptStat(\"11\")\n", + "legend = r.TLegend(0.89, 0.89, 0.75, 0.8)\n", + "legend.AddEntry(data_hist,\"data\",\"f\")\n", + "legend.AddEntry(mc_hist,\"mc\",\"f\")\n", + "legend.Draw()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#for variable in branches_needed:\n", + "#\n", + "# plot_MC_vs_data(data_cut, data_weights, MC_Ds_cut, \n", + "# variable, \n", + "# sw_idx=sw_idx, l_index=l_index, mother_index_fit=mother_index_fit)\n", + "#plt.hist(data_cut[\"cos_thetal\"], weights=data_weights_Ds, density=True,\n", + "# histtype='step', hatch='/', fill='True', linewidth='2', \n", + "# alpha=0.65, bins=70, label='Weighted data Cos(theta_l)');\n", + "#\n", + "#plt.hist(MC_Ds_cut[\"cos_thetal\"],density=True, \n", + "# histtype='step', hatch='\\\\', fill='True', linewidth='2', \n", + "# alpha=0.45, bins=70, label='MC Ds Cos(theta_l)');\n", + "#plt.legend(fontsize=12)\n", + "#fig=plt.gcf()\n", + "#fig.set_size_inches(10,6)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#sw_data_array= np.array( \n", + "# [\n", + "# tuple( data[label][k] for label in branches+[\"nDplus_sw\",\"nDs_sw\"] )\n", + "# \n", + "# for k in range(s_weights[0][\"nDplus_sw\"].shape[0])\n", + "# ],\n", + "# \n", + "# dtype=[(label, np.float32) for label in branches+[\"nDplus_sw\",\"nDs_sw\"]]\n", + "# \n", + "# )\n", + "# rn.array2root(sw_data_array,\n", + "# filename='/disk/lhcb_data/davide/Rphipi/BDT_selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sw_data_'+l_flv[l_index]+l_flv[l_index]+'.root',\n", + "# treename='decay_tree',\n", + "# mode='recreate',\n", + "# )" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/BDT_select_and_fit.py b/BDT_select_and_fit.py new file mode 100644 index 0000000..31428b6 --- /dev/null +++ b/BDT_select_and_fit.py @@ -0,0 +1,596 @@ +import ROOT as r +import root_numpy as rn +import pickle +import numpy as np +import matplotlib.pyplot as plt +from xgboost import XGBClassifier +from tools.data_processing import * +from tools.mc_fitter import MC_fit +import os +import argparse + +l_flv=['e','mu'] +mother_ID=["Ds","Dplus","both"] + + + +def select_and_fit(mother_index_fit, l_index, x_cut, iteration, test): + + #PATHS NEEDED + + FIT_PATH=l_flv[l_index]+'/fits' + BDT_PATH=l_flv[l_index]+'/BDTs/test_'+str(test) + + with open(BDT_PATH+'/variables_used.pickle', 'rb') as f: + branches_needed_0 = pickle.load(f) + branches_needed=['cos_thetal']+branches_needed_0 + + #Data loading + MC_Dplus_sig_dict, MC_Ds_sig_dict, _ = load_datasets(l_index) + + with open('/disk/lhcb_data/davide/Rphipi/NN_for_selection/'+l_flv[l_index]+l_flv[l_index]+'/'+'data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + data_dict=pickle.load(f) + with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_'+mother_ID[0]+'_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + MC_Ds_mass_for_fit=pickle.load(f) + with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_'+mother_ID[1]+'_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + MC_Dplus_mass_for_fit=pickle.load(f) + + + """ + Normalising the chi2s in data and MC + + """ + MC_Dplus_sig_dict, MC_Ds_sig_dict, data_dict = norm_chi2(MC_Dplus_sig_dict, MC_Ds_sig_dict, data_dict) + + + """ + + Applying mass cuts on data, + retrieving mass distributions for sig MC and data + + + """ + + + data_mass, mc_mass, data_dict, lower_cut, upper_cut =mass_cut_for_fit(mother_index_fit=mother_index_fit, l_index=l_index, + branches_needed=branches_needed, + data_dict=data_dict, MC_Dplus_sig_dict=MC_Dplus_sig_dict, MC_Ds_sig_dict=MC_Ds_sig_dict) + + """ + + Load the MC DCB shape parameters, + if not present fit them + + """ + + if os.path.exists(FIT_PATH+'/MC_'+mother_ID[0]+'_CB_params.pickle'): + with open(FIT_PATH+'/MC_'+mother_ID[0]+'_CB_params.pickle','rb') as f: + + Ds_CB_params = pickle.load(f) + + alpha_Ds_l=Ds_CB_params['alpha_Ds_l'] + power_Ds_l=Ds_CB_params['n_Ds_l'] + alpha_Ds_r=Ds_CB_params['alpha_Ds_r'] + power_Ds_r=Ds_CB_params['n_Ds_r'] + frac_Ds=Ds_CB_params['CB fraction'] + + else: + + MC_Ds_fit_results, alpha_Ds_l, power_Ds_l, alpha_Ds_r, power_Ds_r, frac_Ds = MC_fit( MC_Ds_mass_for_fit, mother_index=0, l_index=l_index) + + if os.path.exists(FIT_PATH+'/MC_'+mother_ID[1]+'_CB_params.pickle'): + with open(FIT_PATH+'/MC_'+mother_ID[1]+'_CB_params.pickle','rb') as f: + + Dplus_CB_params = pickle.load(f) + + alpha_Dplus_l=Dplus_CB_params['alpha_Dplus_l'] + power_Dplus_l=Dplus_CB_params['n_Dplus_l'] + alpha_Dplus_r=Dplus_CB_params['alpha_Dplus_r'] + power_Dplus_r=Dplus_CB_params['n_Dplus_r'] + frac_Dplus=Dplus_CB_params['CB fraction'] + + else: + + MC_Dplus_fit_results, alpha_Dplus_l, power_Dplus_l, alpha_Dplus_r, power_Dplus_r, frac_Dplus = MC_fit(MC_Dplus_mass_for_fit, mother_index=1, l_index=l_index) + + """ + + Preprocess data for XGBoost classifier + + + """ + + data_2, mc_2, data_mean, mc_mean, data_std, mc_std = preprocess_for_XGBoost(MC_Dplus_sig_dict, MC_Ds_sig_dict, data_dict, branches_needed, mother_index_fit=mother_index_fit) + + + Nsig_from_MC=mc_mass.shape[0] + + + """ + + BDT selection + + + """ + + print("BDT cut at {0} fit".format(x_cut)) + + print("BDT selection..") + + k = np.random.randint(10) + MODEL_PATH=BDT_PATH+'/XG_'+str(k) + + loaded_model = pickle.load(open(MODEL_PATH+"/XG_"+str(k)+"_.pickle.dat", "rb")) + + output_XG=loaded_model.predict_proba(data_2) + output_XG_signal=loaded_model.predict_proba(mc_2) + + data_selected=np.array(data_mass[np.where(output_XG[:,1]>x_cut)]) + XG_mc_selected=np.array(mc_mass[np.where(output_XG_signal[:,1]>x_cut)]) + + sig_sel_eff=np.float(XG_mc_selected.shape[0])/np.float(Nsig_from_MC) + + print("Signal selection efficiency: {0}".format(sig_sel_eff)) + + """ + + Select mass window for fit + + + """ + + + cut_indices=[] + for i in range(len(data_selected)): + if lower_cut" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Parameters trained\n", - "Model saved in path: mu_MagDown_test_4/CNN_model.ckpt\n" - ] - } - ], - "source": [ - "if __name__=='__main__':\n", - "\n", - " if task == 'TRAIN':\n", - " if not os.path.exists(PATH):\n", - " os.mkdir(PATH)\n", - " \n", - " elif os.path.exists(PATH):\n", - " if os.path.exists(PATH+'/checkpoint'):\n", - " ans = input('A previous checkpoint already exists, choose the action to perform \\n \\n 1) Overwrite the current model saved at '+PATH+'/checkpoint \\n 2) Start training a new model \\n 3) Restore and continue training the previous model \\n ')\n", - " \n", - " if ans == '1':\n", - " print('Overwriting existing model in '+PATH)\n", - " for file in os.listdir(PATH):\n", - " file_path = os.path.join(PATH, file)\n", - " try:\n", - " if os.path.isfile(file_path):\n", - " os.unlink(file_path)\n", - " #elif os.path.isdir(file_path): shutil.rmtree(file_path)\n", - " except Exception as e:\n", - " print(e)\n", - " \n", - " elif ans == '2':\n", - " PATH = input('Specify the name of the model, a new directory will be created.\\n')\n", - " os.mkdir(PATH) \n", - " bkg()\n", - "\n", - " elif task == 'TEST': \n", - " if not os.path.exists(PATH+'/checkpoint'):\n", - " print('No checkpoint to test')\n", - " else:\n", - " output = bkg()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "if task=='TEST':\n", - "\n", - " Ds_mass_MC =[MC_sig_dict[\"Ds_ConsD_M\"][i][0] for i in range(m)]\n", - " NN_selected = X_test_0[np.argmax(output, axis=1).astype(np.bool)]\n", - " Ds_mass_sel_NN = [NN_selected[i][dim] for i in range(NN_selected.shape[0])]\n", - " Ds_mass_train_NN =[X_train_0[i][dim] for i in range(X_train_0.shape[0])]\n", - "\n", - " plt.subplot(1,2,1)\n", - " plt.hist(Ds_mass_MC,bins=70);\n", - " plt.subplot(1,2,2)\n", - " plt.hist(Ds_mass_sel_NN,alpha=0.8,bins=70);\n", - " #plt.hist(Ds_mass_train_NN,alpha=0.2,bins=70);\n", - "\n", - " fig=plt.gcf();\n", - " fig.set_size_inches(20,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "if task=='TRAIN':\n", - " hyper_dict={\n", - " 'm':m,\n", - " 'test_size':test_size,\n", - " 'val_size':val_size,\n", - " 'LEARNING_RATE':LEARNING_RATE,\n", - " 'BETA1':BETA1,\n", - " 'BATCH_SIZE':BATCH_SIZE,\n", - " 'EPOCHS':EPOCHS,\n", - " 'VAL_PERIOD':VAL_PERIOD,\n", - " 'SEED':SEED,\n", - " 'sizes':sizes,\n", - " 'LAMBD':LAMBD,\n", - " 'PATH':PATH,\n", - " }\n", - " with open(PATH+'/hyper_parameters.pkl', 'wb') as f: \n", - " pickle.dump(hyper_dict, f)" - ] - }, - { - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/DNN_selection.ipynb b/DNN_selection.ipynb deleted file mode 100644 index f8d9343..0000000 --- a/DNN_selection.ipynb +++ /dev/null @@ -1,340 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import tensorflow as tf\n", - "import matplotlib.pyplot as plt\n", - "import os\n", - "import pickle\n", - "import math\n", - "\n", - "trunc_normal= tf.truncated_normal_initializer(stddev=1)\n", - "normal = tf.random_normal_initializer(stddev=1)\n", - "\n", - "from architectures.data_processing import *\n", - "from architectures.utils.toolbox import *\n", - "from architectures.DNN import *" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "l_index=1\n", - "mag_index=1" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "with open('/disk/lhcb_data/davide/Rphipi/NN_for_selection/'+l_flv[l_index]+l_flv[l_index]+'/'+'data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'_Mag'+mag_status[mag_index]+'.pickle', 'rb') as f:\n", - " data_dict=pickle.load(f, encoding='latin1')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "data_dict[\"Ds_ENDVERTEX_CHI2\"]=data_dict[\"Ds_ENDVERTEX_CHI2\"]/data_dict[\"Ds_ENDVERTEX_NDOF\"]\n", - "data_dict[\"Ds_OWNPV_CHI2\"]=data_dict[\"Ds_OWNPV_CHI2\"]/data_dict[\"Ds_OWNPV_NDOF\"]\n", - "data_dict[\"Ds_IPCHI2_OWNPV\"]=data_dict[\"Ds_IPCHI2_OWNPV\"]/data_dict[\"Ds_ENDVERTEX_NDOF\"]\n", - "\n", - "del data_dict[\"Ds_ENDVERTEX_NDOF\"]\n", - "del data_dict[\"Ds_OWNPV_NDOF\"]\n", - "\n", - "data_dict[\"phi_ENDVERTEX_CHI2\"]=data_dict[\"phi_ENDVERTEX_CHI2\"]/data_dict[\"phi_ENDVERTEX_NDOF\"]\n", - "data_dict[\"phi_OWNPV_CHI2\"]=data_dict[\"phi_OWNPV_CHI2\"]/data_dict[\"phi_OWNPV_NDOF\"]\n", - "data_dict[\"phi_IPCHI2_OWNPV\"]=data_dict[\"phi_IPCHI2_OWNPV\"]/data_dict[\"phi_ENDVERTEX_NDOF\"]\n", - "\n", - "del data_dict[\"phi_ENDVERTEX_NDOF\"]\n", - "del data_dict[\"phi_OWNPV_NDOF\"]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "branches_needed = [\n", - " \"Ds_ENDVERTEX_CHI2\",\n", - " #\"Ds_ENDVERTEX_NDOF\",\n", - " \"Ds_OWNPV_CHI2\",\n", - " #\"Ds_OWNPV_NDOF\",\n", - " \"Ds_IPCHI2_OWNPV\",\n", - " \"Ds_IP_OWNPV\",\n", - " \"Ds_DIRA_OWNPV\",\n", - " #l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index],\n", - " #\"Ds_Hlt1TrackMVADecision_TOS\",\n", - " #\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\",\n", - " #\"Ds_Hlt2Phys_TOS\",\n", - " \"phi_ENDVERTEX_CHI2\",\n", - " #\"phi_ENDVERTEX_NDOF\",\n", - " \"phi_OWNPV_CHI2\",\n", - " #\"phi_OWNPV_NDOF\",\n", - " \"phi_IPCHI2_OWNPV\",\n", - " \"phi_IP_OWNPV\",\n", - " \"phi_DIRA_OWNPV\",\n", - " #\"Ds_ConsD_M\",\n", - " ] " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "#Number of input features\n", - "m=data_dict[\"Ds_ConsD_M\"].shape[0]\n", - "dim=len(branches_needed)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "data = extract_array(data_dict, branches_needed, dim, m)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(106404, 10)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "task='TEST'\n", - "\n", - "PATH=l_flv[l_index]+'_Mag'+mag_status[mag_index]+'_test_4'" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "if task == 'TEST' and os.path.exists(PATH+'/hyper_parameters.pkl'):\n", - " with open(PATH+'/hyper_parameters.pkl', 'rb') as f: \n", - " hyper_dict = pickle.load(f)\n", - " #for key, item in hyper_dict.items():\n", - " # print(key+':'+str(item))\n", - " \n", - " #m=hyper_dict[\"m\"]\n", - " test_size=hyper_dict[\"test_size\"]\n", - " val_size=hyper_dict[\"val_size\"]\n", - " LEARNING_RATE=hyper_dict[\"LEARNING_RATE\"]\n", - " BETA1=hyper_dict[\"BETA1\"]\n", - " BATCH_SIZE=hyper_dict[\"BATCH_SIZE\"]\n", - " EPOCHS=hyper_dict[\"EPOCHS\"]\n", - " VAL_PERIOD=hyper_dict[\"VAL_PERIOD\"]\n", - " SEED=hyper_dict[\"SEED\"]\n", - " sizes=hyper_dict[\"sizes\"]\n", - " LAMBD=hyper_dict[\"LAMBD\"]\n", - " PATH=hyper_dict[\"PATH\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def bkg(data):\n", - " \n", - " batch_size_output=5000\n", - " n_batches_output = m//batch_size_output\n", - "\n", - " tf.reset_default_graph()\n", - " nn = DNN(dim, sizes,\n", - " lr=LEARNING_RATE, beta1=BETA1, lambd=LAMBD,\n", - " batch_size=BATCH_SIZE, epochs=EPOCHS,\n", - " save_sample=VAL_PERIOD, path=PATH, seed=SEED)\n", - " \n", - " vars_to_train= tf.trainable_variables()\n", - " vars_all = tf.global_variables()\n", - " vars_to_init = list(set(vars_all)-set(vars_to_train))\n", - " init_op = tf.variables_initializer(vars_to_init)\n", - " \n", - " # Add ops to save and restore all the variables.\n", - " saver = tf.train.Saver()\n", - " gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)\n", - " \n", - " with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n", - " \n", - " sess.run(init_op)\n", - " print('\\n Selecting signal events with model...')\n", - " saver.restore(sess,PATH+'/CNN_model.ckpt')\n", - " print('Model restored.')\n", - " \n", - " nn.set_session(sess)\n", - " output_dict={}\n", - " \n", - " for i in range(n_batches_output):\n", - " small_dataset = data[i:i+batch_size_output]\n", - " output_dict[i] = nn.predict(small_dataset)\n", - " output=np.concatenate([output_dict[i] for i in range(len(output_dict))])\n", - " return output\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'sizes' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'No checkpoint'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0moutput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbkg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m\u001b[0m in \u001b[0;36mbkg\u001b[0;34m(data)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_default_graph\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m nn = DNN(dim, sizes,\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mlr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mLEARNING_RATE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbeta1\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mBETA1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlambd\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mLAMBD\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mBATCH_SIZE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mEPOCHS\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'sizes' is not defined" - ] - } - ], - "source": [ - "if __name__=='__main__':\n", - " if not os.path.exists(PATH+'/checkpoint'):\n", - " print('No checkpoint')\n", - " else:\n", - " output=bkg(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "output" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.argmax(output, axis=1).astype(np.bool).sum()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "a = data_dict[\"Ds_ConsD_M\"][0:output.shape[0]][np.argmax(output, axis=1).astype(np.bool)]\n", - "b = [data_dict[\"Ds_ConsD_M\"][0:output.shape[0]][i] for i in range(output.shape[0])]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "NN_selected=np.array([a[i][0] for i in range(len(a))])\n", - "full = np.array([b[i][0] for i in range(len(b))])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "full=np.delete(full,np.where(full<0))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plt.hist(full,alpha=0.4,bins=100, range=(0,3000));\n", - "plt.hist(NN_selected,alpha=0.4,bins=100, range=(0,3000));\n", - "fig=plt.gcf();\n", - "fig.set_size_inches(16,10)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "np.random.randint(14)" - ] - }, - { - "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.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/XGBoost_train.ipynb b/XGBoost_train.ipynb new file mode 100644 index 0000000..62d97b6 --- /dev/null +++ b/XGBoost_train.ipynb @@ -0,0 +1,578 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import pickle\n", + "import math\n", + "\n", + "from sklearn.metrics import accuracy_score, roc_auc_score\n", + "\n", + "from xgboost import XGBClassifier\n", + "from tools.data_processing import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# IMPORTING THE DATASET" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "metadata": {}, + "outputs": [], + "source": [ + "l_index=0\n", + "mother_ID=[\"Ds\",\"Dplus\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bkg data amounts to 11440 while signal MC amounts to 1250 Ds and 1150 Dplus samples\n" + ] + } + ], + "source": [ + "MC_Dplus_sig_dict, MC_Ds_sig_dict, data_bkg_dict = load_datasets(l_index)\n", + "\n", + "m_plus=MC_Dplus_sig_dict[\"Dplus_ConsD_M\"].shape[0]\n", + "m_s=MC_Ds_sig_dict[\"Ds_ConsD_M\"].shape[0]\n", + "n=data_bkg_dict[\"Ds_ConsD_M\"].shape[0]\n", + "\n", + "print('Bkg data amounts to {0} while signal MC amounts to {1} Ds and {2} Dplus samples'.format(n,m_s,m_plus))" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "#Normalising the Chi2 vertex fits to the NDoF\n", + "\n", + "MC_Ds_sig_dict[\"Ds_ENDVERTEX_CHI2\"]=MC_Ds_sig_dict[\"Ds_ENDVERTEX_CHI2\"]/MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "MC_Ds_sig_dict[\"Ds_IPCHI2_OWNPV\"]=MC_Ds_sig_dict[\"Ds_IPCHI2_OWNPV\"]/MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "MC_Ds_sig_dict[\"Ds_FDCHI2_OWNPV\"]=MC_Ds_sig_dict[\"Ds_FDCHI2_OWNPV\"]/MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "MC_Ds_sig_dict[\"Ds_OWNPV_CHI2\"]=MC_Ds_sig_dict[\"Ds_OWNPV_CHI2\"]/MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "\n", + "del MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "del MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "#del MC_sig_dict[\"Ds_M\"]\n", + "\n", + "MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_CHI2\"]=MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_CHI2\"]/MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "MC_Dplus_sig_dict[\"Dplus_IPCHI2_OWNPV\"]=MC_Dplus_sig_dict[\"Dplus_IPCHI2_OWNPV\"]/MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "\n", + "MC_Dplus_sig_dict[\"Dplus_FDCHI2_OWNPV\"]=MC_Dplus_sig_dict[\"Dplus_FDCHI2_OWNPV\"]/MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "MC_Dplus_sig_dict[\"Dplus_OWNPV_CHI2\"]=MC_Dplus_sig_dict[\"Dplus_OWNPV_CHI2\"]/MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "\n", + "del MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "del MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]=data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]=data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"Ds_OWNPV_CHI2\"]=data_bkg_dict[\"Ds_OWNPV_CHI2\"]/data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "data_bkg_dict[\"Ds_FDCHI2_OWNPV\"]=data_bkg_dict[\"Ds_FDCHI2_OWNPV\"]/data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "\n", + "del data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "del data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]=data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "#data_bkg_dict[\"phi_OWNPV_CHI2\"]=data_bkg_dict[\"phi_OWNPV_CHI2\"]/data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", + "data_bkg_dict[\"phi_IPCHI2_OWNPV\"]=data_bkg_dict[\"phi_IPCHI2_OWNPV\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "\n", + "#del data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", + "del data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "del MC_Ds_sig_dict[\"phi_M\"]\n", + "del MC_Dplus_sig_dict[\"phi_M\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [], + "source": [ + "#Number of input features\n", + "\n", + "dim=len(['cos_thetal']+return_branches_BDT(mother_index=1, l_index=l_index, meson_index=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtYAAAHoCAYAAABtiKiGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xm8VVX9//HXBxkEmUQmRRQFp4w0vQ6EXwMRNcoxzGtpmhVOYZkKTglpafojZ1NxIvsaVxxKNDSxL+i30hTUr1o4aygqk6IkoAzr98c5XO/Fe+EA+55z7uX1fDzOg7PXXvvszzls5X3XXWftSCkhSZIkaf00K3UBkiRJUlNgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMtC81AWsq86dO6devXqVugxJkiQ1cdOnT5+XUuqypn6NNlj36tWLadOmlboMSZIkNXER8e9C+jkVRJIkScqAwVqSJEnKgMFakiRJyoDBWpIkScqAwVqSJEnKQKNdFUSSJDVNH330EXPmzGHp0qWlLkVNXIsWLejatSvt27fP5PUM1pIkqWx89NFHzJ49mx49etC6dWsiotQlqYlKKbF48WJmzZoFkEm4diqIJEkqG3PmzKFHjx60adPGUK0GFRG0adOGHj16MGfOnExe02AtSZLKxtKlS2ndunWpy9AGpHXr1plNOzJYS5KksuJItYopy+vNYC1JkiRlwGAtSZIkZcBgLUmSlKHRo0cTEUQEzZo1Y9NNN2WPPfbgvPPO47333svkHPfffz/9+/enY8eOtG/fnp133pmTTjqJ//znP9V9IoJrr702k/Oti6lTpxIRvPDCC/X2efPNN6s/q7/97W+f23/RRRcREfTq1etz+1577TW+//3v07NnT1q2bEmXLl0YOnQoTzzxRJZvY6243J4kSSp7V0x+uSTnPX3w9ut0XIcOHXjooYcA+PDDD3n66ae5/vrrGTt2LA899BC77777Otc0fvx4vv3tb3PiiSdy/vnnExE899xz/Pa3v2XBggW0bdsWgMcff5xtttlmnc9TTG3btmX8+PH079+/Vvudd95Z/X5q+tvf/saQIUPYbrvtuPDCC+nduzdz587l3nvvpX///rz//vt06NChWOVXM1hLkiRlrHnz5uy9997V2wceeCAnn3wy++67L0cddRQvvfQSG2200Tq99rXXXsuQIUO44YYbqtsOOuggRowYQUqpuq3m+cvdwQcfzN13381VV11V/bk8//zzzJgxg29961s8/vjj1X0XL17MUUcdxR577MGkSZNo2bJl9b5vfvOb/OAHP6BFixZFfw/gVBBJkqSi6NixI5dddhmvvfYakydPrm6/5JJL6NOnDxtvvDHdunXjoIMOWu2UkQULFtC9e/c699Vc4WLVqSApJX72s59V32nwhBNOoKqqiojgzTffBD6bmjFhwgROPPFEOnTowJZbbsmoUaNYsWJF9Wu9+OKLVFZW0rNnT9q0acPOO+/MlVdeWavP2jj00ENZuHAhU6ZMqW6rqqpin332oUePHrX63nXXXcyaNYsrrriiVqheaeDAgbRp02ad6lhfBmtJkqQiGThwIM2bN6+eB3z77bdz8cUX89Of/pQ///nPXH/99fTp04ePP/643tfYbbfdGD9+PNdeey3vvPNOwee+8sorufjiiznppJO4++67ad26NSNGjKiz74gRI2jbti133303xxxzDBdeeCF333139f5Zs2axww478Jvf/IZJkybxwx/+kFGjRnHppZcWXE9Nm2yyCd/4xjcYP358dVtVVRVHH3305/o++uijbLHFFvTt23edztWQnAoiSZJUJK1ataJz587Mnj0bgCeffJIDDjiAU045pbrPEUccsdrXuPjii3n++ecZPnw4w4cPZ5tttuGwww5jxIgR9Y5kL1++nMsuu4yTTjqJCy+8EIADDjiAN954g7feeutz/ffdd19+/etfAzB48GAeeugh7r33Xr71rW8BMGjQIAYNGgTkRsL32WcfFi1axE033cQ555yzlp9KTmVlJd///ve5/vrrefbZZ5k5cyZDhw7lV7/6Va1+s2bNYquttlqnczQ0R6wlSZKKqOY86F133ZVJkyYxatQonnzySZYvX77G43v27Mn06dN55JFHOOOMM+jUqRNXXHEFX/rSl3j77bfrPOatt97ivffe45BDDqnVvur2SgcccECt7S984Qu1XnvJkiWMGjWKPn360KpVK1q0aMF5553HG2+8wbJly9b4HuoyZMgQli9fzp///GeqqqoYNGgQnTt3rrNvud5EyGAtSarliskvVz8kZWvJkiXMnz+fbt26AXDCCSdw8cUXM2HCBPbaay+6devGz372szUG7I022ohBgwYxZswYpk2bxp///Gfef//96lHmVa2cs92lS5da7atur9SxY8da2y1btmTJkiXV2yNHjmTMmDEMGzaMSZMm8dRTT3H++edXv8d10apVKw477DB+//vfM2HCBCorK+vs16NHD2bOnLlO52hoBmtJkqQimTJlCsuWLaNfv34ANGvWjNNPP50ZM2Ywc+ZMzjzzTC6++GJuuummtXrdAw44gF122YUXX3yxzv0rp4jMnTu3Vvuq24W66667GD58OCNGjGD//fenoqKC5s3Xf4ZxZWUlEyZMYN68eRx++OF19hkwYACzZs3in//853qfL2sGa0mSpCJYsGABI0eOpE+fPuy///6f29+zZ0/OPvts+vTpw7/+9a96X2fOnDmfa1uyZAlvv/129Uh4Xa/dvXt37rvvvlrtEydOXMt3kbN48WJatWpVvb18+XKqqqrW6bVqGjx4MN/85jcZMWJEvetQDx06lB49enD66aezdOnSz+2fOnUqixYtWu9a1oVfXpQkScrYsmXLqlf+WLhwIdOnT+f6669n0aJFPPTQQ9VrNZ944ol06tSJvffemw4dOjBlyhReeeWV1a6uceCBB7Ljjjty8MEH07NnT9577z2uvfZaPvjgA0488cQ6j9loo40466yzOOuss+jSpQv9+/dn4sSJPP/880Bu5HxtDB48mOuuu44+ffrQqVMnrrvuOj755JO1eo26NG/enAkTJqy2T+vWrbnzzjv52te+Rv/+/Tn11FPZdtttmTdvHn/84x+54447mD9//nrXsi4M1pIkqeyt6x0QS+XDDz+kX79+RATt27enT58+HHPMMQwfPrzWyh39+vXjpptu4sYbb2TJkiX06dOHm266icMOO6ze1x4xYgRVVVWMHDmSOXPm0KVLF3bbbTf++te/sueee9Z73Omnn84HH3zAb37zGy6//HIOOeQQzj33XE455RTat2+/Vu/vmmuu4aSTTuLUU0+ldevWHHfccRx++OEMGzZsrV5nXfXv35+nn36aiy++mPPOO4/Zs2fTsWNH9tlnHyZPnlySuy4CRM1vpjYmFRUVadq0aaUuQ5KanJpfWmxsYUaN34wZM9hpp51KXcYG4wc/+AGTJ0/m3//+d6lLKak1XXcRMT2lVLGm13HEWpIkaQPwwgsvcOedd/KVr3yFZs2a8eCDD3Lbbbet801d9HkGa0mSpA3AJptswl//+leuvfZaPv74Y7beemsuvfRSzjjjjFKX1mQYrCVJkjYA22yzDVOmTCl1GU2ay+1JkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRlwVRBJWtWUSz57PvCc0tUhSWpUijpiHREbR8STEfF/EfHPiPh5vn1cRLwREc/mH7sWsy5JkiRpfRV7xPoTYL+U0n8iogXw14h4ML/vrJTS3UWuR5IkNQY1f5NUTOvwW6vRo0fz85//HICIoEOHDvTp04cDDjiA4cOH071796yrZOnSpVxzzTXceuutvP7667Rp04bevXtz+OGHc/bZZwMwdepUBg4cyPPPP88Xv/jFzGsoxOjRo7n22muZN29evX3GjRvH9773Pdq1a8fs2bNp3bp1rf2DBg3if/7nfzjuuOMYN25crX1Tp05lzJgxPPHEE3z00UdsscUWHHLIIZx55plstdVWDfGWainqiHXK+U9+s0X+kYpZgyRJUkPr0KEDjz/+OH//+9+pqqriiCOO4He/+x19+/Zl+vTpmZ/vRz/6ERdccAHf+c53eOCBBxg7dixf/epXuf/++6v77Lbbbjz++OP07t078/M3hJQSf/rTn2q1zZ49m0cffZS2bdt+rv/VV1/NfvvtR+vWrbnxxht55JFHGDVqFM888wyHHnpoUWou+hzriNgImA70Aa5LKf0jIk4GfhkRFwB/Ac5OKX1Sx7HDgGFAUX7qkCRJWhfNmzdn7733rt4+8MADOfnkk9l333056qijeOmll9hoo43qPHbAgAEMGDCA0aNHF3SuRYsWcdttt/HLX/6Ss846q7r9iCOOIKXPxi/bt29fq6Zyd/DBB1NVVcXQoUOr2yZMmEDv3r1p165drb7PPPMMP/3pTzn//PO58MILq9v33Xdfvve97/HAAw8UpeairwqSUlqeUtoV2BLYMyK+CJwD7AjsAXQCRtZz7NiUUkVKqaJLly5Fq1mSJGl9dezYkcsuu4zXXnuNyZMnZ/a6H3/8MUuXLq1ziklEVD+fOnUqEcELL7xQ3fbBBx9QWVnJJptswhZbbMGll17KmWeeSa9evar7jBs3jojg+eefZ/DgwWyyySbsuOOO3HvvvbXO9ac//YnBgwfTtWvX6hD/8MMPr/P7qqys5E9/+hMLFy6sbquqqqKysvJzfa+55ho6d+7Mz372szpf6xvf+MY617E2SrbcXkppATAVOCil9G5+msgnwG3AnqWqS5IkqaEMHDiQ5s2b88QTT2T2ml26dKFnz56MHj2ae++9t1YQXZPjjz+eyZMnc9VVVzF27Fgefvhh7rzzzjr7fvvb3+aQQw7hD3/4A9tttx2VlZW8/fbb1fvfeOMNDj74YH73u99xzz338JWvfIWvfe1r/O1vf1un9zVgwAA23XRT/vjHPwIwc+ZMHn/88TqD9aOPPsqgQYNo0aLFOp0rK0WdChIRXYClKaUFEdEa2B+4NCI2Tym9G7kfqw4DXljtC0mSJDVCrVq1onPnzsyePbu6bfny5bWmbKSUWLFiBcuWLatua9asGc2a1T8eOm7cOCorK/nmN79Js2bN+PKXv0xlZSWnnXYaLVu2rPOYF154gYkTJzJhwgSOPPJIIPfFwJ49e9Y5h/n000/nhBNOAGD33XenW7duPPDAA5x00klAbp73SitWrGDgwIH885//5JZbbqF///6FfDy1NGvWjCOPPJKqqiqOPfZYqqqq+NKXvsROO+30ub6zZs0qi2nCxR6x3hyYEhHPAU8Bk1NKDwB3RMTzwPNAZ+AXRa5LkiSpKGqGaIDevXvTokWL6sdjjz3GRRddVKut5rzhuuy333689tprjB8/nhNOOIH58+dz1llnsd9++7FixYo6j5k2bRqQm8u8UuvWrdl///3r7H/AAQdUP99ss83o2rVrrRHrt99+m+OOO44ePXrQvHlzWrRowcMPP8zLL7+8+g9kNSorK5k8eTLvv/9+vdNAVqo57aVUijpinVJ6DvhyHe37FbMOSZKkUliyZAnz58+nW7du1W33338/n3zy2ZoNJ554IrvvvjvDhg2rbttiiy3W+Nrt2rWjsrKSyspKUkqMGjWKiy66iPvvv7/OVTHee+892rVrx8Ybb1yrvb7vsXXs2LHWdsuWLVmyZAmQG6E+5JBDWLhwIRdeeCF9+vRhk0024YILLmDOnDlrrL0+/fr1Y4sttuDiiy/mmWee4Z577qmzX48ePZg5c+Y6nycr3nlRkiSpSKZMmcKyZcvo169fdVvfvn1r9WnXrh1bbLEFFRUV63yeiOCss87ioosu4sUXX6wzWHfv3p2FCxeyZMmSWuF67ty5a32+V199lWeeeYYHH3yQgw46qLp98eLF6/YGajjqqKMYM2YMe+21F9tss02dfQYMGMCkSZNYtmwZzZuXLt6W7MuLkiRJG5IFCxYwcuRI+vTpU+90i3WxdOlSFixY8Ln2V155BaDW6HhNK4P7xIkTq9sWL168TiuWrAzQrVq1qm7797//vc5fXKzpuOOO4+CDD+anP/1pvX2GDx/O3Llz+eUvf1nn/kmTJq13HYVwxFqSJCljy5Ytq175Y+HChUyfPp3rr7+eRYsW8dBDD9W7hvW6+PDDD9l+++057rjjGDhwIB06dOCll17ikksuoUePHhx++OF1HvfFL36Rgw8+mJNPPpmFCxfSvXt3Lr/8ctq0abPaL0rWZccdd2TLLbfkjDPO4KKLLmLhwoWMGjWKHj16rPf7+8IXvlC9Mkh9dt11Vy6//HJ+8pOf8K9//YvKyko6d+7MG2+8wa233sqHH37IkCFD1ruWNTFYS5Kk8rcOtxYvpQ8//JB+/foREbRv354+ffpwzDHHNMgtzdu3b8+IESOYNGkSv//97/noo4/o0aMHBx54IOeffz4dOnSo99hx48Zx8sknc9ppp9G2bVtOPfVUtt12W5566qm1qqFVq1bce++9nHrqqQwdOpQtt9yS8847j6lTp9ZaN7shnXbaafTt25cxY8bwgx/8oNbnUPPGOQ0pVv1mamNRUVGRVn6bVZIyNeWSz543sn/Ms3DF5M++wX/64O1LWIk2RDNmzKhzOTUVx7Jly/jiF7/IXnvtxW9/+9tSl1M0a7ruImJ6SmmNk94dsZYkSdpA3XXXXbzzzjv07duXjz76iJtuuolXXnmF22+/vdSlNUoGa0mSpA3UJptswm233carr77K8uXL6du3L/fffz977ulNsNeFwVqSJGkDNWTIkKJ8qW9D4XJ7kiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBgzWkgS5uy2ufEjSehg9ejQRUf1o06YNffv2ZezYsbX6TZ06lYgo2i2/AYYOHcqAAQPW6piXX36Z0aNHs2DBgoYpqglxHWtJklT2fvPsb0py3lN2PWWdjuvQoQMPPfQQAB9//DH3338/J554Im3btuXb3/52liU2uJdffpmf//znHH/88XTs2LHU5ZQ1g7UkSVLGmjdvzt577129PWjQIP7+97/zxz/+sdEFaxXOqSCSJElF0K5dO5YuXbraPlVVVbRs2ZIbbrihuu2uu+5iu+22o3Xr1gwcOJBnnnmGiGDcuHGrfa233nqLIUOG0Lp1a3r16sXNN9/8uT4vvvgilZWV9OzZkzZt2rDzzjtz5ZVXsmLFCiA3XeXggw8GYJtttiEi6NWrFwDvvvsuJ5xwAttuuy2tW7dm++235/zzz+fTTz9di0+laXHEWpIkqQEsW7YMgEWLFjFx4kQeffRRbr311nr7jxs3jmHDhjF27FiOP/54AKZNm0ZlZSVDhw7lmmuuYcaMGRx11FFrPHdKiUMPPZR58+Zxyy23sPHGGzNq1Cjef/99tttuu+p+s2bNYocdduA73/kO7dq149lnn2XUqFEsXryYc845h912240xY8Zw5plncu+997L55pvTqlUrAObNm0enTp24/PLL2XTTTavnYs+dO5cbb7xxPT65xstgLUmSlLH58+fTokWLWm2nnXYa3/3ud+vsf8MNN/DjH/+Y22+/ncrKyur2Sy+9lJ122omqqioigoMOOoilS5cycuTI1Z7/wQcf5JlnnuGJJ55gr732AmD33Xend+/etYL1oEGDGDRoEJAL4/vssw+LFi3ipptu4pxzzqF9+/bssMMOAHz5y1+uHq0G6Nu3L2PGjKne7t+/P5tssgknnHAC11xzDS1btizgk2paDNaSJEkZ69ChA4888ggAn3zyCdOnT+eCCy6gU6dOjBo1qlbfq6++mttvv52qqioOP/zwWvueeuopjj76aCKiuu2QQw5ZY7B+8skn6datW3WoBth6663Zfffda/VbsmQJl1xyCXfccQczZ86sNVVl2bJlNG9ef1RMKXHVVVcxduxY3njjDZYsWVK9b+bMmfTp02e1NTZFBmtJkqSMNW/enIqKiurt/v37s3TpUs4991yGDx9Op06dqvfdc8899OnTh/333/9zr/Pee+/RpUuXWm2rbtflvffeo2vXrp9r79q1KwsXLqzeHjlyJDfffDOjRo1it912o2PHjtx333384he/YMmSJbRt27bec1x55ZWceeaZnH322Xz1q19l00035amnnuLUU0+tFbI3JH55UZIkqQi+8IUv8Omnn/Laa6/Var/jjjv4+OOPOfjgg1m8eHGtfd27d2fu3Lm12lbdrkv37t2ZM2fO59pXbbvrrrsYPnw4I0aMYP/996eiomK1o9SrHnvkkUfyy1/+kgMOOIA99tiDTTbZpKBjmyqDtSRJUhGsvBFMz549a7VvueWW/OUvf+GVV15h6NChtaZj7LHHHtx///2klKrbJk6cuMZz7bHHHsyePZt//OMf1W0zZ87k6aefrtVv8eLF1V9GBFi+fDlVVVW1+qycK73qKPSqx0Luh4QNmVNBJEmSMrZs2TKeeOIJAD799FOmT5/OL37xCw499FC6d+/+uf7bbrstjzzyCPvuuy/HHHMM48ePp1mzZowcOZK99tqLyspKvve97zFjxgxuuukmAJo1q398dMiQIeyyyy4ceeSRXHrppWy88cZccMEFn5seMnjwYK677jr69OlDp06duO666/jkk09q9Vn55cUbb7yRysrK6jtJDh48mKuvvpq99tqL3r17c8cdd/Dqq6+u1+fW2BmsJUlS2VvXOyCWyocffki/fv0AaNGiBVtvvTUnnXQS559/fr3H7LTTTjz88MMMHDiQH/7wh9x8881UVFQwfvx4zj33XO677z4qKiq4/vrrGTx4MO3bt6/3tSKCiRMnMmzYME444QS6du3Kueeey+TJk5k3b151v2uuuYaTTjqJU089ldatW3Pcccdx+OGHM2zYsOo+W2+9NWPGjOHqq6/mmmuuYcstt+TNN9/kggsuYO7cudXv6YgjjuDqq6+uXvd6QxQ1f7XQmFRUVKRp06aVugxJTcWUS+puH3hOcesoA1dMfrn6+emDty9hJdoQzZgxg5122qnUZZS1//7v/+bYY4/l9ddfZ5tttil1OU3Cmq67iJieUqqot0OeI9aSJEll7OSTT2bw4MFsuummPP300/ziF7/g61//uqG6DBmsJUmSytj8+fM55ZRTmD9/PpttthlHHXUUl112WanLUh0M1pIkSWVswoQJpS5BBXK5PUmSJCkDBmtJklRWGuvCCmqcsrzeDNaSJKlstGjR4nN3H5Qa0uLFi2nRokUmr2WwliRJZaNr167MmjWLRYsWOXKtBpVSYtGiRcyaNetzN85ZV355UZIklY2VNz155513at3aW2oILVq0oFu3bqu92c7aMFhLkqSy0r59+8yCjlRMTgWRJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJQ1GAdERtHxJMR8X8R8c+I+Hm+fZuI+EdEvBIRd0ZEy2LWJUmSJK2vYo9YfwLsl1LaBdgVOCgi9gYuBa5IKW0HfAB8v8h1SZIkSeulqME65fwnv9ki/0jAfsDd+fbfAocVsy5JkiRpfRV9jnVEbBQRzwJzgMnAa8CClNKyfJe3gR7FrkuSJElaH0UP1iml5SmlXYEtgT2BnerqVtexETEsIqZFxLS5c+c2ZJmSJEnSWinZqiAppQXAVGBvoGNENM/v2hJ4p55jxqaUKlJKFV26dClOoZIkSVIBir0qSJeI6Jh/3hrYH5gBTAGG5rsdB9xXzLokSZKk9dV8zV0ytTnw24jYiFyon5BSeiAi/gVURcQvgGeAW4pclyRJkrReihqsU0rPAV+uo/11cvOtJUmSpEbJOy9KkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRloXuoCJEnl64rJL1c/P33w9iWsRJLKnyPWkiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBooarCOiZ0RMiYgZEfHPiPhxvn10RMyKiGfzjyHFrEuSJElaX8W+pfky4IyU0tMR0Q6YHhGT8/uuSCmNKXI9kiRJUiaKGqxTSu8C7+afL4yIGUCPYtYgSZIkNYSSzbGOiF7Al4F/5Jt+FBHPRcStEbFpPccMi4hpETFt7ty5RapUkiRJWrOSBOuIaAvcA/wkpfQRcD3QG9iV3Ij2r+s6LqU0NqVUkVKq6NKlS9HqlSRJktak6ME6IlqQC9V3pJTuBUgpzU4pLU8prQBuAvYsdl2SJEnS+ijqHOuICOAWYEZK6fIa7Zvn518DHA68UMy6JG2gplxS6gokSU1IsVcF6Q8cCzwfEc/m284Fjo6IXYEEvAmcWOS6JEmSpPVS7FVB/gpEHbsmFbMOSZIkKWveeVGSJEnKQLGngkiSytAVk18udQmS1Og5Yi1JkiRlwGAtSZIkZcBgLUmSJGXAYC1JkiRlwGAtSZIkZcBgLUmSJGXAYC1JkiRlwGAtSZIkZcBgLUmSJGXAYC1JkiRlwGAtSZIkZcBgLUmSJGXAYC1JkiRlwGAtSZIkZcBgLUmSJGXAYC1JkiRlwGAtSZIkZaB5qQuQJDUOV0x+ufr56YO3L2ElklSeHLGWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjLgqiCStDpTLvns+cDHOP0VAAAfsElEQVRzSleHJKnsOWItSZIkZWCdg3VEbBoRu0ZEqywLkiRJkhqjgoJ1RPw8In5VY3s/YCYwHXgtInZuoPokSZKkRqHQEevvAC/W2P418FegP/AScEldB0mSJEkbikKD9RbA6wAR0RPYBRiVUnoCuBzYu2HKkyRJkhqHQoP1QqBD/vl+wAcppSfz20uANlkXJkmSJDUmhS639yhwdkSsAM4E7quxb3vgrawLkyRJkhqTQkesTwc+AaqABcB5NfZ9F3gs47okSZKkRqWgEeuU0ixyU0DqciCwOLOKJEmSpEao0OX2/icidqxnd3fgz9mVJEmSJDU+hU4FGQC0r2dfe2DfTKqRJEmSGqm1ufNiWrUhIlqSmyLyXmYVSZIkSY1QvXOsI2IUcEF+MwFPRER93f9fxnVJkiRJjcrqvrw4CZgHBHA1ubstvrlKn0+BF1NK/9sg1UmSJEmNRL3BOqX0FPAUQEQsBP6UUppXrMIkSZKkxqTQ5fZ+29CFSJIkSY1ZQcE6IloAPwaOALYENl61T0qpa7alSZIkSY1Hobc0vwI4EXgAmEJubrUkSZKkvEKD9ZHA2SmlXzdkMZKk4rli8sulLkGSmpRC17EO4LmGLESSJElqzAoN1jcBRzdkIZIkSVJjVuhUkNnAdyJiCjAZWLDK/pRSun5NLxIRPYHbge7ACmBsSumqiOgE3An0IrdW9rdSSh8UWJskSZJUcoUG6yvzf24FfLWO/QlYY7AGlgFnpJSejoh2wPSImAwcD/wlpfSriDgbOBsYWWBtkiRJUskVNBUkpdRsDY+NCnydd1NKT+efLwRmAD2AQ4GVa2X/Fjhs7d+KJEmSVDqFzrHOXET0Ar4M/APollJ6F3LhG3BNbEmSJDUqBQfriOgaEZdGxF8i4uWI2Dnf/uOI6Lc2J42ItsA9wE9SSh+txXHDImJaREybO3fu2pxSkiRJalCF3nlxT3JfWpwLPAoMAFrld28OnAEMLfC1WpAL1XeklO7NN8+OiM1TSu9GxObAnLqOTSmNBcYCVFRUpELOJ0m1TLmk1BVIkpqoQkesryB3x8Xtyd2BMWrsexLYs5AXiYgAbgFmpJQur7FrInBc/vlxwH0F1iVJkiSVhUJXBdkNODSltCIfjmuaT+FzovsDxwLPR8Sz+bZzgV8BEyLi+8BMcnd6lCRJkhqNQoP1h0CXevZtS26d6zVKKf2V2qPdNQ0qsBZJkiSp7BQ6FeQ+4OcRsW2NthQRnYEzgXvrPkySJEnaMBQarM8GPgL+BTyWb7sBeAlYDFyQfWmSJElS41HQVJCU0gcRsTe5+dGDgI+B94GbgdtTSp80XImSJElS+St0jjUppU/JrehxS8OVI0mSJDVOBU0FiYhHI+LkiKjvC4ySJEnSBq3QOdZzgTHAOxExOSJOiIhNG7AuSZIkqVEpKFinlIaSW6v6u8B/gOuA9yLigYg4NiLaNWCNkiRJUtkrdMSalNLHKaXxKaXDyYXsH+Z33QS81xDFSZIkSY1FwcG6ppTSQuA14A1yy/C1zrIoSZIkqbFZq2AdEXtGxK8jYia59ay/ClwFbNcQxUmSJEmNRUHL7UXEr4BvAVsDrwC3AVUppRkNWJskSZLUaBS6jvW3gAnkwvSzDViPJEmS1CgVeufFbRu6EEmSJKkxK3iOdUS0yt8k5paIeDgitsu3HxUROzVciZIkSVL5K3SO9fbAZKADMB0YAKxcu/q/gK+TW+NakiRJ2iAVOmJ9NTAT6AUcCESNfY8C+2RbliRJktS4FPrlxf8CjkwpLYiIjVbZNxvYPNuyJEmSpMal0BHrJdR/E5gewIJsypEkSZIap0KD9WTg3IjoUKMtRUQrYDgwKfPKJEmSpEak0KkgZwF/A14lF7ITcAGwM9ASOKJBqpMkSZIaiYJGrFNKbwG7ADeQ+wLja+TmVd8F7J5Seq+hCpQkSZIag0JHrEkpfQD8LP+QJEmSVEPBN4iRJEmSVD+DtSRJkpQBg7UkSZKUAYO1JEmSlAGDtSRJkpSBgoN1RHw3Ijo2ZDGSJElSY7U2I9a3AVsBRM4FEdG9YcqSJEmSGpd617GOiD8B/5d/PAcEuTsuQi6QjwIeALw5jCRJkjZ4q7tBzGTgy8A3gB3JheprI2IK8BS1g7YkSZK0Qas3WKeUrlz5PCJaAYuBp4EdgGPJherfRcRDwCMppYcauFZJkiSpbNU7xzoihkfEPhHRLqX0Sb75tpTS0eTCdQDjgbbAtQ1fqiRJklS+VjcV5BDgfKBzRLxJboS6MiJaA8/n+zyYUnq6YUuUJEmSyl+9I9YppcEppW7AlsCPyI1Q7w88CLxPLmifHBGD8lNFJEmSpA3WGpfbSym9m1J6ML/5g5RSJ6CCXNDuCYwDPmiwCiVJkqRGYF3vvDgj/+e5KaWewO4Z1SNJkiQ1SqubY11LSqlmCE/Av4FP8vtm1HmQJEmStIEoOFjXlFJaAWyTcS2SJElSo7WuU0EkSZIk1WCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyUNRgHRG3RsSciHihRtvoiJgVEc/mH0OKWZMkSZKUhWKPWI8DDqqj/YqU0q75x6Qi1yRJkiStt6IG65TSY8D7xTynJEmSVAzlMsf6RxHxXH6qyKb1dYqIYRExLSKmzZ07t5j1SZIkSatVDsH6eqA3sCvwLvDr+jqmlMamlCpSShVdunQpVn2SJEnSGpU8WKeUZqeUlqeUVgA3AXuWuiZJkiRpbZU8WEfE5jU2DwdeqK+vJEmSVK6aF/NkETEeGAB0joi3gVHAgIjYFUjAm8CJxaxJkiRJykJRg3VK6eg6mm8pZg2SJElSQyj5VBBJkiSpKTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRloXuoCJKnBTbkk+9cZeE42rylJajIcsZYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIyYLCWJEmSMmCwliRJkjJgsJYkSZIy4DrWkqS1dsXkl6ufnz54+xJWIknlwxFrSZIkKQMGa0mSJCkDBmtJkiQpAwZrSZIkKQMGa0mSJCkDBmtJkiQpAwZrSZIkKQMGa0mSJCkDBmtJkiQpA955UZI2IDXvmChJypYj1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBgzWkiRJUgYM1pIkSVIGDNaSJElSBooarCPi1oiYExEv1GjrFBGTI+KV/J+bFrMmSZIkKQvFHrEeBxy0StvZwF9SStsBf8lvS5IkSY1KUYN1Sukx4P1Vmg8Ffpt//lvgsGLWJEmSJGWhHOZYd0spvQuQ/7NrieuRJEmS1lo5BOuCRcSwiJgWEdPmzp1b6nIkSZKkauUQrGdHxOYA+T/n1NcxpTQ2pVSRUqro0qVL0QqUJEmS1qQcgvVE4Lj88+OA+0pYiyRJkrROir3c3njgcWCHiHg7Ir4P/AoYHBGvAIPz25IkSVKj0ryYJ0spHV3PrkHFrEOSJEnKWjlMBZEkSZIaPYO1JEmSlAGDtSRJkpQBg7UkSZKUAYO1JEmSlAGDtSRJkpQBg7UkSZKUAYO1JEmSlAGDtSRJkpQBg7UkSZKUAYO1JEmSlAGDtSRJkpQBg7UkSZKUAYO1JEmSlIHmpS5AkjIz5ZLPng88p+mcS5LUKDhiLUmSJGXAYC1JkiRlwKkgkqT1csXkl6ufnz54+xJWIkml5Yi1JEmSlAGDtSRJkpQBp4JIappqrtohSVIROGItSZIkZcBgLUmSJGXAYC1JkiRlwGAtSZIkZcBgLUmSJGXAYC1JkiRlwOX2JKmJq3lnRElSw3HEWpIkScqAwVqSJEnKgMFakiRJyoDBWpIkScqAwVqSJEnKgKuCSJIajd88+5vq56fsekoJK5Gkz3PEWpIkScqAI9aSGoyji5KkDYnBWlJRGLIlSU2dwVqSmiDvtihJxecca0mSJCkDBmtJkiQpA04FkbROnDOtUqt5DYLXoaTSM1hLkpoEf9iTVGpOBZEkSZIy4Ii1JDURrgQiSaVlsJa03vwVvCRJBmtJatQcpZak8mGwlpSpVVdqkCRpQ2GwlrRaTvNQY+R1K6kUyiZYR8SbwEJgObAspVRR2oqkDZejzpIkrb2yCdZ5A1NK80pdhKS6lWXgnnJJqSuoXcPAc0pXhySppMotWEuS1GCcIiKpIZVTsE7AwxGRgBtTSmNX7RARw4BhAFtttVWRy5MkNUaF/KbFwC0pC+UUrPunlN6JiK7A5Ih4MaX0WM0O+bA9FqCioiKVokipqSrLaR5SA/Kal5S1srmleUrpnfyfc4A/AHuWtiJJkiSpcGURrCNik4hot/I5cADwQmmrkiRJkgpXLlNBugF/iAjI1fT7lNJDpS1JkiRJKlxZBOuU0uvALqWuQ5IkSVpXZRGsJUkqF/V9qdHVQiStSVnMsZYkSZIaO0espQ2Aa/RKktTwDNbSBsx1fCVJyo7BWmqi6gvNhmlJkhqGc6wlSZKkDDhiLUlSRvw+g7RhM1hLUpm7YvLLtbZPH7x9iSpZs1VrXamcay6U06gkrYlTQSRJkqQMOGItqfGZckmpK6hfzdoGnlO6OiRJRWewliSpATjfWtrwOBVEkiRJyoAj1pIklYij2lLTYrCWGjn/YZbKn/+dShsGg7XUCHlXRUmSyo/BWmokDM1S0+B/y1LT5ZcXJUmSpAwYrCVJkqQMOBVEklTWnDohqbEwWEuSGtwVk1+ufn764O1LWEn5cuUQqfFzKogkSZKUAUesJUkqY45kS42HwVoqM/4j2kRNueSz5wPPKV0dkqQGY7CWpEam5nxlSVL5MFhLZczVEKQNk//tS42TX16UJEmSMuCItVQGHJ2SJKnxM1hLJWCQXgc1v/zXWDTGmiVJ68xgLUlSI+QKQlL5MVhLktRI1PfbLkO2VB4M1pIkNSGrhu+aQdsALjUsg7XUgJxLrbWxoaxPXfN9nj54+xJWsmHw/0NS8RisJUnawDmSLWXDYC1JapQef21+re1+vTcrUSWSlOMNYiRJkqQMOGItZcBfo0rrz7nXxeUKI1L2DNaSVGw1bxwz8JzS1SGtI8O3VDeDtZQxv4GvtbGhrARSnw39/UtqWgzWksqHtwBfL3vPHFv9/ImthpWwEjUVjkxLa8dgLUkZevz1z1aq6LftZmtslxoLfxsnrZnBWlJpbeCj1OsyyuzItCSVJ4O1JBVZzdFr1a3m3OtWXT5rX3XtapUXp45oQ2ewlqQyV3OEWio3LtsnfcZgLUmSSsLwrabGYC2tBb+8o4bkyLSaqkL+32nIVlNgsJbWwDCtdeVc6tKpORe7X29XYZFUHAZrKc8AvR7e+N/Pnm/zX2vuv4GvBCJp9er7/3HNkez6Rrgd+VYpGawlSWWt0JVAXDGk6Svki5L1ta8uZBfSz8CuQpRNsI6Ig4CrgI2Am1NKvypxSWqiHJmWJK1tSJcKURbBOiI2Aq4DBgNvA09FxMSU0r9KW5maCv9HWQZqThfp+KXS1dHE+IVHqTBZ/juwttNQ1na0u5CpMCpPZRGsgT2BV1NKrwNERBVwKGCwboRK+esyA7QkqZjWZ3pKVueqaV2C+9oeY8CvX6SUSl0DETEUOCil9IP89rHAXimlH63Sbxiw8v69OwAvFbVQ1aUzMK/URagseW1odbw+VB+vDdWnlNfG1imlLmvqVC4j1lFH2+cSf0ppLODvPctIRExLKVWUug6VH68NrY7Xh+rjtaH6NIZro1mpC8h7G+hZY3tL4J0S1SJJkiSttXIJ1k8B20XENhHREqgEJpa4JkmSJKlgZTEVJKW0LCJ+BPyZ3HJ7t6aU/lnislQYp+aoPl4bWh2vD9XHa0P1Kftroyy+vChJkiQ1duUyFUSSJElq1AzWkiRJUgYM1lqjiLg1IuZExAur6TMgIp6NiH9GxKPFrE+ls6ZrIyI6RMT9EfF/+Wvje8WuUaURET0jYkpEzMj/3f+4jj4REVdHxKsR8VxE7FaKWlV8BV4f38lfF89FxN8jYpdS1KriKuTaqNF3j4hYnr8fSllwjrXWKCL2Bf4D3J5S+mId+zsCfyd3k5+ZEdE1pTSn2HWq+Aq4Ns4FOqSURkZEF3I3deqeUvq0yKWqyCJic2DzlNLTEdEOmA4cllL6V40+Q4DhwBBgL+CqlNJeJSlYRVXg9fEVYEZK6YOI+Bow2uuj6Svk2sj32wiYDCwht+jF3cWv9vMcsdYapZQeA95fTZdvA/emlGbm+xuqNxAFXBsJaBcRAbTN911WjNpUWimld1NKT+efLwRmAD1W6XYouR/KUkrpCaBj/h9VNXGFXB8ppb+nlD7Ibz5B7h4XauIK/H8H5H4ovwcoq8xhsFYWtgc2jYipETE9Ir5b6oJUNq4FdiJ3w6fngR+nlFaUtiQVW0T0Ar4M/GOVXT2At2psv03d/4CqCVvN9VHT94EHi1GPykd910ZE9AAOB24oflWrVxbrWKvRaw7sDgwCWgOPR8QTKaWXS1uWysCBwLPAfkBvYHJE/G9K6aPSlqViiYi25EaVflLH33vUcYjzEzcga7g+VvYZSC5Y71PM2lRaa7g2rgRGppSW534hWj4M1srC28C8lNLHwMcR8RiwC2Cw1veAX6XclzlejYg3gB2BJ0tbloohIlqQ+4fxjpTSvXV0eRvoWWN7S3K/3dAGoIDrg4j4EnAz8LWU0vxi1qfSKeDaqACq8qG6MzAkIpallP5YxDLr5FQQZeE+4L8ionlEtCH3JaQZJa5J5WEmud9kEBHdgB2A10takYoiP6/+FnJfPru8nm4Tge/mVwfZG/gwpfRu0YpUyRRyfUTEVsC9wLH+BnTDUci1kVLaJqXUK6XUC7gbOKUcQjU4Yq0CRMR4YADQOSLeBkYBLQBSSjeklGZExEPAc8AK4OaUUr1L86npWNO1AVwEjIuI58n92n9kSmleicpVcfUHjgWej4hn823nAltB9fUxidyKIK8Ci8j9hkMbhkKujwuAzYDf5Ecml6WUKkpQq4qrkGujbLncniRJkpQBp4JIkiRJGTBYS5IkSRkwWEuSJEkZMFhLkiRJGTBYS5IkSRkwWEvKRESMjoiUf6yIiA8i4qmI+GVEdC91fcUUESMiYkCRz9ky/3ewa4av+aOIaJJLR0XENyPi1YjYaJX2XSLi9xExKyI+jYj3I+KRiDgqIgpeojYiro2I+fkbXdS1/8yIWB4Rm0dERb5vh/V9X5JKy2AtKUsfAv2ArwCV5G/uQG490t1LWViRjSC3vncxtSS3jnhmwbqpiohmwM+B/5dSWl6jfSjwFLA5cA6wP3ACuZsa3Q4ctxanGQ90Ag6oZ38lMDWl9G5KaRrwLHD6Wr4VSWXGYC0pS8tSSk/kH39OKV0CfAl4F7hz1dHBNYmIjRukyjIREa1LXcMGahDQG/j9yoaI6AGMA+4A9ksp3Z5Seiyl9MeU0jBy1/Fra3GOvwP/Jhega4mIPsDu5ML3SrcBJ63NqLik8mOwltSgUkoLyI3g9gYG19cvIo7PTyPZMyKmRsRi4Kz8vo0j4rKIeCsiPomI/4uIIXW8xg8j4vmIWBIRsyPi7pq/Xo+Ib+X3f5J/rV/WDDI1augbEZMj4uOIeDEijljlPPtExP9GxEf5x7MRcWR+35vk7hY3qsbUmAH5fSkifhoRV0bEXOD5lcdExJh6Po+2Ndo2i4gbI+Ld/Ht8KSJ+kt+9MP/nbTXO26vQzy8iWuWnLyzIT3+4gvxdNFcnP/1kXkTsFRHTImJxRPw1IraJiK4R8ceI+E9EzIiI/VY59rv5vu/npw5NiYiKVfrsHBEP5ft8nH+dUwv5u1iN44CHU0oLa7T9gNzdiM9Iddw5LaX0Ukpp6iq1HZp/z0si4r38Z7zyzqMJuBM4tI4fECuBpcA9NdomkhvhPnANtUsqYwZrScUwBVgG7F1A3/HAA+Rudf1Avu1u4HjgYuBgcr+unxg15hNHxPnAjcCjwGHAyeSmprTN7z+AXNB5GjgUuAY4E7i2jhp+Ty7oHA68AlRFxJb512mfr+t14JvAUOB3QMf8sYfnz3sLuWkx/fLnXOksclMNjgVOK+DzWPn+WgNT8+/tovzn82tgi3yXlaH1FzXO+26+bY2fH/ArcuHyIuA7wNbAGQWW1wYYC1wBHE3u1sO/I/d3+VfgCGAWcFdEtKlxXC9yUyyOBL4NvA08FhHb1ugzEVgOHAMcQu7vrV3+M1nT30V99iM3olzTvsC0lNL7hbzhiPgWualOT+br+jkwDLikRrfx+Vq/vsrhlcBDKaUPVjaklD4C/klu+omkxiql5MOHDx/r/QBGA/NWs/9d4PrV7D8eSMCPV2kflG//6irtjwF35Z93BBYBl6/m9Z8ApqzSNoJcaNtylRpOqNFnM3I/FJyU367I92m3mnPNA0bX0Z6AZ+pofxMYU8/n0Ta/fSKwAti1nnO2zfc/fh0+v82AxcDIGvubAS+SH3xdw997rdcHTsm3XVCj7Qv5tq/V8zrNyI0Yv7jyOKBz/pi+9Ryzxr+LOo7ZIn/M11dpnwGMr6N/8xqPZvm2IDfN47ZV+p6Q/xw3q9H2r5Wfc3575/z5j67jXOOAvxX6Xnz48FF+D0esJRVLFNjvT6ts7w+8B/wtIpqvfAB/IResIDc625rcPNXPnzg3t3s34K5Vdt1JLtD1W6X94ZVPUkrzgTnAlvmm14D/AL/PTwVY0+joqlZ9f4Xaj1wof3Ytjyvk8+sLbAzct/KglNKKmttr8CnwvzW2X83/+T91tPVY2RARO0XEHyJiNrkfcJb+//bOL8SLKorjnwOaQmn5B01IWaOMwiQxH4oEAxNDyChRH3oooiyKHizIetJMwoogopAMhSKsRSgMSzOlfDFICU1KSxRKaytdpbLc3fD0cO6487v+dh2X37aufj9wGebeO3funNnfcubM954BrgMmpC6twE/ASousHKOy8/bkXhQZao5k9UY4vJ0VIUvpKJXm1DSBiMo3ZzbdSthxYmmY94DZJUnPAuIhcH2duR0pzU8I0Q+RYy2E6HWSxnQE8GuF7nmfkYSz0ZGVJcDY1GdE2v5CfUYSeuF87GJ/eFZ/PNtvJxwmPF7fz0zjNQO/m9mGTL7QHVVsUI8RdH193VHFfoUz91t2bL7fFX8mR7ygPW1P29Hdi7rBAGY2hHiAGQssAqYBU4FddNr6FGHrFmA10JL01JNTe0/uRaF3bsvqD9P58FTwbZrTVGrlPCPT9mNqbXow1Y8t9V1LPPTdlfbnA+vd/USdubWV5ieE6Ido9bEQ4v/gduL/zfYKffOFY62E03N3N8ccTdsxnBmJJNV1AHnEc3TpHJVx9+3ArKR7ngG8Quiyq2jI6+WFPkmkyyuTO/tHgWvOZZ6JKvZrSdtR1Noit1cjuYVwZO9w971FpWW5nFPbvWlR4DRgBbDBzK5y91M9uBfF9eXR7W3AYjMblhx23P1vYEeaV3mhYzHGw8DXdc5RONi4+w9mthNYYGb7gGsJbX89ruAc/xaFEOcXilgLIXqV9Hp+BSEF+KwHQ2whIqp/ufuOvKQ+2wlta908wx65incSi+TKzCN0y1Uc/nrj/uPuHxHR1BtKTacj3BU5BFyf1eUZVLYAk81sUhdj1ESEs+POZr9vCOd+TnGQRa7nOfQeRarB05FjM7uVWNB4Bu7e4e5bCcd5DJlj3M29yDlI2Gp8Vv8WIUd5qcLc9xEPK031bJrkQ2XWEtk+HiGi+Bu7GLcJ+L7C+YUQ5ymKWAshGskAMysihUOIXL2PElkjZnnpYxznwGZgE7DZzFYQmROGEh9CGezuz7j7cTNbBiw3s0uIV/SDiGwMS939MPHxlE1mtobQvd5IZMBY5e6Hqk7GzGYTi9Q+BH4kNMMLqdUT7yV0tRsJDfA+r03tlvMB8JqZPUtk7LiHWORW5m3gMeBTM1tCOHfjgQnuvtjd283sIDDPzPYQjvLuivY7amZvAkvN7N/U5yFSRpVe4kvCNqvM7EUier2EcFgBSA8RLxNa+APAMOBpYJe7t1a8FzW4e1uKIE+hpMl398Nm9gDwbpKSrCEWlV5GaNEnkXTR7n7KzJ4E3kmZST4hnPWriTcDc1O0u+B9wmF/EFhdksXk3Ew8hAoh+it9vXpSRUXlwih0ZodwIgp8nHiNvhy4ssLx91PKgpG1DSLSme0nHJgWIuqXZ3ZYSOhi21KfZmBoqX0+EZ1tJ6LEy4EBZ5sDpawdxOK6dcSiurY0zkpgeKn/FMJxPJHGm57qHXi8zvUNJCKxLcAx4FVCZlAzF0JnvYrQPp8kHPgnSu0zCWf6ZDq2qar9Up83iFSBx4i0douolhXkSFY3PZ1/YlZfc/3ALGAP8bZhN5FC8HNgXWofRaTPO5CuqYWI/o6rei+6mPNTwP4u2m5K5/iZkA+1Eo76QmBg1vdOYtHmCeAP4uuJz5f/pkp9v0jXP6OL804mfjdNff1bVlFR6Xkx93pyPyGEEOLCxMxGExHu29z9q76eD4CZvQBMdXflsRaiHyPHWgghxEWHmb0OXO7u950Hc7mUyIs917OvOwoh+hdavCiEEOJiZBnwXcpx3teMA56TUy1E/0cRayGEEEIIIRqAItZCCCGEEEI0ADnWQgghhBBCNAA51kIIIYQQQjQAOdZCCCGEEEI0ADnWQgghhBBCNID/AFjaJwXLXwEHAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Convert data dictionaries to arrays for NN\n", + "features=features=['cos_thetal']+return_branches_BDT(mother_index=0, l_index=l_index, meson_index=0)\n", + "MC_Ds_sig = extract_array(MC_Ds_sig_dict, features, dim, m_s)\n", + "\n", + "features=features=['cos_thetal']+return_branches_BDT(mother_index=1, l_index=l_index, meson_index=0)\n", + "MC_Dplus_sig = extract_array(MC_Dplus_sig_dict, features, dim, m_plus)\n", + "\n", + "features=features=['cos_thetal']+return_branches_BDT(mother_index=0, l_index=l_index, meson_index=0)\n", + "data_bkg = extract_array(data_bkg_dict, features, dim, n)\n", + "\n", + "plt.hist(MC_Ds_sig[:,dim-1]/1000,alpha=0.5, label='Ds Signal MC',range=(1.5,2.4),density=True, bins=200);\n", + "plt.hist(MC_Dplus_sig[:,dim-1]/1000,alpha=0.5, label='D+ Signal MC', range=(1.5,2.4),density=True, bins=200);\n", + "plt.hist(data_bkg[:,dim-1]/1000,alpha=0.5, label='Bkg data',range=(1.5,2.4),density=True, bins=200);\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('D reconstructed mass (GeV)', fontsize=15)\n", + "plt.legend(fontsize=15)\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(12,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/mu/bdt_train.png', format='png', dpi=100)\n", + "#Cut on Ds Mass\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "metadata": {}, + "outputs": [], + "source": [ + "#Cuts on mass\n", + "\n", + "#data_bkg_cut=data_bkg[np.where(data_bkg[:,dim-1]<1930)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "#Add 0/1 label for bkg/sig\n", + "\n", + "MC_Dplus_sig_labelled=add_labels(MC_Dplus_sig,signal=True)\n", + "MC_Ds_sig_labelled=add_labels(MC_Ds_sig,signal=True)\n", + "data_bkg_labelled=add_labels(data_bkg,signal=False)\n", + "\n", + "#Merge MC sig and data bkg, shuffle it\n", + "\n", + "data=np.concatenate((data_bkg_labelled,MC_Dplus_sig_labelled), axis =0)\n", + "data=np.concatenate((data,MC_Ds_sig_labelled), axis =0)\n", + "np.random.seed(1)\n", + "np.random.shuffle(data)\n", + "\n", + "#get train size\n", + "train_size=data.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [], + "source": [ + "#Strip away the label column and convert it to a one-hot encoding\n", + "\n", + "X=data[:,0:dim]\n", + "Y_labels=data[:,dim].astype(int)\n", + "Y_labels=Y_labels.reshape(train_size,1)\n", + "Y_labels_hot = to_one_hot(Y_labels)\n", + "Y_labels=Y_labels_hot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 253, + "metadata": {}, + "outputs": [], + "source": [ + "#Divide the dataset k \"equi populated\" sets\n", + "test=1\n", + "k=10 #number of subsets\n", + "i=0#number of subset that is train set\n", + "\n", + "X_train, Y_train, X_test, Y_test, X_dict, Y_dict = k_subsets(i, k, X, Y_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 254, + "metadata": {}, + "outputs": [], + "source": [ + "X_mean=X_train.mean(axis=0)\n", + "X_train_1=X_train-X_mean\n", + "X_std=X_train_1.std(axis=0)\n", + "X_train_2=X_train_1/X_std\n", + "\n", + "\n", + "\n", + "X_mean=X_test.mean(axis=0)\n", + "X_test_1=X_test-X_mean\n", + "X_std=X_test_1.std(axis=0)\n", + "X_test_2=X_test_1/X_std\n" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(12456, 14)" + ] + }, + "execution_count": 255, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_2.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SETTING UP THE XGBOOST" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "metadata": {}, + "outputs": [], + "source": [ + "PATH=l_flv[l_index]+'/BDTs/test_'+str(test)\n", + "\n", + "if not os.path.exists(PATH):\n", + " os.mkdir(PATH)\n", + "\n", + "if not os.path.exists(PATH+'/variables_used.pickle'):\n", + " with open(PATH+'/variables_used.pickle', 'wb') as handle: \n", + " pickle.dump(return_branches_BDT(mother_index=0, l_index=l_index, meson_index=0), handle, protocol=2)\n", + "\n", + "PATH=l_flv[l_index]+'/BDTs/test_'+str(test)+'/XG_'+str(i)\n", + "\n", + "if not os.path.exists(PATH):\n", + " os.mkdir(PATH)" + ] + }, + { + "cell_type": "code", + "execution_count": 257, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=3, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n", + " reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n", + " silent=True, subsample=1)" + ] + }, + "execution_count": 257, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model = XGBClassifier()\n", + "model.fit(X_train_2, Y_train[:,1])" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "metadata": {}, + "outputs": [], + "source": [ + "output_XG = model.predict_proba(X_test_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.suptitle('S/B selection from XGBoost', fontsize='15')\n", + "Ds_mass_MC =[MC_Ds_sig_dict[\"Ds_ConsD_M\"][j][0]/1000 for j in range(m_s)]\n", + "Dplus_mass_MC =[MC_Dplus_sig_dict[\"Dplus_ConsD_M\"][j][0]/1000 for j in range(m_plus)]\n", + "XG_selected = X_dict[i][np.argmax(output_XG,1).astype(np.bool)]\n", + "Ds_mass_sel_XG = XG_selected[:,dim-1]/1000\n", + "Ds_mass_train_XG =X_dict[i][:,dim-1:dim]/1000\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.hist(Ds_mass_MC+Dplus_mass_MC,bins=70, label='MC signal events');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "plt.subplot(1,2,2)\n", + "\n", + "plt.hist(Ds_mass_sel_XG,alpha=0.6,bins=70, label='S selected from test set');\n", + "plt.hist(Ds_mass_train_XG,alpha=0.2,bins=70, label='Test set (S+B)');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf();\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+PATH+'/D_s_XG.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 260, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "true_positives_XG=output_XG[:,1][np.where(Y_test[:,1]==1)]\n", + "false_positives_XG=output_XG[:,1][np.where(Y_test[:,0]==1)]\n", + "plt.hist(true_positives_XG,alpha=0.5,bins=80,density=True,label=\"True positives\");\n", + "plt.hist(false_positives_XG,alpha=0.5,bins=80,density=True, label=\"False positives\");\n", + "plt.legend()\n", + "plt.xlabel(\"XGBoost BDT output\", fontsize='15')\n", + "plt.ylabel(\"Events (a.u.)\", fontsize='15')\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+PATH+'/tp_vs_fp_XG.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6027397260273972" + ] + }, + "execution_count": 261, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.float(np.where(true_positives_XG>0.5)[0].shape[0])/np.float(true_positives_XG.shape[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pAUC from XG Boost 0.930797420973\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfoAAAHoCAYAAAChCy3ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XmcjWXjx/HPZSxjFyNrlorKlpiipBg7IVpIDyrFrygPCT2V1kc7IkuytVmKLE3WrKVUKsmSnYzILsvMmOX6/XEPz8TMOMM55z7L9/16zeusznwpvnPd93Vfl7HWIiIiIqEph9sBRERExHdU9CIiIiFMRS8iIhLCVPQiIiIhTEUvIiISwlT0IiIiIUxFLyIiEsJU9CIiIiFMRS8iIhLCcrodwBuioqJshQoV3I4hIiLiFz/99NNBa21xT94bEkVfoUIFVq9e7XYMERERvzDG7PL0vTp0LyIiEsJU9CIiIiFMRS8iIhLCQuIcfUaSkpKIi4sjISHB7SgSwCIjIylbtiy5cuVyO4qIiE+EbNHHxcVRsGBBKlSogDHG7TgSgKy1HDp0iLi4OCpWrOh2HBERnwjZQ/cJCQkUK1ZMJS+ZMsZQrFgxHfURkZAWskUPqOTlgvT/iIiEupAuehERkXCnoveR3bt3U7FiRQ4fPgzAkSNHqFixIrt2OWscbNmyhTvuuIOrrrqK2rVr07BhQ1asWHHe5yxbtozChQtTs2ZNatSoQePGjdm/f7/Xcu7cuZPJkydn+lrevHmpWbMmVapUoUuXLiQlJZ19/ZtvvuGmm27i2muv5dprr2Xs2LH/+PUffvgh1apVo2rVqlSpUoW33norw+/j6ftERCT7VPQ+csUVV/Doo48ycOBAAAYOHEj37t0pX748CQkJtGrViu7du7Nt2zZ++uknRowYwfbt2zP8rPr167NmzRrWrl3LjTfeyMiRI72WM6uiB7jqqqtYs2YNv/32G3FxcXz66acA7Nu3j06dOjFmzBh+//13vvnmG9577z2+/PJLAObNm8ewYcNYuHAh69ev5+eff6Zw4cLnfb6n78tMcnJyNn/HIiLhJWRn3af373/DmjXe/cyaNWHYsKzf06dPH2rXrs2wYcP45ptvGDFiBACffPIJN998M23atDn73mrVqlGtWrUsP89ay/Hjx7n66qsBOHz4MA899BDbt28nX758jB07lho1amT6/PLly+nduzfgnJtesWIFAwcOZOPGjdSsWZOuXbvSp0+fDL93REQEN910E3v27AFg5MiRPPDAA9SqVQuAqKgo3njjDV544QVatWrFq6++yltvvUXp0qUB5zK2Rx555LzPzep9DRo04K233iI6OpqDBw8SHR3Nzp07mTRpEl9++SUJCQmcPHmS4sWL07VrV1q2bAnAAw88QOvWrbnzzjsZOHAgy5YtIzExkZ49e9KjR4+s/6OJiISYsCh6t+TKlYs333yT5s2bs3DhQnLnzg3A+vXrzxakJ77++mtq1qzJoUOHyJ8/P4MHDwbg+eef54YbbmDWrFksWbKELl26sGbNmkyff+uttxg5ciT16tXjxIkTREZG8tprr/HWW28RGxubZYaEhAS+//573nnnnbO/h65du/7jPdHR0axfvx6AdevWUbt27Qv+3jx937m+++471q5dS9GiRZk5cybTpk2jZcuWnD59msWLFzN69GjGjx9P4cKF+fHHH0lMTKRevXo0bdpUl9KJSFgJi6K/0Mjbl+bNm0epUqVYt24dTZo0yfA97dq1Y8uWLVSuXJnPP//8vNfr169/tohff/11+vfvz5gxY/jmm2+YMWMGADExMRw6dIhjx45l+ny9evXo27cv999/P+3bt6ds2bIXzL9t2zZq1qzJli1buPvuu6lRowbgHF3IaMa6v2axN2nShKJFiwLQokULnnjiCRITE5k/fz633XYbefPmZeHChaxdu5bp06cDcOzYMbZs2aKiF5GwonP0PrRmzRoWLVrEqlWrGDp0KHv37gWgatWq/Pzzz2ffN3PmTCZNmnR24l5W2rRpc3bSnrX2vNeNMZk+P3DgQMaNG0d8fDx169bl999/v+D3O3OOfuvWraxatYo5c+ac/T2cu2PgTz/9RJUqVc6+/tNPP13w87N6X86cOUlNTQU471r3/Pnzn70fGRlJgwYNWLBgAdOmTaNjx46A8+czYsQI1qxZw5o1a9ixYwdNmza9YCYRkVDi16I3xkwwxuw3xqzL5HVjjBlujNlqjFlrjPH8+HaAsdby6KOPMmzYMMqVK8dTTz1Fv379AOjUqRMrV648W5oAp06d8uhzv/nmG6666ioAbrvtNj755BPAmZ0fFRVFoUKFMn1+27ZtVK9enQEDBhAdHc3vv/9OwYIFOX78+AW/b6lSpXjttdd49dVXAejZsyeTJk1iTdrkh0OHDjFgwAD69+8PwNNPP03//v3Zt28fAImJiQwfPvy8z83qfRUqVDj7Q8CZUXlmOnbsyMSJE/n6669p1qwZAM2aNWP06NFnrxTYvHkzJ0+evODvVUQkpFhr/fYF3AbUAtZl8npLYB5ggLrA9558bu3ate25NmzYcN5z/vTee+/Ze++99+zj5ORkW6tWLbts2TJrrbUbN260LVq0sBUrVrR169a1TZo0sYsWLTrvc5YuXWoLFSpkr7/+elujRg1bv359u2nTJmuttYcOHbJt2rSx1atXt3Xq1LG//vprls/36tXLVq1a1daoUcN27NjRJiQk2NOnT9uYmBhbo0YNO2TIkH987x07dtiqVauefZyammpr1KhhV6xYYa21dvny5TY6Otpec801tnLlynbUqFH/+PUTJkywVatWtVWqVLFVq1a1b7/9doZ/Vpm9b+PGjbZ69er25ptvts8884wtX768tdbaiRMn2p49e/7jM06fPm2LFi1qH3jggbPPpaSk2KefftpWq1bNVq1a1TZo0MAePXr0vO/v9v8rIiLZBay2HnavsRkc5vUlY0wFINZae94Uc2PMe8Aya+2UtMebgAbW2r1ZfWZ0dLQ99zDyxo0bue6667wVW0KY/l8REV9JTYX4eEhMhLRpRV5hjPnJWhvtyXsDbTJeGWB3usdxac9lWfQiIiKeSkmBU6ecAo6P/999bzx37muJic73LFIkhSNHIlz5/QZa0Wc0ZTvDQw7GmO5Ad4By5cr5MpOIiPhYUpJnxemN59It8JktuXJB3ryQL59zm/7+ZZdB6dL/fC5fPliy5EtWr15B69ZtgVu8+mfmqUAr+jjginSPywJ/ZvRGa+1YYCw4h+4zeY82LZEs+fvUlUiwsBZOn774kWx2n0tJubicefJkXr7Fi5//3Lm32Xku50U05q5d1Vi+/BBdurhT8hB4RT8H6GWMmQrUAY5d6Px8ZiIjIzl06JC2qpVM2bT96CMjI92OIuIRayEhwbuHlrN67mJ/Dj63LNPfL1XKe+UbGQkR7hwNz9LJkycZPXo0ffv2pXz58nTp0sXVPH4temPMFKABEGWMiQOeB3IBWGvHAHNxZt5vBU4BD17s9ypbtixxcXEcOHDgUmNLCIuMjPRo4SCRzJyZbOXrw81nnrsYxmRdnMWKebd8w3lsdfz4cVq1asXKlSupV68eN998s9uR/Fv01tr7LvC6BXp643vlypVLK6CJhKnk5PPL0lfnf89MtsquiIjMi7NgQShRwnvlmzt3eJevvxw9epQWLVrw448/Mnny5IAoeQi8Q/ciEqKSkvxzuDk+/tImW2VWnJddBmXKXPz53XOfy5XLu3++4q7Dhw/TrFkzfv31Vz777DPatWvndqSzVPQiYerMZCtfXlqU/vZSJltlNqItXvzSJled+1wgnu+V4LBx40a2bt3K559/zh133OF2nH9Q0YsEmMREOHHCt+d6z9xeymSrzIqzSBHvlW9kJOTQjhwSwBITE8mTJw/16tVjx44dFClSxO1I51HRi/hBUhLs3w/79v3v66+/Mr7/99/Z//wcOTI/l5svnzPZylvlmyePzveKAPz55580btyYp556igcffDAgSx5U9CIXLSUFDh7MurTP3D90KOPPKFwYSpZ0vmrWdG4vv9yZjJWd8s2VS+Ur4k+7d+8mJiaGffv2cfXVV7sdJ0sqepF0rIUjRy486v7rL2eEnraL7j/ky/e/8r7mGrjttv89LlHin/d1Cb9I8NmxYwcxMTEcPnyYhQsXBszs+syo6CXkWQvHj1941H3mfkYztnPn/l85lysHN930z9JOX+IFCvj/9ygi/nHs2DFuv/12Tpw4weLFi4mO9mhfGVep6CVoxcefX9SZlXhGC41ERDiHyc+UdLVq54+6zzwuUkSHxkUEChcuTN++fWnQoAE1a9Z0O45HVPQSFGbNgsmT/1ngmU1ai4r6X0lfdVXGh81LlnQmqGlGt4h4Yv369Zw6dYobb7yRf//7327HyRYVvQS8iROhWzdnsZKrroJatc4/133mfvHiWohERLzr119/pXHjxlx++eWsXbuWiCBbcEFFLwFt/Hh45BFo3Bhmz3ZmmYuI+Mvq1atp2rQp+fPnZ9asWUFX8gA6cCkBa+xYePhhaNZMJS8i/rdq1SoaNWpE4cKFWbFiBZUqVXI70kVR0UtAGjUKevSAli1h5kyVvIj438iRIylevDjLly8P6k3SdOheAs6778Ljj0Pr1vDZZ85KbCIi/mKtxRjDuHHjOHr0KCVKlHA70iXRiF4CyrBhTsm3bQvTp6vkRcS/Fi5cSN26dTl48CB58uQJ+pIHFb0EkLffhj59oH17ZySfO7fbiUQknHz55Ze0bt2axMRE7MXu+BSAVPQSEN54A/r1g3vugalTdYmciPjXrFmzaNeuHdWrV2fJkiUUL17c7Uheo6IX1736KgwYAB07OoviqORFxJ9iY2O55557qF27Nl999RVFixZ1O5JXqejFVS+/DP/5D3TqBB99BDk1PVRE/KxWrVp06tSJBQsWBOxWs5dCRS+uefFFGDQIOneGDz9UyYuIfy1dupTk5GRKly7NBx98QKFChdyO5BMqevE7a52Cf+EFeOABZ4nbIFxsSkSC2NixY4mJiWHYsGFuR/E5Fb34lbXwzDPOIftu3ZwlblXyIuJPI0eOpEePHrRs2ZJevXq5HcfnVPTiN9bCwIHO5Lvu3Z0lbrV7nIj405AhQ+jVqxdt27bl888/JzIy0u1IPqd/ZsUvrIWnnnIuo3v0URg9WiUvIv61Z88eBg0axD333MNnn31GnjBZkUvTn8TnrHUWwnnnHejVC4YPB2PcTiUi4aZMmTJ89913XHfddeQMo9m/GlOJT1kLvXs7Jd+7t0peRPzLWsszzzzDu+++C0D16tXDquRBRS8+lJoKPXvCiBHQty8MHaqSFxH/sdbSr18/Bg8ezPr160NqWdvsCK8fa8RvUlOdc/Fjxzrn5l9/XSUvIv5jreWJJ57g3Xff5fHHH+edd97BhOk/QhrRi9elpjp7yY8dC08/rZIXEf+y1vLoo4/y7rvv8uSTT4Z1yYOKXrwsJcW5Pn7cOHj2Wfjvf1XyIuJfxhiuueYann76ad58882wLnnQoXvxsv79YdIkeP555yvM/36JiB8lJyezefNmqlSpQp8+fdyOEzA0ohev+fFHZ8Jdjx7O8rYqeRHxl6SkJDp16kTdunXZu3ev23ECikb04hXJyc5qdyVLOufkRUT8JTExkQ4dOjB79mzefvttSpUq5XakgKKiF6945x1YswamT4fChd1OIyLhIiEhgbvuuou5c+cyYsSIsFi7PrtU9HLJdu50dqNr3Rrat3c7jYiEk+HDhzNv3jzee+89unfv7nacgKSil0tirbMojjHw7rs6Ly8i/tWnTx9q165No0aN3I4SsDQZTy7J9Okwd66z7Wy5cm6nEZFw8Pfff/Pggw/y119/kStXLpX8Bajo5aIdOwZPPAG1asHjj7udRkTCwdGjR2natCkff/wxq1evdjtOUNChe7loTz8N+/dDbCyE2R4RIuKCw4cP07RpU9auXcv06dNp1aqV25GCgv55lovy3XcwZowzoq9d2+00IhLqDhw4QJMmTfj999+ZNWsWLVu2dDtS0FDRS7YlJTnXzJcp45ybFxHxNWstOXPm5IsvvqBJkyZuxwkqKnrJtiFDYN06mD0bChZ0O42IhLK//vqLokWLcvnll/PDDz+QI4emlmWX/sQkW7ZvhxdfhHbtoE0bt9OISCj7448/qFevHj169ABQyV8k/amJx6yFxx5zJt6NGOF2GhEJZTt27OD222/n4MGDZ4teLo4O3YtHjhyB0aNhwQIYPtw5Py8i4gtbtmwhJiaGU6dOsXjxYmprxu8lUdFLpvbvh1mzYMYMWLLE2bimYUNnVC8i4gspKSm0bduWhIQElixZwvXXX+92pKCnopd/iIuDzz93yv2bbyA1Fa6+Gp58Eu66C6KjtcytiPhOREQEEyZMoGDBglStWtXtOCFBRS9s3+4U+4wZ8P33znNVq8KzzzrlXr26yl1EfGvNmjV888039OrVi7p167odJ6So6MPcv/4Fn3zi3K9VC/77X6fcr7nG3VwiEj5Wr15N06ZNKVCgAF26dKFQoUJuRwopKvowtnixU/KPPgpPPQUVK7qdSETCzXfffUfz5s0pWrQoS5cuVcn7gIo+TFkLzzwDV1zhLIATGel2IhEJNytWrKBVq1aULFmSJUuWcMUVV7gdKSSp6MPUF1845+PHjVPJi4g7Nm3aRNmyZVm8eDGlS5d2O07IMtZatzNcsujoaKvtCj2XkgI1a8Lp07B+vXaeExH/+vvvv88eok9ISCBSo41sM8b8ZK2N9uS9WhkvDE2d6qxV//LLKnkR8a/Y2FgqVKjAqlWrAFTyfqCiDzNJSTBokDOiv/tut9OISDiZOXMm7du356qrrqJy5cpuxwkbGs+FmQkTnOvmv/wStD+EiPjLp59+SqdOnbjxxhuZP38+hQsXdjtS2NA/9WEkPh5eegnq1YMWLdxOIyLhYuXKldx3333ccsstLFy4UCXvZyr6MDJqFPz5JwwerJXuRMR/6taty+DBg5k3bx4FCxZ0O07YUdGHib//hldfhWbN4Lbb3E4jIuHgo48+Ii4ujoiICAYMGED+/PndjhSWVPRhYuhQOHTIWeJWRMTXhg8fTpcuXXj99dfdjhL2VPRh4OBBePttZw17bessIr725ptv0rt3b9q1a8fbb7/tdpywp6IPA8OGwYkTznXzIiK+9N///pf+/fvToUMHpk2bRu7cud2OFPZU9CHu1CkYPRruvBOuu87tNCISyuLj4/n000/p3LkzH3/8Mbly5XI7kqDr6EPexx/D4cPw73+7nUREQpW1luTkZPLmzcvy5cspWLAgERERbseSNBrRhzBrncP2tWpB/fpupxGRUGSt5cknn+Suu+4iKSmJIkWKqOQDjIo+hC1YABs3Qp8+um5eRLwvNTWVxx9/nKFDh1KxYkVyavOMgKT/KiFs6FAoVQruvdftJCISalJTU+nRowfjxo2jX79+vPHGGxiNKAKSRvQhav16WLgQevUCTXoVEW/r06cP48aN45lnnlHJBziN6EPUsGGQNy/06OF2EhEJRV26dKFMmTL079/f7ShyARrRh6ADB+Cjj6BLFyhWzO00IhIqkpKSmD59OgC1a9dWyQcJFX0IGjMGEhN1SZ2IeE9iYiJ3330399xzD6tXr3Y7jmSD34veGNPcGLPJGLPVGDMwg9fLGWOWGmN+McasNca09HfGYJaY6OxS16IFXHut22lEJBTEx8fTrl075syZw8iRI4mOjnY7kmSDX4veGBMBjARaAFWA+4wxVc5527PAp9baG4COwCh/Zgx206bBvn0azYuId5w6dYo2bdowf/583n//fR577DG3I0k2+XtEfxOw1Vq73Vp7GpgKtD3nPRYolHa/MPCnH/MFtTML5FStCk2auJ1GRELBsmXLWLZsGRMnTuThhx92O45cBH/Pui8D7E73OA6oc857XgAWGmMeB/IDjTP6IGNMd6A7QLly5bweNBht3gy//AIjRmiBHBG5NNZajDG0bNmSTZs2ceWVV7odSS6Sv0f0GdWPPefxfcAka21ZoCXwkTHmvJzW2rHW2mhrbXTx4sV9EDX4zJ3r3LZu7W4OEQluR44coUGDBixatAhAJR/k/D2ijwOuSPe4LOcfmu8GNAew1n5njIkEooD9fkkYxObOdQ7bly/vdhIRCVaHDh2iSZMmrFu3jvj4eLfjiBf4e0T/I1DJGFPRGJMbZ7LdnHPe8wfQCMAYcx0QCRzwa8ogdOIELF8OLXWNgohcpP3799OwYUM2bNjA7NmzadOmjduRxAv8OqK31iYbY3oBC4AIYIK1dr0x5iVgtbV2DvAk8L4xpg/OYf0HrLXnHt6Xc3z1FSQlqehF5OKcOVy/c+dOYmNjadw4w+lREoT8vgSutXYuMPec5walu78BqOfvXMFu7lwoWBDq6U9ORC5C4cKFady4MXfddRe3336723HEi7TWfQiw1in6pk0hVy6304hIMNm1axfWWipUqMDw4cPdjiM+oKIPAb/9Bnv26LC9iGTP9u3badiwIcWKFeOnn37SDnQhSkUfAs5cVteihbs5RCR4bN68mZiYGOLj45k5c6ZKPoSp6EPA3LlQqxaUKuV2EhEJBhs2bKBRo0akpKSwdOlSatSo4XYk8SHtXhfkjhyBb7/VYXsR8Vz//v2x1rJs2TKVfBjQiD7ILVoEKSkqehHx3EcffcTBgwepVKmS21HEDzSiD3Jz50LRonDTTW4nEZFA9sMPP9ChQwcSEhK47LLLVPJhRCP6IJaaCvPmQfPmEBHhdhoRCVTffvstzZs3JyoqikOHDlGmTBm3I4kfaUQfxH74Afbv12F7Ecnc8uXLadq0KSVLlmTFihUq+TCkog9ikydDnjzarU5EMrZkyRJatGhBuXLlWL58OWXLlnU7krhARR+kkpNh2jSn5AsVcjuNiASiqKgo6tSpw7Jlyyil62/Dloo+SC1e7By2v/9+t5OISKDZuHEj1lpq1KjBkiVLuPzyy92OJC5S0QepTz6BIkW0Gp6I/NOMGTOoUaMG48aNA9CKd6KiD0anTsHMmXD33c45ehERgKlTp9KhQwduuukm7r33XrfjSIBQ0QehL76AEyegUye3k4hIoPjoo4+4//77qVevHvPnz6dw4cJuR5IA4VHRG2OK+jqIeO6TT6BMGbjtNreTiEgg2LVrFw899BANGjRg7ty5FCxY0O1IEkA8HdHvNcZ8aoxpYYzRUQAXHTrkLJLTsaMWyRERR/ny5Zk7dy6xsbHkz5/f7TgSYDwt7f8DLgdigd3GmMHGmGt8F0syM326c2mdDtuLyIgRI4iNjQWgSZMm5M2b1+VEEog8Knpr7URrbQOgEjAeuA/YYIxZaYzpZowp4MOMks4nn8C118INN7idRETc9Oabb/LEE08wZcoUt6NIgMvWYXhr7XZr7SBrbUWgCZACjAX2GWMmGWNq+SKkOHbsgK+/dkbzumJGJHy98sor9O/fn44dO/LBBx+4HUcCXLbPtxtj8hljHgAGAbcCG4ChwHXAj8aYp7yaUM6aONEp+K5d3U4iIm6w1jJo0CCee+45OnfuzMcff0zOnNqbTLLmcdEbY24zxkwE9gHvAJuAutba6tba56y1dYCngYG+iRreUlKcom/aFMqVczuNiLjl8OHDdOvWjYkTJxKhGbniAY9+FDTGbAMqAN8CTwCfWmtPZfDWxcBrXksnZy1aBHFxMGSI20lExN+stezfv58SJUowfPhwAHLk0AVQ4hlP/0+ZAVxnra1vrZ2UScljrf3JWqv/+3xgwgQoVgzatHE7iYj4U2pqKj179qR27docOHCAHDlyqOQlWzyddd/fWrvZ12EkYwcPwqxZ8K9/aclbkXCSkpJC9+7dGT16NJ06dSIqKsrtSBKEPF0Z77/GmPcyeW2MMeZl78aS9D7+GJKSoFs3t5OIiL8kJyfz4IMPMn78eJ577jlef/11bVAjF8XT4z/3AV9n8trXgJZv8RFrYfx4uPFGqF7d7TQi4i+vvfYaH330ES+//DIvvfSSSl4umqfXZZQG9mTy2p9pr4sPrF4N69bBmDFuJxERf3riiScoX748nTt3djuKBDlPR/T7gMwWw6kFHPBOHDnX+PGQN6+ztr2IhLbExEQGDRrEyZMnKVSokEpevMLTov8UGGSMaZX+SWNMS+A5YKq3g4mz7/yUKc6+89pxUiS0xcfH07ZtW15++WW++uort+NICPH00P0goCbwhTHmELAXKAUUBRbilL142eTJ8Pff8PDDbicREV86efIkbdq0YenSpYwbN462bdu6HUlCiEdFb61NAJoaY5oBDYFiwCFgsbV2kQ/zhS1rYdgwuP56qF/f7TQi4ivHjx+nVatWrFy5kg8++ECH68XrsrVIsrV2AbDAR1kknSVLYP16Z6EcTbYVCV1//fUX27dvZ/LkyXTo0MHtOBKCslX0xpg8QBkg8tzXrLUbvBVK4J13oHhxuO8+t5OIiC+cPHmSfPnycfXVV7N582by5cvndiQJUZ4umFPaGBMLnAK2AL+l+1qXditesm0bxMbC//0fRJ73I5WIBLuDBw9y66238uyzzwKo5MWnPB3Rj8O5jK4vzra0p32WSBgxAnLmhEcfdTuJiHjb/v37ady4MVu2bOHVV191O46EAU+Lvh7wiLX2U1+GEWeW/YQJcO+9UKqU22lExJv27t1Lo0aN2LlzJ7GxsTRq1MjtSBIGPC36/UC8L4OIY8oUOH4cnnjC7SQi4k1JSUk0btyYP/74g3nz5nH77be7HUnCRHauox9gjFlurf3bl4HC3ZQpcO21ztr2IhI6cuXKxYsvvkjp0qW55ZZb3I4jYcTTom8PlAN2GWN+BI6e87q11uq6kEu0Zw+sWAEvvKBL6kRCxbZt21i/fj1t2rTh7rvvdjuOhCFPiz4K2JZ2PxdQ3Ddxwtu0ac5CObqkTiQ0bNq0iZiYGFJTU2nUqBH58+d3O5KEIU9Xxmvo6yDiHLavXRsqVXI7iYhcqg0bNhATE4O1lq+++kolL67xdFObs4yjtDEmW4vtSNa2bHG2pNVoXiT4rV254R67AAAgAElEQVS7lgYNGmCMYdmyZVSvXt3tSBLGPC56Y0xLY8z3QAKwG6iR9vz7xph/+Shf2Jg61TkvrxUwRYLf559/Tu7cuVm+fDnXXXed23EkzHm6Ml4XYA7wO9AdSD9VbDPQzfvRwoe1zmH7+vWhbFm304jIxUpOTgbg+eef55dffqFy5couJxLxfET/DPCmtbYr8PE5r60Hqng1VZhZuxY2btRhe5FgtnLlSqpUqcKmTZswxlC8uOYsS2DwtOjLA5ltR5sAFPJOnPD02WcQEQG68kYkOC1btoxmzZphjKFAgQJuxxH5B0+LfjdwQyavRQNbvRMnPM2dC7fcAlFRbicRkez66quvaNmyJeXLl2fZsmWUKVPG7Ugi/+Bp0Y8Hnk+bdJc37TljjGkE9Afe90W4cPDnn/DLL9CypdtJRCS7vv32W+644w6uvvpqli5dSiltUCEByNOifx34CPgAOJz23LfAAmCatXa4D7KFhfnznVsVvUjwuf7663nooYdYunQpl19+udtxRDJkrLWev9mYq4BGOCvlHQaWWGs3+yibx6Kjo+3q1avdjnFR7r4bVq2C3bu17K1IsFi0aBF169alYMGCbkeRMGWM+claG+3Je7O1YI61dpu1dqy1drC1dkwglHwwS0qChQud0bxKXiQ4TJkyhRYtWvDcc8+5HUXEI5mubmeMqQJss9Ympt3PkrV2g1eThYGVK50taXXYXiQ4fPDBBzz00EPUr1+fV155xe04Ih7JahnbdUBd4Ie0+5kd4zdpr0V4N1romzsXcuWCxo3dTiIiFzJu3Di6d+9Oo0aNmD17Nvny5XM7kohHsir6hsCGdPfFy+bOhdtvB112KxLYTpw4wYsvvkjz5s35/PPPiYyMdDuSiMcyLXpr7fKM7ot37NoF69dDNy0eLBLQrLUUKFCAr7/+mlKlSpEnTx63I4lki6dr3TcyxjyQyWsPGGM04s+mefOcW52fFwlcr732Gr1798ZaS4UKFVTyEpQ8nXX/X6BEJq9FAYO9Eyc8pKbCe+/BNdeA9rwQCTzWWl566SWefvppDh48SEpKituRRC6ap0VfFcjsQvVf0KY22fLpp7BmDQwapMvqRAKNtZZnn32W559/nq5du/LRRx+RM2dW05lEApunRZ8MFM3ktWJeyhIWkpLg2WehRg3o2NHtNCJyrmeeeYbBgwfzyCOPMGHCBCIidEGRBDdPi/4b4CljTO70T6Y9fhL42tvBQtX48bBtGwweDDmytVyRiPjDzTffTO/evRkzZgw59JdUQoBHS+AaY2rglP1RYBqwFygF3AsUBm611q7zYc4sBcsSuKdOwVVXwdVXw4oVOmwvEihSU1P58ccfqVOnjttRRDzi9SVwrbVrgRuBlUBnnE1uOuOU/01ulnwwGT4c9u2DV19VyYsEipSUFB5++GFuueUW1q5d63YcEa/zeIaJtXYTcJ8Ps4S0I0fg9dfhjjvg1lvdTiMiAMnJyTz44IN8/PHHPP/881SvXt3tSCJep6mkfjJyJBw9Cv/9r9tJRAQgKSmJzp07M23aNF555RWeeeYZtyOJ+ERWm9p8Cjxtrd2Wdj8r1lrbwbvRQkdqqjMJLybGmW0vIu6bPn0606ZN480336Rfv35uxxHxmaxG9MWBXGn3LyfzTW3kApYtg507NZoXCSQdO3akXLly1KtXz+0oIj6VVdF3xZldj7W2gV/ShKjx46FIEWjXzu0kIuEtPj6ebt268Z///Idq1aqp5CUsZDXrfgdwA4AxZokx5lr/RAotR47AjBlw//2QN6/baUTC18mTJ2nVqhVTp07l119/dTuOiN9kNaKPB85suNwAKOTzNCFo8mRITNQudSJuOn78OK1atWLlypV8+OGH3H///W5HEvGbrIr+F+AdY8yitMePG2P2ZvJea60d4Mk3NMY0B94BIoBx1trXMnjPvcALOPMCfrXWdvLkswPR+PFQsybccIPbSUTC07Fjx2jRogU//PADkydPpkMHzRuW8JJV0T8CvAW0xSncRkBiJu+1wAWL3hgTAYwEmgBxwI/GmDnW2g3p3lMJeBqoZ609Yoy53JPfSCD65Rfna8QIt5OIhK/cuXNz2WWX8dlnn9FOE2UkDGVa9Nba34E7AIwxqcCd1tofLvH73QRstdZuT/vcqTg/SGxI955HgJHW2iNpOfZf4vd0zfjxkCePc35eRPzr4MGDREREcNlllxEbG4vRcpQSpjKdjHfOBLwHcSbnXaoywO50j+PSnkuvMlDZGLPSGLMq7VB/Rvm6G2NWG2NWHzhwwAvRvCs+Hj75BNq3h8suczuNSHj566+/aNCgAe3atcNaq5KXsJbVrPv6QJG0+xOAil74fhn9bTv3+vycQCWcCYD3AeOMMUXO+0XWjrXWRltro4sXL+6FaN41a5azEp4m4Yn4159//kmDBg3YsWMHgwYNUslL2MvqHP1u4B5jzAmcgq6Ydj9D6c+zZyEOuCLd47LAnxm8Z5W1NgnYYYzZhFP8P3rw+QHjyy+hVClo2NDtJCLhY/fu3cTExLBv3z7mz59P/fr13Y4k4rqsiv5VYBTwb5xR9+RM3mfSXo/w4Pv9CFQyxlQE9gAdgXNn1M/CGclPMsZE4RzK3+7BZweUnTvhmmu057yIP3Xt2pX9+/ezcOFCbr75ZrfjiASErCbjvW+MmYMzml4B9OSfk+ayzVqbbIzpBSzA+cFggrV2vTHmJWC1tXZO2mtNjTEbgBTgKWvtoUv5vm7YtQsaNXI7hUh4GTduHIcPHyY62qNtukXCQpa711lr/wL+Msa8CMy21p57mD3brLVzgbnnPDco3X0L9E37CkpJSfDnn1C+vNtJRELf77//zqRJkxg8eDBXXnklV155pduRRAKKRweWrbUvWmv/NMZcZoypb4zpZIy5DMAYE2mM0QHqdOLinB3rypVzO4lIaFu3bh0NGjRg4sSJ7Nmzx+04IgHJo4I2xkQYY97AmSi3HPiI/83CnwE875t4wWnXLudWI3oR3/n1119p2LAhOXLkYPny5VxxxRUX/kUiYcjTkfhgnIVsegFX8s/L5GYDrb2cK6ip6EV866effqJhw4ZERkayfPlyrr1We26JZMbTou8CDLTWTuSfC94AbMMpf0nzxx/OrQYYIr5x6NAhSpQowYoVK6hUqZLbcUQCWpaT8dIpglPoGcmNZ5fWhY1du6BkSYiMdDuJSGg5ePAgUVFRNG3alN9++42cOT39J0wkfHk6ol+HsyZ9RloAP3snTmjYtUuH7UW8bdmyZVx55ZXMmDEDQCUv4iFP/6a8AswwxuQFPsNZIKemMaYd0ANo46N8QWnXLm1LK+JNixYtom3btlSsWJF69eq5HUckqHh6ed1snBXsGgPzcCbjjQMeADpbaxf4KmCwSU11ztFrRC/iHXPnzqV169ZUrlyZZcuWUbJkSbcjiQQVj499WWs/BT41xlQGooDDwKa0BW4kzf79kJioa+hFvGHLli3ceeed1KhRg4ULF1K0aFG3I4kEnWyf5LLWbgY2+yBLSNCldSLeU6lSJUaPHs1dd91FkSLnbWIpIh7QinZedubSOhW9yMWbOnUqP//szPHt1q2bSl7kEqjovezvv53byy5zN4dIsJo0aRKdOnVi8ODBbkcRCQkqei9LSHBudQ29SPaNHTuWBx98kMaNG/Phhx+6HUckJKjovUxFL3Jx3n33XXr06EHLli2ZM2cO+fLlczuSSEhQ0XtZfLxzq6IX8VxqaioLFizgzjvvZObMmUTqL5CI13g8694YczfQHigLnPe30Fp7kxdzBa2EBIiIgFy53E4iEhzi4+PJmzcvn332GREREeTSXx4Rr/J0m9oXgE+B63A2tVmfwZfgFL0GIyIXZq3lhRde4JZbbuHYsWNERkaq5EV8wNMRfTfgNWvtf3wZJhSo6EUuzFrLM888w6uvvsoDDzxAgQIF3I4kErI8LfqCwGJfBgkVKnqRrFlr6devH0OGDKFHjx6MGjWKHDk0XUjEVzz92zUVaO7LIKEiPl5FL5KVwYMHM2TIEB5//HFGjx6tkhfxMU9H9IuB140xUcAi4Oi5b7DWzvVmsGCVkAB587qdQiRwdenShYiICAYMGIAxxu04IiHP06KflnZbAeiawesWiPBGoGB36pRG9CLnSklJYeLEiTz44INcccUVDBw40O1IImHD06Kv6NMUIWTfPihb1u0UIoEjOTmZrl27MnnyZIoXL07btm3djiQSVjwqemvtLl8HCRVxcVCnjtspRAJDUlIS999/P5999hmDBw9WyYu4IDsL5uQE7gJuBYri7Ef/NfC5tTbZN/GCS0ICHDyoEb0IQGJiIh07dmTWrFm8/fbb9O3b1+1IImHJo6I3xlwOLARqADuBv4CbgZ7Ar8aYptbaA74KGSz+/NO5LVPG3RwigWDDhg0sXLiQESNG0KtXL7fjiIQtT0f0Q4BiQB1r7Y9nnjTG3AjMSHu9s/fjBZc9e5xbFb2Es5SUFCIiIrjhhhvYunUrpUqVcjuSSFjz9ALWlsCA9CUPkPb4aaCVt4MFo7g451aH7iVcnThxgiZNmvDee+8BqORFAoCnRZ8HOJ7Ja8eB3N6JE9w0opdw9vfff9O8eXOWL19OwYIF3Y4jImk8LfpVwABjTP70T6Y9HpD2etiLi4MCBaBQIbeTiPjX0aNHadq0Kd9//z1Tp06lU6dObkcSkTSenqN/ElgK7DbGLMSZjHc50AwwQAOfpAsye/Y4o3kt9iXhJDExkcaNG7N27VqmT5+uS+hEAoxHI3pr7RqgEjAWKA40wSn6MUAla+2vPksYRPbs0fl5CT958uThvvvuY9asWSp5kQDk8XX01tqDgNatzEJcHDRs6HYKEf/Yt28fu3fv5sYbb+TJJ590O46IZMLjopespaTA3r2aiCfhYc+ePcTExHDy5Em2bt1KpDZ4EAlYmRa9MeYH4AFr7QZjzI84G9dkylp7k7fDBZP9+yE5WYfuJfT98ccfxMTEsH//fubNm6eSFwlwWY3o1wPx6e5nWfThTpfWSTjYsWMHDRs25OjRoyxatIg62thBJOBlWvTW2gfT3X/AL2mCmBbLkXDw1ltvcfz4cRYvXkzt2rXdjiMiHvBo1r0xZoIxJsOtao0x5Y0xE7wbK/icKXqN6CWUDR06lFWrVqnkRYKIpwvmPIBzWV1GooCuXkkTxDZtchbLKVHC7SQi3rVu3ToaNWrEgQMHyJ07N5UqVXI7kohkQ3Zm3Wd2jr4aEPY7161fD1WrarEcCS1r1qyhcePG5MmThyNHjlC8eGY/74tIoMpq1n1voHfaQwvMMsYknvO2SKAEMMkn6YLIunXQpo3bKUS8Z/Xq1TRt2pQCBQqwZMkSrr76arcjichFyGpEvwFnC1oD9MVZAnfvOe85DfwOfOqTdEFi/344cACqVXM7iYh3rF69mkaNGlG0aFGWLl1KhQoV3I4kIhcpq1n3i4BFAMaY48D71to//RUsmKxb59yq6CVUlC1blvr16zN69GiuuOIKt+OIyCXwdDLeBKBkRi8YY2oZY8L6XwIVvYSKNWvWkJycTMmSJYmNjVXJi4QAT4t+NPCvTF7rBIzyTpzgtG4dFCumGfcS3BYsWMDNN9/M888/73YUEfEiT4u+LrAkk9eWpr0ettatc0bzmnEvwSo2NpY2bdpw7bXX0qdPH7fjiIgXeVr0+ch6Cdz8XsgSlKz9X9GLBKOZM2fSvn17atSoweLFi4mKinI7koh4kadF/xtwXyav3YezFn5Y2r0bjh9X0UtwOnbsGN26daN27dp89dVXFC1a1O1IIuJlni6Y8xowwxiTB+ea+b1AKZwV8e5K+wpL69N+xKla1d0cIhejcOHCLFy4kGuuuYaCBQu6HUdEfMCjorfWzjTGdAVexSl1i3N9/R7gX9baWb6LGNjOzLhX0UswmTBhAsePH6d3795ER0e7HUdEfMjTQ/dYaz8CrgCqArcBVYBy1topPsoWFNatg9KlQUc8JViMGTOGbt26MW/ePFJSUtyOIyI+5nHRA1hrLc5KeDuArWmPw5om4kkwGT58OI8++iitWrVi1qxZREREuB1JRHzM46I3xrQ0xnwPJAB/ADXSnh9rjMnsGvuQlpICGzao6CU4vPXWW/Tu3Zt27drx+eefExkZ6XYkEfEDT/ej7wLMwRnNdz/n120Bunk/WuDbvh0SElT0Ehzy5MlDhw4dmDZtGrlz53Y7joj4iacj+meAN621XYGPz3ltPc75+rCzbZtzq+25JVBZa9m5cycAjz/+OFOmTCFXrlzuhhIRv/K06MuTtsFNBhKAQt6JE1z2pu3lV7q0uzlEMmKt5emnn6ZatWps2rQJAKPlG0XCjqdFvxu4IZPXooGt3okTXPbtc25LZrjdj4h7rLU8+eSTvP7663Tu3JlKOuwkErY8LfrxwPNpk+7ypj1njDGNgP7A+74IF+j27oVChSBfPreTiPxPamoqjz/+OEOHDuWJJ55g1KhR5MiRrQtsRCSEeLoy3us419B/AJy58PZbIAJ4z1o73AfZAt7evVCqlNspRP5p0qRJjBw5kn79+vHGG2/ocL1ImPN0ZTwL9DTGDAEaAVHAYWCJtXazD/MFtH37VPQSeLp06UK+fPno0KGDSl5Esr1gzjZr7Vhr7WBr7ZhwLnlwRvQ6Py+BIDk5mf79+7N3715y5sxJx44dVfIiAmQxojfGZOuSOWvthkuPEzys1aF7CQynT5+mU6dOzJgxg8qVK/Pwww+7HUlEAkhWh+7XkfUe9GeYtPeF1Vqax4/DqVMqenFXYmIi9957L3PmzGHIkCEqeRE5T1ZF39BvKYKQLq0Tt8XHx3PXXXcxb948Ro4cyWOPPeZ2JBEJQJkWvbV2uT+DBJszi+VoRC9uOXXqFHFxcbz//vsayYtIpjy9vA4AY0wLnAVyrgBesdb+YYy5DWcnuz99ETBQqejFLSdOnCB37twUK1aM1atXa916EcmSp5valEjbue4LoCvOJjZRaS8/CDznm3iB60zR69C9+NOxY8do1qwZ//rXv7DWquRF5II8vbxuBFAAuDbtK/11O1/hXFsfVvbtg9y5oWhRt5NIuDhy5AhNmzblhx9+4N5779XlcyLiEU8P3TcHulprtxpjzp1dHweU8W6swHfmGnr9Wyv+cOjQIZo0acK6deuYMWMGbdq0cTuSiASJ7JyjT8nk+Sgg3gtZgoquoRd/sdbSvn17NmzYwOzZs2nRooXbkUQkiHh66P5r4PFzRvNnrrF/CFji6Tc0xjQ3xmwyxmw1xgzM4n13G2OsMSba08/2p337dH5e/MMYwxtvvEFsbKxKXkSyzdMR/QDgG5xFdGbilPwjxphqQDWgricfkvaDwkigCc4h/x+NMXPOXVXPGFMQeAL43sN8frd3L9x6q9spJJTt2bOHL7/8ku7du1OnTh2344hIkPJoRG+tXQfUBlYDD+Acxm+Ps099nWyseX8TzqV42621p4GpQNsM3vcy8AaQ4OHn+tXp03DokA7di+/88ccf3H777fTr14+9Zy7xEBG5CB6fo7fWbgM6X+L3K4Pzw8EZccA/hirGmBuAK6y1scaYfpl9kDGmO9AdoFy5cpcYK3u0Kp740vbt24mJieHo0aMsWrSIUvqJUkQuQbZ2r0vPGHOtMeZOY0zp7PyyDJ47u56+MSYHMBR48kIflLaLXrS1Nrp48eLZiHDpzhS9/v0Vb9uyZQu33347x48fZ8mSJTpkLyKXzNMFc94zxoxJ97gDzvn6z4HfjTG3ePj94nBW1TujLJB+Rb2COOf8lxljduKc+58TaBPytCqe+MqqVas4ffo0S5cupVatWm7HEZEQ4OmIvjmwIt3jl4HJQGlgQdpjT/wIVDLGVDTG5AY6AnPOvGitPWatjbLWVrDWVgBWAW2stas9/Hy/0Kp44m2JiYkAdO7cmc2bN1OjRg2XE4lIqPC06C8n7dy6MaYScDXwhrV2HzAWuMGTD7HWJgO9cH442Ah8aq1db4x5yRgTNCuA7NvnLJRTooTbSSQU/PLLL1SqVInly519pAoXLuxyIhEJJZ5OxjsMnKm1xsC+tJn44Jx393gvemvtXGDuOc8NyuS9DTz9XH/auxeioiBXLreTSLD74YcfaNasGYUKFaJs2bJuxxGREORp0c8DXjLGlAD6A5+me60asNPLuQKaVsUTb/j2229p3rw5UVFRLF26lPLly7sdSURCkKeH7p/EOV/+fzjn6tOPwNsB872cK6BpVTy5VBs3bqRp06aULFmSFStWqORFxGc8GtFba4/hLHWb0Wv1vZooCOzdC1WquJ1Cgtk111xDnz59eOyxx3SdvIj41EVfRx+uUlOdEb3+bZaL8dVXX/HHH3+QI0cOXn75ZZW8iPicij6bDh+G5GQdupfs++KLL2jVqhV9+/Z1O4qIhBEVfTZpsRy5GDNmzKB9+/Zcf/31vP/++27HEZEwoqLPJhW9ZNeUKVPo0KEDN910E4sWLeKyyy5zO5KIhBEVfTZpQxvJjpSUFIYOHUq9evWYP3++FsMREb/LdNa9MSZfdj7IWnvq0uMEPo3oxVOpqalEREQwb948IiMjyZ8/v9uRRCQMZTWiPwEcz8ZXWNi7FwoUcL5EMjNq1CjatGlDYmIixYoVU8mLiGuyuo7+IdJtISsOXVonFzJs2DD69OlD69at3Y4iIpJ50VtrJ/kxR9DYu1fn5yVzb7zxBgMGDOCuu+5i8uTJ5M6d2+1IIhLmNBkvm7TOvWTm7bffZsCAAXTs2JGpU6eq5EUkIHi6qQ3GmA7AI0BlIPLc1621l3sxV8DSoXvJTMOGDenZsyfvvPMOEREeb+goIuJTHo3ojTGdgA+ArUBZYA4Qm/br/wbe9VXAQHLiBBw/rkP38j/WWhYtWgRArVq1ePfdd1XyIhJQPD10/xTwMtAz7fEoa+1DQEXgIBAWl9b9/rtzW6mSuzkkMFhr6dOnD02bNmX+/LDawFFEgoinRV8JWGmtTQFSgEIA1trjwOtAL9/ECyxr1zq3NWq4m0Pcl5qaevYwfe/evWnWrJnbkUREMuRp0R8D8qTd3wNcl+41AxTzZqhA9dtvkC8fXHml20nETampqfTo0YPRo0fTv39/hg4dijHG7VgiIhnydDLeaqAGsADn/PwgY0wycBoYBHzvm3iBZe1aqFYNdAo2vH377beMHz+e5557jhdffFElLyIBzdOifxUon3Z/UNr9UUAE8CPQ3fvRAou18Ouv0K6d20nEbbfeeis///wzNWvWdDuKiMgFeXTo3lq7ylo7Le3+UWttW6AAUMRaW8dau92XIQPBvn1w6JDOz4er06dP06lTp7OT7lTyIhIsLnrBHGttorX2b2+GCWRnJuJVr+5uDvG/xMRE7r77bqZMmcKWLVvcjiMiki3ZWTAnGmiPcx19Rgvm3OvFXAFHRR+e4uPjad++PfPnz2fUqFE8+uijbkcSEckWj4reGPMozqI4h4AtOJPwwsratVCmDBQLi+sLBCAhIYHWrVuzZMkSxo0bR7du3dyOJCKSbZ6O6PsBE4H/s9Ym+zBPwFq7Vufnw03u3LmpXLkyXbt2pXPnzm7HERG5KJ4W/eXAlHAt+aQk2LgRWrRwO4n4w7Fjxzhy5AgVKlRg1KhRbscREbkknk7GmwfU8WWQQLZpk1P2GtGHviNHjtCkSROaNGnC6dNhd4ZKREKQpyP6kcBYY0wuYBFw9Nw3WGs3eDNYINHSt+Hh4MGDNGnShA0bNjB9+nRtMysiIcHTol+advs8zoI56RnA4iyeE5LWroVcueCaa9xOIr7y119/0bhxY7Zu3crs2bNp3ry525FERLzC06Jv6NMUAW7tWrjuOqfsJTT179+fbdu2ERsbS6NGjdyOIyLiNR4VvbV2ua+DBLK1a6FhWP+oE/reeecdHnvsMerUCdupKCISoi56ZbxwcegQ7Nmj8/OhaOfOnTz00EPEx8dTpEgRlbyIhCSPit4Yk2qMScnkK9kYc9gYs9QYE3Jbvvz2m3Orog8t27Zt4/bbb2fmzJls3x7yWzWISBjz9Bx937Svv4EvgAM419a3BgoC44H6wHRjTFdr7cc+yOoKFX3o2bRpEzExMSQmJrJkyRKqVq3qdiQREZ/xtOhLAyuttfed8/xAY8xU4DJrbWNjzIdAfyBkin7tWoiKgpIl3U4i3rBhwwZiYmKw1rJ06VKqa/MCEQlxnp6jfxBnCdyMTATOrA86Dah0qaECyZmlb41xO4l4Q2pqKiVKlGDZsmUqeREJC54WfU7g2kxeuy7d55wGEi41VKBISYF167RjXSiIi4vDWku1atX45ZdfuO6669yOJCLiF54W/VTgVWNMX2NMJWNMkbTbfsBgYHLa+2oBv/siqBu2b4dTp3R+Pth9//33VKtWjSFDhgCQI4cuNhGR8OHpOfreOKP1V4A30z2fCLwPPJX2+HtgsdfSuUxL3wa/lStX0qJFC4oXL87dd9/tdhwREb/zdMGc00BvY8yLQHWgJLAP+M1aezjd+5b5IqRb1q6FHDmgShW3k8jFWLZsGXfccQdlypRhyZIllClTxu1IIiJ+5+mIHoC0Ug+bVfL27IESJSBfPreTSHYdPnyYNm3aUL58eRYvXkxJXTYhImEq06I3xrQEvrHW/p12P0vW2rleTRYATp+GyEi3U8jFKFq0KJ988gl169alePHibscREXFNViP6WKAu8EPafYuzU11GQnL3utOnQTuVBpc5c+YA0KZNG1q3bu1yGhER92VV9BWBvenuh53ERBV9MJkxYwYdO3bk5ptvpnXr1hgtfiAiknnRW2t3ZXQ/nGhEHzymTJlC586dqVOnDrGxsSp5EZE02ZqMB2CMyQd0w1lAZx/wYaj+IKCiDw4ffPABDz30EPXr1yc2NpYCBQq4HUlEJGBkNRnvbaC1tbZyuucKAj/iLJJdwEUAACAASURBVHN7BCgMPGmMuclau9nXYf1NRR8c1qxZQ0xMDLNnzyafLpEQEfmHrJYIa8j5m9P0AyoDj1hro3A2u9kJPOeTdC47fRry5HE7hWTm2LFjAAwZMoTY2FiVvIhIBrIq+grAT+c8dxewwVo7AcBaewB4G6jnk3Qu04g+cA0dOpQqVarwxx9/YIwhj34iExHJUFZFn5N0G9QYY4ribGCz5Jz37cRZKS/kaNZ9YHr99dfp27cvt9xyC6VKlXI7johIQMuq6DcDDdI9viPtdsE577scOEwI0og+8Lz88ssMHDiQ++67jylTppArVy63I4mIBLSsZt2/C7xvjCkM/AU8AewAFp7zvqbAOt/Ec5eKPrCMHz+eQYMG0bVrV8aPH09ERMit0SQi4nVZXUc/yRhTCugJFAF+Bnpaa5POvMcYUxxoC7zo66BuUNEHlnvvvZfDhw/z5JNPaqtZEREPZfmvpbX2VWttWWttAWvtbdba3855/YC1tqS1drRvY7pDs+7dZ/+/vfsOj6JaHzj+fSEJTUhCx4AEDAgYBJEiINKkI01RQEGKCAoioF4RL5fiT0CkXAsqCIiAgKBIE41ICRYU8IIaEZHeld4TUs7vj5kNm81uCiS7Ke/nefbZnZkzM++ebPbdc+bMjDG8/fbbXLp0icKFC/Piiy9qkldKqXTQb8wUaIvetxISEnjmmWcYMmQICxa4numplFIqLdJ9ZbzcREfd+058fDz9+/fnww8/ZMSIEQwYMMDXISmlVLakLXoPjNEWva/ExcXRu3dvPvzwQ0aPHs348eP12vVKKXWDtEXvQVyc9ayJ3vuOHz/ON998w2uvvcbIkSN9HY5SSmVrmug9uHbNetbBeN4TGxuLn58f5cqV4/fff6do0aK+DkkppbI97br3wJHotUXvHdHR0XTp0oUXX3wRQJO8UkplEE30Hmii956rV6/SsWNHVq9eTaVKlXwdjlJK5Sjade9BTIz1rIk+c12+fJkHH3yQjRs3MmfOHPr06ePrkJRSKkfRRO+BtugznzGGjh07EhkZybx583j88cd9HZJSSuU42nXvgSb6zCciPPPMMyxatEiTvFJKZRJt0Xugo+4zz5kzZ9iyZQutW7emS5cuvg5HKaVyNE30HmiLPnOcOnWKFi1a8Ndff7F//35KlCjh65CUUipH00TvgSb6jPf333/TvHlz9u7dy4oVKzTJK6WUF2ii90BH3WesY8eO0bx5cw4dOsQXX3xBs2bNfB2SUkrlCproPdAWfcZatGgRR44c4auvvqJRo0a+DkcppXINHXXvgbboM4YxBoDhw4fz66+/apJXSikv83qiF5HWIvKniOwRkRFulg8XkZ0i8quIrBOR8t6OEa4n+vz5fbH3nGHPnj3UrVuXP/74AxGhQoUKvg5JKaVyHa8mehHJC0wH2gDVgO4iUs2l2HagtjHmLuBTYJI3Y3RwJHo9ve7G7Nq1i/vvv58DBw4Q46hMpZRSXuftFn1dYI8xZp8x5hqwGOjoXMAYs8EYc8We/BEo6+UYAU30NyMqKoomTZoQHx/Phg0bqFmzpq9DUkqpXMvbiT4EOOw0fcSe50k/4Et3C0TkKRHZJiLbTp48mYEhWjTR35hdu3bRtGlT8uTJQ2RkJOHh4b4OSSmlcjVvJ3pxM8+4LSjyOFAbeMPdcmPMTGNMbWNM7cw4H1sT/Y257bbbaNWqFZGRkVSpUsXX4SilVK7n7dPrjgDlnKbLAsdcC4nIA8ArQGNjjE8O8GqiT5/t27dTsWJFAgMDWbBgga/DUUopZfN2i34rUElEKohIANANWOlcQETuBmYAHYwx/3g5vkR6el3afffdd9x///0MGjTI16EopZRy4dVEb4yJAwYDEcAfwBJjzO8iMk5EOtjF3gBuAZaKyA4RWelhc5kqJsZK8uLuYINKtHHjRlq1akVISAivv/66r8NRSinlwutXxjPGrAHWuMz7j9PrB7wdkzsxMdptn5q1a9fSsWNHKlSowLp16yhdurSvQ1JKKeVCr4znQXS0JvqUxMbG8swzz1CpUiU2btyoSV4ppbIovda9B9qiT5m/vz9fffUVQUFBFCtWzNfhKKWU8kBb9B5oondv6dKlDBkyBGMMt99+uyZ5pZTK4rRF70FMjF7n3tXHH39Mr169aNCgAVevXqVgwYK+Dkl5SWxsLLGxsYk3KVLK1/LkyUNAQAB58+b1dShZniZ6D7RFn9TcuXPp27cvTZo0YeXKlZrkc4lr165x4sQ5rl41QAAiguZ65WsiYEwCIucpUsSfkiWDyZNHO6g90UTvgSb662bNmkX//v1p0aIFy5cv1ySfS8TFxXHkyBkgiMKFtXtLZT3GGC5evERc3ClCQkogej60W/oTyANN9NeVKVOGzp07a0s+l7l8+QpxcQXJr8ewVBYlIhQqVJjLl/PoXTJToIneA0308McffwDQrl07li1bpl/4ucz589Hky1fA12Eolaq8eQtw9aomek800XuQ2xP9hAkTCA8PZ9OmTb4ORflIXFyCDnRS2UKePHm5di3e12FkWZroPcitid4Yw9ixYxk5ciTdu3enQYMGvg5JKaXUTdDBeB7kxkRvjOGVV15hwoQJ9O7dm1mzZmmLTimlsjlt0XuQGxP92rVrmTBhAgMGDGD27Nma5JVSKgfQFr0HufFa9y1atGDVqlW0a9dOT1NRSqkcQlv0HuSWFn1CQgIvvvgiv/zyCyJC+/btNckrpVQOoi16D3JDoo+Pj+fJJ59k7ty5BAcHU6NGDV+HpJRSKoNponcjIQFiY3N2oo+Li+OJJ55g4cKFjBkzhpdfftnXISmllMoEmujdcFxgqUAOvVZIbGwsjz32GEuXLmX8+PGa5JVSKgfTRO9GdLT1nFMTfUJCAhcvXmTKlCkMHz7c1+EopZTKRJro3XAk+px2xdfo6GiuXr1KcHAwq1ev1tPnlFIqF9BR925cvWo956REf+XKFTp06EDr1q2Ji4vTJK+UUrmEtujdyGkt+kuXLvHggw8SGRnJnDlz8PPTP7tSSuUW+o3vRk5K9BcuXKBt27Zs3ryZBQsW0KNHD1+HpJRSyos00buRkwbjDRgwgJ9++onFixfTtWtXX4ejlFLKy/QYvRs5qUU/ceJEli9frkleKaVyKU30bmT3wXgnT55k3LhxJCQkUL58edq1a+frkJRSSvmIJno3snOL/sSJEzRp0oQJEyawc+dOX4ejlFLKx/QYvRvZ9Rj90aNHadasGUeOHGHNmjWEh4f7OiSllFI+pi16N7Jji/7QoUM0btyY48ePExERQdOmTX0dksolzp49Q/XqJRg5clCyZf/+97NUqxbMqVP/JJn/1VfL6d69JXfeWYzQ0ADuuSeEp5/uxtat3ycpV69eKCEhkvioXr0EPXu25ffff8nU9+TJ3r27mTJlDOfPn0vzOsYY7r23AiEhwv79e5ItnzJlDOHhxd2uO27cC9SrF5ps/g8/bKRXr/aEhxcnNDSAevVCGTVqCEePHkoxlpiYGMaOfZ677ipJWFghevZsx+HDB1J9DzExMYwZM5yaNUtz++0F6dy5Eb/8si1Jmc2bI3n44abcdVdJKlTIR/36FRk79nkuXryQbHsff/wBDRtWomLF/LRufQ/ffrsuWZlNm9bSsWNDqlQJpEaNUvTr15k9e/5MNVaVnCZ6N7LjMfp9+/Zx+fJlvv76a+677z5fh6NykeDgoowcOZH5899P8uX/22//46OP3uWll8ZTvHjJxPmjRw+jf/+HKF06hMmTZ7F48Te8/PJELl26SKdO93HgwN4k2+/cuQcrV25m5crNvP76DE6fPsljj7Xi3LmzXnuPDvv27Wbq1LFcuJD2RL9t2+bEZLpixeKbjmH27Ld45JFm5M9fgNdfn8Hixd8wfPhooqK206dPxxTXHTVqCEuWzGXUqMnMnPkpZ8+eolu3FkQ7WjcprLd48WyGDx/DBx98RqFCt9Ct2wMcOXIwscy5c2cID7+b116bzscfRzBgwPMsXfoRgwYlPaV3xYrFjBgxkIcf7sX8+V9SufKd9O7dnl27ohLL/Prrz/Tq1Y7SpUOYMWMp48e/y8GD++jevYXbHw4qZdp170Z2atFfunSJW265hSZNmrB3714KFizo65BULtStW18WL57Dyy8/zerVPwEwYsRAqlevRc+eAxLLRUSsYNas/zJ16oc8+mjvJNt4+OGefP31KvLnT3rMrGTJMtxzz72J02FhVWja9E5+/nkzzZu3zbw3lUFWrFhEwYKFuOOOcFasWMTQof++4W1FRW1n7NjhPPfcv3nxxXGJ8++9934efbQPa9eu9rjusWNHWLx4NlOmzKFr114AVK16F/XrV2DZsgX06PFkiutNmjSTbt36AtCwYTMaNKjIe++9wWuvvQNAmzadadOmc+J6DRo0wd8/gH/96ynOnj1DcHBRACZPHk3Xrk8wbNgoAOrXb8zvv29n+vSJvP32AgBWr15KUFBRpk9fmHiBrwoVKtGiRQ22bv2eZs3a3FD95VbaoncjuyT6Xbt2UaVKFebPnw+gSV75jIgwYcJ7REVtZ96895k3731+/fVnJkx4jzx5rn/NfPDBf6lZs06yJO/QsuWDlC59a4r7KlSoMABxcbFJ5q9cuYTmzatToUI+atcux8SJrxAXF5ekTFTUDh55pDm3316QatWCGTz4MU6e/DtJmbffnkDDhmFUrJifGjVK8dhjrfnnnxP88MNGevd+ECCxK95dt7qz+Ph4Vq9eSsuWHejWrS+7d+9k585fU1wnJXPmvE3RosUZOnSU2+UtWrT3uO6mTV8D0LZtl8R5ZcqEUKfOfWzY8KXH9Xbt+o34+HgaNXogcV6+fPmoW7cR69Z9kWK8wcHFAIiNvQbAwYP72LdvNw8++EhimTx58tC+fVfWr78eQ2xsLAUKFExyFc/AwCDAOhSi0kcTvRvR0ZA3L/j7+zoSz6KiomjcuDFxcXHUqlXL1+EoRbVqd9Gnz7NMmvQKkya9Qs+eA6lRo3bi8ri4OP73v83cf3/LdG3XGENcXBxxcXEcPXqY1177F0FBRbn33saJZSIjv+bppx8lPLwWc+asoG/fZ5kxYzKvvDI4sczp0yfp2rUJV69eYfr0hbz66tts3hxJ9+4tuHbNSkRLl87j7bfH07//cD7+OIIJE94jNDSMK1cuU716LUaNmgzArFnLWLlyM7Nnf55i7N9/v56TJ/+mY8dutGv3MP7+/qxYsShd79/Zjz9Gct99zfG/gS+nPXt2UaZMWQoVuiXJ/EqVqrJnzy6P68XEWC0ff/+AJPMDAvJx5MhBrl69kmR+fHw8MTExREXt4M03/4+2bbtQsmTpxBjA6pVxFhZWlXPnznD69EkAHnrocf7++xjTp7/OuXNnOXr0MGPGDCcsrAr33dc83e89t9Ouezeio7N2a37Hjh088MAD5MuXj/Xr13PHHXf4OiSlABg27D/MnfsOBQoU5KWXXkuy7OzZ08TExHDrreWSzDfGEB8fnzidN29eRCRxeubMqcycOTVxOjAwiA8+WJbYwgN4443/UL9+E9588yMAmjZtDcCECS/z3HP/5tZbyzJjxhQAFi6MoHDhIgBUrFiZ9u3rsWbNZ3Tq1J0dO7bQuHFLevd+JnHbzi3g22+3/tfCw++mXLnQVOtj+fJFBAYG0aRJawICAmjUqIV9jHp8kveYVidOHCUk5LZ0rwdw/vxZihQJSjY/MDCY8+c9j3cIDQ0DYMeOrbRsafVoGGP45ZetGGM4f/4cBQpc701s2vRO9u61Bs01adKKt96anyQGIFkcgYHBAJw7d5ZixUoQHn43c+euZuDArowfPwKwfhwsXBhBvnz50v3ecztt0btx9WrWTfR///03zZo1o2DBgkRGRmqSV1nKJ598SHx8PBcvXiAqanuSZY4uV9cEN2PGFMqX9098zJ07PcnyLl0eZ82araxZs5WFCyNo2bIjTz7ZObELPD4+nqio/9G+fdKrP3bo8CgJCQn8/PNmALZv38L997dMTPIAd99dl3LlQtmy5TsA7ryzJuvXr2Hy5NFs374lyQ+Q9IqJieGrrz6ndevOBARYreFOnbpz+PABfv75xxveLqT/B0Limm5+XBhjUvzRUbVqderUacirr77Ar7/+zOnTJ5k4cST79u0GSHYnzA8++Izly79n4sT32bXrN556qmuy7vbk+0v62fjzz98ZPLgHbdp0YfHib/jwwxUEBgbTs2dbHYx3AzTRu5GVW/SlSpVi3LhxbNq0ibCwMF+Ho1SiEyeOMXXqGAYPfpmGDZvx738PJjb2+nH0okWLky9fPo4fP5JkvYce6pmYyN0pUaIUNWrUpkaN2jRu3JJp0z4kJKQ806ZZg9HOnDlFbGwsJUqUSrJe8eLW9LlzZwD455/jyco4yjnKdOvWl5deGs+qVUto374eNWqUYtKkUTeU8Dds+JLz58/RrFlbzp8/x/nz56hfvwn58uVL0n2fN68fCQnutx8fH5/kOHXp0iEcO5byKXSeBAYGuz1b4MKFc25b+s6mTZtLgQIFadOmNnfdVZK1a1fRr99z+Pv7ExRUNEnZO+64kzp1GtCz5wCmT1/E+vVr+P77DYkxOPbpzHG6oqOX5o03RlGhQiWmTJlNo0bNadmyA/PmfcGhQ/tZuHDWDb3/3EwTvRtZMdF/++23bN1qfREOHjyY0NBQ3waklIvRo4cSFFSU5557hddee4f9+/9i1qz/Ji738/OjVq36REZ+nWQ950SeFiJCWFgV9uz5A7B+QPj7+yc7V//UKWuQnSMRlSxZJlkZRzlHmTx58vDUU8OIjPyDLVsOMXDgC7z99ng+/viDNNbCdcuXW8l8wICuVKsWTLVqwdSpU46YmBhWrVqS+OOhWLESXLx4IdmxbrB+nBQrdv3UxPr1m/Ddd+uSDTJMi7CwKhw7dpgrVy4nmb9nz65kx8xdVagQxtdfb+eHH/YSGbmLdet+49q1GMLDa6U4XqB6dWv80KFD+xJjcOzTNYagoKIUK1YicfrOO2smKRMUFEzZsuU5eDDp6ZcqdZro3YiOzlpXxVu3bh2tW7dm6NChOuJUZUmbNq1l9eqljBv3JgUKFKRSpao8+eRQpk0bx/HjRxPL9e8/lO3bf+LTT+ensLWUGWP466+dicf68+bNS/Xq97B69dIk5VatWkKePHm45576ANSqVY/IyAguXbqYWGbHjq0cPnyAunWTX3siJKQcgwePIDQ0jL/+si4n7eiCdwxQ8+Ty5Ut8881qOnXqztKlG5I8Ro+eysmTfye2cuvVa0RCQkKyU+OuXLnMd9+to169Ronz+vR5ltOnT/LWW0nHPzisW7fGY0yOQZBffnl9AOGJE8fYsuVbmjZN2+lq5ctXJCzsDs6ePc2qVUvo3r1fiuUdF0AqV65C4voVK1ZO8rdKSEjgiy+WJjllrmzZ8skO/Zw5c5rDhw+kaWyESkoH47mRlVr0ERERdOrUibCwMJYtW3ZDA3iUykwxMTGMHDmI5s3b0arV9Qu2DBv2H5YvX8TYscN5//1PAGjVqiNPPjmUYcN688MPG2jR4kGKFi3O2bOn2bRpLQAFCyYdFf7PP8cTj2mfP3+Wzz9fyK5dUbzwwvXzyF94YSw9erRi2LA+dOzYjV27fuONN0bRo0d/br21LABPPTWcefPeo0ePVgwa9BKXL19i/PgRVK1anbZtHwLgX/8aQHBwUWrVupfChQP54YcN7N//F6+88jpwfTDe/Pkz6NixGwUKFKRq1erJ6iQiYgVXr16hX7/nqFWrXpJldeo05K23XmPFikXcf/8DVK5cjQ4dHuWFF/px+PB+qle/h9On/2HGjCkYY+jbd0jiuuHhNRk9eiqjRw9l9+6ddOzYjaJFi3Po0H4++WQOFy6c93htgVtvLUu3bv0YPdpqMBQrVoIpU8YQElKeLl0eTyw3bdo4pk0bx6FD13sNZs9+i+DgYpQuHcL+/X/xzjsTqFKlepJE/+yzPalYsTJ33lmTAgUKEhX1P959dxL33FOfhg2vX6nz+efH8Oyzj1O2bCh16jRk6dKP7G0uTCzTs+dA+vbtxNChvenUqTtXrlzm3XdfJyAggM6dH3P7/lQKjDHZ/nHPPfeYjNS0qTH33Zehm7whq1atMgEBAaZmzZrm5MmTvg5H5TJ79x43hw/Hm6NHTYqPF14Ya/Lnz29++GFvsmXvv7/EAGbx4m+SzJ81a5lp1OgBExQUbPz8/EypUmVM27ZdzPz5a5KUK1u2vMEaqWUAU6RIoLn77npm5sxPk+3r3XcXmypVwo2/v78pXTrEPPvsSHPwYGySMhER/zMNGjQ1+fMXMEWKBJpOnbqbHTtOJC6fOvVDU7t2AxMUFGzy5y9gqlatbiZPnpVkG6NGTTYhIbeZvHnzmrJly7utk+bN25kKFSp5rLNevZ42gYFBZt++aHP0qDH798eYoUNHmfLlKxo/Pz8TFBRs2rTpbCIj/3C7/pIl602zZm1NUFBR4+fnZ8qWLW8ee+wp8913f6X4t9q3L9r07z/MFC1a3BQoUNA0a9bGbN68L0mZ4cNHGyDJvJEjJ5py5UJNQECAKVOmrHnmmX+ZPXsuJynz6qtvmerVa5nChYuYggULmSpVws0LL4wzu3dfTBbHpEkzTWjo7SYgIMCEh9+d7PNx9Kgx7733ialRo7a55ZbCplixEqZZszYmImK72/e1d+9Vc+LEaV//y3gVsM2kMUeKyQFdwbVr1zbbtm1LvWAaNWgAhQrB2rUZtskb0rVrVw4cOEBERARFixZNfQWlMtC+fScICCiZ5II3SmVF0dHRFCp0hVKlcs/3pIj8bIxJ08AW7bp3Izoairu/x4RXxMXF4efnx4IFC4iOjiYwMNB3wSillMrW9Ke6G748Rr9gwQLq1q3L6dOnyZcvnyZ5pZRSN0UTvRu+umDOnDlz6NWrF0FBQeTPKqMBlVJKZWua6N3wRYt+xowZ9OvXjxYtWrB69WoKFSrk3QCUUkrlSJro3fB2op83bx4DBw6kXbt2rFixQu9Cp5RSKsNoonfD2xfMad68OUOGDGHZsmXaZa+UUipDaaJ3YYz3WvTLly8nPj6ekJAQ3nzzzcSrbimllFIZRRO9i5gY6zkz74RojGHMmDF07tyZOXPmZN6OlFJK5Xp6Hr2La9es58xq0RtjGDlyJBMnTqRPnz707ds3c3aklFJKoYk+GUeiz4xedGMMzz//PNOmTWPgwIFMnz5drzqmlFIqU2mWceHous+MRL9nzx5mzJjBkCFDePfddzXJK6WUynTaoneRGS16YwwiQqVKldixYwdhYWF6FzqllFJeoU1KF45En1GD8eLj4+nbty/vvvsuAJUqVdIkr5RSyms00bvIyBZ9XFwcPXv2ZO7cuZw+ffrmN6iUUkqlk3bdu8ioRH/t2jV69OjBZ599xsSJE3nppZduPjillFIqnTTRu8iIRJ+QkEDXrl1ZuXIlU6dOZdiwYRkTnFJKKZVOmuhdZMSo+zx58tC4cWNatmzJoEGDMiYwpZRS6gZoondxMy36K1eusHv3bmrWrMnw4cMzNjCllFLqBuhgPBc3Our+0qVLtG3blqZNm3L27NmMD0wppZS6Adqid3EjLfoLFy7Qtm1bfvzxR+bPn09wcHDmBKeUF/n55SE+Pl4v7KSyvISEeAIC8vo6jCxL/4NdpDfRnz17lhYtWvDTTz/xySef0L1798wLTikvCgzMT0zMVV+HoVSq4uOvUqBAJt6JLJvTRO8ivYl+ypQpbN++nc8++4yHHnoo8wJTyssKFSqIn98VoqOjfR2KUm4ZY7h06QKFCiWQLzNvOZrNade9i7g46zlvGnuBRo8eTYcOHahbt27mBaWUD/j5+VG2bFFOnDjHxYvnEQkA9KqOKmswJgGRaxQp4k/JksX1iqMp0ETvQUqfmePHjzNo0CDee+89SpUqpUle5VgBAQHcdltJYmNjiYuLwxjj65CUAkBECAgIJG9aW2W5mCb6dDpy5AjNmjXj2LFj7N27l1KlSvk6JKUynb+/P/7+/r4OQyl1A/QYfTocPHiQxo0bc+LECSIiImjQoIGvQ1JKKaVSpC36NNq/fz9NmjThwoULfPPNN9pdr5RSKlvQFn0aFSxYkHLlyrFu3TpN8koppbINbdGnYv/+/ZQtW5ZSpUrx7bff6shOpZRS2Yq26FPw22+/Ua9ePYYOHQqgSV4ppVS24/VELyKtReRPEdkjIiPcLM8nIp/Yy38SkVBvxwgQFRVF06ZNCQgI4LnnnvNFCEoppdRN82qiF5G8wHSgDVAN6C4i1VyK9QPOGmPCgGnA696M0aF79+4UKlSIyMhIKleu7IsQlFJKqZvm7RZ9XWCPMWafMeYasBjo6FKmI/CR/fpToLl4sc88NjYWgMDAQDZt2sTtt9/urV0rpZRSGc7biT4EOOw0fcSe57aMMSYOOA8Uc92QiDwlIttEZNvJkyczLMBbb/Xnzjsvsnz5EsqXL59h21VKKaV8wduJ3l3L3PWammkpgzFmpjGmtjGmdokSJTIkOIAHH4SoqMLUqnVrhm1TKaWU8hVvJ/ojQDmn6bLAMU9lRMQPCATOeCU6pZRSKofxdqLfClQSkQpi3QqrG7DSpcxK4An79cPAeqN30lBKKaVuiFcvmGOMiRORwUAEkBeYY4z5XUTGAduMMSuB2cB8EdmD1ZLv5s0YlVJKqZzE61fGM8asAda4zPuP0+tooKu341JKKaVyIr0ynlJKKZWDaaJXSimlcjBN9EoppVQOpoleKaWUysE00SullFI5mCZ6pZRSKgfTRK+UUkrlYJrolVJKqRxME71SSimVg2miV0oppXIwTfRKKaVUDqaJXimllMrBNNErpZRSOZgmeqWUUioHE2OMr2O4aSJyEjiYgZssDpzKwO3lVlqPN0/r8OZpHd48rcObl9F18l952QAADvdJREFUWN4YUyItBXNEos9oIrLNGFPb13Fkd1qPN0/r8OZpHd48rcOb58s61K57pZRSKgfTRK+UUkrlYJro3Zvp6wByCK3Hm6d1ePO0Dm+e1uHN81kd6jF6pZRSKgfTFr1SSimVg2miV0oppXKwXJ3oRaS1iPwpIntEZISb5flE5BN7+U8iEur9KLO2NNThcBHZKSK/isg6ESnvizizstTq0KncwyJiRERPc3IjLfUoIo/Yn8ffRWSht2PM6tLw/3ybiGwQke32/3RbX8SZVYnIHBH5R0SiPCwXEXnLrt9fRaSWVwIzxuTKB5AX2AtUBAKAX4BqLmWeAd63X3cDPvF13FnpkcY6bAoUtF8/rXWY/jq0yxUGNgE/ArV9HXdWe6Txs1gJ2A4E29MlfR13VnqksQ5nAk/br6sBB3wdd1Z6APcDtYAoD8vbAl8CAtwL/OSNuHJzi74usMcYs88Ycw1YDHR0KdMR+Mh+/SnQXETEizFmdanWoTFmgzHmij35I1DWyzFmdWn5HAK8CkwCor0ZXDaSlnrsD0w3xpwFMMb84+UYs7q01KEBitivA4FjXowvyzPGbALOpFCkIzDPWH4EgkSkTGbHlZsTfQhw2Gn6iD3PbRljTBxwHijmleiyh7TUobN+WL9m1XWp1qGI3A2UM8as9mZg2UxaPouVgcoi8r2I/Cgirb0WXfaQljocAzwuIkeANcCz3gktx0jvd2aG8MvsHWRh7lrmrucapqVMbpbm+hGRx4HaQONMjSj7SbEORSQPMA3o7a2Asqm0fBb9sLrvm2D1LH0rIuHGmHOZHFt2kZY67A7MNcZMEZH6wHy7DhMyP7wcwSc5JTe36I8A5Zymy5K8GyqxjIj4YXVVpdQtk9ukpQ4RkQeAV4AOxpgYL8WWXaRWh4WBcGCjiBzAOq63UgfkJZPW/+cVxphYY8x+4E+sxK8saanDfsASAGPMZiA/1s1aVNqk6Tszo+XmRL8VqCQiFUQkAGuw3UqXMiuBJ+zXDwPrjT2iQgFpqEO723kGVpLXY6LJpViHxpjzxpjixphQY0wo1jiHDsaYbb4JN8tKy//zcqzBoYhIcayu/H1ejTJrS0sdHgKaA4hIVaxEf9KrUWZvK4Fe9uj7e4Hzxpjjmb3TXNt1b4yJE5HBQATWaNM5xpjfRWQcsM0YsxKYjdU1tQerJd/NdxFnPWmswzeAW4Cl9jjGQ8aYDj4LOotJYx2qVKSxHiOAliKyE4gHXjTGnPZd1FlLGuvweeADERmG1eXcWxs/14nIIqxDQ8XtcQyjAX8AY8z7WOMa2gJ7gCtAH6/EpX8jpZRSKufKzV33SimlVI6niV4ppZTKwTTRK6WUUjmYJnqllFIqB9NEr5RSSuVgmuhVphORMfZd1xyPKyLym4g8lUn72ygin2bGtrMSEWlv12doJu+nib2f8AzebksRGepm/lwRyXLXCRCR/iKyX0TiRGSjPa+qiHwrIpcdf4v0fv4yq36Vcsi159ErrzsPOK4tXgh4EJghIpeMMXq70NypJdaFqP7rMv9VoID3w/FMREoD7wHvAEuBs/aiN4AgoANwGTiOddfL2HRs/n9Afaw7xymV4TTRK2+Js+/W5LBORBoAnYBsk+hFJL8xRu8gl4mMMVkx4YVx/SIyvzrNrwKsNMasc5q3Mz0bNsZcwLrioVKZQrvulS9dxL5qFICIFBKRd0TkT7t7f7+ITBeRIs4riUheEXlZRHaLSIyIHBGRuZ52IiKB9h3LfhGREva8YBFZbHe5HhORl0Rksn09ecd6ve0u1bp2d+xV4EV7WXER+UhETtuxbnS9/ry97mCXeWNE5JSbfVQXkbV2PLtEpIvLemKv+4+IXBSReVy/XahHIhIkIrPs9xgtIodE5AOXMuEi8oW93YsistRuwaa03TwiMkJE9th/g90i8oSbcp1FZIuIXLXrao2IlBeRMVhXWSvvdEhnrr1Osq57EakpIuvsuj4rIh+LSCmn5aH2Nh4RkRkict7+XIwV68ZAqdVTRxHZZtfRCRGZJCL+9rIxwLd20V/s/fQWEQPcDgyz5220yyfruheRu0RklYicE5FLdp20sJcl67pPS/069iMiPexyF0TkSxEp61KugP1+Dtrb2i8iE+xlb4jIPpGkt98WkT4ick2sSwWrbE4TvfIaEfGzH0XEuptdY+BzpyIFsVpNrwBtgFFAM6yuUmczgLFYN9doj5UwCnnYZ1HgGyAAaGqMcVyXey7QAngOeAqrG/lRD6EvAlZjXbrScavY5UAr4AV7vTzABhEJS7ESPFuIdR3szsBfwGKXL+whwH+AmVjd3Vex7k+fmqnAfcAwO96RJL07XhjwPdY1y3ti3SXvTmCV65e/i7eBf9vxtMP6O84RkfZO2+4JLMPqkn4E63Kfu4ESwCz7PZ/A6rauj9Vln4xYP842Yn0+emDdGrUxsFasa7I7mwRcwqqjBVh19nAK7wMRecSOcwtWF/xYrM/EBLvILGCQ/foxO9Yv7ecT9vuoj9Vl7277VbDquAwwEOtv/DlJb27iKtX6tdUDBmP9DzwF1LLXcexbgBXA08B0rM/waK7fiGYWUIHkd5XsDawyxpxCZX/GGH3oI1MfWPewNm4eb6aynh/Q0C57mz2vij09JIX1NgKfYiWUX7C+ZIs4LQ+3t9HVaV4B4BRwwGleb7vccy7bb23Pb+w0rxDWzT1mOM0zwGA3dXHKzT76Os0rBsQBA+3pvFh3uHrPZVtr7XVDU6iLKODZFJbPx7qLW4DTvEpY14JvZ083sfcTbk+HAQnAEy7bmgdstV/nAY4Cy1LY92Tn+naaPxfr2uqO6YnAOZe/YV07pu72dKg9Pc9lWzuAxSnEIMBB4EOX+X2xfkwVc1cHTuUOAJPdff6cphdh3bWsgIcY0l2/Tvs5DwQ7zRtqb6uAPd3Knu6QQh18B3zkNF3R3n/71P639ZE9HtqiV95yHqhjP+7Dakk/ISKjnQuJSE8R2S4il7AGNH1nL6psPze1n+emsr9SQCRwGmhprOOgDo4u9lWOGcaYq1gtf3e+cJmuC5w0xkQ6rX8Zq7V/XypxefK107ZOA/9g3cISrJZfGayWmbNladjuDuBFEXlGRCq7Wf4AVmsxwdHjAuzHSmCeboXbHCsRfO7US+MHrANqikhe4A7gVuDDNMSYmrrA185/Q2PMFjtG1/r+2mV6J9fr0Z3KwG3AEpf3sh6rlyMjRsI3Az6xP2NpkZb6ddhqjDnrNO0YHxDitO8zJuWbI80GHhKRW+zp3sDfwFdpjFdlcZrolbfEGWO22Y/vjTFvYXXVjrS71xGRzlitls1AV6x7r3e2189vPxcDLrskbneqAVWB+XYSdlYauGiSD6rzdLvNv12my7iZ5yhXNJW4PDnnMn2N6+/Zcbzc9Ta/abnt72Cswwz/Af4Ukb9ExPkujMWBl7B+VDk/KuK5a7k4Vi/DeZd15mL1wpTB+juBNQr9ZqWnvlOqR3ccXdhrSPpe9tvzU+peT6tipK8e0lK/Du7eLyT9f0lt30uwflg8Ynf198LqGYlLR8wqC9NR98qXdmIdO78d6zbAXYGfjDGJxzpFxPXY4WmgkIgUSSXZbwC2AzNF5JQxZpXTshNAYUk+gr6Eh2253uLxOFDSTblS9vtwiMF6f85u5IfACfvZdZ/uYkjCGHMO6/j+EBG5C/gX8LGI/GqM2WnH+znWsVpXno7PnsE6tNAQK0G4+gcobL8u42Z5eqVU3z/f5LYdf6+nsD4vrva7mZdep0lfPaSlfjNs38aYyyKyGKslfxAoT+o9Ziob0Ra98iVHt+hh+7kAVnJ09pjL9Hr7uVdqGzfGvAZMAZaKSDOnRY4R3R0cM0SkANbgvLT4CSgpIvc7rV8Qa9DUd07ljmD1KjjK5MHqSk2vw1jJvqPL/C5uynpkrNPCXsT6v69iz16H9Xf42anHxfE44GFT67FanIFu1tlmjLmGddz/KJBsJL6T1FrbDj8BrUTE8eMBEamDdVz+O08rpZEjzlAP7yUj7le/Dqu1nJb3Cmmr3/Tsu6ibQXyuZgONsMaQ/GiM+SMd+1BZnLbolbf4ici99usA4B6sUcUrjDGOFutaYLqIvIL15d4W63hlImPMnyIyE5giIiWBTVgXLHnYGOPcJe0oP8JOECtEpIUx5kdjTJSIrALes5edAIYDV3DfgnLdZoSIfA98IiIjsFpNL2D9UHnDqejnwCAR2Q7sA54kDafEudlfvIhMAiaLdWret8BDOP2I8EREvrPjiMLqmeiPdWGXLXaRMfbrL0RkDlYrPgTrR89cY8xGN/H8KSLvY50ZMAnrh1N+rNH6lY0xTxpjEkTE0XvwMdaANIP1Q2eRMWYbsAsoJSK97fhOefhxMRVr1HiEiLwO3II1QO834LPU6iAldpzPA/PFOo3zS6wfIBWxrvHwsDHmys3sA2sU/1Zgk4hMwfq83A2cNsbMcRNTqvWbjn2vBSKAhSIyDuviPGWA+40xA5z2+ZOI/I415mGA2y2pbEsTvfKWQKxj72AdbzwIvA/8n1OZGVhfsM9hfbGtxTqdyvViIs/Y6z8JjMDqylybwr4HY42K/1JEmhhjfsHqpnwPeAvrdKzpWMm4ThrfT2es3oL/2rFuAZoZY/Y4lRmL1eX8f1jJ4x2shDaY9PsvVrf/QKyR1Suxu+FTWW8z1nsNxRpJvx1oY4w5AmCM2W3/APs/rNOyCmC1cNcBe9xsz2EQ1qly/YFxwAWsQzGzHQWMMQtFJBrrdMlPsX5g/Mj1sRBLsAZXTsI6bPKRHWsSxpiTItIUq74XYdXlGmBYOlu3bhljPhGRC1inHvbFqqd9WIMrM2L7f4rIfVg/ThyHSHba+/Mk1fpN476NPfblVazPTQmsMzjcXaRqOdb/3+L07ENlfWKM6+FHpXIfe1RzFNYYgZS6m5XKkURkC/CnMaanr2NRGUtb9CpXEpGuWKd//YbVnd4f6/zxVI/9K5WTiHVFx2ZYvVmDUimusiFN9Cq3uox1pTbHNcx/Ax60z89WKjfZinWa3svGmK2+DkZlPO26V0oppXIwPb1OKaWUysE00SullFI5mCZ6pZRSKgfTRK+UUkrlYJrolVJKqRzs/wHBi/2ksUNneQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "threshold_range=np.linspace(0.0,1.,num=30)\n", + "sig_eps_vals_XG=[sel_eff(true_positives_XG,threshold_range[k]) for k in range(len(threshold_range))]\n", + "bkg_eps_vals_XG=[sel_eff(false_positives_XG,threshold_range[k]) for k in range(len(threshold_range))]\n", + "\n", + "\n", + "plt.plot(threshold_range,threshold_range, 'black', linestyle='dashed')\n", + "plt.plot(bkg_eps_vals_XG,sig_eps_vals_XG,'b',label=\"XG Boost ROC Curve\")\n", + "plt.xlabel(\"Background selection efficiency\", fontsize='15')\n", + "plt.ylabel(\"Signal selection efficiency\", fontsize='15')\n", + "pAUC_XG=roc_auc_score(Y_test,output_XG)\n", + "plt.text(0.69,0.1,\"\\n XGBoost AUC {0:.4g}\\n\".format(pAUC_XG), bbox=dict(boxstyle=\"round\", facecolor='blue', alpha=0.10), horizontalalignment='center', verticalalignment='center',fontsize='15')\n", + "plt.legend()\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(8,8)\n", + "\n", + "print(\"pAUC from XG Boost {0}\".format(pAUC_XG))\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'/BDTs/test_'+str(test)+'/roc_comparison_'+str(i)+'.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "metadata": {}, + "outputs": [], + "source": [ + "# save XGBOOST model to file\n", + "pickle.dump(model, open(PATH+\"/XG_\"+str(i)+\"_.pickle.dat\", \"wb\"), protocol=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 264, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(np.arange(dim-1),model.feature_importances_)\n", + "plt.xticks(np.arange(dim-1), features[:-1], rotation=90, fontsize=12);\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(12,6)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'/BDTs/test_'+str(test)+'/significant_features_'+str(i)+'.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 204, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(features)" + ] + }, + { + "cell_type": "code", + "execution_count": 284, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'mu/BDTs/test_1/XG_9'" + ] + }, + "execution_count": 284, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PATH" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/building_blocks/BDT_select.ipynb b/building_blocks/BDT_select.ipynb new file mode 100644 index 0000000..36ddba8 --- /dev/null +++ b/building_blocks/BDT_select.ipynb @@ -0,0 +1,422 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import pickle\n", + "import math\n", + "\n", + "trunc_normal= tf.truncated_normal_initializer(stddev=1)\n", + "normal = tf.random_normal_initializer(stddev=1)\n", + "\n", + "from xgboost import XGBClassifier\n", + "from architectures.data_processing import *\n", + "from architectures.utils.toolbox import *\n", + "from architectures.DNN import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "l_index=1\n", + "l_flv=['e','mu']\n", + "mother_ID=[\"Ds\",\"Dplus\"]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DATA LOADING & PREPROCESSING" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "with open('/disk/lhcb_data/davide/Rphipi/NN_for_selection/'+l_flv[l_index]+l_flv[l_index]+'/'+'data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f:\n", + " data_dict=pickle.load(f, encoding='latin1')\n", + "data_dict[\"Ds_ENDVERTEX_CHI2\"]=data_dict[\"Ds_ENDVERTEX_CHI2\"]/data_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "data_dict[\"Ds_OWNPV_CHI2\"]=data_dict[\"Ds_OWNPV_CHI2\"]/data_dict[\"Ds_OWNPV_NDOF\"]\n", + "data_dict[\"Ds_IPCHI2_OWNPV\"]=data_dict[\"Ds_IPCHI2_OWNPV\"]/data_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "del data_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "del data_dict[\"Ds_OWNPV_NDOF\"]\n", + "\n", + "data_dict[\"phi_ENDVERTEX_CHI2\"]=data_dict[\"phi_ENDVERTEX_CHI2\"]/data_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "#data_dict[\"phi_OWNPV_CHI2\"]=data_dict[\"phi_OWNPV_CHI2\"]/data_dict[\"phi_OWNPV_NDOF\"]\n", + "data_dict[\"phi_IPCHI2_OWNPV\"]=data_dict[\"phi_IPCHI2_OWNPV\"]/data_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "\n", + "del data_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "#del data_dict[\"phi_OWNPV_NDOF\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'protocol' is an invalid keyword argument for this function", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mPATH\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m'/variables_used.pkl'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mbranches_needed\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpickle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprotocol\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;31m#Number of input features\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: 'protocol' is an invalid keyword argument for this function" + ] + } + ], + "source": [ + "task='TEST'\n", + "\n", + "test=0\n", + "i=np.random.randint(6)\n", + "PATH=l_flv[l_index]+'/BDTs/test_'+str(test)+'/NN_'+str(i)\n", + "\n", + "with open(PATH+'/variables_used.pkl', 'rb') as f: \n", + " branches_needed = pickle.load(f)\n", + " \n", + "#Number of input features\n", + "m=data_dict[\"Ds_ConsD_M\"].shape[0]\n", + "branches_needed.pop()\n", + "dim=len(branches_needed)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = extract_array(data_dict, branches_needed, dim, m)\n", + "\n", + "data_mean=data.mean(axis=0)\n", + "data_1=data-data_mean\n", + "data_std=data_1.std(axis=0)\n", + "data_2=data_1/data_std\n", + "data_2.std(axis=0)\n", + "#data_2=data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# NN SELECTION" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "with open(PATH+'/hyper_parameters.pkl', 'rb') as f: \n", + " hyper_dict = pickle.load(f)\n", + " #for key, item in hyper_dict.items():\n", + " # print(key+':'+str(item))\n", + "\n", + "k=hyper_dict[\"k\"]\n", + "LEARNING_RATE=hyper_dict[\"LEARNING_RATE\"]\n", + "BETA1=hyper_dict[\"BETA1\"]\n", + "BATCH_SIZE=hyper_dict[\"BATCH_SIZE\"]\n", + "EPOCHS=hyper_dict[\"EPOCHS\"]\n", + "VAL_PERIOD=hyper_dict[\"VAL_PERIOD\"]\n", + "SEED=hyper_dict[\"SEED\"]\n", + "sizes=hyper_dict[\"sizes\"]\n", + "LAMBD=hyper_dict[\"LAMBD\"]\n", + "PATH=hyper_dict[\"PATH\"]\n", + " \n", + "if not os.path.exists(PATH+'/hyper_parameters.pkl'):\n", + " print(\"No saved sizes dict\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input for propagation (?, 13)\n", + "Logits shape (?, 2)\n", + "Input for propagation (?, 13)\n", + "Logits shape (?, 2)\n" + ] + } + ], + "source": [ + "tf.reset_default_graph()\n", + "model_NN = DNN(dim, sizes,\n", + " lr=LEARNING_RATE, beta1=BETA1, lambd=LAMBD,\n", + " batch_size=BATCH_SIZE, epochs=EPOCHS,\n", + " save_sample=VAL_PERIOD, path=PATH, seed=SEED)\n", + "\n", + "vars_to_train=tf.trainable_variables()\n", + "vars_all = tf.global_variables()\n", + "vars_to_init = list(set(vars_all)-set(vars_to_train))\n", + "init_op = tf.variables_initializer(vars_to_init)\n", + "\n", + "saver = tf.train.Saver()\n", + "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.33)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Evaluate model on test set...\n", + "INFO:tensorflow:Restoring parameters from mu/test_0/NN_4/NN_model.ckpt\n", + "Model restored.\n" + ] + } + ], + "source": [ + "output_dict_NN={}\n", + "batch_size=400\n", + "n_batches = data.shape[0]//batch_size\n", + "\n", + "with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n", + " sess.run(init_op)\n", + " print('\\n Evaluate model on test set...')\n", + " saver.restore(sess,PATH+'/NN_model.ckpt')\n", + " print('Model restored.')\n", + " model_NN.set_session(sess)\n", + " for j in range(n_batches):\n", + " \n", + " small_dataset = data_2[j*batch_size:(j+1)*batch_size]\n", + " output_dict_NN[j] = model_NN.predict(small_dataset)\n", + " \n", + " if data.shape[0]%batch_size != 0:\n", + " output_dict_NN[j+1] = model_NN.predict(data_2[(j+1)*batch_size: data_2.shape[0]-1])\n", + " \n", + " output_NN=np.concatenate([output_dict_NN[i] for i in range(len(output_dict_NN))])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "x_cut=0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "a = data_dict[\"Ds_ConsD_M\"][np.where(output_NN[:,1]>x_cut)[0]]\n", + "b = [data_dict[\"Ds_ConsD_M\"][i] for i in range(len(data_dict[\"Ds_ConsD_M\"]))]\n", + "\n", + "NN_selected=np.array([a[i][0] for i in range(len(a))])\n", + "full = np.array([b[i][0] for i in range(len(b))])\n", + "full=np.delete(full,np.where(full<0))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "full_plot=full/1000\n", + "NN_selected_plot=NN_selected/1000\n", + "plt.hist(full_plot,alpha=0.4,bins=120, range=(full_plot.min(),full_plot.max()),density=True,label='before NN');\n", + "plt.hist(NN_selected_plot,alpha=0.5,bins=120, range=(full_plot.min(),full_plot.max()),density=True,label='after NN');\n", + "plt.legend(fontsize=20)\n", + "\n", + "plt.xlabel('D reconstructed mass (GeV)', fontsize=17)\n", + "plt.ylabel('# events (a.u)', fontsize=17)\n", + "\n", + "fig=plt.gcf();\n", + "fig.set_size_inches(16,10)\n", + "plt.savefig('/home/hep/davide/Rphipi/mu/test_'+str(test)+'/selected_data_NN.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "np.save('/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/'+'sel_data_NN_'+l_flv[l_index]+l_flv[l_index]+'.npy', NN_selected)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# XGBOOST SELECTION" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "PATH=l_flv[l_index]+'/test_'+str(test)+'/XG_'+str(i)\n", + "loaded_model = pickle.load(open(PATH+\"/XG_\"+str(i)+\"_.pickle.dat\", \"rb\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "output_XG=loaded_model.predict_proba(data_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "a = data_dict[\"Ds_ConsD_M\"][np.where(output_XG[:,1]>x_cut)[0]]\n", + "b = [data_dict[\"Ds_ConsD_M\"][0:output_XG.shape[0]][i] for i in range(output_XG.shape[0])]\n", + "\n", + "XG_selected=np.array([a[i][0] for i in range(len(a))])" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "full_plot=full/1000\n", + "XG_selected_plot=XG_selected/1000\n", + "\n", + "plt.hist(full_plot,alpha=0.4,bins=120, range=(full_plot.min(),full_plot.max()),density=True,label='before XG');\n", + "plt.hist(XG_selected_plot,alpha=0.5,bins=120, range=(full_plot.min(),full_plot.max()),density=True,label='after XG');\n", + "plt.legend(fontsize=20)\n", + "plt.xlabel('D reconstructed mass (GeV)', fontsize=17)\n", + "plt.ylabel('# events (a.u)', fontsize=17)\n", + "fig=plt.gcf();\n", + "fig.set_size_inches(16,10)\n", + "plt.savefig('/home/hep/davide/Rphipi/mu/test_'+str(test)+'/selected_data_XG.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "np.save('/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/'+'sel_data_XG_'+l_flv[l_index]+l_flv[l_index]+'.npy', NN_selected)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(range(len(loaded_model.feature_importances_)), loaded_model.feature_importances_)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/building_blocks/BDT_train.ipynb b/building_blocks/BDT_train.ipynb new file mode 100644 index 0000000..efd3b16 --- /dev/null +++ b/building_blocks/BDT_train.ipynb @@ -0,0 +1,755 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import pickle\n", + "import math\n", + "\n", + "from sklearn.metrics import accuracy_score, roc_auc_score\n", + "trunc_normal= tf.truncated_normal_initializer(stddev=1)\n", + "normal = tf.random_normal_initializer(stddev=1)\n", + "\n", + "from xgboost import XGBClassifier\n", + "from architectures.data_processing import *\n", + "from architectures.utils.toolbox import *\n", + "from architectures.DNN import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# IMPORTING THE DATASET" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "l_index=0\n", + "mother_ID=[\"Ds\",\"Dplus\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bkg data amounts to 14066 while signal MC amounts to 1466 Ds and 1974 Dplus samples\n" + ] + } + ], + "source": [ + "MC_Dplus_sig_dict, MC_Ds_sig_dict, data_bkg_dict = load_datasets(l_index)\n", + "\n", + "m_plus=MC_Dplus_sig_dict[\"Dplus_ConsD_M\"].shape[0]\n", + "m_s=MC_Ds_sig_dict[\"Ds_ConsD_M\"].shape[0]\n", + "n=data_bkg_dict[\"Ds_ConsD_M\"].shape[0]\n", + "\n", + "print('Bkg data amounts to {0} while signal MC amounts to {1} Ds and {2} Dplus samples'.format(n,m_s,m_plus))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Normalising the Chi2 vertex fits to the NDoF\n", + "\n", + "MC_Ds_sig_dict[\"Ds_ENDVERTEX_CHI2\"]=MC_Ds_sig_dict[\"Ds_ENDVERTEX_CHI2\"]/MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "MC_Ds_sig_dict[\"Ds_OWNPV_CHI2\"]=MC_Ds_sig_dict[\"Ds_OWNPV_CHI2\"]/MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "MC_Ds_sig_dict[\"Ds_IPCHI2_OWNPV\"]=MC_Ds_sig_dict[\"Ds_IPCHI2_OWNPV\"]/MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "del MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "del MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "#del MC_sig_dict[\"Ds_M\"]\n", + "\n", + "MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_CHI2\"]=MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_CHI2\"]/MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "MC_Dplus_sig_dict[\"Dplus_OWNPV_CHI2\"]=MC_Dplus_sig_dict[\"Dplus_OWNPV_CHI2\"]/MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "MC_Dplus_sig_dict[\"Dplus_IPCHI2_OWNPV\"]=MC_Dplus_sig_dict[\"Dplus_IPCHI2_OWNPV\"]/MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "\n", + "del MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "del MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]=data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "data_bkg_dict[\"Ds_OWNPV_CHI2\"]=data_bkg_dict[\"Ds_OWNPV_CHI2\"]/data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]=data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "del data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "del data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]=data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "#data_bkg_dict[\"phi_OWNPV_CHI2\"]=data_bkg_dict[\"phi_OWNPV_CHI2\"]/data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", + "data_bkg_dict[\"phi_IPCHI2_OWNPV\"]=data_bkg_dict[\"phi_IPCHI2_OWNPV\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "\n", + "#del data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", + "del data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "del MC_Ds_sig_dict[\"phi_M\"]\n", + "del MC_Dplus_sig_dict[\"phi_M\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#Number of input features\n", + "\n", + "dim=len(return_branches(mother_index=1, l_index=l_index))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dim" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Convert data dictionaries to arrays for NN\n", + "\n", + "MC_Ds_sig = extract_array(MC_Ds_sig_dict, return_branches(mother_index=0, l_index=l_index), dim, m_s)\n", + "MC_Dplus_sig = extract_array(MC_Dplus_sig_dict, return_branches(mother_index=1, l_index=l_index), dim, m_plus)\n", + "data_bkg = extract_array(data_bkg_dict, return_branches(mother_index=0, l_index=l_index), dim, n)\n", + "\n", + "plt.hist(MC_Ds_sig[:,dim-1]/1000,alpha=0.5, label='Ds Signal MC',density=True, bins=30);\n", + "plt.hist(MC_Dplus_sig[:,dim-1]/1000,alpha=0.5, label='D+ Signal MC', density=True, bins=30);\n", + "plt.hist(data_bkg[:,dim-1]/1000,alpha=0.5, label='Bkg data',density=True, bins=200);\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('D reconstructed mass (GeV)', fontsize=15)\n", + "plt.legend(fontsize=15)\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(12,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/mu/bdt_train.png', format='png', dpi=100)\n", + "#Cut on Ds Mass\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Cuts on mass\n", + "\n", + "#data_bkg_cut=data_bkg[np.where(data_bkg[:,dim-1]<1930)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#Add 0/1 label for bkg/sig\n", + "\n", + "MC_Dplus_sig_labelled=add_labels(MC_Dplus_sig,signal=True)\n", + "MC_Ds_sig_labelled=add_labels(MC_Ds_sig,signal=True)\n", + "data_bkg_labelled=add_labels(data_bkg,signal=False)\n", + "\n", + "#Merge MC sig and data bkg, shuffle it\n", + "\n", + "data=np.concatenate((data_bkg_labelled,MC_Dplus_sig_labelled), axis =0)\n", + "data=np.concatenate((data,MC_Ds_sig_labelled), axis =0)\n", + "np.random.seed(1)\n", + "np.random.shuffle(data)\n", + "\n", + "#get train size\n", + "train_size=data.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#Strip away the label column and convert it to a one-hot encoding\n", + "\n", + "X=data[:,0:dim]\n", + "Y_labels=data[:,dim].astype(int)\n", + "Y_labels=Y_labels.reshape(train_size,1)\n", + "Y_labels_hot = to_one_hot(Y_labels)\n", + "Y_labels=Y_labels_hot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#Divide the dataset k \"equi populated\" sets\n", + "test=2\n", + "k=6 #number of subsets\n", + "i=0 #number of subset that is train set\n", + "\n", + "X_train, Y_train, X_test, Y_test, X_dict, Y_dict = k_subsets(i, k, X, Y_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "X_mean=X_train.mean(axis=0)\n", + "X_train_1=X_train-X_mean\n", + "X_std=X_train_1.std(axis=0)\n", + "X_train_2=X_train_1/X_std\n", + "\n", + "\n", + "\n", + "X_mean=X_test.mean(axis=0)\n", + "X_test_1=X_test-X_mean\n", + "X_std=X_test_1.std(axis=0)\n", + "X_test_2=X_test_1/X_std\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(14585, 14)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_2.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SETTING UP THE NETWORK" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "task='TRAIN'\n", + "\n", + "PATH=l_flv[l_index]+'/BDTs/test_'+str(test)\n", + "\n", + "if not os.path.exists(PATH):\n", + " os.mkdir(PATH)\n", + "\n", + "if not os.path.exists(PATH+'/variables_used.pickle'):\n", + " with open(PATH+'/variables_used.pickle', 'wb') as handle: \n", + " pickle.dump(return_branches(mother_index=0, l_index=l_index), handle, protocol=2)\n", + "\n", + "PATH=l_flv[l_index]+'/BDTs/test_'+str(test)+'/NN_'+str(i)\n", + "\n", + "if not os.path.exists(PATH):\n", + " os.mkdir(PATH)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "LEARNING_RATE = 0.001\n", + "BETA1 = 0.5\n", + "BATCH_SIZE = 64\n", + "EPOCHS = 50\n", + "VAL_PERIOD = 10\n", + "SEED=1\n", + "LAMBD=0.1\n", + "\n", + "sizes = {\n", + "'dense_layers': [\n", + " #(16, 'bn', 0.8, lrelu, tf.glorot_uniform_initializer()),\n", + " #(8, 'bn', 0.5, lrelu, tf.glorot_uniform_initializer()),\n", + " #(16, 'bn', 1, tf.nn.relu, tf.random_normal_initializer()),\n", + " (200, 'bn', 0.95, tf.nn.relu, tf.random_normal_initializer()),\n", + " (200, 'bn', 0.95, tf.nn.relu, tf.random_normal_initializer()),\n", + " #(200, 'bn', 0.90, tf.nn.relu, tf.glorot_uniform_initializer()),\n", + " (100, 'bn', 0.95, tf.nn.relu, tf.random_normal_initializer()),\n", + " ],\n", + "'n_classes':2,\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input for propagation (?, 14)\n", + "Logits shape (?, 2)\n", + "Input for propagation (?, 14)\n", + "Logits shape (?, 2)\n" + ] + } + ], + "source": [ + "tf.reset_default_graph()\n", + "model_NN = DNN(dim-1, sizes,\n", + " lr=LEARNING_RATE, beta1=BETA1, lambd=LAMBD,\n", + " batch_size=BATCH_SIZE, epochs=EPOCHS,\n", + " save_sample=VAL_PERIOD, path=PATH, seed=SEED)\n", + "\n", + "init_op = tf.global_variables_initializer()\n", + "saver = tf.train.Saver()\n", + "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.13)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Training...\n", + "\n", + " ****** \n", + "\n", + "Training DNN for 50 epochs with a total of 14585 samples\n", + "distributed in 227 batches of size 64\n", + "\n", + "The learning rate set is 0.001\n", + "\n", + " ****** \n", + "\n", + "Evaluating performance on validation/train sets\n", + "At iteration 0, train cost: 2630, train accuracy 0.5969, test accuracy 0.7789\n", + "Average of signal as predicted by NN 0.2796\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'\\n Training...'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mmodel_NN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_session\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msess\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mmodel_NN\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train_2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mX_test_2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mY_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0msave_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msaver\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msess\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPATH\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m'/NN_model.ckpt'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Rphipi/architectures/DNN.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X_train, Y_train, X_test, Y_test)\u001b[0m\n\u001b[1;32m 288\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_accuracy\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 289\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 290\u001b[0;31m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfeed_dict\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 291\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 292\u001b[0m )\n", + "\u001b[0;32m~/miniconda3/envs/deepnet/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m 887\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 888\u001b[0m result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 889\u001b[0;31m run_metadata_ptr)\n\u001b[0m\u001b[1;32m 890\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 891\u001b[0m \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/deepnet/lib/python3.6/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m 1099\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1100\u001b[0m \u001b[0mfeed_dict_tensor\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msubfeed_t\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp_val\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1101\u001b[0;31m \u001b[0mfeed_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_bytes\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msubfeed_t\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0msubfeed_t\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubfeed_val\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1102\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1103\u001b[0m \u001b[0;31m# Create a fetch handler to take care of the structure of fetches.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/deepnet/lib/python3.6/site-packages/tensorflow/python/util/compat.py\u001b[0m in \u001b[0;36mas_bytes\u001b[0;34m(bytes_or_text, encoding)\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mIf\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0mbytes_or_text\u001b[0m\u001b[0;31m`\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0ma\u001b[0m \u001b[0mbinary\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0municode\u001b[0m \u001b[0mstring\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m \"\"\"\n\u001b[0;32m---> 59\u001b[0;31m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_or_text\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_six\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 60\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mbytes_or_text\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mencoding\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_or_text\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbytes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n", + " sess.run(init_op)\n", + " \n", + " print('\\n Training...')\n", + " model_NN.set_session(sess)\n", + " model_NN.fit(X_train_2, Y_train, X_test_2, Y_test)\n", + " \n", + " save_path = saver.save(sess, PATH+'/NN_model.ckpt')\n", + " hyper_dict={\n", + " 'k':k,\n", + " 'LEARNING_RATE':LEARNING_RATE,\n", + " 'BETA1':BETA1,\n", + " 'BATCH_SIZE':BATCH_SIZE,\n", + " 'EPOCHS':EPOCHS,\n", + " 'VAL_PERIOD':VAL_PERIOD,\n", + " 'SEED':SEED,\n", + " 'sizes':sizes,\n", + " 'LAMBD':LAMBD,\n", + " 'PATH':PATH,\n", + " }\n", + " with open(PATH+'/hyper_parameters.pkl', 'wb') as f: \n", + " pickle.dump(hyper_dict, f)\n", + " print(\"Model and hyperparameters saved in path: %s\" % save_path)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "task='TEST'\n", + "\n", + "with open(PATH+'/hyper_parameters.pkl', 'rb') as f: \n", + " hyper_dict = pickle.load(f)\n", + " #for key, item in hyper_dict.items():\n", + " # print(key+':'+str(item))\n", + "\n", + "k=hyper_dict[\"k\"]\n", + "LEARNING_RATE=hyper_dict[\"LEARNING_RATE\"]\n", + "BETA1=hyper_dict[\"BETA1\"]\n", + "BATCH_SIZE=hyper_dict[\"BATCH_SIZE\"]\n", + "EPOCHS=hyper_dict[\"EPOCHS\"]\n", + "VAL_PERIOD=hyper_dict[\"VAL_PERIOD\"]\n", + "SEED=hyper_dict[\"SEED\"]\n", + "sizes=hyper_dict[\"sizes\"]\n", + "LAMBD=hyper_dict[\"LAMBD\"]\n", + "PATH=hyper_dict[\"PATH\"]\n", + " \n", + "if not os.path.exists(PATH+'/hyper_parameters.pkl'):\n", + " print(\"No saved sizes dict\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n", + " \n", + " print('\\n Evaluate model on test set...')\n", + " saver.restore(sess,PATH+'/NN_model.ckpt')\n", + " print('Model restored.')\n", + " model_NN.set_session(sess)\n", + " model_NN.test(X_test_2,Y_test)\n", + " output_NN=model_NN.predict(X_test_2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + " \n", + "plt.suptitle('S/B selection from NN', fontsize='15')\n", + "Ds_mass_MC =[MC_Ds_sig_dict[\"Ds_ConsD_M\"][i][0]/1000 for i in range(m_s)]\n", + "Dplus_mass_MC =[MC_Dplus_sig_dict[\"Dplus_ConsD_M\"][i][0]/1000 for i in range(m_plus)]\n", + "NN_selected = X_dict[i][np.argmax(output_NN,1).astype(np.bool)]\n", + "Ds_mass_sel_NN = NN_selected[:,dim-1]/1000\n", + "Ds_mass_train_NN =X_dict[i][:,dim-1:dim]/1000\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.hist(Ds_mass_MC+Dplus_mass_MC,bins=70, label='MC signal events');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "plt.subplot(1,2,2)\n", + "\n", + "plt.hist(Ds_mass_sel_NN,alpha=0.6,bins=70, label='S selected from test set');\n", + "plt.hist(Ds_mass_train_NN,alpha=0.2,bins=70, label='Test set (S+B)');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf();\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+PATH+'/D_s_NN.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + " \n", + "true_positives_NN=output_NN[:,1][np.where(Y_test==1)[0]]\n", + "false_positives_NN=output_NN[:,1][np.where(Y_test==0)[0]]\n", + "\n", + "true_positives_NN=output_NN[:,1][np.where(Y_test[:,1]==1)]\n", + "false_positives_NN=output_NN[:,1][np.where(Y_test[:,0]==1)]\n", + "plt.hist(true_positives_NN,alpha=0.5,bins=80,density=True,label=\"True positives\");\n", + "plt.hist(false_positives_NN,alpha=0.5,bins=80,density=True, label=\"False positives\");\n", + "plt.xlabel(\"NN BDT output\", fontsize='15')\n", + "plt.ylabel(\"Events (a.u.)\", fontsize='15')\n", + "plt.legend()\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+PATH+'/fp_vs_tp_NN.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SETTING UP XGBOOST" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=3, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n", + " reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n", + " silent=True, subsample=1)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "PATH=l_flv[l_index]+'/BDTs/test_'+str(test)+'/XG_'+str(i)\n", + "if not os.path.exists(PATH):\n", + " os.mkdir(PATH)\n", + "# fit model to training data\n", + "model = XGBClassifier()\n", + "\n", + "model.fit(X_train_2, Y_train[:,1])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "output_XG=model.predict_proba(X_test_2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.suptitle('S/B selection from XGBoost', fontsize='15')\n", + "Ds_mass_MC =[MC_Ds_sig_dict[\"Ds_ConsD_M\"][i][0]/1000 for i in range(m_s)]\n", + "Dplus_mass_MC =[MC_Dplus_sig_dict[\"Dplus_ConsD_M\"][i][0]/1000 for i in range(m_plus)]\n", + "XG_selected = X_dict[i][np.argmax(output_XG,1).astype(np.bool)]\n", + "Ds_mass_sel_XG = XG_selected[:,dim-1]/1000\n", + "Ds_mass_train_XG =X_dict[i][:,dim-1:dim]/1000\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.hist(Ds_mass_MC+Dplus_mass_MC,bins=70, label='MC signal events');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "plt.subplot(1,2,2)\n", + "\n", + "plt.hist(Ds_mass_sel_XG,alpha=0.6,bins=70, label='S selected from test set');\n", + "plt.hist(Ds_mass_train_XG,alpha=0.2,bins=70, label='Test set (S+B)');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf();\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+PATH+'/D_s_XG.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "task='TEST'" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "true_positives_XG=output_XG[:,1][np.where(Y_test[:,1]==1)]\n", + "false_positives_XG=output_XG[:,1][np.where(Y_test[:,0]==1)]\n", + "plt.hist(true_positives_XG,alpha=0.5,bins=80,density=True,label=\"True positives\");\n", + "plt.hist(false_positives_XG,alpha=0.5,bins=80,density=True, label=\"False positives\");\n", + "plt.legend()\n", + "plt.xlabel(\"XGBoost BDT output\", fontsize='15')\n", + "plt.ylabel(\"Events (a.u.)\", fontsize='15')\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+PATH+'/tp_vs_fp_XG.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'true_positives_NN' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0msig_eps_vals_NN\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msig_eff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrue_positives_NN\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mbkg_eps_vals_NN\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbkg_eff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfalse_positives_NN\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0msig_eps_vals_NN\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msig_eff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrue_positives_NN\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 8\u001b[0m \u001b[0mbkg_eps_vals_NN\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbkg_eff\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfalse_positives_NN\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthreshold_range\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'true_positives_NN' is not defined" + ] + } + ], + "source": [ + "threshold_range=np.linspace(0.0,1.,num=30)\n", + "sig_eps_vals_XG=[sig_eff(true_positives_XG,threshold_range[i]) for i in range(len(threshold_range))]\n", + "bkg_eps_vals_XG=[bkg_eff(false_positives_XG,threshold_range[i]) for i in range(len(threshold_range))]\n", + "if task=='TEST': \n", + "\n", + " \n", + " sig_eps_vals_NN=[sig_eff(true_positives_NN,threshold_range[i]) for i in range(len(threshold_range))]\n", + " bkg_eps_vals_NN=[bkg_eff(false_positives_NN,threshold_range[i]) for i in range(len(threshold_range))]\n", + " \n", + " plt.plot(threshold_range,threshold_range, 'black', linestyle='dashed')\n", + " plt.plot(bkg_eps_vals_NN,sig_eps_vals_NN, 'r', label=\"NN ROC Curve\")\n", + " pAUC_NN=roc_auc_score(Y_test,output_NN)\n", + " print(\"pAUC from NN {0}\".format(pAUC_NN))\n", + "\n", + "plt.plot(threshold_range,threshold_range, 'black', linestyle='dashed')\n", + "plt.plot(bkg_eps_vals_XG,sig_eps_vals_XG,'b',label=\"XG Boost ROC Curve\")\n", + "plt.xlabel(\"Background selection efficiency\", fontsize='15')\n", + "plt.ylabel(\"Signal selection efficiency\", fontsize='15')\n", + "pAUC_XG=roc_auc_score(Y_test,output_XG)\n", + "plt.text(0.69,0.1,\"NN AUC {0:.4g}\\n \\n XGBoost AUC {1:.4g}\\n\".format(pAUC_NN,pAUC_XG), bbox=dict(boxstyle=\"round\", facecolor='blue', alpha=0.10), horizontalalignment='center', verticalalignment='center',fontsize='15')\n", + "plt.legend()\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(8,8)\n", + "\n", + "print(\"pAUC from XG Boost {0}\".format(pAUC_XG))\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'/BDTs/test_'+str(test)+'/roc_comparison_'+str(i)+'.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# save XGBOOST model to file\n", + "pickle.dump(model, open(PATH+\"/XG_\"+str(i)+\"_.pickle.dat\", \"wb\"), protocol=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/building_blocks/MC_fitter_unbinned.ipynb b/building_blocks/MC_fitter_unbinned.ipynb new file mode 100644 index 0000000..dfedc96 --- /dev/null +++ b/building_blocks/MC_fitter_unbinned.ipynb @@ -0,0 +1,301 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hep/davide/miniconda3/envs/root_env/lib/ROOT.py:301: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility\n", + " return _orig_ihook( name, *args, **kwds )\n" + ] + } + ], + "source": [ + "import ROOT as r\n", + "import root_numpy as rn\n", + "import pickle\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import array as array\n", + "from architectures.data_processing import *" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "l_index=1\n", + "l_flv=['e','mu']\n", + "MC_Dplus_sig_dict, MC_Ds_sig_dict, _ = load_datasets(l_index)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "Dplus_M=np.array([MC_Dplus_sig_dict[\"Dplus_ConsD_M\"][i][0] for i in range(len(MC_Dplus_sig_dict[\"Dplus_ConsD_M\"]))])\n", + "Ds_M=np.array([MC_Ds_sig_dict[\"Ds_ConsD_M\"][i][0] for i in range(len(MC_Ds_sig_dict[\"Ds_ConsD_M\"]))])\n", + "\n", + "data=np.concatenate((Dplus_M,Ds_M),axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#cut on mass\n", + "cut_indices=[]\n", + "\n", + "lower_mass_cut=1930\n", + "upper_mass_cut=2030\n", + "\n", + "for i in range(len(data)):\n", + " if lower_mass_cut" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_array=np.array([data_cut[i] for i in range(len(data_cut))], dtype=[('D_sel_M', np.float32)])\n", + "\n", + "plt.hist(data_cut,range=(lower_mass_cut,upper_mass_cut),bins=100);\n", + "fig=plt.gcf();\n", + "\n", + "fig.set_size_inches(16,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "rn.array2root(data_array,\n", + " filename='/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_NN_'+l_flv[l_index]+l_flv[l_index]+'.root',\n", + " treename='D_M',\n", + " mode='recreate',\n", + " )\n", + "f=r.TFile('/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_NN_'+l_flv[l_index]+l_flv[l_index]+'.root')\n", + "tree=f.Get(\"D_M\") " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "mass = np.array([0],dtype=np.float32)\n", + "branch = tree.GetBranch(\"D_sel_M\")\n", + "branch.SetAddress(mass)\n", + "\n", + "num_entries=tree.GetEntries()\n", + "m = r.RooRealVar(\"m\",\"m\",lower_mass_cut,upper_mass_cut)\n", + "l = r.RooArgSet(m)\n", + "data_hist = r.RooDataSet(\"data histogram\", \"data\", l)\n", + "\n", + "\n", + "for i in range(num_entries):\n", + " tree.GetEvent(i)\n", + " r.RooAbsRealLValue.__assign__(m, mass[0])\n", + " data_hist.add(l, 1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Creating the signal PDF\n", + "\n", + "\n", + "mean_dplus= r.RooRealVar(\"mean_D+\",\"mean_D+\",1.87,1.77,1.97)\n", + "sigma_dplus = r.RooRealVar(\"sigma_D+\",\"sigma_D+\",0.020,0.,0.2)\n", + "alpha_dplus = r.RooRealVar(\"alpha_D+\",\"alpha_D+\",0.020,-10.,10.)\n", + "n_dplus = r.RooRealVar(\"n_D+\",\"n_D+\",0.020,-50.,50.)\n", + "sig_dplus = r.RooCBShape(\"signal_D+\",\"signal_D+\", m, mean_dplus, sigma_dplus, alpha_dplus, n_dplus)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Creating the signal PDF\n", + "\n", + "mean_ds= r.RooRealVar(\"mean_Ds\",\"mean_Ds\",1.97,1.87,2.07)\n", + "sigma_ds = r.RooRealVar(\"sigma_Ds\",\"sigma_Ds\",0.020,0.,0.2)\n", + "alpha_ds = r.RooRealVar(\"alpha_Ds\",\"alpha_Ds\",0.020,-10.,10.)\n", + "n_ds = r.RooRealVar(\"n_Ds\",\"n_Ds\",0.020,-50.,50.)\n", + "sig_ds = r.RooCBShape(\"signal_Ds\",\"signal_Ds\", m, mean_ds, sigma_ds, alpha_ds, n_ds)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#coef0 = r.RooRealVar(\"c0\",\"coefficient #0\",1.0,-1.,1)\n", + "#coef1 = r.RooRealVar(\"c1\",\"coefficient #1\",0.1,-1.,1)\n", + "#coef2 = r.RooRealVar(\"c2\",\"coefficient #2\",-0.1,-1.,1)\n", + "#bkg = r.RooChebychev(\"bkg\",\"background p.d.f.\",m,r.RooArgList(coef0,coef1,coef2))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#Add 2 sources of signal\n", + "\n", + "# first add the sig and the peak together with fraction fpeak\n", + "ns = r.RooRealVar(\"# of Ds sig events\",\"# of Ds sig events\",100.,0.,40000.)\n", + "#nplus = r.RooRealVar(\"# of Dplus sig events\",\"# of Dplus sig events\",100.,0.,40000.)\n", + "#nbkg = r.RooRealVar(\"# of bkg events\",\"# of bkg events\",100.,0.,40000.)\n", + "# sigpeak(x) = fpeak*sig(x) + (1-fpeak)*bkg(x)\n", + "model = r.RooAddPdf(\"model\",\"two mass peaks\",r.RooArgList(sig_ds),r.RooArgList(ns))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model.fitTo(data_hist,r.RooFit.Extended())\n", + "\n", + "\n", + "\n", + "xframe = m.frame(r.RooFit.Title(\"Fit to \"+l_flv[l_index]+\" data\"))\n", + "\n", + "#bkg_component = r.RooArgSet(bkg)\n", + "data_hist.plotOn(xframe)\n", + "#model.plotOn(xframe,r.RooFit.Components(bkg_component),r.RooFit.LineStyle(2))\n", + "model.plotOn(xframe)\n", + "#sigpeaks.plotOn(xframe)\n", + "xframe.Draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#NB=nbkg.getVal()\n", + "NS=ns.getVal()\n", + "Nplus=nplus.getVal()\n", + "\n", + "if l_index==0:\n", + " Nsig_from_MC=1466+1974\n", + "if l_index==1:\n", + " Nsig_from_MC=5881+9639\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15520.023435679977" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "NS+Nplus" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15520" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Nsig_from_MC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/building_blocks/XGBoost.ipynb b/building_blocks/XGBoost.ipynb new file mode 100644 index 0000000..664c94c --- /dev/null +++ b/building_blocks/XGBoost.ipynb @@ -0,0 +1,565 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import pickle\n", + "import math\n", + "\n", + "from xgboost import XGBClassifier\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score, roc_auc_score\n", + "from architectures.data_processing import *\n", + "from architectures.utils.toolbox import *\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# IMPORTING THE DATASET" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "l_index=1\n", + "mother_ID=[\"Ds\",\"Dplus\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bkg data amounts to 13821 while signal MC amounts to 5881 Ds and 9639 Dplus samples\n" + ] + } + ], + "source": [ + "MC_Dplus_sig_dict, MC_Ds_sig_dict, data_bkg_dict = load_datasets(l_index)\n", + "\n", + "m_plus=MC_Dplus_sig_dict[\"Dplus_ConsD_M\"].shape[0]\n", + "m_s=MC_Ds_sig_dict[\"Ds_ConsD_M\"].shape[0]\n", + "n=data_bkg_dict[\"Ds_ConsD_M\"].shape[0]\n", + "\n", + "print('Bkg data amounts to {0} while signal MC amounts to {1} Ds and {2} Dplus samples'.format(n,m_s,m_plus))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Normalising the Chi2 vertex fits to the NDoF\n", + "\n", + "MC_Ds_sig_dict[\"Ds_ENDVERTEX_CHI2\"]=MC_Ds_sig_dict[\"Ds_ENDVERTEX_CHI2\"]/MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "MC_Ds_sig_dict[\"Ds_OWNPV_CHI2\"]=MC_Ds_sig_dict[\"Ds_OWNPV_CHI2\"]/MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "MC_Ds_sig_dict[\"Ds_IPCHI2_OWNPV\"]=MC_Ds_sig_dict[\"Ds_IPCHI2_OWNPV\"]/MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "del MC_Ds_sig_dict[\"Ds_OWNPV_NDOF\"]\n", + "del MC_Ds_sig_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "#del MC_sig_dict[\"Ds_M\"]\n", + "\n", + "MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_CHI2\"]=MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_CHI2\"]/MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "MC_Dplus_sig_dict[\"Dplus_OWNPV_CHI2\"]=MC_Dplus_sig_dict[\"Dplus_OWNPV_CHI2\"]/MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "MC_Dplus_sig_dict[\"Dplus_IPCHI2_OWNPV\"]=MC_Dplus_sig_dict[\"Dplus_IPCHI2_OWNPV\"]/MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "\n", + "del MC_Dplus_sig_dict[\"Dplus_OWNPV_NDOF\"]\n", + "del MC_Dplus_sig_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]=data_bkg_dict[\"Ds_ENDVERTEX_CHI2\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "data_bkg_dict[\"Ds_OWNPV_CHI2\"]=data_bkg_dict[\"Ds_OWNPV_CHI2\"]/data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]=data_bkg_dict[\"Ds_IPCHI2_OWNPV\"]/data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "del data_bkg_dict[\"Ds_OWNPV_NDOF\"]\n", + "del data_bkg_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]=data_bkg_dict[\"phi_ENDVERTEX_CHI2\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "#data_bkg_dict[\"phi_OWNPV_CHI2\"]=data_bkg_dict[\"phi_OWNPV_CHI2\"]/data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", + "data_bkg_dict[\"phi_IPCHI2_OWNPV\"]=data_bkg_dict[\"phi_IPCHI2_OWNPV\"]/data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "\n", + "#del data_bkg_dict[\"phi_OWNPV_NDOF\"]\n", + "del data_bkg_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "del MC_Ds_sig_dict[\"phi_M\"]\n", + "del MC_Dplus_sig_dict[\"phi_M\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def return_branches(mother_index=None):\n", + "\n", + " branches_needed = [\n", + " #________________________________________\n", + " #D\n", + " #________________________________________\n", + " #D Geometric variables, pT and FD\n", + " \n", + " mother_ID[mother_index]+\"_ENDVERTEX_CHI2\",\n", + " mother_ID[mother_index]+\"_IPCHI2_OWNPV\",\n", + "\n", + " mother_ID[mother_index]+\"_OWNPV_CHI2\",\n", + " mother_ID[mother_index]+\"_IP_OWNPV\",\n", + " mother_ID[mother_index]+\"_DIRA_OWNPV\",\n", + " \n", + " mother_ID[mother_index]+\"_PT\",\n", + " mother_ID[mother_index]+\"_FD_OWNPV\",\n", + " \n", + " #________________________________________\n", + " #PHI\n", + " #________________________________________\n", + " #phi geometric variables, pT and FD\n", + " \n", + " \"phi_ENDVERTEX_CHI2\",\n", + " \"phi_IPCHI2_OWNPV\",\n", + " \n", + " \"phi_PT\",\n", + " \n", + " #phi Reconstructed mass\n", + " \n", + " #\"phi_M\",\n", + " \n", + " #________________________________________\n", + " #PION\n", + " #________________________________________\n", + " #pi Geometric variables and pT\n", + " 'pi_PT',\n", + " \n", + " #________________________________________\n", + " #LEPTONS\n", + " #________________________________________\n", + " #leptons Geometric variables and pT\n", + " \n", + " l_flv[l_index]+\"_plus_PT\",\n", + " l_flv[l_index]+\"_minus_PT\",\n", + " \n", + " \n", + " #D Reconstructed mass\n", + " mother_ID[mother_index]+\"_ConsD_M\",\n", + " ] \n", + " return branches_needed" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Number of input features\n", + "\n", + "dim=len(return_branches(mother_index=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#Convert data dictionaries to arrays for NN\n", + "\n", + "MC_Ds_sig = extract_array(MC_Ds_sig_dict, return_branches(mother_index=0), dim, m_s)\n", + "MC_Dplus_sig = extract_array(MC_Dplus_sig_dict, return_branches(mother_index=1), dim, m_plus)\n", + "data_bkg = extract_array(data_bkg_dict, return_branches(mother_index=0), dim, n)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(MC_Ds_sig[:,dim-1],alpha=0.5,bins=30);\n", + "plt.hist(MC_Dplus_sig[:,dim-1],alpha=0.5,bins=30);\n", + "plt.hist(data_bkg[:,dim-1],alpha=0.5,bins=200);\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(16,8)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#Cut on Ds Mass\n", + "\n", + "#data_bkg_cut=data_bkg[np.where(data_bkg[:,dim-1]>1915)]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#Add 0/1 label for bkg/sig\n", + "\n", + "MC_Dplus_sig_labelled=add_labels(MC_Dplus_sig,signal=True)\n", + "MC_Ds_sig_labelled=add_labels(MC_Ds_sig,signal=True)\n", + "data_bkg_labelled=add_labels(data_bkg,signal=False)\n", + "\n", + "#Merge MC sig and data bkg, shuffle it\n", + "\n", + "data=np.concatenate((data_bkg_labelled,MC_Ds_sig_labelled), axis =0)\n", + "data=np.concatenate((data,MC_Dplus_sig_labelled), axis =0)\n", + "np.random.seed(1)\n", + "np.random.shuffle(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "#get train size\n", + "train_size=data.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#Strip away the label column and convert it to a one-hot encoding\n", + "\n", + "X=data[:,0:dim]\n", + "Y_labels=data[:,dim].astype(int)\n", + "Y_labels=Y_labels.reshape(train_size,1)\n", + "#Y_labels_hot = to_one_hot(Y_labels)\n", + "#Y_labels=Y_labels_hot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#Divide the dataset k \"equi populated\" sets\n", + "\n", + "k=5 #number of subsets\n", + "i=0 #number of subset that is train set\n", + "\n", + "X_train, Y_train, X_test, Y_test, X_dict, Y_dict = k_subsets(i, k, X, Y_labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.528952660100201" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.float((m_s+m_plus)/(train_size))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "#np.argmax(Y_train, axis=1).sum()/Y_train.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_mean=X_train.mean(axis=0)\n", + "X_train_1=X_train-X_mean\n", + "X_std=X_train_1.std(axis=0)\n", + "X_train_2=X_train_1/X_std\n", + "X_train_2.std(axis=0)\n", + "\n", + "\n", + "X_mean=X_test.mean(axis=0)\n", + "X_test_1=X_test-X_mean\n", + "X_std=X_test_1.std(axis=0)\n", + "X_test_2=X_test_1/X_std\n", + "X_test_2.std(axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SETTING UP THE NETWORK" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "XGBClassifier(base_score=0.5, booster='gbtree', colsample_bylevel=1,\n", + " colsample_bytree=1, gamma=0, learning_rate=0.1, max_delta_step=0,\n", + " max_depth=3, min_child_weight=1, missing=None, n_estimators=100,\n", + " n_jobs=1, nthread=None, objective='binary:logistic', random_state=0,\n", + " reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None,\n", + " silent=True, subsample=1)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# fit model to training data\n", + "model = XGBClassifier()\n", + "\n", + "y=Y_train.reshape(Y_train.shape[0])\n", + "\n", + "model.fit(X_train_2, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "output=model.predict_proba(X_test_2)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.suptitle('S/B selection from NN', fontsize='15')\n", + "Ds_mass_MC =[MC_Ds_sig_dict[\"Ds_ConsD_M\"][i][0]/1000 for i in range(m_s)]\n", + "Dplus_mass_MC =[MC_Dplus_sig_dict[\"Dplus_ConsD_M\"][i][0]/1000 for i in range(m_plus)]\n", + "NN_selected = X_dict[i][np.argmax(output,1).astype(np.bool)]\n", + "Ds_mass_sel_NN = NN_selected[:,dim-1]/1000\n", + "Ds_mass_train_NN =X_dict[i][:,dim-1:dim]/1000\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.hist(Ds_mass_MC+Dplus_mass_MC,bins=70, label='MC signal events');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "plt.subplot(1,2,2)\n", + "\n", + "plt.hist(Ds_mass_sel_NN,alpha=0.6,bins=70, label='S selected from test set');\n", + "plt.hist(Ds_mass_train_NN,alpha=0.2,bins=70, label='Test set (S+B)');\n", + "plt.legend(fontsize='15')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf();\n", + "fig.set_size_inches(16,8)\n", + "plt.savefig('/home/hep/davide/D_s_NN.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "true_positives=output[:,1][np.where(Y_test==1)[0]]\n", + "false_positives=output[:,1][np.where(Y_test==0)[0]]\n", + "plt.hist(true_positives,alpha=0.5,bins=80,density=True,label=\"True positives\");\n", + "plt.hist(false_positives,alpha=0.5,bins=80,density=True, label=\"False positives\");\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "pAUC 0.8704610495805598\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "tp=output[:,1][np.where(Y_test==1)[0]]\n", + "fp=output[:,1][np.where(Y_test==0)[0]]\n", + "\n", + "def sig_eff(tp,threshold):\n", + " \n", + " sig_eps = np.where(tp>threshold)[0].shape[0]/tp.shape[0]\n", + " return sig_eps\n", + "\n", + "def bkg_eff(fp,threshold):\n", + " \n", + " bkg_eps = np.where(fp>threshold)[0].shape[0]/fp.shape[0]\n", + " return bkg_eps\n", + "\n", + "threshold_range=np.linspace(0.0,1.,num=30)\n", + "sig_eps_vals=[sig_eff(tp,threshold_range[i]) for i in range(len(threshold_range))]\n", + "bkg_eps_vals=[bkg_eff(fp,threshold_range[i]) for i in range(len(threshold_range))]\n", + "\n", + "\n", + "plt.plot(threshold_range,threshold_range, 'black', linestyle='dashed')\n", + "plt.plot(bkg_eps_vals,sig_eps_vals,'b',label=\"NN ROC Curve\")\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(8,8)\n", + "pAUC=roc_auc_score(Y_test,output[:,1])\n", + "print(\"pAUC {0}\".format(pAUC))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "39.04553343189967" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S=X_test[np.where(output[:,1]>0.6)].shape[0]\n", + "B=X_test[np.where(output[:,1]<0.6)].shape[0]\n", + "S/(np.sqrt(S+B))" + ] + }, + { + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/building_blocks/data_fitter_unbinned.ipynb b/building_blocks/data_fitter_unbinned.ipynb new file mode 100644 index 0000000..2fcaaee --- /dev/null +++ b/building_blocks/data_fitter_unbinned.ipynb @@ -0,0 +1,279 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hep/davide/miniconda3/envs/root_env/lib/ROOT.py:301: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility\n", + " return _orig_ihook( name, *args, **kwds )\n" + ] + } + ], + "source": [ + "import ROOT as r\n", + "import root_numpy as rn\n", + "import pickle\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import array as array" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "l_index=1\n", + "l_flv=['e','mu']\n", + "\n", + "data = np.load('/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_NN_'+l_flv[l_index]+l_flv[l_index]+'.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#cut on mass\n", + "cut_indices=[]\n", + "\n", + "lower_mass_cut=1790\n", + "upper_mass_cut=2030\n", + "\n", + "for i in range(len(data)):\n", + " if lower_mass_cut" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "data_array=np.array([data_cut[i] for i in range(len(data_cut))], dtype=[('D_sel_M', np.float32)])\n", + "\n", + "plt.hist(data_cut,range=(lower_mass_cut,upper_mass_cut),bins=100);\n", + "fig=plt.gcf();\n", + "\n", + "fig.set_size_inches(16,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "rn.array2root(data_array,\n", + " filename='/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_NN_'+l_flv[l_index]+l_flv[l_index]+'.root',\n", + " treename='D_M',\n", + " mode='recreate',\n", + " )\n", + "f=r.TFile('/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_NN_'+l_flv[l_index]+l_flv[l_index]+'.root')\n", + "tree=f.Get(\"D_M\") " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "mass = np.array([0],dtype=np.float32)\n", + "branch = tree.GetBranch(\"D_sel_M\")\n", + "branch.SetAddress(mass)\n", + "\n", + "num_entries=tree.GetEntries()\n", + "m = r.RooRealVar(\"m\",\"m\",lower_mass_cut,upper_mass_cut)\n", + "l = r.RooArgSet(m)\n", + "data_hist = r.RooDataSet(\"data histogram\", \"data\", l)\n", + "\n", + "\n", + "for i in range(num_entries):\n", + " tree.GetEvent(i)\n", + " r.RooAbsRealLValue.__assign__(m, mass[0])\n", + " data_hist.add(l, 1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#Creating the signal PDF\n", + "\n", + "\n", + "mean_dplus= r.RooRealVar(\"mean_D+\",\"mean_D+\",1.87,1.77,1.97)\n", + "sigma_dplus = r.RooRealVar(\"sigma_D+\",\"sigma_D+\",0.020,0.,0.2)\n", + "sig_dplus = r.RooGaussian(\"signal_D+\",\"signal_D+\", m, mean_dplus, sigma_dplus)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Creating the signal PDF\n", + "\n", + "mean_ds= r.RooRealVar(\"mean_Ds\",\"mean_Ds\",1.97,1.87,2.07)\n", + "sigma_ds = r.RooRealVar(\"sigma_Ds\",\"sigma_Ds\",0.020,0.,0.2)\n", + "sig_ds = r.RooGaussian(\"signal_Ds\",\"signal_Ds\", m, mean_ds, sigma_ds)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "coef0 = r.RooRealVar(\"c0\",\"coefficient #0\",1.0,-1.,1)\n", + "coef1 = r.RooRealVar(\"c1\",\"coefficient #1\",0.1,-1.,1)\n", + "coef2 = r.RooRealVar(\"c2\",\"coefficient #2\",-0.1,-1.,1)\n", + "bkg = r.RooChebychev(\"bkg\",\"background p.d.f.\",m,r.RooArgList(coef0,coef1,coef2))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#Add 2 sources of signal\n", + "\n", + "# first add the sig and the peak together with fraction fpeak\n", + "ns = r.RooRealVar(\"# of Ds sig events\",\"# of Ds sig events\",100.,0.,40000.)\n", + "nplus = r.RooRealVar(\"# of Dplus sig events\",\"# of Dplus sig events\",100.,0.,40000.)\n", + "nbkg = r.RooRealVar(\"# of bkg events\",\"# of bkg events\",100.,0.,40000.)\n", + "# sigpeak(x) = fpeak*sig(x) + (1-fpeak)*bkg(x)\n", + "model = r.RooAddPdf(\"model\",\"two mass peaks\",r.RooArgList(sig_ds,sig_dplus,bkg),r.RooArgList(ns,nplus,nbkg))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "model.fitTo(data_hist,r.RooFit.Extended())\n", + "\n", + "\n", + "\n", + "xframe = m.frame(r.RooFit.Title(\"Fit to \"+l_flv[l_index]+\" data\"))\n", + "\n", + "bkg_component = r.RooArgSet(bkg)\n", + "data_hist.plotOn(xframe)\n", + "model.plotOn(xframe,r.RooFit.Components(bkg_component),r.RooFit.LineStyle(2))\n", + "model.plotOn(xframe)\n", + "#sigpeaks.plotOn(xframe)\n", + "xframe.Draw()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "NB=nbkg.getVal()\n", + "NS=ns.getVal()\n", + "Nplus=nplus.getVal()\n", + "\n", + "Nsig_from_MC=5881+9639" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "112.05993156721254" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(Nsig_from_MC)/np.sqrt(NB+Nsig_from_MC)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "invalid syntax (, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m NS+\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" + ] + } + ], + "source": [ + "NS+" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.15" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/dataMC_preselection.ipynb b/dataMC_preselection.ipynb new file mode 100644 index 0000000..f017e85 --- /dev/null +++ b/dataMC_preselection.ipynb @@ -0,0 +1,564 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hep/davide/miniconda3/envs/root_env/lib/ROOT.py:301: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility\n", + " return _orig_ihook( name, *args, **kwds )\n" + ] + } + ], + "source": [ + "import ROOT as r\n", + "import ctypes\n", + "import numpy as np\n", + "from array import array\n", + "import root_numpy as rn\n", + "import matplotlib.pyplot as plt\n", + "import pickle" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "l_index = 0\n", + "data_index = None \n", + "mother_index = None" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "mother_ID=['Ds','Dplus']\n", + "l_flv = ['e','mu']\n", + "data_type = ['MC','data']\n", + "\n", + "def find_file_path(l_index=l_index, mother_index=mother_index, data_index=data_index): \n", + " return \"/disk/lhcb_data/davide/Rphipi/\"+data_type[data_index]+\"/\"+mother_ID[mother_index]+\"_phipi_\"+l_flv[l_index]+l_flv[l_index]+\"/\"+mother_ID[mother_index]+\"_phipi_\"+l_flv[l_index]+l_flv[l_index]+\".root\"\n", + "\n", + "mother_index=0\n", + "\n", + "data = r.TFile(find_file_path(l_index=l_index, mother_index=mother_index, data_index=1))\n", + "MC_Ds = r.TFile(find_file_path(l_index=l_index, mother_index=mother_index, data_index=0))\n", + "\n", + "tree_name_Ds = mother_ID[mother_index]+'_OfflineTree/DecayTree'\n", + "t_data = data.Get(tree_name_Ds)\n", + "t_MC_Ds = MC_Ds.Get(tree_name_Ds)\n", + "\n", + "\n", + "mother_index=1\n", + "\n", + "MC_Dplus = r.TFile(find_file_path(l_index=l_index, mother_index=mother_index, data_index=0))\n", + "\n", + "tree_name_Dplus = mother_ID[mother_index]+'_OfflineTree/DecayTree'\n", + "t_MC_Dplus = MC_Dplus.Get(tree_name_Dplus)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t_MC_Dplus" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def return_branches(mother_index=None):\n", + "\n", + " branches_needed = [\n", + " #________________________________________\n", + " #D\n", + " #________________________________________\n", + " #D Geometric variables, pT and FD\n", + " \n", + " mother_ID[mother_index]+\"_ENDVERTEX_CHI2\",\n", + " mother_ID[mother_index]+\"_ENDVERTEX_NDOF\",\n", + " mother_ID[mother_index]+\"_IPCHI2_OWNPV\",\n", + "\n", + " mother_ID[mother_index]+\"_OWNPV_CHI2\",\n", + " mother_ID[mother_index]+\"_OWNPV_NDOF\",\n", + " mother_ID[mother_index]+\"_IP_OWNPV\",\n", + " mother_ID[mother_index]+\"_DIRA_OWNPV\",\n", + " \n", + " mother_ID[mother_index]+\"_PT\",\n", + " mother_ID[mother_index]+\"_FD_OWNPV\",\n", + " mother_ID[mother_index]+\"_FDCHI2_OWNPV\",\n", + " \n", + " #D Reconstructed mass\n", + " mother_ID[mother_index]+\"_ConsD_M\",\n", + " \n", + " #D Trigger variables\n", + " mother_ID[mother_index]+\"_Hlt1TrackMVADecision_TOS\",\n", + " mother_ID[mother_index]+\"_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\",\n", + " mother_ID[mother_index]+\"_Hlt2Phys_TOS\",\n", + " \n", + " #________________________________________\n", + " #PHI\n", + " #________________________________________\n", + " #phi geometric variables, pT and FD\n", + " \n", + " \"phi_ENDVERTEX_CHI2\",\n", + " \"phi_ENDVERTEX_NDOF\",\n", + " \"phi_IPCHI2_OWNPV\",\n", + " \n", + " #\"phi_OWNPV_CHI2\",\n", + " #\"phi_OWNPV_NDOF\",\n", + " #\"phi_IP_OWNPV\",\n", + " #\"phi_DIRA_OWNPV\",\n", + " \n", + " \"phi_PT\",\n", + " \n", + " #phi Reconstructed mass\n", + " \n", + " \"phi_M\",\n", + " \n", + " #________________________________________\n", + " #PION\n", + " #________________________________________\n", + " #pi Geometric variables and pT\n", + " #\"pi_OWNPV_CHI2\",\n", + " #\"pi_OWNPV_NDOF\",\n", + " #'pi_IP_OWNPV',\n", + " \n", + " 'pi_PT',\n", + " \n", + " #pi PID variables\n", + " \n", + " \"pi_MC15TuneV1_ProbNNpi\",\n", + " \n", + " #________________________________________\n", + " #LEPTONS\n", + " #________________________________________\n", + " #leptons Geometric variables and pT\n", + " \n", + " #l_flv[l_index]+\"_plus_OWNPV_CHI2\",\n", + " #l_flv[l_index]+\"_plus_OWNPV_NDOF\",\n", + " #l_flv[l_index]+\"_minus_OWNPV_CHI2\",\n", + " #l_flv[l_index]+\"_minus_OWNPV_NDOF\",\n", + " #\n", + " #l_flv[l_index]+\"_plus_IP_OWNPV\",\n", + " #l_flv[l_index]+\"_minus_IP_OWNPV\",\n", + " \n", + " l_flv[l_index]+\"_plus_PT\",\n", + " l_flv[l_index]+\"_minus_PT\",\n", + " \n", + " #leptons PID variables\n", + " \n", + " l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index],\n", + " l_flv[l_index]+\"_minus_MC15TuneV1_ProbNN\"+l_flv[l_index],\n", + " \n", + " \n", + " ] \n", + " return branches_needed" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "#Switch on only the branches that you need\n", + "t_data.SetBranchStatus(\"*\",0)\n", + "t_MC_Dplus.SetBranchStatus(\"*\",0)\n", + "t_MC_Ds.SetBranchStatus(\"*\",0)\n", + "\n", + "\n", + "for branch in return_branches(mother_index=0):\n", + " t_data.SetBranchStatus(branch, 1)\n", + " t_MC_Ds.SetBranchStatus(branch, 1)\n", + " \n", + "for branch in return_branches(mother_index=1):\n", + " t_data.SetBranchStatus(branch, 1)\n", + " t_MC_Ds.SetBranchStatus(branch, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#Create a dictionary\n", + "\n", + "#dict ={'branch_name'=[branch_value[event]]}\n", + "\n", + "MC_Ds_tuple_dict = {}\n", + "branches_needed=return_branches(mother_index=0)\n", + "for branch in branches_needed:\n", + " \n", + " MC_Ds_tuple_dict[branch] = rn.root2array(\n", + " \n", + " filenames=find_file_path(l_index, mother_index=0, data_index=0),\n", + " treename = tree_name_Ds,\n", + " branches = branch,\n", + " start=0,\n", + " stop=t_MC_Ds.GetEntries(),\n", + " )\n", + " \n", + "MC_Dplus_tuple_dict = {}\n", + "branches_needed=return_branches(mother_index=1)\n", + "for branch in branches_needed:\n", + " \n", + " MC_Dplus_tuple_dict[branch] = rn.root2array(\n", + " \n", + " filenames=find_file_path(l_index, mother_index=1, data_index=0),\n", + " treename = tree_name_Dplus,\n", + " branches = branch,\n", + " start=0,\n", + " stop=t_MC_Dplus.GetEntries(),\n", + " )\n", + " \n", + "data_tuple_dict = {}\n", + "\n", + "branches_needed=return_branches(mother_index=0)\n", + "for branch in branches_needed:\n", + " \n", + " data_tuple_dict[branch] = rn.root2array(\n", + " \n", + " filenames=find_file_path(l_index,mother_index=0, data_index=1),\n", + " treename = tree_name_Ds,\n", + " branches = branch,\n", + " start=0,\n", + " stop=t_data.GetEntries(),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#HLT1 PRESELECTION\n", + "data_tuple_dict_presel_1={}\n", + "MC_Ds_tuple_dict_presel_1={}\n", + "MC_Dplus_tuple_dict_presel_1={}\n", + "\n", + "for label in return_branches(mother_index=0): \n", + "\n", + " data_tuple_dict_presel_1[label] = data_tuple_dict[label][data_tuple_dict[\"Ds_Hlt1TrackMVADecision_TOS\"]]\n", + " MC_Ds_tuple_dict_presel_1[label] = MC_Ds_tuple_dict[label][MC_Ds_tuple_dict[\"Ds_Hlt1TrackMVADecision_TOS\"]]\n", + "\n", + "for label in return_branches(mother_index=1): \n", + " MC_Dplus_tuple_dict_presel_1[label] = MC_Dplus_tuple_dict[label][MC_Dplus_tuple_dict[\"Dplus_Hlt1TrackMVADecision_TOS\"]]\n", + "\n", + "#RareCharm D2pi l l HLT2 PRESELECTION\n", + "\n", + "data_tuple_dict_presel_2={}\n", + "MC_Ds_tuple_dict_presel_2={}\n", + "MC_Dplus_tuple_dict_presel_2={}\n", + "\n", + "for label in return_branches(mother_index=0):\n", + "\n", + " data_tuple_dict_presel_2[label] = data_tuple_dict_presel_1[label][data_tuple_dict_presel_1[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]]\n", + " MC_Ds_tuple_dict_presel_2[label] = MC_Ds_tuple_dict_presel_1[label][MC_Ds_tuple_dict_presel_1[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]]\n", + "\n", + "for label in return_branches(mother_index=1): \n", + " \n", + " MC_Dplus_tuple_dict_presel_2[label] = MC_Dplus_tuple_dict_presel_1[label][MC_Dplus_tuple_dict_presel_1[\"Dplus_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]]\n", + "\n", + "#PID preselection\n", + "\n", + "#MC_PID_indices=np.where(MC_tuple_dict_presel_2[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "\n", + "data_PID_indices_plus=np.where(data_tuple_dict_presel_2[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "data_PID_indices_minus=np.where(data_tuple_dict_presel_2[l_flv[l_index]+\"_minus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "data_PID_indices_pi=np.where(data_tuple_dict_presel_2[\"pi_MC15TuneV1_ProbNNpi\"]>0.4)\n", + "\n", + "data_PID_indices = np.intersect1d(data_PID_indices_plus,data_PID_indices_minus)\n", + "data_PID_indices = np.intersect1d(data_PID_indices,data_PID_indices_pi)\n", + "data_tuple_dict_presel_3={}\n", + "MC_Ds_tuple_dict_presel_3={}\n", + "MC_Dplus_tuple_dict_presel_3={}\n", + "\n", + "for label in return_branches(mother_index=0):\n", + "\n", + " data_tuple_dict_presel_3[label] = data_tuple_dict_presel_2[label][data_PID_indices]\n", + " MC_Ds_tuple_dict_presel_3[label] = MC_Ds_tuple_dict_presel_2[label]#[MC_PID_indices]\n", + " \n", + "for label in return_branches(mother_index=1):\n", + " MC_Dplus_tuple_dict_presel_3[label] = MC_Dplus_tuple_dict_presel_2[label]#[MC_PID_indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "if l_flv[l_index]=='mu':\n", + " lower_phi_mass = 980\n", + " upper_phi_mass = 1060\n", + " \n", + "if l_flv[l_index]=='e':\n", + " lower_phi_mass = 850\n", + " upper_phi_mass = 1100\n", + " \n", + "#Retrieve mc signal and data bkg events\n", + "\n", + "MC_Dplus_indices=[]\n", + "MC_Ds_indices=[]\n", + "data_indices=[]\n", + " \n", + "for i in range(len(MC_Ds_tuple_dict_presel_3[\"Ds_ConsD_M\"])):\n", + "\n", + " phi_m = MC_Ds_tuple_dict_presel_3[\"phi_M\"][i]\n", + " #fixing a window on the phi mass\n", + " if lower_phi_mass0.4)\n", + "\n", + "data_PID_indices_plus=np.where(data_tuple_dict_presel_2[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "data_PID_indices_minus=np.where(data_tuple_dict_presel_2[l_flv[l_index]+\"_minus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "data_PID_indices_pi=np.where(data_tuple_dict_presel_2[\"pi_MC15TuneV1_ProbNNpi\"]>0.4)\n", + "\n", + "data_PID_indices = np.intersect1d(data_PID_indices_plus,data_PID_indices_minus)\n", + "data_PID_indices = np.intersect1d(data_PID_indices,data_PID_indices_pi)\n", + "data_tuple_dict_presel_3={}\n", + "MC_Ds_tuple_dict_presel_3={}\n", + "MC_Dplus_tuple_dict_presel_3={}\n", + "\n", + "for label in return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0):\n", + " data_tuple_dict_presel_3[label] = data_tuple_dict_presel_2[label][data_PID_indices]\n", + " \n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_3[label] = MC_Ds_tuple_dict_presel_2[label]#[MC_PID_indices]\n", + " \n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0):\n", + " MC_Dplus_tuple_dict_presel_3[label] = MC_Dplus_tuple_dict_presel_2[label]#[MC_PID_indices]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# BKGCAT and True ID preselection for MC Ds" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "#Getting rid of MC Background using BKG_CAT in MC Ds\n", + "#Keeping only low mass and ghost background\n", + "MC_Ds_indices=np.where(MC_Ds_tuple_dict_presel_3[\"Ds_BKGCAT\"]<65)[0]\n", + "\n", + "MC_Ds_tuple_dict_presel_4={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_4[label] = MC_Ds_tuple_dict_presel_3[label][MC_Ds_indices]\n", + " \n", + "#No reflection\n", + "MC_Ds_indices=np.where(MC_Ds_tuple_dict_presel_4[\"Ds_BKGCAT\"]!=30)\n", + "\n", + "MC_Ds_tuple_dict_presel_5={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_5[label] = MC_Ds_tuple_dict_presel_4[label][MC_Ds_indices]\n", + " \n", + "\n", + "#No partially reconstructed\n", + "MC_Ds_indices=np.where(MC_Ds_tuple_dict_presel_5[\"Ds_BKGCAT\"]!=40)\n", + "\n", + "MC_Ds_tuple_dict_presel_6={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_6[label] = MC_Ds_tuple_dict_presel_5[label][MC_Ds_indices]\n", + "\n", + "#Getting rid of MC Background matching mother IDs\n", + "MC_Ds_indices=np.where(np.abs(MC_Ds_tuple_dict_presel_6[\"pi_MC_MOTHER_ID\"])==431)[0]\n", + "\n", + "MC_Ds_tuple_dict_presel_7={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_7[label] = MC_Ds_tuple_dict_presel_6[label][MC_Ds_indices]\n", + " \n", + "MC_Ds_indices=np.where(np.abs(MC_Ds_tuple_dict_presel_7[l_flv[l_index]+\"_plus_MC_MOTHER_ID\"])==333)\n", + "\n", + "MC_Ds_tuple_dict_presel_8={}\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_8[label] = MC_Ds_tuple_dict_presel_7[label][MC_Ds_indices]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# BKGCAT and True ID preselection for MC Dplus" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "#Getting rid of MC Background using BKG_CAT in MC Ds\n", + "#Keeping only low mass and ghost background\n", + "MC_Dplus_indices=np.where(MC_Dplus_tuple_dict_presel_3[\"Dplus_BKGCAT\"]<65)[0]\n", + "\n", + "MC_Dplus_tuple_dict_presel_4={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_4[label] = MC_Dplus_tuple_dict_presel_3[label][MC_Dplus_indices]\n", + " \n", + "#No reflection\n", + "MC_Dplus_indices=np.where(MC_Dplus_tuple_dict_presel_4[\"Dplus_BKGCAT\"]!=30)\n", + "\n", + "MC_Dplus_tuple_dict_presel_5={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_5[label] = MC_Dplus_tuple_dict_presel_4[label][MC_Dplus_indices]\n", + " \n", + "\n", + "#No partially reconstructed\n", + "MC_Dplus_indices=np.where(MC_Dplus_tuple_dict_presel_5[\"Dplus_BKGCAT\"]!=40)\n", + "\n", + "MC_Dplus_tuple_dict_presel_6={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_6[label] = MC_Dplus_tuple_dict_presel_5[label][MC_Dplus_indices]\n", + "\n", + "#Getting rid of MC Background matching mother IDs\n", + "MC_Dplus_indices=np.where(np.abs(MC_Dplus_tuple_dict_presel_6[\"pi_MC_MOTHER_ID\"])==411)[0]\n", + "\n", + "MC_Dplus_tuple_dict_presel_7={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_7[label] = MC_Dplus_tuple_dict_presel_6[label][MC_Dplus_indices]\n", + " \n", + "MC_Dplus_indices=np.where(np.abs(MC_Dplus_tuple_dict_presel_7[l_flv[l_index]+\"_plus_MC_MOTHER_ID\"])==333)\n", + "\n", + "MC_Dplus_tuple_dict_presel_8={}\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_8[label] = MC_Dplus_tuple_dict_presel_7[label][MC_Dplus_indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if l_flv[l_index]=='mu':\n", + " lower_MC = 1.8\n", + " upper_MC = 2.1\n", + " lower_data = 1.0\n", + " upper_data = 3.0\n", + " \n", + "if l_flv[l_index]=='e':\n", + " lower_MC = 1.7\n", + " upper_MC = 2.15\n", + " lower_data = 1.6\n", + " upper_data = 2.4\n", + "\n", + "#plt.suptitle('Reconstructed D_s mass', fontsize=15)\n", + "plt.subplot(1,2,1)\n", + "label=\"Ds_ConsD_M\"\n", + "plt.title('MC', fontsize=15)\n", + "left_h_Ds=[MC_Ds_tuple_dict_presel_8[label][i][0]/1000 for i in range(len(MC_Ds_tuple_dict_presel_8[\"Ds_ConsD_M\"]))]\n", + "label=\"Dplus_ConsD_M\"\n", + "left_h_Dplus=[MC_Dplus_tuple_dict_presel_8[label][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_8[\"Dplus_ConsD_M\"]))]\n", + "plt.hist(left_h_Ds,alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after presel cuts',density=False);\n", + "plt.hist(left_h_Dplus,alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after presel cuts',density=False);\n", + "plt.legend(fontsize='12')\n", + "plt.ylabel('# events (a.u.)', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "\n", + "label=\"Ds_ConsD_M\"\n", + "plt.subplot(1,2,2)\n", + "plt.title('Data', fontsize=15)\n", + "right_h=[data_tuple_dict_presel_3[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_3[\"Ds_ConsD_M\"]))]\n", + "plt.hist(right_h,alpha=0.7,bins=70,range=(lower_data,upper_data), color='green',label='Data after presel cuts',density=False);\n", + "plt.legend(fontsize='12')\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(18,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'_dataMC_after_presel.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [], + "source": [ + "Dplus_bf_phicut=np.float(MC_Dplus_tuple_dict_presel_8[\"Dplus_ConsD_M\"].shape[0])\n", + "Ds_bf_phicut=np.float(MC_Ds_tuple_dict_presel_8[\"Ds_ConsD_M\"].shape[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# PHI MASS CUT" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "if l_flv[l_index]=='mu':\n", + " lower_phi_mass = 980\n", + " upper_phi_mass = 1060\n", + " \n", + "if l_flv[l_index]=='e':\n", + " lower_phi_mass = 850\n", + " upper_phi_mass = 1100\n", + " \n", + "#Cut on phi mass\n", + "\n", + "MC_Dplus_indices=[]\n", + "MC_Ds_indices=[]\n", + "data_indices=[]\n", + " \n", + "for i in range(len(MC_Ds_tuple_dict_presel_8[\"Ds_ConsD_M\"])):\n", + "\n", + " phi_m = MC_Ds_tuple_dict_presel_3[\"phi_M\"][i]\n", + " #fixing a window on the phi mass\n", + " if lower_phi_mass" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if l_flv[l_index]=='mu':\n", + " lower_MC = 1.75\n", + " upper_MC = 2.1\n", + " lower_data = 1.65\n", + " upper_data = 2.15\n", + " \n", + "if l_flv[l_index]=='e':\n", + " lower_MC = 1.7\n", + " upper_MC = 2.15\n", + " lower_data = 1.0\n", + " upper_data = 3.0\n", + " lower_data = 1.6\n", + " upper_data = 2.4\n", + "\n", + "#plt.suptitle('Reconstructed D_s mass', fontsize=15)\n", + "plt.subplot(1,2,1)\n", + "label=\"Ds_ConsD_M\"\n", + "plt.title('MC', fontsize=15)\n", + "left_h_Ds=[MC_Ds_tuple_dict_presel_9[label][i][0]/1000 for i in range(len(MC_Ds_tuple_dict_presel_9[\"Ds_ConsD_M\"]))]\n", + "label=\"Dplus_ConsD_M\"\n", + "left_h_Dplus=[MC_Dplus_tuple_dict_presel_9[label][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_9[\"Dplus_ConsD_M\"]))]\n", + "plt.hist(left_h_Ds,alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after presel cuts',density=False);\n", + "plt.hist(left_h_Dplus,alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after presel cuts',density=False);\n", + "plt.legend(fontsize='12')\n", + "plt.ylabel('# events (a.u.)', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "\n", + "label=\"Ds_ConsD_M\"\n", + "plt.subplot(1,2,2)\n", + "plt.title('Data', fontsize=15)\n", + "right_h=[data_tuple_dict_presel_4[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_4[\"Ds_ConsD_M\"]))]\n", + "plt.hist(right_h,alpha=0.7,bins=70,range=(lower_data,upper_data), color='green',label='Data after presel cuts',density=False);\n", + "plt.legend(fontsize='12')\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(18,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'_dataMC_after_presel_and_phi_mass_cut.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [], + "source": [ + "Dplus_af_phicut=np.float(MC_Dplus_tuple_dict_presel_9[\"Dplus_ConsD_M\"].shape[0])\n", + "Ds_af_phicut=np.float(MC_Ds_tuple_dict_presel_9[\"Ds_ConsD_M\"].shape[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Phi mass cut efficiency on signal \n", + " Dplus eff 0.964, Ds eff 0.9657\n" + ] + } + ], + "source": [ + "eff_phi_cut_Ds=Ds_af_phicut/Ds_bf_phicut\n", + "eff_phi_cut_Dplus=Dplus_af_phicut/Dplus_bf_phicut\n", + "print(\"\\n Phi mass cut efficiency on signal \\n Dplus eff {0:.4g}, Ds eff {1:.4g}\".format(eff_phi_cut_Dplus,eff_phi_cut_Ds))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Boost Cross Checks" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [], + "source": [ + "## pD = ppi + q in D rest frame\n", + "#\n", + "## Lambda D to lab:\n", + "#\n", + "#p_Dplus_lab, _, _, _, = get_4_momenta(MC_Dplus_tuple_dict_presel_9, 'Dplus')\n", + "#p_pi_lab, _, _, _,= get_4_momenta(MC_Dplus_tuple_dict_presel_9, 'pi')\n", + "#p_l_plus_lab, _, _, _, = get_4_momenta(MC_Dplus_tuple_dict_presel_9, l_flv[l_index]+'_plus')\n", + "#p_l_minus_lab, _, _, _, = get_4_momenta(MC_Dplus_tuple_dict_presel_9, l_flv[l_index]+'_minus')\n", + "#\n", + "#beta_D, beta_D_vec = get_boost_D_to_lab(MC_Dplus_tuple_dict_presel_9, mother_index=1)\n", + "#\n", + "#sigma_Es = []\n", + "#sigma_pxs = []\n", + "#sigma_pys = []\n", + "#sigma_pzs = []\n", + "#\n", + "#D_mass = []\n", + "#pi_mass =[]\n", + "#l_mass =[]\n", + "#\n", + "#for j in range(len(MC_Dplus_tuple_dict_presel_9[\"Dplus_ConsD_M\"])):\n", + "# \n", + "#\n", + "# beta_D=r.TVector3(beta_D_vec[:,j][0], beta_D_vec[:,j][1], beta_D_vec[:,j][2])\n", + "# lambda_lab_to_D=r.TLorentzRotation(-beta_D)\n", + "#\n", + "# p_Dplus_lab_r = get_TLorentzVector(p_Dplus_lab, j)\n", + "# p_pi_lab_r = get_TLorentzVector(p_pi_lab, j)\n", + "# p_l_plus_lab_r = get_TLorentzVector(p_l_plus_lab, j)\n", + "# p_l_minus_lab_r = get_TLorentzVector(p_l_minus_lab, j)\n", + "#\n", + "# #boost it\n", + "# p_Dplus_D = lambda_lab_to_D.VectorMultiplication(p_Dplus_lab_r)\n", + "# p_pi_D = lambda_lab_to_D.VectorMultiplication(p_pi_lab_r)\n", + "# p_l_plus_D = lambda_lab_to_D.VectorMultiplication(p_l_plus_lab_r)\n", + "# p_l_minus_D = lambda_lab_to_D.VectorMultiplication(p_l_minus_lab_r)\n", + "#\n", + "# #impose momentum conservation in D lab frame\n", + "# total_p=p_l_minus_D+p_l_minus_D+p_pi_D\n", + "# sigma_E, sigma_px, sigma_py, sigma_pz = [total_p.E()-p_Dplus_D.E(), total_p.Px()-p_Dplus_D.Px(), total_p.Py()-p_Dplus_D.Py(), total_p.Pz()-p_Dplus_D.Pz()]\n", + "# \n", + "# D_mass.append(p_Dplus_D.M2())\n", + "# pi_mass.append(p_pi_D.M2())\n", + "# \n", + "# l_mass.append(p_l_minus_D.M2())\n", + "# l_mass.append(p_l_plus_D.M2())\n", + "# \n", + "# sigma_Es.append(sigma_E)\n", + "# sigma_pxs.append(sigma_px)\n", + "# sigma_pys.append(sigma_py)\n", + "# sigma_pzs.append(sigma_pz) \n", + "# \n", + "#sigma_Es = np.array(sigma_Es)\n", + "#sigma_pxs = np.array(sigma_pxs)\n", + "#sigma_pys = np.array(sigma_pys)\n", + "#sigma_pzs = np.array(sigma_pzs)\n", + "#\n", + "#D_mass = np.sqrt(np.array(D_mass))\n", + "#pi_mass = np.sqrt(np.array(pi_mass))\n", + "#l_mass = np.sqrt(np.array(l_mass))\n", + "#\n", + "#plt.subplot(2,2,1)\n", + "#plt.hist(sigma_Es, bins=50);\n", + "#plt.subplot(2,2,2)\n", + "#plt.hist(sigma_pzs, bins=50);\n", + "#plt.subplot(2,2,3)\n", + "#plt.hist(sigma_pxs, bins=50);\n", + "#plt.subplot(2,2,4)\n", + "#plt.hist(sigma_pys, bins=50);\n", + "#fig = plt.gcf()\n", + "#\n", + "#\n", + "#fig.set_size_inches(16,8)\n", + "#print(D_mass.mean(), pi_mass.mean(), l_mass.mean())" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "#beta_q = get_boost_D_to_q(MC_Dplus_tuple_dict_presel_9, l_index=l_index, mother_index=1)\n", + "#\n", + "#sigma_Es = []\n", + "#sigma_pxs = []\n", + "#sigma_pys = []\n", + "#sigma_pzs = []\n", + "#\n", + "#D_mass = []\n", + "#pi_mass =[]\n", + "#l_mass =[]\n", + "#\n", + "#for j in range(len(MC_Dplus_tuple_dict_presel_9[\"Dplus_ConsD_M\"])):\n", + "# \n", + "# \n", + "# beta_D=r.TVector3(beta_D_vec[:,j][0], beta_D_vec[:,j][1], beta_D_vec[:,j][2])\n", + "# lambda_lab_to_D=r.TLorentzRotation(-beta_D)\n", + "#\n", + "# p_Dplus_lab_r = get_TLorentzVector(p_Dplus_lab, j)\n", + "# p_pi_lab_r = get_TLorentzVector(p_pi_lab, j)\n", + "# p_l_plus_lab_r = get_TLorentzVector(p_l_plus_lab, j)\n", + "# p_l_minus_lab_r = get_TLorentzVector(p_l_minus_lab, j)\n", + "#\n", + "# #boost it from lab to D\n", + "# p_Dplus_D = lambda_lab_to_D.VectorMultiplication(p_Dplus_lab_r)\n", + "# p_pi_D = lambda_lab_to_D.VectorMultiplication(p_pi_lab_r)\n", + "# p_l_plus_D = lambda_lab_to_D.VectorMultiplication(p_l_plus_lab_r)\n", + "# p_l_minus_D = lambda_lab_to_D.VectorMultiplication(p_l_minus_lab_r)\n", + "# \n", + "# beta_q_r=r.TVector3(0,0, beta_q[j])\n", + "# lambda_D_to_q=r.TLorentzRotation(beta_q_r)\n", + "#\n", + "# #boost it from D to q\n", + "# p_Dplus_q = lambda_D_to_q.VectorMultiplication(p_Dplus_D)\n", + "# p_pi_q = lambda_D_to_q.VectorMultiplication(p_pi_D)\n", + "# p_l_plus_q = lambda_D_to_q.VectorMultiplication(p_l_plus_D)\n", + "# p_l_minus_q = lambda_D_to_q.VectorMultiplication(p_l_minus_D)\n", + "#\n", + "# #impose momentum conservation in D lab frame\n", + "# total_p=p_l_minus_q+p_l_minus_q+p_pi_q\n", + "# sigma_E, sigma_px, sigma_py, sigma_pz = [total_p.E()-p_Dplus_q.E(), total_p.Px()-p_Dplus_q.Px(), total_p.Py()-p_Dplus_q.Py(), total_p.Pz()-p_Dplus_q.Pz()]\n", + "#\n", + "# sigma_Es.append(sigma_E)\n", + "# sigma_pxs.append(sigma_px)\n", + "# sigma_pys.append(sigma_py)\n", + "# sigma_pzs.append(sigma_pz) \n", + "#\n", + "# D_mass.append(p_Dplus_D.M2())\n", + "# pi_mass.append(p_pi_D.M2())\n", + "# \n", + "# l_mass.append(p_l_minus_D.M2())\n", + "# l_mass.append(p_l_plus_D.M2())\n", + "# \n", + "# \n", + "#sigma_Es = np.array(sigma_Es)\n", + "#sigma_pxs = np.array(sigma_pxs)\n", + "#sigma_pys = np.array(sigma_pys)\n", + "#sigma_pzs = np.array(sigma_pzs)\n", + "#\n", + "#D_mass = np.sqrt(np.array(D_mass))\n", + "#pi_mass = np.sqrt(np.array(pi_mass))\n", + "#l_mass = np.sqrt(np.array(l_mass))\n", + "#\n", + "#plt.subplot(2,2,1)\n", + "#plt.hist(sigma_Es, bins=50);\n", + "#plt.subplot(2,2,2)\n", + "#plt.hist(sigma_pzs, bins=50);\n", + "#plt.subplot(2,2,3)\n", + "#plt.hist(sigma_pxs, bins=50);\n", + "#plt.subplot(2,2,4)\n", + "#plt.hist(sigma_pys, bins=50);\n", + "#fig = plt.gcf()\n", + "#\n", + "#\n", + "#fig.set_size_inches(16,8)\n", + "#print(D_mass.mean(), pi_mass.mean(), l_mass.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cos theta_l before cut on phi mass" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [], + "source": [ + "costheta_Dplus_b=get_costheta_list(MC_Dplus_tuple_dict_presel_8, l_index=l_index, mother_index=1)\n", + "costheta_Ds_b=get_costheta_list(MC_Ds_tuple_dict_presel_8, l_index=l_index, mother_index=0)\n", + "costheta_MC_b=np.concatenate((costheta_Dplus_b,costheta_Ds_b),axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [], + "source": [ + "costheta_data_b=get_costheta_list(data_tuple_dict_presel_3, l_index=l_index, mother_index=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAHVCAYAAAAJnF2uAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3X2UX1V9L/73xoSHQn9LK7QgA0a9S3lIckdMBEGQQF0gYLi2SMCHkhrkhovXQq/eiv0JlbY3dpmfWEsx0mKTSguh0EIsUEQIFaoYAgwhBLC1RAhUQQoqIiQk+/dHhrmZZCaZJJPZ8/B6rZWV+Z5z5nw/Z84k+7y/e599Sq01AAAA0MJOrQsAAABg7BJKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaGdfqjffcc886YcKEVm8PwChzzz33/LjWulfrOkYybTMAg2mgbXOzUDphwoQsXbq01dsDMMqUUn7QuoaRTtsMwGAaaNts+C4AAADNCKUAAAA0I5QCAADQTLN7SvuyZs2arFq1Ki+++GLrUthKu+66azo6OjJ+/PjWpQAAsIO5bmdD25sFhlUoXbVqVX75l385EyZMSCmldTkMUK01zzzzTFatWpU3vOENrcsBAGAHc93OKwYjCwyr4bsvvvhiXvva1/rFHmFKKXnta1/rkzIAgDHCdTuvGIwsMKxCaRK/2COU8wYAMLa4/uMV2/u7MOxCKQAAAGPHsLqndGOz5t89qPu7fObULW5TSskHP/jBXHHFFUmSl19+Ofvss08OPfTQ/OM//mOS5KabbsqFF16Yl156KWvWrMkxxxyTSy65pNd+5s+fn09+8pPp6OjI2rVrs88+++TCCy/M4YcfPqBau7q68uSTT+aEE07YyqP8v44++ujMnTs3U6ZM2eZ9AADAlozl6/b+vOpVr8qkSZNSSump9bzzzstOO22+X3CPPfbI888/v13vffvtt2fnnXfermOYMGFCli5dmj333HO7ahkIPaUb2X333bN8+fL84he/SJLccsst2XfffXvW33XXXTn33HNz9dVX5/77788DDzyQgw8+uM99zZgxI/fdd1+WLVuWz372s3n/+9+fhx56aEB1dHV15cYbb9z+AwIAgFFouFy3z5w5M7fffvsmy3fbbbd0dXXlvvvuy6233prbbrstn/3sZ7f+QLfB7bffnm9/+9tD8l6DQSjtwwknnJAbbrghSXLllVfm9NNP71l38cUX54ILLsiECROSrP8E5Oyzz97iPg877LCcc845ueyyy3r2c9BBB+W//tf/mlNPPbXXtqtXr84FF1yQhQsXprOzMwsXLswf/MEfZO7cuT3bTJw4MStXrszKlStzwAEH5MMf/nAOPvjgnHjiifn5z3++yfsvWrQohxxySCZOnJjp06fnpz/96Vb/XAAAYDhpfd0+UK95zWty2WWX5ZJLLkmtNfPnz8/JJ5+cY489Nm9605vy6U9/epPvuf3223PSSSf1vP7Yxz6W+fPnJ0k++clP9tR03nnn9fq+lStXZt68ebn44ovT2dmZO+64IzNnzsw111zTs80ee+zR8x5HHXVU3vve9+bNb35zZs6cmXXr1m1Sy1/8xV9k8uTJOeigg/Lbv/3bWbNmzTb9HPojlPbhtNNOy1VXXZUXX3wxy5Yty6GHHtqzbtmyZXnb2962Tfs95JBD8vDDDydJPv/5z+e+++7L/fffn8svv7zXdjvvvHMuuuiizJgxI11dXZkxY8Zm9/vII4/knHPOyYMPPpjXve51+dM//dNe63/0ox9lzpw5ueOOO7J8+fIcccQR+ZM/+ZNtOgYAABguWl+3b419990348ePz1NPPZUkWbJkSa699tqsWLEiX//61wfcs/nUU0/lxhtvzIMPPpj7778/F110Ua/1EyZMyOzZs3Peeeelq6srRx555Gb3t2TJklxyySV5+OGH8x//8R+56qqreq2///77c9111+Wee+7JihUrsttuu/WE48EilPZh8uTJWblyZa688srtuqdzY7XWXu/x4Q9/OH/913+93fvdb7/9cthhhyVJTj/99Nx555291t9xxx3513/91xxxxBHp7OzMggUL8sQTT2z3+wIAQEutrttvvvnmdHZ2prOzM4sWLcqZZ56Zzs7OXqF4S/t997vfnVe/+tXZZZdd8r73vW+Ta/j+/Mqv/ErGjx+fWbNm5ZprrsnOO++8lUfX29vf/va8/vWvz0477ZQZM2ZsUsctt9yS++67L1OnTk1nZ2duvfXWPPbYY9v1nhsTSvsxffr0fOITn+g1BCBJJk2alHvvvXeb9nnfffflwAMPTJLccMMNOfvss3P//fdn6tSpefnllzf7vTvttFOvrvQNnwO08RTMG7+uteY973lPurq60tXVlRUrVgz6pxsAANBCi+v24447rufaevr06fnLv/zLdHV15bvf/W6/+3zyySezdu3a/Oqv/mqSLV/D93f9P27cuHz3u9/NKaeckptuuinHH3/8Fo9nw32tW7cuq1ev7vd9+8oSs2bN6jneRx55JH/4h3+4xffcGkJpPz7ykY/kwgsvzKRJk3otP/fcc3PRRRflBz/4QZL1J3XevHlb3N+SJUty6aWX5qMf/WjWrVuXJ598MtOmTcvnPve5/PSnP81zzz3Xa/vddtstL7zwQs/rjo6Onn9UXV1defTRR3vWPfbYY1myZEmSZOHChTniiCN67evII4/M4sWLe2p+8cUX82//9m8D/VEAAMCw1fq6fSCee+65zJ49O+ecc05P6Lvlllvyk5/8JKtXr8511123yTV8R0dHHnzwwbz00kv52c9+lltvvTVJ8vzzz+f555/PCSeckC984Qt9Bu++ssQ999yTZH3I3vCe0CVLluSxxx5LrTV/93d/t0kd7373u3P11VfnP//zP5MkP/3pT/P4449v9c9gc4b1I2EGMhX0jtLR0ZGPf/zjmyw//PDDM3fu3JxyyilZvXp11q5dm2OPPbbPfSxcuDD/8i//knXr1mXvvffOwoULc+CBB2bNmjWZMWNGfv7zn2ft2rX5H//jf2wy1fK0adPyf/7P/8nkyZPz+7//+zn11FOzYMGCHHzwwTnssMPy5je/uWfbt7zlLfmzP/uz3HvvvXn961+fL3zhC732tffee+eyyy7L9OnTk6z/B/lHf/RH+S//5b9s748JAADG9HV7f37xi1+ks7Oz55EwH/jAB/K7v/u7Pevf/va35zd/8zfz6KOP5tRTT93k8S1vfOMbc/LJJ+eAAw7IW97ylrz1rW9Nsj4UTp8+PS+//HLWrl27ybV/krz3ve/Nb/zGb+Taa6/NJZdcktmzZ+eEE07IzTffnOOPPz677757z7ZTp07Nxz72sTz88MM5/PDDc9ppp/XaV2dnZ84///wceeSRGTduXHbaaad8+ctfzn777Tegn8NAlA3HNQ+lKVOm1KVLl/Za9tBDD/V0kzMwK1euzEknnZTly5e3LsX5A5oqpdxTa/Vg5u3QV9sM0BfXfdtn/vz5Wbp06SbPTB1qt99+e+bOndvzXNft0dfvxEDbZsN3AQAAaGZYD99lyyZMmDAsekkBAICBmTlzZmbOnNm6jBx99NE5+uijW5chlAIjz6z5d2+yrOW9LEAfFs/ZdNm084e+DgCGPcN3AQAAaEYoBQAAoBnDdwG2l2GKAADbbHiH0r4u9LbHAC4SSyn54Ac/mCuuuCJJ8vLLL2efffbJoYce2jNV8k033ZQLL7wwL730UtasWZNjjjlmk+mc58+fn09+8pPp6OjI2rVrs88+++TCCy/c5PlDGxus6aG/+MUv5qyzzsov/dIvbdP3D+b00AAAjHINrts39Ad/8AfZY4898olPfKLfba677rq8+c1vzkEHHTSo+93YxRdfnC9/+cuZOnVq/uZv/mbA3zfYVq5cmW9/+9v5wAc+0KyGgTJ8dyO77757li9fnl/84hdJkltuuSX77rtvz/q77ror5557bq6++urcf//9eeCBB3LwwQf3ua8ZM2bkvvvuy7Jly/LZz34273//+/PQQw8NyXF88YtfzAsvvDAk7wUAAMPdddddlxUrVuzw9/nKV76S2267bcCBdO3atTukjpUrV+Zv//Zvd8i+B5tQ2ocTTjghN9xwQ5LkyiuvzOmnn96z7uKLL84FF1yQCRMmJEle9apX5eyzz97iPg877LCcc845ueyyy5Ksn375d37ndzJ16tS85S1vyZ133rnJ98ycOTPXXHNNz+s99tgjSbJq1aocddRR6ezszMSJE/Otb32r1/d96UtfypNPPplp06Zl2rRpvb43Sa655pqeKahnzpyZ2bNn59BDD80b3/jG/P3f//0mdTz//PM5/fTTM3ny5Bx00EG5+uqrt3i8AACwI11wwQV505velHe961155JFHepZ/5StfydSpU3PQQQflpJNOys9+9rN8+9vfzqJFi/LJT34ynZ2d+f73v9/ndn25//778853vjNvfOMbe41mvOiiizJp0qQccMAB+dSnPpUkmT17dv793/8973nPe3LxxRfnxz/+cY477rhMnDgxhxxySO65554k63tgP/zhD+dd73pXfuu3fisvv/xyPvaxj2Xy5Mk54IAD8qd/+qd91vKVr3wlBx54YDo7O/PBD34wSf+Z4VOf+lTuuOOOdHZ25uKLL96On/SOJ5T24bTTTstVV12VF198McuWLcuhhx7as27ZsmV529vetk37PeSQQ/Lwww/3vH7ppZdy991356tf/Wo+8pGPDHg/f/u3f5sTTzwxXV1deeCBB3LIIYf0Wv/xj388r3vd67J48eIsXrx4i/t77LHHctddd+XWW2/N7NmzN+lhveCCC3LiiSdm2bJl+fa3v53zzz8/P/3pTwdcLwAADKbvfOc7+Yd/+IesWLEiN954Y+6++/8+Lu60007L3XffnRUrVqSzszNf+cpXcvjhh2f69On5/Oc/n66urrzpTW/qc7u+LFu2LLfddlvuueeezJkzJ4899lgWLVqUVatWZdmyZVmxYkWWL1+eW265JfPmzeu5Dj/vvPPy6U9/OkcddVSWL1+eiy++OB/60Id69rtixYrccsst+Zu/+Ztceuml2XvvvbNs2bLcf//9WbBgQb73ve/1quPee+/N3Llz853vfCddXV358z//883+jD73uc/lyCOPTFdXV84777zt+GnveMP7ntJGJk+enJUrV+bKK6/MCSecMGj7rbX2en3qqacmSY444oi8+OKLeeqppwa0n8MOOyyzZs3KL37xi7z3ve/d5pD8ilNOOSWllLzhDW/IAQcckOXLl/da/41vfCPf+MY3Mnfu3CTJmjVr8thjj2XixInb9b4AALAt7rjjjrzvfe/LLrvskl122SXTp0/vWbdkyZJ85jOfyQsvvJCf/exnOfbYY/vcx0C3O/nkk7Pzzjtn5513zrHHHpu77ror3/rWt/KNb3wjb33rW5OsH1n46KOPbvK9d955Z08v6rve9a48//zzefrpp5Mk06dPz84775xk/fX29773vZ4ez5/85Cf5/ve/nze/+c09+7r11ltz6qmn5tWvfnWS9Pw9Ggil/Zg+fXo+8YlP5Pbbb88zzzzTs3zSpEm59957c8ABB2z1Pu+7774ceOCBPa9LKb3Wb/x6p512yrp165Ik69aty+rVq5MkRx11VP75n/85N954Y84888yce+65OeOMMzb73hsG4hdffHGz77vx61prFi1alDe96U2bfQ8AABgKG1+vbuiMM87IzTffnEmTJmX+/Pm5/fbbt2u7vq6Va635zGc+k1mzZm3rIWT33Xfv+brWmi9/+cv9BuPN6S8zjCSG7/bjIx/5SC688MJMmjSp1/Jzzz03F110UX7wgx8kWX/i582bt8X9LVmyJJdeemk++tGP9ix75ZOQ73znO9l1112z11579fqejo6OnnHnN9xwQ9asWZMkefzxx7P33nvnzDPPzKxZs3oNV3jFbrvt1msY7mtf+9o89NBDqbXmuuuu67Xttddem1prVq5cmUceeWSTHtDjjjsuX/7yl3teb9yTCgAAQ+md73xnrrvuurz00kt54YUX8vWvf71n3UsvvZRf+7Vfy9q1a3tN9LPx9XF/221s0aJFWb16dZ577rnceuutOfTQQ3Pcccflr/7qr3omR/3Rj37U0wO6oSOPPDJXXXVVkvW9u3vssccm1/zJ+uvtyy67rGfSo0cffXSTW+qOPfbYXH311XnuueeSpOfv/jLDxsc7nA3vntKGz/nr6OjIxz/+8U2WH3744Zk7d25OOeWUrF69OmvXru33E42FCxfmX/7lX7Ju3brsvffeWbhwYa+e0vHjx+ftb397nnvuuXz1q1/d5Ptnz56dE044ITfffHOOP/74nk9Tbr311sydOzfjx4/PHnvs0ef3zpo1K9OmTcv++++fxYsXZ86cOTnuuOOy33775a1vfWuef/75Xsf6jne8I0899VQuvfTS7Lbbbr329Yd/+Ic5++yzc+CBB2bcuHHp6OjITTfdNLAfJAAAo98QX7e/4x3vyH/7b/8tBx10UDo6OjJ16tSedZ/97Gfztre9LR0dHZkyZUrPBEYzZszImWeemS984Qu59tpr+91uY5MmTcoxxxyTJ554Iueff37233//7L///lmxYkUOOeSQ7Lzzztlll11y5ZVXbhI4//iP/zgf+MAHcuWVV2bcuHH52te+1ud7nHPOOVm5cmUOPvjg7Lzzznn1q1/dK2gn6+en+V//63/lsMMOy6677ppJkybla1/7Wr+ZobOzM6tXr87EiRMza9asYX1fadn4PsehMmXKlLp06dJeyx566KFeoW00O/roozN37txMmTKlaR0zZ87MSSedlFNOOWW79zWWzh9tzZq/6eiAy2dO7WPLIdLXs9kafqg2VpVS7qm1tv1PdYTrq23eZv5dwKjmuo+N9fU7MdC22fBdAAAAmhnew3dHsf5upB5q8+fPb10CAAAwhg27ntJWw4nZPs4bAMDY4vqPV2zv78KwCqW77rprnnnmGb/gI0ytNc8880x23XXX1qUAADAEXLfzisHIAsNq+G5HR0dWrVrV53TKDG+77rprOjo6WpcBAMAQcN3OhrY3CwyrUDp+/Pi84Q1vaF0GAACwGa7bGUzDavguAAAAY4tQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNDKvnlAK0Mmv+3Zssu3zm1AaVAACMLXpKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGjG7LsAI5yZgwGAkWyLPaWllK+WUp4qpSzvZ30ppXyplLKilHJfKeWQwS8TANgWpZSVpZQHSildpZSlresBgI0NZPju/CTHb2b9byR5fZKDk8xK8lfbXxYAMIim1Vo7a61TWhcCABvbYiittX4ryX9uZpMTk1xR17s3ybhSyn6DVSAAAACj12BMdNSR5PENXq/qXgYAtFeT3NI9hPd/bryylHJWKWVpKWXp008/3aA8AMa6IZ3oqJRyVpKzkmT//fcfyrcGGJ4Wz+l7+bTzh7YORrN31Fp/WEr51ST/VEp5uNZ6yysra62XJbksSaZMmVJbFQnA2DUYPaWrkmw4XLeje9kmaq2X1Vqn1Fqn7LXXXoPw1gDA5tRaf9j991NJrkliamYAhpXB6Cm9McmHkvxd98y762qtj2/hewCa6OvxKTBalVJ2T1JrrS90f318ki80LgsAetliKC2lXJnk6CR7llJWJbkwyfgkqbXOS3JtkmmllBVJVif57R1WLQCwNX4tyXWllJrkl5IsTHJ925IAoLcthtJa6+lbWF+TnDNoFQEMA9OfXZAs/ubg7rS/+0dhB6m1/nuSya3rAIDNGYx7SgEAAGCbCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzYxrXQDAYJg1/+7WJQAAsA30lAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAMx4JA4wsi+dk+rNP9Fq06DVnNCoGAIDtpacUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGbMvgswhK7vemKTZSd37tugEgCA4UFPKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA045EwwJCbNf/uTZZdPnNqg0rWm/7sgsHf6eI5fT7+pS99bbfoB3c3/ZkAAAwVPaUAAAA0I5QCAADQjFAKAABAM+4pBcaUHXL/6A4w/dkFyeJv9l447fw2xQAA7EB6SgEAAGhGTykwbPU1S+/0Zwc2oy0AACODnlIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoZ17oAgB1h+rMLWpcAAMAA6CkFAACgGaEUAACAZgzfBejH9V1PbLLs5M59B7wtAABbpqcUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGbMvgs0N/3ZBcnib/ax5teHvBYAAIaWnlIAAACaEUoBAABoRigFAACgGfeUAiPe9GcXtC4BAIBtNKCe0lLK8aWU5aWUh0opn+pj/d6llFtLKStKKd8rpcwe/FIBgK1VSnlVKeW+Uso/tq4FAPqyxVBaStklybwk70kyOckppZRDNtrsY0mW1loPSnJEks+VUnYb7GIBgK32O0keal0EAPRnIMN3D03yYK318SQppSxMcmKSezfYZlWSyaWUkmSPJD9O8tIg1wowplzf9USv14t+cHejShipSikdWd9m/3GS321cDgD0aSDDdzuSPL7B61Xdyzb0F0kOSvJkkgeS/E6tdd3GOyqlnFVKWVpKWfr0009vY8kAwAB9Mcn/TrJJm/wKbTMArQ3W7LvnJ1mW5HVJOpNcUkr5fzbeqNZ6Wa11Sq11yl577TVIbw0AbKyUclKSp2qt92xuO20zAK0NJJSuSrLfBq87updt6Mgkf1fX+7ckj2Z9zykA0MYRSaaXUlYmuSrJMaWUK9qWBACbGkgoXZJkYimlo5QyPsmMJDdttM33kxybJKWUX8v6QLpyEOsEALZCrfX8WmtHrXVCktOS3FZr/VDjsgBgE1uc6KjW+mIp5ewkN2d9iL2i1rr0lce+1FrnJbkoyRWllIeSvCrJZ2qtP9yBdQMAADAKDGT23dRab0xy40bL5m3w9Q+T/PrglgYADIZa6+1Jbm9cBgD0aUChFGBbzZrvMSYAAPRvsGbfBQAAgK0mlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0My41gUA9Gf6swtalwAAwA6mpxQAAIBmhFIAAACaEUoBAABoxj2lwI6zeE6mP/tEr0WLXnNGo2IAABiO9JQCAADQjFAKAABAM0IpAAAAzbinFBhSnj0KAMCGhFKArXB91xNb3ggAgAEzfBcAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZsy+CzAKzZp/d5/LL585dYgrAQDYPD2lAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADRj9l2AEWz6sws2WbboNWc0qAQAYNsIpcBW6+txIx41AgDAtjB8FwAAgGaEUgAAAJoxfBdghOjr/lEAgJFOTykAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAM0IpAAAAzQilAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQzrnUBALQ1a/7dmyy7fObUBpUAAGORnlIAAACa0VMKDI7Fc1pXAADACKSnFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKCZAU10VEo5PsncJK9KsqDW+rk+tjk6yeeT7JzkJ7XWowaxTmCUu77ridYlwKhTStk1yZ1Z397vnuSGJOfVWmvTwgBgA1sMpaWUXZLMS3Jkkh8m+U4p5Ru11ns32GbvJH+e5Nha6w9LKXvuqIIBgAF7Kcm7aq0/L6WMz/qAOi3JbW3LAoD/ayDDdw9N8mCt9fFa65okC5OcuNE2pyW5utb6wySptf54cMsEALZWXe/n3S/HZ/2Ip6calgQAmxhIKO1I8vgGr1d1L9vQAUn2KaXcVUp5oJTy0b52VEo5q5SytJSy9Omnn962igGAASulvKqU0pX1YfT2WuvyjdZrmwFoarAmOtopSWeSY7N+WNDvlVImbrxRrfWyWuuUWuuUvfbaa5DeGgDoT611ba21M+s/UD6ylDJto/XaZgCaGkgoXZVkvw1ed3Qv29DjSW6utf68e+juPyeZPDglAgDbq9b6XNZPdHRY61oAYEMDCaVLkkwspXR0T5IwI8lNG21zQ5J3llLGlVJ+Kck7kjw8uKUCAFujlLJnKeWXu7/eLcm7kyzf/HcBwNDa4uy7tdYXSylnJ7k560PsFbXWpaWU2d3r59Va7y2l/FOSZVk/kcLlG87OCwA08bokf11KKUl2TXJlrfXrjWsCgF4G9JzSWuuNSW7caNm8jV5/PuufUwoADAO11mVZP+cDAAxbgzXREQAAAGw1oRQAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoZ17oAYJhYPGfTZdPOH/o6AAAYU/SUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0M651AQAMrunPLuhz+aLXnDHElQAAbJmeUgAAAJoRSgEAAGhGKAUAAKAZ95QC/Vs8Z9Nl087vc9Pru57YwcUAADAa6SkFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJrxnFIYzbbiOaMAANCCnlIAAACaEUoBAACC0AFjAAAQ/klEQVRoRigFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGbGtS4AgIYWz8n0Z5/otWjRa85oVAwAMBbpKQUAAKAZoRQAAIBmhFIAAACaEUoBAABoRigFAACgGaEUAACAZoRSAAAAmvGcUmDr9PFcSwAA2FZ6SgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoRigFAACgGY+EAZIk13f1/ZiXkzv3HeJKAAAYS/SUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANCMUAoAAEAzQikAAADNCKUAAAA0I5QCAADQjFAKAABAMwMKpaWU40spy0spD5VSPrWZ7aaWUl4upZwyeCUCANuilLJfKeVb3W3490opv9e6JgDY2BZDaSlllyTzkrwnyeQkp5RSDulju1cl+ZMk3xjsIgGAbbImycdqrROTvC3JmaWUzsY1AUAvA+kpPTTJg7XWx2uta5IsTHJiH9v9zyTXJnlqEOsDALZRrfWHtdZl3V//LMmyJPu2rQoAehs3gG06kjy+wetVSY7ecINSyr5J3pdkWpKp/e2olHJWkrOSZP/999/KUoEWru96onUJDKJZ8+/u9Xr6s87vWFFKmZD1bfRHNlqubQagqcGa6OiLSX6v1rpucxvVWi+rtU6ptU7Za6+9BumtAYDNKaXskeSaJOfWWn+y4TptMwCtDaSndFWS/TZ43dG9bENTklxVSkmSPZOcUEp5udZ63aBUCQBsk1LK+Ky/vebKWuvft64HADY2kFC6JMnEUkpHkh8lmZFk9oYb1Frf8MrXpZT5Sf5RIAWAtsr6T4svT/JQrfX/a10PAPRli8N3a60vJjk7yc1ZP0HCP9Ral5ZSZpdSZm/+uwGAho5I8uEkx5RSurr/nNC6KADY0EB6SlNrvTHJjRstm9fPtjO3vywAYHvVWu9MUlrXAQCbM1gTHQEAAMBWE0oBAABoZkDDd4ERYPGc1hUAAMBW01MKAABAM0IpAAAAzQilAAAANCOUAgAA0IyJjmCsMSESAADDiJ5SAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGZMdAQAADAW9TcB5rTzh7QMPaUAAAA0I5QCAADQjOG7MBJ51igAAKOEnlIAAACaEUoBAABoRigFAACgGaEUAACAZkx0BKPc9V1PbLLs5M59G1QCAACb0lMKAABAM0IpAAAAzRi+CzBGTH92QesSAAA2oacUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmxrUuYDDMmn/3Jssunzm1QSUAAABsDT2lAAAANCOUAgAA0IxQCgAAQDNCKQAAAM0IpQAAADQjlAIAANDMqHgkDAA7Xl+P30o8ggsA2D56SgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoxuy7MIpc3/XEoG4HAAA7mp5SAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGaEUgAAAJoRSgEAAGjGI2FgOFs8p8/FHunCjjT92QW5/uIFvZYtes0ZjaoBAEY7PaUAAAA0I5QCAADQjFAKAABAM+4pBWCLpj+7oP+Vi7/Z+/W083dsMQDAqKKnFAAAgGaEUgAAAJoRSgEAAGhGKAUAAKAZoRQAAIBmhFIAAACaEUoBAABoxnNKYUdbPGfTZZ7jCAAASQYYSkspxyeZm+RVSRbUWj+30foPJ/nfSUqSl5L891rr0kGuFcak67ueaF0CMEKVUr6a5KQkT9VaJ7auBwD6ssXhu6WUXZLMS/KeJJOTnFJKOWSjzb6X5J3dDd7/m+QvB7tQAGCrzU9yfOsiAGBzBnJP6aFJHqy1Pl5rXZNkYZITN9yg1vrdWutPul/emWTfwS0TANhatdZvJfnP1nUAwOYMZPhuR5LHN3i9KsnRm9n+vydZ1NeKUspZSc5Kkv33339gFUJr7gmFrePfzIiibQagtUGd6KiUcnSSWUne2df6WutlSS5LkilTptTBfG8AYOtpm4HtNWv+3X0uv3zm1CGuhJFqIKF0VZL9Nnjd0b2sl1LK5CSXJ3lPrfWZwSkPAACA0WwgoXRJkomllI4kP0oyI8nsDTcopeyf5O+TfLjW+r1BrxIAAGAH6KunVy/v0NpiKK21vlhKOTvJzVk/MdIVtdalpZTZ3evnJbkgyWuTXFpKSZKXa61TdlzZAMCWlFKuzPp5IPYspaxKcmGt9fK2VQH01t/w374MNCwKmiPLgO4prbXemOTGjZbN2+DrM5OcObilAQDbo9Z6eusaAEYioXZoDepERwAAADuKsDg6CaUAAMCotzXDhBlaQikAADBiCZsjn1AKAAAMOkNtGSihFAZRn//5vr5BIQAAMEIIpQAAwJAw1Ja+CKUAADCG9RcUDbVlqAil0MLiOZsum3b+0NcBALAV9HSyIwilAAAAWzDiJ27qq1NkmNipdQEAAACMXUIpAAAAzRi+C8PF4jm5vuuJ1lXAVuvr9/bkzn0bVAIAw8OIH+o7xPSUAgAA0IyeUgAAGCPMnju4/DwHh55SAAAAmhFKAQAAaEYoBQAAoBn3lMI2Gug9BP3NqGt2UgAAEEoBAIA+mMRnBFs8p3UFW8XwXQAAAJrRUwob2o5PlaY/u2AQCwEAgLFBTykAAADNCKUAAAA0I5QCAADQjHtKGbH6mhHu8plTt3vbAVk8J9Of7ftRLwAAMCRG2Cy7/RFKAQBghBv0D+BhCAmlAAAAO5gPDvrnnlIAAACaEUoBAABoxvBdAAAYhfoaLgrDkVDKqDKS/vO9vsvsvQAA9Nbf9ezlr//mEFcydAzfBQAAoBk9pYx6059d0PeKxaP30yYAABgphFIAABghRtKtSmy7PjtVXr/v0BcyRIRSAAAYhgRQxgr3lAIAANCMnlJGlX7vHwUAgOFo8ZxeL6c/O/ae0CCUAjDoNn7k0aIf9D8E7fKZU3d0OQDAMCaUAgAw9DbqHUqSTDt/6OuAIdLniD5Pg0gilAIAwJDqawIjo0YYy4RSAAB2nL56RLdmW72nMOoJpQAAAINooJNvbjwHw1gllAIAMHyN4N7TrXnOqGeSjlye/rD9hFIAAEaWrRkSPEICLIxlQilswBAKABhlRnBPK+3o/RxaQinDX7+fhv76kJYBbLu+GvdFrzmjQSUAmyHAjkkCaHtCKQAAg2NrhtW2tL11Cq8jlgA6PAmlAADQnwEG2Osv/tgmy6bHqJChIGiOfEIpAADsINsTmMZKoBUqEUoZsfwHBgCMZltzrdNXgB3Ka6WBvv9YCdpsHaEUAABGuNYf1g/0/VvXOdr09eSIkzv3bVDJ9tmpdQEAAACMXUIpAAAAzRi+CwAAMMz1NVR3oNsN9yG9QikAAGyFgYYDYGAM3wUAAKAZPaUAAGy9xXNaV7DNRuLwRhjNhFJGBMNkAIAWXIPAjieUAgAw5gmf0I5QCgDAiNJfgOxrCK6wCcOfUAoAwJDamlA5GPsFhjehFAAYdH1OJDOtQSGMeIImbL8d9UHQYPFIGAAAAJrRU8qY5ZNXABhc2lZgW+gpBQAAoBk9pQAAAGNQn/f/N7jPdFSE0unPLuhj6dQhrwMAYKzYEUN1Df+FsWlAw3dLKceXUpaXUh4qpXyqj/WllPKlUsqKUsp9pZRDBr9UAGBrbKn9BoDhYIuhtJSyS5J5Sd6TZHKSU/oInb+R5PVJDk4yK8lfDXKdAMBWGGD7DQDNDaSn9NAkD9ZaH6+1rkmyMMmJG21zYpIr6nr3JhlXStlvkGsFAAZuIO03ADQ3kHtKO5I8vsHrVUmOHsA2Gy9LKeWsJGd1v3y+lPLI1hS7GXsm+XGvJb/754O062Fr02MeG8bicY/FY04c9xiw/v/pr/72oB3z6wdhH6PJQNpvbfPgGkP/fnsZi8c9Fo85GZvHPRaPOcmnh7RtHtKJjmqtlyW5bLD3W0pZWmudMtj7Hc7G4jEnY/O4x+IxJ467dR1DaSwe83CibR48Y/GYk7F53GPxmJOxedxj8ZiToT/ugQzfXZVkw6G4Hd3LtnYbAGDoaJsBGBEGEkqXJJlYSukopYxPMiPJTRttc2OSDyZJ9yQK62qtjwcAaGUg7TcANLfF4bu11hdLKWcnuTnrQ+wVtdalpZTZ3evnJbk2ybRSyookq5P89g6suS+DPuxoBBiLx5yMzeMei8ecOO6xZCwe8w7XX/s9hCWMxfM6Fo85GZvHPRaPORmbxz0WjzkZ4uMutdahfD8AAADoMZDhuwAAALBDCKUAAAA0MyJDaSnlC6WUh7r/3FBK2bOf7Y4vpSzv3u5TQ13nYCqlvL+U8mApZV0ppd/pmUspK0spD5RSukopQ3nv0A6xFcc9ms71r5RSbuk+j98opbymn+1Gxbne0rkr632plLKilHJf92RqI9oAjvnoUspPus9tVynlghZ1DqZSyldLKU+VUpb3s37UneexRtusbe5ju9F0rsdM2zwW2+VE29zP+qE717XWEfcnyTFJxnV//SdJvtjHNrskWZn10+GPT7I0ySGta9+OYz4wyVuS3J5kyma2W5lkz9b1DuVxj8Jz/WdJfrf76/OSfGm0nuuBnLskv5nk+iQlySFJ7m9d9xAc89FJ/rF1rYN83Ed1n7/l/awfVed5LP7RNmubR/m5HhNt81hsl7fiuLXNO/Bcj8ie0lrrbbXWl7tf3plk3z42OzTJg7XWx2uta5IsTHLiUNU42GqtD9VaH2ldx1Ab4HGPqnOd9bV/rfvrKzKyj2VLBnLuTsz6WUNrrfXeJONKKfttvKMRZLT9vg5IrfVbSf5zM5uMtvM85mibxw5t86hum8diu5yMvt/XARlObfOIDKUbOSvJoj6WdyTZ8Fmpq7qXjXY1ySvDS/5n62KGyGg713vVWp9Oku6/f7Wf7UbDuR7IuRtt53egx/OO7mFEt5VSOoemtKZG23ke67TNvY2G/6+31mg712OlbR6L7XKibe7PkJ3rLT6ntJVSyjeT7N3Hqt+vtV7fvc3vJ3k56z+xGvEGcswD8I5a6w9LKb+a5J9KKQ/XWm8ZvCoH3yAd94iyuWPeit2MuHPNgN2TZL9a6wullOOSXFdKeWOtdV3rwhjbtM29aJtHGW0zW6Bt3oGGbSittf765taXUs5I8t4kx9TuQc8bWZX148Jf0dG9bNja0jEPcB8/7P77qVLKNUmmJhnW/xkOwnGPqnNdSnm6lLJXrfXpUspeSZ7qZx8j7lz3YSDn7pVt7trMNiPJFo+51vqzDb6+uZSyOusvlJ4ckgrbGG3neVTSNm/zPkbc/9fa5t7GUNs8FtvlRNvcnyE71yNy+G4p5fgkv5fkvbXWF/rZbEmSiaWUjlLK+CQzktw0VDW2UErZvZTyS698neT4JCvaVjUkRtu5vjHJh7q//lD6OJZRdK4Hcu5uTPLBJOme9W1drfXxjFxbPObuC55Xvn5bkj3SzwXQKDLazvOYo23u2yj6/3prjbZzPVba5rHYLifa5v4M3bneUTMo7cg/Sf4t68c3d3X/mde9/HVJbtxguxOSPJjkoawfbtK89u045vdl/ScTLyX5UZKbNz7mJG9MsizJ/Un+NckfJSmta9/Rxz0Kz/Vrk3wzyQPdf//KaD7XfZ27JLOTzO7+uiT586xv2LuymRkuR8qfARzzx5Ms7/5zb5KjW9c8CMd8ZZL/SLKm+9/0rNF+nsfaH22ztnmUn+sx0zaPxXZ5gMetbd6B57p0vyEAAAAMuRE5fBcAAIDRQSgFAACgGaEUAACAZoRSAAAAmhFKAQAAaEYoBQAAoBmhFAAAgGb+f2aKV+adw3ywAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.subplot(1,2,1)\n", + "plt.hist(costheta_Ds_b,alpha=0.7,density=True,bins=70, label=\"MC Ds tuple\");\n", + "plt.hist(costheta_Dplus_b,alpha=0.5,density=True,bins=70, label=\"MC Dplus tuple\");\n", + "plt.legend()\n", + "plt.subplot(1,2,2)\n", + "plt.hist(costheta_MC_b,alpha=0.7,density=True,bins=70, label=\"MC Ds+Dplus tuple\");\n", + "plt.hist(costheta_data_b,alpha=0.5,density=True,bins=70, label=\"data before cut\");\n", + "plt.legend()\n", + "fig = plt.gcf()\n", + "fig.set_size_inches(16,8)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cos theta_l after cut on phi mass" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [], + "source": [ + "costheta_Dplus=get_costheta_list(MC_Dplus_tuple_dict_presel_9, l_index=l_index, mother_index=1)\n", + "costheta_Ds=get_costheta_list(MC_Ds_tuple_dict_presel_9, l_index=l_index, mother_index=0)\n", + "costheta_MC=np.concatenate((costheta_Dplus,costheta_Ds),axis=0)\n", + "costheta_data=get_costheta_list(data_tuple_dict_presel_4, l_index=l_index, mother_index=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAHVCAYAAAAJnF2uAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3X+YXVV9L/73QsKPQr9Xq2lRhhj1PsrvjpgIomgi7QMChmopiJZLaigNxWuhV2/F3oLS3mIfc8VSxJhebKhYfhS8kGq8gBgKVCiEEEIISOs1QrAKpaBQhASyvn/MZDqZH5mTzMzZc2Zer+eZJ+fsvfben7Oz96z5nLX2WqXWGgAAAGjCTk0HAAAAwNQlKQUAAKAxklIAAAAaIykFAACgMZJSAAAAGiMpBQAAoDGSUgAAABojKQUAAKAxklIAAAAas3NTB37Vq15VZ86c2dThAZhk7rnnnn+ttU5vOo5Opm4GYCy1Wjc3lpTOnDkzK1eubOrwAEwypZQfNB1Dp1M3AzCWWq2bdd8FAACgMZJSAAAAGiMpBQAAoDGNPVMK0KRNmzZlw4YNef7555sOhe202267paurK9OmTWs6lCnBvUJ/7j9gPEhKgSlpw4YN+fmf//nMnDkzpZSmw6FFtdY8+eST2bBhQ173utc1Hc6U4F5hC/cfMF5G7L5bSvlyKeXxUsraEcrNLqW8WEo5YezCAxgfzz//fF75ylf6I7vDlFLyyle+UqtdG7lX2ML9B4yXVp4pXZrk6G0VKKW8LMmfJblxDGICaAt/ZHcm/2/t55yzhWsBGA8jJqW11luT/NsIxf5rkmuTPD4WQQEAADA1jPqZ0lLK3knel2RuktkjlD09yelJMmPGjNEeGmDMLFh695ju79L52/x1mKSnxeFDH/pQLr/88iTJiy++mFe/+tU59NBD8/Wvfz1J8s1vfjPnnXdeXnjhhWzatCnvfve7c/HFF2+1n6VLl+bjH/94urq68tJLL+XVr351zjvvvBx++OEtxbp69er88Ic/zDHHHLOdn/I/zJkzJ4sWLcqsWbN2eB90hql8rwznZS97WQ466KCUUvpiPfvss7PTTtv+7n/PPffMs88+O6pj33LLLdlll11G9RlmzpyZlStX5lWvetWoYgHYUWMxJcznk/xBrXXzSAVrrUtqrbNqrbOmT58+BocG6Fx77LFH1q5dm5/97GdJkptuuil777133/o777wzZ511Vq6++urcd999uf/++3PAAQcMua+TTjop9957b9asWZNPf/rT+Y3f+I08+OCDLcWxevXqLF++fPQfCMbJRLlX5s+fn1tuuWXQ8t133z2rV6/Ovffem5tvvjnf/va38+lPf3r7P+gOuOWWW/Kd73ynLccCGC9jkZTOSnJlKWV9khOSXFJK+bUx2C/ApHfMMcfkG9/4RpLkiiuuyMknn9y37sILL8y5556bmTNnJulpjTnjjDNG3Odhhx2WM888M0uWLOnbz/77759f/uVfzoknnrhV2Y0bN+bcc8/NVVddle7u7lx11VX51Kc+lUWLFvWVOfDAA7N+/fqsX78+++67b0455ZQccMABOfbYY/Pv//7vg46/bNmyHHLIITnwwAMzb968/PSnP93u8wIDNX2vtOoVr3hFlixZkosvvji11ixdujTHH398jjzyyLzhDW/IJz/5yUHb3HLLLTnuuOP63n/kIx/J0qVLkyQf//jH+2I6++yzt9pu/fr1Wbx4cS688MJ0d3fntttuy/z583PNNdf0ldlzzz37jvHOd74z733ve/PGN74x8+fPz+bNg9sT/vIv/zIHH3xw9t9///zWb/1WNm3atEPnAWB7jDoprbW+rtY6s9Y6M8k1SX631nrdqCMDmAI+8IEP5Morr8zzzz+fNWvW5NBDD+1bt2bNmrzlLW/Zof0ecsgheeihh5Ikn/3sZ3Pvvffmvvvuy6WXXrpVuV122SXnn39+TjrppKxevTonnXTSNvf73e9+N2eeeWYeeOCBvOY1r8mf//mfb7X+xz/+cS644ILcdtttWbt2bd7+9rfnz/7sz3boM0B/Td8r22PvvffOtGnT8vjjPUNt3HXXXbn22muzbt26/N3f/V3LLZuPP/54li9fngceeCD33Xdfzj///K3Wz5w5MwsXLszZZ5+d1atX54gjjtjm/u66665cfPHFeeihh/Iv//IvufLKK7daf9999+W6667LPffck3Xr1mX33XfvS44BxlMrU8JckeSOJG8qpWwopSwopSwspSwc//AAJreDDz4469evzxVXXDGqZzoHqrVudYxTTjklf/3Xfz3q/e6zzz457LDDkiQnn3xybr/99q3W33bbbfmnf/qnvP3tb093d3cuu+yyPPbYY6M+LjR1r9xwww3p7u5Od3d3li1bltNOOy3d3d1bJcUj7fdXf/VX8/KXvzy77rpr3ve+9w26b4bzC7/wC5k2bVoWLFiQa665Jrvssst2frqtvfWtb81rX/va7LTTTjnppJMGxXHTTTfl3nvvzezZs9Pd3Z2bb745jzzyyKiOCdCKEQc6qrWePFKZfmXnjyoagClo3rx5+djHPpZbbrklTz75ZN/ygw46KKtWrcq+++673fu89957s99++yVJvvGNb+TWW2/N17/+9fzpn/5p1q5dm513Hv7X/0477bRVt77+cxIOnA5i4Ptaa97znvfkK1/5ynbHDCNp4l456qijctRRRyXpeaZ0/vz5mTNnzjb3+cMf/jAvvfRSfvEXfzHJyPfNcPfczjvvnH/8x3/MzTffnGuvvTZf+MIXsmLFim0eu/++Nm/enI0bNw573KHu3wULFuSP//iPt3kMgLE2Fs+UAjAKH/7wh3PeeefloIMO2mr5WWedlfPPPz8/+MEPkvT8gbl48eIR93fXXXflkksuyW//9m9n8+bN+eEPf5i5c+fmM5/5TH7605/m6aef3qr87rvvnueee67vfVdXV1atWpWkZxCk73//+33rHnnkkdx1111Jkquuuipvf/vbt9rXEUcckRUrVvTF/Pzzz+ef//mfWz0VsE1N3yutePrpp7Nw4cKceeaZfUnfTTfdlJ/85CfZuHFjrrvuukH3TVdXVx544IG88MILeeaZZ3LzzTcnSZ599tk8++yzOeaYY/K5z32u777sb6j795577knSk2T3fyb0rrvuyiOPPJJaa/72b/92UBy/+qu/mquvvjr/9m89MwH+9Kc/zaOPPrrd5wBge416ShiAyaCVaSnGS1dXVz760Y8OWn744Ydn0aJFOeGEE7Jx48a89NJLOfLII4fcx1VXXZV/+Id/yObNm7PXXnvlqquuyn777ZdNmzblpJNOyr//+7/npZdeyu/+7u8OmvZh7ty5+dM//dMcfPDB+cM//MOceOKJueyyy3LAAQfksMMOyxvf+Ma+sm9605vyF3/xF1m1alVe+9rX5nOf+9xW+9prr72yZMmSzJs3L0lPcvAnf/In+c//+T+P9jQxQUzle2U4P/vZz9Ld3d03JcwHP/jB/P7v/37f+re+9a359V//9Xz/+9/PiSeeOGj6lte//vU5/vjjs+++++ZNb3pT3vzmNyfpSQrnzZuXF198MS+99NKg+y1J3vve9+b9739/rr322lx88cVZuHBhjjnmmNxwww05+uijs8cee/SVnT17dj7ykY/koYceyuGHH54PfOADW+2ru7s755xzTo444ojsvPPO2WmnnfLFL34x++yzT0vnAWBHlf7PPLTTrFmz6sqVKxs5NsCDDz7Y12WP1qxfvz7HHXdc1q5d23QoQ/7/lVLuqbWaKHUUhqqb3Sujs3Tp0qxcuXLQnKntdsstt2TRokV987qOhmsCaFWrdbPuuwAAADRG910AWjJz5swJ0UoKnWTL4EhNmzNnzogDNAE0RVIKk9yCpXcPWtbkM2EAAEwQKy4Yevncc9oahu67AAAANEZSCgAAQGMkpQAAADTGM6UAyfDPVOyoFp7FKKXkQx/6UC6//PIkyYsvvphXv/rVOfTQQ/umbfjmN7+Z8847Ly+88EI2bdqUd7/73YOmlli6dGk+/vGPp6urKy+99FJe/epX57zzzhs0F+JAYzVVxec///mcfvrp+bmf+7kd2n4sp6qgDRq4V/r71Kc+lT333DMf+9jHhi1z3XXX5Y1vfGP233//Md3vQBdeeGG++MUvZvbs2fnqV7/a8nZjbf369fnOd76TD37wg43FADAaWkoBGrLHHntk7dq1+dnPfpYkuemmm7L33nv3rb/zzjtz1lln5eqrr859992X+++/PwcccMCQ+zrppJNy7733Zs2aNfn0pz+d3/iN38iDDz7Yls/x+c9/Ps8991xbjgWtuO6667Ju3bpxP86XvvSlfPvb3245IX3ppZfGJY7169fnb/7mb8Zl3wDtICkFaNAxxxyTb3zjG0mSK664IieffHLfugsvvDDnnntuZs6cmSR52cteljPOOGPEfR522GE588wzs2TJkiQ9U0H83u/9XmbPnp03velNuf322wdtM3/+/FxzzTV97/fcc88kyYYNG/LOd74z3d3dOfDAA3Prrbdutd1FF12UH/7wh5k7d27mzp271bZJcs011/RNhzF//vwsXLgwhx56aF7/+tfna1/72qA4nn322Zx88sk5+OCDs//+++fqq68e8fMy+Z177rl5wxvekHe961357ne/27f8S1/6UmbPnp39998/xx13XJ555pl85zvfybJly/Lxj3883d3d+d73vjdkuaHcd999ecc73pHXv/71W/UgOP/883PQQQdl3333zSc+8YkkycKFC/P//t//y3ve855ceOGF+dd//dccddRROfDAA3PIIYfknnvuSdLTAnvKKafkXe96V/7Lf/kvefHFF/ORj3wkBx98cPbdd9/8+Z//+ZCxfOlLX8p+++2X7u7ufOhDH0oy/H36iU98Irfddlu6u7tz4YUXjuJMAzRDUgrQoA984AO58sor8/zzz2fNmjU59NBD+9atWbMmb3nLW3Zov4ccckgeeuihvvcvvPBC7r777nz5y1/Ohz/84Zb38zd/8zc59thjs3r16tx///055JBDtlr/0Y9+NK95zWuyYsWKrFixYsT9PfLII7nzzjtz8803Z+HChYNaWM8999wce+yxWbNmTb7zne/knHPOyU9/+tOW42XyueOOO/J//s//ybp167J8+fLcffd/THP1gQ98IHfffXfWrVuX7u7ufOlLX8rhhx+eefPm5bOf/WxWr16dN7zhDUOWG8qaNWvy7W9/O/fcc08uuOCCPPLII1m2bFk2bNiQNWvWZN26dVm7dm1uuummLF68uO/aP/vss/PJT34y73znO7N27dpceOGF+c3f/M2+/a5bty433XRTvvrVr+aSSy7JXnvtlTVr1uS+++7LZZddlocffnirOFatWpVFixbljjvuyOrVq/OFL3xhm+foM5/5TI444oisXr06Z5999ijONkAzPFMK0KCDDz4469evzxVXXJFjjjlmzPZba93q/Yknnpgkefvb357nn38+jz/+eEv7Oeyww7JgwYL87Gc/y3vf+94dTpK3OOGEE1JKyete97rsu+++Wbt27Vbrb7zxxtx4441ZtGhRkmTTpk155JFHcuCBB47quHSu2267Le973/uy6667Ztddd828efP61t111135oz/6ozz33HN55plncuSRRw65j1bLHX/88dlll12yyy675Mgjj8ydd96ZW2+9NTfeeGPe/OY3J+lpzf/+978/aNvbb7+9rxX1Xe96V5599tk88cQTSZJ58+Zll112SdJzjT/88MN9LZ4/+clP8r3vfS9vfOMb+/Z1880358QTT8zLX/7yJOn7F2CykpQCNGzevHn52Mc+lltuuSVPPvlk3/KDDjooq1atyr777rvd+7z33nuz33779b0vpWy1fuD7nXbaKZs3b06SbN68ORs3bkySvPOd78zf//3fZ/ny5TnttNNy1lln5dRTT93msfsnxM8///w2jzvwfa01y5Ytyxve8IZtHoOpY+A10t+pp56aG264IQcddFCWLl2aW265ZVTlhro+a635oz/6oyxYsGBHP0L22GOPvte11nzxi18cNjHeluHuU4BOp/suQMM+/OEP57zzzstBBx201fKzzjor559/fn7wgx8k6fkjdPHixSPu76677soll1yS3/7t3+5btqVV5o477shuu+2W6dOnb7VNV1dX3zNw3/jGN7Jp06YkyaOPPpq99torp512WhYsWLBV18ktdt9996264b7yla/Mgw8+mFprrrvuuq3KXnvttam1Zv369fnud787qAX0qKOOyhe/+MW+9wNbUpl63vGOd+S6667LCy+8kOeeey5/93d/17fuhRdeyC/90i/lpZde2mqgn4HX5HDlBlq2bFk2btyYp59+OjfffHMOPfTQHHXUUfmrv/qrvgHJfvzjH/e1gPZ3xBFH5Morr0zS07q75557DrrPkp5rfMmSJX2DHn3/+98f1I39yCOPzNVXX52nn346Sfr+He4+Hfh5ATqNllKAZLunpRhLXV1d+ehHPzpo+eGHH55FixblhBNOyMaNG/PSSy8N27py1VVX5R/+4R+yefPm7LXXXrnqqqu2aimdNm1a3vrWt+bpp5/Ol7/85UHbL1y4MMccc0xuuOGGHH300X0tOzfffHMWLVqUadOmZc899xxy2wULFmTu3LmZMWNGVqxYkQsuuCBHHXVU9tlnn7z5zW/Os88+u9Vnfdvb3pbHH388l1xySXbfffet9vXHf/zHOeOMM7Lffvtl5513TldXV775zW+2diJpjzbfK29729vya7/2a9l///3T1dWV2bNn96379Kc/nbe85S3p6urKrFmz+gYwOumkk3Laaaflc5/7XK699tphyw100EEH5d3vfncee+yxnHPOOZkxY0ZmzJiRdevW5ZBDDskuu+ySXXfdNVdcccWghPN//s//mQ9+8IO54oorsvPOO+crX/nKkMc488wzs379+hxwwAHZZZdd8vKXv3yrRDvpeSb8v/23/5bDDjssu+22Ww466KB85StfGfY+7e7uzsaNG3PggQdmwYIFnisFOk4Z+NxRu8yaNauuXLmykWPDVLJg6eCWrUvnzx6i5NTy4IMPbpW0TWZz5szJokWLMmvWrEbjmD9/fo477riccMIJo97XUP9/pZR7aq3NfsgON1TdPJXuFVrjmoBJZLi5p8foC8hW62bddwEAAGiM7rsAk9xwg7q029KlS5sOAQCYgLSUAlNWU48vMDr+39rPOWcL1wIwHiSlwJS022675cknn/QHVoeptebJJ5/Mbrvt1nQoU4Z7hS3cf8B40X0XmJK6urqyYcOGIad2YGLbbbfd0tXV1XQYU4Z7hf7cf8B4kJQCU9K0adPyute9rukwYMJzrwAw3nTfBQAAoDGSUgAAABojKQUAAKAxklIAAAAaIykFAACgMZJSAAAAGmNKGGC7LFh696Bll86f3UAkAABMBlpKAQAAaIykFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxkhKAQAAaIykFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxkhKAQAAaIykFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxkhKAaDDlFL2KaXcWkpZW0p5uJTyB0OUmVNK+UkpZXXvz7lNxAoAI9m56QAAgO22KclHaq1rSik/n2RVKeWGWuvqAeVuq7Ue10B8ANCyEVtKSylfLqU8XkpZO8z6U0op9/d+W3tPKWXW2IcJAGxRa/1RrXVN7+tnkqxJsnezUQHAjmml++7SJEdvY/3DSd5Raz0wyf9I8r/HIC4AoAWllJlJZie5fYjVb+v90vjbpZTuYbY/vZSyspSy8oknnhjHSAFgaCMmpbXWW5P82zbW/2Ot9Se9b2+Pb2oBoC1KKXsmuSbJWf3q4i3uSbJP75fGf5bkulLKoHq/1rqk1jqr1jpr+vTp4x80AAww1gMd/U6SZcOt9G0sAIyNUsq0JNcmuaLW+rWB62utz9Ran+t9fUOSjUn2am+UADCyMUtKSylzkixI8t+HK+PbWAAYvVJKSXJpkgdrrf9rmDLT+71+S5I9kzzenggBoHVjMvpuKeXg9FSO76m1PjkW+wQAhvX2JKckub+UsmXE3U8mmZEktdbFSU4upZzeu25jkg/WWl9se6QAMIJRJ6WllBlJvpbklFrrw6MPCQDYllrr7UnKCGUuSnJReyICgB03YlJaSrkiyZwkryqlbEhyXpJpSd83secmeWWSS3p6E+XFWqtpYQAAABjRiElprfXkEdafluS0MYsIAACAKWOsR98FAACAlklKAQAAaIykFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxkhKAQAAaIykFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxkhKAQAAaIykFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxkhKAQAAaIykFAAAgMbs3HQAwMSwYOndg5ZdOn92A5EAADCVaCkFAACgMZJSAAAAGiMpBQAAoDGSUgAAABojKQUAAKAxRt8FJoYVFwxeNvec9scBAEBbaSkFAACgMZJSAAAAGiMpBQAAoDGSUgAAABojKQUAAKAxklIAAAAaIykFAACgMZJSAAAAGiMpBQAAoDE7Nx0AwHZbccHgZXPPaX8cAACMmqQUmNIWLL170LJL589uIBIAgKlJ910AAAAaIykFAACgMZJSAAAAGiMpBQAAoDEGOgLab6jRcxs276nL/uPNim/1/GtEXwCAcaelFAAAgMZISgEAAGiM7rswSQw13yYAAEx0WkoBAABojKQUAACAxkhKAQAAaIykFAAAgMZISgEAAGjMiElpKeXLpZTHSylrh1lfSikXlVLWlVLuLaUcMvZhAgAAMBm1MiXM0iQXJ/nrYda/P8lrkxyQ5M1J/irJL49FcMDENO+py7ZesOJbydxzmglme624YKu38556rKFAAABIWmgprbXemuTftlHk2CSX1x6rkuxcStlnrAIEAABg8mqlpXQkXUke7fd+wxDLkiSllNOTnJ4kM2bMGINDAxPVgqV3D7n80vmzJ/WxhzNUTE3GAwAwUbR1oKNa65Ja66xa66zp06e389AAAABMQGORlG5I0r+7blfvMgAAANimsUhKlyf5UJL0jry7udY6qOsuAAAADDTiM6WllCuSzEnyqlLKhiTnJZmWJLXWxUmuTTK3lLIuycYkvzVu0QJTy4CRcgEAmHxGTEprrSePsL4mOXPMIgIAAGDKaOtARwAAANCfpBQAOkwpZZ9Syq2llLWllIdLKX8wRJlSSrmolLKulHJv77gPADDhjMU8pUCbDTcPZ1OuX/1Ylv1gYsXUDuYepUGbknyk1rqmlPLzSVaVUm6ota7uV+b9SV6b5IAkb07yV0l+uf2hAsC2aSkFgA5Ta/1RrXVN7+tnkqxJsveAYscmubz2WJVk51LKPgGACUZSCgAdrJQyM8nsJLcPWNWVpP8UbRt6lw3c/vRSyspSysonnnhivMIEgGFJSgGgQ5VS9kxyTZKzaq0/2ZF91FqX1Fpn1VpnTZ8+fWwDBIAWSEoBoAOVUqalZ67wK2qtXxuiyIYk/bvrdvUuA4AJRVIKAB2mlFKSXJrkwVrr/xqm2PIkH+otf0iSzbXWR4cpCwCNMfouAHSetyc5Jcn9pZQtI+5+MsmMJKm1Lk5PK+rcUsq6JBuT/FYTgQLASCSlANBhaq23JykjlKlJzmxPRACw4ySl0AatzitqjksAAKYaz5QCAADQGEkpAAAAjdF9FxgT8566bMjly15xapsjAQCgk2gpBQAAoDGSUgAAABojKQUAAKAxklIAAAAaIykFAACgMUbfhUlkqBFwp8zotysu6Hs576nHkozBZ++3zz5zzxndPgEA2IqWUgAAABojKQUAAKAxklIAAAAaIykFAACgMQY6AtgeQwyolEyhAaUAAMaYllIAAAAaIykFAACgMbrvwhS0YOndTYewQ65f/digZcd3793y9guW3r1Vl9vxOM72nNuhyl46f3bL2wMATAZaSgEAAGiMllJg0pr31GUT7vgGRAIA2JqWUgAAABojKQUAAKAxklIAAAAaIykFAACgMQY6goYMOQjPim8NXjb3nLYc2wA8AAA0QUspAAAAjdFSCrTVgqV3Z95Tj2217PjuvRuKBgCApmkpBQAAoDGSUgAAABojKQUAAKAxnimFsbTigsHLxmH03PEw7GjAo4x/yP0CAEAvLaUAAAA0RlIKAABAYySlAAAANEZSCgAAQGMkpQAAADRGUgoAAEBjJKUAAAA0RlIKAABAYySlAAAANEZSCgAAQGMkpQAAADSmpaS0lHJ0KWVtKeXBUsonhli/Vynl5lLKulLKw6WUhWMfKgAAAJPNziMVKKXsmmRxkiOS/CjJHaWUG2utq/oV+0iSlbXWPyilTE/yT6WUy2qtPxuXqGEcLVh696Bll86f3UAkAAAw+bXSUnpokgdqrY/WWjcluSrJsQPKbEjy86WUkmTPJP+a5IUxjRQAAIBJp5WktCvJo/3eb+hd1t9fJtk/yQ+T3J/k92qtmwfuqJRyeillZSll5RNPPLGDIQMAADBZjNVAR+ckWZPkNUm6k1xcSvn/BhaqtS6ptc6qtc6aPn36GB0aAACATtVKUrohyT793nf1LuvviCR/W3v8c5Lvp6flFAAAAIbVSlJ6V5IDSyldpZRpSU5K8s0BZb6X5MgkKaX8UnoS0vVjGCcAAACT0Iij79Zany+lnJHkhvQksZfXWldumfal1ro4yflJLi+lPJjkZUn+qNb6o3GMGwAAgElgxKQ0SWqty5MsH7Bscb/XP0ryK2MbGgAAAJNdS0kpwHi6fvVjg5Yd3713A5EAANBuYzX6LgAAAGw3SSkAAACNkZQCAADQGEkpAAAAjTHQEXSgeU9d1r6DrbhgwLEHD0oEAAA7SkspAAAAjZGUAgAA0BhJKQAAAI3xTCnQ0a5f7RlXAIBOJimFSa6tgyIBAMB20n0XAACAxkhKAQAAaIykFAA6TCnly6WUx0stsvu/AAAZLUlEQVQpa4dZP6eU8pNSyuren3PbHSMAtMozpQDQeZYmuTjJX2+jzG211uPaEw4A7DgtpQDQYWqttyb5t6bjAICxoKUUoI2GGg152StObSASpoC39XbvfTzJ79daVzcdEAAMRVIKY2ioOTOX/eDuBiIBprh7kuxTa32ulHJUkutKKa+vtW4eWLCUcnqS05NkxowZbQ4TAHTfBYBJp9b6TK31ud7XNyTZmGSvYcouqbXOqrXOmj59ejvDBIAkklIAmHRKKdP7vX5Lkj3T040XACYc3XcBoMOUUq5IMifJq0opG5Kcl2RaktRaFyc5ubdbbtLTSvrBWuuLTcQKACORlMJEt+KCpiMAJpha68kjrL8oyUVtCgcARkX3XQAAABojKQUAAKAxklIAAAAa45lSYEIaas7XqWDB0sHz2l46f3YDkQAAtIeWUgAAABojKQUAAKAxklIAAAAaIykFAACgMZJSAAAAGiMpBQAAoDGSUgAAABojKQUAAKAxOzcdADBxXb/6saZDYDssWHr3kMsvnT+7zZEAALROSykAAACNkZQCAADQGEkpAAAAjZGUAgAA0BhJKQAAAI2RlAIAANAYSSkAAACNkZQCAADQGEkpAAAAjZGUAgAA0BhJKQAAAI2RlAIAANAYSSkAAACNkZQCAADQGEkpAAAAjZGUAgAA0JidWylUSjk6yaIkL0tyWa31M0OUmZPks0l2SfKTWus7xzBOGLUFS+8etOzS+bMbiGR4169+rOkQGIb/GwCgo624oOkIhjViUlpK2TXJ4iRHJPlRkjtKKTfWWlf1K7NXki8kObLW+qNSyqvGK2AYK/OeuixZ8a2tF849p5lgAABgimql++6hSR6otT5aa92U5Kokxw4o84EkV9daf5QktdZ/HdswAQAAmIxaSUq7kjza7/2G3mX97Zvk1aWUO0sp95dSfnusAgQAAGDyaumZ0hbslOTgJEcm2T3JnaWUO2qta/sXKqWcnuT0JJkxY8YYHRoAAIBO1UpL6YYk+/R739W7rL9Hk9xQa/333q67f5+eJHUrtdYltdZZtdZZ06dP39GYAQAAmCRaSUrvSnJgKaWrlDItyUlJvjmgzDeSvKOUsnMp5eeSvC3JQ2MbKgAAAJPNiN13a63Pl1LOSHJDepLYy2utK0spC3vXL661riql/N8ka5JMS3Jp/9F5oZMNOUovAAAwJlp6prTWujzJ8gHLFg94/9n0zFMKU4J5KwEAYPRa6b4LAAAA40JSCgAAQGMkpQAAADRGUgoAAEBjJKUAAAA0RlIKAABAYySlAAAANEZSCgAAQGN2bjoAGGTFBYOXzT2n/XHAdpj31GXNHbz3npn31GN9i5a94tSmogEA2C5aSgEAAGiMpBQAAIDGSEoBAABojKQUAACAxhjoCMZZowPgAADABKelFAAAgMZISgEAAGiMpBQAAIDGSEoBAABojKQUAACAxhh9F6Bhw43QvOwVp7Y5EgCA9tNSCgAAQGMkpQAAADRG910AAIDJZMUFTUewXbSUAgAA0BhJKQAAAI3RfRdacP3qx5oOAQAAJiUtpQAAADRGSykAdJhSypeTHJfk8VrrgUOsL0n+PMmvJHkhyYJa66r2Rgm0w4Kldw+5/NL5s9scCew4LaUA0HmWJjl6G+vfn+S1SQ5IsiDJX7UhJgDYIVpK6VxDDXU995z2xwHQZrXWW0spM7dR5Ngkl9daa5JVpZSdSyn71FofbUuAALAdJKUAMPl0JemfgG4YYlmSpJRyepLTk2TGjBltCQ5gW4bqkqw78uSm+y4ATGG11iW11lm11lnTp09vOhwApiAtpQAw+WxIsk+SO3vfd/UuA5hQhhuoiRYN9ThbB9JSCgCTz/IkH0qSUsohSTZ7nhSAiUpLKQB0mFLKFUnmJHlVKWVDkvOSTEuSWuviJNcmmVtKWZdkY5LfaihUYIIb7fObnv9kLEhKmVy20YVh3lOPtTEQgPFTaz15hPU1yZltCgeYgEaTLJr7lHbTfRcAAIDGaCkFAIAxtj0D+GiBZKqTlAIAwATjWU2mEt13AQAAaIyWUgAAmALMCcpEJSkFAADGlYSYbZGUAkxwnisCACYzz5QCAADQGEkpAAAAjdF9l/ZYccHgZXPPaX8cAADAhCIpBQAAxsx4DGo02vEVWo3JmA3N0H0XAACAxmgpBQBgShuuFa1drWadMl3KRIvT6PSTh5ZSAAAAGqOlFPpbcUHmPfVY01FAkmTeU5cNWrbsFadu9358kwwATGSSUgAAGIWJ1q2VSWqo2SwmiZa675ZSji6lrC2lPFhK+cQ2ys0upbxYSjlh7EIEAABgshoxKS2l7JpkcZL3JDk4yQmllEOGKPeyJH+W5MaxDhIAAIDJqZWW0kOTPFBrfbTWuinJVUmOHaLcf01ybZLHxzA+AAAAJrFWktKuJI/2e7+hd1mfUsreSd6X5Ivb2lEp5fRSyspSysonnnhie2MFAABgkhmrgY4+n+QPaq2bSynDFqq1LkmyJElmzZpVx+jYAAww1Mi9yY6N3gsAMJ5aSUo3JNmn3/uu3mX9zUpyZW9C+qokx5RSXqy1XjcmUQIAADAptZKU3pXkwFJKV5IfJzkpycL+BWqtr9vyupSyNMnXJaSMxvWrt54rdNkPBg+1Pu+px3J8994jbgsAMBmYeobJasSktNb6fCnljCQ3pOcZ1MtrrStLKQt71y8e5xgBAACYpFp6prTWujzJ8gHLhkxGa63zRx8WAAAAU8FYDXQEQBv0DWC04lvNBgIAMEZamRIGAAAAxoWWUgAAJqWhBga6dP7stm0PtEZSCgAAMJGsuKDpCNpK910AAAAao6WU5kyxb4AAAIDBJKUAHej61Y81HQIAwJjQfRcAAIDGSEoBAABojKQUAACAxkhKAQAAaIyBjgAAAJpiRgpJKQAAU8eCpXc3HQIwgKQUAABgR7Xa0jn3nPGNo4NJShkXA7+FnPdUz5yKx3fv3UQ4wzLXIwAANEtSCgAA0ArPf44LSSkdYd5TlzUdAgCAZ1JhHJgSBgAAgMZoKQUAACaXAd1st4xvsuwVpzYRDSOQlAIAABPOUI9vSSonJ0kpAABAf+MxoJFBkoYlKQUAAFoy3OCTE6UFc8tAVFu66w6k9XVikpQCAMAkNNETyC3MsoCklO0y1DDol86f3UAkAADAZCApBQCAKW603Vpbbe0cj1ZaLa2dT1IKAAAMItmjXSSlAAAwhTSZbE7ERHermFZ8q7lAprCdmg4AAACAqUtLKQAA0BEmYksroycpBQCADiIxY7KRlAIA0PGGmrZuohrtSLcw2UhKaavrVz82aNnx3Xs3EAkwkHmIAXbccK2Xkk0YmaQUAIAJabjWz6nyhZluukwVklIAADpKO7vq6moL409SCgAADdMqylQmKQUAAMjoxz8xfsqO2anpAAAAAJi6tJQy9lZckHlPDf6WCJigVlyQJEPftyu+9R+v557TpoAAmtFqF1pdbWFsSUoBAJhSJJUwsUhKAaADlVKOTrIoycuSXFZr/cyA9XOSXJ/k+72LvlZrPb+tQQISYGiBpJTGDfVAOADDK6XsmmRxkiOS/CjJHaWUG2utqwYUva3WelzbA4Qd0M5pXoCJxUBHANB5Dk3yQK310VrrpiRXJTm24ZgAYIdoKZ2Megct2YoBSgAmk64kj/Z7vyHJnCHKva2UsjbJ40l+v9a6emCBUsrpSU5PkhkzZox9pNBGQ3WVXfaKUxuIBNgeklIAmJzuSbJPrfW5UspRSa4rpby+1rq5f6Fa65IkS5Jk1qxZtYE4ASa04R41M//o2JGUAkDn2ZBkn37vu3qX9am1PtPv9Q2llI1J9kryw7ZECNuwPc+Pjrb100BDMPF5phQAOs9dSQ4spXSVUqYlOSnJN/sXKKVM7/f6LUn2TE83XgCYULSUAkCHqbU+X0o5I8kN6fmC+fJa68pSysLe9YuTnNz7vGiSbEzywVrri81EDGNL6ydMLpJSWtM7eNK8p4boU7/iW20OBoBa6/IkywcsW9zv9UVJLmp3XEw+Q3W1vXT+7AYiASYr3XcBAABojJZSAACAcTLU6L1G7t2allIAAAAaIykFAACgMS113y2lHJ1kUZKXJbms1vqZAetPSfLfk5QkLyT5nVrryjGOFQCAScyoujA1jZiUllJ2TbI4yRFJfpTkjlLKjbXWVf2KPZzkHbXWn5RS3pPkfyfpHo+AAWhI7yjcLZl7zvjFAUwKElBgi1ZaSg9N8kCt9dEkKaVcleTYJH1Jaa31H/uVvz2JJ3cBABhyShmYDIYawIgd00pS2pXk0X7vNySZs43yv5Nk2VAreifxPj1JZsyY0VqEAAB0hiF7VPxK28MAOsuYDnRUSpmTZEF6ni8dpNa6pNY6q9Y6a/r06WN5aAAAADpQKy2lG5Ls0+99V++yrZRSDk5yaZL31FqfHJvwtt9wXUQunT97h7dvddsm9Y973lODuxIs+8F/rO+EzwMATHAtPmfu2VFgJK0kpXclObCU0pXkx0lOSrKwf4FSyowkX0tySq314TGPcrIY6pd304OBTMSYAACAKWPEpLTW+nwp5YwkN6Snu+/ltdaVpZSFvesXJzk3ySuTXFJKSZIXa62zxi9sAAAAJoOW5imttS5PsnzAssX9Xp+W5LSxDQ0AAIDJrqWkFACAyWMsxuAYOIbF8d1mBAR2zJiOvgsAAADbQ0spg7U4mh4AAMBoSUoBABi161cPnpIOoBWS0gmuXfOmqkhgahlpbmMAgHaRlAIA0GOIR3jmPfVYlr3i1AaCAaYKSSkAANs076nLmg4BmMQkpQBTiD8sAYCJxpQwAAAANEZSCgAAQGN03wUAIInR+IFmaCkFAACgMZJSAAAAGqP77ngZYp6vHSnXf1J7c4QB7dZqV77ju/feekHv77b+22/5HXbp/NljExwAMClISgEAJrEFS+8ecrkpooCJQvddAAAAGiMpBQAAoDG67wIATHK66kJnGGosh0HjNkxCktJhbPXLe8W3hi8495zxD2ZbegcT6T8g0lBa/jwAQOcaYgDFkf5GAGia7rsAAAA0RlIKAABAY6ZM992hhkM3Vx4AAECzpkxSCgDQlPH4cnzIfb52VLsEJqCpMPiRpLSD9A1WZKAiAABgkpCUAgB0oKGmebn+qQYCARglAx0BAADQGC2lAAATyRBzjTY+LzrAONJSCgAAQGMmR0tpv28U5z3VMzrVslecOqjYoGcvhhgwaMv2O3JsAIDRWLD07iH/Fjk+/t4A/sNkG5F3ciSlE9hQF0wy9EUzXNkdLdcuEy0eAOgIQ3yxvd1fjgNMApJSAGDKGo/5QwHYPpJSAIBxNtT0LXlt613t9EqCycU9vTUDHQEAANAYLaUAQEfolK62Q8U5r4E4gKmlkwc/kpQCAOyoIUfh/5W2hwHQySSlAABjaMjnRwEYlqQUAGAEQ3XJTUzhAkxs2zM9ZZMMdAQAAEBjpnRLaatDMbf60PD2DO3c5DDQk2kI6sn0WQAAYCqa0kkpADB1DNcFF4BmSUoBgClryEGJVnxriHJ65gCMF0kpANAW29NS2eT8o+16NMQjKAA9JKUAwJRgqhaAiUlSCgB0rhUXNB0BAKM0aZNS34YCTCx9v5cHPq8395z2B8O4G+2gQq1u3+oI+QBMXJM2KQUAOtNov1j2rCZAZ5GU7iAVHgAAwOhJSgGAMddqa+eyV5w6zpEAMNFJSgGAxhgDAoCdmg4AAACAqUtLKQAAwBQy0UYu11IKAABAY1pKSkspR5dS1pZSHiylfGKI9aWUclEpZV0p5d5SyiFjHyoAsIW6GYDJYsSktJSya5LFSd6T5OAkJwxRsb0/yWuTHJBkQZK/GuM4AYBe6mYAJpNWWkoPTfJArfXRWuumJFclOXZAmWOTXF57rEqycyllnzGOFQDooW4GYNJoZaCjriSP9nu/IcmcFsoMXJZSyulJTu99+2wp5bvbE+wwXpXkX8dgP03o1Ng7Ne6kc2Pv1LiTzo29U+NOOi72T255Mdq4Xzv6WDqGunl8dGrcSefGLu72End7dWrcST45VrG3VDe3dfTdWuuSJEvGcp+llJW11lljuc926dTYOzXupHNj79S4k86NvVPjTjo39k6Nu9Opm/9Dp8addG7s4m4vcbdXp8adtD/2VrrvbkjSv7tPV++y7S0DAIwNdTMAk0YrSeldSQ4spXSVUqYlOSnJNweUWZ7kQ0nSO9DC5lrrowEAxoO6GYBJY8Tuu7XW50spZyS5IT1J7OW11pWllIW96xcnuTbJ3FLKuiQbk/zWOMY80Jh2OWqzTo29U+NOOjf2To076dzYOzXupHNj79S4207dPG46Ne6kc2MXd3uJu706Ne6kzbGXWms7jwcAAAB9Wum+CwAAAONCUgoAAEBjOiIpLaX8RinlgVLK5lLKsEMTl1KOLqWsLaU8WEr5RL/lv1BKuamUcn8p5cZSyivaFPeIxy2lvKmUsrrfz09LKWf1rvtUKeWxfuuOaUfcrcbeW259b5nVpZSV27t9E3GXUvYppdzae608XEr5g37r2n7Oh7tu+60vpZSLSinrSin39g5Y0tK2Dcd9Su//w9pSyj39793hrpt2aSH2OaWUn/S7Ds5tdduG4/54v5jXllJeKqX8Qu+6xs55KeXLpZTHSylrh1k/Ia9xtq2om9taN7d6voa715s6360eu0yQurmF37MT9vdVC7FPyHq5hbjVyWMX88Stj2utE/4nyX5J3pTkliSzhimza5L16Rn+flqSlUkO6V33F0l+v/f12UkualPc23XcJC9L8qMkr+19/6kkH2vonLcUe+85f9VoP3s7406yV5KDe1//fJJ/StLdxDnf1nXbr8yvJ7k+SUlySJL7Wt224bgPTfKfel+/J8nqka6bCRT7nCRf35Ftm4x7QPn3Jvn2BDnn7+y9dtcOs37CXeN+Wvp/VTe393x3ZL3c6rEzAermFuuHCfn7qsXYJ1y93GLcc6JOHqu4J2x93BEtpbXWB2ut3x2h2KFJHqi1Plpr3ZTkqiTH9q47NslXel9f3m/5eNve4x6Z5Hu11h+Ma1StGe05m7DnvNb6o1rrmt7XzyRZk2TvNsU30Lau2y2OTc/ImrXWuirJzqWUfVrctrG4a63/WGv9Se/b29PcOR5oNOdtQp/zAU5OckVbIhtBrfXWJP+2jSIT8RpnBOrmtuvUermlY0+QurlT6+SWYp+g9bI6uY0mcn3cEUlpi7qS9J9/bUPvsiSZXmt9Ikl6//3FNsW0vcf9QAZfsGeWUh4qpXy1lPLK8QhyGK3GXpNs6ZLzX3dg+7G2XcctpcxMMjs9v5y3aOc539Z1O1KZVrYdL9t77N9Jsqzf++Gum3ZoNfa39XZT+XYppXs7tx0PLR+7lPJzSY5Oz5QgWzR5zkcyEa9xxoa6eex0ar283cdusG7u1Dp5W3ENZ6LUy+rkiVUnN3Z9jzhPabuUUr6Vnq4bA/1hrfX6dsfTqm3FvZ372SXJvCTn9Fv8hSR/nJ4L91NJLkrvROhjYYxif1ut9UellF9M8n9LKQ/VWm8amwiHNobnfM8k1yQ5q983h+N6zqeiUsqcJAuSvKPf4rZfN9vpniT71FqfK6UcleS6Usrrmw5qO7w3yT/UWvt/GzrRzzkTkLq5vXVzp9bLibq5k3RgvaxOngImTFJaa/2VUe5iQ3r6OW/R1bssSZ4opUyvtT5RSpme5PFRHqvPtuIupWzPcd+TZFWt9cf99v1Ev30tTs9zO2NmLGKvtf6o99/HSynXpOebzZsywc95KWVaer6xuqLW+rV++x7Xcz6EbV23A8vcOaDMtBa2HS+txJ1SysFJLk3ynlrrk1uWb+O6aYcRY+/tOrbl9Q2llI3p+WOrpc89Trbn2INadho+5yOZiNc4UTenzXVzp9bLYxX7BKibO7VO7h/XNo8/AetldfLEqpMbu74nU/fdu5IcWErp6v2ldlKSb/auW57kN3tf/2a/5eNte447qK9577cnW/x6knVjGt22jRh7KWWP3i4JKaXskZ6uCeta3X6ctBJ3Sc8v5Adrrf9rwLp2n/NtXbdbLE/vN8K9o6BtrrU+2uK2jcVdSpmR5GtJTqm1Ptxv+baum3ZoJfbp/V6/Jcme6fkjakKf8954/1OSd6VnoIIty5o+5yOZiNc4Y0PdPHY6tV5u6dgTpG7u1Do5rRx/gtbL6uSJVSc3d33XNo/6tCM/Sd6Xnmz8hSQ/TnJD7/LXJFner9wxSR5I8mB6uhZtWf7KJN9Kcn/vv7/QpriHPO4Qce+R5Mn0jojWb/nl6XnQ/6EkN6an60K7zvmIsSd5fW9896VnlLw/SVIm+jlPT3eV2hv76t6fY5o650Ndt0kWJlnY+7qkp+vSut5YZ21r2zZeIyPF/b+TPNXvHK8c6bqZQLF/NMna3p9VSeZ0wjnvfT8/yZUDtmv0nKfnj/p/SbIpPb/LF3TCNe5nxP9XdXMb6+ZW4t7Wvd7U+d6O2CdE3TzS79mJ/PuqhdgnZL3cQtzq5LGLecLWx1t+UQEAAEDbTabuuwAAAHQYSSkAAACNkZQCAADQGEkpAAAAjZGUAgAA0BhJKQAAAI2RlAIAANCY/x9KsJg+IGRBWQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.subplot(1,2,1)\n", + "plt.hist(costheta_Ds,alpha=0.7,density=True,bins=70, label=\"MC Ds tuple\");\n", + "plt.hist(costheta_Dplus,alpha=0.5,density=True,bins=70, label=\"MC Dplus tuple\");\n", + "plt.legend()\n", + "plt.subplot(1,2,2)\n", + "plt.hist(costheta_MC,alpha=0.7,density=True,bins=70, label=\"MC Ds+Dplus tuple\");\n", + "plt.hist(costheta_data,alpha=0.5,density=True,bins=70, label=\"data before cut\");\n", + "plt.legend()\n", + "fig = plt.gcf()\n", + "fig.set_size_inches(16,8)" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [], + "source": [ + "MC_Dplus_tuple_dict_presel_9[\"cos_thetal\"]=costheta_Dplus\n", + "MC_Ds_tuple_dict_presel_9[\"cos_thetal\"]=costheta_Ds\n", + "data_tuple_dict_presel_4[\"cos_thetal\"]=costheta_data" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [], + "source": [ + "MC_Dplus_tuple_dict_presel_10={}\n", + "\n", + "\n", + "indices=np.where(MC_Dplus_tuple_dict_presel_9[\"cos_thetal\"]!=-2)[0]\n", + "labels = return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0)+['cos_thetal']\n", + "\n", + "for label in labels: \n", + " MC_Dplus_tuple_dict_presel_10[label]=MC_Dplus_tuple_dict_presel_9[label][indices]\n", + " \n", + "\n", + "MC_Ds_tuple_dict_presel_10={}\n", + "\n", + "\n", + "indices=np.where(MC_Ds_tuple_dict_presel_9[\"cos_thetal\"]!=-2)[0]\n", + "labels = return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0)+['cos_thetal']\n", + "\n", + "for label in labels: \n", + " MC_Ds_tuple_dict_presel_10[label]=MC_Ds_tuple_dict_presel_9[label][indices]\n", + " \n", + "data_tuple_dict_presel_5={}\n", + "\n", + "\n", + "indices=np.where(data_tuple_dict_presel_4[\"cos_thetal\"]!=-2)[0]\n", + "labels = return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0)+['cos_thetal']\n", + "\n", + "for label in labels: \n", + " data_tuple_dict_presel_5[label]=data_tuple_dict_presel_4[label][indices] " + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [], + "source": [ + "data_tuple_dict=data_tuple_dict_presel_5\n", + "MC_Ds_tuple_dict=MC_Ds_tuple_dict_presel_10\n", + "MC_Dplus_tuple_dict=MC_Dplus_tuple_dict_presel_10" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [], + "source": [ + "if l_flv[l_index]=='mu':\n", + " \n", + " lower_Dplus_mass_data=1830\n", + " lower_Dplus_mass_mc=lower_Dplus_mass_data\n", + " \n", + " upper_Dplus_mass=1910\n", + " upper_Dplus_mass_mc=upper_Dplus_mass_data\n", + " \n", + " lower_Ds_mass = 1930\n", + " lower_Ds_mass_mc=lower_Ds_mass_data\n", + " \n", + " upper_Ds_mass = 2010\n", + " upper_Ds_mass_mc=upper_Ds_mass_data\n", + " \n", + " \n", + "if l_flv[l_index]=='e':\n", + " \n", + " lower_Dplus_mass_data=1810\n", + " lower_Dplus_mass_mc=1790\n", + " \n", + " upper_Dplus_mass_data=1920\n", + " upper_Dplus_mass_mc=1950\n", + "\n", + " lower_Ds_mass_data = 1920\n", + " lower_Ds_mass_mc=1890\n", + " upper_Ds_mass_data = 2020\n", + " upper_Ds_mass_mc=2050\n", + "\n", + "#Retrieve mc signal and data bkg events\n", + "\n", + "data_bkg_indices=[]\n", + "MC_Ds_sig_indices=[]\n", + "MC_Dplus_sig_indices=[]\n", + "\n", + "\n", + "for i in range(len(data_tuple_dict[\"Ds_ConsD_M\"])):\n", + " \n", + " m = data_tuple_dict[\"Ds_ConsD_M\"][i]\n", + " \n", + " #selecting the out of signal regions\n", + " if 0,\n", + " ,\n", + " )" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "def find_file_path(l_index, type_index, mag_index): \n", - " return \"/disk/lhcb_data/davide/Rphipi/\"+data_type[type_index]+\"/Ds_phipi_\"+l_flv[l_index]+l_flv[l_index]+\"/Ds_phipi_\"+l_flv[l_index]+l_flv[l_index]+\"_Mag\"+mag_status[mag_index]+\".root\"" + "t_MC_Dplus, t_MC_Ds, t_data" ] }, { @@ -63,29 +113,71 @@ "metadata": {}, "outputs": [], "source": [ - "data = r.TFile(find_file_path(l_index, 1, mag_index))\n", - "MC = r.TFile(find_file_path(l_index, 0, mag_index))" + "#Switch on only the branches that you need\n", + "t_data.SetBranchStatus(\"*\",0)\n", + "t_MC_Dplus.SetBranchStatus(\"*\",0)\n", + "t_MC_Ds.SetBranchStatus(\"*\",0)\n", + "\n", + "\n", + "for branch in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0):\n", + " t_MC_Ds.SetBranchStatus(branch, 1)\n", + "\n", + "for branch in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0):\n", + " t_MC_Dplus.SetBranchStatus(branch, 1)\n", + " \n", + "for branch in return_branches(data_index=1, mother_index=1, l_index=l_index, meson_index=0): \n", + " t_data.SetBranchStatus(branch, 1)\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "t_data = data.Get(\"Ds_OfflineTree/DecayTree\")\n", - "t_data" + "#Create a dictionary\n", + "\n", + "#dict ={'branch_name'=[branch_value[event]]}\n", + "\n", + "MC_Ds_tuple_dict = {}\n", + "branches_needed=return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0)\n", + "for branch in branches_needed:\n", + " \n", + " MC_Ds_tuple_dict[branch] = rn.root2array(\n", + " \n", + " filenames=find_file_path(l_index, mother_index=0, data_index=0),\n", + " treename = tree_name_Ds,\n", + " branches = branch,\n", + " start=0,\n", + " stop=t_MC_Ds.GetEntries(),\n", + " )\n", + " \n", + "MC_Dplus_tuple_dict = {}\n", + "branches_needed=return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0)\n", + "for branch in branches_needed:\n", + " \n", + " MC_Dplus_tuple_dict[branch] = rn.root2array(\n", + " \n", + " filenames=find_file_path(l_index, mother_index=1, data_index=0),\n", + " treename = tree_name_Dplus,\n", + " branches = branch,\n", + " start=0,\n", + " stop=t_MC_Dplus.GetEntries(),\n", + " )\n", + " \n", + "data_tuple_dict = {}\n", + "\n", + "branches_needed=return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0)\n", + "for branch in branches_needed:\n", + " \n", + " data_tuple_dict[branch] = rn.root2array(\n", + " \n", + " filenames=find_file_path(l_index,mother_index=0, data_index=1),\n", + " treename = tree_name_Ds,\n", + " branches = branch,\n", + " start=0,\n", + " stop=t_data.GetEntries(),\n", + " )" ] }, { @@ -95,203 +187,7 @@ "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t_MC = MC.Get(\"Ds_OfflineTree/DecayTree\")\n", - "t_MC" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "t_data.SetBranchStatus(\"*\",0)\n", - "t_data.SetBranchStatus(\"Ds_ENDVERTEX_CHI2\",1)\n", - "t_data.SetBranchStatus(\"Ds_ENDVERTEX_NDOF\",1)\n", - "t_data.SetBranchStatus(\"Ds_OWNPV_CHI2\",1)\n", - "t_data.SetBranchStatus(\"Ds_OWNPV_NDOF\",1)\n", - "t_data.SetBranchStatus(\"Ds_IP_OWNPV\",1)\n", - "t_data.SetBranchStatus(\"Ds_IPCHI2_OWNPV\",1)\n", - "t_data.SetBranchStatus(\"Ds_DIRA_OWNPV\",1)\n", - "t_data.SetBranchStatus(\"Ds_ConsD_M\",1)\n", - "\n", - "t_data.SetBranchStatus(l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index], 1)\n", - "t_data.SetBranchStatus(\"Ds_Hlt1TrackMVADecision_TOS\", 1)\n", - "t_data.SetBranchStatus(\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\", 1)\n", - "t_data.SetBranchStatus(\"Ds_Hlt2Phys_TOS\", 1)\n", - "\n", - "\n", - "t_MC.SetBranchStatus(\"Ds_ENDVERTEX_CHI2\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_ENDVERTEX_NDOF\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_OWNPV_CHI2\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_OWNPV_NDOF\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_IP_OWNPV\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_IPCHI2_OWNPV\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_DIRA_OWNPV\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_ConsD_M\", 1)\n", - "\n", - "t_MC.SetBranchStatus(l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index], 1)\n", - "t_MC.SetBranchStatus(\"Ds_Hlt1TrackMVADecision_TOS\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\", 1)\n", - "t_MC.SetBranchStatus(\"Ds_Hlt2Phys_TOS\", 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "t_data.SetBranchStatus(\"phi_ENDVERTEX_CHI2\",1)\n", - "t_data.SetBranchStatus(\"phi_ENDVERTEX_NDOF\",1)\n", - "t_data.SetBranchStatus(\"phi_OWNPV_CHI2\",1)\n", - "t_data.SetBranchStatus(\"phi_OWNPV_NDOF\",1)\n", - "t_data.SetBranchStatus(\"phi_IP_OWNPV\",1)\n", - "t_data.SetBranchStatus(\"phi_IPCHI2_OWNPV\",1)\n", - "t_data.SetBranchStatus(\"phi_DIRA_OWNPV\",1)\n", - "\n", - "\n", - "t_MC.SetBranchStatus(\"phi_ENDVERTEX_CHI2\", 1)\n", - "t_MC.SetBranchStatus(\"phi_ENDVERTEX_NDOF\", 1)\n", - "t_MC.SetBranchStatus(\"phi_OWNPV_CHI2\", 1)\n", - "t_MC.SetBranchStatus(\"phi_OWNPV_NDOF\", 1)\n", - "t_MC.SetBranchStatus(\"phi_IP_OWNPV\", 1)\n", - "t_MC.SetBranchStatus(\"phi_IPCHI2_OWNPV\", 1)\n", - "t_MC.SetBranchStatus(\"phi_DIRA_OWNPV\", 1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "branches_needed = [\n", - " \"Ds_ENDVERTEX_CHI2\",\n", - " \"Ds_ENDVERTEX_NDOF\",\n", - " \"Ds_OWNPV_CHI2\",\n", - " \"Ds_OWNPV_NDOF\",\n", - " \"Ds_IPCHI2_OWNPV\",\n", - " \"Ds_IP_OWNPV\",\n", - " \"Ds_DIRA_OWNPV\",\n", - " \"Ds_ConsD_M\",\n", - " l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index],\n", - " \"Ds_Hlt1TrackMVADecision_TOS\",\n", - " \"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\",\n", - " \"Ds_Hlt2Phys_TOS\",\n", - " \n", - " \"phi_ENDVERTEX_CHI2\",\n", - " \"phi_ENDVERTEX_NDOF\",\n", - " \"phi_OWNPV_CHI2\",\n", - " \"phi_OWNPV_NDOF\",\n", - " \"phi_IP_OWNPV\",\n", - " \"phi_IPCHI2_OWNPV\",\n", - " \"phi_DIRA_OWNPV\",\n", - "\n", - " ] " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "MC_count=0\n", - "for event in enumerate(t_MC):\n", - " MC_count+=1\n", - " \n", - "data_count=0\n", - "for event in enumerate(t_data):\n", - " data_count+=1" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MC event count 24354, real data event count 106404\n" - ] - } - ], - "source": [ - "print(\"MC event count {0}, real data event count {1}\".format(MC_count,data_count))" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "MC_tuple_dict = {}\n", - "\n", - "for i in range(len(branches_needed)):\n", - " \n", - " MC_tuple_dict[branches_needed[i]] = rn.root2array(\n", - " \n", - " filenames=find_file_path(l_index, 0, mag_index),\n", - " treename = tree_name,\n", - " branches = branches_needed[i],\n", - " start=0,\n", - " stop=MC_count,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "data_tuple_dict = {}\n", - "\n", - "for i in range(len(branches_needed)):\n", - " \n", - " data_tuple_dict[branches_needed[i]] = rn.root2array(\n", - " \n", - " filenames=find_file_path(l_index, 1, mag_index),\n", - " treename = tree_name,\n", - " branches = branches_needed[i],\n", - " start=0,\n", - " stop=data_count,\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "Ds_constrained_mass_MC = np.array([MC_tuple_dict[\"Ds_ConsD_M\"][i][0] for i in range(len(MC_tuple_dict[\"Ds_ConsD_M\"]))])\n", - "Ds_constrained_mass_data = np.array([data_tuple_dict[\"Ds_ConsD_M\"][i][0] for i in range(len(data_tuple_dict[\"Ds_ConsD_M\"]))])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -303,56 +199,632 @@ } ], "source": [ + "#Check the Ds mass plot\n", + "Dplus_mass_MC = np.array([MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"][i][0] for i in range(len(MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"]))])\n", + "Ds_mass_MC = np.array([MC_Ds_tuple_dict[\"Ds_ConsD_M\"][i][0] for i in range(len(MC_Ds_tuple_dict[\"Ds_ConsD_M\"]))])\n", + "Ds_mass_data = np.array([data_tuple_dict[\"Ds_ConsD_M\"][i][0] for i in range(len(data_tuple_dict[\"Ds_ConsD_M\"]))])\n", + "\n", "plt.subplot(1,2,1)\n", - "plt.hist(Ds_constrained_mass_MC,bins=70, range=(0,3000));\n", + "plt.hist(Ds_mass_MC,bins=70, range=(1750,2100), density=True);\n", + "plt.hist(Dplus_mass_MC,bins=70, range=(1750,2100), density=True);\n", "plt.subplot(1,2,2)\n", - "plt.hist(Ds_constrained_mass_data,bins=70, range=(0,3000));\n", + "plt.hist(Ds_mass_data,bins=70, range=(1100,2750), density=True);\n", "fig = plt.gcf()\n", "fig.set_size_inches(16,6)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "data_bkg_indices_over=[]\n", - "data_bkg_indices_under=[]\n", + "#HLT1 PRESELECTION\n", + "data_tuple_dict_presel_1={}\n", + "MC_Ds_tuple_dict_presel_1={}\n", + "MC_Dplus_tuple_dict_presel_1={}\n", "\n", - "MC_sig_indices=[]" + "\n", + "for label in return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0): \n", + " data_tuple_dict_presel_1[label] = data_tuple_dict[label][data_tuple_dict[\"Ds_Hlt1TrackMVADecision_TOS\"]]\n", + " \n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_1[label] = MC_Ds_tuple_dict[label][MC_Ds_tuple_dict[\"Ds_Hlt1TrackMVADecision_TOS\"]]\n", + "\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_1[label] = MC_Dplus_tuple_dict[label][MC_Dplus_tuple_dict[\"Dplus_Hlt1TrackMVADecision_TOS\"]]\n", + "\n", + "#RareCharm D2pi l l HLT2 PRESELECTION\n", + "\n", + "data_tuple_dict_presel_2={}\n", + "MC_Ds_tuple_dict_presel_2={}\n", + "MC_Dplus_tuple_dict_presel_2={}\n", + "\n", + "for label in return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0):\n", + " data_tuple_dict_presel_2[label] = data_tuple_dict_presel_1[label][data_tuple_dict_presel_1[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]]\n", + "\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0):\n", + " MC_Ds_tuple_dict_presel_2[label] = MC_Ds_tuple_dict_presel_1[label][MC_Ds_tuple_dict_presel_1[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]]\n", + "\n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0): \n", + " MC_Dplus_tuple_dict_presel_2[label] = MC_Dplus_tuple_dict_presel_1[label][MC_Dplus_tuple_dict_presel_1[\"Dplus_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]]\n", + "\n", + "#PID preselection\n", + "\n", + "#MC_PID_indices=np.where(MC_tuple_dict_presel_2[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "\n", + "data_PID_indices_plus=np.where(data_tuple_dict_presel_2[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "data_PID_indices_minus=np.where(data_tuple_dict_presel_2[l_flv[l_index]+\"_minus_MC15TuneV1_ProbNN\"+l_flv[l_index]]>0.4)\n", + "data_PID_indices_pi=np.where(data_tuple_dict_presel_2[\"pi_MC15TuneV1_ProbNNpi\"]>0.4)\n", + "\n", + "data_PID_indices = np.intersect1d(data_PID_indices_plus,data_PID_indices_minus)\n", + "data_PID_indices = np.intersect1d(data_PID_indices,data_PID_indices_pi)\n", + "data_tuple_dict_presel_3={}\n", + "MC_Ds_tuple_dict_presel_3={}\n", + "MC_Dplus_tuple_dict_presel_3={}\n", + "\n", + "for label in return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0):\n", + " data_tuple_dict_presel_3[label] = data_tuple_dict_presel_2[label][data_PID_indices]\n", + " \n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_3[label] = MC_Ds_tuple_dict_presel_2[label]#[MC_PID_indices]\n", + " \n", + "for label in return_branches(data_index=0, mother_index=1, l_index=l_index, meson_index=0):\n", + " MC_Dplus_tuple_dict_presel_3[label] = MC_Dplus_tuple_dict_presel_2[label]#[MC_PID_indices]" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "for i in range(len(data_tuple_dict[\"Ds_ConsD_M\"])):\n", - " #retrieving the Ds reconstructed mass\n", - " Ds_m = data_tuple_dict[\"Ds_ConsD_M\"][i][0]\n", + "if l_flv[l_index]=='mu':\n", + " lower_phi_mass = 980\n", + " upper_phi_mass = 1060\n", " \n", - " #selecting the out of signal regions\n", - " if 0" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if l_flv[l_index]=='mu':\n", + " lower_MC = 1.8\n", + " upper_MC = 2.1\n", + " lower_data = 1.0\n", + " upper_data = 3.0\n", + " \n", + "if l_flv[l_index]=='e':\n", + " lower_MC = 1.75\n", + " upper_MC = 2.15\n", + " lower_data = 1.0\n", + " upper_data = 3.5\n", + "\n", + "\n", + "#plt.suptitle('Reconstructed D_s mass', fontsize=15)\n", + "plt.subplot(1,2,1)\n", + "label_1=\"Ds_ConsD_M\"\n", + "label_2=\"Dplus_ConsD_M\"\n", + "#plt.title('MC', fontsize=12)\n", + "#plt.hist([MC_Ds_tuple_dict[label_1][i][0]/1000 for i in range(len(MC_Ds_tuple_dict[\"Ds_ConsD_M\"]))] + [MC_Dplus_tuple_dict[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"]))],alpha=0.3,bins=70,range=(1.8,2.1), label='MC no presel');\n", + "plt.hist([MC_Ds_tuple_dict_presel_1[label_1][i][0]/1000 for i in range(len(MC_Ds_tuple_dict_presel_1[\"Ds_ConsD_M\"]))] + [MC_Dplus_tuple_dict_presel_1[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_1[\"Dplus_ConsD_M\"]))],alpha=0.4,bins=70,range=(lower_MC,upper_MC), label='MC after HLT1 TOS presel');\n", + "plt.hist([MC_Ds_tuple_dict_presel_2[label_1][i][0]/1000 for i in range(len(MC_Ds_tuple_dict_presel_2[\"Ds_ConsD_M\"]))] + [MC_Dplus_tuple_dict_presel_2[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_2[\"Dplus_ConsD_M\"]))],alpha=0.5,bins=70,range=(lower_MC,upper_MC), label='MC after HLT2 TOS presel');\n", + "plt.hist([MC_Ds_tuple_dict_presel_4[label_1][i][0]/1000 for i in range(len(MC_Ds_tuple_dict_presel_4[\"Ds_ConsD_M\"]))] + [MC_Dplus_tuple_dict_presel_4[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_4[\"Dplus_ConsD_M\"]))],alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after cutting on phi mass');\n", + "\n", + "#plt.hist([MC_Dplus_tuple_dict[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"]))],alpha=0.3,bins=70,range=(1.8,2.1), label='MC no presel');\n", + "plt.hist([MC_Dplus_tuple_dict_presel_1[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_1[\"Dplus_ConsD_M\"]))],alpha=0.4,bins=70,range=(lower_MC,upper_MC), label='MC after HLT1 TOS presel');\n", + "plt.hist([MC_Dplus_tuple_dict_presel_2[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_2[\"Dplus_ConsD_M\"]))],alpha=0.5,bins=70,range=(lower_MC,upper_MC), label='MC after HLT2 TOS presel');\n", + "plt.hist([MC_Dplus_tuple_dict_presel_4[label_2][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_4[\"Dplus_ConsD_M\"]))],alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after cutting on phi mass');\n", + "#\n", + "plt.legend(fontsize='10')\n", + "plt.ylabel('# events', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "\n", + "label=\"Ds_ConsD_M\"\n", + "plt.subplot(1,2,2)\n", + "plt.title('Data', fontsize=12)\n", + "#plt.hist([data_tuple_dict[\"Ds_ConsD_M\"][i][0]/1000 for i in range(len(data_tuple_dict[\"Ds_ConsD_M\"]))],alpha=0.3,bins=70,range=(1.0,3.0), label='Data');\n", + "plt.hist([data_tuple_dict_presel_1[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_1[\"Ds_ConsD_M\"]))],alpha=0.4,bins=70,range=(lower_data,upper_data),label='Data after HLT1 TOS presel');\n", + "plt.hist([data_tuple_dict_presel_2[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_2[\"Ds_ConsD_M\"]))],alpha=0.5,bins=70,range=(lower_data,upper_data), label='Data after HLT2 TOS presel');\n", + "plt.hist([data_tuple_dict_presel_3[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_3[\"Ds_ConsD_M\"]))],alpha=0.7,bins=70,range=(lower_data,upper_data), label='Data after \\mu & \\pi PID presel');\n", + "plt.hist([data_tuple_dict_presel_4[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_4[\"Ds_ConsD_M\"]))],alpha=0.7,bins=70,range=(lower_data,upper_data), label='Data after cutting on phi mass');\n", + "plt.legend(fontsize='10')\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(18,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'/reco_mass.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ - "for i in range(len(MC_tuple_dict[\"Ds_ConsD_M\"])):\n", - " #retrieving the Ds reconstructed mass\n", - " Ds_m = MC_tuple_dict[\"Ds_ConsD_M\"][i][0]\n", + "#Getting rid of MC Background using BKG_CAT in MC Ds\n", + "#Keeping only low mass and ghost background\n", + "MC_Ds_indices=np.where(MC_Ds_tuple_dict_presel_4[\"Ds_BKGCAT\"]<65)[0]\n", + "\n", + "MC_Ds_tuple_dict_presel_5={}\n", + "\n", + "for label in return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0): \n", + " MC_Ds_tuple_dict_presel_5[label] = MC_Ds_tuple_dict_presel_4[label][MC_Ds_indices]\n", " \n", - " #selecting the signal regions\n", - " if 1850" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Check the phi mass plot\n", + "if l_flv[l_index]=='e':\n", + " lower=700\n", + " upper=1350\n", + "if l_flv[l_index]=='mu':\n", + " lower=925\n", + " upper=1100\n", + "\n", + "phi_mass_MC_Ds = np.array([MC_Ds_tuple_dict_presel_9[\"phi_M\"][i] for i in range(len(MC_Ds_tuple_dict_presel_9[\"phi_M\"]))])\n", + "#phi_ConsD_mass_MC_Ds = np.array([MC_Ds_tuple_dict[\"Ds_ConsD_phi_1020_M\"][i][0] for i in range(len(MC_Ds_tuple_dict[\"phi_M\"]))])\n", + "\n", + "phi_mass_MC_Dplus = np.array([MC_Dplus_tuple_dict_presel_9[\"phi_M\"][i] for i in range(len(MC_Dplus_tuple_dict_presel_9[\"phi_M\"]))])\n", + "#phi_ConsD_mass_MC_Dplus = np.array([MC_Ds_tuple_dict[\"Ds_ConsD_phi_1020_M\"][i][0] for i in range(len(MC_Ds_tuple_dict[\"phi_M\"]))])\n", + "\n", + "\n", + "plt.hist(phi_mass_MC_Ds,bins=70, alpha=0.7,histtype='step', range=(lower,upper),label='phi_M from Ds MC', density=True);\n", + "plt.hist(phi_mass_MC_Dplus,bins=70, alpha=0.5, range=(lower,upper),label='phi_M from Dplus MC', density=True);\n", + "plt.legend(fontsize='10')\n", + "plt.ylabel('# events a.u.', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig = plt.gcf()\n", + "fig.set_size_inches(8,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'/phi_reco_m_'+l_flv[l_index]+'.png', format='png', dpi=100)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1019.451527895175, 10.386124443762935)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "phi_mass_MC_Dplus.mean(), phi_mass_MC_Dplus.std() " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1019.6615397712993, 10.228840405403313)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "phi_mass_MC_Ds.mean(), phi_mass_MC_Ds.std() " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if l_flv[l_index]=='mu':\n", + " lower_MC = 1.8\n", + " upper_MC = 2.1\n", + " lower_data = 1.0\n", + " upper_data = 3.0\n", + " \n", + "if l_flv[l_index]=='e':\n", + " lower_MC = 1.7\n", + " upper_MC = 2.15\n", + " lower_data = 1.6\n", + " upper_data = 2.4\n", + "\n", + "#plt.suptitle('Reconstructed D_s mass', fontsize=15)\n", + "plt.subplot(1,2,1)\n", + "label=\"Ds_ConsD_M\"\n", + "plt.title('MC', fontsize=15)\n", + "left_h_Ds=[MC_Ds_tuple_dict_presel_9[label][i][0]/1000 for i in range(len(MC_Ds_tuple_dict_presel_9[\"Ds_ConsD_M\"]))]\n", + "label=\"Dplus_ConsD_M\"\n", + "left_h_Dplus=[MC_Dplus_tuple_dict_presel_9[label][i][0]/1000 for i in range(len(MC_Dplus_tuple_dict_presel_9[\"Dplus_ConsD_M\"]))]\n", + "plt.hist(left_h_Ds,alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after presel cuts',density=False);\n", + "plt.hist(left_h_Dplus,alpha=0.7,bins=70,range=(lower_MC,upper_MC), label='MC after presel cuts',density=False);\n", + "plt.legend(fontsize='12')\n", + "plt.ylabel('# events (a.u.)', fontsize=15)\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "\n", + "label=\"Ds_ConsD_M\"\n", + "plt.subplot(1,2,2)\n", + "plt.title('Data', fontsize=15)\n", + "right_h=[data_tuple_dict_presel_4[label][i][0]/1000 for i in range(len(data_tuple_dict_presel_4[\"Ds_ConsD_M\"]))]\n", + "plt.hist(right_h,alpha=0.7,bins=70,range=(lower_data,upper_data), color='green',label='Data after presel cuts',density=False);\n", + "plt.legend(fontsize='12')\n", + "plt.xlabel('Reconstructed D_s Mass (GeV)', fontsize=15)\n", + "fig=plt.gcf()\n", + "fig.set_size_inches(18,8)\n", + "plt.savefig('/home/hep/davide/Rphipi/'+l_flv[l_index]+'_dataMC_after_presel.png', format='png', dpi=100)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-11284.10784068, -3191.47331083, -4319.60960101, ...,\n", + " 4002.90405006, 1450.30552012, 2983.92342003])" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MC_Dplus_tuple_dict_presel_9[\"Dplus_PX\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "def get_boost_d_to_lab(data, mass, mother_index=mother_index):\n", + " \n", + " p_x = np.array(data[mother_ID[mother_index]+\"_PX\"])/1000\n", + " p_y = np.array(data[mother_ID[mother_index]+\"_PY\"])/1000\n", + " p_z = np.array(data[mother_ID[mother_index]+\"_PZ\"])/1000\n", + " \n", + " p_s = np.array([ p_x, p_y, p_z ])\n", + " \n", + " mod_p_s = np.sqrt(np.power(p_s,2).sum(axis=0))\n", + " \n", + " E_s = np.sqrt(np.power(mod_p_s,2)+np.power(mD,2))\n", + " \n", + " beta_X=p_x/E_s\n", + " beta_Y=p_y/E_s\n", + " beta_Z=p_z/E_s\n", + " \n", + " beta = mod_p_s/E_s\n", + " beta_vec= np.array([beta_X,beta_Y,beta_Z])\n", + "\n", + " return E_s, p_x, p_y, p_z, beta, beta_vec" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [], + "source": [ + "Dplus_Es, Dplus_p_x_s, Dplus_p_y_s, Dplus_p_z_s, Dplus_betas, Dplus_beta_vecs = get_E_beta(MC_Dplus_tuple_dict_presel_9, mD, mother_index=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-0.09567449673232613" + ] + }, + "execution_count": 131, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Dplus_beta_vecs[:,0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "metadata": {}, + "outputs": [], + "source": [ + "b = r.TVector3(Dplus_beta_vecs[:,0][0], Dplus_beta_vecs[:,0][1], Dplus_beta_vecs[:,0][2])" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9943688868860036" + ] + }, + "execution_count": 137, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "b.z()" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "v = r.TLorentzVector(Dplus_p_x_s[0], Dplus_p_y_s[0], Dplus_p_z_s[0], Dplus_Es[0])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-11.284107840680841" + ] + }, + "execution_count": 149, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Dplus_p_x_s[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-11.284107840680841" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v.X()" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [], + "source": [ + "l = r.TLorentzRotation(b)" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "metadata": {}, + "outputs": [], + "source": [ + "v1=l.VectorMultiplication(v)" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14875.647585213312" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v1.E()" ] }, { @@ -361,91 +833,379 @@ "metadata": {}, "outputs": [], "source": [ - "data_tuple_bkg={}\n", - "data_tuple_bkg_under = {}\n", - "data_tuple_bkg_over = {}\n", - "MC_tuple_sig ={}\n", - "\n", - "for label in branches_needed:\n", + "def costhetal(data, l_index=l_index, meson_index=meson_index):\n", " \n", - "\n", - " data_tuple_bkg[label] = data_tuple_dict[label][data_bkg_indices_under+data_bkg_indices_over]\n", - " data_tuple_bkg_under[label] = data_tuple_dict[label][data_bkg_indices_under]\n", - " data_tuple_bkg_over[label] = data_tuple_dict[label][data_bkg_indices_over]\n", - " MC_tuple_sig[label] = MC_tuple_dict[label][MC_sig_indices]\n", - " " + " p_e = np.array([data[l_flv[l_index]+\"_plus_PX\"], data[l_flv[l_index]+\"_plus_PY\"], data[l_flv[l_index]+\"_plus_PZ\"]])\n", + " \n", + " p_pi = np.array([data[\"pi_PX\"], data[\"pi_PY\"], data[\"pi_PZ\"]])\n", + " \n", + " num = (p_e*p_pi).sum(axis=0)\n", + " \n", + " den = np.sqrt((p_e*p_e).sum(axis=0))*np.sqrt((p_pi*p_pi).sum(axis=0))\n", + " \n", + " return num/den" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(np.concatenate((costhetal(MC_Dplus_tuple_dict),costhetal(MC_Ds_tuple_dict)),axis=0),bins=70,alpha=0.7,density=True, label='MC');\n", + "plt.hist(costhetal(data_tuple_dict),bins=70,alpha=0.3, density=True, label='data');\n", + "plt.legend(fontsize='15');\n", + "fig = plt.gcf()\n", + "fig.set_size_inches(18,8)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, "outputs": [], "source": [ - "nbins=70\n", - "MC_Ds_endvtx_chi2ratio=MC_tuple_dict[\"Ds_ENDVERTEX_CHI2\"]/MC_tuple_dict[\"Ds_ENDVERTEX_NDOF\"]\n", - "data_under_Ds_endvtx_chi2ratio=data_tuple_bkg_under[\"Ds_ENDVERTEX_CHI2\"]/data_tuple_bkg_under[\"Ds_ENDVERTEX_NDOF\"]\n", - "data_over_Ds_endvtx_chi2ratio=data_tuple_bkg_over[\"Ds_ENDVERTEX_CHI2\"]/data_tuple_bkg_over[\"Ds_ENDVERTEX_NDOF\"]" + "MC_Dplus_tuple_dict=MC_Dplus_tuple_dict_presel_9\n", + "MC_Ds_tuple_dict=MC_Ds_tuple_dict_presel_9\n", + "data_tuple_dict=data_tuple_dict_presel_4" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "#data_tuple_dict_presel={}\n", + "#\n", + "##data_tuple_for_NN=data_tuple_dict\n", + "#\n", + "#indices=[]\n", + "#for i in range(len(data_tuple_dict[\"Ds_ConsD_M\"])):\n", + "# Ds_m = data_tuple_dict[\"Ds_ConsD_M\"][i]\n", + "# if 1890np.max(data_bkg):\n", + " upper_limit=np.max(MC_sig)\n", + " else:\n", + " upper_limit=np.max(data_bkg)\n", + " \n", + " lower_limit=0\n", + " if \"DIRA\" in variable:\n", + " lower_limit=0.9998750\n", + " upper_limit=1.\n", + " \n", + " if \"PT\" in variable:\n", + " lower_limit=60.\n", + " upper_limit=0.\n", + " \n", + " if \"prob\" in variable:\n", + " lower_limit=0.\n", + " upper_limit=1.\n", + " \n", + " if \"Hlt\" in variable:\n", + " lower_limit=0.\n", + " upper_limit=2.\n", + " \n", + " \n", + " #Create and fill MC Signal histogram\n", + "\n", + " h_mc= r.TH1F(particle+\" \"+variable+\" MC/data comparison\", particle+\" \"+variable+\" MC/data comparison\", nbins, lower_limit, upper_limit)\n", + " \n", + " for i in range(len(MC_sig)):\n", + " h_mc.Fill(MC_sig[i])\n", + " \n", + " n1=h_mc.Integral(\"width\")\n", + " h_mc.Scale(1/n1)\n", + " h_mc.Integral(\"width\");\n", + " \n", + " #Create and fill data bkg histogram\n", + " h_data= r.TH1F(particle+\" \"+variable+\" from data\", particle+\" \"+variable+\" from data\", nbins, lower_limit, upper_limit)\n", + " for i in range(len(data_bkg)):\n", + " h_data.Fill(data_bkg[i])\n", + " \n", + " n2=h_data.Integral(\"width\")\n", + " h_data.Scale(1/n2)\n", + " h_data.Integral(\"width\");\n", + " \n", + " a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", + " b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", + " c=[h_data.GetBinContent(i) for i in range(nbins)]\n", + " d=[h_data.GetBinCenter(i) for i in range(nbins)]\n", + " plt.title(particle+\" \"+variable+\" Signal MC/ data comparison\", fontsize=15)\n", + " \n", + " plt.bar(b,a,width=width_MC,alpha=0.6, label=\"Signal MC\")\n", + " plt.bar(d,c,width=width_data, alpha=0.4, label=\"Background Data\")\n", + " if \"CHI2\" in variable:\n", + " plt.xlabel(\"CHI2/NDOF\", fontsize=12)\n", + "\n", + " plt.legend(fontsize=15)\n", + " fig = plt.gcf()\n", + " fig.set_size_inches(16,8)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Retrieve data from needed branch\n", + "plt.subplot(1,2,1)\n", + "MC_Ds_endvtx_chi2ratio=MC_Ds_tuple_dict[\"Ds_ENDVERTEX_CHI2\"]/MC_Ds_tuple_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "data_Ds_endvtx_chi2ratio=data_tuple_bkg[\"Ds_ENDVERTEX_CHI2\"]/data_tuple_bkg[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70,particle=\"Ds\", variable=\"END VTX CHI2\", \n", + " MC_sig=MC_Ds_endvtx_chi2ratio, data_bkg=data_Ds_endvtx_chi2ratio, \n", + " width_MC=0.05, width_data=0.06)\n", + "plt.subplot(1,2,2)\n", + "#Retrieve data from needed branch\n", + "MC_Dplus_endvtx_chi2ratio=MC_Dplus_tuple_dict[\"Dplus_ENDVERTEX_CHI2\"]/MC_Dplus_tuple_dict[\"Dplus_ENDVERTEX_NDOF\"]\n", + "data_Dplus_endvtx_chi2ratio=data_tuple_bkg[\"Ds_ENDVERTEX_CHI2\"]/data_tuple_bkg[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70,particle=\"Dplus\", variable=\"END VTX CHI2\", \n", + " MC_sig=MC_Dplus_endvtx_chi2ratio, data_bkg=data_Ds_endvtx_chi2ratio, \n", + " width_MC=0.05, width_data=0.06)\n", + "\n", + "plt.savefig('/home/hep/davide/Rphipi/endvtx_chi2.png', format='png', dpi=100)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "if np.max(MC_Ds_endvtx_chi2ratio)>np.max(data_under_Ds_endvtx_chi2ratio):\n", - " max_endvchi2_under=np.max(MC_Ds_endvtx_chi2ratio)\n", - "else:\n", - " max_endvchi2_under=np.max(data_under_Ds_endvtx_chi2ratio)\n", - " \n", - "if np.max(MC_Ds_endvtx_chi2ratio)>np.max(data_over_Ds_endvtx_chi2ratio):\n", - " max_endvchi2_over=np.max(MC_Ds_endvtx_chi2ratio)\n", - "else:\n", - " max_endvchi2_over=np.max(data_over_Ds_endvtx_chi2ratio)" + "MC_mu_endvtx_ownpv_chi2=MC_Ds_tuple_dict[l_flv[l_index]+\"_plus_OWNPV_CHI2\"]/MC_Ds_tuple_dict[\"Ds_ENDVERTEX_NDOF\"]\n", + "data_mu_endvtx_ownpv_chi2=data_tuple_bkg[l_flv[l_index]+\"_plus_OWNPV_CHI2\"]/data_tuple_bkg[\"Ds_ENDVERTEX_NDOF\"]\n", + "\n", + "plot_sb_comparison(nbins=70,particle=\"e\", variable=\"own pv CHI2\", \n", + " MC_sig=MC_mu_endvtx_ownpv_chi2, data_bkg=data_mu_endvtx_ownpv_chi2, \n", + " width_MC=0.5, width_data=0.6)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "h_mc_under= r.TH1F(\"Ds end vertex MC/data comparison under\", \"Ds end vertex MC/data under Ds mass comparison\",nbins, 0, max_endvchi2_under)\n", - "h_mc_over = r.TH1F(\"Ds end vertex MC/data comparison over\", \"Ds end vertex MC/data over Ds mass comparison\",nbins, 0, max_endvchi2_over)\n", + "#Retrieve data from needed branch\n", + "plt.subplot(1,2,1)\n", + "MC_Ds_IP_ownpv=MC_Ds_tuple_dict[\"Ds_IP_OWNPV\"]\n", + "data_Ds_IP_ownpv=data_tuple_bkg[\"Ds_IP_OWNPV\"]\n", "\n", - "for i in range(len(MC_Ds_endvtx_chi2ratio)):\n", - " h_mc_under.Fill(MC_Ds_endvtx_chi2ratio[i])\n", - " h_mc_over.Fill(MC_Ds_endvtx_chi2ratio[i])\n", + "#Plot\n", + "plot_sb_comparison(nbins=70,particle=\"Ds\", variable=\"Ds IP own pv\", \n", + " MC_sig=MC_Ds_IP_ownpv, data_bkg=data_Ds_IP_ownpv, \n", + " width_MC=0.001, width_data=0.002)\n", + "plt.subplot(1,2,2)\n", + "#Retrieve data from needed branch\n", + "MC_Dplus_IP_ownpv=MC_Dplus_tuple_dict[\"Dplus_IP_OWNPV\"]\n", + "data_Ds_IP_ownpv=data_tuple_bkg[\"Ds_IP_OWNPV\"]\n", "\n", - "n1=h_mc_under.Integral(\"width\")\n", - "h_mc_under.Scale(1/n1)\n", - "h_mc_under.Integral(\"width\");\n", - "n2=h_mc_over.Integral(\"width\")\n", - "h_mc_over.Scale(1/n2)\n", - "h_mc_over.Integral(\"width\");" + "#Plot\n", + "plot_sb_comparison(nbins=70,particle=\"Dplus\", variable=\"Ds IP own pv\", \n", + " MC_sig=MC_Dplus_IP_ownpv, data_bkg=data_Ds_IP_ownpv, \n", + " width_MC=0.001, width_data=0.002)\n", + "\n", + "plt.savefig('/home/hep/davide/Rphipi/ip_ownpv.png', format='png', dpi=100)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "h_data_under= r.TH1F(\"data below signal\", \"data below signal\",nbins, 0, max_endvchi2_under)\n", - "h_data_over= r.TH1F(\"data over signal\", \"data over signal\",nbins, 0, max_endvchi2_over)\n", - "for i in range(len(data_under_Ds_endvtx_chi2ratio)):\n", - " h_data_under.Fill(data_under_Ds_endvtx_chi2ratio[i])\n", - "for i in range(len(data_over_Ds_endvtx_chi2ratio)):\n", - " h_data_over.Fill(data_over_Ds_endvtx_chi2ratio[i])\n", - " \n", - " \n", - "n2=h_data_under.Integral(\"width\")\n", - "h_data_under.Scale(1/n2)\n", - "h_data_under.Integral(\"width\");\n", - "n3=h_data_over.Integral(\"width\")\n", - "h_data_over.Scale(1/n3)\n", - "h_data_over.Integral(\"width\");" + "#Retrieve data from needed branch\n", + "plt.subplot(1,2,1)\n", + "#Retrieve data from needed branch\n", + "MC_Ds_endvtx_chi2ratio=MC_Ds_tuple_dict[\"phi_ENDVERTEX_CHI2\"]/MC_Ds_tuple_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "data_Ds_endvtx_chi2ratio=data_tuple_bkg[\"phi_ENDVERTEX_CHI2\"]/data_tuple_bkg[\"phi_ENDVERTEX_NDOF\"]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70,particle=\"phi\", variable=\"END VTX CHI2\", \n", + " MC_sig=MC_Ds_endvtx_chi2ratio, data_bkg=data_Ds_endvtx_chi2ratio, \n", + " width_MC=0.07, width_data=0.08)\n", + "plt.subplot(1,2,2)\n", + "#Retrieve data from needed branch\n", + "MC_Dplus_endvtx_chi2ratio=MC_Dplus_tuple_dict[\"phi_ENDVERTEX_CHI2\"]/MC_Dplus_tuple_dict[\"phi_ENDVERTEX_NDOF\"]\n", + "data_Ds_endvtx_chi2ratio=data_tuple_bkg[\"phi_ENDVERTEX_CHI2\"]/data_tuple_bkg[\"phi_ENDVERTEX_NDOF\"]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70,particle=\"phi\", variable=\"END VTX CHI2\", \n", + " MC_sig=MC_Dplus_endvtx_chi2ratio, data_bkg=data_Ds_endvtx_chi2ratio, \n", + " width_MC=0.07, width_data=0.08)" ] }, { @@ -455,9 +1215,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -467,29 +1227,62 @@ } ], "source": [ - "a=[h_mc_under.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc_under.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Ds End Vertex chisq/ndof Signal MC/ data under peak comparison\", fontsize=20)\n", + "#Retrieve data from needed branch\n", + "plt.subplot(1,2,1)\n", + "MC_Ds_ownpv_chi2ratio=MC_Ds_tuple_dict[\"Ds_OWNPV_CHI2\"]/MC_Ds_tuple_dict[\"Ds_OWNPV_NDOF\"]\n", + "data_Ds_ownpv_chi2ratio=data_tuple_bkg[\"Ds_OWNPV_CHI2\"]/data_tuple_bkg[\"Ds_OWNPV_NDOF\"]\n", "\n", - "plt.bar(b,a,width=0.05,alpha=0.6,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.06, alpha=0.4, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Ds\", variable=\"Own PV CHI2\", \n", + " MC_sig=MC_Ds_ownpv_chi2ratio, data_bkg=data_Ds_ownpv_chi2ratio,\n", + " width_MC=0.008, width_data=0.008)\n", + "plt.subplot(1,2,2)\n", + "#Retrieve data from needed branch\n", + "MC_Dplus_ownpv_chi2ratio=MC_Dplus_tuple_dict[\"Dplus_OWNPV_CHI2\"]/MC_Dplus_tuple_dict[\"Dplus_OWNPV_NDOF\"]\n", + "data_Ds_ownpv_chi2ratio=data_tuple_bkg[\"Ds_OWNPV_CHI2\"]/data_tuple_bkg[\"Ds_OWNPV_NDOF\"]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Dplus\", variable=\"Own PV CHI2\", \n", + " MC_sig=MC_Dplus_ownpv_chi2ratio, data_bkg=data_Ds_ownpv_chi2ratio,\n", + " width_MC=0.01, width_data=0.01)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, + "outputs": [], + "source": [ + "##Retrieve data from needed branch\n", + "#plt.subplot(1,2,1)\n", + "#MC_Ds_ownpv_chi2ratio=MC_Ds_tuple_dict[\"phi_OWNPV_CHI2\"]/MC_Ds_tuple_dict[\"phi_OWNPV_NDOF\"]\n", + "#data_Ds_ownpv_chi2ratio=data_tuple_bkg[\"phi_OWNPV_CHI2\"]/data_tuple_bkg[\"phi_OWNPV_NDOF\"]\n", + "#\n", + "##Plot\n", + "#plot_sb_comparison(nbins=70, particle=\"phi\", variable=\"Own PV CHI2\", \n", + "# MC_sig=MC_Ds_ownpv_chi2ratio, data_bkg=data_Ds_ownpv_chi2ratio,\n", + "# width_MC=0.009, width_data=0.008)\n", + "#\n", + "#plt.subplot(1,2,2)\n", + "#MC_Ds_ownpv_chi2ratio=MC_Dplus_tuple_dict[\"phi_OWNPV_CHI2\"]/MC_Dplus_tuple_dict[\"phi_OWNPV_NDOF\"]\n", + "#data_Ds_ownpv_chi2ratio=data_tuple_bkg[\"phi_OWNPV_CHI2\"]/data_tuple_bkg[\"phi_OWNPV_NDOF\"]\n", + "#\n", + "##Plot\n", + "#plot_sb_comparison(nbins=70, particle=\"phi\", variable=\"Own PV CHI2\", \n", + "# MC_sig=MC_Ds_ownpv_chi2ratio, data_bkg=data_Ds_ownpv_chi2ratio,\n", + "# width_MC=0.009, width_data=0.008)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -499,89 +1292,25 @@ } ], "source": [ - "a=[h_mc_over.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc_over.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", + "#Retrieve data from needed branch\n", + "plt.subplot(1,2,1)\n", "\n", - "plt.title(\"Ds End Vertex chisq/ndof Signal MC/ data over peak comparison\", fontsize=20)\n", - "plt.bar(b,a,width=0.05,alpha=0.6,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.06, alpha=0.4, label=\"data over Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "nbins=70\n", - "MC_Ds_ownvtx_chi2ratio=MC_tuple_dict[\"Ds_OWNPV_CHI2\"]/MC_tuple_dict[\"Ds_OWNPV_NDOF\"]\n", - "data_under_Ds_ownvtx_chi2ratio=data_tuple_bkg_under[\"Ds_OWNPV_CHI2\"]/data_tuple_bkg_under[\"Ds_OWNPV_NDOF\"]\n", - "data_over_Ds_ownvtx_chi2ratio=data_tuple_bkg_over[\"Ds_OWNPV_CHI2\"]/data_tuple_bkg_over[\"Ds_OWNPV_NDOF\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "if np.max(MC_Ds_ownvtx_chi2ratio)>np.max(data_under_Ds_ownvtx_chi2ratio):\n", - " max_ownvchi2_under=np.max(MC_Ds_ownvtx_chi2ratio)\n", - "else:\n", - " max_ownvchi2_under=np.max(data_under_Ds_ownvtx_chi2ratio)\n", - " \n", - "if np.max(MC_Ds_ownvtx_chi2ratio)>np.max(data_over_Ds_ownvtx_chi2ratio):\n", - " max_ownvchi2_over=np.max(MC_Ds_ownvtx_chi2ratio)\n", - "else:\n", - " max_ownvchi2_over=np.max(data_over_Ds_ownvtx_chi2ratio)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "h_mc_under= r.TH1F(\"Ds own PV vertex MC/data comparison under\", \"Ds own PV vertex MC/data under Ds mass comparison\",nbins, 0, max_ownvchi2_under)\n", - "h_mc_over = r.TH1F(\"Ds own PV vertex MC/data comparison over\", \"Ds own PV vertex MC/data over Ds mass comparison\",nbins, 0, max_ownvchi2_over)\n", + "MC_Ds_pT=MC_Ds_tuple_sig[\"Ds_PT\"]/1000\n", + "data_Ds_pT=data_tuple_bkg[\"Ds_PT\"]/1000\n", "\n", - "for i in range(len(MC_Ds_ownvtx_chi2ratio)):\n", - " h_mc_under.Fill(MC_Ds_ownvtx_chi2ratio[i])\n", - " h_mc_over.Fill(MC_Ds_ownvtx_chi2ratio[i])\n", + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Dplus\", variable=\"PT\", \n", + " MC_sig=MC_Ds_pT, data_bkg=data_Ds_pT,\n", + " width_MC=.03, width_data=.03)\n", + "plt.subplot(1,2,2)\n", "\n", - "n1=h_mc_under.Integral(\"width\")\n", - "h_mc_under.Scale(1/n1)\n", - "h_mc_under.Integral(\"width\");\n", - "n2=h_mc_over.Integral(\"width\")\n", - "h_mc_over.Scale(1/n2)\n", - "h_mc_over.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "h_data_under= r.TH1F(\"data below signal_1\", \"data below signal_1\",nbins, 0, max_ownvchi2_under)\n", - "h_data_over= r.TH1F(\"data over signal_1\", \"data over signal_1\",nbins, 0, max_ownvchi2_over)\n", - "for i in range(len(data_under_Ds_ownvtx_chi2ratio)):\n", - " h_data_under.Fill(data_under_Ds_ownvtx_chi2ratio[i])\n", - "for i in range(len(data_over_Ds_ownvtx_chi2ratio)):\n", - " h_data_over.Fill(data_over_Ds_ownvtx_chi2ratio[i])\n", - " \n", - " \n", - "n2=h_data_under.Integral(\"width\")\n", - "h_data_under.Scale(1/n2)\n", - "h_data_under.Integral(\"width\");\n", - "n3=h_data_over.Integral(\"width\")\n", - "h_data_over.Scale(1/n3)\n", - "h_data_over.Integral(\"width\");" + "MC_Dplus_pT=MC_Dplus_tuple_sig[\"Dplus_PT\"]/1000\n", + "data_Ds_pT=data_tuple_bkg[\"Ds_PT\"]/1000\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Ds\", variable=\"PT\", \n", + " MC_sig=MC_Dplus_pT, data_bkg=data_Ds_pT,\n", + " width_MC=.3, width_data=.3)" ] }, { @@ -591,9 +1320,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -603,17 +1332,23 @@ } ], "source": [ - "a=[h_mc_under.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc_under.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Ds Own PV Vertex chisq/ndof Signal MC/ data under peak comparison\", fontsize=20)\n", + "plt.subplot(1,2,1)\n", + "MC_Ds_DIRA_ownpv=MC_Ds_tuple_sig[\"Ds_DIRA_OWNPV\"]\n", + "data_Ds_DIRA_ownpv=data_tuple_bkg[\"Ds_DIRA_OWNPV\"]\n", "\n", - "plt.bar(b,a,width=0.015,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.01, alpha=0.6, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Dplus\", variable=\"DIRA Own PV\", \n", + " MC_sig=MC_Ds_DIRA_ownpv, data_bkg=data_Ds_DIRA_ownpv,\n", + " width_MC=0.000001, width_data=0.000001)\n", + "plt.subplot(1,2,2)\n", + "MC_Dplus_DIRA_ownpv=MC_Dplus_tuple_sig[\"Dplus_DIRA_OWNPV\"]\n", + "data_Ds_DIRA_ownpv=data_tuple_bkg[\"Ds_DIRA_OWNPV\"]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Dplus\", variable=\"DIRA Own PV\", \n", + " MC_sig=MC_Dplus_DIRA_ownpv, data_bkg=data_Ds_DIRA_ownpv,\n", + " width_MC=0.000001, width_data=0.000001)\n", + "plt.savefig('/home/hep/davide/Rphipi/dira_ownpv.png', format='png', dpi=100)" ] }, { @@ -623,9 +1358,9 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -635,17 +1370,23 @@ } ], "source": [ - "a=[h_mc_over.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc_over.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", + "plt.subplot(2,1,1)\n", + "MC_probNNmu=MC_Ds_tuple_sig[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]\n", + "data_probNNmu=data_tuple_bkg[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]\n", "\n", - "plt.title(\"Ds Own PV Vertex chisq/ndof Signal MC/ data over peak comparison\", fontsize=20)\n", - "plt.bar(b,a,width=0.014,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.01, alpha=0.6, label=\"data over Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Ds\",variable=\"probNN mu\", \n", + " MC_sig=MC_probNNmu, data_bkg=data_probNNmu,\n", + " width_MC=0.01, width_data=0.01)\n", + "plt.subplot(2,1,2)\n", + "MC_probNNmu=MC_Dplus_tuple_sig[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]\n", + "data_probNNmu=data_tuple_bkg[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]\n", + "\n", + "#Plot\n", + "plot_sb_comparison(nbins=70, particle=\"Dplus\",variable=\"probNN mu\", \n", + " MC_sig=MC_probNNmu, data_bkg=data_probNNmu,\n", + " width_MC=0.01, width_data=0.01)\n", + "plt.savefig('/home/hep/davide/Rphipi/probnn_mu.png', format='png', dpi=100)" ] }, { @@ -654,10 +1395,28 @@ "metadata": {}, "outputs": [], "source": [ - "nbins=70\n", - "MC_Ds_DIRA_ownpv=MC_tuple_dict[\"Ds_DIRA_OWNPV\"]\n", - "data_under_Ds_DIRA_ownpv=data_tuple_bkg_under[\"Ds_DIRA_OWNPV\"]\n", - "data_over_Ds_DIRA_ownpv=data_tuple_bkg_over[\"Ds_DIRA_OWNPV\"]" + "#MC_Hlt1TrackMVA_TOS=MC_tuple_sig[\"Ds_Hlt1TrackMVADecision_TOS\"]\n", + "#data_Hlt1TrackMVA_TOS=data_tuple_bkg[\"Ds_Hlt1TrackMVADecision_TOS\"]\n", + "#\n", + "##Plot\n", + "#plot_sb_comparison(nbins=4, particle=\"Ds\",variable=\"Hlt1 Track MVA TOS\", \n", + "# MC_sig=MC_Hlt1TrackMVA_TOS, data_bkg=data_Hlt1TrackMVA_TOS,\n", + "# width_MC=0.5, width_data=0.5)\n", + "\n", + "#MC_Hlt2RareCharm_TOS=MC_tuple_sig[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]\n", + "#data_Hlt2RareCharm_TOS=data_tuple_bkg[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]\n", + "#\n", + "##Plot\n", + "#plot_sb_comparison(nbins=4, particle=\"Ds\",variable=\"Hlt2 RareCharm D2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\" TOS\", \n", + "# MC_sig=MC_Hlt2RareCharm_TOS, data_bkg=data_Hlt2RareCharm_TOS,\n", + "# width_MC=0.5, width_data=0.5)\n", + "\n", + "#MC_Hlt2Phys_TOS=MC_tuple_sig[\"Ds_Hlt2Phys_TOS\"]\n", + "#data_Hlt2Phys_TOS=data_tuple_bkg[\"Ds_Hlt2Phys_TOS\"]\n", + "#\n", + "#plot_sb_comparison(nbins=4, particle=\"Ds\",variable=\"Hlt2 Phys TOS\", \n", + "# MC_sig=MC_Hlt2Phys_TOS, data_bkg=data_Hlt2Phys_TOS,\n", + "# width_MC=0.5, width_data=0.5)" ] }, { @@ -666,600 +1425,6 @@ "metadata": {}, "outputs": [], "source": [ - "if np.min(MC_Ds_DIRA_ownpv)" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc_under.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc_under.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Ds Own PV Vertex chisq/ndof Signal MC/ data under peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.000001,alpha=0.6,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.0000015, alpha=0.4, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc_over.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc_over.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", - "\n", - "plt.title(\"Ds Own PV Vertex chisq/ndof Signal MC/ data over peak comparison\", fontsize=20)\n", - "plt.bar(b,a,width=0.000001,alpha=0.6,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.0000015, alpha=0.4, label=\"data over Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "nbins=70\n", - "MC_probNNmu=MC_tuple_dict[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]\n", - "data_probNNmu_under=data_tuple_bkg_under[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]\n", - "data_probNNmu_over=data_tuple_bkg_over[l_flv[l_index]+\"_plus_MC15TuneV1_ProbNN\"+l_flv[l_index]]" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "h_mc= r.TH1F(\"ProbNN e MC/data comparison below\", \"ProbNN e MC/data below Ds mass comparison\",nbins, 0, 1)\n", - "\n", - "for i in range(len(MC_probNNmu)):\n", - " h_mc.Fill(MC_probNNmu[i]) \n", - "\n", - "n1=h_mc.Integral(\"width\")\n", - "h_mc.Scale(1/n1)\n", - "h_mc.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "h_data_under= r.TH1F(\"data below signal_3\", \"data below signal_3\",nbins, 0, 1)\n", - "h_data_over= r.TH1F(\"data over signal_3\", \"data over signal_3\",nbins, 0, 1)\n", - "for i in range(len(data_probNNmu_under)):\n", - " h_data_under.Fill(data_probNNmu_under[i])\n", - "for i in range(len(data_probNNmu_over)):\n", - " h_data_over.Fill(data_probNNmu_under[i])\n", - " \n", - "n2=h_data_under.Integral(\"width\")\n", - "h_data_under.Scale(1/n2)\n", - "h_data_under.Integral(\"width\");\n", - "n3=h_data_over.Integral(\"width\")\n", - "h_data_over.Scale(1/n3)\n", - "h_data_over.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"ProbNN mu Signal MC/ data under peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.01,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.01, alpha=0.6, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Prob NN mu Signal MC/ data under peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.01,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.01, alpha=0.6, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [], - "source": [ - "nbins=4\n", - "MC_Hlt1TrackMVA_TOS=MC_tuple_dict[\"Ds_Hlt1TrackMVADecision_TOS\"]\n", - "data_Hlt1TrackMVA_TOS_under=data_tuple_bkg_under[\"Ds_Hlt1TrackMVADecision_TOS\"]\n", - "data_Hlt1TrackMVA_TOS_over=data_tuple_bkg_over[\"Ds_Hlt1TrackMVADecision_TOS\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [], - "source": [ - "h_mc= r.TH1F(\"Hlt1 TrackMVA TOS MC/data comparison under\", \"Hlt1 TrackMVA TOS MC/data under Ds mass comparison\",nbins, 0, 2)\n", - "\n", - "for i in range(len(MC_Hlt1TrackMVA_TOS)):\n", - " h_mc.Fill(MC_Hlt1TrackMVA_TOS[i]) \n", - "\n", - "n1=h_mc.Integral(\"width\")\n", - "h_mc.Scale(1/n1)\n", - "h_mc.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [], - "source": [ - "h_data_under= r.TH1F(\"data below signal_4\", \"data below signal_4\",nbins, 0, 2)\n", - "h_data_over= r.TH1F(\"data over signal_4\", \"data over signal_4\",nbins, 0, 2)\n", - "for i in range(len(data_Hlt1TrackMVA_TOS_under)):\n", - " h_data_under.Fill(data_Hlt1TrackMVA_TOS_under[i])\n", - "for i in range(len(data_Hlt1TrackMVA_TOS_over)):\n", - " h_data_over.Fill(data_Hlt1TrackMVA_TOS_over[i])\n", - " \n", - "n2=h_data_under.Integral(\"width\")\n", - "h_data_under.Scale(1/n2)\n", - "h_data_under.Integral(\"width\");\n", - "n3=h_data_over.Integral(\"width\")\n", - "h_data_over.Scale(1/n3)\n", - "h_data_over.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Hlt1 TrackMVA TOS Signal MC/ data below peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.5,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.5, alpha=0.6, label=\"data below Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Hlt1 TrackMVA TOS Signal MC/ data over peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.5,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.5, alpha=0.6, label=\"data over Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [], - "source": [ - "nbins=4\n", - "MC_Hlt2RareCharm_TOS=MC_tuple_dict[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]\n", - "data_Hlt2RareCharm_TOS_under=data_tuple_bkg_under[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]\n", - "data_Hlt2RareCharm_TOS_over=data_tuple_bkg_over[\"Ds_Hlt2RareCharmD2Pi\"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+\"OSDecision_TOS\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": {}, - "outputs": [], - "source": [ - "h_mc= r.TH1F(\"Hlt2 RareCharm TOS MC/data comparison under\", \"Hlt2 RareCharm TOS MC/data under Ds mass comparison\",nbins, 0, 2)\n", - "\n", - "for i in range(len(MC_Hlt2RareCharm_TOS)):\n", - " h_mc.Fill(MC_Hlt2RareCharm_TOS[i]) \n", - "\n", - "n1=h_mc.Integral(\"width\")\n", - "h_mc.Scale(1/n1)\n", - "h_mc.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": {}, - "outputs": [], - "source": [ - "h_data_under= r.TH1F(\"data below signal\", \"data below signal\",nbins, 0, 2)\n", - "h_data_over= r.TH1F(\"data over signal\", \"data over signal\",nbins, 0, 2)\n", - "for i in range(len(data_Hlt2RareCharm_TOS_under)):\n", - " h_data_under.Fill(data_Hlt2RareCharm_TOS_under[i])\n", - "for i in range(len(data_Hlt2RareCharm_TOS_over)):\n", - " h_data_over.Fill(data_Hlt2RareCharm_TOS_over[i])\n", - " \n", - "n2=h_data_under.Integral(\"width\")\n", - "h_data_under.Scale(1/n2)\n", - "h_data_under.Integral(\"width\");\n", - "n3=h_data_over.Integral(\"width\")\n", - "h_data_over.Scale(1/n3)\n", - "h_data_over.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Hlt1 TrackMVA TOS Signal MC/ data below peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.5,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.5, alpha=0.6, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Hlt1 TrackMVA TOS Signal MC/ data under peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.5,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.5, alpha=0.6, label=\"data under Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "metadata": {}, - "outputs": [], - "source": [ - "nbins=4\n", - "MC_Hlt2Phys_TOS=MC_tuple_dict[\"Ds_Hlt2Phys_TOS\"]\n", - "data_Hlt2Phys_TOS_under=data_tuple_bkg_under[\"Ds_Hlt2Phys_TOS\"]\n", - "data_Hlt2Phys_TOS_over=data_tuple_bkg_over[\"Ds_Hlt2Phys_TOS\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "metadata": {}, - "outputs": [], - "source": [ - "h_mc= r.TH1F(\"Hlt2 Phys TOS MC/data comparison under\", \"Hlt2 Phys TOS MC/data under Ds mass comparison\",nbins, 0, 2)\n", - "\n", - "for i in range(len(MC_Hlt2Phys_TOS)):\n", - " h_mc.Fill(MC_Hlt2Phys_TOS[i]) \n", - "\n", - "n1=h_mc.Integral(\"width\")\n", - "h_mc.Scale(1/n1)\n", - "h_mc.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "TFile::Append:0: RuntimeWarning: Replacing existing TH1: data below signal (Potential memory leak).\n", - "TFile::Append:0: RuntimeWarning: Replacing existing TH1: data over signal (Potential memory leak).\n" - ] - } - ], - "source": [ - "h_data_under= r.TH1F(\"data below signal\", \"data below signal\",nbins, 0, 2)\n", - "h_data_over= r.TH1F(\"data over signal\", \"data over signal\",nbins, 0, 2)\n", - "for i in range(len(data_Hlt2Phys_TOS_under)):\n", - " h_data_under.Fill(data_Hlt2Phys_TOS_under[i])\n", - "for i in range(len(data_Hlt2Phys_TOS_under)):\n", - " h_data_over.Fill(data_Hlt2Phys_TOS_under[i])\n", - " \n", - "n2=h_data_under.Integral(\"width\")\n", - "h_data_under.Scale(1/n2)\n", - "h_data_under.Integral(\"width\");\n", - "n3=h_data_over.Integral(\"width\")\n", - "h_data_over.Scale(1/n3)\n", - "h_data_over.Integral(\"width\");" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_under.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_under.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Hlt2 Phys TOS Signal MC/ data below peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.5,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.5, alpha=0.6, label=\"data below Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "a=[h_mc.GetBinContent(i) for i in range(nbins)]\n", - "b=[h_mc.GetBinCenter(i) for i in range(nbins)]\n", - "c=[h_data_over.GetBinContent(i) for i in range(nbins)]\n", - "d=[h_data_over.GetBinCenter(i) for i in range(nbins)]\n", - "plt.title(\"Hlt1 TrackMVA TOS Signal MC/ data over peak comparison\", fontsize=20)\n", - "\n", - "plt.bar(b,a,width=0.5,alpha=0.4,label=\"Signal MC\")\n", - "plt.bar(d,c,width=0.5, alpha=0.6, label=\"data over Ds mass peak\")\n", - "plt.legend(fontsize=20)\n", - "fig = plt.gcf()\n", - "fig.set_size_inches(16,8)" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "metadata": {}, - "outputs": [], - "source": [ "#h_data_under.SetLineColor(38)\n", "#h_mc_under.SetLineColor(46)\n", "#\n", @@ -1279,20 +1444,98 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "with open('/disk/lhcb_data/davide/Rphipi/NN/'+l_flv[l_index]+l_flv[l_index]+'/MC_for_NN_'+l_flv[l_index]+l_flv[l_index]+'_Mag'+mag_status[mag_index]+'.pickle', 'wb') as handle:\n", - " pickle.dump(MC_tuple_sig, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", - "with open('/disk/lhcb_data/davide/Rphipi/NN/'+l_flv[l_index]+l_flv[l_index]+'/data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'_Mag'+mag_status[mag_index]+'.pickle', 'wb') as handle:\n", + "with open('/disk/lhcb_data/davide/Rphipi/NN_for_training/'+l_flv[l_index]+l_flv[l_index]+'/MC_for_NN_Ds_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n", + " pickle.dump(MC_Ds_tuple_sig, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + " \n", + "with open('/disk/lhcb_data/davide/Rphipi/NN_for_training/'+l_flv[l_index]+l_flv[l_index]+'/MC_for_NN_Dplus_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n", + " pickle.dump(MC_Dplus_tuple_sig, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + "\n", + "with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_Ds_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n", + " pickle.dump(MC_Ds_mass_for_fit, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + " \n", + "with open('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_Dplus_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n", + " pickle.dump(MC_Dplus_mass_for_fit, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + "\n", + "with open('/disk/lhcb_data/davide/Rphipi/NN_for_training/'+l_flv[l_index]+l_flv[l_index]+'/data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n", " pickle.dump(data_tuple_bkg, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", - "with open('/disk/lhcb_data/davide/Rphipi/NN_for_selection/'+l_flv[l_index]+l_flv[l_index]+'/data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'_Mag'+mag_status[mag_index]+'.pickle', 'wb') as handle:\n", + " \n", + "with open('/disk/lhcb_data/davide/Rphipi/NN_for_selection/'+l_flv[l_index]+l_flv[l_index]+'/data_for_NN_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n", " pickle.dump(data_tuple_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)" ] }, { "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "25059" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data_tuple_bkg[\"Ds_ConsD_M\"].shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2020" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MC_Dplus_tuple_sig[\"Dplus_ConsD_M\"].shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1245" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "MC_Ds_tuple_sig[\"Ds_ConsD_M\"].shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], diff --git a/file_list.txt b/file_list.txt deleted file mode 100644 index f211df4..0000000 --- a/file_list.txt +++ /dev/null @@ -1,137 +0,0 @@ -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000001_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000002_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000003_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000004_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000005_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000006_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000007_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000008_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000009_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000010_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000011_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000012_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000013_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000014_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000015_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000016_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000017_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000018_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000019_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000020_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000021_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000022_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000023_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000024_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000025_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000026_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000027_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000028_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000029_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000030_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000031_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000032_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000033_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000034_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000035_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000036_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000037_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000038_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000039_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000040_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000041_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000042_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000043_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000044_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000045_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000046_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000047_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000048_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000049_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000050_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000051_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000052_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000053_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000054_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000055_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000056_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000057_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000058_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000059_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000060_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000061_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000062_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000063_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000064_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000065_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000066_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000067_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000068_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000069_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000070_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000071_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000072_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000073_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000074_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000075_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000076_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000077_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000078_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000079_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000080_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000081_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000082_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000083_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000084_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000085_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000086_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000087_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000088_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000089_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000090_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000091_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000092_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000093_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000094_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000096_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000097_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000098_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000099_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000100_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000101_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000102_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000103_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000104_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000105_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000106_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000107_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000108_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000109_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000110_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000111_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000112_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000113_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000114_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000115_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000116_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000117_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000118_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000119_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000120_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000121_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000122_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000123_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000124_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000125_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000126_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000127_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000128_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000129_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000130_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000131_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000132_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000133_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000134_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000135_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000136_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000137_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000138_1.charm_d2hll_dvntuple.root diff --git a/file_list_short.txt b/file_list_short.txt deleted file mode 100644 index c40f87a..0000000 --- a/file_list_short.txt +++ /dev/null @@ -1,30 +0,0 @@ -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000001_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000002_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000003_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000004_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000005_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000006_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000007_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000008_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000009_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000010_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000011_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000012_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000013_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000014_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000015_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000016_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000017_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000018_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000019_1.charm_d2hll_dvntuple.root -root://eoslhcb.cern.ch//eos/lhcb/grid/prod/lhcb/LHCb/Collision17/CHARM_D2HLL_DVNTUPLE.ROOT/00075545/0000/00075545_00000020_1.charm_d2hll_dvntuple.root - - - - - -TChain *chain = new TChain("DpTopimumu_OS/DecayTree") -TFileCollection *fc = new TFileCollection("dum","","file_list_short.txt") -chain->AddFileInfoList(fc->GetList()) -TFile *file = TFile::Open("DpTopimumu_OS","RECREATE") -chain->CloneTree(-1,"fast") diff --git a/fit_script.sh b/fit_script.sh new file mode 100644 index 0000000..6e205b0 --- /dev/null +++ b/fit_script.sh @@ -0,0 +1,33 @@ +#!/bin/bash + +while getopts ":i:s:" opt; do + + case $opt in + i) + iter=$OPTARG + echo "fitting $OPTARG iterations " >&2 + ;; + l) + l_index=$OPTARG + echo "each consisting of $OPTARG*10^5 events" >&2 + ;; + m) + mother_index_fit=$OPTARG + echo "plotted in a histogram of $OPTARG bins" >&2 + ;; + \?) + echo "invalid option: -$OPTARG" >&2 + exit 1 + ;; + :) + echo "Option: -$OPTARG requires an argument." >&2 + exit 1 + ;; + esac +done + +for ((index = 1; index< $iter; index+=1)); do + + python BDTselect_and_fit.py -x_cut $(( 0)) -iteration $(( $iter)) -l_index $(( $l_index)) -mother_index_fit $(( $mother_index_fit)) + +done diff --git a/minuit_fitter.ipynb b/minuit_fitter.ipynb deleted file mode 100644 index 5d42501..0000000 --- a/minuit_fitter.ipynb +++ /dev/null @@ -1,150 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import ROOT as r\n", - "import ctypes\n", - "import numpy as np\n", - "from array import array\n", - "import root_numpy as rn\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def fcn( npar, gin, f, par, iflag):\n", - " \n", - " global ncount\n", - " global chisq\n", - " global pulls\n", - " global fitfunavg\n", - " global delta\n", - " \n", - " pull = np.array([0. for i in range(nbins)])\n", - " residuals = np.array([0. for i in range(nbins)])\n", - " \n", - " fitfunavg=np.array([func((xup[i]+xdown[i])/2) for i in range(nbins)])\n", - " \n", - " chisq, delta = 0., 0.\n", - " \n", - " delta = np.array([data[i]-fitfun[i] for i in range(0,nbins)])\n", - " \n", - " chisq = np.dot(np.transpose(delta),np.dot(Vxinv,delta))\n", - " \n", - " for i in range(nbins):\n", - " \n", - " pulls[i] = (y[i]-fitfun[i])/(np.sqrt(Vx[i,i]))\n", - " \n", - " print('X^2', chisq)\n", - " f[0] = chisq\n", - " ncount+=1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "###DEFINE FIT FUNCTIONS HERE\n", - "###AS FUNC" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "##___MINUIT______\n", - "\n", - "def fit():\n", - " \n", - " gMinuit = r.TMinuit(5)\n", - " gMinuit.SetFCN(fcn)\n", - " \n", - " arglist = np.array([0. for i in range(10)], dtype='float32')\n", - " ierflg = ctypes.c_int(1982)\n", - " \n", - " arglist[0]=1\n", - " gMinuit.mnexcm( \"SET ERR\", arglist, 1, ierflg )\n", - " \n", - " # Set starting values and step sizes for parameters\n", - " vstart = np.array([], dtype='float32')\n", - " step = np.array([], dtype='float32')\n", - " \n", - " gMinuit.mnparm( 0, \"\", vstart[0], step[0], lower_bound, upper_bound, ierflg)#par0\n", - " \n", - " #if needed\n", - " #gMinuit.FixParameter(0)\n", - " \n", - " #Minimization Step\n", - " \n", - " arglist[0] = 500\n", - " arglist[1] = 1e-20\n", - " gMinuit.mnexcm( \"MIGRAD\", arglist, 3, ierflg)\n", - " gMinuit.mnexcm(\"HESSE\", arglist, 4, ierflg)\n", - " \n", - " amin, edm, errdef, par0, err_par0 = map(ctypes.c_double, (0.18, 0.19, 0.20, 0.21, 0.22, 0.23))\n", - " nvpar, nparx, icstat = map(ctypes.c_int, (1983, 1984, 1985))\n", - " gMinuit.mnstat( amin, edm, errdef, nvpar, nparx, icstat )\n", - " gMinuit.mnprin( 4, amin.value )\n", - " gMinuit.GetParameter(0,par0,err_par0)\n", - " \n", - " fitpars = np.array([par0.value])\n", - " err_fitpars = np.array([err_par0.value])\n", - " ratio = chisq/(fit_bins-2)\n", - " \n", - " return firpars, err_fitpars, ratio, pulls" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "if __name__ == '__maun__':\n", - " \n", - " binwidth = (end-start)/nbins\n", - " \n", - " xup = np.array([start +1.0*(i+1.)*binwidth] for i in range(0,nbins))\n", - " xdown = np.array([start +1.0*(i+0.)*binwidth] for i in range(0,nbins))\n", - " \n", - " fitpars, err_fitpars, ratio, pulls = fit()\n", - " \n", - " #save data and plot here\n", - " " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 2", - "language": "python", - "name": "python2" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 2 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython2", - "version": "2.7.15" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/productions/local_test_mc/Ds_eepi_mc_local.py b/productions/local_test_mc/Ds_eepi_mc_local.py index 461fd6f..91cbe6a 100644 --- a/productions/local_test_mc/Ds_eepi_mc_local.py +++ b/productions/local_test_mc/Ds_eepi_mc_local.py @@ -54,11 +54,13 @@ #decay_OSmumu = "[D+ -> ^pi+ ^mu+ ^mu-]CC" # find my own decay_tree_location using main_opt and make_decay_tree_tuples.py -decay_tree_location_Dplus_electrons = 'Phys/D2XMuMuSS_Pi_EE_OSLine/Particles' -#decay_tree_location_Dplus_muons = 'Phys/D2XMuMuSS_PiOSLine/Particles' +#Event/Allstreams + +decay_tree_location_Ds_electrons = 'Phys/D2XMuMuSS_Pi_EE_OSLine/Particles' + #ACCESSING TO THE DECAY DAUGHTERS -StrippingSel = AutomaticData(decay_tree_location_Dplus_electrons) +StrippingSel = AutomaticData(decay_tree_location_Ds_electrons) electron_from_Ds = FilterInTrees('electron_from_Ds', Code="('e-' == ABSID)") @@ -180,6 +182,7 @@ from Configurables import TupleToolGeometry from Configurables import TupleToolTrackIsolation from Configurables import TupleToolANNPID +from Configurables import TupleToolBremInfo # from Configurables import Rich__Rec__DetailedTrSegMakerFromRecoTracks # from Configurables import TupleToolRICHPid #from Configurables import TupleToolApplyIsolation @@ -195,21 +198,35 @@ "TupleToolRecoStats", "TupleToolANNPID", "TupleToolPid", - # "TupleToolMCTruth", + "TupleToolMCTruth", + "TupleToolMCBackgroundInfo", + "TupleToolBremInfo", # 'TupleToolTrigger', # 'TupleToolTISTOS', # 'TupleToolRICHPid', ] + # DTT.pi_plus.addTool(TupleToolANNPID,name='TupleToolANNPID') # DTT.pi_plus.ToolList+=['TupleToolANNPID'] # DTT.pi_plus.TupleToolANNPID.ANNPIDTunes = ['MC15TuneV1','MC15TuneDNNV1','MC15TuneFLAT4dV1','MC15TuneCatBoostV1'] # print 'PID tunes',DTT.pi_plus.TupleToolANNPID.ANNPIDTunes + + DTT.addTool( TupleToolMCTruth, name="TupleToolMCTruth" ) + DTT.TupleToolMCTruth.ToolList += ["MCTupleToolHierarchy","MCTupleToolHierarchy"] + + DTT.Ds.addTool(TupleToolBremInfo) + DTT.Ds.TupleToolBremInfo.Particle += ["e-", "e+"] + DTT.Ds.addTool(TupleToolTrigger, name='TupleToolTrigger') + DTT.Ds.TupleToolTrigger.Verbose = True DTT.Ds.TupleToolTrigger.TriggerList = trigger_list + DTT.Ds.addTool(TupleToolTISTOS, name='TupleToolTISTOS') + DTT.Ds.TupleToolTISTOS.Verbose = True DTT.Ds.TupleToolTISTOS.TriggerList = trigger_list + DTT.Ds.ToolList += ["TupleToolTISTOS"] #DTT.Lambda_b0.addTool(TupleToolSLTools, name='TupleToolSLTools') #DTT.Lambda_b0.ToolList += ["TupleToolSLTools"] @@ -241,13 +258,16 @@ ################################################## from Configurables import DaVinci # DaVinci().EventPreFilters = fltrs.filters('Filters') -DaVinci().EvtMax = 2000 # 200 # Number of events +DaVinci().EvtMax = -1 # 200 # Number of events DaVinci().SkipEvents = 0 # Events to skip DaVinci().PrintFreq = 10000 DaVinci().Simulation = True DaVinci().Lumi = True DaVinci().RootInTES = '/Event/AllStreams' +#not this + DaVinci().InputType = 'MDST' + #DaVinci().appendToMainSequence([muons_from_Lc_sel_seq.sequence(), # muons_from_Lc_sel_WC_seq.sequence()]) DaVinci().appendToMainSequence([Ds_phi_pi_sel_seq.sequence()]) diff --git a/productions/local_test_mc/Ds_mumupi_mc_local.py b/productions/local_test_mc/Ds_mumupi_mc_local.py index 0a54b19..28aab40 100644 --- a/productions/local_test_mc/Ds_mumupi_mc_local.py +++ b/productions/local_test_mc/Ds_mumupi_mc_local.py @@ -118,10 +118,6 @@ TopSelection=Ds_sel ) ############################################################################# -# Now WS: -# Lb_SL_WS = CombineParticles("Lb_SL_WS") -# Lb_SL_WS.DecayDescriptors = ["[Lambda_b0 -> Lambda_c(2595)+ mu+]cc"] -# Lb_SL_WS.MotherCut = "(M<6500) & (VFASPF(VCHI2/VDOF) < 6.0) & (BPVDIRA>0.999)" @@ -144,15 +140,32 @@ }) + + +#Ds_OfflineTree.Ds.addTupleTool('') Ds_OfflineTree.Ds.addTupleTool('TupleToolDecayTreeFitter/ConsD') + + #Ds_OfflineTree.Ds.ConsD.constrainToOriginVertex = True Ds_OfflineTree.Ds.ConsD.Verbose = True Ds_OfflineTree.Ds.ConsD.daughtersToConstrain = ['phi(1020)'] Ds_OfflineTree.Ds.ConsD.UpdateDaughters = True - decay_trees.append(Ds_OfflineTree) + +# LoKi_Cone = LoKi__Hybrid__TupleTool('LoKi_Cone') +# LoKi_Cone.Variables = { +# "VTXISONUMVTX" : "RELINFO('/Event/AllStreams/Phys/D2XMuMuSS_PiOSLine/RelInfoVertexIsolation', 'VTXISONUMVTX', -999.)", +# #"VTXISONUMVTX" : "RELINFO(Phys/D2XMuMuSS_PiOSLine/Particles/RelInfoVertexIsolation, VTXISONUMVTX, -1.)", +# #"VTXISODCHI2ONETRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2ONETRACK', -1.)", +# #"VTXISODCHI2MASSONETRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2MASSONETRACK', -1.)", +# #"VTXISODCHI2TWOTRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2TWOTRACK', -1.)", +# #"VTXISODCHI2MASSTWOTRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2MASSTWOTRACK', -1.)", +# } + +# Ds_OfflineTree.Ds.addTupleTool(LoKi_Cone) + # Lb_SL_OfflineTree_WS = DecayTreeTuple("Lb_SL_OfflineTree_WS") # Lb_SL_OfflineTree_WS.Inputs = ["Phys/Lb_SL_WS/Particles"] # Lb_SL_OfflineTree_WS.Decay = decay0_WS @@ -180,12 +193,16 @@ from Configurables import TupleToolGeometry from Configurables import TupleToolTrackIsolation from Configurables import TupleToolANNPID +from Configurables import TupleToolMCBackgroundInfo +from Configurables import TupleToolMCTruth +from Configurables import TupleToolBremInfo # from Configurables import Rich__Rec__DetailedTrSegMakerFromRecoTracks # from Configurables import TupleToolRICHPid #from Configurables import TupleToolApplyIsolation #from Configurables import TupleToolSLTools + for DTT in decay_trees: DTT.ToolList = [ "TupleToolKinematic", @@ -195,7 +212,10 @@ "TupleToolRecoStats", "TupleToolANNPID", "TupleToolPid", - # "TupleToolMCTruth", + "TupleToolMCTruth", + "TupleToolMCBackgroundInfo", + "TupleToolBremInfo", + # 'TupleToolTrigger', # 'TupleToolTISTOS', # 'TupleToolRICHPid', @@ -204,13 +224,23 @@ # DTT.pi_plus.ToolList+=['TupleToolANNPID'] # DTT.pi_plus.TupleToolANNPID.ANNPIDTunes = ['MC15TuneV1','MC15TuneDNNV1','MC15TuneFLAT4dV1','MC15TuneCatBoostV1'] # print 'PID tunes',DTT.pi_plus.TupleToolANNPID.ANNPIDTunes + + DTT.addTool( TupleToolMCTruth, name="TupleToolMCTruth" ) + DTT.TupleToolMCTruth.ToolList += ["MCTupleToolHierarchy","MCTupleToolHierarchy"] + DTT.Ds.addTool(TupleToolTrigger, name='TupleToolTrigger') + DTT.Ds.TupleToolTrigger.Verbose = True DTT.Ds.TupleToolTrigger.TriggerList = trigger_list + DTT.Ds.addTool(TupleToolTISTOS, name='TupleToolTISTOS') + DTT.Ds.TupleToolTISTOS.Verbose = True DTT.Ds.TupleToolTISTOS.TriggerList = trigger_list + DTT.Ds.ToolList += ["TupleToolTISTOS"] + + #DTT.Lambda_b0.addTool(TupleToolSLTools, name='TupleToolSLTools') #DTT.Lambda_b0.ToolList += ["TupleToolSLTools"] @@ -241,7 +271,7 @@ ################################################## from Configurables import DaVinci # DaVinci().EventPreFilters = fltrs.filters('Filters') -DaVinci().EvtMax = 2000 # # Number of events set to all of them +DaVinci().EvtMax = -1 # # Number of events set to all of them DaVinci().SkipEvents = 0 # Events to skip DaVinci().PrintFreq = 10000 DaVinci().Simulation = True diff --git a/productions/online_test_mc/Ds_eepi_mc_online.py b/productions/online_test_mc/Ds_eepi_mc_online.py index abea48c..df003b9 100644 --- a/productions/online_test_mc/Ds_eepi_mc_online.py +++ b/productions/online_test_mc/Ds_eepi_mc_online.py @@ -50,15 +50,17 @@ decay_OSee = "[D_s+ -> ^(phi(1020) -> ^e+ ^e-) ^pi+]CC" + #decay_OSmumu = "[D+ -> ^pi+ ^mu+ ^mu-]CC" +# find my own decay_tree_location using main_opt and make_decay_tree_tuples.py +#Event/Allstreams -#decay_tree_location_Dplus_muons = 'Phys/D2XMuMuSS_PiOSLine/Particles' -decay_tree_location_Dplus_electrons = 'Phys/D2XMuMuSS_Pi_EE_OSLine/Particles' +decay_tree_location_Ds_electrons = 'Phys/D2XMuMuSS_Pi_EE_OSLine/Particles' #ACCESSING TO THE DECAY DAUGHTERS -StrippingSel = AutomaticData(decay_tree_location_Dplus_electrons) +StrippingSel = AutomaticData(decay_tree_location_Ds_electrons) electron_from_Ds = FilterInTrees('electron_from_Ds', Code="('e-' == ABSID)") @@ -180,6 +182,7 @@ from Configurables import TupleToolGeometry from Configurables import TupleToolTrackIsolation from Configurables import TupleToolANNPID +from Configurables import TupleToolBremInfo # from Configurables import Rich__Rec__DetailedTrSegMakerFromRecoTracks # from Configurables import TupleToolRICHPid #from Configurables import TupleToolApplyIsolation @@ -195,21 +198,35 @@ "TupleToolRecoStats", "TupleToolANNPID", "TupleToolPid", - # "TupleToolMCTruth", + "TupleToolMCTruth", + "TupleToolMCBackgroundInfo", + "TupleToolBremInfo", # 'TupleToolTrigger', # 'TupleToolTISTOS', # 'TupleToolRICHPid', ] + # DTT.pi_plus.addTool(TupleToolANNPID,name='TupleToolANNPID') # DTT.pi_plus.ToolList+=['TupleToolANNPID'] # DTT.pi_plus.TupleToolANNPID.ANNPIDTunes = ['MC15TuneV1','MC15TuneDNNV1','MC15TuneFLAT4dV1','MC15TuneCatBoostV1'] # print 'PID tunes',DTT.pi_plus.TupleToolANNPID.ANNPIDTunes + + DTT.addTool( TupleToolMCTruth, name="TupleToolMCTruth" ) + DTT.TupleToolMCTruth.ToolList += ["MCTupleToolHierarchy","MCTupleToolHierarchy"] + + DTT.Ds.addTool(TupleToolBremInfo) + DTT.Ds.TupleToolBremInfo.Particle += ["e-", "e+"] + DTT.Ds.addTool(TupleToolTrigger, name='TupleToolTrigger') + DTT.Ds.TupleToolTrigger.Verbose = True DTT.Ds.TupleToolTrigger.TriggerList = trigger_list + DTT.Ds.addTool(TupleToolTISTOS, name='TupleToolTISTOS') + DTT.Ds.TupleToolTISTOS.Verbose = True DTT.Ds.TupleToolTISTOS.TriggerList = trigger_list + DTT.Ds.ToolList += ["TupleToolTISTOS"] #DTT.Lambda_b0.addTool(TupleToolSLTools, name='TupleToolSLTools') #DTT.Lambda_b0.ToolList += ["TupleToolSLTools"] @@ -247,7 +264,10 @@ DaVinci().Simulation = True DaVinci().Lumi = True DaVinci().RootInTES = '/Event/AllStreams' +#not this + DaVinci().InputType = 'MDST' + #DaVinci().appendToMainSequence([muons_from_Lc_sel_seq.sequence(), # muons_from_Lc_sel_WC_seq.sequence()]) DaVinci().appendToMainSequence([Ds_phi_pi_sel_seq.sequence()]) @@ -259,7 +279,7 @@ #DaVinci().UserAlgorithms.extend(decay_trees) DaVinci().TupleFile = "Ds_eepi.root" -#DaVinci().Input = ['PFN:/disk/gangadir/davide/workspace/davide/00071955_00000002_7.AllStreams.mdst'] +#DaVinci().Input = ['PFN:/disk/gangadir/davide/workspace/davide/local_MC/Ds_phipi_ee/00071955_00000002_7.AllStreams.mdst'] DaVinci().DataType = "2016" diff --git a/productions/online_test_mc/Ds_mumupi_mc_online.py b/productions/online_test_mc/Ds_mumupi_mc_online.py index a894ae5..3e011e3 100644 --- a/productions/online_test_mc/Ds_mumupi_mc_online.py +++ b/productions/online_test_mc/Ds_mumupi_mc_online.py @@ -52,12 +52,13 @@ decay_OSmumu = "[D_s+ -> ^(phi(1020) -> ^mu+ ^mu-) ^pi+]CC" #decay_OSmumu = "[D+ -> ^pi+ ^mu+ ^mu-]CC" - +#for mc /Event/ #decay_tree_location_Dplus_electrons = 'Phys/D2XMuMuSS_Pi_EE_OSLine/Particles' decay_tree_location_Dplus_muons = 'Phys/D2XMuMuSS_PiOSLine/Particles' -#ACCESSING TO THE DECAY DAUGHTERS + StrippingSel = AutomaticData(decay_tree_location_Dplus_muons) +#ACCESSING TO THE DECAY DAUGHTERS muon_from_Ds = FilterInTrees('muon_from_Ds', Code="('mu-' == ABSID)") muon_from_Ds_sel = Selection("muon_from_Ds_sel", @@ -80,6 +81,7 @@ # pion_Filter = FilterDesktop('pionFilter', Code="ALL") pion_Filter = FilterDesktop('pionFilter', Code="PPINFO(PROBNNpi)>0.2") + pion_Filter_sel = Selection("Filtered_pion_sel", Algorithm=pion_Filter, RequiredSelections=[pion_from_Ds_sel]) @@ -116,10 +118,6 @@ TopSelection=Ds_sel ) ############################################################################# -# Now WS: -# Lb_SL_WS = CombineParticles("Lb_SL_WS") -# Lb_SL_WS.DecayDescriptors = ["[Lambda_b0 -> Lambda_c(2595)+ mu+]cc"] -# Lb_SL_WS.MotherCut = "(M<6500) & (VFASPF(VCHI2/VDOF) < 6.0) & (BPVDIRA>0.999)" @@ -142,15 +140,32 @@ }) + + +#Ds_OfflineTree.Ds.addTupleTool('') Ds_OfflineTree.Ds.addTupleTool('TupleToolDecayTreeFitter/ConsD') + + #Ds_OfflineTree.Ds.ConsD.constrainToOriginVertex = True Ds_OfflineTree.Ds.ConsD.Verbose = True Ds_OfflineTree.Ds.ConsD.daughtersToConstrain = ['phi(1020)'] Ds_OfflineTree.Ds.ConsD.UpdateDaughters = True - decay_trees.append(Ds_OfflineTree) + +# LoKi_Cone = LoKi__Hybrid__TupleTool('LoKi_Cone') +# LoKi_Cone.Variables = { +# "VTXISONUMVTX" : "RELINFO('/Event/AllStreams/Phys/D2XMuMuSS_PiOSLine/RelInfoVertexIsolation', 'VTXISONUMVTX', -999.)", +# #"VTXISONUMVTX" : "RELINFO(Phys/D2XMuMuSS_PiOSLine/Particles/RelInfoVertexIsolation, VTXISONUMVTX, -1.)", +# #"VTXISODCHI2ONETRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2ONETRACK', -1.)", +# #"VTXISODCHI2MASSONETRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2MASSONETRACK', -1.)", +# #"VTXISODCHI2TWOTRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2TWOTRACK', -1.)", +# #"VTXISODCHI2MASSTWOTRACK" : "RELINFO('Phys/D2XMuMuSS_PiOSLine/Particles/VertexIsoInfo', 'VTXISODCHI2MASSTWOTRACK', -1.)", +# } + +# Ds_OfflineTree.Ds.addTupleTool(LoKi_Cone) + # Lb_SL_OfflineTree_WS = DecayTreeTuple("Lb_SL_OfflineTree_WS") # Lb_SL_OfflineTree_WS.Inputs = ["Phys/Lb_SL_WS/Particles"] # Lb_SL_OfflineTree_WS.Decay = decay0_WS @@ -178,12 +193,16 @@ from Configurables import TupleToolGeometry from Configurables import TupleToolTrackIsolation from Configurables import TupleToolANNPID +from Configurables import TupleToolMCBackgroundInfo +from Configurables import TupleToolMCTruth +from Configurables import TupleToolBremInfo # from Configurables import Rich__Rec__DetailedTrSegMakerFromRecoTracks # from Configurables import TupleToolRICHPid #from Configurables import TupleToolApplyIsolation #from Configurables import TupleToolSLTools + for DTT in decay_trees: DTT.ToolList = [ "TupleToolKinematic", @@ -193,7 +212,10 @@ "TupleToolRecoStats", "TupleToolANNPID", "TupleToolPid", - # "TupleToolMCTruth", + "TupleToolMCTruth", + "TupleToolMCBackgroundInfo", + "TupleToolBremInfo", + # 'TupleToolTrigger', # 'TupleToolTISTOS', # 'TupleToolRICHPid', @@ -202,13 +224,23 @@ # DTT.pi_plus.ToolList+=['TupleToolANNPID'] # DTT.pi_plus.TupleToolANNPID.ANNPIDTunes = ['MC15TuneV1','MC15TuneDNNV1','MC15TuneFLAT4dV1','MC15TuneCatBoostV1'] # print 'PID tunes',DTT.pi_plus.TupleToolANNPID.ANNPIDTunes + + DTT.addTool( TupleToolMCTruth, name="TupleToolMCTruth" ) + DTT.TupleToolMCTruth.ToolList += ["MCTupleToolHierarchy","MCTupleToolHierarchy"] + DTT.Ds.addTool(TupleToolTrigger, name='TupleToolTrigger') + DTT.Ds.TupleToolTrigger.Verbose = True DTT.Ds.TupleToolTrigger.TriggerList = trigger_list + DTT.Ds.addTool(TupleToolTISTOS, name='TupleToolTISTOS') + DTT.Ds.TupleToolTISTOS.Verbose = True DTT.Ds.TupleToolTISTOS.TriggerList = trigger_list + DTT.Ds.ToolList += ["TupleToolTISTOS"] + + #DTT.Lambda_b0.addTool(TupleToolSLTools, name='TupleToolSLTools') #DTT.Lambda_b0.ToolList += ["TupleToolSLTools"] @@ -257,7 +289,7 @@ #DaVinci().UserAlgorithms.extend(decay_trees) DaVinci().TupleFile = "Ds_mumupi.root" -#DaVinci().Input = ['PFN:/disk/gangadir/davide/workspace/davide/00071953_00000001_7.AllStreams.mdst'] +#DaVinci().Input = ['PFN:/disk/gangadir/davide/workspace/davide/local_MC/Ds_phipi_mumu/00071953_00000001_7.AllStreams.mdst'] # DaVinci().DataType = "2016" diff --git a/tools/DNN.py b/tools/DNN.py new file mode 100644 index 0000000..e306c1d --- /dev/null +++ b/tools/DNN.py @@ -0,0 +1,375 @@ +#NETWORK ARCHITECTURES + +import numpy as np +import os +import math + +import tensorflow as tf +import matplotlib.pyplot as plt +from datetime import datetime + +from architectures.utils.NN_building_blocks import * + +def lrelu(x, alpha=0.1): + return tf.maximum(alpha*x,x) + +# some dummy constants +LEARNING_RATE = None +LEARNING_RATE_D = None +LEARNING_RATE_G = None +BETA1 = None +BATCH_SIZE = None +EPOCHS = None +SAVE_SAMPLE_PERIOD = None +PATH = None +SEED = None +LAMBD = None +#seed=1 + +class classifier(object): + + def __init__(self, X, sizes, c_name): + + mi = X.get_shape().as_list()[1] + n_classes = sizes['n_classes'] + self.dense_layers = [] + + with tf.variable_scope('classificator_'+c_name) as scope: + + for count, (mo, apply_batch_norm, keep_prob, act_f, w_init) in enumerate(sizes['dense_layers'], start=0): + + name = 'dense_layer_{0}'.format(count) + + layer = DenseLayer(name,mi, mo, + apply_batch_norm, keep_prob, + act_f, w_init) + mi = mo + self.dense_layers.append(layer) + + #readout layer + readout_layer = DenseLayer('readout_layer', + mi, n_classes, + 'bn', 1., lambda x: x, + tf.random_normal_initializer()) + + self.dense_layers.append(readout_layer) + + #return self.propagate(X) + + def propagate(self, X, reuse=None, is_training=None): + + print('Input for propagation', X.get_shape()) + + output = X + + for layer in self.dense_layers: + output = layer.forward(output, reuse, is_training) + + print('Logits shape', output.get_shape()) + return output + + +#untested yet +class DNN(object): + + """ + Builds densely connected deep neural network. Regularization implemented + with dropout, no regularization parameter implemented yet. Minimization through + AdamOptimizer (adaptive learning rate) + + Constructor inputs: + + -Positional arguments: + - dim: (int) input features + - sizes: (dict) python dictionary containing the size of the + dense layers and the number of classes for classification + + sizes = {'dense_layer_n' :[mo, apply_batch_norm, keep_probability, act_f, w_init] + 'n_classes': n_classes + } + + mo: (int) size of layer n + apply_batch_norm: (bool) apply batch norm at layer n + keep_probability: (float32) probability of activation of output + act_f: (function) activation function for layer n + w_init: (tf initializer) random initializer for weights at layer n + n_classes: number of classes + + -Keyword arguments + + -lr: (float32) learning rate arg for the AdamOptimizer + -beta1: (float32) beta1 arg for the AdamOptimizer + -batch_size: (int) size of each batch + -epochs: (int) number of times the training has to be repeated over all the batches + -save_sample: (int) after how many iterations of the training algorithm performs the evaluations in fit function + -path: (str) path for saving the session checkpoint + + Class attributes: + + - X: (tf placeholder) input tensor of shape (batch_size, input features) + - Y: (tf placeholder) label tensor of shape (batch_size, n_classes) (one_hot encoding) + - Y_hat: (tf tensor) shape=(batch_size, n_classes) predicted class (one_hot) + - loss: (tf scalar) reduced mean of cost computed with softmax cross entropy with logits + - train_op: gradient descent algorithm with AdamOptimizer + + """ + def __init__(self, + dim, sizes, + lr=LEARNING_RATE, beta1=BETA1, lambd=LAMBD, + batch_size=BATCH_SIZE, epochs=EPOCHS, + save_sample=SAVE_SAMPLE_PERIOD, path=PATH, seed=SEED): + + self.seed=seed + self.n_classes = sizes['n_classes'] + self.dim = dim + + self.sizes=sizes + self.lambd=lambd + + self.X_input = tf.placeholder( + tf.float32, + shape=(None, dim), + name = 'X_input' + ) + + self.X_test = tf.placeholder( + tf.float32, + shape=(None, dim), + name = 'X_test' + ) + + self.batch_sz=tf.placeholder( + tf.int32, + shape=(), + name='batch_sz', + ) + + self.Y_input = tf.placeholder( + tf.float32, + shape=(None, self.n_classes), + name='Y_input' + ) + + self.Y_test = tf.placeholder( + tf.float32, + shape=(None, self.n_classes), + name='Y_test' + ) + + NN = classifier(self.X_input, sizes, 'sig_bkg') + + with tf.variable_scope('classificator_sig_bkg') as scope: + self.Y_hat = NN.propagate(self.X_input, reuse=None, is_training=True) + + + predicted_NN = tf.nn.softmax(self.Y_hat) + self.train_accuracy = evaluation(predicted_NN, self.Y_input) + + cost = tf.nn.softmax_cross_entropy_with_logits( + logits= self.Y_hat, + labels= self.Y_input, + ) + + + #cost = tf.square(predicted_NN-self.Y_input) + + + tot_params = [t for t in tf.trainable_variables() if 'classificator' in t.name] + temp =[t for t in tf.trainable_variables() if 'classificator' and not 'beta' in t.name] + weight_params =[t for t in temp if not 'gamma' in t.name] + + self.regularizator=tf.reduce_sum([tf.nn.l2_loss(weight_params[i]) for i in range(len(weight_params))]) + + self.loss = tf.reduce_mean(cost) + self.lambd*self.regularizator + + self.train_op = tf.train.AdamOptimizer( + learning_rate=lr, + beta1=beta1 + ).minimize(self.loss, + #var_list=tot_params + ) + + + with tf.variable_scope('classificator_sig_bkg') as scope: + scope.reuse_variables() + self.Y_hat_from_test = NN.propagate( + self.X_test, reuse=True, is_training=False, + ) + predicted_NN_test=tf.nn.softmax(self.Y_hat_from_test) + self.a=tf.reduce_sum(tf.argmax(predicted_NN_test, 1))/batch_size + + + + self.test_accuracy = evaluation(self.Y_hat_from_test, self.Y_test) + + #saving for later + self.lr = lr + self.batch_size=batch_size + self.epochs = epochs + self.path = path + self.save_sample = save_sample + self.NN = NN + + + def set_session(self, session): + + self.session=session + + for layer in self.NN.dense_layers: + layer.set_session(session) + + def fit(self, X_train, Y_train, X_test, Y_test): + + """ + Function is called if the flag is_training is set on TRAIN. If a model already is present + continues training the one already present, otherwise initialises all params from scratch. + + Performs the training over all the epochs, at when the number of epochs of training + is a multiple of save_sample prints out training cost, train and test accuracies + + Plots a plot of the cost versus epoch. + + Positional arguments: + + - X_train: (ndarray) size=(train set size, input features) training sample set + - X_test: (ndarray) size=(test set size, input features) test sample set + + - Y_train: (ndarray) size=(train set size, input features) training labels set + - Y_test: (ndarray) size=(test set size, input features) test labels set + + + + """ + seed = self.seed + + + N = X_train.shape[0] + test_size = X_test.shape[0] + + n_batches = N // self.batch_size + + print('\n ****** \n') + print('Training DNN for '+str(self.epochs)+' epochs with a total of ' +str(N)+ ' samples\ndistributed in ' +str(n_batches)+ ' batches of size '+str(self.batch_size)+'\n') + print('The learning rate set is '+str(self.lr)) + print('\n ****** \n') + + costs = [] + for epoch in range(self.epochs): + # a=0 + # train_acc = 0 + # test_acc = 0 + train_accuracies=[] + test_accuracies=[] + a_list=[] + + seed += 1 + + train_batches = supervised_random_mini_batches(X_train, Y_train, self.batch_size, seed) + test_batches = supervised_random_mini_batches(X_test, Y_test, self.batch_size, seed) + + for train_batch in train_batches: + + (X_train_batch, Y_train_batch) = train_batch + # print(X_train, Y_train) + feed_dict = { + + self.X_input: X_train_batch, + self.Y_input: Y_train_batch, + self.batch_sz: self.batch_size, + + } + + _, c = self.session.run( + (self.train_op, self.loss), + feed_dict=feed_dict + ) + + train_acc = self.session.run( + (self.train_accuracy), + + feed_dict=feed_dict + + ) + + + costs.append(c) + + train_accuracies.append(train_acc) + + c = np.array(costs).mean() + train_acc = np.array(train_accuracies).mean() + + if epoch % self.save_sample ==0: + + for test_batch in test_batches: + + (X_test_batch, Y_test_batch) = test_batch + + + feed_dict={ + self.X_test: X_test_batch, + self.Y_test: Y_test_batch, + + } + + test_acc, a = self.session.run( + (self.test_accuracy, self.a), + feed_dict=feed_dict + + ) + + a_list.append(a) + test_accuracies.append(test_acc) + + print_a = np.array(a_list).mean() + test_acc = np.array(test_accuracies).mean() + print('Evaluating performance on validation/train sets') + print('At iteration {0}, train cost: {1:.4g}, train accuracy {2:.4g}, test accuracy {3:.4g}'.format(epoch, c, train_acc, test_acc)) + print('Average of signal as predicted by NN {0:.4g}'.format(print_a)) + + plt.plot(costs) + plt.ylabel('cost') + plt.xlabel('iteration') + plt.title('learning rate=' + str(self.lr)) + plt.show() + + print('Parameters trained') + + + def test(self, X_test, Y_test): + + test_accuracies=[] + test_batches = supervised_random_mini_batches(X_test, Y_test, self.batch_size, self.seed) + + for test_batch in test_batches: + (X_test_batch, Y_test_batch) = test_batch + + feed_dict={ + self.X_test: X_test_batch, + self.Y_test: Y_test_batch, + + } + + test_acc = self.session.run( + + self.test_accuracy, + feed_dict=feed_dict + + ) + + test_accuracies.append(test_acc) + + test_acc = np.array(test_accuracies).mean() + print('Test accuracy: {0:.4g}'.format(test_acc)) + + + def predict(self, X): + + pred = tf.nn.softmax(self.Y_hat_from_test) + + output = self.session.run( + pred, + feed_dict={self.X_test:X} + ) + return output + diff --git a/tools/__init__.py b/tools/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tools/__init__.py diff --git a/tools/__init__.pyc b/tools/__init__.pyc new file mode 100644 index 0000000..5a6c21f --- /dev/null +++ b/tools/__init__.pyc Binary files differ diff --git a/tools/__pycache__/DNN.cpython-36.pyc b/tools/__pycache__/DNN.cpython-36.pyc new file mode 100644 index 0000000..7d0e366 --- /dev/null +++ b/tools/__pycache__/DNN.cpython-36.pyc Binary files differ diff --git a/tools/__pycache__/NN_BDT_model.cpython-36.pyc b/tools/__pycache__/NN_BDT_model.cpython-36.pyc new file mode 100644 index 0000000..e6986cc --- /dev/null +++ b/tools/__pycache__/NN_BDT_model.cpython-36.pyc Binary files differ diff --git a/tools/__pycache__/__init__.cpython-36.pyc b/tools/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000..69abacb --- /dev/null +++ b/tools/__pycache__/__init__.cpython-36.pyc Binary files differ diff --git a/tools/__pycache__/data_processing.cpython-36.pyc b/tools/__pycache__/data_processing.cpython-36.pyc new file mode 100644 index 0000000..837dc64 --- /dev/null +++ b/tools/__pycache__/data_processing.cpython-36.pyc Binary files differ diff --git a/tools/data_processing.py b/tools/data_processing.py new file mode 100644 index 0000000..c2b3c30 --- /dev/null +++ b/tools/data_processing.py @@ -0,0 +1,695 @@ +import os +import pickle +import numpy as np +import sys + +mother_ID=['Ds','Dplus','both'] +meson_ID =['pi','X'] +l_flv = ['e','mu'] +data_type = ['MC','data'] +mag_status =['Up','Down'] +tree_name = 'Ds_OfflineTree/DecayTree' + +def sel_eff(tp,threshold): + + sig_eps = np.float(np.where(tp>threshold)[0].shape[0])/np.float(tp.shape[0]) + return sig_eps + +def load_datasets(l_index): + if sys.version_info[0]>2: + data_index=0 + with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/'+data_type[data_index]+'_for_BDT_training_Ds_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + MC_Ds_sig_dict=pickle.load(f, encoding='latin1') + + data_index=0 + with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/'+data_type[data_index]+'_for_BDT_training_Dplus_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + MC_Dplus_sig_dict=pickle.load(f, encoding='latin1') + + data_index=1 + with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/'+data_type[data_index]+'_for_BDT_training_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + data_bkg_dict=pickle.load(f, encoding='latin1') + else: + data_index=0 + with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/'+data_type[data_index]+'_for_BDT_training_Ds_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + MC_Ds_sig_dict=pickle.load(f)#, encoding='latin1') + + data_index=0 + with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/'+data_type[data_index]+'_for_BDT_training_Dplus_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + MC_Dplus_sig_dict=pickle.load(f)#, encoding='latin1') + + data_index=1 + with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/'+data_type[data_index]+'_for_BDT_training_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'rb') as f: + data_bkg_dict=pickle.load(f)#, encoding='latin1') + + + return MC_Dplus_sig_dict, MC_Ds_sig_dict, data_bkg_dict + + +def extract_array(event_dict, branches_needed, features, examples): + + extracted = np.array( + [np.zeros(shape=features) for i in range(examples)] + ) + + for event in range(examples): + for i, key in enumerate(branches_needed): + extracted[event][i]=event_dict[key][event] + + return extracted + +def add_labels(ndarray, signal=True): + if signal==True: + labeled_ndarray=np.concatenate((ndarray, np.ones(shape=(ndarray.shape[0],1))), axis =1) + elif signal==False: + labeled_ndarray=np.concatenate((ndarray, np.zeros(shape=(ndarray.shape[0],1))), axis =1) + + return labeled_ndarray + +def to_one_hot(labels): + + temp = np.zeros(shape=(labels.shape[0],2)) + + for i in range(labels.shape[0]): + if labels[i]==0: + temp[i][0]=1 + else: + temp[i][1]=1 + + return temp + +def k_subsets(i, k, X, Y_labels): + + train_size, dim=X.shape + #divide in k subsets and strip out the Ds_mass branch + k_batch_size = train_size//k + + X_dict={} + Y_dict={} + + for b in range(k): + X_dict[b]=X[k_batch_size*b:k_batch_size*(b+1)] + Y_dict[b]=Y_labels[k_batch_size*b:k_batch_size*(b+1)] + + k_range=np.arange(k) + + X_test = X_dict[i][:,0:dim-1] + Y_test = Y_dict[i][:,0:dim-1] + + + k_subset=np.delete(k_range, i) + + + X_train = np.concatenate([X_dict[j][:,0:dim-1] for j in k_subset],axis=0) + Y_train = np.concatenate([Y_dict[j][:,0:dim-1] for j in k_subset],axis=0) + + return X_train, Y_train, X_test, Y_test, X_dict, Y_dict + + +def return_branches(data_index=None, mother_index=None, l_index=None, meson_index=None): + if data_index==0: + if l_index==1: + branches_needed = [ + #________________________________________ + #D MC true info + + + mother_ID[mother_index]+'_MC_MOTHER_ID', + mother_ID[mother_index]+'_BKGCAT', + mother_ID[mother_index]+'_TRUEID', + #________________________________________ + #D Geometric variables, pT and FD + + mother_ID[mother_index]+"_ENDVERTEX_CHI2", + mother_ID[mother_index]+"_ENDVERTEX_NDOF", + mother_ID[mother_index]+"_IPCHI2_OWNPV", + + mother_ID[mother_index]+"_OWNPV_CHI2", + mother_ID[mother_index]+"_OWNPV_NDOF", + mother_ID[mother_index]+"_IP_OWNPV", + mother_ID[mother_index]+"_DIRA_OWNPV", + + mother_ID[mother_index]+"_PX", + mother_ID[mother_index]+"_PY", + mother_ID[mother_index]+"_PZ", + mother_ID[mother_index]+"_PT", + mother_ID[mother_index]+"_FD_OWNPV", + mother_ID[mother_index]+"_FDCHI2_OWNPV", + + #D Reconstructed mass + mother_ID[mother_index]+"_ConsD_M", + + #D Trigger variables + mother_ID[mother_index]+"_Hlt1TrackMVADecision_TOS", + mother_ID[mother_index]+"_Hlt2RareCharmD2Pi"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+"OSDecision_TOS", + mother_ID[mother_index]+"_Hlt2Phys_TOS", + + #________________________________________ + #PHI MC TRUE INFO + + 'phi_MC_MOTHER_ID', + 'phi_BKGCAT', + 'phi_TRUEID', + #________________________________________ + #phi geometric variables, pT and FD + + "phi_ENDVERTEX_CHI2", + "phi_ENDVERTEX_NDOF", + "phi_IPCHI2_OWNPV", + + #"phi_OWNPV_CHI2", + #"phi_OWNPV_NDOF", + #"phi_IP_OWNPV", + #"phi_DIRA_OWNPV", + + "phi_PT", + + #phi Reconstructed mass + + "phi_M", + + #________________________________________ + #PION + #Pion mother ID and bkg cat + + meson_ID[meson_index]+'_MC_MOTHER_ID', + meson_ID[meson_index]+'_TRUEID', + + #_____________________________________ + #pi Geometric variables and pT + #"pi_OWNPV_CHI2", + #"pi_OWNPV_NDOF", + #'pi_IP_OWNPV', + + meson_ID[meson_index]+"_PX", + meson_ID[meson_index]+"_PY", + meson_ID[meson_index]+"_PZ", + + meson_ID[meson_index]+'_PT', + + #pi PID variables + + "pi_MC15TuneV1_ProbNNpi", + + #________________________________________ + #LEPTONS + l_flv[l_index]+'_plus_MC_MOTHER_ID', + l_flv[l_index]+'_plus_TRUEID', + + l_flv[l_index]+'_minus_MC_MOTHER_ID', + l_flv[l_index]+'_minus_TRUEID', + #________________________________________ + #leptons Geometric variables and pT + + l_flv[l_index]+"_plus_OWNPV_CHI2", + #l_flv[l_index]+"_plus_OWNPV_NDOF", + l_flv[l_index]+"_minus_OWNPV_CHI2", + #l_flv[l_index]+"_minus_OWNPV_NDOF", + # + #l_flv[l_index]+"_plus_IP_OWNPV", + #l_flv[l_index]+"_minus_IP_OWNPV", + + l_flv[l_index]+"_plus_PX", + l_flv[l_index]+"_plus_PY", + l_flv[l_index]+"_plus_PZ", + + l_flv[l_index]+"_minus_PX", + l_flv[l_index]+"_minus_PY", + l_flv[l_index]+"_minus_PZ", + + l_flv[l_index]+"_plus_PT", + l_flv[l_index]+"_minus_PT", + + #leptons PID variables + + l_flv[l_index]+"_plus_MC15TuneV1_ProbNN"+l_flv[l_index], + l_flv[l_index]+"_minus_MC15TuneV1_ProbNN"+l_flv[l_index], + + + ] + if l_index==0: + branches_needed = [ + #________________________________________ + #D MC true info + + + mother_ID[mother_index]+'_MC_MOTHER_ID', + mother_ID[mother_index]+'_BKGCAT', + mother_ID[mother_index]+'_TRUEID', + #________________________________________ + #D Geometric variables, pT and FD + + mother_ID[mother_index]+"_ENDVERTEX_CHI2", + mother_ID[mother_index]+"_ENDVERTEX_NDOF", + mother_ID[mother_index]+"_IPCHI2_OWNPV", + + mother_ID[mother_index]+"_OWNPV_CHI2", + mother_ID[mother_index]+"_OWNPV_NDOF", + mother_ID[mother_index]+"_IP_OWNPV", + mother_ID[mother_index]+"_DIRA_OWNPV", + + mother_ID[mother_index]+"_PX", + mother_ID[mother_index]+"_PY", + mother_ID[mother_index]+"_PZ", + mother_ID[mother_index]+"_PT", + mother_ID[mother_index]+"_FD_OWNPV", + mother_ID[mother_index]+"_FDCHI2_OWNPV", + + #D Reconstructed mass + mother_ID[mother_index]+"_ConsD_M", + + #D Trigger variables + mother_ID[mother_index]+"_Hlt1TrackMVADecision_TOS", + mother_ID[mother_index]+"_Hlt2RareCharmD2Pi"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+"OSDecision_TOS", + mother_ID[mother_index]+"_Hlt2Phys_TOS", + + #________________________________________ + #PHI MC TRUE INFO + + 'phi_MC_MOTHER_ID', + 'phi_BKGCAT', + 'phi_TRUEID', + #________________________________________ + #phi geometric variables, pT and FD + + "phi_ENDVERTEX_CHI2", + "phi_ENDVERTEX_NDOF", + "phi_IPCHI2_OWNPV", + + #"phi_OWNPV_CHI2", + #"phi_OWNPV_NDOF", + #"phi_IP_OWNPV", + #"phi_DIRA_OWNPV", + + "phi_PT", + + #phi Reconstructed mass + + "phi_M", + + #________________________________________ + #PION + #Pion mother ID and bkg cat + + meson_ID[meson_index]+'_MC_MOTHER_ID', + meson_ID[meson_index]+'_TRUEID', + + #_____________________________________ + #pi Geometric variables and pT + #"pi_OWNPV_CHI2", + #"pi_OWNPV_NDOF", + #'pi_IP_OWNPV', + + + meson_ID[meson_index]+"_PX", + meson_ID[meson_index]+"_PY", + meson_ID[meson_index]+"_PZ", + + meson_ID[meson_index]+'_PT', + + #pi PID variables + + "pi_MC15TuneV1_ProbNNpi", + + #________________________________________ + #LEPTONS + l_flv[l_index]+'_plus_MC_MOTHER_ID', + l_flv[l_index]+'_plus_TRUEID', + + l_flv[l_index]+'_minus_MC_MOTHER_ID', + l_flv[l_index]+'_minus_TRUEID', + #________________________________________ + #leptons Geometric variables and pT + + l_flv[l_index]+"_plus_OWNPV_CHI2", + #l_flv[l_index]+"_plus_OWNPV_NDOF", + l_flv[l_index]+"_minus_OWNPV_CHI2", + #l_flv[l_index]+"_minus_OWNPV_NDOF", + # + #l_flv[l_index]+"_plus_IP_OWNPV", + #l_flv[l_index]+"_minus_IP_OWNPV", + + l_flv[l_index]+"_plus_PX", + l_flv[l_index]+"_plus_PY", + l_flv[l_index]+"_plus_PZ", + + l_flv[l_index]+"_plus_PT", + + l_flv[l_index]+"_minus_PX", + l_flv[l_index]+"_minus_PY", + l_flv[l_index]+"_minus_PZ", + + l_flv[l_index]+"_minus_PT", + + #leptons PID variables + + l_flv[l_index]+"_plus_MC15TuneV1_ProbNN"+l_flv[l_index], + l_flv[l_index]+"_minus_MC15TuneV1_ProbNN"+l_flv[l_index], + + + ] + if data_index==1: + branches_needed = [ + + #________________________________ + #D Geometric variables, pT and FD + + mother_ID[mother_index]+"_ENDVERTEX_CHI2", + mother_ID[mother_index]+"_ENDVERTEX_NDOF", + mother_ID[mother_index]+"_IPCHI2_OWNPV", + + mother_ID[mother_index]+"_OWNPV_CHI2", + mother_ID[mother_index]+"_OWNPV_NDOF", + mother_ID[mother_index]+"_IP_OWNPV", + mother_ID[mother_index]+"_DIRA_OWNPV", + + mother_ID[mother_index]+"_PX", + mother_ID[mother_index]+"_PY", + mother_ID[mother_index]+"_PZ", + mother_ID[mother_index]+"_PT", + mother_ID[mother_index]+"_FD_OWNPV", + mother_ID[mother_index]+"_FDCHI2_OWNPV", + + #D Reconstructed mass + mother_ID[mother_index]+"_ConsD_M", + + #D Trigger variables + mother_ID[mother_index]+"_Hlt1TrackMVADecision_TOS", + mother_ID[mother_index]+"_Hlt2RareCharmD2Pi"+l_flv[l_index].capitalize()+l_flv[l_index].capitalize()+"OSDecision_TOS", + mother_ID[mother_index]+"_Hlt2Phys_TOS", + + + #________________________________________ + #phi geometric variables, pT and FD + + "phi_ENDVERTEX_CHI2", + "phi_ENDVERTEX_NDOF", + "phi_IPCHI2_OWNPV", + + #"phi_OWNPV_CHI2", + #"phi_OWNPV_NDOF", + #"phi_IP_OWNPV", + #"phi_DIRA_OWNPV", + + "phi_PT", + + #phi Reconstructed mass + + "phi_M", + + #________________________________________ + #PION + + #_____________________________________ + #pi Geometric variables and pT + #"pi_OWNPV_CHI2", + #"pi_OWNPV_NDOF", + #'pi_IP_OWNPV', + + + meson_ID[meson_index]+"_PX", + meson_ID[meson_index]+"_PY", + meson_ID[meson_index]+"_PZ", + + meson_ID[meson_index]+'_PT', + + #pi PID variables + + "pi_MC15TuneV1_ProbNNpi", + + #________________________________________ + #LEPTONS + #________________________________________ + #leptons Geometric variables and pT + + l_flv[l_index]+"_plus_OWNPV_CHI2", + #l_flv[l_index]+"_plus_OWNPV_NDOF", + l_flv[l_index]+"_minus_OWNPV_CHI2", + #l_flv[l_index]+"_minus_OWNPV_NDOF", + # + #l_flv[l_index]+"_plus_IP_OWNPV", + #l_flv[l_index]+"_minus_IP_OWNPV", + + l_flv[l_index]+"_plus_PX", + l_flv[l_index]+"_plus_PY", + l_flv[l_index]+"_plus_PZ", + + l_flv[l_index]+"_plus_PT", + + l_flv[l_index]+"_minus_PX", + l_flv[l_index]+"_minus_PY", + l_flv[l_index]+"_minus_PZ", + + l_flv[l_index]+"_minus_PT", + + #leptons PID variables + + l_flv[l_index]+"_plus_MC15TuneV1_ProbNN"+l_flv[l_index], + l_flv[l_index]+"_minus_MC15TuneV1_ProbNN"+l_flv[l_index], + + + ] + return branches_needed + +def return_branches_BDT(mother_index=None, l_index=None, meson_index=None): + if l_index==1: + branches_needed = [ + #________________________________ + #D Geometric variables, pT and FD + + mother_ID[mother_index]+"_ENDVERTEX_CHI2", + mother_ID[mother_index]+"_IPCHI2_OWNPV", + + #mother_ID[mother_index]+"_OWNPV_CHI2", + #mother_ID[mother_index]+"_IP_OWNPV", + mother_ID[mother_index]+"_DIRA_OWNPV", + + mother_ID[mother_index]+"_PT", + #mother_ID[mother_index]+"_FD_OWNPV", + mother_ID[mother_index]+"_FDCHI2_OWNPV", + + + + + #________________________________________ + #phi geometric variables, pT and FD + + #"phi_ENDVERTEX_CHI2", + "phi_IPCHI2_OWNPV", + + #"phi_OWNPV_CHI2", + #"phi_OWNPV_NDOF", + #"phi_IP_OWNPV", + #"phi_DIRA_OWNPV", + + #"phi_PT", + + #________________________________________ + #PION + + #_____________________________________ + #pi Geometric variables and pT + #"pi_OWNPV_CHI2", + #"pi_OWNPV_NDOF", + #'pi_IP_OWNPV', + + + meson_ID[meson_index]+'_PT', + + + #________________________________________ + #LEPTONS + #________________________________________ + #leptons Geometric variables and pT + + #l_flv[l_index]+"_plus_OWNPV_CHI2", + #l_flv[l_index]+"_plus_OWNPV_NDOF", + #l_flv[l_index]+"_minus_OWNPV_CHI2", + #l_flv[l_index]+"_minus_OWNPV_NDOF", + # + #l_flv[l_index]+"_plus_IP_OWNPV", + #l_flv[l_index]+"_minus_IP_OWNPV", + + l_flv[l_index]+"_plus_PT", + l_flv[l_index]+"_minus_PT", + + + #D Reconstructed mass + mother_ID[mother_index]+"_ConsD_M", + ] + if l_index==0: + branches_needed = [ + #________________________________ + #D Geometric variables, pT and FD + + mother_ID[mother_index]+"_ENDVERTEX_CHI2", + mother_ID[mother_index]+"_IPCHI2_OWNPV", + + mother_ID[mother_index]+"_OWNPV_CHI2", + #mother_ID[mother_index]+"_IP_OWNPV", + mother_ID[mother_index]+"_DIRA_OWNPV", + + mother_ID[mother_index]+"_PT", + mother_ID[mother_index]+"_FD_OWNPV", + mother_ID[mother_index]+"_FDCHI2_OWNPV", + + + #________________________________________ + #phi geometric variables, pT and FD + + #"phi_ENDVERTEX_CHI2", + #"phi_IPCHI2_OWNPV", + + #"phi_OWNPV_CHI2", + #"phi_OWNPV_NDOF", + #"phi_IP_OWNPV", + #"phi_DIRA_OWNPV", + + #"phi_PT", + + #________________________________________ + #PION + + #_____________________________________ + #pi Geometric variables and pT + #"pi_OWNPV_CHI2", + #"pi_OWNPV_NDOF", + #'pi_IP_OWNPV', + + + meson_ID[meson_index]+'_PT', + + + #________________________________________ + #LEPTONS + #________________________________________ + #leptons Geometric variables and pT + + #l_flv[l_index]+"_plus_OWNPV_CHI2", + #l_flv[l_index]+"_plus_OWNPV_NDOF", + #l_flv[l_index]+"_minus_OWNPV_CHI2", + #l_flv[l_index]+"_minus_OWNPV_NDOF", + # + #l_flv[l_index]+"_plus_IP_OWNPV", + #l_flv[l_index]+"_minus_IP_OWNPV", + + l_flv[l_index]+"_plus_PT", + l_flv[l_index]+"_minus_PT", + + + #D Reconstructed mass + mother_ID[mother_index]+"_ConsD_M", + ] + return branches_needed + +def norm_chi2(MC_Dplus_sig_dict, MC_Ds_sig_dict, data_dict): + MC_Ds_sig_dict["Ds_ENDVERTEX_CHI2"]=MC_Ds_sig_dict["Ds_ENDVERTEX_CHI2"]/MC_Ds_sig_dict["Ds_ENDVERTEX_NDOF"] + MC_Ds_sig_dict["Ds_IPCHI2_OWNPV"]=MC_Ds_sig_dict["Ds_IPCHI2_OWNPV"]/MC_Ds_sig_dict["Ds_ENDVERTEX_NDOF"] + + MC_Ds_sig_dict["Ds_FDCHI2_OWNPV"]=MC_Ds_sig_dict["Ds_FDCHI2_OWNPV"]/MC_Ds_sig_dict["Ds_OWNPV_NDOF"] + MC_Ds_sig_dict["Ds_OWNPV_CHI2"]=MC_Ds_sig_dict["Ds_OWNPV_CHI2"]/MC_Ds_sig_dict["Ds_OWNPV_NDOF"] + + del MC_Ds_sig_dict["Ds_OWNPV_NDOF"] + del MC_Ds_sig_dict["Ds_ENDVERTEX_NDOF"] + + MC_Dplus_sig_dict["Dplus_ENDVERTEX_CHI2"]=MC_Dplus_sig_dict["Dplus_ENDVERTEX_CHI2"]/MC_Dplus_sig_dict["Dplus_ENDVERTEX_NDOF"] + MC_Dplus_sig_dict["Dplus_IPCHI2_OWNPV"]=MC_Dplus_sig_dict["Dplus_IPCHI2_OWNPV"]/MC_Dplus_sig_dict["Dplus_ENDVERTEX_NDOF"] + + MC_Dplus_sig_dict["Dplus_FDCHI2_OWNPV"]=MC_Dplus_sig_dict["Dplus_FDCHI2_OWNPV"]/MC_Dplus_sig_dict["Dplus_OWNPV_NDOF"] + MC_Dplus_sig_dict["Dplus_OWNPV_CHI2"]=MC_Dplus_sig_dict["Dplus_OWNPV_CHI2"]/MC_Dplus_sig_dict["Dplus_OWNPV_NDOF"] + + del MC_Dplus_sig_dict["Dplus_OWNPV_NDOF"] + del MC_Dplus_sig_dict["Dplus_ENDVERTEX_NDOF"] + + data_dict["Ds_ENDVERTEX_CHI2"]=data_dict["Ds_ENDVERTEX_CHI2"]/data_dict["Ds_ENDVERTEX_NDOF"] + data_dict["Ds_IPCHI2_OWNPV"]=data_dict["Ds_IPCHI2_OWNPV"]/data_dict["Ds_ENDVERTEX_NDOF"] + + data_dict["Ds_FDCHI2_OWNPV"]=data_dict["Ds_FDCHI2_OWNPV"]/data_dict["Ds_OWNPV_NDOF"] + data_dict["Ds_OWNPV_CHI2"]=data_dict["Ds_OWNPV_CHI2"]/data_dict["Ds_OWNPV_NDOF"] + + del data_dict["Ds_OWNPV_NDOF"] + del data_dict["Ds_ENDVERTEX_NDOF"] + + return MC_Dplus_sig_dict, MC_Ds_sig_dict, data_dict + +def mass_cut_for_fit(lower_cut, upper_cut, mother_index_fit=None, l_index=None, + branches_needed=None, data_dict=None, + MC_Dplus_dict=None, MC_Ds_dict=None): + + #applying needed mass cuts on data + #Applies needed mass cuts on data and + #returns arrays of mass distr for MC and data + + + data_indices=[] + + for i in range(len(data_dict["Ds_ConsD_M"])): + + D_m = data_dict["Ds_ConsD_M"][i] + #fixing a window on the phi mass + if lower_cutx_cut) + + output_XG_Dplus_MC=loaded_model.predict_proba(mc_Dplus_to_select) + bdt_selection_mc_Dplus= np.where(output_XG_Dplus_MC[:,1]>x_cut) + + output_XG_Ds_MC=loaded_model.predict_proba(mc_Ds_to_select) + bdt_selection_mc_Ds= np.where(output_XG_Ds_MC[:,1]>x_cut) + + + """ + Save data/MC tuples with geom and kinetic variables after BDT cut for later comparison + + """ + + data_bdt_sel={} + + for label in branches_needed: + data_bdt_sel[label] = data_dict[label][bdt_selection_data] + + MC_Dplus_dict_sel={} + + for label in branches_needed_Dplus: + MC_Dplus_dict_sel[label] = MC_Dplus_dict[label][bdt_selection_mc_Dplus] + + MC_Ds_dict_sel={} + + for label in branches_needed: + MC_Ds_dict_sel[label] = MC_Ds_dict[label][bdt_selection_mc_Ds] + + print(len(bdt_selection_mc_Ds[0]),len(bdt_selection_mc_Dplus[0])) + # MC_Dplus_array= np.array( + # [ + # tuple( MC_Dplus_dict_sel[label][k] for label in branches_needed_Dplus ) + # for k in range(len(MC_Dplus_dict_sel[label])) + # ], + + # dtype=[(label, np.float32) for label in branches_needed_Dplus] + # ) + + + # MC_Ds_array= np.array( + # [ + # tuple( MC_Ds_dict_sel[label][k] for label in branches_needed ) + # for k in range(len(MC_Ds_dict_sel[label])) + # ], + + # dtype=[(label, np.float32) for label in branches_needed] + # ) + + + """ + + Apply BDT cuts on data/MC mass variables + + + """ + + data_mass_selected=np.array(data_mass[bdt_selection_data]) + mc_Dplus_mass_selected=np.array(mc_Dplus_mass[bdt_selection_mc_Dplus]) + mc_Ds_mass_selected=np.array(mc_Ds_mass[bdt_selection_mc_Ds]) + + """ + + Signal selection efficiency of BDT + + + """ + + + if mother_ID[mother_index_fit]=='both': + + nsig_from_MC=mc_Dplus_to_select.shape[0]+mc_Ds_to_select.shape[0] + nsig_bdt_sel_MC=mc_Dplus_mass_selected.shape[0]+mc_Ds_mass_selected.shape[0] + sig_sel_eff=np.float(nsig_bdt_sel_MC)/np.float(nsig_from_MC) + + if mother_ID[mother_index_fit]=='Dplus': + + nsig_from_MC=mc_Dplus_to_select.shape[0] + nsig_bdt_sel_MC=mc_Dplus_mass_selected.shape[0] + sig_sel_eff=np.float(nsig_bdt_sel_MC)/np.float(nsig_from_MC) + + if mother_ID[mother_index_fit]=='Ds': + + nsig_from_MC=mc_Ds_to_select.shape[0] + nsig_bdt_sel_MC=mc_Ds_mass_selected.shape[0] + sig_sel_eff=np.float(nsig_bdt_sel_MC)/np.float(nsig_from_MC) + + + print("BDT Signal selection efficiency: {0}".format(sig_sel_eff)) + + """ + Cut for mass fit + + """ + + data_cut_indices=[] + for i in range(len(data_mass_selected)): + if lower_mass_cut 1: + name = 'g_deconv_layer_%s' %deconv_count + #print(name) + + layer = DeconvLayer( + name, 2*mi, mo, [dec_dims_H[deconv_count], dec_dims_W[deconv_count]], + filter_sz, stride, apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.g_dec_conv_layers.append(layer) + mi = mo + + + assert conv_count==deconv_count, '\n Number of convolutional and deconvolutional layers do not coincide in \n encoder and decoder part of generator '+g_name + + # self.g_dims_H = dec_dims_H + # self.g_dims_W = dims_W + self.conv_count=conv_count + self.deconv_count=deconv_count + self.g_name=g_name + + def g_forward(self, X, reuse=None, is_training=True): + + print('Generator_'+self.g_name) + + output = X + print('Input for generator encoder shape', X.get_shape()) + + skip_conv_outputs=[] + #convolutional encoder layers + + for i, layer in enumerate(self.g_enc_conv_layers, 1): + output = layer.forward(output, + reuse, + is_training) + + skip_conv_outputs.append(output) + # print('After conv layer%i' %i) + # print('shape: ', output.get_shape()) + + assert i == self.conv_count + + if (output.get_shape().as_list()[1], output.get_shape().as_list()[2]) != (1, 1): + output = tf.reshape( + output, + [-1, 1, 1, self.n_C_last] + ) + + print('Output of generator encoder, \n and input for generator decoder shape', output.get_shape()) + + for i, layer in enumerate(self.g_dec_conv_layers, 1): + + skip_layer=self.conv_count - i + if i > 1: + #print('After deconv layer %i' %i) + #print('main path', output.get_shape()) + #print('secondary path', skip_conv_outputs[skip_layer].get_shape()) + output = tf.concat([output, skip_conv_outputs[skip_layer]], axis =3) + #print('After concat shape', output.get_shape()) + output = layer.forward(output, + reuse, + is_training) + + # print('After deconv layer %i' %i) + # print('Shape', output.get_shape()) + + assert i == self.deconv_count + + print('Generator output shape', output.get_shape()) + return output + +#same as pix2pix with input noise +class bicycleGenerator(object): + + def __init__(self, X, output_dim_H, output_dim_W, g_sizes_enc, g_sizes_dec, g_name): + + _, input_dim_H, input_dim_W, input_n_C = X.get_shape().as_list() + + enc_dims_H=[input_dim_H] + enc_dims_W=[input_dim_W] + enc_dims_nC=[input_n_C] + + output_n_C=input_n_C + self.latent_dims = g_sizes_enc['latent_dims'] + mi = input_n_C + self.latent_dims + + with tf.variable_scope('generator_'+g_name) as scope: + + #building generator encoder convolutional layers + self.g_enc_conv_layers =[] + enc_dims=[] + for conv_count, (mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init) in enumerate(g_sizes_enc['conv_layers'], 1): + + name = "g_conv_layer_%s" % conv_count + layer = ConvLayer(name, mi, mo, + filter_sz, stride, + apply_batch_norm, keep_prob, + act_f, w_init) + + input_dim_H = int(np.ceil(float(input_dim_H)/stride)) + input_dim_W = int(np.ceil(float(input_dim_W)/stride)) + + enc_dims_H.append(input_dim_H) + enc_dims_W.append(input_dim_W) + enc_dims_nC.append(mo) + self.g_enc_conv_layers.append(layer) + + mi = mo + + dec_dims_H = [output_dim_H] + dec_dims_W = [output_dim_W] + + #building generator decoder deconvolutional layers + #calculate outputsize for each deconvolution step + for _, _, stride, _, _, _, _ in reversed(g_sizes_dec['deconv_layers']): + + output_dim_H = int(np.ceil(float(output_dim_H)/stride)) + output_dim_W = int(np.ceil(float(output_dim_W)/stride)) + + dec_dims_H.append(output_dim_H) + dec_dims_W.append(output_dim_W) + + dec_dims_H = list(reversed(dec_dims_H)) + dec_dims_W = list(reversed(dec_dims_W)) + + self.g_dec_conv_layers=[] + + #number of channels of last convolution and of first transposed convolution + # the layer will be reshaped to have dimensions [?, 1, 1, mi*enc_dims_W[-1]*enc_dims_H[-1]] + mi=mi*enc_dims_W[-1]*enc_dims_H[-1] + self.n_C_last=mi + + for deconv_count, (mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init) in enumerate(g_sizes_dec['deconv_layers'], 1): + + if deconv_count == 1: + name = 'g_deconv_layer_%s' %deconv_count + #print(name) + + layer = DeconvLayer( + name, mi, mo, [dec_dims_H[deconv_count], dec_dims_W[deconv_count]], + filter_sz, stride, apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.g_dec_conv_layers.append(layer) + mi = mo + + if deconv_count > 1: + name = 'g_deconv_layer_%s' %deconv_count + #print(name) + + layer = DeconvLayer( + name, 2*mi, mo, [dec_dims_H[deconv_count], dec_dims_W[deconv_count]], + filter_sz, stride, apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.g_dec_conv_layers.append(layer) + mi = mo + + + assert conv_count==deconv_count, '\n Number of convolutional and deconvolutional layers do not coincide in \n encoder and decoder part of generator '+g_name + + # self.g_dims_H = dec_dims_H + # self.g_dims_W = dims_W + self.conv_count=conv_count + self.deconv_count=deconv_count + self.g_name=g_name + + def g_forward(self, X, z, reuse=None, is_pretraining=None, is_training=True): + + if is_pretraining: + z=X + elif not is_pretraining: + z = tf.reshape(z, [tf.shape(X)[0], 1, 1, self.latent_dims]) + z = tf.tile(z, [1, tf.shape(X)[1], tf.shape(X)[2], 1]) + + print('Generator_'+self.g_name) + + output = X + output=tf.concat([X,z], axis=3) + + print('Input for generator encoded shape', X.get_shape()) + + skip_conv_outputs=[] + #convolutional encoder layers + + for i, layer in enumerate(self.g_enc_conv_layers, 1): + output = layer.forward(output, + reuse, + is_training) + + skip_conv_outputs.append(output) + #print('After conv layer%i' %i) + #print('shape: ', output.get_shape()) + + assert i == self.conv_count + + if (output.get_shape().as_list()[1], output.get_shape().as_list()[2]) != (1, 1): + output = tf.reshape( + output, + [-1, 1, 1, self.n_C_last] + ) + + print('Output of generator encoder, \n and input for generator decoder shape', output.get_shape()) + + for i, layer in enumerate(self.g_dec_conv_layers, 1): + + skip_layer=self.conv_count - i + if i > 1: + #print('After deconv layer %i' %i) + #print('main path', output.get_shape()) + #print('secondary path', skip_conv_outputs[skip_layer].get_shape()) + output = tf.concat([output, skip_conv_outputs[skip_layer]], axis =3) + #print('After concat shape', output.get_shape()) + output = layer.forward(output, + reuse, + is_training) + + # print('After deconv layer %i' %i) + # print('Shape', output.get_shape()) + + assert i == self.deconv_count + + print('Generator output shape', output.get_shape()) + return output + +class condGenerator(object): + def __init__(self, dim_y, dim_H, dim_W, g_sizes, g_name): + + self.residual=False + for key in g_sizes: + if not 'block' in key: + self.residual=False + else : + self.residual=True + + #dimensions of input + latent_dims = g_sizes['z'] + + #dimensions of output generated images + dims_H =[dim_H] + dims_W =[dim_W] + mi = latent_dims + dim_y + + if not self.residual: + + print('Convolutional architecture detected for generator ' + g_name) + + with tf.variable_scope('generator_'+g_name) as scope: + + #building generator dense layers + self.g_dense_layers = [] + count = 0 + + for mo, apply_batch_norm, keep_prob, act_f, w_init in g_sizes['dense_layers']: + name = 'g_dense_layer_%s' %count + #print(name) + count += 1 + layer = DenseLayer(name, mi, mo, + apply_batch_norm, keep_prob, + act_f=act_f , w_init=w_init + ) + + self.g_dense_layers.append(layer) + mi = mo + mi = mi + dim_y + + #deconvolutional layers + #calculating the last dense layer mo + + for _, _, stride, _, _, _, _, in reversed(g_sizes['conv_layers']): + + dim_H = int(np.ceil(float(dim_H)/stride)) + dim_W = int(np.ceil(float(dim_W)/stride)) + + dims_H.append(dim_H) + dims_W.append(dim_W) + + dims_H = list(reversed(dims_H)) + dims_W = list(reversed(dims_W)) + self.g_dims_H = dims_H + self.g_dims_W = dims_W + + #last dense layer: projection + projection, bn_after_project, keep_prob, act_f, w_init = g_sizes['projection'][0] + + mo = (projection)*dims_H[0]*dims_W[0] + name = 'g_dense_layer_%s' %count + count+=1 + #print(name) + self.g_final_layer = DenseLayer(name, mi, mo, not bn_after_project, keep_prob, act_f, w_init) + # self.g_dense_layers.append(layer) + + mi = projection+dim_y + self.g_conv_layers=[] + + for i, (mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init) in enumerate(g_sizes['conv_layers'] , 1): + name = 'g_conv_layer_%s' %count + count +=1 + + layer = DeconvLayer( + name, mi, mo, [dims_H[i], dims_W[i]], + filter_sz, stride, apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.g_conv_layers.append(layer) + mi = mo + mi = mi + dim_y + + if self.residual: + + print('Residual convolutional architecture detected for generator ' + g_name) + with tf.variable_scope('generator_'+g_name) as scope: + + #dense layers + self.g_dense_layers = [] + count = 0 + + mi = latent_dims + + for mo, apply_batch_norm, keep_prob, act_f, w_init in g_sizes['dense_layers']: + name = 'g_dense_layer_%s' %count + count += 1 + + layer = DenseLayer( + name, mi, mo, + apply_batch_norm, keep_prob, + f=act_f, w_init=w_init + ) + self.g_dense_layers.append(layer) + mi = mo + + #checking generator architecture + + g_steps = 0 + for key in g_sizes: + if 'deconv' in key: + if not 'shortcut' in key: + g_steps+=1 + + g_block_n=0 + g_layer_n=0 + + for key in g_sizes: + if 'block' and 'shortcut' in key: + g_block_n+=1 + if 'deconv_layer' in key: + g_layer_n +=1 + + assert g_block_n+g_layer_n==g_steps, '\nCheck keys in g_sizes, \n sum of generator steps do not coincide with sum of convolutional layers and convolutional blocks' + + layers_output_sizes={} + blocks_output_sizes={} + + #calculating the output size for each transposed convolutional step + for key, item in reversed(list(g_sizes.items())): + + if 'deconv_layer' in key: + + _, _, stride, _, _, _, _, = g_sizes[key][0] + layers_output_sizes[g_layer_n-1]= [dim_H, dim_W] + + dim_H = int(np.ceil(float(dim_H)/stride)) + dim_W = int(np.ceil(float(dim_W)/stride)) + dims_H.append(dim_H) + dims_W.append(dim_W) + + g_layer_n -= 1 + + + if 'deconvblock_layer' in key: + + for _ ,_ , stride, _, _, _, _, in g_sizes[key]: + + dim_H = int(np.ceil(float(dim_H)/stride)) + dim_W = int(np.ceil(float(dim_W)/stride)) + dims_H.append(dim_H) + dims_W.append(dim_W) + + blocks_output_sizes[g_block_n-1] = [[dims_H[j],dims_W[j]] for j in range(1, len(g_sizes[key])+1)] + g_block_n -=1 + + dims_H = list(reversed(dims_H)) + dims_W = list(reversed(dims_W)) + + #saving for later + self.g_dims_H = dims_H + self.g_dims_W = dims_W + + #final dense layer + projection, bn_after_project, keep_prob, act_f, w_init = g_sizes['projection'][0] + + mo = projection*dims_H[0]*dims_W[0] + name = 'g_dense_layer_%s' %count + layer = DenseLayer(name, mi, mo, not bn_after_project, keep_prob, act_f, w_init) + self.g_dense_layers.append(layer) + + #deconvolution input channel number + mi = projection + self.g_blocks=[] + + block_n=0 #keep count of the block number + layer_n=0 #keep count of conv layer number + i=0 + for key in g_sizes: + + if 'block' and 'shortcut' in key: + + g_block = DeconvBlock(block_n, + mi, blocks_output_sizes, g_sizes, + ) + self.g_blocks.append(g_block) + + mo, _, _, _, _, _, _, = g_sizes['deconvblock_layer_'+str(block_n)][-1] + mi = mo + block_n+=1 + count+=1 + i+=1 + + if 'deconv_layer' in key: + + name = 'g_conv_layer_{0}'.format(layer_n) + + mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = g_sizes[key][0] + + g_conv_layer = DeconvLayer( + name, mi, mo, layers_output_sizes[layer_n], + filter_sz, stride, apply_batch_norm, keep_prob, + act_f, w_init + ) + self.g_blocks.append(g_conv_layer) + + mi=mo + layer_n+=1 + count+=1 + i+=1 + + assert i==g_steps, 'Check convolutional layer and block building, steps in building do not coincide with g_steps' + assert g_steps==block_n+layer_n, 'Check keys in g_sizes' + + self.g_sizes=g_sizes + self.g_name = g_name + self.projection = projection + self.bn_after_project = bn_after_project + self.dim_y = dim_y + + def g_forward(self, Z, y, reuse=None, is_training=True): + + if not self.residual: + + print('Generator_'+self.g_name) + print('Deconvolution') + #dense layers + + output = Z + output = lin_concat(output, y, self.dim_y) + print('Input for deconvolution shape', output.get_shape()) + i=0 + for layer in self.g_dense_layers: + + + output = layer.forward(output, reuse, is_training) + output= lin_concat(output, y, self.dim_y) + #print('After dense layer and concat %i' %i) + #print('shape: ', output.get_shape()) + i+=1 + + output = self.g_final_layer.forward(output, reuse, is_training) + + output = tf.reshape( + output, + + [-1, self.g_dims_H[0], self.g_dims_W[0], self.projection] + + ) + #print('Reshaped output after projection', output.get_shape()) + + if self.bn_after_project: + output = tf.contrib.layers.batch_norm( + output, + decay=0.9, + updates_collections=None, + epsilon=1e-5, + scale=True, + is_training=is_training, + reuse=reuse, + scope='bn_after_project' + ) + # passing to deconv blocks + output = conv_concat(output, y, self.dim_y) + #print('After reshape and concat', output.get_shape()) + i=0 + for layer in self.g_conv_layers[:-1]: + i+=1 + output = layer.forward(output, reuse, is_training) + output = conv_concat(output, y, self.dim_y) + #print('After deconvolutional layer and concat %i' %i) + #print('shape: ', output.get_shape()) + + output=self.g_conv_layers[-1].forward(output, reuse, is_training) + print('Deconvoluted output shape', output.get_shape()) + return output + else: + + print('Generator_'+self.g_name) + print('Deconvolution') + #dense layers + + output = Z + print('Input for deconvolution shape', Z.get_shape()) + i=0 + for layer in self.g_dense_layers: + i+=1 + output = layer.forward(output, reuse, is_training) + #print('After dense layer %i' %i) + #print('shape: ', output.get_shape()) + + + output = tf.reshape( + output, + + [-1, self.g_dims_H[0], self.g_dims_W[0], self.projection] + + ) + + #print('Reshaped output after projection', output.get_shape()) + + if self.bn_after_project: + output = tf.contrib.layers.batch_norm( + output, + decay=0.9, + updates_collections=None, + epsilon=1e-5, + scale=True, + is_training=is_training, + reuse=reuse, + scope='bn_after_project' + ) + # passing to deconv blocks + + + i=0 + for block in self.g_blocks: + i+=1 + output = block.forward(output, + reuse, + is_training) + #print('After deconvolutional block %i' %i) + #print('shape: ', output.get_shape()) + + + print('Deconvoluted output shape', output.get_shape()) + return output + +#VARIATIONAL_AUTOENCODERS + +class denseEncoder: + + def __init__(self, X, e_sizes, name): + + latent_dims = e_sizes['z'] + + _, mi = X.get_shape().as_list() + + with tf.variable_scope('encoder'+name) as scope: + + self.e_layers=[] + + count=0 + for mo, apply_batch_norm, keep_prob, act_f, w_init in e_sizes['dense_layers']: + + name = 'layer_{0}'.format(count) + count +=1 + + layer = DenseLayer(name, mi, mo, + apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.e_layers.append(layer) + mi = mo + + name = 'layer_{0}'.format(count) + + last_enc_layer = DenseLayer(name, mi, 2*latent_dims, + False, 1, f=lambda x:x, w_init=e_sizes['last_layer_weight_init']) + + self.latent_dims = latent_dims + self.e_layers.append(last_enc_layer) + + def encode(self, X, reuse = None, is_training=False): + + output=X + for layer in self.e_layers: + output = layer.forward(output, reuse, is_training) + + self.means = output[:,:self.latent_dims] + self.stddev = tf.nn.softplus(output[:,self.latent_dims:])+1e-6 + + with st.value_type(st.SampleValue()): + Z = st.StochasticTensor(Normal(loc=self.means, scale=self.stddev)) + + return Z + +class denseDecoder: + + def __init__(self, Z, latent_dims, dim, d_sizes, name): + + mi = latent_dims + + with tf.variable_scope('decoder'+name) as scope: + + self.d_layers = [] + count = 0 + for mo, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['dense_layers']: + + name = 'layer_{0}'.format(count) + count += 1 + + layer = DenseLayer(name, mi, mo, + apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.d_layers.append(layer) + mi = mo + + name = 'layer_{0}'.format(count) + + last_dec_layer = DenseLayer(name, mi, dim, False, 1, + f=lambda x:x, w_init=d_sizes['last_layer_weight_init'] + ) + + self.d_layers.append(last_dec_layer) + + def decode(self, Z, reuse=None, is_training=False): + + output=Z + + for layer in self.d_layers: + output = layer.forward(output, reuse, is_training) + + return output + +class bicycleEncoder(object): + + def __init__(self, X, e_sizes, e_name): + + _, dim_H, dim_W, mi = X.get_shape().as_list() + latent_dims=e_sizes['latent_dims'] + + self.residual=False + for key in e_sizes: + if 'block' in key: + self.residual=True + + if not self.residual: + print('Convolutional Network architecture detected for encoder '+ e_name) + + + with tf.variable_scope('encoder_'+e_name) as scope: + #building discriminator convolutional layers + + self.e_conv_layers =[] + count=0 + for mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init in e_sizes['conv_layers']: + + # make up a name - used for get_variable + name = "e_conv_layer_%s" % count + #print(name) + count += 1 + + layer = ConvLayer(name, mi, mo, + filter_sz, stride, + apply_batch_norm, keep_prob, + act_f, w_init) + + self.e_conv_layers.append(layer) + mi = mo + + dim_H = int(np.ceil(float(dim_H) / stride)) + dim_W = int(np.ceil(float(dim_W) / stride)) + + mi = mi * dim_H * dim_W + + #building encoder dense layers + + self.e_dense_layers = [] + for mo, apply_batch_norm, keep_prob, act_f, w_init in e_sizes['dense_layers']: + + name = 'e_dense_layer_%s' %count + #print(name) + count +=1 + + layer = DenseLayer(name, mi, mo, + apply_batch_norm, keep_prob, + act_f, w_init) + mi = mo + self.e_dense_layers.append(layer) + + #final logistic layer + + name = 'e_last_dense_layer_mu' + w_init_last = e_sizes['readout_layer_w_init'] + #print(name) + self.e_final_layer_mu = DenseLayer(name, mi, latent_dims, + False, keep_prob=1, + act_f=lambda x: x, w_init=w_init_last) + name = 'e_last_dense_layer_sigma' + self.e_final_layer_sigma = DenseLayer(name, mi, latent_dims, + False, keep_prob=1, + act_f=lambda x: x, w_init=w_init_last) + + self.e_name=e_name + self.latent_dims=latent_dims + else: + print('Residual Convolutional Network architecture detected for Encoder'+ e_name) + + with tf.variable_scope('encoder_'+e_name) as scope: + #building discriminator convolutional layers + + self.e_blocks = [] + #count conv blocks + e_steps = 0 + for key in e_sizes: + if 'conv' in key: + if not 'shortcut' in key: + e_steps+=1 + + e_block_n=0 + e_layer_n=0 + + + for key in e_sizes: + + if 'block' and 'shortcut' in key: + + e_block = ConvBlock(e_block_n, + mi, e_sizes, + ) + self.e_blocks.append(e_block) + + mo, _, _, _, _, _, _, = e_sizes['convblock_layer_'+str(e_block_n)][-1] + mi = mo + dim_H = e_block.output_dim(dim_H) + dim_W = e_block.output_dim(dim_W) + e_block_n+=1 + + + if 'conv_layer' in key: + + name = 'e_conv_layer_{0}'.format(e_layer_n) + + mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = e_sizes[key][0] + + + e_conv_layer = ConvLayer(name, mi, mo, + filter_sz, stride, + apply_batch_norm, keep_prob, + act_f, w_init + ) + + self.e_blocks.append(e_conv_layer) + + mi = mo + dim_W = int(np.ceil(float(dim_W) / stride)) + dim_H = int(np.ceil(float(dim_H) / stride)) + e_layer_n+=1 + + assert e_block_n+e_layer_n==e_steps, '\nCheck keys in d_sizes, \n total convolution steps do not mach sum between convolutional blocks and convolutional layers' + + count=e_steps + + mi = mi * dim_H * dim_W + + #building encoder dense layers + + self.e_dense_layers = [] + for mo, apply_batch_norm, keep_prob, act_f, w_init in e_sizes['dense_layers']: + + name = 'e_dense_layer_%s' %count + #print(name) + count +=1 + + layer = DenseLayer(name, mi, mo, + apply_batch_norm, keep_prob, + act_f, w_init) + mi = mo + self.e_dense_layers.append(layer) + + #final logistic layer + + + w_init_last = e_sizes['readout_layer_w_init'] + #print(name) + name = 'e_last_dense_layer_mu' + self.e_final_layer_mu = DenseLayer(name, mi, latent_dims, + 'bn', keep_prob=1, + act_f=lambda x: x, w_init=w_init_last) + name = 'e_last_dense_layer_sigma' + self.e_final_layer_sigma = DenseLayer(name, mi, latent_dims, + 'bn', keep_prob=1, + act_f=lambda x: x, w_init=w_init_last) + + self.e_name=e_name + self.latent_dims=latent_dims + + def e_forward(self, X, reuse = None, is_training=True): + + if not self.residual: + print('Encoder_'+self.e_name) + print('Convolution') + + output = X + print('Input for convolution shape ', X.get_shape()) + i=0 + for layer in self.e_conv_layers: + i+=1 + # print('Convolution_layer_%i' %i) + # print('Input shape', output.get_shape()) + output = layer.forward(output, + reuse, + is_training) + #print('After convolution shape', output.get_shape()) + + output = tf.contrib.layers.flatten(output) + #print('After flatten shape', output.get_shape()) + i=0 + for layer in self.e_dense_layers: + #print('Dense weights %i' %i) + #print(layer.W.get_shape()) + output = layer.forward(output, + reuse, + is_training) + i+=1 + # print('After dense layer_%i' %i) + # print('Shape', output.get_shape()) + #output = tf.nn.relu(output) + mu = self.e_final_layer_mu.forward(output, + reuse, + is_training) + + log_sigma = self.e_final_layer_sigma.forward(output, + reuse, + is_training) + + z = mu + tf.random_normal(shape=tf.shape(self.latent_dims))*tf.exp(log_sigma) + + print('Encoder output shape', z.get_shape()) + return z, mu, log_sigma + else: + print('Residual encoder_'+self.e_name) + print('Convolution') + + output = X + + i=0 + print('Input for convolution shape ', X.get_shape()) + for block in self.e_blocks: + i+=1 + #print('Convolution_block_%i' %i) + #print('Input shape', output.get_shape()) + output = block.forward(output, + reuse, + is_training) + #print('After block shape', output.get_shape()) + + + output = tf.contrib.layers.flatten(output) + #print('After flatten shape', output.get_shape()) + + i=0 + for layer in self.e_dense_layers: + #print('Dense weights %i' %i) + #print(layer.W.get_shape()) + output = layer.forward(output, + reuse, + is_training) + i+=1 + # print('After dense layer_%i' %i) + # print('Shape', output.get_shape()) + + #output = tf.nn.relu(output) + mu = self.e_final_layer_mu.forward(output, + reuse, + is_training) + + log_sigma = self.e_final_layer_sigma.forward(output, + reuse, + is_training) + + + z = mu + tf.random_normal(shape=tf.shape(self.latent_dims))*tf.exp(log_sigma) + + print('Encoder output shape', z.get_shape()) + return z, mu, log_sigma + +# class convEncoder: + +# class convDecoder: + +# class resEncoder: + +# class resDecoder: + diff --git a/tools/utils/__init__.py b/tools/utils/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/tools/utils/__init__.py diff --git a/tools/utils/__pycache__/NN_building_blocks.cpython-36.pyc b/tools/utils/__pycache__/NN_building_blocks.cpython-36.pyc new file mode 100644 index 0000000..d0ccd9f --- /dev/null +++ b/tools/utils/__pycache__/NN_building_blocks.cpython-36.pyc Binary files differ diff --git a/tools/utils/__pycache__/NN_gen_building_blocks.cpython-36.pyc b/tools/utils/__pycache__/NN_gen_building_blocks.cpython-36.pyc new file mode 100644 index 0000000..a09af52 --- /dev/null +++ b/tools/utils/__pycache__/NN_gen_building_blocks.cpython-36.pyc Binary files differ diff --git a/tools/utils/__pycache__/__init__.cpython-36.pyc b/tools/utils/__pycache__/__init__.cpython-36.pyc new file mode 100644 index 0000000..756f2e7 --- /dev/null +++ b/tools/utils/__pycache__/__init__.cpython-36.pyc Binary files differ diff --git a/tools/utils/__pycache__/toolbox.cpython-36.pyc b/tools/utils/__pycache__/toolbox.cpython-36.pyc new file mode 100644 index 0000000..52b19fd --- /dev/null +++ b/tools/utils/__pycache__/toolbox.cpython-36.pyc Binary files differ diff --git a/tools/utils/toolbox.py b/tools/utils/toolbox.py new file mode 100644 index 0000000..2c6e541 --- /dev/null +++ b/tools/utils/toolbox.py @@ -0,0 +1,807 @@ +import numpy as np +import os +import math +import tensorflow as tf +import pickle +import matplotlib.pyplot as plt + +rnd_seed=1 + +def conv_concat(X, y, y_dim): + + yb = tf.reshape(y, [tf.shape(X)[0], 1, 1, y_dim]) + yb = tf.tile(yb, [1, tf.shape(X)[1], tf.shape(X)[2] ,1]) + output = tf.concat([X, yb], 3) + return output + +def lin_concat(X, y, y_dim): + + yb = tf.reshape(y, [tf.shape(X)[0], y_dim]) + output = tf.concat([X, yb], 1) + + return output + +def lrelu(x, alpha=0.2): + + """ + Implements the leakyRELU function: + + inputs X, returns X if X>0, returns alpha*X if X<0 + """ + + + return tf.maximum(alpha*x,x) + +def evaluation(Y_pred, Y): + + """ + Returns the accuracy by comparing the convoluted output Y_hat + with the labels of the samples Y + + """ + + correct = tf.equal(tf.argmax(Y_pred, 1), tf.argmax(Y, 1)) + accuracy = tf.reduce_mean(tf.cast(correct, tf.float32)) + + return accuracy + +def supervised_random_mini_batches(X, Y, mini_batch_size, seed): + + """ + Creates a list of random mini_batches from (X, Y) + + Arguments: + X -- input data, of shape (number of examples, input size) + Y -- true "label" one hot matrix of shape (number of examples, n_classes) + mini_batch_size -- size of the mini-batches, integer + + Returns: + mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y) + """ + + + m = X.shape[0] #number of examples in set + n_classes = Y.shape[1] + mini_batches=[] + + np.random.seed(seed) + permutation = list(np.random.permutation(m)) + #print('Zeroth element of batch permutation:', permutation[0]) + shuffled_X = X[permutation,:] + shuffled_Y = Y[permutation,:] + #partition of (shuffled_X, shuffled_Y) except the last mini_batch + + num_complete_mini_batches = math.floor(m/mini_batch_size) + for k in range(num_complete_mini_batches): + mini_batch_X = shuffled_X[k*mini_batch_size:(k+1)*mini_batch_size,:] + mini_batch_Y = shuffled_Y[k*mini_batch_size:(k+1)*mini_batch_size,:] + + mini_batch = (mini_batch_X, mini_batch_Y) + mini_batches.append(mini_batch) + + # handling the case of last mini_batch < mini_batch_size + if m % mini_batch_size !=0: + + mini_batch_X = shuffled_X[mini_batch_size*num_complete_mini_batches:m,:] + mini_batch_Y = shuffled_Y[mini_batch_size*num_complete_mini_batches:m,:] + + mini_batch = (mini_batch_X, mini_batch_Y) + mini_batches.append(mini_batch) + + return mini_batches + +def unsupervised_random_mini_batches(X, mini_batch_size, seed): + + """ + Creates a list of random mini_batches from (X) + + Arguments: + X -- input data, of shape (number of examples, input size) + mini_batch_size -- size of the mini-batches, integer + + Returns: + mini_batches -- list of mini_batch_X + """ + + m = X.shape[0] #number of examples in set + mini_batches=[] + + np.random.seed(seed) + permutation = list(np.random.permutation(m)) + #print('Zeroth element of batch permutation:', permutation[0]) + shuffled_X = X[permutation,:] + + #partition of shuffled_X except the last mini_batch + + num_complete_mini_batches = math.floor(m/mini_batch_size) + for k in range(num_complete_mini_batches): + mini_batch_X = shuffled_X[k*mini_batch_size:(k+1)*mini_batch_size,:] + mini_batches.append(mini_batch_X) + + # handling the case of last mini_batch < mini_batch_size + if m % mini_batch_size !=0: + + mini_batch_X = shuffled_X[mini_batch_size*num_complete_mini_batches:m,:] + mini_batches.append(mini_batch_X) + + return mini_batches + +def unsupervised_random_mini_batches_labels(X, mini_batch_size, seed): + + """ + Creates a list of random mini_batches from (Y) + + Arguments: + X -- input data, of shape (number of examples, input size) + mini_batch_size -- size of the mini-batches, integer + + Returns: + mini_batches -- list of mini_batch_X + """ + + m = X.shape[0] #number of examples in set + mini_batches=[] + + np.random.seed(seed) + permutation = list(np.random.permutation(m)) + #print('Zeroth element of batch permutation:', permutation[0]) + shuffled_X = X[permutation] + + #partition of shuffled_X except the last mini_batch + + num_complete_mini_batches = math.floor(m/mini_batch_size) + for k in range(num_complete_mini_batches): + mini_batch_X = shuffled_X[k*mini_batch_size:(k+1)*mini_batch_size] + mini_batches.append(mini_batch_X) + + # handling the case of last mini_batch < mini_batch_size + if m % mini_batch_size !=0: + + mini_batch_X = shuffled_X[mini_batch_size*num_complete_mini_batches:m] + mini_batches.append(mini_batch_X) + + return mini_batches + +# def preprocess_true(true): + +# mean_true=true[true!=0].mean() +# std_true=np.std(true[np.where(true!=0)],axis=0) + +# true[true!=0]-=mean_true +# true=np.where(true==0,0,true/std_true) + +# return true, mean_true, std_true +# def preprocess_reco(reco): + +# mean_reco=np.mean(reco,axis=0) +# std_reco=np.std(reco,axis=0) + +# reco-=mean_reco +# reco=np.where(reco==0,0,reco/std_reco) + +# return reco, mean_reco, std_reco + +# def reconstruct(sample, mean, std): +# return np.where(sample!=0,sample*std+mean,0) + +def four_cells(img): + img = img.flatten() + return img[img.argsort()[-4:][::-1]] + +def normalise(X, norm_space=False): + + if norm_space: + X[:,0]=X[:,0]/X[:,0].max() + X[:,1]=X[:,1]/X[:,1].max() + max_X = X[:,2].max() + X[:,2]=X[:,2]/max_X + min_X = 0 + + else: + X=np.where(X>0,X,0) + #temp = X.reshape(X.shape[0],X.shape[1]*X.shape[2]*X.shape[3]) + #temp = temp.sum(axis=1) + max_X = np.max(X) + #max_X = np.max(temp.sum(axis=1)) + + X=X/max_X + min_X=0 + + return X, min_X, max_X + +def denormalise(X, min_X, max_X, norm_space=False): + #mask = X!=0 + #return np.where(X!=0, np.exp(X*max_X), 0) + denormalised = np.zeros_like(X) + if norm_space: + denormalised[:,0]=(X[:,0]*52).astype(int) + denormalised[:,1]=(X[:,1]*64).astype(int) + denormalised[:,2]=X[:,2]*max_X + return denormalised + + else: + return np.where(X!=0, X*max_X, 0) + +# def normalise(X): + +# X=np.where(X>12 ,X,0) +# #X=np.where(X>12,np.log(X),0) + +# # E_max = X.max() +# # E_min = np.min(X[X>0]) +# # X = np.where(X>0, X-(E_max+E_min)/2,0) +# # X/=X.max() + +# E_min=np.min(X[X>0]) +# X=np.where(X>0,X-E_min,0) +# E_max=np.max(X) +# X=np.where(X!=0,X/E_max,0) + +# return X, E_max, E_min + +# def denormalise(X, E_max, E_min): +# # X=X*E_max-E_min)/2 +# # X=np.where(X!=0, X+(E_max+E_min)/2, 0) + +# X=np.where(X!=0,X*E_max,0) +# X=np.where(X!=0, X+E_min, 0) +# #X=np.where(X!=0, np.exp(X), 0) + +# return X + +def delete_undetected_events_single(X): + + pos_rejected=[] + + for i in range(len(X)): + if np.array_equal(X[i],np.zeros_like(X[i])): + pos_rejected.append(i) + + X_filtered=np.delete(X,pos_rejected,axis=0) + + return X_filtered + +def delete_undetected_events_double(true, reco): + + pos_rejected=[] + + for i in range(len(true)): + if np.array_equal(reco[i],np.zeros_like(reco[i])) or np.array_equal(true[i],np.zeros_like(true[i])) : + pos_rejected.append(i) + + reco_filtered=np.delete(reco,pos_rejected,axis=0) + true_filtered=np.delete(true, pos_rejected, axis=0) + + assert len(true_filtered)==len(reco_filtered) + + return true_filtered, reco_filtered + +def delete_undetected_events_triple(true_p, true_K, reco): + + pos_rejected=[] + + for i in range(len(true_p)): + if np.array_equal(reco[i],np.zeros_like(reco[i])) or np.array_equal(true_p[i],np.zeros_like(true_p[i])) or np.array_equal(true_K[i],np.zeros_like(true_K[i])) : + pos_rejected.append(i) + + reco_filtered=np.delete(reco,pos_rejected,axis=0) + true_p_filtered=np.delete(true_p, pos_rejected, axis=0) + true_K_filtered=np.delete(true_K, pos_rejected, axis=0) + + assert len(true_p_filtered)==len(reco_filtered)==len(true_K_filtered) + + + return true_p_filtered, true_K_filtered, reco_filtered + +def selection(true, reco, n_cells, energy_fraction): + + pos_selected=[] + pos_rejected=[] + + for i in range(len(reco)): + tot_E=reco[i].sum() + reshaped=reco[i].flatten() + if (reshaped[reshaped.argsort()[-n_cells:][::-1]].sum())/tot_E 1: + + true, reco = load_batch(true_path, reco_path, 0) + #true, reco = delete_undetected_events_double(true, reco) + + #delete too noisy events + if select: + true_output, reco_output, _, _, = selection(true, reco, n_cells, energy_fraction) + + for i in range(1, n_batches): + + true_temp, reco_temp = load_batch(true_path, reco_path, i) + #true_temp, reco_temp = delete_undetected_events_double(true1, reco1) + + #delete too noisy events + if select: + true_temp, reco_temp, _, _, = selection(true_temp, reco_temp, n_cells, energy_fraction) + + true = np.concatenate((true, true_temp), axis=0) + reco = np.concatenate((reco, reco_temp), axis=0) + + if preprocess =='normalise': + + reco, min_reco, max_reco = normalise(reco) + true, min_true, max_true = normalise(true) + m = reco.shape[0] + train_size = m - test_size + + train_true = true[0:train_size] + test_true = true[train_size:m] + + train_reco = reco[0:train_size] + test_reco = reco[train_size:m] + + return train_true, test_true, min_true, max_true, train_reco, test_reco, min_reco, max_reco + + else: + m = reco.shape[0] + train_size = m - test_size + + train_true = true[0:train_size] + test_true = true[train_size:m] + + train_reco = reco[0:train_size] + test_reco = reco[train_size:m] + + return train_true, test_true, train_reco, test_reco + +def load_data_conditional(true_path, reco_path, n_batches, dim=None, preprocess=None, test_size=None): + + if n_batches == 1: + + #delete undetected particles + true1, reco1 = load_batch(true_path, reco_path, 0) + true2, reco2 = delete_undetected_events_double(true1, reco1) + ETs, reco_output = load_conditional(true2, reco2) + + elif n_batches > 1: + + true1, reco1 = load_batch(true_path, reco_path, 0) + true2, reco2 = delete_undetected_events_double(true1, reco1) + ETs, reco_output = load_conditional(true2, reco2) + + for i in range(1, n_batches): + + true1, reco1 = load_batch(true_path, reco_path, i) + true_temp, reco_temp = delete_undetected_events_double(true1, reco1) + ETs_temp, reco_output_temp = load_conditional(true_temp, reco_temp) + + #delete too noisy events + ETs = np.concatenate((ETs, ETs_temp), axis=0) + reco_output = np.concatenate((reco_output, reco_output_temp), axis=0) + + true = ETs + reco = reco_output + + if preprocess =='normalise': + + reco, min_reco, max_reco = normalise(reco, norm_space=False) + true, min_true, max_true = normalise(true, norm_space=True) + m = reco.shape[0] + train_size = m - test_size + + train_true = true[0:train_size] + test_true = true[train_size:m] + + train_reco = reco[0:train_size] + test_reco = reco[train_size:m] + + return train_true, test_true, min_true, max_true, train_reco, test_reco, min_reco, max_reco + + else: + m = reco.shape[0] + train_size = m - test_size + + train_true = true[0:train_size] + test_true = true[train_size:m] + + train_reco = reco[0:train_size] + test_reco = reco[train_size:m] + + return train_true, test_true, train_reco, test_reco + +def draw_one_sample(train_true, train_reco, preprocess=None, + min_true=None, max_true=None, min_reco=None, max_reco=None, + save=False, PATH=None): + + j = np.random.randint(len(train_true)) + + X_batch_A = train_true[j] + X_batch_B = train_reco[j] + + if preprocess=='normalise': + X_batch_A=denormalise(X_batch_A, min_true, max_true) + X_batch_B=denormalise(X_batch_B, min_reco, max_reco) + + n_H_A, n_W_A ,n_C = X_batch_A.shape + n_H_B, n_W_B ,n_C = X_batch_B.shape + + plt.subplot(2,2,1) + plt.imshow(X_batch_A.reshape(n_H_A,n_W_A)) + plt.xlabel('X') + plt.ylabel('Y') + plt.title('True E_T: {:.6g} MeV'.format(X_batch_A.sum())) + plt.subplots_adjust(wspace=0.2,hspace=0.2) + + plt.subplot(2,2,2) + plt.imshow(X_batch_B.reshape(n_H_B,n_W_B)) + plt.xlabel('X') + plt.ylabel('Y') + plt.title('Reco E_T: {:.6g} MeV'.format(X_batch_B.sum())) + plt.subplots_adjust(wspace=0.2,hspace=0.2) + + plt.suptitle('HCAL MC simulation\n ') + fig = plt.gcf() + fig.set_size_inches(11,4) + if not save: + plt.show() + else: + plt.savefig(PATH+'/HCAL_reconstruction_example_{0}.png'.format(j),dpi=80) + +def draw_one_sample_conditional(train_true, train_reco, preprocess=None, + min_true=None, max_true=None, min_reco=None, max_reco=None, + save=False, PATH=None): + + j = np.random.randint(len(train_true)) + + + if preprocess=='normalise': + X_batch_A=denormalise(train_true, min_true, max_true, norm_space=True) + X_batch_B=denormalise(train_reco, min_reco, max_reco) + + X_batch_A = X_batch_A[j] + X_batch_B = X_batch_B[j] + + n_H_B, n_W_B, n_C = X_batch_B.shape + + plt.imshow(X_batch_B.reshape(n_H_B,n_W_B)) + plt.xlabel('X') + plt.ylabel('Y') + plt.title('HCAL MC simulation \n X: {1} Y: {0} \n True E_T: {2:.6g} MeV, Reco MC E_T: {3:.6g}'.format(X_batch_A[0].sum(), X_batch_A[1].sum(), X_batch_A[2].sum(), X_batch_B.sum())) + fig = plt.gcf() + fig.set_size_inches(11,4) + if not save: + plt.show() + else: + plt.savefig(PATH+'/HCAL_reconstruction_example_{0}.png'.format(j),dpi=80) + +def draw_nn_sample(X_A, X_B, i, preprocess=False, + min_true=None, max_true=None, min_reco=None, max_reco=None, f=None, + save=True, is_training=False, total_iters=None, PATH=None): + + j = np.random.randint(len(X_A)) + + _, n_H_A, n_W_A, n_C = X_A.shape + _, n_H_B, n_W_B, _ = X_B.shape + + #draw the response for one particle + if i ==1 : + X_A = X_A[j] + X_B = X_B[j] + sample_nn = f(X_A.reshape(1, n_H_A, n_W_A, n_C)) + #draw the response for i particles + if i>1: + X_A = X_A[j:j+i] + X_B = X_B[j:j+i] + X_A = X_A.sum(axis=0) + X_B = X_B.sum(axis=0) + + sample_nn = f(X_A.reshape(1, n_H_A, n_W_A, n_C)) + + if preprocess=='normalise': + + X_A=denormalise(X_A, min_true, max_true) + X_B=denormalise(X_B, min_reco, max_reco) + sample_nn=denormalise(sample_nn, min_reco, max_reco) + + plt.subplot(1,3,1) + plt.gca().set_title('True ET {0:.6g}'.format(X_A.sum())) + plt.imshow(X_A.reshape(n_H_A,n_W_A)) + plt.xlabel('X') + plt.ylabel('Y') + plt.subplots_adjust(wspace=0.2,hspace=0.2) + + plt.subplot(1,3,2) + plt.gca().set_title('MC Reco ET {0:.6g}'.format(X_B.sum())) + plt.imshow(X_B.reshape(n_H_B,n_W_B)) + plt.xlabel('X') + plt.ylabel('Y') + plt.subplots_adjust(wspace=0.2,hspace=0.2) + + plt.subplot(1,3,3) + plt.gca().set_title('NN Reco ET {0:.6g}'.format(sample_nn.sum())) + plt.imshow(sample_nn.reshape(n_H_B,n_W_B)) + plt.xlabel('X') + plt.ylabel('Y') + plt.subplots_adjust(wspace=0.2,hspace=0.2) + if is_training: + plt.suptitle('At iter {0}'.format(total_iters)) + fig = plt.gcf() + fig.set_size_inches(10,8) + + if save: + if is_training: + plt.savefig(PATH+'/sample_at_iter_{0}.png'.format(total_iters),dpi=80) + else: + plt.savefig(PATH+'/nn_reco_sample_{0}.png'.format(j),dpi=80) + else: + plt.show() + +def draw_nn_sample_conditional(y, reco_MC, i, preprocess=False, + min_true=None, max_true=None, min_reco=None, max_reco=None, f=None, + save=True, is_training=False, total_iters=None, PATH=None): + + j = np.random.randint(len(reco_MC)) + + #_, n_H_A, n_W_A, n_C = X_A.shape + _, n_H_B, n_W_B, _ = reco_MC.shape + + #draw the response for one particle + + y =y[j:j+4] + reco_MC = reco_MC[j:j+4] + sample_nn = f(y.reshape(4, y.shape[1])).reshape(4, n_H_B, n_W_B) + + + if preprocess=='normalise': + + Y=denormalise(y, min_true, max_true, norm_space=True) + X_B_mc=denormalise(reco_MC, min_reco, max_reco) + X_B_nn=denormalise(sample_nn, min_reco, max_reco) + + + for i in range(4): + + plt.subplot(2,4,i+1) + plt.gca().set_title('X: {1}, Y: {0} \n True ET {2:.6g}, \n MC ET {3:.6g}\n'.format(Y[i,0].sum(), Y[i,1].sum(), Y[i,2].sum(), X_B_mc[i].sum())) + plt.imshow(X_B_mc[i].reshape(n_H_B,n_W_B)) + plt.subplots_adjust(wspace=0.25,hspace=0.25) + plt.xlabel('X') + plt.ylabel('Y') + plt.subplot(2,4,i+5) + plt.gca().set_title('NN ET {0:.6g}'.format(X_B_nn[i].sum())) + plt.imshow(X_B_nn[i].reshape(n_H_B,n_W_B)) + plt.xlabel('X') + plt.ylabel('Y') + plt.subplots_adjust(wspace=0.25,hspace=0.25) + + fig = plt.gcf() + fig.set_size_inches(20,10) + + if save: + if is_training: + plt.savefig(PATH+'/sample_at_iter_{0}.png'.format(total_iters),dpi=80) + else: + plt.savefig(PATH+'/nn_reco_sample_{0}.png'.format(j),dpi=80) + else: + plt.show() + + + +def get_inner_HCAL(reco): + inner_HCAL = reco[:,12:40,16:48,:] + return inner_HCAL + +def get_outer_HCAL(reco): + m_tot, h, w, c = reco.shape + outer_HCAL = np.zeros(shape=(m_tot,h//2,w//2,c)) + + for m in range(0, m_tot): + img=reco[m] + for j in range(0, w, 2): + for i in range(0, h, 2): + outer_HCAL[m,i//2,j//2,0]=img[i:i+2,j:j+2].sum() + + outer_HCAL[:,6:20,8:24,:]=0 + return outer_HCAL + +def get_4_max_cells(img): + + c =0 + value = np.zeros(shape=(2,2)) + pos =np.zeros(shape=(2,1)) + + for i in range(img.shape[0]-1): + for j in range(img.shape[1]-1): + c_prime = img[i:i+2,j:j+2].sum() + if c_prime > c: + c = c_prime + value[0,0]=img[i,j] + value[0,1]=img[i,j+1] + value[1,0]=img[i+1,j] + value[1,1]=img[i+1,j+1] + + pos[0]=i + pos[1]=j + return value, pos + +def get_triggered_events(true, reco_inner, reco_outer): + l = [] + for m in range(len(reco_inner)): + value_inner, pos_inner = get_4_max_cells(reco_inner[m]) + value_outer, pos_outer = get_4_max_cells(reco_outer[m]) + + if value_inner.sum()>3680 or value_outer.sum()>3680: + l.append(m) + triggered_true = np.array([true[l[i]].sum() for i in range(len(l))]) + triggered_reco_inner = np.array([reco_inner[l[i]].sum() for i in range(len(l))]) + triggered_reco_outer = np.array([reco_outer[l[i]].sum() for i in range(len(l))]) + + return l, triggered_true, triggered_reco_inner, triggered_reco_outer + +# def crop_conditional(true, reco, dim): + +# ETs=[] +# assert len(reco)==len(true) + +# cropped_reco=np.zeros(shape=(reco.shape[0],2*dim+1,2*dim+1,1)) +# max_x = reco.shape[2] +# max_y = reco.shape[1] +# pos_rejected=[] +# for i in range(len(reco)): + +# reco_y, reco_x, _ = np.where(reco[i]==reco[i].max()) + +# #CENTER OF IMAGE +# if 2*dim0)][0]) + +# else: +# pos_rejected.append(i) +# # + +# # print(len(pos_rejected)) +# ETs=np.array(ETs) +# reco_rejected=np.delete(cropped_reco,pos_rejected,axis=0) + +# assert len(reco_rejected)==len(ETs) + +# return ETs, reco_rejected + +# def crop_function(true, reco, dim): + +# assert len(reco)==len(true) +# j=0 +# cropped_reco=np.zeros(shape=(reco.shape[0],2*dim,2*dim,1)) +# cropped_true=np.zeros(shape=(true.shape[0],2*dim,2*dim,1)) +# max_x = reco.shape[2] +# max_y = reco.shape[1] + +# for i in range(len(reco)): +# y , x , _= np.where(true[i]>0) + +# #CORNERS + +# #top left corner +# # if y[0]<=2*dim and x[0]<=2*dim: +# # #print(i, x, y) +# # cropped_reco[i]=reco[i,0:2*dim, 0:2*dim, :] +# # cropped_true[i]=true[i,0:2*dim, 0:2*dim, :] +# # j+=1 + +# # #top right corner +# # elif y[0]<=2*dim and max_x-2*dim