diff --git a/BDT.ipynb b/BDT.ipynb
deleted file mode 100644
index 9cf4002..0000000
--- a/BDT.ipynb
+++ /dev/null
@@ -1,803 +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",
-    "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": [
-    "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]+\"_FDCHI2_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": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 864x576 with 1 Axes>"
-      ]
-     },
-     "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), 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)\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",
-    "#data_bkg_cut=data_bkg[np.where(data_bkg[:,dim-1]>1915)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "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)\n",
-    "\n",
-    "#get train size\n",
-    "train_size=data.shape[0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "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": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#Divide the dataset k \"equi populated\" sets\n",
-    "test=0\n",
-    "k=5 #number of subsets\n",
-    "i=4 #number of subset that is train set\n",
-    "PATH=l_flv[l_index]+'/test_'+str(test)\n",
-    "\n",
-    "if not os.path.exists(PATH):\n",
-    "    os.mkdir(PATH)\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": 11,
-   "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": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(14004, 13)"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "X_train_2.shape"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# SETTING UP THE NETWORK"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "task='TRAIN'\n",
-    "\n",
-    "PATH=l_flv[l_index]+'/test_'+str(test)+'/NN_'+str(i)\n",
-    "\n",
-    "if not os.path.exists(PATH):\n",
-    "    os.mkdir(PATH)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "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": 15,
-   "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",
-      "\n",
-      " Training...\n",
-      "\n",
-      " ****** \n",
-      "\n",
-      "Training DNN for 50 epochs with a total of 14004 samples\n",
-      "distributed in 218 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: 2671, train accuracy 0.6318, test accuracy 0.7216\n",
-      "Average of signal as predicted by NN 0.3682\n",
-      "Evaluating performance on validation/train sets\n",
-      "At iteration 10, train cost: 826, train accuracy 0.8614, test accuracy 0.8577\n",
-      "Average of signal as predicted by NN 0.1526\n",
-      "Evaluating performance on validation/train sets\n",
-      "At iteration 20, train cost: 440.7, train accuracy 0.869, test accuracy 0.8491\n",
-      "Average of signal as predicted by NN 0.192\n",
-      "Evaluating performance on validation/train sets\n",
-      "At iteration 30, train cost: 298.7, train accuracy 0.8679, test accuracy 0.8429\n",
-      "Average of signal as predicted by NN 0.08267\n",
-      "Evaluating performance on validation/train sets\n",
-      "At iteration 40, train cost: 225.9, train accuracy 0.8622, test accuracy 0.8341\n",
-      "Average of signal as predicted by NN 0.04972\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Parameters trained\n",
-      "Model and hyperparameters saved in path: e/test_0/NN_4/NN_model.ckpt\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",
-    "\n",
-    "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",
-    "    with open(PATH+'/variables_used.pkl', 'wb') as f:  \n",
-    "        pickle.dump(return_branches(mother_index=0), f)\n",
-    "    print(\"Model and hyperparameters saved in path: %s\" % save_path)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "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": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      " Evaluate model on test set...\n",
-      "INFO:tensorflow:Restoring parameters from e/test_0/NN_4/NN_model.ckpt\n",
-      "Model restored.\n",
-      "Test accuracy: 0.8453\n"
-     ]
-    }
-   ],
-   "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": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x576 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "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": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "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": 20,
-   "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": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "PATH=l_flv[l_index]+'/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": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "output_XG=model.predict_proba(X_test_2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x576 with 2 Axes>"
-      ]
-     },
-     "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": 23,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x576 with 1 Axes>"
-      ]
-     },
-     "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": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "pAUC from NN 0.8886196769456681\n",
-      "pAUC from XG Boost 0.890928026160944\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "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/mu/test_'+str(test)+'/roc_comparison_'+str(i)+'.png', format='png', dpi=100)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# save XGBOOST model to file\n",
-    "pickle.dump(model, open(PATH+\"/XG_\"+str(i)+\"_.pickle.dat\", \"wb\"))"
-   ]
-  },
-  {
-   "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/BDT_select.ipynb b/BDT_select.ipynb
deleted file mode 100644
index a4b916e..0000000
--- a/BDT_select.ipynb
+++ /dev/null
@@ -1,380 +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 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": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "l_index=0\n",
-    "l_flv=['e','mu']\n",
-    "mother_ID=[\"Ds\",\"Dplus\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# DATA LOADING & PREPROCESSING"
-   ]
-  },
-  {
-   "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]+'.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": [],
-   "source": [
-    "task='TEST'\n",
-    "\n",
-    "test=0\n",
-    "i=4\n",
-    "PATH=l_flv[l_index]+'/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": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
-      ]
-     },
-     "execution_count": 6,
-     "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": 7,
-   "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": 8,
-   "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": 9,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      " Evaluate model on test set...\n",
-      "INFO:tensorflow:Restoring parameters from e/test_0/NN_4/NN_model.ckpt\n",
-      "Model restored.\n"
-     ]
-    }
-   ],
-   "source": [
-    "output_dict_NN={}\n",
-    "batch_size=200\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": 10,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = data_dict[\"Ds_ConsD_M\"][0:output_NN.shape[0]][np.argmax(output_NN, axis=1).astype(np.bool)]\n",
-    "b = [data_dict[\"Ds_ConsD_M\"][0:output_NN.shape[0]][i] for i in range(output_NN.shape[0])]\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": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x720 with 1 Axes>"
-      ]
-     },
-     "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": 12,
-   "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": 13,
-   "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": 14,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "output_XG=loaded_model.predict_proba(data_2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a = data_dict[\"Ds_ConsD_M\"][0:output_XG.shape[0]][np.argmax(output_XG, axis=1).astype(np.bool)]\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": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x720 with 1 Axes>"
-      ]
-     },
-     "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": 17,
-   "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": 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/BDT_select_and_fit.ipynb b/BDT_select_and_fit.ipynb
new file mode 100644
index 0000000..7098684
--- /dev/null
+++ b/BDT_select_and_fit.ipynb
@@ -0,0 +1,324 @@
+{
+ "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": "markdown",
+   "metadata": {},
+   "source": [
+    "# PATHs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "l_index=0\n",
+    "mother_index_fit=2\n",
+    "l_flv=['e','mu']\n",
+    "mother_ID=[\"Ds\",\"Dplus\",\"both\"]\n",
+    "test=4\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=['cos_thetal']+branches_needed_0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Data loading, applying mass cuts, preprocessing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(34845, 2035, 1295)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#MC_Dplus_sig_dict, MC_Ds_sig_dict, _ = load_datasets(l_index)\n",
+    "\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",
+    "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",
+    "\"\"\"\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=1810\n",
+    "        upper_cut=1930\n",
+    "    if mother_index_fit==2:\n",
+    "        lower_cut=1810\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=1780\n",
+    "        upper_cut=1930\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, \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, mother_index_fit=mother_index_fit)\n",
+    "    \n",
+    "    \n",
+    "plt.hist(np.concatenate((mc_Dplus_mass, mc_Ds_mass)),bins=70,density=True,alpha=0.7);\n",
+    "plt.hist(data_mass,bins=70,density=True,alpha=0.4);\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Just RooFit it!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BDT cut at 0.1 fit\n",
+      "BDT selection..\n",
+      "(340, 476)\n",
+      "BDT Signal selection efficiency: 0.245045045045\n",
+      "chi2 1.10479563477\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.10,0.90,num=10)\n",
+    "fit_results={}\n",
+    "splots={}\n",
+    "#Just fit it!\n",
+    "for i, x_cut in enumerate(x_cut_values[0:1]):\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], splots[i] = select_and_fit(BDT_PATH, mother_index_fit, l_index, lower_cut, upper_cut,\n",
+    "                                               data_mass, mc_Dplus_mass, mc_Ds_mass, data_to_select, mc_Dplus_to_select, mc_Ds_to_select,\n",
+    "                                               data_dict, MC_Dplus_tuple_dict, MC_Ds_tuple_dict, branches_needed,\n",
+    "                                               x_cut, i, test)\n",
+    "\n",
+    "    with open(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/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))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sw_idx=0\n",
+    "with open('/disk/lhcb_data/davide/Rphipi/BDT_selected_data/'+l_flv[l_index]+l_flv[l_index]+'/BDT_sel_data_'+l_flv[l_index]+l_flv[l_index]+'_geom_var.pickle', 'rb') as f:\n",
+    "    data_cut=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[1]+'_'+l_flv[l_index]+l_flv[l_index]+'_geom_var.pickle', 'rb') as f:\n",
+    "    MC_Dplus_cut=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]+'_geom_var.pickle', 'rb') as f:\n",
+    "    MC_Ds_cut=pickle.load(f)\n",
+    "\n",
+    "key=data_cut.keys()[0]\n",
+    "nentries=data_cut[key].shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_weights={}\n",
+    "if mother_ID[mother_index_fit]=='Dplus':\n",
+    "    data_weights[0]=np.array([splots[sw_idx].GetSWeight(i, \"nDplus_sw\") for i in range(nentries)])\n",
+    "\n",
+    "if mother_ID[mother_index_fit]=='Ds':\n",
+    "    data_weights[1]=np.array([splots[sw_idx].GetSWeight(i, \"nDs_sw\") for i in range(nentries)])\n",
+    "\n",
+    "if mother_ID[mother_index_fit]=='both':\n",
+    "    data_weights[0]=np.array([splots[sw_idx].GetSWeight(i, \"nDs_sw\") for i in range(nentries)])\n",
+    "    data_weights[1]=np.array([splots[sw_idx].GetSWeight(i, \"nDplus_sw\") for i in range(nentries)])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved: e/fits/both/0/Ds_sweighted_cos_thetal_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_ENDVERTEX_CHI2_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_IPCHI2_OWNPV_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_OWNPV_CHI2_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_DIRA_OWNPV_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_PT_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_FD_OWNPV_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_Ds_FDCHI2_OWNPV_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_pi_PT_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_e_plus_PT_0.png\n",
+      "Saved: e/fits/both/0/Ds_sweighted_e_minus_PT_0.png\n"
+     ]
+    }
+   ],
+   "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)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#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)"
+   ]
+  }
+ ],
+ "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<data_selected[i]<upper_cut:
+
+			cut_indices.append(i)
+    
+	data_cut=data_selected[cut_indices]/1000.   
+
+	lower_cut/=1000.
+	upper_cut/=1000.
+
+	"""
+
+	Create a rootfile from which will do the unbinned fit
+
+
+	"""
+
+	data_array=np.array(
+
+			[data_cut[i] for i in range(len(data_cut))], dtype=[('D_reco_M', np.float32)]
+
+			)
+
+
+
+
+	rn.array2root(data_array,
+					filename='/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_'+l_flv[l_index]+l_flv[l_index]+'.root',
+					treename='decay_tree',
+					mode='recreate',
+					)
+	f=r.TFile('/disk/lhcb_data/davide/Rphipi/selected_data/'+l_flv[l_index]+l_flv[l_index]+'/sel_data_'+l_flv[l_index]+l_flv[l_index]+'.root')
+	tree=f.Get("decay_tree") 
+
+	#some tricks to pass Roofit a dataset in python
+	mass = np.array([0],dtype=np.float32)
+
+	branch = tree.GetBranch("D_reco_M")
+	branch.SetAddress(mass)
+
+	num_entries=tree.GetEntries()
+	m = r.RooRealVar("D mass reco (GeV/c^2)","D mass reco (GeV/c^2)",lower_cut,upper_cut)
+	l = r.RooArgSet(m)
+	data_set = r.RooDataSet("data set", "data set", l)
+
+	for i in range(num_entries):
+		tree.GetEvent(i)
+		r.RooAbsRealLValue.__assign__(m, mass[0])
+		data_set.add(l, 1.0)
+	f.Close()
+	"""
+
+	Retrieve the needed pdfs
+
+
+	"""
+
+	##Creating D+ signal PDF left tail
+	mean_Dplus= r.RooRealVar("mean_Dplus","mean_Dplus",1.87,1.83,1.91)
+	sigma_Dplus = r.RooRealVar("sigma_Dplus","sigma_Dplus",0.020,0.,0.2)
+
+	sig_frc_Dplus =r.RooRealVar("Dplus Double crystalball fraction","Dplus Double crystalball fraction",frac_Dplus)
+
+	al_Dplus_left = r.RooRealVar("alpha_Dplus_left","alpha_Dplus_left",alpha_Dplus_l)
+	pwr_Dplus_left = r.RooRealVar("n_Dplus_left","n_Dplus_left",power_Dplus_l)
+	sig_Dplus_left = r.RooCBShape("signal Dplus left","signal Dplus left", m, mean_Dplus, sigma_Dplus, al_Dplus_left, pwr_Dplus_left)
+	#Creating D+ signal PDF right tail
+
+	al_Dplus_right = r.RooRealVar("alpha_Dplus_right","alpha_Dplus_right",alpha_Dplus_r)
+	pwr_Dplus_right = r.RooRealVar("n_Dplus_right","n_Dplus_right",power_Dplus_r)
+	sig_Dplus_right = r.RooCBShape("signal Dplus right","signal Dplus right", m, mean_Dplus, sigma_Dplus, al_Dplus_right, pwr_Dplus_right)
+
+	#Adding the two CBs with their relative fraction
+	sig_Dplus = r.RooAddPdf("signal Dplus","Dplus mass peak",r.RooArgList(sig_Dplus_left, sig_Dplus_right),r.RooArgList(sig_frc_Dplus))
+
+	#Creating Ds+ signal PDF
+	mean_Ds= r.RooRealVar("mean_Ds","mean_Ds",1.97,1.93,2.01)
+	sigma_Ds = r.RooRealVar("sigma_Ds","sigma_Ds",0.020,0.,0.2)
+
+	sig_frc_Ds =r.RooRealVar("Ds Double crystalball fraction","Ds Double crystalball fraction",frac_Ds)
+
+	al_Ds_left = r.RooRealVar("alpha_Ds_left","alpha_Ds_left",alpha_Ds_l)
+	pwr_Ds_left = r.RooRealVar("n_Ds_left","n_Ds_left",power_Ds_l)
+	sig_Ds_left = r.RooCBShape("signal Ds left","signal Ds left", m, mean_Ds, sigma_Ds, al_Ds_left, pwr_Ds_left)
+	#Creating D+ signal PDF right tail
+
+	al_Ds_right = r.RooRealVar("alpha_Ds_right","alpha_Ds_right",alpha_Ds_r)
+	pwr_Ds_right = r.RooRealVar("n_Ds_right","n_Ds_right",power_Ds_r)
+	sig_Ds_right = r.RooCBShape("signal Ds right","signal Ds right", m, mean_Ds, sigma_Ds, al_Ds_right, pwr_Ds_right)
+
+	#Adding the two CBs with their relative fraction
+	sig_Ds = r.RooAddPdf("sig_Ds","Ds mass peak",r.RooArgList(sig_Ds_left, sig_Ds_right),r.RooArgList(sig_frc_Ds))
+
+	#Model the background
+
+	coef0 = r.RooRealVar("c0","coefficient #0",1.0,-10.,10)
+	coef1 = r.RooRealVar("c1","coefficient #1",0.1,-10.,10)
+	coef2 = r.RooRealVar("c2","coefficient #2",-0.1,-10.,10)
+	bkg = r.RooChebychev("bkg","background p.d.f.",m,r.RooArgList(coef0,coef1,coef2))
+
+	#add it altogether
+
+    #Add 2 sources of signal
+	if mother_ID[mother_index_fit]=='both':
+
+		NDs = r.RooRealVar("nDs","nDs",100.,0.,40000.)
+		NDplus = r.RooRealVar("nDplus","nDplus",100.,0.,40000.)
+		nbkg = r.RooRealVar("nbkg","nbkg",100.,0.,40000.)
+		model = r.RooAddPdf("model","Dplus and Ds mass peaks",r.RooArgList(sig_Ds, sig_Dplus, bkg),r.RooArgList(NDs, NDplus,nbkg))
+
+
+	if mother_ID[mother_index_fit]=='Ds':
+		NDs = r.RooRealVar("nDs","nDs",100.,0.,40000.)
+		nbkg = r.RooRealVar("nbkg","nbkg",100.,0.,40000.)
+		model = r.RooAddPdf("model","Ds mass peak",r.RooArgList(sig_Ds, bkg),r.RooArgList(NDs,nbkg))
+
+	if mother_ID[mother_index_fit]=='Dplus':
+
+		NDplus = r.RooRealVar("nDplus","nDplus",100.,0.,40000.)
+		nbkg = r.RooRealVar("nbkg","nbkg",100.,0.,40000.)
+		model = r.RooAddPdf("model","Dplus mass peak",r.RooArgList(sig_Dplus, bkg),r.RooArgList(NDplus,nbkg))
+
+	fitr = model.fitTo(data_set,r.RooFit.Extended(),r.RooFit.Save())
+	xframe = m.frame(r.RooFit.Title("Fit to "+l_flv[l_index]+" data"))
+
+	bkg_component = r.RooArgSet(bkg)
+	sig_Dplus_component = r.RooArgSet(sig_Dplus)
+	sig_Ds_component = r.RooArgSet(sig_Ds)
+	#sig_D_component = r.RooArgSet(sig_Dplus_component,sig_Ds_component)
+
+	data_set.plotOn(xframe)
+	model.plotOn(xframe)
+	hpull=xframe.pullHist()
+
+	n_param = fitr.floatParsFinal().getSize()
+	reduced_chi_square = xframe.chiSquare(n_param)
+
+	model.plotOn(xframe,r.RooFit.Components(bkg_component),r.RooFit.LineStyle(2))
+
+	if mother_ID[mother_index_fit]=='Dplus':
+
+		model.plotOn(xframe, r.RooFit.Components(sig_Dplus_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+
+	if mother_ID[mother_index_fit]=='Ds':
+
+		model.plotOn(xframe, r.RooFit.Components(sig_Ds_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+
+	if mother_ID[mother_index_fit]=='both':
+
+		model.plotOn(xframe, r.RooFit.Components(sig_Ds_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+		model.plotOn(xframe, r.RooFit.Components(sig_Dplus_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+
+
+	model.paramOn(xframe, r.RooFit.Layout(0.69,0.99,0.92), r.RooFit.Format("NEU", r.RooFit.AutoPrecision(1)))
+	xframe.getAttText().SetTextSize(0.04)
+
+	xframe2 = m.frame(r.RooFit.Title("Pulls"))
+	xframe2.addPlotable(hpull,"P")
+
+	c = r.TCanvas("Fit {0}".format(iteration),"Fit {0}".format(iteration),900,600)
+	pad1 = r.TPad("pad1", "pad1", 0, 0.35, 1, 1.0)
+	pad1.SetBottomMargin(0)
+	pad1.Draw()
+	c.cd()
+	pad2 = r.TPad("pad2", "pad2", 0, 0.05, 1, 0.35)
+	pad2.SetTopMargin(0)
+	pad2.SetBottomMargin(0.2)
+	pad2.SetGridx()
+	pad2.SetGridy()
+	pad2.Draw()
+
+	pad1.cd()
+	xframe.Draw()
+	#xframe.GetYaxis().SetLabelOffset(-0.01)
+	pad2.cd()
+	xframe2.Draw()
+	xframe2.GetXaxis().SetTitleSize(0.09)
+	xframe2.GetXaxis().SetLabelSize(0.1)
+	xframe2.GetYaxis().SetLabelSize(0.05)
+
+
+
+	print("chi2 {0}".format(reduced_chi_square))
+	c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}/fit_{1}.png".format(iteration,iteration))
+	
+	
+	xframe_sw = m.frame(r.RooFit.Title("Weighted "+l_flv[l_index]+" data"))
+
+	if mother_ID[mother_index_fit]=='both':
+
+		splot = r.RooStats.SPlot(
+		'sData','sData', data_set, model,
+		r.RooArgList(NDs, NDplus, nbkg)
+
+		)
+
+		Ds_sw=splot.GetSWeightVars()[0]
+		Dplus_sw=splot.GetSWeightVars()[1]
+		bkg_sw=splot.GetSWeightVars()[2]
+
+		argset = r.RooArgSet(m, Ds_sw)
+		dataset_Ds_w = r.RooDataSet("Ds weighted dataset","Ds weighted dataset",data_set, argset,"","nDs_sw")
+
+		argset = r.RooArgSet(m, Dplus_sw)
+		dataset_Dplus_w = r.RooDataSet("Dplus weighted dataset","Dplus weighted dataset",data_set, argset,"","nDplus_sw")
+
+		
+		dataset_Ds_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kBlue))
+		dataset_Dplus_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kRed))
+
+
+		Ds_sw.setRange(-1.2,1.5)
+		frame_Ds_sw = Ds_sw.frame(r.RooFit.Title("signal Ds sWeights"))
+		data_set.plotOn(frame_Ds_sw, r.RooFit.MarkerSize(0.05))
+
+		Dplus_sw.setRange(-1.2,1.5)
+		frame_Dplus_sw = Dplus_sw.frame(r.RooFit.Title("signal Dplus sWeights"))
+		data_set.plotOn(frame_Dplus_sw, r.RooFit.MarkerSize(0.05))
+		   
+		bkg_sw.setRange(-.6,1.2)
+		frame_bkg_sw = bkg_sw.frame(r.RooFit.Title("background sWeights"))
+		data_set.plotOn(frame_bkg_sw, r.RooFit.MarkerSize(0.05))
+		   
+
+		sframe = m.frame(r.RooFit.Title("m vs sWeights"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(Ds_sw),
+		                r.RooFit.MarkerColor(r.kGreen), r.RooFit.Name("Ds_sig"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(Dplus_sw),
+		                r.RooFit.MarkerColor(r.kBlue), r.RooFit.Name("Dplus_sig"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(bkg_sw),
+		                r.RooFit.MarkerColor(r.kRed), r.RooFit.Name("bkg"))
+
+		legend = r.TLegend(0.89, 0.89, 0.5, 0.7)
+		legend.AddEntry(sframe.findObject('Ds_sig'), 'Signal Ds sWeights', 'p')
+		legend.AddEntry(sframe.findObject('Dplus_sig'), 'Signal Dplus sWeights', 'p')
+		legend.AddEntry(sframe.findObject('bkg'), 'Background sWeights', 'p')
+		#
+		c = r.TCanvas("sWeighted mass dist {0}".format(iteration),"sWeighted mass dist {0}".format(iteration),900,600)
+		xframe_sw.Draw()
+		c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweighted_mass_plot_fit{0}.png".format(iteration))
+
+
+		c = r.TCanvas("sWeights {0}".format(iteration),"sWeights {0}".format(iteration),900,900)
+		c.Divide(2,2)
+		c.cd(1)
+		frame_Ds_sw.Draw()
+		c.cd(2)
+		frame_Dplus_sw.Draw()
+		c.cd(3)
+		frame_bkg_sw.Draw()
+		c.cd(4)
+		sframe.Draw()
+		legend.Draw()
+		c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweights_{0}.png".format(iteration))
+
+
+		nbkg_w = splot.GetYieldFromSWeight("nbkg_sw")
+		nDs_w = splot.GetYieldFromSWeight("nDs_sw")
+		nDplus_w = splot.GetYieldFromSWeight("nDplus_sw")
+		raw_sig=nDs_w+nDplus_w
+
+	if mother_ID[mother_index_fit]=='Ds':
+
+		splot = r.RooStats.SPlot(
+		'sData','sData', data_set, model,
+		r.RooArgList(NDs, nbkg)
+
+		)
+
+		Ds_sw=splot.GetSWeightVars()[0]
+		bkg_sw=splot.GetSWeightVars()[1]
+
+		argset = r.RooArgSet(m, Ds_sw)
+		dataset_Ds_w = r.RooDataSet("Ds weighted dataset","Ds weighted dataset",data_set, argset,"","nDs_sw")
+
+		dataset_Ds_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kBlue))
+
+		Ds_sw.setRange(-3.,1.4)
+		frame_Ds_sw = Ds_sw.frame(r.RooFit.Title("signal Ds sWeights"))
+		data_set.plotOn(frame_Ds_sw, r.RooFit.MarkerSize(0.05))
+		   
+		bkg_sw.setRange(-.5,5.)
+		frame_bkg_sw = bkg_sw.frame(r.RooFit.Title("background sWeights"))
+		data_set.plotOn(frame_bkg_sw, r.RooFit.MarkerSize(0.05))
+		   
+		sframe = m.frame(r.RooFit.Title("m vs sWeights"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(Ds_sw),
+		                r.RooFit.MarkerColor(r.kGreen), r.RooFit.Name("Ds_sig"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(bkg_sw),
+		                r.RooFit.MarkerColor(r.kRed), r.RooFit.Name("bkg"))
+
+		legend = r.TLegend(0.89, 0.89, 0.75, 0.8)
+		legend.AddEntry(sframe.findObject('Ds_sig'), 'Signal Ds sWeights', 'p')
+		legend.AddEntry(sframe.findObject('bkg'), 'Background sWeights', 'p')
+		#
+		c = r.TCanvas("sWeighted mass dist {0}".format(iteration),"sWeighted mass dist {0}".format(iteration),900,600)
+		xframe_sw.Draw()
+		c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweighted_mass_plot_fit{0}.png".format(iteration))
+
+
+		c = r.TCanvas("sWeights {0}".format(iteration),"sWeights  {0}".format(iteration),900,600)
+		c.cd()
+		pad1 = r.TPad("pad1", "pad1", 0, 0.5, 0.5, 1.0)
+		pad1.Draw()
+		c.cd()
+		pad2 = r.TPad("pad2", "pad2", 0.5, 0.5, 1.0, 1.0)
+		pad2.Draw()
+		c.cd()
+		pad3 = r.TPad("pad3", "pad3", 0, 0.05, 1, 0.50)
+		pad3.SetGridx()
+		pad3.Draw()
+		
+
+		pad1.cd()
+		frame_Ds_sw.Draw()
+		pad2.cd()
+		frame_bkg_sw.Draw()
+		pad3.cd()
+		sframe.Draw()
+		legend.Draw()
+
+		c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweights_{0}.png".format(iteration))
+
+
+		nbkg_w = splot.GetYieldFromSWeight("nbkg_sw")
+		nDs_w = splot.GetYieldFromSWeight("nDs_sw")
+		raw_sig=nDs_w
+
+	if mother_ID[mother_index_fit]=='Dplus':
+
+		splot = r.RooStats.SPlot(
+		'sData','sData', data_set, model,
+		r.RooArgList(NDplus, nbkg)
+
+		)
+
+		Dplus_sw=splot.GetSWeightVars()[0]
+		bkg_sw=splot.GetSWeightVars()[1]
+
+		argset = r.RooArgSet(m, Dplus_sw)
+		dataset_Dplus_w = r.RooDataSet("Dplus weighted dataset","Dplus weighted dataset",data_set, argset,"","nDplus_sw")
+
+		#model.plotOn(xframe_sw, r.RooFit.Components(sig_Dplus_component),r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+		dataset_Dplus_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kRed))
+
+
+		Dplus_sw.setRange(-1.2,1.8)
+		frame_Dplus_sw = Dplus_sw.frame(r.RooFit.Title("signal Dplus sWeights"))
+		data_set.plotOn(frame_Dplus_sw, r.RooFit.MarkerSize(0.05))
+		   
+		bkg_sw.setRange(-1.2,2.1)
+		frame_bkg_sw = bkg_sw.frame(r.RooFit.Title("background sWeights"))
+		data_set.plotOn(frame_bkg_sw, r.RooFit.MarkerSize(0.05))
+		   
+
+		sframe = m.frame(r.RooFit.Title("m vs sWeights"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(Dplus_sw),
+		                r.RooFit.MarkerColor(r.kBlue), r.RooFit.Name("Dplus_sig"))
+		data_set.plotOnXY(sframe, r.RooFit.YVar(bkg_sw),
+		                r.RooFit.MarkerColor(r.kRed), r.RooFit.Name("bkg"))
+
+		legend = r.TLegend(0.89, 0.89, 0.75, 0.8)
+		legend.AddEntry(sframe.findObject('Dplus_sig'), 'Signal Dplus sWeights', 'p')
+		legend.AddEntry(sframe.findObject('bkg'), 'Background sWeights', 'p')
+		#
+		c = r.TCanvas("sWeighted mass dist {0}".format(iteration),"sWeighted mass dist {0}".format(iteration),900,600)
+		xframe_sw.Draw()
+		c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweighted_mass_plot_fit{0}.png".format(iteration))
+
+
+		c = r.TCanvas("sWeights {0}".format(iteration),"sWeights  {0}".format(iteration),900,600)
+		c.cd()
+		pad1 = r.TPad("pad1", "pad1", 0, 0.5, 0.5, 1.0)
+		pad1.Draw()
+		c.cd()
+		pad2 = r.TPad("pad2", "pad2", 0.5, 0.5, 1.0, 1.0)
+		pad2.Draw()
+		c.cd()
+		pad3 = r.TPad("pad3", "pad3", 0, 0.05, 1, 0.50)
+		pad3.SetGridx()
+		pad3.Draw()
+		
+
+		pad1.cd()
+		frame_Dplus_sw.Draw()
+		pad2.cd()
+		frame_bkg_sw.Draw()
+		pad3.cd()
+		sframe.Draw()
+		legend.Draw()
+
+		c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweights_{0}.png".format(iteration))
+
+
+		nbkg_w = splot.GetYieldFromSWeight("nbkg_sw")
+		nDplus_w = splot.GetYieldFromSWeight("nDplus_sw")
+		raw_sig=nDplus_w
+
+	fom=(Nsig_from_MC)/np.sqrt(nbkg_w+Nsig_from_MC)
+
+	eff_corrected_sig = (raw_sig)/(sig_sel_eff)
+
+	fit_results={
+				 '# XGBoost test {0} BDT output'.format(test): '\n',
+				 '# background': nbkg_w,
+				 #'err bkg': err_bkg,
+				 '# fitted signal': raw_sig,
+				 #'error sig': raw_sig_err,
+				 '# of signal in MC': Nsig_from_MC,
+				 'signal selection efficiency': sig_sel_eff,
+				 'S/sqrt(S+B)': fom,
+				 'efficiency corrected yeld': eff_corrected_sig,
+				 'chi 2': reduced_chi_square
+				 }
+
+	return fit_results
+
+
+if __name__=='__main__':
+
+	
+	parser = argparse.ArgumentParser(description='Fit at different BDT cuts')
+	parser.add_argument('-iteration', metavar='Fit iteration', type =int, help='Fit iteration')
+	#parser.add_argument('-test', metavar='BDT test', type =int, help='Which BDT test you are using')
+	parser.add_argument('-x_cut', metavar='BDT cut', type =float, help='BDT cut')
+	parser.add_argument('-l_index', metavar='Lepton flavour', type =int, help='Which lepton flavour are you fitting?')
+	parser.add_argument('-mother_index_fit', metavar='Decay mother', type =int, help='Which mass window are you fitting?')
+	args = parser.parse_args()
+	
+	test=4
+
+	#test=args.test
+	i = args.iteration
+	l_index = args.l_index
+	mother_index_fit = args.mother_index_fit
+	x_cut=args.x_cut
+
+	
+	FIT_PATH=l_flv[l_index]+'/fits'
+	BDT_PATH=l_flv[l_index]+'/BDTs/test_'+str(test)
+
+
+	if not os.path.exists(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}/'.format(i)):
+		os.mkdir(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/{0}/'.format(i))
+
+	
+	fit_results = select_and_fit(mother_index_fit, l_index, x_cut, i, test)
+
+	with open(FIT_PATH+'/'+mother_ID[mother_index_fit]+'/fit_results_{0}.txt'.format(i), 'w') as g:
+		print('Saving fit results...')
+		for key, value in fit_results.items():
+			g.write('%s:%s\n' % (key, value))
+	g.close()
diff --git a/XGBoost.ipynb b/XGBoost.ipynb
deleted file mode 100644
index 664c94c..0000000
--- a/XGBoost.ipynb
+++ /dev/null
@@ -1,565 +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",
-    "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": [
-       "<Figure size 1152x576 with 1 Axes>"
-      ]
-     },
-     "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": [
-       "<Figure size 1152x576 with 2 Axes>"
-      ]
-     },
-     "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": [
-       "<matplotlib.legend.Legend at 0x7f6790669c18>"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "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": [
-       "<Figure size 576x576 with 1 Axes>"
-      ]
-     },
-     "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/XGBoost_train.ipynb b/XGBoost_train.ipynb
new file mode 100644
index 0000000..d8ee477
--- /dev/null
+++ b/XGBoost_train.ipynb
@@ -0,0 +1,550 @@
+{
+ "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": 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 12244 while signal MC amounts to 1262 Ds and 2025 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_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": 5,
+   "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": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "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": 7,
+   "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": 8,
+   "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": 9,
+   "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": 133,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Divide the dataset k \"equi populated\" sets\n",
+    "test=4\n",
+    "k=10 #number of subsets\n",
+    "i=9#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": 134,
+   "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": 135,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(13977, 11)"
+      ]
+     },
+     "execution_count": 135,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train_2.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SETTING UP THE XGBOOST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 136,
+   "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": 137,
+   "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": 137,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# fit model to training data\n",
+    "model = XGBClassifier()\n",
+    "\n",
+    "model.fit(X_train_2, Y_train[:,1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output_XG = model.predict_proba(X_test_2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 139,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x576 with 2 Axes>"
+      ]
+     },
+     "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": 140,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x576 with 1 Axes>"
+      ]
+     },
+     "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": 141,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6441176470588236"
+      ]
+     },
+     "execution_count": 141,
+     "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": 142,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "pAUC from XG Boost 0.91106396392\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x576 with 1 Axes>"
+      ]
+     },
+     "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": 143,
+   "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": 144,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.bar(np.arange(dim-1),model.feature_importances_)\n",
+    "plt.xticks(np.arange(dim-1), features[:-1], rotation=90);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 82,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12"
+      ]
+     },
+     "execution_count": 82,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(features)"
+   ]
+  },
+  {
+   "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<ipython-input-5-1c550638f0c3>\u001b[0m in \u001b[0;36m<module>\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": [
+       "<Figure size 1152x720 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1152x720 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 864x576 with 1 Axes>"
+      ]
+     },
+     "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<ipython-input-17-873a3d0d91d5>\u001b[0m in \u001b[0;36m<module>\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": [
+       "<Figure size 1152x576 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1152x576 with 1 Axes>"
+      ]
+     },
+     "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<ipython-input-23-690618031886>\u001b[0m in \u001b[0;36m<module>\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<ipython-input-23-690618031886>\u001b[0m in \u001b[0;36m<listcomp>\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<data[i]<upper_mass_cut:\n",
+    "        cut_indices.append(i)\n",
+    "        \n",
+    "data_cut=data[cut_indices]/1000.  \n",
+    "\n",
+    "lower_mass_cut/=1000.\n",
+    "upper_mass_cut/=1000."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x720 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1152x576 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 1152x576 with 2 Axes>"
+      ]
+     },
+     "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": [
+       "<matplotlib.legend.Legend at 0x7f6790669c18>"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "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": [
+       "<Figure size 576x576 with 1 Axes>"
+      ]
+     },
+     "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<data[i]<upper_mass_cut:\n",
+    "        cut_indices.append(i)\n",
+    "        \n",
+    "data_cut=data[cut_indices]/1000.  \n",
+    "\n",
+    "lower_mass_cut/=1000.\n",
+    "upper_mass_cut/=1000."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x720 with 1 Axes>"
+      ]
+     },
+     "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 (<ipython-input-14-c949510cd7b7>, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-14-c949510cd7b7>\"\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": [
+       "<ROOT.TTree object (\"DecayTree\") at 0x5644e0a94f60>"
+      ]
+     },
+     "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_mass<phi_m<upper_phi_mass:\n",
+    "        MC_Ds_indices.append(i)\n",
+    "        \n",
+    "for i in range(len(MC_Dplus_tuple_dict_presel_3[\"Dplus_ConsD_M\"])):\n",
+    "\n",
+    "    phi_m = MC_Dplus_tuple_dict_presel_3[\"phi_M\"][i]\n",
+    "    #fixing a window on the phi mass\n",
+    "    if lower_phi_mass<phi_m<upper_phi_mass:\n",
+    "        MC_Dplus_indices.append(i)\n",
+    "        \n",
+    "for i in range(len(data_tuple_dict_presel_3[\"Ds_ConsD_M\"])):\n",
+    "\n",
+    "    phi_m = data_tuple_dict_presel_3[\"phi_M\"][i]\n",
+    "    #fixing a window on the phi mass\n",
+    "    if lower_phi_mass<phi_m<upper_phi_mass:\n",
+    "        data_indices.append(i)\n",
+    "\n",
+    "MC_Ds_tuple_dict_presel_4 ={}\n",
+    "MC_Dplus_tuple_dict_presel_4 ={}\n",
+    "data_tuple_dict_presel_4={}\n",
+    "\n",
+    "\n",
+    "for label in return_branches(mother_index=0):  \n",
+    "    \n",
+    "    data_tuple_dict_presel_4[label] = data_tuple_dict_presel_3[label][data_indices]\n",
+    "    MC_Ds_tuple_dict_presel_4[label] = MC_Ds_tuple_dict_presel_3[label][MC_Ds_indices]\n",
+    "\n",
+    "for label in return_branches(mother_index=1):  \n",
+    "    MC_Dplus_tuple_dict_presel_4[label] = MC_Dplus_tuple_dict_presel_3[label][MC_Dplus_indices]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_tuple_dict=data_tuple_dict_presel_4\n",
+    "MC_Ds_tuple_dict=MC_Ds_tuple_dict_presel_4\n",
+    "MC_Dplus_tuple_dict=MC_Dplus_tuple_dict_presel_4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if l_flv[l_index]=='mu':\n",
+    "    lower_Dplus_mass=1830\n",
+    "    upper_Dplus_mass=1910\n",
+    "\n",
+    "    lower_Ds_mass = 1930\n",
+    "    upper_Ds_mass = 2010\n",
+    "    \n",
+    "if l_flv[l_index]=='e':\n",
+    "    lower_Dplus_mass=1810\n",
+    "    upper_Dplus_mass=1900\n",
+    "\n",
+    "    lower_Ds_mass = 1900\n",
+    "    upper_Ds_mass = 2000\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",
+    "    #retrieving the Ds reconstructed mass\n",
+    "    \n",
+    "    #if 0<data_tuple_dict[\"phi_M\"][i]<lower_phi_mass or upper_phi_mass<data_tuple_dict[\"phi_M\"][i]:\n",
+    "        m = data_tuple_dict[\"Ds_ConsD_M\"][i]\n",
+    "        \n",
+    "    #selecting the out of signal regions\n",
+    "        if 0<m<lower_Dplus_mass or upper_Dplus_mass < m < lower_Ds_mass or upper_Ds_mass < m:\n",
+    "        #if 0<m<lower_Ds_mass or upper_Ds_mass < m:\n",
+    "            data_bkg_indices.append(i)\n",
+    "            \n",
+    "for i in range(len(MC_Ds_tuple_dict[\"Ds_ConsD_M\"])):\n",
+    "    \n",
+    "    #retrieving the Ds reconstructed mass\n",
+    "    #if lower_phi_mass<MC_tuple_dict[\"phi_M\"][i]<lower_phi_mass:\n",
+    "        m = MC_Ds_tuple_dict[\"Ds_ConsD_M\"][i]\n",
+    "    \n",
+    "    #selecting the signal regions\n",
+    "        #if lower_Dplus_mass< m <upper_Dplus_mass or lower_Ds_mass< m <upper_Ds_mass:\n",
+    "        if lower_Ds_mass< m <upper_Ds_mass:\n",
+    "            MC_Ds_sig_indices.append(i)  \n",
+    "            \n",
+    "for i in range(len(MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"])):\n",
+    "    \n",
+    "    #retrieving the Ds reconstructed mass\n",
+    "    #if lower_phi_mass<MC_tuple_dict[\"phi_M\"][i]<lower_phi_mass:\n",
+    "        m = MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"][i]\n",
+    "    \n",
+    "    #selecting the signal regions\n",
+    "        #if lower_Dplus_mass< m <upper_Dplus_mass or lower_Ds_mass< m <upper_Ds_mass:\n",
+    "        if lower_Dplus_mass< m <upper_Dplus_mass:\n",
+    "            MC_Dplus_sig_indices.append(i)\n",
+    "            \n",
+    "#Create the dict tuples with all MC signal and data bkg events\n",
+    "\n",
+    "data_tuple_bkg={}\n",
+    "MC_Ds_tuple_sig ={}\n",
+    "MC_Dplus_tuple_sig ={}\n",
+    "\n",
+    "MC_Ds_mass_for_fit= np.array([MC_Ds_tuple_dict[\"Ds_ConsD_M\"][i][0] for i in range(len(MC_Ds_tuple_dict[\"Ds_ConsD_M\"]))])\n",
+    "MC_Dplus_mass_for_fit=np.array([MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"][i][0] for i in range(len(MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"]))])\n",
+    "\n",
+    "for label in return_branches(mother_index=0):    \n",
+    "\n",
+    "    data_tuple_bkg[label] = data_tuple_dict[label][data_bkg_indices]\n",
+    "    MC_Ds_tuple_sig[label] = MC_Ds_tuple_dict[label][MC_Ds_sig_indices]\n",
+    "    \n",
+    "for label in return_branches(mother_index=1):  \n",
+    "    MC_Dplus_tuple_sig[label] = MC_Dplus_tuple_dict[label][MC_Dplus_sig_indices]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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",
+    "    \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": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "14066"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_tuple_bkg[\"Ds_ConsD_M\"].shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1974"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "MC_Dplus_tuple_sig[\"Dplus_ConsD_M\"].shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1466"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "MC_Ds_tuple_sig[\"Ds_ConsD_M\"].shape[0]"
+   ]
+  }
+ ],
+ "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_ with_cos_thetal.ipynb b/dataMC_preselection_ with_cos_thetal.ipynb
new file mode 100644
index 0000000..f0b7957
--- /dev/null
+++ b/dataMC_preselection_ with_cos_thetal.ipynb
@@ -0,0 +1,1092 @@
+{
+ "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\n",
+    "import math\n",
+    "\n",
+    "from tools.data_processing import *\n",
+    "from tools.kinematics import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "masses = {\n",
+    "            'Ds': 1.968,\n",
+    "            'Dplus':1.869,\n",
+    "            'pi':0.140,\n",
+    "            'mu_plus': 0.105,\n",
+    "            'mu_minus': 0.105,\n",
+    "            'e_plus': 0.0005,\n",
+    "            'e_minus': 0.0005,\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "l_index =0\n",
+    "meson_index=0\n",
+    "mother_index = None\n",
+    "data_index = None "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# RETRIEVE DESIRED DATA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mother_ID=['Ds','Dplus']\n",
+    "meson_ID =['pi','X']\n",
+    "l_flv = ['e','mu']\n",
+    "\n",
+    "data_type = ['MC','data']\n",
+    "\n",
+    "def find_file_path(l_index=l_index, meson_index=meson_index, mother_index=mother_index, data_index=data_index): \n",
+    "    if data_index == 0:\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]+\"_\"+l_flv[l_index]+l_flv[l_index]+meson_ID[meson_index]+\".root\"\n",
+    "    else:\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]+\"_phi\"+meson_ID[meson_index]+\"_\"+l_flv[l_index]+l_flv[l_index]+\".root\"\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",
+    "\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, meson_index=meson_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",
+    "\n",
+    "#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",
+    "#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",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# HLT and PID Preselection"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "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",
+    "\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": "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": [
+       "<Figure size 1296x576 with 2 Axes>"
+      ]
+     },
+     "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<phi_m<upper_phi_mass:\n",
+    "        MC_Ds_indices.append(i)\n",
+    "        \n",
+    "for i in range(len(MC_Dplus_tuple_dict_presel_8[\"Dplus_ConsD_M\"])):\n",
+    "\n",
+    "    phi_m = MC_Dplus_tuple_dict_presel_3[\"phi_M\"][i]\n",
+    "    #fixing a window on the phi mass\n",
+    "    if lower_phi_mass<phi_m<upper_phi_mass:\n",
+    "        MC_Dplus_indices.append(i)\n",
+    "        \n",
+    "for i in range(len(data_tuple_dict_presel_3[\"Ds_ConsD_M\"])):\n",
+    "\n",
+    "    phi_m = data_tuple_dict_presel_3[\"phi_M\"][i]\n",
+    "    #fixing a window on the phi mass\n",
+    "    if lower_phi_mass<phi_m<upper_phi_mass:\n",
+    "        data_indices.append(i)\n",
+    "\n",
+    "MC_Ds_tuple_dict_presel_9 ={}\n",
+    "MC_Dplus_tuple_dict_presel_9 ={}\n",
+    "data_tuple_dict_presel_4={}\n",
+    "\n",
+    "\n",
+    "for label in return_branches(data_index=1, mother_index=0, l_index=l_index, meson_index=0):  \n",
+    "    \n",
+    "    data_tuple_dict_presel_4[label] = data_tuple_dict_presel_3[label][data_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_9[label] = MC_Ds_tuple_dict_presel_8[label][MC_Ds_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_9[label] = MC_Dplus_tuple_dict_presel_8[label][MC_Dplus_indices]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1296x576 with 2 Axes>"
+      ]
+     },
+     "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": "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\n",
+      "text/plain": [
+       "<Figure size 1152x576 with 2 Axes>"
+      ]
+     },
+     "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": "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\n",
+      "text/plain": [
+       "<Figure size 1152x576 with 2 Axes>"
+      ]
+     },
+     "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<m<lower_Dplus_mass_data or upper_Dplus_mass_data < m < lower_Ds_mass_data or upper_Ds_mass_data < m:\n",
+    "            data_bkg_indices.append(i)\n",
+    "            \n",
+    "for i in range(len(MC_Ds_tuple_dict[\"Ds_ConsD_M\"])):\n",
+    "    \n",
+    "        m = MC_Ds_tuple_dict[\"Ds_ConsD_M\"][i]\n",
+    "    \n",
+    "        if lower_Ds_mass_mc< m <upper_Ds_mass_mc:\n",
+    "            MC_Ds_sig_indices.append(i)  \n",
+    "            \n",
+    "for i in range(len(MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"])):\n",
+    "    \n",
+    "        m = MC_Dplus_tuple_dict[\"Dplus_ConsD_M\"][i]\n",
+    "    \n",
+    "    #selecting the signal regions\n",
+    "        if lower_Dplus_mass_mc< m <upper_Dplus_mass_mc:\n",
+    "            MC_Dplus_sig_indices.append(i)\n",
+    "            \n",
+    "\n",
+    "data_tuple_bkg={}\n",
+    "MC_Ds_tuple_sig ={}\n",
+    "MC_Dplus_tuple_sig ={}\n",
+    "\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_bkg[label] = data_tuple_dict[label][data_bkg_indices]\n",
+    "\n",
+    "labels=return_branches(data_index=0, mother_index=0, l_index=l_index, meson_index=0)+['cos_thetal']\n",
+    "for label in labels:\n",
+    "    MC_Ds_tuple_sig[label] = MC_Ds_tuple_dict[label][MC_Ds_sig_indices]\n",
+    "    \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_sig[label] = MC_Dplus_tuple_dict[label][MC_Dplus_sig_indices] "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 151,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('/disk/lhcb_data/davide/Rphipi/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/MC_for_BDT_training_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/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/MC_for_BDT_training_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/BDT_training/'+l_flv[l_index]+l_flv[l_index]+'/data_for_BDT_training_'+l_flv[l_index]+l_flv[l_index]+'.pickle', 'wb') as handle:\n",
+    "    pickle.dump(data_tuple_bkg, 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_tuple_dict, 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_tuple_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)\n",
+    "\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', 'wb') as handle:\n",
+    "    pickle.dump(data_tuple_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 152,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "12244"
+      ]
+     },
+     "execution_count": 152,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data_tuple_bkg[\"Ds_ConsD_M\"].shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 153,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2025"
+      ]
+     },
+     "execution_count": 153,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "MC_Dplus_tuple_sig[\"Dplus_ConsD_M\"].shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 154,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1262"
+      ]
+     },
+     "execution_count": 154,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "MC_Ds_tuple_sig[\"Ds_ConsD_M\"].shape[0]"
+   ]
+  },
+  {
+   "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/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/fitter.ipynb b/fitter.ipynb
deleted file mode 100644
index ae8d8ee..0000000
--- a/fitter.ipynb
+++ /dev/null
@@ -1,212 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import ROOT as r\n",
-    "import pickle\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "l_index=0\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",
-    "for i in range(len(data)):\n",
-    "    if 1790<data[i]<2030:\n",
-    "        cut_indices.append(i)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 1152x720 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "data_cut=data[cut_indices]/1000\n",
-    "plt.hist(data_cut,range=(1.79,2.03),bins=100);\n",
-    "fig=plt.gcf();\n",
-    "fig.set_size_inches(16,10)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "h1 = r.TH1D(\"h1\",\"data histogram\",100,1.79,2.03)\n",
-    "for i in range(len(data_cut)): h1.Fill(data_cut[i])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "m = r.RooRealVar(\"m\",\"m\",1.8,2.5)\n",
-    "l = r.RooArgList(m)\n",
-    "data_hist = r.RooDataHist(\"data histogram\", \"data\", l, h1)"
-   ]
-  },
-  {
-   "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",
-    "\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",
-    "\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",
-    "fpeak = r.RooRealVar(\"fpeak\",\"peaking signals fraction\",0.5,0.,1.)\n",
-    "# sigpeak(x) = fpeak*sig(x) + (1-fpeak)*bkg(x)\n",
-    "sigpeaks = r.RooAddPdf(\"sigpeak\",\"two mass peaks\",r.RooArgList(sig_ds,sig_dplus),r.RooArgList(fpeak))\n",
-    "\n",
-    "\n",
-    "# now we can add (sig+peak) to bkg with the fraction fpeak\n",
-    "fbkg = r.RooRealVar(\"fbkg\",\"background fraction\",0.5,0.,1.)\n",
-    "# model2(x) = fbkg*bkg(x) + (1-fbkg)*sigpeak(x)\n",
-    "model = r.RooAddPdf(\"model\",\"bkg+(sig_ds+sig_dplus)\",r.RooArgList(bkg,sigpeaks),r.RooArgList(fbkg))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "##Plotting composite models\n",
-    "#\n",
-    "#xframe = m.frame()\n",
-    "#sigpeaks.plotOn(xframe)\n",
-    "#bkg_component = r.RooArgSet(bkg)\n",
-    "#model.plotOn(xframe,r.RooFit.Components(bkg_component),r.RooFit.LineStyle(2))\n",
-    "#\n",
-    "#xframe.Draw()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model.fitTo(data_hist,r.RooFit.Extended(),r.RooFit.PrintLevel(-1))\n",
-    "\n",
-    "\n",
-    "xframe = m.frame(r.RooFit.Title(\"Fit to muon data\"))\n",
-    "sigpeaks.plotOn(xframe)\n",
-    "bkg_component = r.RooArgSet(bkg)\n",
-    "model.plotOn(xframe,r.RooFit.Components(bkg_component),r.RooFit.LineStyle(2))\n",
-    "data_hist.plotOn(xframe)\n",
-    "model.plotOn(xframe)\n",
-    "xframe.Draw()"
-   ]
-  },
-  {
-   "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/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/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_cut<D_m<upper_cut:
+             data_indices.append(i)
+
+     for label in branches_needed:  
+         
+         data_dict[label] = data_dict[label][data_indices]
+         
+
+     m_plus=MC_Dplus_dict["Dplus_ConsD_M"].shape[0]
+     m_s=MC_Ds_dict["Ds_ConsD_M"].shape[0]
+     m=data_dict["Ds_ConsD_M"].shape[0]
+
+
+     mc_Dplus_mass=np.array([MC_Dplus_dict["Dplus_ConsD_M"][i][0] for i in range(m_plus)])
+     mc_Ds_mass=np.array([MC_Ds_dict["Ds_ConsD_M"][i][0] for i in range(m_s)])
+
+     #mc_D_mass=np.concatenate((mc_Ds_mass,mc_Dplus_mass),axis=0)
+     data_mass=np.array([data_dict["Ds_ConsD_M"][i][0] for i in range(m)])
+
+     # if mother_index_fit==0:
+     #     mc_mass=mc_Ds_mass
+     # if mother_index_fit==1:
+     #     mc_mass=mc_Dplus_mass
+     # if mother_index_fit==2:
+     #     mc_mass=mc_D_mass
+
+     return data_mass, mc_Dplus_mass, mc_Ds_mass, data_dict
+
+def preprocess_for_XGBoost(MC_Dplus_dict, MC_Ds_dict, data_dict, branches_needed, mother_index_fit=None):
+
+     m_plus=MC_Dplus_dict["Dplus_ConsD_M"].shape[0]
+     m_s=MC_Ds_dict["Ds_ConsD_M"].shape[0]
+     m=data_dict["Ds_ConsD_M"].shape[0]
+     print(m, m_plus, m_s)
+     branches_needed.pop()
+     dim=len(branches_needed)
+
+     branches_needed_Dplus=[]
+     for branch in branches_needed:
+         if 'Ds' in branch:
+             branches_needed_Dplus.append(branch.replace("Ds", "Dplus"))
+         else:
+             branches_needed_Dplus.append(branch)
+             
+     data = extract_array(data_dict, branches_needed, dim, m)
+     mc_Ds_sig = extract_array(MC_Ds_dict, branches_needed, dim, m_s)
+     mc_Dplus_sig = extract_array(MC_Dplus_dict, branches_needed_Dplus, dim, m_plus)
+
+         
+     mc_Ds_mean=mc_Ds_sig.mean(axis=0)
+     mc_Ds_1=mc_Ds_sig-mc_Ds_mean
+     mc_Ds_std=mc_Ds_1.std(axis=0)
+     mc_Ds_2=mc_Ds_1/mc_Ds_std
+
+     mc_Dplus_mean=mc_Dplus_sig.mean(axis=0)
+     mc_Dplus_1=mc_Dplus_sig-mc_Dplus_mean
+     mc_Dplus_std=mc_Dplus_1.std(axis=0)
+     mc_Dplus_2=mc_Dplus_1/mc_Dplus_std
+
+     data_mean=data.mean(axis=0)
+     data_1=data-data_mean
+     data_std=data_1.std(axis=0)
+     data_2=data_1/data_std
+
+     return data_2, mc_Dplus_2, mc_Ds_2  
+
+
diff --git a/tools/data_processing.pyc b/tools/data_processing.pyc
new file mode 100644
index 0000000..4b22d04
--- /dev/null
+++ b/tools/data_processing.pyc
Binary files differ
diff --git a/tools/kinematics.py b/tools/kinematics.py
new file mode 100644
index 0000000..55dda9f
--- /dev/null
+++ b/tools/kinematics.py
@@ -0,0 +1,170 @@
+import os
+import pickle
+import numpy as np
+import sys
+import ROOT as r
+
+mother_ID=['Ds','Dplus']
+meson_ID =['pi','X']
+l_flv = ['e','mu']
+data_type = ['MC','data']
+mag_status =['Up','Down'] 
+
+masses = {
+			'Ds': 1.968,
+			'Dplus':1.869,
+			'pi':0.140,
+			'mu_plus': 0.105,
+			'mu_minus': 0.105,
+			'e_plus': 0.0005,
+			'e_minus': 0.0005,
+}
+
+mother_index=None
+l_index=None
+
+
+def get_4_momenta(data, particle):
+    
+    mass = masses[particle]
+       
+    p_x = np.array(data[particle+"_PX"])/1000
+    p_y = np.array(data[particle+"_PY"])/1000
+    p_z = np.array(data[particle+"_PZ"])/1000        
+        
+    p_spatial = np.array([ p_x, p_y, p_z ])
+    
+    mod_p_spatial = np.sqrt(np.power(p_spatial,2).sum(axis=0))
+    E = np.sqrt(np.power(mod_p_spatial,2)+np.power(mass,2)).reshape(1,p_spatial.shape[1])
+    
+    p = np.concatenate((E, p_spatial),axis=0)
+    
+    return p, p_x, p_y, p_z
+
+
+def get_TLorentzVector(p, i):
+    
+    p_r = r.TLorentzVector(p[:,i][1], p[:,i][2], p[:,i][3], p[:,i][0])
+    return p_r
+
+
+def get_sp(p1, p2, i=None):
+    
+    if i:
+        spatial_sp2 = p1[:,i][1]*p2[:,i][1] + p1[:,i][2]*p2[:,i][2] + p1[:,i][3]*p2[:,i][3]
+        E2 = p1[:,i][0]*p2[:,i][0]
+        full_sp = E2 - spatial_sp2
+        
+    else:
+        spatial_sp2 = p1[:,:][1]*p2[:,:][1] + p1[:,:][2]*p2[:,:][2] + p1[:,:][3]*p2[:,:][3]
+        E2 = p1[:,:][0]*p2[:,:][0]
+        full_sp = E2 - spatial_sp2
+        
+    return full_sp, E2, spatial_sp2
+
+def get_costheta(p_l, p_pi):
+
+	num = p_pi.Px()*p_l.Px()+p_pi.Py()*p_l.Py()+p_pi.Pz()*p_l.Pz()
+
+	mod_p_pi = np.sqrt(p_pi.Px()*p_pi.Px()+p_pi.Py()*p_pi.Py()+p_pi.Pz()*p_pi.Pz())
+	mod_p_l = np.sqrt(p_l.Px()*p_l.Px()+p_l.Py()*p_l.Py()+p_l.Pz()*p_l.Pz())
+
+	costheta = num/(mod_p_pi*mod_p_l)
+	return costheta
+
+def get_boost_D_to_lab(data, mother_index=mother_index):
+    
+    p, p_x, p_y, p_z =  get_4_momenta(data, mother_ID[mother_index])
+    
+    p_spatial= np.array([ p_x, p_y, p_z ])
+    
+    mod_p_spatial = np.sqrt(np.power(p_spatial,2).sum(axis=0))
+    
+    E = p[0,:]
+    
+    beta_X=(p_x/E).reshape(p.shape[1])
+    beta_Y=(p_y/E).reshape(p.shape[1])
+    beta_Z=(p_z/E).reshape(p.shape[1])
+    
+    beta = (mod_p_spatial/E).reshape(p.shape[1])
+    
+    beta_vec= np.array([beta_X,beta_Y,beta_Z])
+
+    return beta, beta_vec
+
+def get_boost_D_to_q(data, l_index=l_index, mother_index=mother_index):
+    
+    l_m = masses[l_flv[l_index]+'_plus']
+    pi_m = masses['pi']
+    D_m = masses[mother_ID[mother_index]]
+    
+    p_plus , p_plus_x, p_plus_y, p_plus_z = get_4_momenta(data, l_flv[l_index]+'_plus')
+    E_plus = p_plus[0,:]
+    
+    p_plus_spatial= np.array([ p_plus_x, p_plus_y, p_plus_z ])
+    mod_p_plus_spatial = np.sqrt(np.power(p_plus_spatial,2).sum(axis=0))
+
+    p_minus , p_minus_x, p_minus_y, p_minus_z = get_4_momenta(data, l_flv[l_index]+'_minus')
+    E_minus = p_minus[0,:]
+    
+    p_minus_spatial= np.array([ p_minus_x, p_minus_y, p_minus_z ])
+    mod_p_minus_spatial = np.sqrt(np.power(p_minus_spatial,2).sum(axis=0))
+    
+    q = p_plus + p_minus
+    
+    q2, q_02, modq2 = get_sp(q, q)
+
+    lambdaD=((D_m*D_m) - (pi_m*pi_m))**2 -2*q2*(D_m*D_m +pi_m*pi_m) +np.power(q2,2)
+    lambdaD_pos = np.where(lambdaD<0,0,lambdaD)
+    sqrt_lambda=np.sqrt(lambdaD_pos)
+
+    beta = -sqrt_lambda/(np.sqrt(q2)*2*D_m)
+
+    return beta
+
+def get_costheta_list(data, l_index, mother_index):
+    
+    costheta_list=[]
+    
+    p_D_lab, _, _, _, = get_4_momenta(data, mother_ID[mother_index])
+    p_pi_lab, _, _, _,= get_4_momenta(data, 'pi')
+    p_l_plus_lab, _, _, _, = get_4_momenta(data, l_flv[l_index]+'_plus')
+    p_l_minus_lab, _, _, _, = get_4_momenta(data, l_flv[l_index]+'_minus')
+    
+    _, beta_D_vec = get_boost_D_to_lab(data, mother_index=mother_index)
+    beta_q = get_boost_D_to_q(data, l_index=l_index, mother_index=l_index)
+    
+    for j in range(len(data[mother_ID[mother_index]+"_ConsD_M"])):
+    #for j in range(2000):
+        p_D_lab_r = get_TLorentzVector(p_D_lab, j)
+        p_pi_lab_r = get_TLorentzVector(p_pi_lab, j)
+        p_l_plus_lab_r = get_TLorentzVector(p_l_plus_lab, j)
+        p_l_minus_lab_r = get_TLorentzVector(p_l_minus_lab, j)
+        
+        beta_D=r.TVector3(beta_D_vec[:,j][0], beta_D_vec[:,j][1], beta_D_vec[:,j][2])
+        lambda_lab_to_D=r.TLorentzRotation(-beta_D)
+        
+        #boost it from lab to D
+        p_D_D = lambda_lab_to_D.VectorMultiplication(p_D_lab_r)
+        p_pi_D = lambda_lab_to_D.VectorMultiplication(p_pi_lab_r)
+        p_l_plus_D = lambda_lab_to_D.VectorMultiplication(p_l_plus_lab_r)
+        p_l_minus_D = lambda_lab_to_D.VectorMultiplication(p_l_minus_lab_r)
+        
+        beta_q_r=r.TVector3(0,0, beta_q[j])
+        lambda_D_to_q=r.TLorentzRotation(beta_q_r)
+        
+        #boost it from D to q
+        p_D_q = lambda_D_to_q.VectorMultiplication(p_D_D)
+        p_pi_q = lambda_D_to_q.VectorMultiplication(p_pi_D)
+        p_l_plus_q = lambda_D_to_q.VectorMultiplication(p_l_plus_D)
+        p_l_minus_q = lambda_D_to_q.VectorMultiplication(p_l_minus_D)
+        
+        costheta=get_costheta(p_pi_q, p_l_plus_q)
+        
+        if not np.isnan(costheta):
+            costheta_list.append(costheta)
+        elif np.isnan(costheta):
+            costheta_list.append(-2)
+    costheta_list=np.array(costheta_list)
+    
+    return costheta_list
diff --git a/tools/kinematics.pyc b/tools/kinematics.pyc
new file mode 100644
index 0000000..7dc9e84
--- /dev/null
+++ b/tools/kinematics.pyc
Binary files differ
diff --git a/tools/mc_fitter.py b/tools/mc_fitter.py
new file mode 100644
index 0000000..ad3fff3
--- /dev/null
+++ b/tools/mc_fitter.py
@@ -0,0 +1,159 @@
+import ROOT as r
+import root_numpy as rn
+import pickle
+import numpy as np
+import matplotlib.pyplot as plt
+import array as array
+from xgboost import XGBClassifier
+from tools.data_processing import *
+
+import os
+l_flv=['e','mu']
+mother_ID=["Ds","Dplus","both"]
+
+def MC_fit(mc_mass, mother_index, l_index):
+    FIT_PATH=l_flv[l_index]+'/fits'
+    print("Fitting MC "+mother_ID[mother_index]+" signal")
+
+
+    if l_flv[l_index]=='mu':
+        if mother_ID[mother_index]=='Dplus':
+            lower_mass_cut=mc_mass.min()
+            upper_mass_cut=mc_mass.max()
+        if mother_ID[mother_index]=='Ds':
+            lower_mass_cut=mc_mass.min()
+            upper_mass_cut=mc_mass.max()
+    
+    if l_flv[l_index]=='e':
+        if mother_ID[mother_index]=='Dplus':
+            lower_mass_cut=mc_mass.min()
+            upper_mass_cut=mc_mass.max()
+        if mother_ID[mother_index]=='Ds':
+            lower_mass_cut=mc_mass.min()
+            upper_mass_cut=mc_mass.max()   
+
+    mc_fit=mc_mass/1000.
+    lower_mass_cut/=1000.
+    upper_mass_cut/=1000.
+    
+    #create a rootfile from which will do the unbinned fit
+
+
+
+    data_array=np.array([mc_fit[i] for i in range(len(mc_fit))], dtype=[('MC_D_m', np.float32)])
+    
+    rn.array2root(data_array,
+                  filename='/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_'+mother_ID[mother_index]+'_'+l_flv[l_index]+l_flv[l_index]+'_mass.root',
+                  treename='D_M',
+                  mode='recreate',
+                 )
+    f=r.TFile('/disk/lhcb_data/davide/Rphipi/MC/for_fit/'+l_flv[l_index]+l_flv[l_index]+'/MC_'+mother_ID[mother_index]+'_'+l_flv[l_index]+l_flv[l_index]+'_mass.root')
+    tree=f.Get("D_M") 
+    
+    #some tricks to pass Roofit a dataset in python
+    mass = np.array([0],dtype=np.float32)
+    branch = tree.GetBranch("MC_D_m")
+    branch.SetAddress(mass)
+    
+    num_entries=tree.GetEntries()
+    m = r.RooRealVar("m","m",lower_mass_cut,upper_mass_cut)
+    l = r.RooArgSet(m)
+    data_hist = r.RooDataSet("data histogram", "data", l)
+    
+    
+    for i in range(num_entries):
+        tree.GetEvent(i)
+        r.RooAbsRealLValue.__assign__(m, mass[0])
+        data_hist.add(l, 1.0)
+    
+    
+    #Creating the signal PDF as two crystall balls
+    
+    if l_flv[l_index]=='mu':
+        if mother_ID[mother_index]=='Dplus':
+            mean_d_startval=1.85
+            mean_d_up=1.95
+            mean_d_down=1.75
+        if mother_ID[mother_index]=='Ds':
+            mean_d_startval=1.95
+            mean_d_up=2.05
+            mean_d_down=1.85
+        
+    if l_flv[l_index]=='e':
+        if mother_ID[mother_index]=='Dplus':
+            mean_d_startval=1.85
+            mean_d_up=2.30
+            mean_d_down=1.70
+        if mother_ID[mother_index]=='Ds':
+            mean_d_startval=1.95
+            mean_d_up=2.30
+            mean_d_down=1.70
+
+    
+    #Creating D signal PDF left tail
+    mean_d= r.RooRealVar("mean_D","mean_D",mean_d_startval,mean_d_down,mean_d_up)
+    sigma_d = r.RooRealVar("sigma_D","sigma_D",0.020,0.,0.2)
+    
+    alpha_l = r.RooRealVar("alpha_D_l","alpha_D_l",-0.020,-10.,10.)
+    n_l = r.RooRealVar("n_D_l","n_D_l",0.020,-50.,50.)
+    sig_l = r.RooCBShape("signal_D_l","signal_D_l", m, mean_d, sigma_d, alpha_l, n_l)
+
+    #Creating D signal PDF right tail
+  
+    alpha_r = r.RooRealVar("alpha_D_r","alpha_D_r",0.020,-10.,10.)
+    n_r = r.RooRealVar("n_D_r","n_D_r",0.020,-50.,50.)
+    sig_r = r.RooCBShape("signal_D_r","signal_D_r", m, mean_d, sigma_d, alpha_r, n_r)
+
+    
+    #Add 2 sources of signal
+    # first add the sigs together 
+    frac = r.RooRealVar("# of Ds sig events","# of Ds sig events",0.5,0.,1.)
+    
+    model = r.RooAddPdf("model","two mass peaks",r.RooArgList(sig_l,sig_r),r.RooArgList(frac))
+    
+    fitr = model.fitTo(data_hist,r.RooFit.Save())
+
+    xframe = m.frame(r.RooFit.Title("Fit to "+l_flv[l_index]+" MC signal"))
+
+    data_hist.plotOn(xframe)
+    model.plotOn(xframe)
+    c = r.TCanvas()
+    xframe.Draw()
+    
+    n_param = fitr.floatParsFinal().getSize()
+    reduced_chi_square = xframe.chiSquare(n_param)
+    
+    CB_fraction=frac.getVal()
+    Nsig_from_MC=mc_mass.shape[0]
+    
+    a_l = alpha_l.getVal()
+    pwr_l= n_l.getVal()
+    
+    a_r= alpha_r.getVal()
+    pwr_r=n_r.getVal()
+    
+    print("chi2 {0}".format(reduced_chi_square))
+    c.SaveAs(l_flv[l_index]+"/fits/MC_"+mother_ID[mother_index]+"_fit.png")
+    
+    MC_fit_results={
+                 '# Fitting the MC signal':'\n',
+                 'CB fraction': CB_fraction,
+                 '# of signal in MC': Nsig_from_MC,
+                 'alpha_'+mother_ID[mother_index]+'_l': a_l, 
+                 'n_'+mother_ID[mother_index]+'_l': pwr_l, 
+                 'alpha_'+mother_ID[mother_index]+'_r': a_r, 
+                 'n_'+mother_ID[mother_index]+'_r': pwr_r,
+                 }
+    print('Saving MC fit results...')
+    with open(FIT_PATH+'/MC_'+mother_ID[mother_index]+'_fit_results.txt', 'w') as f:
+            
+            for key, value in MC_fit_results.items():
+                f.write('%s:%s\n' % (key, value))
+    with open(FIT_PATH+'/MC_'+mother_ID[mother_index]+'_CB_params.pickle','w') as handle:
+            
+            pickle.dump(MC_fit_results, handle)
+    print('Saved MC fit results \n Proceeding to fit script')
+    return MC_fit_results, a_l, pwr_l, a_r, pwr_r, CB_fraction
+
+
+
diff --git a/tools/mc_fitter.pyc b/tools/mc_fitter.pyc
new file mode 100644
index 0000000..20e194f
--- /dev/null
+++ b/tools/mc_fitter.pyc
Binary files differ
diff --git a/tools/select_and_fit_funct.py b/tools/select_and_fit_funct.py
new file mode 100644
index 0000000..1290973
--- /dev/null
+++ b/tools/select_and_fit_funct.py
@@ -0,0 +1,797 @@
+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 plot_MC_vs_data(data, weight_dict, MC, variable, 
+                    sw_idx=None, l_index=None, mother_index_fit=None):
+    
+    for key in MC:
+        if 'Ds' in key:
+            mother='Ds'
+            weight_idx = 1
+            variable_MC=variable
+        if 'Dplus' in key:
+            mother='Dplus'
+            weight_idx = 0
+            variable_MC=variable.replace("Ds","Dplus")
+    
+    inf=data[variable].min()
+    sup=data[variable].max()
+    
+    data_entries=data[variable].shape[0]
+    mc_entries=MC[variable_MC].shape[0]
+    
+    
+    
+    data_hist = r.TH1F(mother+" sWeighted data "+ variable,
+                       mother+" sWeighted data "+ variable,
+                       70,inf,sup)
+    
+    mc_hist = r.TH1F(mother+" MC "+ variable,
+                     mother+" MC "+ variable,
+                     70,inf,sup)
+    
+    mc_hist.Sumw2()
+    
+    for i in range(data_entries):
+        data_hist.Fill(data[variable][i],weight_dict[weight_idx][i])
+        
+    for i in range(len(MC[variable_MC])):    
+        mc_hist.Fill(MC[variable_MC][i])
+        
+    n1 = data_hist.Integral("width") 
+    data_hist.Scale(1/n1)
+    n2 = mc_hist.Integral("width")
+    mc_hist.Scale(1/n2)
+    
+    c1 = r.TCanvas(variable, variable, 900, 600)
+    
+    
+    mc_hist.Draw("E")
+    data_hist.Draw("E Same")
+    data_hist.GetXaxis().SetTitle(variable)
+    data_hist.GetYaxis().SetTitleOffset(1.5)
+    data_hist.GetYaxis().SetTitle("distr dN/d"+variable)
+    data_hist.SetLineColor(r.kRed)
+    r.gStyle.SetOptStat("11")
+    legend = r.TLegend(0.89, 0.89, 0.75, 0.8)
+    legend.AddEntry(data_hist,"data","f")
+    legend.AddEntry(mc_hist,"mc","f")
+    legend.Draw()
+    save_path=l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(sw_idx)+"/"+mother+"_sweighted_"+variable+"_{0}.png".format(sw_idx)
+    c1.SaveAs(save_path)
+    print("Saved: "+save_path)
+
+def select_and_fit(BDT_PATH, mother_index_fit, l_index, lower_mass_cut, upper_mass_cut,
+                   data_mass, mc_Dplus_mass, mc_Ds_mass, data_to_select, mc_Dplus_to_select=None, mc_Ds_to_select=None,
+                   data_dict=None, MC_Dplus_dict=None, MC_Ds_dict=None,  branches_needed=None,
+                   x_cut=None, iteration=None, test=None):
+
+    """
+    Get DCB Shapes
+
+    """
+
+    mc_Ds_mass_for_CB = np.array([MC_Ds_dict["Ds_ConsD_M"][i][0] for i in range(len(MC_Ds_dict["Ds_ConsD_M"]))])
+    mc_Dplus_mass_for_CB = np.array([MC_Dplus_dict["Dplus_ConsD_M"][i][0] for i in range(len(MC_Dplus_dict["Dplus_ConsD_M"]))])
+
+
+    BDT_PATH=l_flv[l_index]+'/BDTs/test_'+str(test)
+    FIT_PATH=l_flv[l_index]+'/fits'
+
+    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']
+            fraction_Ds=Ds_CB_params['CB fraction']
+    
+    
+    else:
+    
+        MC_Ds_fit_results, alpha_Ds_l, power_Ds_l, alpha_Ds_r, power_Ds_r, fraction_Ds = MC_fit( mc_Ds_mass_for_CB, 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']
+            fraction_Dplus=Dplus_CB_params['CB fraction']
+    
+    else:
+    
+        MC_Dplus_fit_results, alpha_Dplus_l, power_Dplus_l, alpha_Dplus_r, power_Dplus_r, fraction_Dplus = MC_fit(mc_Dplus_mass_for_CB, mother_index=1, l_index=l_index)
+
+
+    branches_needed_Dplus=[]
+    for label in branches_needed:
+        if 'Ds' in label:
+            branches_needed_Dplus.append(label.replace("Ds", "Dplus"))
+        else:
+            branches_needed_Dplus.append(label)
+
+    """
+    BDT Selection step
+
+    """
+    
+    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_data=loaded_model.predict_proba(data_to_select)
+    bdt_selection_data= np.where(output_XG_data[:,1]>x_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<data_mass_selected[i]<upper_mass_cut:
+
+            data_cut_indices.append(i)
+
+    mc_Dplus_indices=[]
+    for i in range(len(mc_Dplus_mass_selected)):
+        if lower_mass_cut<mc_Dplus_mass_selected[i]<upper_mass_cut:
+            
+            mc_Dplus_indices.append(i)
+
+    mc_Ds_indices=[]
+    for i in range(len(mc_Ds_mass_selected)):
+        if lower_mass_cut<mc_Ds_mass_selected[i]<upper_mass_cut:
+
+            mc_Ds_indices.append(i)
+
+
+    data_mass_cut=data_mass_selected[data_cut_indices]/1000.
+    
+    mc_Dplus_mass_selected/=1000.   
+    mc_Ds_mass_selected/=1000.
+
+    lower_mass_cut/=1000.
+    upper_mass_cut/=1000.
+
+    data_cut={}
+    
+    for label in branches_needed: 
+        data_cut[label] = data_bdt_sel[label][data_cut_indices]
+
+    MC_Dplus_cut={}
+
+    for label in branches_needed_Dplus: 
+        MC_Dplus_cut[label] = MC_Dplus_dict_sel[label][mc_Dplus_indices]
+
+    MC_Ds_cut={}
+
+    for label in branches_needed: 
+        MC_Ds_cut[label] = MC_Ds_dict_sel[label][mc_Ds_indices]
+
+    if mother_ID[mother_index_fit]=='both':
+
+        nsig_mass_cut_MC=len(mc_Dplus_indices)+len(mc_Ds_indices)
+        mass_cut_eff=np.float(nsig_mass_cut_MC)/np.float(nsig_bdt_sel_MC)
+
+    if mother_ID[mother_index_fit]=='Dplus':
+
+        nsig_mass_cut_MC=len(mc_Dplus_indices)
+        mass_cut_eff=np.float(nsig_mass_cut_MC)/np.float(nsig_bdt_sel_MC)
+
+    if mother_ID[mother_index_fit]=='Ds':
+        
+        nsig_mass_cut_MC=len(mc_Ds_indices)
+        mass_cut_eff=np.float(nsig_mass_cut_MC)/np.float(nsig_bdt_sel_MC)
+
+    sig_eff = sig_sel_eff*mass_cut_eff
+    
+
+    # sel_data_array= np.array( 
+    #                           [
+    #                           tuple( data_bdt_sel[label][k] for label in branches_needed )
+    #                           for k in range(len(data_bdt_sel[label]))
+    #                           ],
+    #                           dtype=[(label, np.float32) for label in branches_needed]
+    #                         )
+
+
+
+    #
+    data_mass_array=np.array(
+
+            [data_mass_cut[i] for i in range(len(data_mass_cut))], dtype=[('D_reco_M', np.float32)]
+
+            )
+    
+    rn.array2root(data_mass_array,
+                  filename='/disk/lhcb_data/davide/Rphipi/BDT_selected_data/'+l_flv[l_index]+l_flv[l_index]+'/BDT_sel_data_'+l_flv[l_index]+l_flv[l_index]+'_mass.root',
+                  treename='decay_tree',
+                  mode='recreate',
+                 )
+
+    f=r.TFile('/disk/lhcb_data/davide/Rphipi/BDT_selected_data/'+l_flv[l_index]+l_flv[l_index]+'/BDT_sel_data_'+l_flv[l_index]+l_flv[l_index]+'_mass.root')
+    tree=f.Get("decay_tree") 
+    
+
+    """
+    Create RooDataSet for mass
+
+    """
+
+    mass = np.array([0],dtype=np.float32)
+    branch = tree.GetBranch("D_reco_M")
+    branch.SetAddress(mass)
+    
+    num_entries=tree.GetEntries()
+    m = r.RooRealVar("D mass reco (GeV/c^2)","D mass reco (GeV/c^2)",lower_mass_cut,upper_mass_cut)
+    l = r.RooArgSet(m)
+    data_set = r.RooDataSet("data set", "data set", l)
+    
+    for i in range(num_entries):
+        tree.GetEvent(i)
+        r.RooAbsRealLValue.__assign__(m, mass[0])
+        data_set.add(l, 1.0)
+
+    """
+    Create total PDF
+
+    """
+
+    ##Creating D+ signal PDF left tail
+    mean_Dplus= r.RooRealVar("mean_Dplus","mean_Dplus",1.87,1.83,1.91)
+    sigma_Dplus = r.RooRealVar("sigma_Dplus","sigma_Dplus",0.020,0.,0.2)
+    
+    sig_frc_Dplus =r.RooRealVar("Dplus Double crystalball fraction","Dplus Double crystalball fraction",fraction_Dplus)
+    
+    al_Dplus_left = r.RooRealVar("alpha_Dplus_left","alpha_Dplus_left",alpha_Dplus_l)
+    pwr_Dplus_left = r.RooRealVar("n_Dplus_left","n_Dplus_left",power_Dplus_l)
+    sig_Dplus_left = r.RooCBShape("signal Dplus left","signal Dplus left", m, mean_Dplus, sigma_Dplus, al_Dplus_left, pwr_Dplus_left)
+    #Creating D+ signal PDF right tail
+  
+    al_Dplus_right = r.RooRealVar("alpha_Dplus_right","alpha_Dplus_right",alpha_Dplus_r)
+    pwr_Dplus_right = r.RooRealVar("n_Dplus_right","n_Dplus_right",power_Dplus_r)
+    sig_Dplus_right = r.RooCBShape("signal Dplus right","signal Dplus right", m, mean_Dplus, sigma_Dplus, al_Dplus_right, pwr_Dplus_right)
+   
+    #Adding the two CBs with their relative fraction
+    sig_Dplus = r.RooAddPdf("signal Dplus","Dplus mass peak",r.RooArgList(sig_Dplus_left, sig_Dplus_right),r.RooArgList(sig_frc_Dplus))
+    
+    #Creating Ds+ signal PDF
+    mean_Ds= r.RooRealVar("mean_Ds","mean_Ds",1.97,1.93,2.01)
+    sigma_Ds = r.RooRealVar("sigma_Ds","sigma_Ds",0.020,0.,0.2)
+    
+    sig_frc_Ds =r.RooRealVar("Ds Double crystalball fraction","Ds Double crystalball fraction",fraction_Ds)
+    
+    al_Ds_left = r.RooRealVar("alpha_Ds_left","alpha_Ds_left",alpha_Ds_l)
+    pwr_Ds_left = r.RooRealVar("n_Ds_left","n_Ds_left",power_Ds_l)
+    sig_Ds_left = r.RooCBShape("signal Ds left","signal Ds left", m, mean_Ds, sigma_Ds, al_Ds_left, pwr_Ds_left)
+    #Creating D+ signal PDF right tail
+  
+    al_Ds_right = r.RooRealVar("alpha_Ds_right","alpha_Ds_right",alpha_Ds_r)
+    pwr_Ds_right = r.RooRealVar("n_Ds_right","n_Ds_right",power_Ds_r)
+    sig_Ds_right = r.RooCBShape("signal Ds right","signal Ds right", m, mean_Ds, sigma_Ds, al_Ds_right, pwr_Ds_right)
+   
+    #Adding the two CBs with their relative fraction
+    sig_Ds = r.RooAddPdf("sig_Ds","Ds mass peak",r.RooArgList(sig_Ds_left, sig_Ds_right),r.RooArgList(sig_frc_Ds))
+    
+    #Model the background
+    
+    coef0 = r.RooRealVar("c0","coefficient #0",1.0,-10.,10)
+    coef1 = r.RooRealVar("c1","coefficient #1",0.1,-10.,10)
+    #coef2 = r.RooRealVar("c2","coefficient #2",-0.1,-10.,10)
+    bkg = r.RooChebychev("bkg","background p.d.f.",m,r.RooArgList(coef0,coef1))#coeff2))
+    
+    #add it altogether
+    
+    #Add 2 sources of signal
+    if mother_ID[mother_index_fit]=='both':
+
+        NDs = r.RooRealVar("nDs","nDs",100.,0.,40000.)
+        NDplus = r.RooRealVar("nDplus","nDplus",100.,0.,40000.)
+        nbkg = r.RooRealVar("nbkg","nbkg",100.,0.,40000.)
+        model = r.RooAddPdf("model","Dplus and Ds mass peaks",r.RooArgList(sig_Ds, sig_Dplus, bkg),r.RooArgList(NDs, NDplus,nbkg))
+
+    if mother_ID[mother_index_fit]=='Ds':
+        NDs = r.RooRealVar("nDs","nDs",100.,0.,40000.)
+        nbkg = r.RooRealVar("nbkg","nbkg",100.,0.,40000.)
+        model = r.RooAddPdf("model","Ds mass peak",r.RooArgList(sig_Ds, bkg),r.RooArgList(NDs,nbkg))
+
+    if mother_ID[mother_index_fit]=='Dplus':
+
+        NDplus = r.RooRealVar("nDplus","nDplus",100.,0.,40000.)
+        nbkg = r.RooRealVar("nbkg","nbkg",100.,0.,40000.)
+        model = r.RooAddPdf("model","Dplus mass peak",r.RooArgList(sig_Dplus, bkg),r.RooArgList(NDplus,nbkg))
+    
+    """
+    Fit step
+
+
+    """
+
+    fitr = model.fitTo(data_set,r.RooFit.Extended(),r.RooFit.Save())
+    xframe = m.frame(r.RooFit.Title("Fit to "+l_flv[l_index]+" data"))
+
+    bkg_component = r.RooArgSet(bkg)
+    sig_Dplus_component = r.RooArgSet(sig_Dplus)
+    sig_Ds_component = r.RooArgSet(sig_Ds)
+    #sig_D_component = r.RooArgSet(sig_Dplus_component,sig_Ds_component)
+
+    data_set.plotOn(xframe)
+    model.plotOn(xframe)
+    hpull=xframe.pullHist()
+
+    n_param = fitr.floatParsFinal().getSize()
+    reduced_chi_square = xframe.chiSquare(n_param)
+
+    """
+    Plot the fit results
+
+    """
+
+    model.plotOn(xframe,r.RooFit.Components(bkg_component),r.RooFit.LineStyle(2))
+
+    if mother_ID[mother_index_fit]=='Dplus':
+
+        model.plotOn(xframe, r.RooFit.Components(sig_Dplus_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+
+    if mother_ID[mother_index_fit]=='Ds':
+
+        model.plotOn(xframe, r.RooFit.Components(sig_Ds_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+
+    if mother_ID[mother_index_fit]=='both':
+
+        model.plotOn(xframe, r.RooFit.Components(sig_Ds_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+        model.plotOn(xframe, r.RooFit.Components(sig_Dplus_component), r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+
+
+    model.paramOn(xframe, r.RooFit.Layout(0.69,0.99,0.92), r.RooFit.Format("NEU", r.RooFit.AutoPrecision(1)))
+    xframe.getAttText().SetTextSize(0.04)
+
+    xframe2 = m.frame(r.RooFit.Title("Pulls"))
+    xframe2.addPlotable(hpull,"P")
+
+    c = r.TCanvas("Fit {0}".format(iteration),"Fit {0}".format(iteration),900,600)
+    pad1 = r.TPad("pad1", "pad1", 0, 0.35, 1, 1.0)
+    pad1.SetBottomMargin(0)
+    pad1.Draw()
+    c.cd()
+    pad2 = r.TPad("pad2", "pad2", 0, 0.05, 1, 0.35)
+    pad2.SetTopMargin(0)
+    pad2.SetBottomMargin(0.2)
+    pad2.SetGridx()
+    pad2.SetGridy()
+    pad2.Draw()
+
+    pad1.cd()
+    xframe.Draw()
+    #xframe.GetYaxis().SetLabelOffset(-0.01)
+    pad2.cd()
+    xframe2.Draw()
+    xframe2.GetXaxis().SetTitleSize(0.09)
+    xframe2.GetXaxis().SetLabelSize(0.1)
+    xframe2.GetYaxis().SetLabelSize(0.05)
+
+
+    print("chi2 {0}".format(reduced_chi_square))
+    c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}/fit_{1}.png".format(iteration,iteration))
+    
+    """
+    Create .pickle files with discriminating variables of selected data
+
+    """
+    # rn.array2root(sel_data_array,
+    #               filename='/disk/lhcb_data/davide/Rphipi/BDT_selected_data/'+l_flv[l_index]+l_flv[l_index]+'/BDT_sel_data_'+l_flv[l_index]+l_flv[l_index]+'_geom_var.root',
+    #               treename='decay_tree',
+    #               mode='recreate',
+    #              )
+    # rn.array2root(MC_Ds_array,
+    #               filename='/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]+'_geom_var.root',
+    #               treename='decay_tree',
+    #               mode='recreate',
+    #              )
+    # rn.array2root(MC_Dplus_array,
+    #               filename='/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]+'_geom_var.root',
+    #               treename='decay_tree',
+    #               mode='recreate',
+    #              )
+    
+    with open('/disk/lhcb_data/davide/Rphipi/BDT_selected_data/'+l_flv[l_index]+l_flv[l_index]+'/BDT_sel_data_'+l_flv[l_index]+l_flv[l_index]+'_geom_var.pickle', 'wb') as handle:
+        pickle.dump(data_cut, handle, protocol=pickle.HIGHEST_PROTOCOL)
+    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]+'_geom_var.pickle', 'wb') as handle:
+        pickle.dump(MC_Ds_cut, handle, protocol=pickle.HIGHEST_PROTOCOL)
+    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]+'_geom_var.pickle', 'wb') as handle:
+        pickle.dump(MC_Dplus_cut, handle, protocol=pickle.HIGHEST_PROTOCOL)
+
+
+    xframe_sw = m.frame(r.RooFit.Title("Weighted "+l_flv[l_index]+" data"))
+
+    """
+    sPlotting
+
+    """
+
+    if mother_ID[mother_index_fit]=='both':
+
+        splot = r.RooStats.SPlot(
+        'sData','sData', data_set, model,
+        r.RooArgList(NDs, NDplus, nbkg)
+
+        )
+
+        Ds_sw=splot.GetSWeightVars()[0]
+        Dplus_sw=splot.GetSWeightVars()[1]
+        bkg_sw=splot.GetSWeightVars()[2]
+
+        argset = r.RooArgSet(m, Ds_sw)
+        dataset_Ds_w = r.RooDataSet("Ds weighted dataset","Ds weighted dataset",data_set, argset,"","nDs_sw")
+
+        argset = r.RooArgSet(m, Dplus_sw)
+        dataset_Dplus_w = r.RooDataSet("Dplus weighted dataset","Dplus weighted dataset",data_set, argset,"","nDplus_sw")
+
+        
+        dataset_Ds_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kBlue))
+        dataset_Dplus_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kRed))
+
+
+        Ds_sw.setRange(-1.2,1.5)
+        frame_Ds_sw = Ds_sw.frame(r.RooFit.Title("signal Ds sWeights"))
+        data_set.plotOn(frame_Ds_sw, r.RooFit.MarkerSize(0.05))
+
+        Dplus_sw.setRange(-1.2,1.5)
+        frame_Dplus_sw = Dplus_sw.frame(r.RooFit.Title("signal Dplus sWeights"))
+        data_set.plotOn(frame_Dplus_sw, r.RooFit.MarkerSize(0.05))
+           
+        bkg_sw.setRange(-.6,1.2)
+        frame_bkg_sw = bkg_sw.frame(r.RooFit.Title("background sWeights"))
+        data_set.plotOn(frame_bkg_sw, r.RooFit.MarkerSize(0.05))
+           
+
+        sframe = m.frame(r.RooFit.Title("m vs sWeights"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(Ds_sw),
+                        r.RooFit.MarkerColor(r.kGreen), r.RooFit.Name("Ds_sig"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(Dplus_sw),
+                        r.RooFit.MarkerColor(r.kBlue), r.RooFit.Name("Dplus_sig"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(bkg_sw),
+                        r.RooFit.MarkerColor(r.kRed), r.RooFit.Name("bkg"))
+
+        legend = r.TLegend(0.89, 0.89, 0.5, 0.7)
+        legend.AddEntry(sframe.findObject('Ds_sig'), 'Signal Ds sWeights', 'p')
+        legend.AddEntry(sframe.findObject('Dplus_sig'), 'Signal Dplus sWeights', 'p')
+        legend.AddEntry(sframe.findObject('bkg'), 'Background sWeights', 'p')
+        #
+        c = r.TCanvas("sWeighted mass dist {0}".format(iteration),"sWeighted mass dist {0}".format(iteration),900,600)
+        xframe_sw.Draw()
+        c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweighted_mass_plot_fit{0}.png".format(iteration))
+
+
+        c = r.TCanvas("sWeights {0}".format(iteration),"sWeights {0}".format(iteration),900,900)
+        c.Divide(2,2)
+        c.cd(1)
+        frame_Ds_sw.Draw()
+        c.cd(2)
+        frame_Dplus_sw.Draw()
+        c.cd(3)
+        frame_bkg_sw.Draw()
+        c.cd(4)
+        sframe.Draw()
+        legend.Draw()
+        c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweights_{0}.png".format(iteration))
+
+
+        nbkg_w = splot.GetYieldFromSWeight("nbkg_sw")
+        nDs_w = splot.GetYieldFromSWeight("nDs_sw")
+        nDplus_w = splot.GetYieldFromSWeight("nDplus_sw")
+        raw_sig=nDs_w+nDplus_w
+
+    if mother_ID[mother_index_fit]=='Ds':
+
+        splot = r.RooStats.SPlot(
+        'sData','sData', data_set, model,
+        r.RooArgList(NDs, nbkg)
+
+        )
+        
+        Ds_sw=splot.GetSWeightVars()[0]
+        bkg_sw=splot.GetSWeightVars()[1]
+
+        argset = r.RooArgSet(m, Ds_sw)
+        dataset_Ds_w = r.RooDataSet("Ds weighted dataset","Ds weighted dataset",data_set, argset,"","nDs_sw")
+
+        dataset_Ds_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kBlue))
+
+        Ds_sw.setRange(-3.,1.4)
+        frame_Ds_sw = Ds_sw.frame(r.RooFit.Title("signal Ds sWeights"))
+        data_set.plotOn(frame_Ds_sw, r.RooFit.MarkerSize(0.05))
+           
+        bkg_sw.setRange(-.5,5.)
+        frame_bkg_sw = bkg_sw.frame(r.RooFit.Title("background sWeights"))
+        data_set.plotOn(frame_bkg_sw, r.RooFit.MarkerSize(0.05))
+           
+        sframe = m.frame(r.RooFit.Title("m vs sWeights"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(Ds_sw),
+                        r.RooFit.MarkerColor(r.kGreen), r.RooFit.Name("Ds_sig"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(bkg_sw),
+                        r.RooFit.MarkerColor(r.kRed), r.RooFit.Name("bkg"))
+
+        legend = r.TLegend(0.89, 0.89, 0.75, 0.8)
+        legend.AddEntry(sframe.findObject('Ds_sig'), 'Signal Ds sWeights', 'p')
+        legend.AddEntry(sframe.findObject('bkg'), 'Background sWeights', 'p')
+        #
+        c = r.TCanvas("sWeighted mass dist {0}".format(iteration),"sWeighted mass dist {0}".format(iteration),900,600)
+        xframe_sw.Draw()
+        c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweighted_mass_plot_fit{0}.png".format(iteration))
+
+
+        c = r.TCanvas("sWeights {0}".format(iteration),"sWeights  {0}".format(iteration),900,600)
+        c.cd()
+        pad1 = r.TPad("pad1", "pad1", 0, 0.5, 0.5, 1.0)
+        pad1.Draw()
+        c.cd()
+        pad2 = r.TPad("pad2", "pad2", 0.5, 0.5, 1.0, 1.0)
+        pad2.Draw()
+        c.cd()
+        pad3 = r.TPad("pad3", "pad3", 0, 0.05, 1, 0.50)
+        pad3.SetGridx()
+        pad3.Draw()
+        
+
+        pad1.cd()
+        frame_Ds_sw.Draw()
+        pad2.cd()
+        frame_bkg_sw.Draw()
+        pad3.cd()
+        sframe.Draw()
+        legend.Draw()
+
+        c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweights_{0}.png".format(iteration))
+
+
+        nbkg_w = splot.GetYieldFromSWeight("nbkg_sw")
+        nDs_w = splot.GetYieldFromSWeight("nDs_sw")
+        raw_sig=nDs_w
+
+    if mother_ID[mother_index_fit]=='Dplus':
+
+        splot = r.RooStats.SPlot(
+        'sData','sData', data_set, model,
+        r.RooArgList(NDplus, nbkg)
+
+        )
+
+        Dplus_sw=splot.GetSWeightVars()[0]
+        bkg_sw=splot.GetSWeightVars()[1]
+
+        argset = r.RooArgSet(m, Dplus_sw)
+        dataset_Dplus_w = r.RooDataSet("Dplus weighted dataset","Dplus weighted dataset",data_set, argset,"","nDplus_sw")
+
+        #model.plotOn(xframe_sw, r.RooFit.Components(sig_Dplus_component),r.RooFit.LineColor(2),r.RooFit.LineStyle(2) )
+        dataset_Dplus_w.plotOn(xframe_sw, r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kRed))
+
+
+        Dplus_sw.setRange(-1.2,1.8)
+        frame_Dplus_sw = Dplus_sw.frame(r.RooFit.Title("signal Dplus sWeights"))
+        data_set.plotOn(frame_Dplus_sw, r.RooFit.MarkerSize(0.05))
+           
+        bkg_sw.setRange(-1.2,2.1)
+        frame_bkg_sw = bkg_sw.frame(r.RooFit.Title("background sWeights"))
+        data_set.plotOn(frame_bkg_sw, r.RooFit.MarkerSize(0.05))
+           
+
+        sframe = m.frame(r.RooFit.Title("m vs sWeights"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(Dplus_sw),
+                        r.RooFit.MarkerColor(r.kBlue), r.RooFit.Name("Dplus_sig"))
+        data_set.plotOnXY(sframe, r.RooFit.YVar(bkg_sw),
+                        r.RooFit.MarkerColor(r.kRed), r.RooFit.Name("bkg"))
+
+        legend = r.TLegend(0.89, 0.89, 0.75, 0.8)
+        legend.AddEntry(sframe.findObject('Dplus_sig'), 'Signal Dplus sWeights', 'p')
+        legend.AddEntry(sframe.findObject('bkg'), 'Background sWeights', 'p')
+        #
+        c = r.TCanvas("sWeighted mass dist {0}".format(iteration),"sWeighted mass dist {0}".format(iteration),900,600)
+        xframe_sw.Draw()
+        c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweighted_mass_plot_fit{0}.png".format(iteration))
+
+
+        c = r.TCanvas("sWeights {0}".format(iteration),"sWeights  {0}".format(iteration),900,600)
+        c.cd()
+        pad1 = r.TPad("pad1", "pad1", 0, 0.5, 0.5, 1.0)
+        pad1.Draw()
+        c.cd()
+        pad2 = r.TPad("pad2", "pad2", 0.5, 0.5, 1.0, 1.0)
+        pad2.Draw()
+        c.cd()
+        pad3 = r.TPad("pad3", "pad3", 0, 0.05, 1, 0.50)
+        pad3.SetGridx()
+        pad3.Draw()
+        
+
+        pad1.cd()
+        frame_Dplus_sw.Draw()
+        pad2.cd()
+        frame_bkg_sw.Draw()
+        pad3.cd()
+        sframe.Draw()
+        legend.Draw()
+
+        c.SaveAs(l_flv[l_index]+"/fits/"+mother_ID[mother_index_fit]+"/{0}".format(iteration)+"/sweights_{0}.png".format(iteration))
+
+
+        nbkg_w = splot.GetYieldFromSWeight("nbkg_sw")
+        nDplus_w = splot.GetYieldFromSWeight("nDplus_sw")
+        raw_sig=nDplus_w
+
+    
+    """
+    Save fit results
+
+
+    """
+
+    fom=(nsig_from_MC)/np.sqrt(nbkg_w+nsig_from_MC)
+
+    eff_corrected_sig = (raw_sig)/(sig_sel_eff)
+
+    fit_results={
+                 '# background': nbkg_w,
+                 #'err bkg': err_bkg,
+                 '# fitted signal': raw_sig,
+                 #'error sig': raw_sig_err,
+                 'signal selection efficiency from BDT cut': sig_sel_eff,
+                 'sig selection efficiency from mass cut': mass_cut_eff,
+                 'overall signal efficiency': sig_eff,
+                 'S/sqrt(S+B)': fom,
+                 'efficiency corrected yeld': eff_corrected_sig,
+                 'chi 2': reduced_chi_square
+                 }
+
+
+
+    return fit_results, splot
+
+def plot_weighted(f, var_name, splot, i):
+    
+    
+    tree=f.Get("decay_tree")
+    proxy_array = np.array([0],dtype=np.float32)
+    branch = tree.GetBranch(var_name)
+    branch.SetAddress(proxy_array)
+    
+    num_entries=tree.GetEntries()
+    real_var = r.RooRealVar(var_name, var_name, tree.GetMinimum(var_name), tree.GetMaximum(var_name))
+    l = r.RooArgSet(real_var)
+    
+    var_data_set = r.RooDataSet(var_name+"_data_set", var_name+"_data_set", l)
+    
+    for j in range(num_entries):
+        tree.GetEvent(j)
+        r.RooAbsRealLValue.__assign__(real_var, proxy_array[0])
+        var_data_set.add(l, 1.0)
+    
+    weight_set = splot.GetSWeightVars()[i]
+    weight_name = weight_set.GetName()
+    
+    argset = r.RooArgSet(real_var, weight_set)
+    var_data_set_sw = r.RooDataSet(var_name+"_weighted_"+weight_name,
+                                   var_name+"_weighted_"+weight_name,
+                                   var_data_set, argset, "", weight_name)
+    
+    xframe_sw = real_var.frame(r.RooFit.Title(l_flv[l_index]+" "+weight_name+" weighted "+var_name))
+    
+    var_data_set_sw.plotOn(xframe_sw,r.RooFit.MarkerSize(0.5), r.RooFit.MarkerColor(r.kBlue))
+    
+    xframe_sw.Draw()
+    
+    return xframe_sw
+
+    
+    
\ No newline at end of file
diff --git a/tools/select_and_fit_funct.pyc b/tools/select_and_fit_funct.pyc
new file mode 100644
index 0000000..ec54645
--- /dev/null
+++ b/tools/select_and_fit_funct.pyc
Binary files differ
diff --git a/tools/utils/NN_building_blocks.py b/tools/utils/NN_building_blocks.py
new file mode 100644
index 0000000..66bdf4e
--- /dev/null
+++ b/tools/utils/NN_building_blocks.py
@@ -0,0 +1,1187 @@
+#BUILDING BLOCKS
+rnd_seed=1
+
+import numpy as np
+import math
+import tensorflow as tf
+from architectures.utils.toolbox import *
+
+
+# DENSELY CONNECTED NETWORKS
+
+class DenseLayer(object):
+
+    """
+    Creates a dense layer
+
+    Constructor inputs:
+        - name of layer
+        - mi: (int) dimension of input to layer
+        - mo: (int) dimension of output of the activated output
+        - apply_batch_norm: (bool) wether applying or not batch_normalization along the 0 axis of input
+        - f: (function) activation function of the output
+        - w_init: (tensorflow initializer) which initializer to use for the layer weights
+
+    Created attributes:
+
+        - W: (tf variable) (mi x mo) weight matrix
+        - bi: (tf variable) (mo, ) bias vector
+        - bo: (tf variable) (mi, ) bias vector
+    
+    Class methods:
+
+        - forward:
+            input: X (tf tensor) previous output layer
+            outputs: output (tf tensor) activated layer output as A = act_f(X * W+ bi)
+
+        - set_session:
+            Sets current session
+            input:
+                session: (tf session) current session
+    """
+    
+    def __init__(self, name, mi, mo, apply_batch_norm,
+                keep_prob=1., act_f=None, w_init=None
+                ):
+        
+            
+                self.W = tf.get_variable(
+                    "W_%s" %name,
+                    shape=(mi,mo),
+                    initializer=w_init,
+                )
+
+                
+                self.bi = tf.get_variable(
+                    "bi_%s" %name,
+                    shape=(mo,),
+                    initializer=tf.zeros_initializer(),
+                )
+
+                
+                self.act_f=act_f
+                self.name=name
+                self.apply_batch_norm=apply_batch_norm
+                self.keep_prob = keep_prob
+    
+    def forward(self, X, reuse, is_training):
+        
+        if not is_training:
+            self.keep_prob=1.
+
+        Z=tf.matmul(X,self.W)+self.bi
+
+        if self.apply_batch_norm=='bn':
+            Z=tf.contrib.layers.batch_norm(
+                Z,
+                decay=0.9,
+                updates_collections=None,
+                epsilon=1e-5,
+                scale=True,
+                is_training = is_training,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='in':
+            Z = tf.contrib.layers.instance_norm(
+                Z,
+                center=True,
+                scale=True,
+                epsilon=1e-6,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='False':
+            Z = Z
+        
+        activated=self.act_f(Z)
+
+        output=tf.nn.dropout(activated, self.keep_prob, seed=rnd_seed)
+
+        return output
+
+    def set_session(self, session):
+        
+        self.session = session
+
+#2D CONVOLUTIONAL NETWORKS
+
+class AvgPool2D(object):
+
+    """
+    Performs average 2D pooling of the input, with no dropout by default
+    Note that this layer trains no parameters
+
+    Constructor input:
+        - filter_sz: (int) width and height of the square pooling window 
+        - stride: (int) horizontal and vertical value for the stride
+
+        ?extend to square windows and stride?
+
+    Class methods:
+
+        forward:
+            inputs:
+                - X (tf tensor) previous activated layer output
+                - output (tf tensor) average pooled layer output
+
+    """
+
+    def __init__(self, filter_sz, stride, keep_prob=1):
+
+        self.filter_sz = filter_sz
+        self.stride = stride
+        self.keep_prob = keep_prob
+
+    def forward(self, X, reuse, is_training):
+
+        if not is_training:
+            self.keep_prob=1
+
+        output = X
+
+        output = tf.nn.avg_pool(X, 
+            ksize=[1, self.filter_sz,self.filter_sz,1],
+            strides=[1,self.stride, self.stride, 1],
+            padding = 'SAME'
+            )
+        output = tf.nn.dropout(output, self.keep_prob, seed=rnd_seed)
+
+        return output
+
+    def set_session(self, session):
+
+        self.session = session
+
+class MaxPool2D(object):
+
+    """
+    Performs max 2D pooling of the input, with no dropout by default
+    Note that this layer trains no parameters
+
+    Constructor input:
+        - filter_sz: (int) width and height of the square pooling window 
+        - stride: (int) horizontal and vertical value for the stride
+
+        ?extend to square windows and stride?
+
+    Class methods:
+
+        forward:
+            inputs:
+                - X (tf tensor) previous activated layer output
+                - output (tf tensor) max pooled layer output
+
+    """
+
+    def __init__(self, filter_sz, stride, keep_prob=1):
+
+        self.filter_sz = filter_sz
+        self.stride = stride
+        self.keep_prob = keep_prob
+
+    def forward(self, X, reuse, is_training):
+
+        output = X
+
+        if not is_training:
+            self.keep_prob=1
+
+        output = tf.nn.max_pool(output, 
+            ksize=[1, self.filter_sz,self.filter_sz,1],
+            strides=[1,self.stride, self.stride, 1],
+            padding = 'SAME'
+            )
+
+        output = tf.nn.dropout(output, self.keep_prob, seed=rnd_seed)
+        return output
+
+    def set_session(self, session):
+
+        self.session = session
+
+class ConvLayer(object):
+    
+    """
+    Performs 2D strided convlution on rectangular sized input tensor. 
+
+    Constructor inputs:
+
+        - mi: (int) input channels
+        - mo: (int) output channels
+        - filter_sz: (int) width and height of the convolution kernel
+        - stride: (int) horizontal and vertical size of the stride
+        - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+        - keep_prob: (int) dropout keep probability of propagated tensor
+        - f: (function) activation layer function. tf.nn.relu by default
+        - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+
+    Class attributes
+
+        - W: (tf tensor) variable tensor of dim (filter_sz, filter_sz, mi, mo) of trainable weights
+        - b: (tf tensor) variable tensor of dim (mo, ) of trainable biases
+
+    Class methods:
+
+        - forward: 
+            inputs:
+                X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+                reuse: (bool) whether reusing the stored batch_normalization parameters or not
+                is_training: (bool) flag that indicates whether we are in the process of training or not
+            outputs:
+                output: (tf tensor) activated output of dim (batch_sz, n_W, n_H, mo), input for next layer
+        
+        - set_session:
+            Sets current session
+            inputs:
+                session: (tf session) current session
+
+
+    """
+
+
+
+    def __init__(
+            self, name, mi, mo, filter_sz, stride, 
+                 apply_batch_norm, keep_prob = 1, 
+                 f = None, w_init = None
+            ):
+                
+            self.W = tf.get_variable(
+                "W_%s" %name,
+                shape=(filter_sz,filter_sz, mi, mo),
+                initializer=w_init,
+            )
+            
+
+            self.b = tf.get_variable(
+                "b_%s" %name,
+                shape = (mo,),
+                initializer=tf.zeros_initializer(),
+            )
+            
+            self.name = name
+            self.f = f
+            self.stride = stride
+            self.apply_batch_norm = apply_batch_norm
+            self.keep_prob=keep_prob
+        
+    def forward(self, X, reuse, is_training):
+        
+        if not is_training:
+            self.keep_prob=1
+
+        conv_out = tf.nn.conv2d(
+            X,
+            self.W,
+            strides=[1,self.stride,self.stride,1],
+            padding='SAME'
+        )
+
+        
+        conv_out = tf.nn.bias_add(conv_out,self.b)
+        
+        #applying batch_norm
+        if self.apply_batch_norm=='bn':
+            conv_out=tf.contrib.layers.batch_norm(
+                conv_out,
+                decay=0.9,
+                updates_collections=None,
+                epsilon=1e-5,
+                scale=True,
+                is_training = is_training,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='in':
+            conv_out = tf.contrib.layers.instance_norm(
+                conv_out,
+                center=True,
+                scale=True,
+                epsilon=1e-6,
+                reuse=reuse,
+                scope = self.name,
+            )
+        else:
+            return conv_out
+
+        activated = self.f(conv_out)
+
+        output = tf.nn.dropout(activated, self.keep_prob, seed=rnd_seed)  
+        
+        return output 
+    
+    def set_session(self, session):
+        
+        self.session = session
+
+class LocalConvLayer(object):
+    
+    """
+    Performs 2D strided local convlution on rectangular sized input tensor. 
+
+    Constructor inputs:
+
+        - mi: (int) input channels
+        - mo: (int) output channels
+        - filter_sz: (int) width and height of the convolution kernel
+        - stride: (int) horizontal and vertical size of the stride
+        - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+        - keep_prob: (int) dropout keep probability of propagated tensor
+        - f: (function) activation layer function. tf.nn.relu by default
+        - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+
+    Class attributes
+
+        - W: (tf tensor) variable tensor of dim (filter_sz, filter_sz, mi, mo) of trainable weights
+        - b: (tf tensor) variable tensor of dim (mo, ) of trainable biases
+
+    Class methods:
+
+        - forward: 
+            inputs:
+                X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+                reuse: (bool) whether reusing the stored batch_normalization parameters or not
+                is_training: (bool) flag that indicates whether we are in the process of training or not
+            outputs:
+                output: (tf tensor) activated output of dim (batch_sz, n_W, n_H, mo), input for next layer
+        
+        - set_session:
+            Sets current session
+            inputs:
+                session: (tf session) current session
+
+
+    """
+
+    def __init__(
+            self, name, mi, mo, local_sz, filter_sz, stride, 
+                 apply_batch_norm, keep_prob = 1, 
+                 f = None, w_init = None
+            ):
+            
+            patch_sz = (local_sz**2)*mi
+
+            self.W = tf.get_variable(
+                "W_%s" %name,
+                shape=(filter_sz,filter_sz, patch_sz, mo),
+                initializer=w_init,
+            )
+
+            self.b = tf.get_variable(
+                "b_%s" %name,
+                shape = (mo,),
+                initializer=tf.zeros_initializer(),
+            )
+            
+            self.name = name
+            self.f = f
+            self.stride = stride
+            self.apply_batch_norm = apply_batch_norm
+            self.keep_prob=keep_prob
+        
+    def forward(self, X, reuse, is_training):
+        
+        if not is_training:
+            self.keep_prob=1
+
+        conv_out = tf.nn.conv2d(
+            X,
+            self.W,
+            strides=[1,self.stride,self.stride,1],
+            padding='SAME'
+        )
+
+        
+        conv_out = tf.nn.bias_add(conv_out,self.b)
+        
+        #applying batch_norm
+        if self.apply_batch_norm=='bn':
+            conv_out=tf.contrib.layers.batch_norm(
+                conv_out,
+                decay=0.9,
+                updates_collections=None,
+                epsilon=1e-5,
+                scale=True,
+                is_training = is_training,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='in':
+            conv_out = tf.contrib.layers.instance_norm(
+                conv_out,
+                center=True,
+                scale=True,
+                epsilon=1e-6,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='False':
+            return conv_out
+
+        activated = self.f(conv_out)
+
+        output = tf.nn.dropout(activated, self.keep_prob, seed=rnd_seed)  
+        
+        return output 
+    
+    def set_session(self, session):
+        
+        self.session = session
+
+
+class DeconvLayer(object):
+  
+    """
+    Performs 2D strided deconvlution on rectangular sized input tensor. 
+
+    Constructor inputs:
+
+        - mi: (int) input channels
+        - mo: (int) output channels
+        - output_shape: list = [int, int], list[0]([1]) is the witdth (height) of the output after deconvolution, the layer computes the resizing
+                                automatically to match the output_shape. Default padding value is of 2 in both directions but can be modified.
+        - filter_sz: (int) width and height of the convolution kernel
+        - stride: (int) horizontal and vertical size of the stride
+        - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+        - keep_prob: (int) dropout keep probability of propagated tensor
+        - f: (function) activation layer function. tf.nn.relu by default
+        - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+
+    Class attributes
+
+        - W: (tf tensor) variable tensor of dim (filter_sz, filter_sz, mo, mo) of trainable weights
+        - W_id: (tf tensor) variable tensor of dim (1, 1, mi, mo) of trainable weights
+        - b: (tf tensor) variable tensor of dim (mo, ) of trainable biases
+
+    Class methods:
+
+        - forward: 
+            inputs:
+                X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+                reuse: (bool) whether reusing the stored batch_normalization parameters or not
+                is_training: (bool) flag that indicates whether we are in the process of training or not
+
+                The deconvolution is computed in 3 steps according to: (cite article)
+                1) conv2d with W_id is performed to match the output channels mo, with filter_sz=1 and stride=1
+                2) the image is reshaped to reshape_size_H and W 
+                3) conv2d with W is performed with input filter_sz and stride, output width and height will match output_shape
+
+            outputs:
+                output: (tf tensor) activated output of dim (batch_sz, n_W=output_shape[0], n_H = output_shape[1], mo), input for next layer
+        
+        - set_session:
+            Sets current session
+            inputs:
+                session: (tf session) current session
+
+
+    """  
+    def __init__(self, name, 
+                mi, mo, output_shape, 
+                filter_sz, stride, 
+                apply_batch_norm, keep_prob = 1,
+                f=None, w_init = None
+                ):
+
+                #using resize + conv2d and not conv2dt
+                #mi: input channels
+                #mo: output channels
+                #output_shape: width and height of the output image
+                
+                #performs 2 convolutions, the first augments the number of channels
+                #the second performs a convolution with != 1 kernel and stride
+                self.W = tf.get_variable(
+                    "W_%s" %name,
+                    shape=(filter_sz, filter_sz, mo, mo),
+                    initializer=w_init,
+                )
+                self.W_id = tf.get_variable(
+                    'W_%s_id' %name,
+                    shape=(1,1,mi, mo),
+                    initializer=w_init,
+                )
+                
+
+                self.b = tf.get_variable(
+                    "b_%s" %name,
+                    shape=(mo,),
+                    initializer=tf.zeros_initializer(),
+                )
+
+                self.f = f
+                self.stride = stride
+                self.filter_sz = filter_sz
+                self.name = name
+                self.output_shape = output_shape
+                self.apply_batch_norm = apply_batch_norm
+                self.keep_prob = keep_prob
+
+    def forward(self, X, reuse, is_training):
+
+        if not is_training:
+            self.keep_prob = 1
+        
+        padding_value = 0
+        resized_shape_H = (self.output_shape[0] -1)*self.stride+ self.filter_sz-2*padding_value
+        resized_shape_W = (self.output_shape[1] -1)*self.stride+ self.filter_sz-2*padding_value
+        
+        
+        resized = tf.image.resize_images(X, 
+                                          [resized_shape_H,
+                                           resized_shape_W],
+                                          method=tf.image.ResizeMethod.BILINEAR)
+        
+        #print('After first resize shape', resized.get_shape())
+        
+        output_id = tf.nn.conv2d(
+            resized,
+            self.W_id,
+            strides=[1,1,1,1],
+            padding='VALID'
+        )
+
+        #print('After id deconvolution shape', output_id.get_shape())
+        
+        paddings = tf.constant([[0,0],
+                                [padding_value, padding_value], 
+                                [padding_value, padding_value], 
+                                [0,0]])
+        
+        output_id = tf.pad(output_id,
+                          paddings, 'CONSTANT'
+                          )
+        
+        #print('After padding', output_id.get_shape())
+
+        conv_out = tf.nn.conv2d(
+            output_id,
+            self.W,
+            strides=[1,self.stride,self.stride,1],
+            padding='VALID'
+        )
+        
+        #print('After deconvolution', conv_out.get_shape())
+        conv_out = tf.nn.bias_add(conv_out,self.b)
+
+        if self.apply_batch_norm=='bn':
+            conv_out=tf.contrib.layers.batch_norm(
+                conv_out,
+                decay=0.9,
+                updates_collections=None,
+                epsilon=1e-5,
+                scale=True,
+                is_training = is_training,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='in':
+            conv_out = tf.contrib.layers.instance_norm(
+                conv_out,
+                center=True,
+                scale=True,
+                epsilon=1e-6,
+                reuse=reuse,
+                scope = self.name,
+            )
+        elif self.apply_batch_norm=='False':
+            return conv_out
+
+        activated = self.f(conv_out) 
+        output = tf.nn.dropout(activated, self.keep_prob, seed=rnd_seed)
+
+        return output
+
+    def set_session(self, session):
+        
+        self.session = session
+
+class ConvBlock(object):
+
+    """
+    Performs series of 2D strided convolutions on rectangular sized input tensor. The convolution proceeds on two parallel
+    paths: main path is composed by n subsequent convolutions while shortcut path has 1 convolution with different parameters and
+    can be set as the identity convolution. 
+    
+    Constructor inputs:
+
+
+        - block_id: progressive number of block in the network
+        - init_mi: (int) input channels
+        - sizes: (dict) python dictionary with keys:
+                            
+            sizes = { 'convblock_layer_n':[(n_c+1, kernel, stride, apply_batch_norm, keep_prob, act_f, weight initializer),
+                               (n_c+2,,,,,,,),
+                               (n_c+...,,,,,,,),
+                               (n_c+ last,,,,,,,],
+
+            'convblock_shortcut_layer_n':[(n_c+3, kernel, stride, apply_batch_norm, act_f, weight initializer)],
+            'dense_layers':[(dim output, apply_batch_norm, keep_prob, act_f, weight initializer )]
+            }
+
+            - filter_sz: (int) width and height of the convolution kernel at that layer
+            - stride: (int) horizontal and vertical size of the stride at that layer
+            - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+            - keep_prob: (int) dropout keep probability of propagated tensor
+            - f: (function) activation layer function. tf.nn.relu by default
+            - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+            
+            sizes['convblock_layer_n'] is a list of tuples of layers specifications for the main path 
+            sizes['convblock_shortcut_layer_n'] is a list composed by 1 tuple of layer specifications for the shortcut path
+            sizes['dense_layers'] is a list of tuples of layers specifications for the densely connected part of the network
+    
+    Class attributes
+
+        - conv_layers: (list) list of conv_layer objects
+        - shortcut_layer: (list) conv_layer object
+
+    Class methods:
+
+        - forward: 
+            inputs:
+                X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+                reuse: (bool) whether reusing the stored batch_normalization parameters or not
+                is_training: (bool) flag that indicates whether we are in the process of training or not
+            outputs:
+                output: (tf tensor) activated output of dim (batch_sz, n_W, n_H, mo), input for next layer
+        
+        - set_session:
+            Sets current session
+            inputs:
+                session: (tf session) current session
+
+    """
+
+    def __init__(self,
+                block_id,
+                init_mi, sizes,
+                ):
+     
+                #self.f=f
+                self.conv_layers = []
+                mi = init_mi
+                self.block_id=block_id
+                
+                #build the block
+                #main path
+                count=0
+                for mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init in sizes['convblock_layer_'+str(self.block_id)][:-1]:
+                
+                    name = 'convblock_{0}_layer_{1}'.format(block_id, count)
+                    count += 1
+                    layer = ConvLayer(name,
+                                 mi, mo, filter_sz, stride, 
+                                 apply_batch_norm, keep_prob,
+                                 act_f, w_init)
+                
+                    self.conv_layers.append(layer)
+                    mi = mo
+                    
+
+                name = 'convblock_{0}_layer_{1}'.format(block_id, count)
+                mo, filter_sz, stride, apply_batch_norm, self.keep_prob_last, self.fin_act , w_init = sizes['convblock_layer_' +str(self.block_id)][-1]
+            
+                layer = ConvLayer(name,
+                             mi, mo, filter_sz, stride,
+                             apply_batch_norm, 1,
+                             lambda x: x, w_init)
+            
+                self.conv_layers.append(layer)
+            
+                #secondary path
+                #set filter_sz = stride = 1 for an ID block
+                mo, filter_sz, stride, apply_batch_norm, _, w_init = sizes['convblock_shortcut_layer_'+str(self.block_id)][0]
+                name = 'convshortcut_layer_{0}'.format(block_id)
+                self.shortcut_layer = ConvLayer(name,
+                                           init_mi, mo, filter_sz, stride,
+                                           apply_batch_norm, 1,
+                                           f=lambda x: x, w_init=w_init)
+                
+                self.sizes=sizes
+        
+    def output_dim(self, input_dim):
+        
+        dim = input_dim
+        for _, _, stride, _, _, _, _, in self.sizes['convblock_layer_'+str(self.block_id)]:
+            dim = int(np.ceil(float(dim)/stride))
+  
+        return dim
+  
+    def set_session(self, session):
+        
+        self.session = session
+        
+        self.shortcut_layer.set_session(session)
+        
+        for layer in self.conv_layers:
+            layer.set_session(session)
+    
+    def forward(self, X, reuse, is_training):
+        
+        output = X
+        shortcut_output = X
+        #print('Convolutional block %i' %self.block_id)
+        #print('Input shape ', X.get_shape() )
+        i=0
+        for layer in self.conv_layers:
+            i+=1
+            output = layer.forward(output, reuse, is_training) 
+            #print('After layer %i' %i)
+            #print('Output shape ', output.get_shape())
+            
+        shortcut_output = self.shortcut_layer.forward(shortcut_output,reuse, is_training)
+        #print('Shortcut layer after convolution shape ', shortcut_output.get_shape())
+        
+        assert (output.get_shape().as_list()[1], output.get_shape().as_list()[2]) == (shortcut_output.get_shape().as_list()[1], shortcut_output.get_shape().as_list()[2]), 'image size mismatch at conv block {0} '.format(self.block_id)
+        
+        assert output.get_shape().as_list()[-1] == shortcut_output.get_shape().as_list()[-1], 'image channels mismatch at conv block {0}'.format(self.block_id)
+                
+        output = output + shortcut_output
+        
+        activated=self.fin_act(output)
+        output=tf.nn.dropout(activated, keep_prob=self.keep_prob_last, seed=rnd_seed)
+        return output
+
+class DeconvBlock(object):
+
+    """
+    Performs series of 2D strided deconvolutions on rectangular sized input tensor. The convolution proceeds on two parallel
+    paths: main path is composed by n subsequent deconvolutions while shortcut path has 1 deconvolution with different parameters and
+    can be set as the identity deconvolution. 
+    
+    Constructor inputs:
+
+
+        - block_id: progressive number of block in the network
+        - init_mi: (int) input channels
+        - sizes: (dict) python dictionary with keys:
+                          
+            sizes = { 
+
+                        'deconvblock_layer_n':[(n_c+1, kernel, stride, apply_batch_norm, keep_prob, act_f, weight initializer),
+                               (n_c+2,,,,,,,),
+                               (n_c+...,,,,,,,),
+                               (n_c+ last,,,,,,,],
+
+                        'deconvblock_shortcut_layer_n':[(n_c+3, kernel, stride, apply_batch_norm, act_f, weight initializer)],
+                        'dense_layers':[(dim output, apply_batch_norm, keep_prob, act_f, weight initializer )]
+                     }
+
+            - filter_sz: (int) width and height of the convolution kernel at that layer
+            - stride: (int) horizontal and vertical size of the stride at that layer
+            - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+            - keep_prob: (int) dropout keep probability of propagated tensor
+            - f: (function) activation layer function. tf.nn.relu by default
+            - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+            
+            sizes['deconvblock_layer_n'] is a list of tuples of layers specifications for the main path 
+            sizes['deconvblock_shortcut_layer_n'] is a list composed by 1 tuple of layer specifications for the shortcut path
+            sizes['dense_layers'] is a list of tuples of layers specifications for the densely connected part of the network
+    
+    Class attributes
+
+        - conv_layers: (list) list of conv_layer objects
+        - shortcut_layer: (list) conv_layer object
+
+    Class methods:
+
+        - forward: 
+            inputs:
+                X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+                reuse: (bool) whether reusing the stored batch_normalization parameters or not
+                is_training: (bool) flag that indicates whether we are in the process of training or not
+            outputs:
+                output: (tf tensor) activated output of dim (batch_sz, n_W, n_H, mo), input for next layer
+        
+        - set_session:
+            Sets current session
+            inputs:
+                session: (tf session) current session
+
+    """
+    
+    def __init__(self,
+                block_id,
+                mi, output_sizes, 
+                sizes):
+     
+                #self.f=f
+                init_mi=mi
+                self.deconv_layers = []
+                self.block_id=block_id
+                
+                #output shapes has to be a dictionary of [n_H,n_W]
+
+                #build the block
+                #main path
+                
+                for i in range(len(sizes['deconvblock_layer_'+str(block_id)])-1):
+                    
+                    mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = sizes['deconvblock_layer_'+str(block_id)][i]
+                    name = 'deconvblock_{0}_layer_{1}'.format(block_id, i)
+                    layer = DeconvLayer(name,mi, mo, output_sizes[block_id][i],
+                                        filter_sz, stride, 
+                                        apply_batch_norm, keep_prob,
+                                        act_f, w_init)
+                
+                    self.deconv_layers.append(layer)
+                    mi = mo
+                    
+                i = len(sizes['deconvblock_layer_'+str(block_id)])-1
+                
+                name = 'deconvblock_{0}_layer_{1}'.format(block_id, i)
+                mo, filter_sz, stride, apply_batch_norm, self.keep_prob_last, self.fin_act, w_init = sizes['deconvblock_layer_' +str(block_id)][-1]
+                
+
+                layer = DeconvLayer(name, mi, mo, output_sizes[block_id][len(output_sizes[block_id])-1],
+                                    filter_sz, stride,
+                                    apply_batch_norm, 1,
+                                    lambda x: x, w_init)
+            
+                self.deconv_layers.append(layer)
+
+                #secondary path
+                mo, filter_sz, stride, apply_batch_norm, keep_prob, w_init = sizes['deconvblock_shortcut_layer_'+str(block_id)][0]
+                name = 'deconvshortcut_layer_{0}'.format(block_id)
+                self.shortcut_layer = DeconvLayer(name, init_mi, mo, output_sizes[block_id][len(output_sizes[block_id])-1],
+                                           filter_sz,stride,
+                                           apply_batch_norm, 1,
+                                           f=lambda x: x, w_init=w_init)
+
+    def set_session(self, session):
+        
+        self.session = session
+        
+        self.shortcut_layer.set_session(session)
+        
+        for layer in self.deconv_layers:
+            layer.set_session(session)    
+    
+    def forward(self, X, reuse, is_training):
+          
+        output = X
+        shortcut_output = X
+        
+        #print('Deconvolutional block %i' %self.block_id)
+        #print('Input shape ', X.get_shape() )
+        i=0
+
+
+        for layer in self.deconv_layers:
+            i+=1
+            output = layer.forward(output, reuse, is_training)  
+            #print('After layer %i' %i)
+            #print('Output shape ', output.get_shape())
+
+        shortcut_output = self.shortcut_layer.forward(shortcut_output, reuse, is_training)
+        #print('Shortcut layer after convolution shape ', shortcut_output.get_shape())
+        
+        assert (output.get_shape().as_list()[1], output.get_shape().as_list()[2]) == (shortcut_output.get_shape().as_list()[1], shortcut_output.get_shape().as_list()[2]), 'image size mismatch at deconv block {0} '.format(self.block_id)
+        
+        assert output.get_shape().as_list()[-1] == shortcut_output.get_shape().as_list()[-1], 'image channels mismatch at deconv block {0}'.format(self.block_id)
+                
+        output = output + shortcut_output
+        
+        activated=self.fin_act(output)
+
+        output=tf.nn.dropout(activated, keep_prob=self.keep_prob_last, seed=rnd_seed)
+        
+        return output
+
+    def output_dim(self, input_dim):
+        
+        dim = input_dim
+        for _, _, stride, _, _, _, in self.sizes['deconvblock_layer_'+str(self.block_id)]:
+            dim = int(np.ceil(float(dim)/stride))
+  
+        return dim
+
+
+# class DeconvLayer_v2(object):
+  
+#     """
+#     Performs 2D strided deconvlution on rectangular sized input tensor. 
+
+#     Constructor inputs:
+
+#         - mi: (int) input channels
+#         - mo: (int) output channels
+#         - output_shape: list = [int, int], list[0]([1]) is the witdth (height) of the output after transposed convolution
+#         - filter_sz: (int) width and height of the convolution kernel
+#         - stride: (int) horizontal and vertical size of the stride
+#         - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+#         - keep_prob: (int) dropout keep probability of propagated tensor
+#         - f: (function) activation layer function. tf.nn.relu by default
+#         - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+
+#     Class attributes
+
+#         - W: (tf tensor) variable tensor of dim (filter_sz, filter_sz, mi, mo) of trainable weights
+#         - b: (tf tensor) variable tensor of dim (mo, ) of trainable biases
+
+#     Class methods:
+
+#         - forward: 
+#             inputs:
+#                 X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+#                 reuse: (bool) whether reusing the stored batch_normalization parameters or not
+#                 is_training: (bool) flag that indicates whether we are in the process of training or not
+
+#                 The deconvolution is computed in 3 steps according to: (cite article)
+#                 1) conv2d with W_id is performed to match the output channels mo, with filter_sz=1 and stride=1
+#                 2) the image is reshaped to reshape_size_H and W 
+#                 3) conv2d with W is performed with input filter_sz and stride, output width and height will match output_shape
+
+#             outputs:
+#                 output: (tf tensor) activated output of dim (batch_sz, n_W=output_shape[0], n_H = output_shape[1], mo), input for next layer
+        
+#         - set_session:
+#             Sets current session
+#             inputs:
+#                 session: (tf session) current session
+
+
+#     """  
+#     def __init__(self, name, 
+#                 mi, mo, output_shape, 
+#                 filter_sz, stride, 
+#                 apply_batch_norm, keep_prob = 1,
+#                 f=None, w_init = None
+#                 ):
+
+#                 #using resize + conv2d and not conv2dt
+#                 #mi: input channels
+#                 #mo: output channels
+#                 #output_shape: width and height of the output image
+                
+#                 #performs 2 convolutions, the first augments the number of channels
+#                 #the second performs a convolution with != 1 kernel and stride
+                
+#                 filter_shape = [filter_sz, filter_sz, mo, mi]
+
+#                 self.W = tf.get_variable(
+#                     "W_%s" %name,
+#                     filter_shape,
+#                     initializer=w_init,
+#                 )
+                
+#                 self.b = tf.get_variable(
+#                     "b_%s" %name,
+#                     shape=(mo,),
+#                     initializer=tf.zeros_initializer(),
+#                 )
+
+#                 self.f = f
+#                 self.stride = stride
+#                 self.filter_sz = filter_sz
+#                 self.name = name
+#                 self.output_shape = output_shape
+#                 self.apply_batch_norm = apply_batch_norm
+#                 self.keep_prob = keep_prob
+#                 self.mo=mo
+
+#     def forward(self, X, reuse, is_training):
+
+#         if not is_training:
+#             self.keep_prob = 1
+        
+#         m = tf.shape(X)[0]
+#         output_shape=tf.stack([m, self.output_shape[0], self.output_shape[1], self.mo])
+#         strides_shape=[1,self.stride,self.stride,1]
+
+#         conv_out = tf.nn.conv2d_transpose(
+#             value=X,
+#             filter=self.W, 
+#             output_shape=output_shape,
+#             strides=strides_shape,
+#             padding='SAME'
+#         )
+        
+#         #print('After deconvolution', conv_out.get_shape())
+#         conv_out = tf.nn.bias_add(conv_out,self.b)
+
+#         if self.apply_batch_norm=='bn':
+#             conv_out=tf.contrib.layers.batch_norm(
+#                 conv_out,
+#                 decay=0.9,
+#                 updates_collections=None,
+#                 epsilon=1e-5,
+#                 scale=True,
+#                 is_training = is_training,
+#                 reuse=reuse,
+#                 scope = self.name,
+#             )
+#         elif self.apply_batch_norm=='in':
+#             conv_out = tf.contrib.layers.instance_norm(
+#                 conv_out,
+#                 center=True,
+#                 scale=True,
+#                 epsilon=1e-6,
+#                 reuse=reuse,
+#                 scope = self.name,
+#             )
+#         elif self.apply_batch_norm=='False':
+#             return conv_out
+
+#         activated = self.f(conv_out) 
+#         output = tf.nn.dropout(activated, self.keep_prob, seed=rnd_seed)
+
+#         return output
+
+#     def set_session(self, session):
+        
+#         self.session = session
+
+# class DeconvBlock_v2(object):
+
+#     """
+#     Performs series of 2D strided deconvolutions on rectangular sized input tensor. The convolution proceeds on two parallel
+#     paths: main path is composed by n subsequent deconvolutions while shortcut path has 1 deconvolution with different parameters and
+#     can be set as the identity deconvolution. 
+    
+#     Constructor inputs:
+
+
+#         - block_id: progressive number of block in the network
+#         - init_mi: (int) input channels
+#         - sizes: (dict) python dictionary with keys:
+                          
+#             sizes = { 
+
+#                         'deconvblock_layer_n':[(n_c+1, kernel, stride, apply_batch_norm, keep_prob, act_f, weight initializer),
+#                                (n_c+2,,,,,,,),
+#                                (n_c+...,,,,,,,),
+#                                (n_c+ last,,,,,,,],
+
+#                         'deconvblock_shortcut_layer_n':[(n_c+3, kernel, stride, apply_batch_norm, act_f, weight initializer)],
+#                         'dense_layers':[(dim output, apply_batch_norm, keep_prob, act_f, weight initializer )]
+#                      }
+
+#             - filter_sz: (int) width and height of the convolution kernel at that layer
+#             - stride: (int) horizontal and vertical size of the stride at that layer
+#             - apply_batch_norm: (bool) whether applying batch normalization (along [0] axis of input tensor) or not
+#             - keep_prob: (int) dropout keep probability of propagated tensor
+#             - f: (function) activation layer function. tf.nn.relu by default
+#             - w_init: (tf initializer) initialization of the filter parameters, by default tf.truncated_normal_initializer(stddev=0.02)
+            
+#             sizes['deconvblock_layer_n'] is a list of tuples of layers specifications for the main path 
+#             sizes['deconvblock_shortcut_layer_n'] is a list composed by 1 tuple of layer specifications for the shortcut path
+#             sizes['dense_layers'] is a list of tuples of layers specifications for the densely connected part of the network
+    
+#     Class attributes
+
+#         - conv_layers: (list) list of conv_layer objects
+#         - shortcut_layer: (list) conv_layer object
+
+#     Class methods:
+
+#         - forward: 
+#             inputs:
+#                 X: (tf tensor) input tensor of dim (batch_sz, n_W, n_H, mi) output of previous layer
+#                 reuse: (bool) whether reusing the stored batch_normalization parameters or not
+#                 is_training: (bool) flag that indicates whether we are in the process of training or not
+#             outputs:
+#                 output: (tf tensor) activated output of dim (batch_sz, n_W, n_H, mo), input for next layer
+        
+#         - set_session:
+#             Sets current session
+#             inputs:
+#                 session: (tf session) current session
+
+#     """
+    
+#     def __init__(self,
+#                 block_id,
+#                 mi, output_sizes, 
+#                 sizes):
+     
+#                 #self.f=f
+#                 init_mi=mi
+#                 self.deconv_layers = []
+#                 self.block_id=block_id
+                
+#                 #output shapes has to be a dictionary of [n_H,n_W]
+
+#                 #build the block
+#                 #main path
+                
+#                 for i in range(len(sizes['deconvblock_layer_'+str(block_id)])-1):
+                    
+#                     mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = sizes['deconvblock_layer_'+str(block_id)][i]
+#                     name = 'deconvblock_{0}_layer_{1}'.format(block_id, i)
+#                     layer = DeconvLayer_v2(name,mi, mo, output_sizes[block_id][i],
+#                                         filter_sz, stride, 
+#                                         apply_batch_norm, keep_prob,
+#                                         act_f, w_init)
+                
+#                     self.deconv_layers.append(layer)
+#                     mi = mo
+                    
+#                 i = len(sizes['deconvblock_layer_'+str(block_id)])-1
+                
+#                 name = 'deconvblock_{0}_layer_{1}'.format(block_id, i)
+#                 mo, filter_sz, stride, apply_batch_norm, self.keep_prob_last, self.fin_act, w_init = sizes['deconvblock_layer_' +str(block_id)][-1]
+                
+
+#                 layer = DeconvLayer(name, mi, mo, output_sizes[block_id][len(output_sizes[block_id])-1],
+#                                     filter_sz, stride,
+#                                     apply_batch_norm, 1,
+#                                     lambda x: x, w_init)
+            
+#                 self.deconv_layers.append(layer)
+
+#                 #secondary path
+#                 mo, filter_sz, stride, apply_batch_norm, keep_prob, w_init = sizes['deconvblock_shortcut_layer_'+str(block_id)][0]
+#                 name = 'deconvshortcut_layer_{0}'.format(block_id)
+#                 self.shortcut_layer = DeconvLayer(name, init_mi, mo, output_sizes[block_id][len(output_sizes[block_id])-1],
+#                                            filter_sz,stride,
+#                                            apply_batch_norm, 1,
+#                                            f=lambda x: x, w_init=w_init)
+
+#     def set_session(self, session):
+        
+#         self.session = session
+        
+#         self.shortcut_layer.set_session(session)
+        
+#         for layer in self.deconv_layers:
+#             layer.set_session(session)    
+    
+#     def forward(self, X, reuse, is_training):
+          
+#         output = X
+#         shortcut_output = X
+        
+#         #print('Deconvolutional block %i' %self.block_id)
+#         #print('Input shape ', X.get_shape() )
+#         i=0
+
+
+#         for layer in self.deconv_layers:
+#             i+=1
+#             output = layer.forward(output, reuse, is_training)  
+#             #print('After layer %i' %i)
+#             #print('Output shape ', output.get_shape())
+
+#         shortcut_output = self.shortcut_layer.forward(shortcut_output, reuse, is_training)
+#         #print('Shortcut layer after convolution shape ', shortcut_output.get_shape())
+        
+#         assert (output.get_shape().as_list()[1], output.get_shape().as_list()[2]) == (shortcut_output.get_shape().as_list()[1], shortcut_output.get_shape().as_list()[2]), 'image size mismatch at deconv block {0} '.format(self.block_id)
+        
+#         assert output.get_shape().as_list()[-1] == shortcut_output.get_shape().as_list()[-1], 'image channels mismatch at deconv block {0}'.format(self.block_id)
+                
+#         output = output + shortcut_output
+        
+#         activated=self.fin_act(output)
+        
+#         output=tf.nn.dropout(activated, keep_prob=self.keep_prob_last, seed=rnd_seed)
+        
+#         return self.fin_act(output)
+
+#     def output_dim(self, input_dim):
+        
+#         dim = input_dim
+#         for _, _, stride, _, _, _, _, in self.sizes['deconvblock_layer_'+str(self.block_id)]:
+#             dim = int(np.ceil(float(dim)/stride))
+  
+#         return dim
\ No newline at end of file
diff --git a/tools/utils/NN_gen_building_blocks.py b/tools/utils/NN_gen_building_blocks.py
new file mode 100644
index 0000000..c07bae2
--- /dev/null
+++ b/tools/utils/NN_gen_building_blocks.py
@@ -0,0 +1,2540 @@
+#GENERATIVE MODELS BUILDING BLOCKS
+rnd_seed=1
+
+import numpy as np
+import os 
+import math
+
+import tensorflow as tf
+import matplotlib.pyplot as plt
+from datetime import datetime
+
+st = tf.contrib.bayesflow.stochastic_tensor
+Normal = tf.contrib.distributions.Normal
+Bernoulli = tf.contrib.distributions.Bernoulli
+
+from architectures.utils.NN_building_blocks import *
+from architectures.utils.toolbox import *
+#GANS
+
+#(residual) convolution to (?,1) shape
+class Discriminator(object):
+
+    def __init__(self, X, d_sizes, d_name):
+
+        self.residual=False
+
+        for key in d_sizes:
+            if not 'block' in key:
+                self.residual=False
+            else:
+                self.residual=True
+
+        _, dim_H, dim_W, mi = X.get_shape().as_list()
+
+        if not self.residual:
+            print('Convolutional Network architecture detected for discriminator '+ d_name)
+
+
+            with tf.variable_scope('discriminator_'+d_name) as scope:
+                #building discriminator convolutional layers
+
+                self.d_conv_layers =[]
+                count=0
+                for mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['conv_layers']:
+                    
+                    # make up a name - used for get_variable
+                    name = "d_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.d_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 discriminator dense layers
+
+                self.d_dense_layers = []
+                for mo, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['dense_layers']:
+                    
+                    name = 'd_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.d_dense_layers.append(layer)
+                    
+                    #final logistic layer
+
+                name = 'd_dense_layer_%s' %count
+                w_init_last = d_sizes['readout_layer_w_init']
+                #print(name)
+                self.d_final_layer = DenseLayer(name, mi, 1, 
+                                                    False, keep_prob=1, 
+                                                    act_f=lambda x: x, w_init=w_init_last)
+                
+
+                self.d_name=d_name
+        else:
+
+            print('Residual Convolutional Network architecture detected for discriminator'+ d_name)
+            
+            with tf.variable_scope('discriminator_'+d_name) as scope:
+                #building discriminator convolutional layers
+
+                self.d_blocks = []
+                #count conv blocks
+                d_steps = 0
+                for key in d_sizes:
+                    if 'conv' in key:
+                        if not 'shortcut' in key:
+                             d_steps+=1
+
+                d_block_n=0
+                d_layer_n=0
+                
+
+                for key in d_sizes:
+                     
+                    if 'block' and 'shortcut' in key:
+                    
+                        d_block = ConvBlock(d_block_n,
+                                   mi, d_sizes,
+                                   )
+                        self.d_blocks.append(d_block)
+                        
+                        mo, _, _, _, _, _, _, _, = d_sizes['convblock_layer_'+str(d_block_n)][-1]
+                        mi = mo
+                        dim_H = d_block.output_dim(dim_H)
+                        dim_W = d_block.output_dim(dim_W)
+                        d_block_n+=1
+                        
+                    
+                    if 'conv_layer' in key:
+
+                        name = 'd_conv_layer_{0}'.format(d_layer_n)
+
+                        mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = d_sizes[key][0]
+
+
+                        d_conv_layer = ConvLayer(name, mi, mo,
+                                               filter_sz, stride,
+                                               apply_batch_norm, keep_prob,
+                                               act_f, w_init
+                            )
+
+                        self.d_blocks.append(d_conv_layer)
+
+                        mi = mo
+                        dim_W = int(np.ceil(float(dim_W) / stride))
+                        dim_H = int(np.ceil(float(dim_H) / stride))
+                        d_layer_n+=1
+                
+                assert d_block_n+d_layer_n==d_steps, '\nCheck keys in d_sizes, \n total convolution steps do not mach sum between convolutional blocks and convolutional layers'
+                
+                count=d_steps
+
+                mi = mi * dim_H * dim_W
+
+                #build dense layers
+                
+                self.d_dense_layers = []
+                for mo, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['dense_layers']:
+                    
+                    name = 'd_dense_layer_%s' %count
+                    count +=1
+                    
+                    layer = DenseLayer(name,mi, mo,
+                                      apply_batch_norm, keep_prob, 
+                                      act_f, w_init)
+                    mi = mo
+                    self.d_dense_layers.append(layer)
+                
+                #final logistic layer
+                name = 'd_dense_layer_%s' %count
+                w_init_last = d_sizes['readout_layer_w_init']
+                #print(name)
+                self.d_final_layer = DenseLayer(name, mi, 1, 
+                                                    False, keep_prob=1, 
+                                                    act_f=lambda x: x, w_init=w_init_last)
+                
+
+                self.d_steps=d_steps
+                self.d_name = d_name
+
+    def d_forward(self, X, reuse = None, is_training=True):
+
+        if not self.residual:
+            print('Discriminator_'+self.d_name)
+            print('Convolution')
+
+            output = X
+            print('Input for convolution shape ', X.get_shape())
+            i=0
+            for layer in self.d_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.d_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())
+
+            logits = self.d_final_layer.forward(output, 
+                                                reuse,
+                                                is_training)
+            print('Logits shape', logits.get_shape())
+            return logits
+        else:
+            print('Redisual discriminator_'+self.d_name)
+            print('Convolution')
+
+            output = X
+
+            i=0
+            print('Input for convolution shape ', X.get_shape())
+            for block in self.d_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.d_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())
+
+            logits = self.d_final_layer.forward(output, 
+                                                reuse,
+                                                is_training)
+            print('Logits shape', logits.get_shape())
+            return logits
+
+#patchGAN architecture, convolution to (?, n_H_d, n_W_d, 1) shape
+class pix2pixDiscriminator(object):
+
+    def __init__(self, X, d_sizes, d_name):
+
+        self.residual=False
+
+        for key in d_sizes:
+            if not 'block' in key:
+                self.residual=False
+            else:
+                self.residual=True
+
+        _, dim_H, dim_W, mi = X.get_shape().as_list()
+
+        mi = 2*mi #takes as an input the concatenated true and fake images
+
+        if not self.residual:
+ 
+            print('Convolutional pix2pix Network architecture detected for discriminator '+ d_name)
+
+            with tf.variable_scope('discriminator_'+d_name) as scope:
+                
+                #building discriminator convolutional layers
+                self.d_conv_layers =[]
+
+                count=0
+                
+                for mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['conv_layers']:
+                    
+                    # make up a name - used for get_variable
+                    name = "d_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.d_conv_layers.append(layer)
+                    mi = mo
+                    dim_H = int(np.ceil(float(dim_H) / stride))
+                    dim_W = int(np.ceil(float(dim_W) / stride))
+                        
+
+                 #final unactivated conv layer
+                filter_sz, stride, apply_batch_norm, keep_prob, w_init_last = d_sizes['readout_conv_layer'][0]
+                count +=1
+                name = 'last_conv_layer'
+                self.last_conv_layer = ConvLayer(name, mi, 1,
+                                      filter_sz, stride,
+                                      apply_batch_norm, keep_prob,
+                                      lambda x: x, w_init_last)
+                self.d_name=d_name
+        else:
+
+            print('Residual Convolutional pix2pix Network architecture detected for discriminator'+ d_name)
+            
+            with tf.variable_scope('discriminator_'+d_name) as scope:
+                #building discriminator convolutional layers
+
+                self.d_blocks = []
+                #count conv blocks
+                d_steps = 0
+                for key in d_sizes:
+                    if 'conv' in key:
+                        if not 'shortcut' in key:
+                             d_steps+=1
+
+                d_block_n=0
+                d_layer_n=0
+                
+
+                for key in d_sizes:
+                     
+                    if 'block' and 'shortcut' in key:
+                    
+                        d_block = ConvBlock(d_block_n,
+                                   mi, d_sizes,
+                                   )
+                        self.d_blocks.append(d_block)
+                        
+                        mo, _, _, _, _, _, _, _, = d_sizes['convblock_layer_'+str(d_block_n)][-1]
+                        mi = mo
+                        dim_H = d_block.output_dim(dim_H)
+                        dim_W = d_block.output_dim(dim_W)
+                        d_block_n+=1
+                        
+                    
+                    if 'conv_layer' in key:
+
+                        name = 'd_conv_layer_{0}'.format(d_layer_n)
+
+                        mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = d_sizes[key][0]
+
+
+                        d_conv_layer = ConvLayer(name, mi, mo,
+                                               filter_sz, stride,
+                                               apply_batch_norm, keep_prob,
+                                               act_f, w_init
+                            )
+
+                        self.d_blocks.append(d_conv_layer)
+
+                        mi = mo
+                        dim_W = int(np.ceil(float(dim_W) / stride))
+                        dim_H = int(np.ceil(float(dim_H) / stride))
+                        d_layer_n+=1
+                
+                assert d_block_n+d_layer_n==d_steps, '\nCheck keys in d_sizes, \n total convolution steps do not mach sum between convolutional blocks and convolutional layers'
+
+                #final unactivated conv layer
+                filter_sz, stride, apply_batch_norm, keep_prob, w_init_last = d_sizes['readout_conv_layer'][0]
+                count +=1
+                name = 'last_conv_layer'
+                self.last_conv_layer = ConvLayer(name, mi, 1,
+                                      filter_sz, stride,
+                                      apply_batch_norm, keep_prob,
+                                      lambda x: x, w_init_last)
+                self.d_name=d_name
+
+    def d_forward(self, X, samples, reuse = None, is_training=True):
+
+        if not self.residual:
+            print('Discriminator_'+self.d_name)
+
+            output = tf.concat([X,samples],axis=3)
+            print('Input for convolution shape ', X.get_shape())
+
+            i=0
+            for layer in self.d_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())
+
+            logits = self.last_conv_layer.forward(output, 
+                                                reuse,
+                                                is_training)
+
+            print('Logits shape', logits.get_shape())
+            return logits
+        else:
+            print('Discriminator_'+self.d_name)
+
+            output = tf.concat([X,samples],axis=3)
+            print('Input for convolution shape ', X.get_shape())
+
+            i=0
+            for block in self.d_blocks:
+                i+=1
+                # print('Convolution_layer_%i' %i)
+                # print('Input shape', output.get_shape())
+                output = block.forward(output,
+                                     reuse, 
+                                     is_training)
+                # print('After convolution shape', output.get_shape())
+
+            logits = self.last_conv_layer.forward(output, 
+                                                reuse,
+                                                is_training)
+
+            print('Logits shape', logits.get_shape())
+            return logits
+
+#convolution to (?, 1) shape with minibatch discrimination, outputs features for feature matching
+class Discriminator_minibatch(object):
+
+    def __init__(self, X, d_sizes, d_name):
+
+        self.num_kernels=5
+        self.kernel_dim=3
+
+        _, dim_H, dim_W, mi = X.get_shape().as_list()
+
+
+        print('Convolutional Network architecture detected for discriminator '+ d_name)
+
+
+        with tf.variable_scope('discriminator_'+d_name) as scope:
+            #building discriminator convolutional layers
+
+            self.d_conv_layers =[]
+            count=0
+            for mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['conv_layers']:
+                
+                # make up a name - used for get_variable
+                name = "d_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.d_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 discriminator dense layers
+
+            self.d_dense_layers = []
+            for i, (mo, apply_batch_norm, keep_prob, act_f, w_init) in enumerate(d_sizes['dense_layers']):
+                
+                name = 'd_dense_layer_%s' %count
+                #print(name)
+                count +=1
+                
+                layer = DenseLayer(name, mi, mo,
+                                  apply_batch_norm, keep_prob,
+                                  act_f, w_init)
+                
+                self.d_dense_layers.append(layer)
+                mi = mo
+                if i == len(d_sizes['dense_layers'])-1:
+                    name = "mb_disc_layer"
+                    self.mb_layer = DenseLayer(name, mi, self.num_kernels*self.kernel_dim, False,
+                                        keep_prob=1, act_f=lambda x:x, w_init=tf.truncated_normal_initializer(stddev=0.01))
+                
+    
+            #final logistic layer
+
+            name = 'd_dense_layer_%s' %count
+            w_init_last = d_sizes['readout_layer_w_init']
+            #print(name)
+            #
+            self.d_final_layer = DenseLayer(name, mi + self.num_kernels , 1, 
+                                                False, keep_prob=1, 
+                                                act_f=lambda x: x, w_init=w_init_last)
+            
+
+            self.d_name=d_name
+
+            
+    def d_forward(self, X, reuse = None, is_training=True):
+
+        print('Discriminator_'+self.d_name)
+        #print('Convolution')
+
+        output=X
+        print('Input for convolution shape ', output.get_shape())
+
+        for i, layer in enumerate(self.d_conv_layers):
+            # print('Convolution_layer_%i' %i)
+            # print('Input shape', output.get_shape())
+            output = layer.forward(output,
+                                 reuse, 
+                                 is_training)
+            if i==np.ceil(len(self.d_conv_layers)/2):
+                feature_output=output
+            #print('After convolution shape', output.get_shape())
+        
+        output = tf.contrib.layers.flatten(output)
+        #print('After flatten shape', output.get_shape())
+        
+        for i, layer in enumerate(self.d_dense_layers):
+            #print('Dense weights %i' %i)
+            #print(layer.W.get_shape())
+            output = layer.forward(output,
+                                   reuse,
+                                   is_training)
+
+            if i==len(self.d_dense_layers)-1:
+                output_mb=self.mb_layer.forward(output, 
+                                                reuse, 
+                                                is_training)
+
+            # print('After dense layer_%i' %i)
+            # print('Shape', output.get_shape())
+
+        activation = tf.reshape(output_mb, (-1, self.num_kernels, self.kernel_dim))
+        diffs = tf.expand_dims(activation, 3) - tf.expand_dims(
+                tf.transpose(activation, [1, 2, 0]), 0)
+
+        eps = tf.expand_dims(tf.eye(tf.shape(X)[0], dtype=np.float32), 1)
+        abs_diffs = tf.reduce_sum(tf.abs(diffs), 2) + eps
+        minibatch_features = tf.reduce_sum(tf.exp(-abs_diffs), 2)
+        print('minibatch features shape', minibatch_features.get_shape())
+        output=tf.concat([output, minibatch_features], 1)
+
+        logits = self.d_final_layer.forward(output, 
+                                            reuse,
+                                            is_training)
+        print('Logits shape', logits.get_shape())
+        return logits, feature_output
+
+class condDiscriminator(object):
+    def __init__(self, X, dim_y, d_sizes, d_name):
+
+        self.num_kernels=5
+        self.kernel_dim=3
+
+        self.residual=False
+
+        for key in d_sizes:
+            if not 'block' in key:
+                self.residual=False
+            else:
+                self.residual=True
+
+        _, dim_H, dim_W, mi = X.get_shape().as_list()
+
+        mi = mi + dim_y
+        self.dim_y=dim_y
+        if not self.residual:
+            print('Convolutional Network architecture detected for discriminator '+ d_name)
+
+
+            with tf.variable_scope('discriminator_'+d_name) as scope:
+                #building discriminator convolutional layers
+
+                self.d_conv_layers =[]
+                count=0
+                for mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['conv_layers']:
+                    
+                    # make up a name - used for get_variable
+                    name = "d_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.d_conv_layers.append(layer)
+                    mi = mo
+                    mi = mi + dim_y
+
+                    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 discriminator dense layers
+                mi = mi + dim_y
+                self.d_dense_layers = []
+                for i, (mo, apply_batch_norm, keep_prob, act_f, w_init) in enumerate(d_sizes['dense_layers'], 0):
+                    
+                    name = 'd_dense_layer_%s' %count
+                    #print(name)
+                    count +=1
+                    
+                    layer = DenseLayer(name, mi, mo,
+                                      apply_batch_norm, keep_prob,
+                                      act_f, w_init)
+                    mi = mo
+                    mi = mi + dim_y
+                    self.d_dense_layers.append(layer)
+
+                    if i == len(d_sizes['dense_layers'])-1:
+                        name = "mb_disc_layer"
+                        self.mb_layer = DenseLayer(name, mi, self.num_kernels*self.kernel_dim, False,
+                                        keep_prob=1, act_f=lambda x:x, w_init=tf.truncated_normal_initializer(stddev=0.01))
+                    
+                    #final logistic layer
+
+                name = 'd_dense_layer_%s' %count
+                w_init_last = d_sizes['readout_layer_w_init']
+                #print(name)
+                self.d_final_layer = DenseLayer(name, mi+self.num_kernels, 1, 
+                                                    False, keep_prob=1, 
+                                                    act_f=lambda x: x, w_init=w_init_last)
+                
+
+                self.d_name=d_name
+                self.dim_y= dim_y
+        else:
+
+            print('Residual Convolutional Network architecture detected for discriminator'+ d_name)
+            
+            with tf.variable_scope('discriminator_'+d_name) as scope:
+                #building discriminator convolutional layers
+
+                self.d_blocks = []
+                #count conv blocks
+                d_steps = 0
+                for key in d_sizes:
+                    if 'conv' in key:
+                        if not 'shortcut' in key:
+                             d_steps+=1
+
+                d_block_n=0
+                d_layer_n=0
+                
+
+                for key in d_sizes:
+                     
+                    if 'block' and 'shortcut' in key:
+                    
+                        d_block = ConvBlock(d_block_n,
+                                   mi, d_sizes,
+                                   )
+                        self.d_blocks.append(d_block)
+                        
+                        mo, _, _, _, _, _, _, _, = d_sizes['convblock_layer_'+str(d_block_n)][-1]
+                        mi = mo
+                        dim_H = d_block.output_dim(dim_H)
+                        dim_W = d_block.output_dim(dim_W)
+                        d_block_n+=1
+                        
+                    
+                    if 'conv_layer' in key:
+
+                        name = 'd_conv_layer_{0}'.format(d_layer_n)
+
+                        mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = d_sizes[key][0]
+
+
+                        d_conv_layer = ConvLayer(name, mi, mo,
+                                               filter_sz, stride,
+                                               apply_batch_norm, keep_prob,
+                                               act_f, w_init
+                            )
+
+                        self.d_blocks.append(d_conv_layer)
+
+                        mi = mo
+                        dim_W = int(np.ceil(float(dim_W) / stride))
+                        dim_H = int(np.ceil(float(dim_H) / stride))
+                        d_layer_n+=1
+                
+                assert d_block_n+d_layer_n==d_steps, '\nCheck keys in d_sizes, \n total convolution steps do not mach sum between convolutional blocks and convolutional layers'
+                
+                count=d_steps
+
+                mi = mi * dim_H * dim_W
+
+                #build dense layers
+                
+                self.d_dense_layers = []
+                for mo, apply_batch_norm, keep_prob, act_f, w_init in d_sizes['dense_layers']:
+                    
+                    name = 'd_dense_layer_%s' %count
+                    count +=1
+                    
+                    layer = DenseLayer(name,mi, mo,
+                                      apply_batch_norm, keep_prob, 
+                                      act_f, w_init)
+                    mi = mo
+                    self.d_dense_layers.append(layer)
+                
+                #final logistic layer
+                name = 'd_dense_layer_%s' %count
+                w_init_last = d_sizes['readout_layer_w_init']
+                #print(name)
+                self.d_final_layer = DenseLayer(name, mi, 1, 
+                                                    False, keep_prob=1, 
+                                                    act_f=lambda x: x, w_init=w_init_last)
+                
+
+                self.d_steps=d_steps
+                self.d_name = d_name
+
+    def d_forward(self, X, y, reuse = None, is_training=True):
+
+        if not self.residual:
+            print('Discriminator_'+self.d_name)
+            print('Convolution')
+
+            output = X 
+            output = conv_concat(output, y, self.dim_y)  
+            #output = conv_cond_concat(output, yb)
+            print('Input for convolution shape ', output.get_shape())
+            i=0
+            for layer in self.d_conv_layers:
+                i+=1
+                #print('Convolution_layer_%i' %i)
+                #print('Input shape', output.get_shape())
+                output = layer.forward(output,
+                                     reuse, 
+                                     is_training)
+                output = conv_concat(output, y, self.dim_y)
+                if i==np.ceil(len(self.d_conv_layers)/2):
+                    feature_output=output
+                #print('After convolution shape', output.get_shape())
+            
+            output = tf.contrib.layers.flatten(output)
+            output = lin_concat(output, y, self.dim_y)
+
+            #print('After flatten shape', output.get_shape())
+            i=0
+            for layer in self.d_dense_layers:
+                output = layer.forward(output,
+                                       reuse,
+                                       is_training)
+                output = lin_concat(output, y, self.dim_y)
+                if i==len(self.d_dense_layers)-1:
+                    output_mb=self.mb_layer.forward(output, 
+                                                reuse, 
+                                                is_training)
+                i+=1
+
+                #print('After dense layer_%i' %i)
+                #print('Shape', output.get_shape())
+            activation = tf.reshape(output_mb, (-1, self.num_kernels, self.kernel_dim))
+            diffs = tf.expand_dims(activation, 3) - tf.expand_dims(
+                tf.transpose(activation, [1, 2, 0]), 0)
+
+            eps = tf.expand_dims(tf.eye(tf.shape(X)[0], dtype=np.float32), 1)
+            abs_diffs = tf.reduce_sum(tf.abs(diffs), 2) + eps
+            minibatch_features = tf.reduce_sum(tf.exp(-abs_diffs), 2)
+            print('minibatch features shape', minibatch_features.get_shape())
+            output=tf.concat([output, minibatch_features], 1)
+            logits = self.d_final_layer.forward(output, 
+                                                reuse,
+                                                is_training)
+            print('Logits shape', logits.get_shape())
+            return logits, feature_output
+        else:
+            print('Redisual discriminator_'+self.d_name)
+            print('Convolution')
+
+            output = X
+
+            i=0
+            print('Input for convolution shape ', X.get_shape())
+            for block in self.d_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.d_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())
+
+            logits = self.d_final_layer.forward(output, 
+                                                reuse,
+                                                is_training)
+            print('Logits shape', logits.get_shape())
+            return logits
+
+#(residual) deconvolution to (?,n_H, n_W,n_C) image shape
+class Generator(object):
+
+    def __init__(self, Z, 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
+
+        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
+
+                #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
+                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
+
+        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
+   
+    def g_forward(self, Z, reuse=None, is_training=True):
+
+        if not self.residual:
+
+            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:
+                output = layer.forward(output, reuse, is_training)
+                #print('After dense layer %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
+
+            i=0
+            for layer in self.g_conv_layers:
+                i+=1
+                output = layer.forward(output, reuse, is_training)
+                #print('After deconvolutional layer %i' %i)
+                #print('shape: ', output.get_shape())
+
+
+            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
+
+#conv / residual conv / deconv
+class cycleGenerator(object):
+
+    def __init__(self, X, dim_H, dim_W, g_sizes, g_name):
+        
+        #input shape
+        _, input_dim_H, input_dim_W, input_n_C = X.get_shape().as_list()
+        #output shape
+
+        dims_H =[dim_H]
+        dims_W =[dim_W]
+
+        self.residual=False
+        for key in g_sizes:
+            if not 'block' in key:
+                self.residual=False
+            else :
+                self.residual=True
+
+        if not self.residual:
+
+            print('Convolutional Network architecture detected for generator '+ g_name)
+
+            with tf.variable_scope('generator_'+g_name) as scope:
+
+                count = 0
+                #checking generator architecture
+                g_steps=0
+                for key in g_sizes:
+                    g_steps+=1
+
+                g_convs = 0
+                g_deconvs = 0
+                for key in g_sizes:
+                    if 'conv' in key:
+                        if not 'deconv' in key:
+                            g_convs+=1
+                    if 'deconv' in key:
+                         g_deconvs+=1
+                    
+                assert g_steps == g_convs + g_deconvs, '\nCheck keys in g_sizes, \n sum of generator steps do not coincide with sum of convolutional layers, convolutional blocks and deconv layers'
+
+                #dimensions of output generated image
+                deconv_layers_output_sizes={}
+                    
+                for key, item in reversed(list(g_sizes.items())):
+
+                    if 'deconv_layer' in key:
+                        
+                        _, _, stride, _, _, _, _, = g_sizes[key][0]
+                        deconv_layers_output_sizes[g_deconvs-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_deconvs -= 1
+
+                assert g_deconvs  == 0
+                
+                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
+
+
+                #convolution input channel number
+                mi = input_n_C
+
+                self.g_conv_layers=[]
+                self.g_deconv_layers=[]
+
+                conv_layer_n=0 #keep count of conv layer number
+                deconv_layer_n=0 #keep count of deconv layer number
+                i=0 # keep count of the built blocks
+
+                for key in g_sizes:
+
+                    if 'conv_layer' in key:
+                        if not 'deconv' in key:
+
+                            name = 'g_conv_layer_{0}'.format(conv_layer_n)
+
+                            mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = g_sizes[key][0]
+
+                            g_conv_layer = ConvLayer(
+                                name, mi, mo, 
+                                filter_sz, stride, apply_batch_norm, keep_prob,
+                                act_f, w_init
+                                )
+                            self.g_conv_layers.append(g_conv_layer)
+                            mi = mo
+                            conv_layer_n +=1
+                            count +=1
+                            i+=1
+
+                    if 'deconv_layer' in key:
+
+                        name = 'g_deconv_layer_{0}'.format(deconv_layer_n)
+
+                        mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = g_sizes[key][0]
+                        g_deconv_layer = DeconvLayer(
+                            name, mi, mo, deconv_layers_output_sizes[deconv_layer_n],
+                            filter_sz, stride, apply_batch_norm, keep_prob,
+                            act_f, w_init
+                        )
+                        self.g_deconv_layers.append(g_deconv_layer)
+
+                        mi=mo
+                        deconv_layer_n+=1
+                        count+=1 
+                        i+=1
+
+                assert i==conv_layer_n+deconv_layer_n, 'Check convolutional layer and block building, steps in building do not coincide with g_steps'
+
+                #saving for later
+                self.g_sizes=g_sizes
+                self.g_name = g_name
+       
+        if self.residual:
+
+            print('Residual Convolutional Network architecture detected for generator '+ g_name)
+
+            with tf.variable_scope('generator_'+g_name) as scope:
+                    
+                count = 0
+
+                #checking generator architecture
+                g_steps=0
+                for key in g_sizes:
+                    g_steps+=1
+
+                g_convs = 0
+                g_deconvs = 0
+                g_conv_blocks = 0
+                #g_deconv_blocks = 0
+
+                for key in g_sizes:
+
+                    if 'conv' in key:
+                        if not 'deconv' in key:
+                                if not 'block' in key:
+                                    g_convs+=1
+                    if 'convblock' and 'shortcut' in key:
+                            g_conv_blocks+=1
+                        
+                    if 'deconv' in key:
+                        if not 'shortcut' in key:
+                             g_deconvs+=1
+                
+                assert g_steps == g_convs +2*(g_conv_blocks)+ g_deconvs, '\nCheck keys in g_sizes, \n sum of generator steps do not coincide with sum of convolutional layers, convolutional blocks and deconv layers'
+
+                #dimensions of output generated image
+
+                deconv_layers_output_sizes={}
+                
+
+                for key, item in reversed(list(g_sizes.items())):
+
+                    if 'deconv_layer' in key:
+                        
+                        _, _, stride, _, _, _, _, = g_sizes[key][0]
+                        deconv_layers_output_sizes[g_deconvs-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_deconvs -= 1
+
+                assert g_deconvs  == 0
+                
+                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
+
+
+                #convolution input channel number
+                mi = input_n_C
+
+                self.g_blocks=[]
+
+                block_n=0 #keep count of the block number
+                conv_layer_n=0 #keep count of conv layer number
+                deconv_layer_n=0 #keep count of deconv layer number
+                i=0 # keep count of the built blocks
+
+                for key in g_sizes:
+
+                    if 'conv_layer' in key:
+                        if not 'deconv' in key:
+
+                            name = 'g_conv_layer_{0}'.format(conv_layer_n)
+
+                            mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = g_sizes[key][0]
+
+                            g_conv_layer = ConvLayer(
+                                name, mi, mo, 
+                                filter_sz, stride, apply_batch_norm, keep_prob,
+                                act_f, w_init
+                                )
+                            self.g_blocks.append(g_conv_layer)
+                            mi = mo
+                            conv_layer_n +=1
+                            count +=1
+                            i+=1
+
+                    
+                    if 'block' and 'shortcut' in key:
+                    
+                        g_block = ConvBlock(block_n,
+                                   mi, g_sizes,
+                                   )
+                        self.g_blocks.append(g_block)
+                        
+                        mo, _, _, _, _, _, _, = g_sizes['convblock_layer_'+str(block_n)][-1]
+                        mi = mo
+                        block_n+=1
+                        count+=1 
+                        i+=1
+                        
+                    if 'deconv_layer' in key:
+
+                        name = 'g_deconv_layer_{0}'.format(deconv_layer_n)
+
+                        mo, filter_sz, stride, apply_batch_norm, keep_prob, act_f, w_init = g_sizes[key][0]
+                        g_deconv_layer = DeconvLayer(
+                            name, mi, mo, deconv_layers_output_sizes[deconv_layer_n],
+                            filter_sz, stride, apply_batch_norm, keep_prob,
+                            act_f, w_init
+                        )
+                        self.g_blocks.append(g_deconv_layer)
+
+                        mi=mo
+                        deconv_layer_n+=1
+                        count+=1 
+                        i+=1
+
+                assert i==block_n+conv_layer_n+deconv_layer_n, 'Check convolutional layer and block building, steps in building do not coincide with g_steps'
+
+                #saving for later
+                self.g_sizes=g_sizes
+                self.g_name = g_name
+                    # return self.g_forward(Z)
+       
+    def g_forward(self, X, reuse=None, is_training=True):
+        if not self.residual:
+            print('Generator_'+self.g_name)
+            #dense layers
+
+            output = X
+            print('Input for generator shape', X.get_shape())
+            
+            i=0
+
+            for conv_layer in self.g_conv_layers:
+                i+=1
+                output = conv_layer.forward(output,
+                                        reuse,
+                                        is_training)
+                #print('After block step%i' %i)
+                #print('shape: ', output.get_shape())
+            for deconv_layer in self.g_deconv_layers:
+
+                i+=1
+                output = deconv_layer.forward(output,
+                                        reuse,
+                                        is_training)
+
+            print('Generator output shape', output.get_shape())
+            return output
+
+        if self.residual:
+            print('Generator_'+self.g_name)
+            #dense layers
+
+            output = X
+            print('Input for generator shape', X.get_shape())
+            
+            i=0
+
+
+            for block in self.g_blocks:
+                i+=1
+                output = block.forward(output,
+                                        reuse,
+                                        is_training)
+                #print('After block step%i' %i)
+                #print('shape: ', output.get_shape())
+        
+
+            print('Generator output shape', output.get_shape())
+            return output
+
+#residual conv / residual deconv
+class cycleGenerator_fullresidual(object):
+
+    def __init__(self, X, dim_H, dim_W, g_sizes, g_name):
+        
+        _, input_dim_H, input_dim_W, input_n_C = X.get_shape().as_list()
+
+        dims_H =[dim_H]
+        dims_W =[dim_W]
+
+        print('Residual Convolutional Network architecture (v2) detected for generator '+ g_name)
+
+        with tf.variable_scope('generator_'+g_name) as scope:
+                
+            count = 0
+
+            #checking generator architecture
+            g_steps=0
+            for key in g_sizes:
+                g_steps+=1
+
+            g_conv_blocks = 0
+            g_deconv_blocks = 0
+
+            for key in g_sizes:
+
+                if 'conv' in key:
+                    if not 'deconv' in key:
+                            if 'block' in key:
+                                g_conv_blocks+=1
+                if 'deconv' in key:
+                            if 'block' in key:
+                                g_deconv_blocks+=1
+            
+            assert g_steps == g_conv_blocks+ g_deconv_blocks, '\nCheck keys in g_sizes, \n sum of generator steps do not coincide with sum of convolutional blocks and deconvolutional blocks'
+            
+            #dimensions of output generated image
+            g_deconv_blocks=g_deconv_blocks//2
+            deconv_blocks_output_sizes={}
+            for key, item in reversed(list(g_sizes.items())):
+
+                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)
+                    
+                    deconv_blocks_output_sizes[g_deconv_blocks-1] = [[dims_H[j],dims_W[j]] for j in range(1, len(g_sizes[key])+1)]
+                    g_deconv_blocks -=1
+
+            dims_H = list(reversed(dims_H))
+            dims_W = list(reversed(dims_W))
+            
+            assert g_deconv_blocks==0
+
+            #convolution input channel number
+            mi = input_n_C
+
+            self.g_blocks=[]
+
+            convblock_n=0 #keep count of the conv block number
+            deconvblock_n=0 #keep count of deconv block number
+
+            i=0 # keep count of the built blocks
+
+            for key in g_sizes:
+
+                if 'convblock_layer' in key:
+                    if not 'deconv' in key:
+
+                        g_block = ConvBlock(convblock_n,
+                                   mi, g_sizes,
+                                   )
+                        self.g_blocks.append(g_block)
+                        
+                        mo, _, _, _, _, _, _, = g_sizes['convblock_layer_'+str(convblock_n)][-1]
+                        mi = mo
+                        convblock_n+=1
+                        i+=1
+
+                
+                if 'deconvblock_layer' in key:
+
+                        g_block = DeconvBlock(deconvblock_n,
+                                   mi, deconv_blocks_output_sizes, g_sizes,
+                                   )
+                        self.g_blocks.append(g_block)
+                        
+                        mo, _, _, _, _, _, _, = g_sizes['deconvblock_layer_'+str(deconvblock_n)][-1]
+                        mi = mo
+                        deconvblock_n+=1
+                        i+=1
+
+            assert i==convblock_n+deconvblock_n, 'Check convolutional layer and block building, steps in building do not coincide with g_steps'
+
+            #saving for later
+            self.g_dims_H = dims_H
+            self.g_dims_W = dims_W
+            self.g_sizes=g_sizes
+            self.g_name = g_name
+       
+    def g_forward(self, X, reuse=None, is_training=True):
+
+        print('Generator_'+self.g_name)
+        #dense layers
+
+        output = X
+        print('Input for generator shape', X.get_shape())
+        
+        i=0
+
+        for block in self.g_blocks:
+            i+=1
+            output = block.forward(output,
+                                    reuse,
+                                    is_training)
+            #print('After block step%i' %i)
+            #print('shape: ', output.get_shape())
+
+        print('Generator output shape', output.get_shape())
+        return output
+
+#pix2pix architecture, u_net
+#works with same dim of input and output, implement different dimensions
+class pix2pixGenerator(object):
+
+    def __init__(self, X, output_dim_H, output_dim_W, g_enc_sizes, g_dec_sizes, 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
+        mi = input_n_C
+
+        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_enc_sizes['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_dec_sizes['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_dec_sizes['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, 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<energy_fraction:
+            pos_rejected.append(i)
+        else:
+            pos_selected.append(i)
+
+    reco_filtered=np.delete(reco,pos_rejected,axis=0)
+    true_filtered=np.delete(true, pos_rejected, axis=0)
+
+    reco_rejected=np.delete(reco, pos_selected, axis=0)
+    true_rejected=np.delete(true, pos_selected, axis=0)
+
+    assert len(true_filtered)==len(reco_filtered)
+
+    return true_filtered, reco_filtered, true_rejected, reco_rejected
+
+
+def load_batch(true_path, reco_path, i):
+    
+    with open(reco_path+'sample{0}.pickle'.format(i), 'rb') as f:
+        reco=pickle.load(f)
+
+    with open(true_path+'sample{0}.pickle'.format(i), 'rb') as f:
+        true=pickle.load(f)
+    
+    #cut that extra produced pixel
+    true=true[:,1:true.shape[1]-1,1:true.shape[2]-1,:]
+    
+    return true, reco
+
+def load_conditional(true, reco):
+
+    ETs=np.zeros(shape=(len(true),3,1))
+
+    for i in range(len(true)):
+
+        x, y, _ = np.where(true[i]!=0)
+        ETs[i][0]=x[0]
+        ETs[i][1]=y[0]
+        ETs[i][2]=true[i][x, y][0][0]
+    
+    return ETs, reco
+
+def load_data(true_path, reco_path, n_batches, 
+    select=False, n_cells=None, energy_fraction=0.0, 
+    preprocess=None, test_size=None):
+
+    if n_batches == 1:
+
+        #delete undetected particles
+        true, reco = load_batch(true_path, reco_path, 0)
+        #true, reco = delete_undetected_events_double(true1, reco1)
+        
+        #delete too noisy events
+        if select:
+            true_output, reco_output, _, _,  = selection(true, reco, n_cells, energy_fraction)
+            true=true_output
+            reco=reco_output
+
+    elif n_batches > 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*dim<reco_y[0]<=max_y-2*dim and 2*dim<reco_x[0]<=max_x-2*dim:
+#             cropped_reco[i]=reco[i, reco_y[0]-dim:reco_y[0]+dim+1, reco_x[0]-dim:reco_x[0]+dim+1, :]
+#             ETs.append(true[i][np.where(true[i]>0)][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<x[0]<=max_x:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i,0:2*dim,  max_x-2*dim:max_x, :]
+#         #     cropped_true[i]=true[i,0:2*dim,  max_x-2*dim:max_x, :]
+#         #     j+=1
+            
+#         # #bottom right corner
+#         # elif max_y-2*dim<y[0]<=max_y and max_x-2*dim<x[0]<=max_x:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i,max_y-2*dim:max_y, max_x-2*dim:max_x, :]
+#         #     cropped_true[i]=true[i,max_y-2*dim:max_y, max_x-2*dim:max_x, :]
+#         #     j+=1
+            
+#         # #bottom left corner
+#         # elif max_y-2*dim<y[0]<=max_y and x[0] <=2*dim:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i,max_y-2*dim:max_y, 0:2*dim, :]
+#         #     cropped_true[i]=true[i,max_y-2*dim:max_y, 0:2*dim, :]
+#         #     j+=1
+            
+#         # #BORDERS
+        
+#         # #bottom border without corners
+#         # elif max_y-2*dim<=y[0]<max_y and 2*dim<x[0]<=max_x-2*dim:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i, max_y-2*dim:max_y, x[0]-dim:x[0]+dim,  :]
+#         #     cropped_true[i]=true[i, max_y-2*dim:max_y, x[0]-dim:x[0]+dim,  :]
+#         #     j+=1
+            
+#         # #top border without corners
+#         # elif y[0]-2*dim<=0 and 2*dim<x[0]<=max_x-2*dim:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i, 0:2*dim, x[0]-dim:x[0]+dim,  :]
+#         #     cropped_true[i]=true[i, 0:2*dim, x[0]-dim:x[0]+dim,  :]
+#         #     j+=1
+            
+#         # #left border without corners
+#         # elif 2*dim<y[0]<=max_y-2*dim and x[0]<=2*dim:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i,y[0]-dim:y[0]+dim,0:2*dim,  :]
+#         #     cropped_true[i]=true[i,y[0]-dim:y[0]+dim,0:2*dim,  :]
+#         #     j+=1
+            
+#         # #right border without corners
+#         # elif 2*dim<y[0]<=max_y-2*dim and max_x-2*dim<x[0]<=max_x:
+#         #     #print(i, x, y)
+#         #     cropped_reco[i]=reco[i, y[0]-dim:y[0]+dim, max_x-2*dim:max_x,  :]
+#         #     cropped_true[i]=true[i, y[0]-dim:y[0]+dim, max_x-2*dim:max_x,  :]
+#         #     j+=1
+ 
+        
+#         #CENTER OF IMAGE
+#         if 2*dim<y[0]<=max_y-2*dim and 2*dim<x[0]<=max_x-2*dim:
+#             #print(i, x, y)
+#             cropped_reco[i]=reco[i, y[0]-dim:y[0]+dim, x[0]-dim:x[0]+dim, :]
+#             cropped_true[i]=true[i, y[0]-dim:y[0]+dim, x[0]-dim:x[0]+dim, :]
+#             j+=1
+#         #assert i==j-1
+#     return cropped_true, cropped_reco
+
+
+