diff --git a/HCAL_bicycleGAN.ipynb b/HCAL_bicycleGAN.ipynb
index e862f9f..d884488 100644
--- a/HCAL_bicycleGAN.ipynb
+++ b/HCAL_bicycleGAN.ipynb
@@ -9,6 +9,7 @@
     "import scipy as sp\n",
     "import numpy as np\n",
     "import os \n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n",
     "\n",
     "import pickle\n",
     "\n",
@@ -16,7 +17,7 @@
     "import matplotlib.pyplot as plt\n",
     "from datetime import datetime\n",
     "\n",
-    "from architectures.bicycle_GAN import *\n"
+    "from architectures.bicycle_GAN import *"
    ]
   },
   {
@@ -30,44 +31,14 @@
     "\n",
     "# Option to save and restore hyperparameters\n",
     "\n",
-    "PATH='HCAL_bycicleGAN_test110'"
+    "PATH='test11'"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LEARNING_RATE:8e-05\n",
-      "BETA1:0.5\n",
-      "BATCH_SIZE:16\n",
-      "EPOCHS:4\n",
-      "SAVE_SAMPLE_PERIOD:400\n",
-      "SEED:1\n",
-      "d_sizes:{'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6a90>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6c50>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6c88>), (64, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6cc0>), (128, 4, 1, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6cf8>)], 'dense_layers': [(512, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6d30>), (64, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6d68>), (16, False, 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6da0>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6dd8>}\n",
-      "g_sizes_dec:{'deconv_layers': [(64, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6e10>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6e48>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6e80>), (8.0, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6eb8>), (1, 4, 2, False, 0.8, <function identity at 0x7f2e4fad6400>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6ef0>)]}\n",
-      "g_sizes_enc:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6f28>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6f60>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6f98>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b1f6fd0>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f2e3b20b048>)]}\n",
-      "e_sizes:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b0b8>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b0f0>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b128>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b160>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b198>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b1d0>), (128, 'bn', 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b208>), (16, False, 0.8, <function lrelu at 0x7f2e40f839d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b240>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f2e3b20b278>}\n",
-      "preprocess:False\n",
-      "cost_type:FEATURE\n",
-      "validating_size:2000\n",
-      "test_size:2000\n",
-      "n_batches:2\n",
-      "reco_path:/disk/lhcb_data/davide/HCAL_project_full_event/reco/\n",
-      "true_path:/disk/lhcb_data/davide/HCAL_project_full_event/true/\n",
-      "discr_steps:1\n",
-      "gen_steps:1\n",
-      "vae_steps:1\n",
-      "latent_weight:2\n",
-      "cycl_weight:1\n",
-      "kl_weight:1\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if task =='TRAIN' and os.path.exists(PATH+'/hyper_parameters.pkl'):\n",
     "    with open(PATH+'/hyper_parameters.pkl', 'rb') as f:  \n",
@@ -89,7 +60,6 @@
     "    g_sizes_enc = hyper_dict['g_sizes_enc']\n",
     "    g_sizes_dec = hyper_dict['g_sizes_dec']\n",
     "    e_sizes = hyper_dict['e_sizes']\n",
-    "    preprocess = hyper_dict['preprocess']\n",
     "    cost_type = hyper_dict['cost_type']\n",
     "    validating_size=hyper_dict['validating_size']\n",
     "    cycl_weight=hyper_dict['cycl_weight']\n",
@@ -106,32 +76,31 @@
     "    #reco_path = '/disk/lhcb_data/davide/HCAL_project_single_pion/piplus_cells_inout/piplus/reco/'\n",
     "    #true_path = '/disk/lhcb_data/davide/HCAL_project_single_pion/piplus_cells_inout/piplus/true/'\n",
     "    n_batches = 2\n",
-    "    test_size = 2000\n",
-    "    validating_size=2000\n",
+    "    test_size = 1000\n",
+    "    validating_size=1000\n",
     "    \n",
-    "    LEARNING_RATE = 8e-5\n",
+    "    LEARNING_RATE = 4e-5\n",
     "    BETA1 = 0.5\n",
-    "    BATCH_SIZE = 16\n",
+    "    BATCH_SIZE = 32\n",
     "    EPOCHS = 4\n",
     "    SAVE_SAMPLE_PERIOD = 400\n",
     "    SEED = 1\n",
-    "    preprocess=False\n",
     "    cost_type='FEATURE'\n",
     "    \n",
-    "    latent_weight=2\n",
+    "    latent_weight=1\n",
     "    cycl_weight=1\n",
     "    kl_weight=1\n",
     "    discr_steps=1\n",
     "    gen_steps=1\n",
     "    vae_steps=1\n",
-    "    \n",
-    "    latent_dims=16\n",
+    "\n",
+    "    latent_dims=128\n",
     "    ndf = 16\n",
     "    ngf = 16\n",
     "    nef = 16\n",
     "    s = 2\n",
     "    f = 4\n",
-    "    d = 0.8\n",
+    "    d = 0.7\n",
     "    \n",
     "    stddev_d=0.02\n",
     "    stddev_g=0.02\n",
@@ -147,7 +116,6 @@
     "                            (ngf*2, f,   s, 'bn',  1,  lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 13, 16, ngf*4) => (batch, 7, 8, ngf*4)\n",
     "                            (ngf*4, f,   s, 'bn',  1,  lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 7, 8, ngf*4) => (batch, 4, 4, ngf*4)\n",
     "                            (ngf*8, f,   s, 'bn',  d,  lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 4, 4, ngf*4) => (batch, 2, 2, ngf*4)\n",
-    "                            #(ngf*8, f, s, 'bn', 1, lrelu, tf.truncated_normal_initializer(stddev_g)),#(batch, 2, 2, ngf*4) => (batch, 1, 1, ngf*4)\n",
     "                        \n",
     "                       ],\n",
     "    }\n",
@@ -192,9 +160,6 @@
     "    e_sizes={\n",
     "        'latent_dims':latent_dims,\n",
     "        \n",
-    "        #'conv_layer_0':[\n",
-    "        #                    (nef,   f, s, False, 1,lrelu, tf.truncated_normal_initializer(stddev_e)),\n",
-    "        #                ],\n",
     "        'conv_layers':[\n",
     "            \n",
     "                            (nef/2, f,   s,   False, 1, lrelu, tf.random_normal_initializer(stddev_e)),\n",
@@ -205,51 +170,10 @@
     "                        ],\n",
     "\n",
     "        \n",
-    "        #'convblock_layer_0':[\n",
-    "        #                     (nef*2, 1, s, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 26, 32, ndf) => (batch, 13, 16, ndf*2)\n",
-    "        #                     (nef*2, f, 1, 'bn', d, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 13, 16, ndf*2) => (batch, 13, 16, ndf*2)\n",
-    "        #                     (nef*2, 1, 1, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 13, 16, ndf*2) => (batch, 13, 16, ndf*2)\n",
-    "        #                     \n",
-    "        #                ],\n",
-    "        #'convblock_shortcut_layer_0':[\n",
-    "        #                    (nef*2, 1, s, False, 1, tf.random_normal_initializer(stddev_e))\n",
-    "        #                ],\n",
-    "        #\n",
-    "        #'convblock_layer_1':[\n",
-    "        #                     (nef*4, 1, s, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 26, 32, ndf) => (batch, 13, 16, ndf*2)\n",
-    "        #                     (nef*4, f, 1, 'bn', d, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 13, 16, ndf*2) => (batch, 13, 16, ndf*2)\n",
-    "        #                     (nef*4, 1, 1, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 13, 16, ndf*2) => (batch, 13, 16, ndf*2)\n",
-    "        #                     \n",
-    "        #                ],\n",
-    "        #'convblock_shortcut_layer_1':[\n",
-    "        #                    (nef*4, 1, s, False, 1, tf.random_normal_initializer(stddev_e))\n",
-    "        #                ],\n",
-    "        #'convblock_layer_2':[\n",
-    "        #                     (nef*4, 1, s, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 26, 32, ndf) => (batch, 13, 16, ndf*2)\n",
-    "        #                     (nef*4, f, 1, 'bn', d, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 13, 16, ndf*2) => (batch, 7, 8, ndf*4)\n",
-    "        #                     (nef*4, 1, 1, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 7, 8, ndf*4) => (batch, 7, 8, ndf*8)\n",
-    "        #                     \n",
-    "        #                ],\n",
-    "        #\n",
-    "        #'convblock_shortcut_layer_2':[\n",
-    "        #                    (nef*4, 1, s, False, 1, tf.random_normal_initializer(stddev_e))\n",
-    "        #                ],\n",
-    "        \n",
-    "       # 'convblock_layer_3':[\n",
-    "       #                       (nef*8, 1, s, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 26, 32, ndf) => (batch, 13, 16, ndf*2)\n",
-    "       #                       (nef*8, f, 1, 'bn', 1, lrelu, tf.random_normal_initializer(stddev_e)), #(batch, 13, 16, ndf*2) => (batch, 7, 8, ndf*4)\n",
-    "       #                       (nef*8, 1, 1, 'bn', 1, tf.nn.relu,tf.random_normal_initializer(stddev_e)), #(batch, 7, 8, ndf*4) => (batch, 7, 8, ndf*8)\n",
-    "       #                       \n",
-    "       #                  ],\n",
-    "       # 'convblock_shortcut_layer_3':[\n",
-    "       #                      (nef*8, 1, s, False, 1, tf.random_normal_initializer(stddev_e))\n",
-    "       #                     ],\n",
-    "\n",
-    "        \n",
     "        'dense_layers':[    \n",
     "                            (nef*16, 'bn',   d, lrelu, tf.random_normal_initializer(stddev_e)),\n",
-    "                            (nef*8, 'bn',   d, lrelu, tf.random_normal_initializer(stddev_e)),\n",
-    "                            (nef,   False, d, lrelu, tf.random_normal_initializer(stddev_e)),\n",
+    "                            (nef*8,  'bn',   d, lrelu, tf.random_normal_initializer(stddev_e)),\n",
+    "                            (nef,     False, d, lrelu, tf.random_normal_initializer(stddev_e)),\n",
     "                      \n",
     "                        ],\n",
     "        'readout_layer_w_init':tf.random_normal_initializer(stddev_e)\n",
@@ -284,7 +208,6 @@
     "    g_sizes_enc = hyper_dict['g_sizes_enc']\n",
     "    g_sizes_dec = hyper_dict['g_sizes_dec']\n",
     "    e_sizes = hyper_dict['e_sizes']\n",
-    "    preprocess = hyper_dict['preprocess']\n",
     "    cost_type = hyper_dict['cost_type']\n",
     "    validating_size=hyper_dict['validating_size']\n",
     "    cycl_weight=hyper_dict['cycl_weight']\n",
@@ -297,49 +220,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
-    "dim=1\n",
-    "select=False\n",
-    "if preprocess=='normalise':\n",
-    "    train_true, test_true, min_true, max_true, train_reco, test_reco, min_reco, max_reco = load_data(true_path, reco_path, n_batches, select=select, n_cells=dim*dim, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
-    "else:\n",
-    "    train_true, test_true, train_reco, test_reco = load_data(true_path, reco_path, n_batches,  select=select, n_cells=None, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
+    "start_batch=0\n",
+    "train_true, test_true, train_TIS_true, test_TIS_true, train_TOS_true, test_TOS_true, train_reco, test_reco = load_data(true_path, reco_path, n_batches, start_batch,  test_size=test_size)\n",
     "    \n",
     "train_true, train_reco = delete_undetected_events_double(train_true, train_reco)\n",
-    "test_true, test_reco = delete_undetected_events_double(test_true, test_reco)\n"
+    "test_true, test_reco = delete_undetected_events_double(test_true, test_reco)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(42695, 52, 64, 1)"
-      ]
-     },
-     "execution_count": 50,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "train_true.shape"
+    "#train_true=train_true/1000.\n",
+    "#train_reco=train_reco/1000.\n",
+    "#\n",
+    "#test_true=test_true/1000.\n",
+    "#test_reco=test_reco/1000."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 792x288 with 2 Axes>"
       ]
@@ -349,38 +261,12 @@
     }
    ],
    "source": [
-    "if preprocess != False:\n",
-    "    draw_one_sample(train_true, train_reco, preprocess,\n",
-    "                    min_true=min_true, max_true=max_true, \n",
-    "                    min_reco=min_reco, max_reco=max_reco,\n",
-    "                    save=False, PATH=PATH\n",
-    "                   )\n",
-    "else:\n",
-    "    draw_one_sample(train_true,train_reco)"
+    "draw_one_sample(train_true,train_reco)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#train_reco_dict={}\n",
-    "#train_true_dict={}\n",
-    "#\n",
-    "#for i in range(train_true.shape[0]//10):\n",
-    "#    train_true_dict[i]=train_true[10*i:10*(i+1)]\n",
-    "#    train_reco_dict[i]=train_reco[10*i:10*(i+1)]\n",
-    "#\n",
-    "#train_reco_dict_summed=np.array([train_reco_dict[i].sum(axis=0) for i in range(train_true.shape[0]//10)])\n",
-    "#train_true_dict_summed=np.array([train_true_dict[i].sum(axis=0) for i in range(train_true.shape[0]//10)])\n",
-    "#train_reco=train_reco_dict_summed\n",
-    "#train_true=train_true_dict_summed"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -392,37 +278,35 @@
     "    \n",
     "    _, n_H_A, n_W_A ,n_C = train_true.shape\n",
     "    _, n_H_B, n_W_B ,n_C = train_reco.shape\n",
-    "    \n",
     "    gan = bicycle_GAN(n_H_A, n_W_A, n_H_B, n_W_B, n_C,\n",
     "                   min_true=min_true, max_true=max_true, \n",
     "                   min_reco=min_reco, max_reco=max_reco,\n",
     "                   d_sizes=d_sizes, g_sizes_enc=g_sizes_enc, g_sizes_dec=g_sizes_dec, e_sizes=e_sizes,\n",
     "                   lr=LEARNING_RATE, beta1=BETA1,\n",
-    "                   preprocess=preprocess, cost_type=cost_type,\n",
-    "                   cycl_weight=cycl_weight, latent_weight=latent_weight, kl_weight=kl_weight,\n",
+    "                   cost_type=cost_type, cycl_weight=cycl_weight, latent_weight=latent_weight, kl_weight=kl_weight,\n",
     "                   discr_steps=discr_steps, gen_steps=gen_steps, vae_steps=vae_steps,\n",
     "                   batch_size=BATCH_SIZE, epochs=EPOCHS,\n",
     "                   save_sample=SAVE_SAMPLE_PERIOD, path=PATH, seed= SEED)\n",
     "    \n",
     "    vars_to_train= tf.trainable_variables()\n",
-    "        \n",
+    "    \n",
     "    if task == 'TRAIN':\n",
-    "        \n",
+    "    \n",
     "        init_op = tf.global_variables_initializer()\n",
-    "        \n",
-    "        \n",
+    "    \n",
+    "    \n",
     "    if task == 'TEST':\n",
-    "        \n",
+    "    \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",
+    "            \n",
     "    saver=tf.train.Saver()\n",
     "    # Add ops to save and restore all the variables.\n",
     "    \n",
     "    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.15)\n",
     "    \n",
-    "    with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n",
+    "    with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options )) as sess:\n",
     "        \n",
     "        sess.run(init_op)\n",
     "        \n",
@@ -462,17 +346,12 @@
     "        while not done:\n",
     "            plt.clf()\n",
     "            #j = int(input(\"Input event number\"))\n",
-    "            if preprocess:\n",
-    "                draw_nn_sample(test_true, test_reco, 1, preprocess,\n",
-    "                              min_true=min_true, max_true=max_true, \n",
-    "                              min_reco=min_reco, max_reco=max_reco,\n",
-    "                              f=gan.get_sample_A_to_B, save=False, is_training=False, PATH=PATH)\n",
-    "            else:\n",
-    "                draw_nn_sample(test_true, test_reco, 1, preprocess,\n",
+    "\n",
+    "            draw_nn_sample(test_true, test_reco, 1,\n",
     "                              f=gan.get_sample_A_to_B, save=True, is_training=False, PATH=PATH)\n",
     "            \n",
     "            ans = input(\"Generate another?\")\n",
-    "            if ans and ans[0] in ('n' or 'N'):\n",
+    "            if ans and ans[0] in ('n' , 'N'):\n",
     "                done = True\n",
     "        \n",
     "        return test_reco_NN"
@@ -480,7 +359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "metadata": {
     "scrolled": false
    },
@@ -494,112 +373,111 @@
       "Encoder_B\n",
       "Convolution\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
-      "Encoder output shape (?, 16)\n",
+      "Encoder output shape (?, 128)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
-      "After conv layer1\n",
-      "shape:  (?, 26, 32, 24)\n",
-      "After conv layer2\n",
-      "shape:  (?, 13, 16, 32)\n",
-      "After conv layer3\n",
-      "shape:  (?, 7, 8, 48)\n",
-      "After conv layer4\n",
-      "shape:  (?, 4, 4, 80)\n",
-      "After conv layer5\n",
-      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 576)\n",
-      "After deconv layer 1\n",
-      "Shape (?, 4, 4, 80)\n",
-      "After deconv layer 2\n",
-      "Shape (?, 7, 8, 48)\n",
-      "After deconv layer 3\n",
-      "Shape (?, 13, 16, 32)\n",
-      "After deconv layer 4\n",
-      "Shape (?, 26, 32, 24)\n",
+      " and input for generator decoder shape (?, 1, 1, 1024)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
-      "After conv layer1\n",
-      "shape:  (?, 26, 32, 24)\n",
-      "After conv layer2\n",
-      "shape:  (?, 13, 16, 32)\n",
-      "After conv layer3\n",
-      "shape:  (?, 7, 8, 48)\n",
-      "After conv layer4\n",
-      "shape:  (?, 4, 4, 80)\n",
-      "After conv layer5\n",
-      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 576)\n",
-      "After deconv layer 1\n",
-      "Shape (?, 4, 4, 80)\n",
-      "After deconv layer 2\n",
-      "Shape (?, 7, 8, 48)\n",
-      "After deconv layer 3\n",
-      "Shape (?, 13, 16, 32)\n",
-      "After deconv layer 4\n",
-      "Shape (?, 26, 32, 24)\n",
+      " and input for generator decoder shape (?, 1, 1, 1024)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "Encoder_B\n",
       "Convolution\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
-      "Encoder output shape (?, 16)\n",
+      "Encoder output shape (?, 128)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 32)\n",
+      "Feature output shape (?, 64)\n",
       "Logits shape (?, 1)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 32)\n",
+      "Feature output shape (?, 64)\n",
       "Logits shape (?, 1)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 32)\n",
+      "Feature output shape (?, 64)\n",
       "Logits shape (?, 1)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
-      "After conv layer1\n",
-      "shape:  (?, 26, 32, 24)\n",
-      "After conv layer2\n",
-      "shape:  (?, 13, 16, 32)\n",
-      "After conv layer3\n",
-      "shape:  (?, 7, 8, 48)\n",
-      "After conv layer4\n",
-      "shape:  (?, 4, 4, 80)\n",
-      "After conv layer5\n",
-      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 576)\n",
-      "After deconv layer 1\n",
-      "Shape (?, 4, 4, 80)\n",
-      "After deconv layer 2\n",
-      "Shape (?, 7, 8, 48)\n",
-      "After deconv layer 3\n",
-      "Shape (?, 13, 16, 32)\n",
-      "After deconv layer 4\n",
-      "Shape (?, 26, 32, 24)\n",
+      " and input for generator decoder shape (?, 1, 1, 1024)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "\n",
-      " Evaluate model on test set...\n",
-      "INFO:tensorflow:Restoring parameters from HCAL_bycicleGAN_test97/HCAL_bycicleGAN_test97bicycle.ckpt\n",
-      "Model restored.\n",
-      "Per event simulation time 0:00:00.002158\n",
-      "Generate another?n\n"
+      " ****** \n",
+      "\n",
+      "Training bicycleGAN with a total of 38000 samples distributed in 1187 batches of size 32\n",
+      "\n",
+      "The validation set consists of 1000 images\n",
+      "The learning rate is 4e-05, and every 400 batches a generated sample will be saved to test11\n",
+      "\n",
+      " ****** \n",
+      "\n",
+      "Epoch: 0\n",
+      "At iter: 400  -  dt: 0:00:00.220792 - d_acc: 0.55, - d_acc_enc: 0.67\n",
+      "Discriminator cost 39.1, Generator cost 2117, VAE Cost 2724, KL divergence cost 1788\n",
+      "Saving a sample...\n",
+      "At iter: 800  -  dt: 0:00:00.335084 - d_acc: 0.41, - d_acc_enc: 0.53\n",
+      "Discriminator cost 55.4, Generator cost 936.6, VAE Cost 3188, KL divergence cost 2038\n",
+      "Saving a sample...\n",
+      "Printing validation set histograms at epoch 0\n",
+      "ET Distribution plots are being printed...\n",
+      "Done\n",
+      "Resolution plots are being printed...\n",
+      "Done\n",
+      "Epoch: 1\n",
+      "At iter: 1200  -  dt: 0:00:00.261578 - d_acc: 0.48, - d_acc_enc: 0.61\n",
+      "Discriminator cost 41.5, Generator cost 1153, VAE Cost 2441, KL divergence cost 1839\n",
+      "Saving a sample...\n",
+      "At iter: 1600  -  dt: 0:00:00.338094 - d_acc: 0.58, - d_acc_enc: 0.77\n",
+      "Discriminator cost 29.82, Generator cost 451, VAE Cost 2171, KL divergence cost 1646\n",
+      "Saving a sample...\n",
+      "At iter: 2000  -  dt: 0:00:00.337647 - d_acc: 0.55, - d_acc_enc: 0.69\n",
+      "Discriminator cost 27.23, Generator cost 448.8, VAE Cost 1555, KL divergence cost 1172\n",
+      "Saving a sample...\n",
+      "Printing validation set histograms at epoch 1\n",
+      "ET Distribution plots are being printed...\n",
+      "Done\n",
+      "Resolution plots are being printed...\n",
+      "Done\n",
+      "Epoch: 2\n",
+      "At iter: 2400  -  dt: 0:00:00.258182 - d_acc: 0.45, - d_acc_enc: 0.77\n",
+      "Discriminator cost 28.38, Generator cost 583, VAE Cost 1556, KL divergence cost 1319\n",
+      "Saving a sample...\n",
+      "At iter: 2800  -  dt: 0:00:00.801696 - d_acc: 0.55, - d_acc_enc: 0.69\n",
+      "Discriminator cost 25.6, Generator cost 375.7, VAE Cost 1093, KL divergence cost 801\n",
+      "Saving a sample...\n",
+      "At iter: 3200  -  dt: 0:00:00.346768 - d_acc: 0.47, - d_acc_enc: 0.61\n",
+      "Discriminator cost 19.62, Generator cost 323.6, VAE Cost 1117, KL divergence cost 866\n",
+      "Saving a sample...\n",
+      "Printing validation set histograms at epoch 2\n",
+      "ET Distribution plots are being printed...\n",
+      "Done\n",
+      "Resolution plots are being printed...\n",
+      "Done\n",
+      "Epoch: 3\n",
+      "At iter: 3600  -  dt: 0:00:00.259401 - d_acc: 0.42, - d_acc_enc: 0.56\n",
+      "Discriminator cost 28.89, Generator cost 337.9, VAE Cost 1047, KL divergence cost 834.6\n",
+      "Saving a sample...\n",
+      "At iter: 4000  -  dt: 0:00:00.336109 - d_acc: 0.50, - d_acc_enc: 0.67\n",
+      "Discriminator cost 18.27, Generator cost 336.2, VAE Cost 891.9, KL divergence cost 670.5\n",
+      "Saving a sample...\n",
+      "At iter: 4400  -  dt: 0:00:00.337731 - d_acc: 0.45, - d_acc_enc: 0.64\n",
+      "Discriminator cost 17.73, Generator cost 348.3, VAE Cost 915.9, KL divergence cost 722.8\n",
+      "Saving a sample...\n",
+      "Printing validation set histograms at epoch 3\n",
+      "ET Distribution plots are being printed...\n",
+      "Done\n",
+      "Resolution plots are being printed...\n",
+      "Done\n",
+      "Model saved in path: test11/test11bicycle.ckpt\n",
+      "Per event simulation time 0:00:00.003212\n"
      ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 6 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -639,36 +517,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 97,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(6120.0, 1530.0)"
+       "(6279.8237, 1587.4055)"
       ]
      },
-     "execution_count": 55,
+     "execution_count": 97,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "train_reco[:,12:40,16:48,:].max(),train_reco[:,0:12,0:16,:].max()"
+    "test_reco_NN[:,12:40,16:48,:].max(),test_reco_NN[:,0:12,0:16,:].max()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 98,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "31.492105"
+       "61.562237"
       ]
      },
-     "execution_count": 56,
+     "execution_count": 98,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -679,27 +557,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scale=test_reco_NN.std()/test_reco.std()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "55.924515"
+       "18.508837"
       ]
      },
-     "execution_count": 57,
+     "execution_count": 100,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "test_reco_NN.std()"
+    "scale"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 93,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -707,7 +594,7 @@
     "test_reco_MC_hist = np.sum(test_reco_MC_hist,axis=1)\n",
     "max_MC_hist = np.max(test_reco_MC_hist)\n",
     "\n",
-    "test_reco_NN_test=test_reco_NN/2.2\n",
+    "test_reco_NN_test=test_reco_NN/1.5\n",
     "test_reco_NN_hist= test_reco_NN_test.reshape(test_reco_NN.shape[0],test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
     "test_reco_NN_hist = np.sum(test_reco_NN_hist,axis=1)\n",
     "max_NN_hist = np.max(test_reco_NN_hist)\n",
@@ -721,27 +608,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 74,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(27216.0, 21176.656)"
+       "2.3242261"
       ]
      },
-     "execution_count": 94,
+     "execution_count": 74,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "max_MC_hist, max_NN_hist"
+    "max_NN_hist/max_MC_hist"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 95,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -751,12 +638,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 96,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x360 with 2 Axes>"
       ]
@@ -788,12 +675,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 97,
+   "execution_count": 77,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1296x432 with 3 Axes>"
       ]
@@ -805,19 +692,19 @@
    "source": [
     "plt.subplot(1,3,1)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_reco = plt.hist(test_true_hist/1000,bins=30, edgecolor='black');\n",
+    "h_reco = plt.hist(test_true_hist/1000, range=(0,140),bins=30, edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "plt.ylabel('dN/dE_T', fontsize=15)\n",
     "plt.title('Pion E_T from tracking', fontsize=15)\n",
     "plt.subplot(1,3,2)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_reco = plt.hist(test_reco_MC_hist/1000,bins=30,  edgecolor='black');\n",
+    "h_reco = plt.hist(test_reco_MC_hist/1000, range=(0,140), bins=30,  edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "\n",
     "plt.title('Pion Reco E_T from Geant4', fontsize=15)\n",
     "plt.subplot(1,3,3)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_nn = plt.hist(test_reco_NN_hist/1000, bins=30,  edgecolor='black');\n",
+    "h_nn = plt.hist(test_reco_NN_hist/1000, range=(0,140), bins=30,  edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "\n",
     "plt.title('Pion Reco E_T from BicycleGAN', fontsize=15)\n",
@@ -828,12 +715,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 98,
+   "execution_count": 78,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -848,12 +735,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": 79,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAEh9JREFUeJzt3X+QXXV5x/H3wyYkJLCGQAghiyQ6WwVpLXRriXQcB3QEygB20MZxamrTSafjKCodhTpTp//p1BFiW7EZUKJDERppYZgWxomo0+k0NfxQIhGD/NwQk6BAwg9jsjz94560281ucs69e3Nvvnm/Znb23nOfPfvs2d1Pvjn73HMjM5EkleuYXjcgSeoug16SCmfQS1LhDHpJKpxBL0mFM+glqXAGvSQVzqCXpMIZ9JJUuBm9bgDg2JiVs5nb6zYkqedioP76e9fYL57LzAWHquuLoJ/NXH4vLux1G5LUcwPHD9auvffFrz5Vp85TN5JUOINekgpn0EtS4Qx6SSqcQS9JhTvk1E1EfBW4FNiRmWdX2+YDtwFLgCeB92fm8xERwGrgEuAV4E8y84HutC6pFAOD9SdNxnbt6mInvdeNr6/Oiv5m4KIJ264B1mfmMLC+ug9wMTBcva0CbpieNiVJ7Tpk0Gfm94FfTth8ObC2ur0WuGLc9q9ny38B8yJi0XQ1K0lqrt1z9AszcxtA9f6Uavti4JlxdaPVNklSj0z3M2Njkm2Tvvp4RKyidXqH2cyZ5jYkSfu1u6Lfvv+UTPV+R7V9FDh9XN0Q8OxkO8jMNZk5kpkjM5nVZhuSpENpN+jvAlZUt1cAd47b/qFoOQ94cf8pHklSb9QZr7wVeCdwckSMAp8FPgfcHhErgaeB91Xl/0ZrtPIxWuOVH+5Cz5KkBg4Z9Jn5gSkeOuByk5mZwEc6bUrS0aXJ7PiMoe7Md+wb3dqV/fYDnxkrSYUz6CWpcAa9JBXOoJekwhn0klQ4g16SCtcXLw4uHY28NG97Sh6D7BZX9JJUOINekgpn0EtS4Qx6SSqcQS9JhTPoJalwjldKPVL6yKTjo/3DFb0kFc6gl6TCGfSSVDiDXpIKZ9BLUuEMekkqnOOVkrrCkcn+4Ypekgpn0EtS4Qx6SSqcQS9JhTPoJalwBr0kFc6gl6TCOUcvHQFmDC2uXZsnzKldG7tfqb/fXbtr1zblzH13uaKXpMIZ9JJUOINekgpn0EtS4Qx6SSqcQS9JhXO8UjqIgTOHG9WPbd7SlT6ajDZGl/brCOSRq6MVfUR8IiJ+HBGbIuLWiJgdEUsjYkNEbImI2yLi2OlqVpLUXNtBHxGLgY8BI5l5NjAALAc+D1yXmcPA88DK6WhUktSeTs/RzwCOi4gZwBxgG3ABsK56fC1wRYefQ5LUgbaDPjO3Al8AnqYV8C8C9wMvZOa+qmwUqP/cbUnStOvk1M2JwOXAUuA0YC5w8SSlOcXHr4qIjRGxcS972m1DknQInZy6eRfwRGbuzMy9wB3A24F51akcgCHg2ck+ODPXZOZIZo7MZFYHbUiSDqaT8cqngfMiYg7wKnAhsBG4D7gS+CawAriz0yal6TQwOFi/eOv2rvXR5IqU+0a31t9xgzHIJj002a/6Syfn6DfQ+qPrA8DD1b7WAJ8GPhkRjwEnATdNQ5+SpDZ19ISpzPws8NkJmx8H3tbJfiVJ08dLIEhS4Qx6SSqcQS9JhTPoJalwXr1SR50YPKFr+57RYN/dfLHtuhqNbeqI5Ypekgpn0EtS4Qx6SSqcQS9JhTPoJalwBr0kFc6gl6TCOUevo06T2fFGl/EF8oQ59Ysb1A406GHMywlrAlf0klQ4g16SCmfQS1LhDHpJKpxBL0mFM+glqXCOV+oAA4ODjeqPtHG+Jl9f08v4NhnHHFs0v3btQJNLK3fp+9F01NRLIPcPV/SSVDiDXpIKZ9BLUuEMekkqnEEvSYUz6CWpcI5X6gDdHJdsMtrYpI8mo39NrjC5+5KzatcCDP7s5dq1r556XO3a2T/o/aii45JHLlf0klQ4g16SCmfQS1LhDHpJKpxBL0mFM+glqXCOV6pj/TAy+avfOLV2bRMzX36tUf0xL/2qdu3c7z1Vu3asQQ/d+n7oyOWKXpIKZ9BLUuEMekkqXEdBHxHzImJdRPwkIjZHxLKImB8R346ILdX7E6erWUlSc52u6FcD92Tmm4G3ApuBa4D1mTkMrK/uS5J6pO2gj4hB4B3ATQCZ+evMfAG4HFhbla0Frui0SUlS+zpZ0b8B2Al8LSIejIgbI2IusDAztwFU70+Zhj4lSW3qZI5+BnAu8NHM3BARq2lwmiYiVgGrAGZT/7Kxak+T2eoYPKFrffzyyrfUrl2w7se1a2dt687P0MzjZ3dlv9C9GXZn4zVRJyv6UWA0MzdU99fRCv7tEbEIoHq/Y7IPzsw1mTmSmSMzmdVBG5Kkg2k76DPz58AzEfGmatOFwCPAXcCKatsK4M6OOpQkdaTTSyB8FLglIo4FHgc+TOsfj9sjYiXwNPC+Dj+HJKkDHQV9Zj4EjEzy0IWd7FeSNH18ZqwkFc6gl6TCeZnio0STkbuBxQsb7Tt2v1K7ds9lL9SvfXK4du3M3b+uXTt6Qf3x0dffsKl2LXRvtNFLD6sTruglqXAGvSQVzqCXpMIZ9JJUOINekgpn0EtS4RyvPErE7/5m/eKXftVo33lC/StHLvhS/drZP/157dqXzllcu/akR/bVru2XUcV+6UNHJlf0klQ4g16SCmfQS1LhDHpJKpxBL0mFM+glqXAGvSQVzjl6HeCJP1rQqP607++pv+8/rP8jN+u5M2rXLv1i/csJx2D9yxRng8sDN+VsvA4XV/SSVDiDXpIKZ9BLUuEMekkqnEEvSYUz6CWpcI5X9pmBBuN8TcYEn7qgfm1Tv3jLrNq1g4/W3+/Ml7N+8eKFtUtz6/au7BdgbPOWRvXS4eCKXpIKZ9BLUuEMekkqnEEvSYUz6CWpcAa9JBXO8crDYODM4dq1exbVH69sMtbYxL7jGow1AvuWvdqVPt543Vj94gYjk42uGukVJlUAV/SSVDiDXpIKZ9BLUuEMekkqnEEvSYXrOOgjYiAiHoyIu6v7SyNiQ0RsiYjbIuLYztuUJLVrOsYrrwI2A/vnAj8PXJeZ34yIrwArgRum4fMcsRpd0XDR79Qu3XNS/d1uXvXl2rXD3/iL+jsGZv1wTu3aM255qnZtnlB/v5Km1tGKPiKGgD8AbqzuB3ABsK4qWQtc0cnnkCR1ptNTN9cDnwJeq+6fBLyQmfuq+6PA4sk+MCJWRcTGiNi4lz0dtiFJmkrbQR8RlwI7MvP+8ZsnKZ30aZaZuSYzRzJzZCbdeYanJKmzc/TnA5dFxCXAbFrn6K8H5kXEjGpVPwQ823mbkqR2tb2iz8xrM3MoM5cAy4HvZOYHgfuAK6uyFcCdHXcpSWpbN+boPw18MiIeo3XO/qYufA5JUk3TcvXKzPwu8N3q9uPA26Zjv5KkznmZ4jYNDNa/nHAT7/37e2rX3rPz7Nq19+/5dTvt1PL6GzbVrm1yAeSx0a3Nm5F0AC+BIEmFM+glqXAGvSQVzqCXpMIZ9JJUOINekgrneGVlxtCk116b0uN/dkbt2gXLttWuPW3mxtq1Fy2oP9a4/ParatcO3/xc7VqA195U/1gc82j9yxRLmh6u6CWpcAa9JBXOoJekwhn0klQ4g16SCmfQS1LhHK+svHROs/HKJiOTo1tOqV179S/eX7v2tFuPrV07d8lkr/I4ha3b69fSbLUwtmtXo31L6pwrekkqnEEvSYUz6CWpcAa9JBXOoJekwhn0klS4oscrB84crl37/MrdjfZ975nfqF379tGP167d92p3viUL/+4/a9eONdx3k+OM45XSYeeKXpIKZ9BLUuEMekkqnEEvSYUz6CWpcAa9JBXOoJekwh1xc/QDg4O1a3cuO7l27dfeurpRHz/YU//Sw0287qEGlx7+3qbatU1n45sY27yli3uX1ClX9JJUOINekgpn0EtS4Qx6SSqcQS9JhTPoJalwbY9XRsTpwNeBU4HXgDWZuToi5gO3AUuAJ4H3Z+bzB93XwDEMHF9vbHLPSP1L4j53/t7atctvv6p2LcCsX0bt2tc/sq927fEPPlW7dl+DS/7OGFpcf7+jW2vXSup/nazo9wFXZ+aZwHnARyLiLOAaYH1mDgPrq/uSpB5pO+gzc1tmPlDd3g1sBhYDlwNrq7K1wBWdNilJat+0nKOPiCXAOcAGYGFmboPWPwZAd55CKkmqpeNLIETE8cC3gI9n5q6IeueuI2IVsApgdszttA1J0hQ6WtFHxExaIX9LZt5Rbd4eEYuqxxcBOyb72Mxck5kjmTly7DGzO2lDknQQbQd9tJbuNwGbM/OL4x66C1hR3V4B3Nl+e5KkTnVy6uZ84I+BhyPioWrbXwGfA26PiJXA08D7DrWjsdcdxwvvOavWJ9327vqjiqvf8U+1a6++Y8Whi8YZ+s7u2rX5g4fr1za4OmcTjkxKR6+2gz4z/wOY6oT8he3uV5I0vXxmrCQVzqCXpMIZ9JJUOINekgpn0EtS4frixcFjb3LcjnpXmpxxXP2XuV795x+oXTu87bnatQBs3V67tMkLc481uCKlJNXhil6SCmfQS1LhDHpJKpxBL0mFM+glqXAGvSQVzqCXpML1xRz9MXvHmLWt3vz4G6+r/yIlA9t21q7NXfUvOwzOu0s6criil6TCGfSSVDiDXpIKZ9BLUuEMekkqnEEvSYWLzOx1D0TETuCpw/gpTwYaXpe4L9j34WXfh5d9N3dGZi44VFFfBP3hFhEbM3Ok1300Zd+Hl30fXvbdPZ66kaTCGfSSVLijNejX9LqBNtn34WXfh5d9d8lReY5eko4mR+uKXpKOGkUHfUScHhH3RcTmiPhxRFxVbZ8fEd+OiC3V+xN73etkImIgIh6MiLur+0sjYkPV920RcWyve5woIuZFxLqI+El13JcdCcc7Ij5R/YxsiohbI2J2vx7viPhqROyIiE3jtk16jKPlSxHxWET8KCLO7aOe/7b6OflRRPxLRMwb99i1Vc+PRsR7etHzuF4O6H3cY38ZERkRJ1f3++J4T1R00AP7gKsz80zgPOAjEXEWcA2wPjOHgfXV/X50FbB53P3PA9dVfT8PrOxJVwe3GrgnM98MvJVW/319vCNiMfAxYCQzzwYGgOX07/G+GbhowrapjvHFwHD1tgq44TD1ONHNHNjzt4GzM/O3gJ8C1wJUv6PLgbdUH/PliBg4fK0e4GYO7J2IOB14N/D0uM39crz/v8w8at6AO2l9Yx4FFlXbFgGP9rq3SXodovULewFwNxC0npQxo3p8GXBvr/uc0PMg8ATV337Gbe/r4w0sBp4B5tN6jYa7gff08/EGlgCbDnWMgX8EPjBZXa97nvDYe4FbqtvXAteOe+xeYFk/He9q2zpai5kngZP77XiPfyt9Rf+/ImIJcA6wAViYmdsAqven9K6zKV0PfAp4rbp/EvBCZu6r7o/SCqh+8gZgJ/C16pTTjRExlz4/3pm5FfgCrZXZNuBF4H76/3iPN9Ux3v+P2H79+nX8KfDv1e2+7zkiLgO2ZuYPJzzUl70fFUEfEccD3wI+npl9/9JQEXEpsCMz7x+/eZLSfhuZmgGcC9yQmecAL9Nnp2kmU53PvhxYCpwGzKX1X/CJ+u1419H3PzcR8Rlap1lv2b9pkrK+6Tki5gCfAf56socn2dbz3osP+oiYSSvkb8nMO6rN2yNiUfX4ImBHr/qbwvnAZRHxJPBNWqdvrgfmRcT+l38cAp7tTXtTGgVGM3NDdX8dreDv9+P9LuCJzNyZmXuBO4C30//He7ypjvEocPq4ur76OiJiBXAp8MGsznXQ5z0Db6S1KPhh9Ts6BDwQEafSp70XHfQREcBNwObM/OK4h+4CVlS3V9A6d983MvPazBzKzCW0/ij1ncz8IHAfcGVV1o99/xx4JiLeVG26EHiEPj/etE7ZnBcRc6qfmf199/XxnmCqY3wX8KFqGuQ84MX9p3h6LSIuAj4NXJaZr4x76C5geUTMioiltP6w+d+96HEymflwZp6SmUuq39FR4Nzq578/j3ev/0jQ5T+g/D6t/zb9CHioeruE1vnu9cCW6v38Xvd6kK/hncDd1e030PqBfwz4Z2BWr/ubpN/fBjZWx/xfgROPhOMN/A3wE2AT8A1gVr8eb+BWWn9L2EsrZFZOdYxpnUr4B+BnwMO0Jov6pefHaJ3P3v+7+ZVx9Z+pen4UuLjfjveEx5/k//4Y2xfHe+Kbz4yVpMIVfepGkmTQS1LxDHpJKpxBL0mFM+glqXAGvSQVzqCXpMIZ9JJUuP8BiLrW/RkQNZwAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -868,12 +755,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 100,
+   "execution_count": 80,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x288 with 1 Axes>"
       ]
@@ -883,7 +770,7 @@
     }
    ],
    "source": [
-    "idx = np.arange(0,110, step=110/30)\n",
+    "idx = np.arange(0,140, step=140/30)\n",
     "diff=plt.bar(idx, \n",
     "             height=(h_nn[0]-h_reco[0]), edgecolor='black', \n",
     "             linewidth=1, color='lightblue',width = 3.4, align = 'edge') \n",
@@ -897,16 +784,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 138,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "32.47053"
+       "17.12299"
       ]
      },
-     "execution_count": 138,
+     "execution_count": 81,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -917,16 +804,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 139,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "11.406392"
+       "11.471488"
       ]
      },
-     "execution_count": 139,
+     "execution_count": 82,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -937,14 +824,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 140,
+   "execution_count": 83,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x432 with 1 Axes>"
       ]
@@ -972,15 +859,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 84,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "four cells diff mean 270.8730773925781, std 2287.71044921875\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "four_cells_diff= four_cells_diff_NN-four_cells_diff_MC\n",
     "plt.title('4 max_cells ET from Geant4  - 4 max cells ET from NN (GeV)')\n",
-    "plt.hist((four_cells_diff)/1000, bins=30, label = 'MC-NN',  histtype='step');\n",
+    "plt.hist((four_cells_diff)/1000, bins=30, range=(-10,10), label = 'MC-NN',  histtype='step');\n",
     "plt.xlabel('E_T (GeV)')\n",
     "plt.legend();\n",
     "print('four cells diff mean {0}, std {1}'.format(four_cells_diff.mean(), four_cells_diff.std()))\n",
@@ -991,7 +896,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 142,
+   "execution_count": 85,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1005,7 +910,6 @@
     "            'g_sizes_dec':g_sizes_dec,\n",
     "            'g_sizes_enc':g_sizes_enc,\n",
     "            'e_sizes':e_sizes,\n",
-    "            'preprocess':preprocess,\n",
     "            'cost_type':cost_type,\n",
     "            'validating_size':validating_size,\n",
     "            'test_size':test_size,\n",
@@ -1023,7 +927,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 143,
+   "execution_count": 86,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1040,6 +944,125 @@
   },
   {
    "cell_type": "code",
+   "execution_count": 87,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "b=(test_reco_NN_test-test_reco)/1000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "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.hist(b.sum(axis=(1,2,3)),bins=40);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-5.5727487"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b.sum(axis=(1,2,3)).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "17.039783"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "b.sum(axis=(1,2,3)).std()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1000, 52, 64, 1)"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "test_reco_NN_test.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fd080107978>"
+      ]
+     },
+     "execution_count": 36,
+     "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": [
+    "plt.imshow(test_reco_NN_test[1].reshape(52,64))"
+   ]
+  },
+  {
+   "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
diff --git a/arb_act_funct.nb b/arb_act_funct.nb
index c30c5b6..bad5407 100644
--- a/arb_act_funct.nb
+++ b/arb_act_funct.nb
@@ -10,10 +10,10 @@
 NotebookFileLineBreakTest
 NotebookFileLineBreakTest
 NotebookDataPosition[       158,          7]
-NotebookDataLength[     51212,       1034]
-NotebookOptionsPosition[     49458,        995]
-NotebookOutlinePosition[     49816,       1011]
-CellTagsIndexPosition[     49773,       1008]
+NotebookDataLength[     53003,       1057]
+NotebookOptionsPosition[     51255,       1018]
+NotebookOutlinePosition[     51608,       1034]
+CellTagsIndexPosition[     51565,       1031]
 WindowFrame->Normal*)
 
 (* Beginning of Notebook Content *)
@@ -24,9 +24,13 @@
  RowBox[{
   RowBox[{"F", "[", "x_", "]"}], ":=", 
   RowBox[{"Max", "[", 
-   RowBox[{"0", ",", 
+   RowBox[{
+    RowBox[{"0.001", "*", "x"}], ",", 
     RowBox[{"Min", "[", 
-     RowBox[{"6.12", ",", "x"}], "]"}]}], "]"}]}], "\[IndentingNewLine]", 
+     RowBox[{
+      RowBox[{"6.12", "+", 
+       RowBox[{"0.001", "*", "x"}]}], ",", "x"}], "]"}]}], 
+   "]"}]}], "\[IndentingNewLine]", 
  RowBox[{"Plot", "[", 
   RowBox[{
    RowBox[{"F", "[", "x", "]"}], ",", 
@@ -42,8 +46,9 @@
   3.757828761767972*^9, 3.757828762019991*^9}, {3.7578354214131813`*^9, 
   3.757835497958188*^9}, {3.7582826826943827`*^9, 3.758282706258882*^9}, {
   3.758282745491208*^9, 3.758282817357716*^9}, {3.758285016173664*^9, 
-  3.758285024088009*^9}},
- CellLabel->"In[45]:=",ExpressionUUID->"b345f780-c762-422b-bb72-4f3dcbf7d3d9"],
+  3.758285024088009*^9}, {3.772183756825553*^9, 3.772183778136739*^9}, {
+  3.772183812227013*^9, 3.772183831523756*^9}},
+ CellLabel->"In[21]:=",ExpressionUUID->"b345f780-c762-422b-bb72-4f3dcbf7d3d9"],
 
 Cell[BoxData[
  FormBox[
@@ -51,18 +56,27 @@
       TagBox[
        {RGBColor[0.368417, 0.506779, 0.709798], AbsoluteThickness[1.6], 
         Opacity[1.], LineBox[CompressedData["
-1:eJxTTMoPSmViYGDQAWIQbX275PX//8oHGKDgxs6F7z1/I/hlM859nvwNwd8Q
-qvFH/S2Cr3LhNk/ALQSf56iT3oItCP69dQKFDpkIfmPTmm8Nl5Tg/E7x7NNL
-uxXhfLkjGouLoxTg/J+eF7Rq4uTgfKvnMYsirkrD+dM3P5dvL5eE8yuiGwz+
-PhOD899ky5TlJInA+TWrtx3U5RSC8+V79zrk/uKD8+sUubiULbngfOb2WNvT
-/axw/sTFZ6YxNTLA+attCn7snvh9P4zf4fBXTmntKzh/u0LYu+MxCP4zhvV7
-c3kQfNeDCTE7s1/C+UxOR2YGaL2A82ucu0Xqlz+F8/PdJLnuLHwA589TK7rZ
-GIjgn2M7vUKdEcGP6PvZ9+zAPTj/Uv8BTlG7O3D+sUl+/wstrsP5UYZXr4RH
-nYLzl5w0F52hdxLOf584K/QG0wk4v2VS/LWI1Ufh/PWfX16P/HMAzhe48Ss7
-v3IdnG9l2ZpbcGolnJ86iz+/UHopnF+y0+PJs6rpcP6k77vOXbTsQYSfyJ45
-TdOb4XwA5ba/ag==
-         "]], LineBox[CompressedData["
-1:eJxTTMoPSmViYGAwBGIQ/Uxkz5ym6c32MNo9Zm5LW8wCOP1pZkdjy66VcHpJ
+1:eJwBEQPu/CFib1JlAgAAADAAAAACAAAAO9t06///I8CIt6Qy4XqEv9i5oe9J
++yPAYEFBRQ52hL92mM7zk/YjwDnL3Vc7cYS/sFUo/CftI8Dq3hZ9lWeEvyTQ
+2wxQ2iPASgaJx0lUhL8MxUIuoLQjwApVbVyyLYS/3q4QcUBpI8CN8jWGg+CD
+v4GCrPaA0iLAky3H2SVGg7+JF2vLpYshwFPMSHpy94G/HsQoo3NaIMDszFYy
+7b6Av/lJ0Cp8Xh7ATeNumhIZf78651yiWNUbwC9+7sJagHy/l7PnH4d3GcDE
+3IYa/xN6v3hbgDD95hbAxYzdZLNzd7/saxx2bGIUwAqF2XSq33S/fKu2wS0J
+EsACQe6z/Xdyvx+NvUBt+g7AzJyCy8G4b79+IQoKIzkKwPg+Wo1A2mq/A4dd
+PcuPBcCtcXzaRBRmv5GjzJYCgQDAPUcbDWnmYL+rPHD4u5H3v11I1zuLIli/
+iED9HiKt6r/oj+JQCFFLv7cgVu7HXOq/7Qj8cMD+Sr/mAK+9bQzqv/KBFZF4
+rEq/RcFgXLlr6b/9c0jR6AdKvwJCxJlQKui/E1iuUcm+SL98Q4sUf6flvz4g
+elKKLEa/b0YZCtyh4L+TsBFUDAhBv54mctmBUeC/mCkrdMS1QL/OBsuoJwHg
+v56iRJR8Y0C/WI75jubA3r9QKe+o2X0/v9KPwAkVPty/e/G6qZrrPL/Gkk7/
+cTjXv9GBUqscxze/WjHV1Fdayr/4RANdQfwqv6TJNxWYLsm/5or19E/JKb/v
+YZpV2ALIv9TQ54xelii/hJJf1lirxb+wXMy8ezAmv6/z6ddZ/MC/anSVHLZk
+Ib/zF5kwNKG/v1i6h7TEMSC/iEhesbRJvb+LAPSYpv0dv7Op6LK1mri/RRi9
++OAxGb8Q2Pprb3muv22PnnCrNA+/OjmFbXDKqb8lp2fQ5WgKv2WaD29xG6W/
+3r4wMCCdBb+Q+5lwcmygv5jW+Y9a0QC/dLlI5OZ6l7+g3IXfKQv4vpL3us7R
+OYy/IxgwPj3n7L7mFLycgpeDv70jLejhD+S+LRGb4Q==
+         "]], 
+        LineBox[CompressedData["
+1:eJxTTMoPSmViYGAwAmIQ/Uxkz5ym6c32MNo9Zm5LW8wCOP1pZkdjy66VcHpJ
 13pbB+ttcJo/6tWe/ZN2wOkqTVUb+1e74LT/iVlWdjP3w+m/TIel51UfgdMr
 HNZJzLl5Fk7/j3XiPON1A07/mOXLEvUWQX+6HvH/ef9NOP0sMP8r89VbcPqM
 65yH1vF34fRZsd93rlo+hNOz/4VsdfV7Bqel01k2T7L+AKc9qvZ7a23/Cac3
@@ -71,19 +85,33 @@
 xxA0lznzMaUMMTgtZn9/hUsRglZ0392dVoOgLcKLA1dNQNBp5Y/vGO5E0Ie2
 H/7swCUOp6stWhTj1yDoU+4eey5vRdBS4TzhHvsR9I7SKT2GlxD0l01LvjP/
 QNDOhzImVTBKwOlJF3V033IhaIMPW5KuySLoHN2jZ1c4I+jdNp0Zsr4ImsvH
-l3lSGIKOjBacx5aAoFdkXbWozkTQhdvi20QLETQAzllQ5A==
+l3lSGIKOjBacx5aAoFdkXbWozkTQ3ytnXn5fhKA5tPYWR5cjaABfdVlT
          "]], 
         LineBox[CompressedData["
-1:eJxTTMoPSmViYGCQBWIQ3Vr0h2Nti4RDtcg694dVEg5KT7/yKWxF8OOU2Ko+
-3ULwA8Td1WyKJOF8R56OS62cUnB+EkdzYmmgNJzfzFL3IWWmDJxvNKXgppes
-PEJ9lVHc+10KcP7LPaptUxmU4PxHzyVXTzJQhvMnxfWYTo5SgfMbnpd/ez9X
-Fc5/EJGyZfFpNTi/7s7JFZuFNOD8Pg+DWVIumnB+CIPox5Z8LTg/4lRRnfcW
-bTj/fM1FjszHOnB+i+PKk4+09eD894H/38fn6cP56aqrOWf5GsD5X7Umm236
-gODvWfL74dcOQ0T4uig7WMsZwfnyue079Q4g+JJcORt9w43h/DvWky8vW43g
-z8vd9fX/fwQfAHVfwT4=
+1:eJwV0X1QE3QYB/AdIW3JIYdTfxugNNgU0b39cFmIPggHguLJSwlFW+CQIlGO
+c9BxA4NNWDhmMtBjJ50ahy8DQQTL3eyoE2rSlQYkTKpJAil6LHIDVtx6+OO5
+733u+8f3j+f1vGPp+T4MBiMGbzlDprLdc3UESP+rX0VWEdAOFI3JLhEI/8Fq
+FqF5k66AsF4C/vFrNdFoOc+vfM5O4PftNslOdIfkHrvgCYF0t6oF0P+BofPR
+CwLf3+Sx4tEmxdrJuwwOdAnVjiT0w/OCA+cEHKiOEJ1OQx9YlyTYUcKBjYFN
+z5XoOH/dLydZXCie/uDyqeX9J979/au5IOheSjSgfa1lg77ruTCuNk19jh74
+uOCuRsqF5KBh/ll0ymDirar3uMCLTWq9gE6vW2Gq6ODCcMPWi73oPKYmV5UW
+DNt3ekx/oDW+lU5lcwh4G40GWk1A2lg8lhK6AWLH2Pmj6LxyqXzWEgbJB+si
+SjQEnlr5NU0MHnzLf8VBtAQmpjnmBnE4MIXF2h50g1y/zfhuBCz9GEVSTxL4
+dLrMPdvCB7n12eU5tCNL2fPloAAMky1h9TUEKsdtV24GbYJIRWZTdC0Bwx6x
+iZsQCY1B3rn76EzGmr+1xzZDe87CrkIdgax7JZV7e6JAPP9SF/gZgZ/VD5gf
+/bkFtIOTFjNaG3fVNhElhN3Osb8y8K+zad5ZxVERdJpD/BbRBXwzy5QqhpkL
+Gf7GUwRcm42ybqcYjFP1AW/pCVhb/33s0kmAddi6OIKWJ4RDzHopCNVvDh+t
+J7ChqPa2sE8K30zcvsY2EOC8duRG6kEKoRphYSf6SnxFuTObArM0MrQbLasw
+xBtzKPzzYcT9HnS6s2tkNJeCbT9XZkHX/epaPHSEgorr59OP9lw6sbu8isJP
+N35rtqPHY4xDbWYKJxx624rTBApVreeTr1MoHKpVM9EL13vzn3dReHugWrQS
+zeaNzktuUYhq/6QpEL2PGRpyp4/CwzJlbjD6znCbcmiEgnjVjkXxch/w9dbS
+UQrBPm+0U7Q9yeYmjyj4uSQKGdptmdHJHRTG7Rv7Y9DCi+KOp88o6NpWn0lE
+W+1xpfoXFI43ByQko1PYGbtETgoKPWt+L/pwrerBcReFbSXenDT0y74a07oF
+CmH5nlWZ6GrPuUMWD4WVWa7v3kEHRl/d8v4SBXeKU5WN/qLI4vJ6KTyOndmU
+g/4fjjiSnA==
          "]]},
        Annotation[#, 
-        "Charting`Private`Tag$3800#1"]& ], {}}, {{}, {}, {}}}, {}, {}},
+        "Charting`Private`Tag$3142#1"]& ], {}}, {{}, {}, {}}}, {}, {}},
    AspectRatio->NCache[GoldenRatio^(-1), 0.6180339887498948],
    Axes->{True, True},
    AxesLabel->{None, None},
@@ -110,7 +138,7 @@
           Part[#, 1]], 
          (Identity[#]& )[
           Part[#, 2]]}& )}},
-   PlotRange->{{-10, 20}, {0., 6.12}},
+   PlotRange->{{-10, 20}, {-0.009999999387755101, 6.139999999387755}},
    PlotRangeClipping->True,
    PlotRangePadding->{{
       Scaled[0.02], 
@@ -120,8 +148,10 @@
    Ticks->{Automatic, Automatic}], TraditionalForm]], "Output",
  CellChangeTimes->{
   3.758282757552134*^9, {3.758282788914091*^9, 3.758282817859563*^9}, {
-   3.758285017755877*^9, 3.7582850250071774`*^9}},
- CellLabel->"Out[46]=",ExpressionUUID->"2780a80e-bda8-45c2-b1b0-3eb6caa89a36"]
+   3.758285017755877*^9, 3.7582850250071774`*^9}, 3.7721836887928953`*^9, {
+   3.7721837601872807`*^9, 3.772183778656546*^9}, {3.772183815273117*^9, 
+   3.772183831834888*^9}},
+ CellLabel->"Out[22]=",ExpressionUUID->"46789aab-38ca-4d38-86ae-0d31fd88bfd6"]
 }, Open  ]],
 
 Cell[CellGroupData[{
@@ -131,8 +161,7 @@
   RowBox[{
    RowBox[{"F", "[", "x", "]"}], ",", "x"}], "]"}]], "Input",
  CellChangeTimes->{{3.757769150843001*^9, 3.757769154243264*^9}},
- CellLabel->
-  "In[109]:=",ExpressionUUID->"8e07609f-09e3-40d7-af74-38b08a5e8f91"],
+ CellLabel->"In[3]:=",ExpressionUUID->"8e07609f-09e3-40d7-af74-38b08a5e8f91"],
 
 Cell[BoxData[
  FormBox[
@@ -188,9 +217,9 @@
    Selectable->False], TraditionalForm]], "Output",
  CellChangeTimes->{{3.757769154558042*^9, 3.7577691626113*^9}, {
    3.757769617898608*^9, 3.7577696533545313`*^9}, 3.7578287200170727`*^9, 
-   3.757828765494636*^9, 3.757835435982698*^9, 3.7578355211607018`*^9},
- CellLabel->
-  "Out[109]=",ExpressionUUID->"368b90c4-a174-42ff-88ff-fa878b289f90"]
+   3.757828765494636*^9, 3.757835435982698*^9, 3.7578355211607018`*^9, 
+   3.7721836915604553`*^9},
+ CellLabel->"Out[3]=",ExpressionUUID->"72823a99-8940-40bd-ba34-c77fb08f6e38"]
 }, Open  ]],
 
 Cell[CellGroupData[{
@@ -204,8 +233,7 @@
      RowBox[{"+", "20"}]}], "}"}], ",", 
    RowBox[{"PlotRange", "\[RuleDelayed]", "All"}]}], "]"}]], "Input",
  CellChangeTimes->{{3.757769607871423*^9, 3.757769651885653*^9}},
- CellLabel->
-  "In[110]:=",ExpressionUUID->"755b5a3a-b723-4917-b599-cbfec71b6ba8"],
+ CellLabel->"In[4]:=",ExpressionUUID->"755b5a3a-b723-4917-b599-cbfec71b6ba8"],
 
 Cell[BoxData[
  FormBox[
@@ -246,7 +274,7 @@
 JV8R/C8H2maJ/0Dwm35NT971C8EXMFmpE/sXwZ+Xu+vr//8IPgCTLNpW
          "]]},
        Annotation[#, 
-        "Charting`Private`Tag$66113#1"]& ], {}}, {{}, {}, {}}}, {}, {}},
+        "Charting`Private`Tag$2681#1"]& ], {}}, {{}, {}, {}}}, {}, {}},
    AspectRatio->NCache[GoldenRatio^(-1), 0.6180339887498948],
    Axes->{True, True},
    AxesLabel->{None, None},
@@ -283,9 +311,8 @@
    Ticks->{Automatic, Automatic}], TraditionalForm]], "Output",
  CellChangeTimes->{{3.757769608419174*^9, 3.7577696543386173`*^9}, 
    3.757828721891801*^9, 3.757828766940044*^9, 3.757835437374585*^9, 
-   3.7578355225401373`*^9},
- CellLabel->
-  "Out[110]=",ExpressionUUID->"57c09952-dd78-4249-b11e-a32c2dddede6"]
+   3.7578355225401373`*^9, 3.772183696745397*^9},
+ CellLabel->"Out[4]=",ExpressionUUID->"a724236f-251a-42ae-affa-770d3b405a37"]
 }, Open  ]],
 
 Cell[BoxData[
@@ -301,7 +328,7 @@
   3.758276285868677*^9}, {3.75828118360719*^9, 3.758281185012753*^9}, {
   3.7582847078689938`*^9, 3.758284710918268*^9}, {3.758285046311775*^9, 
   3.7582850466003857`*^9}},
- CellLabel->"In[47]:=",ExpressionUUID->"31e3dfa2-15a7-4036-b188-62331ca14f94"],
+ CellLabel->"In[5]:=",ExpressionUUID->"31e3dfa2-15a7-4036-b188-62331ca14f94"],
 
 Cell[CellGroupData[{
 
@@ -317,7 +344,7 @@
    3.758281196739649*^9, 3.758281202092382*^9}, {3.758281304164719*^9, 
    3.75828132617336*^9}, 3.75828137114268*^9, {3.758284712194335*^9, 
    3.758284717316959*^9}},
- CellLabel->"In[48]:=",ExpressionUUID->"89e2d575-eabc-4561-9cef-87861999c7e7"],
+ CellLabel->"In[6]:=",ExpressionUUID->"89e2d575-eabc-4561-9cef-87861999c7e7"],
 
 Cell[BoxData[
  FormBox[
@@ -574,7 +601,7 @@
 m8G3pgE0L/wiKY7aeHihdkMDYkIaoihm35uvZL+lAUM/maIpfnKldmVnRwNm
 tkxiKP4fGYGP3Q==
         "]]},
-      Annotation[#, "Charting`Private`Tag$3850#1"]& ]}, {}, {}},
+      Annotation[#, "Charting`Private`Tag$2747#1"]& ]}, {}, {}},
    AspectRatio->NCache[GoldenRatio^(-1), 0.6180339887498948],
    Axes->{True, True},
    AxesLabel->{None, None},
@@ -610,8 +637,8 @@
       Scaled[0.05]}},
    Ticks->{Automatic, Automatic}], TraditionalForm]], "Output",
  CellChangeTimes->{3.758281326635113*^9, 3.758281371377243*^9, 
-  3.7582847176775627`*^9, 3.758285048877262*^9},
- CellLabel->"Out[48]=",ExpressionUUID->"5aa8ebaa-551f-4695-88d2-561a8f47d302"]
+  3.7582847176775627`*^9, 3.758285048877262*^9, 3.7721837026679497`*^9},
+ CellLabel->"Out[6]=",ExpressionUUID->"8ffbcc70-de1b-4e04-b51f-0cc52b8f204f"]
 }, Open  ]],
 
 Cell[BoxData[
@@ -628,8 +655,7 @@
    RowBox[{"G", "[", "x", "]"}], ",", "x"}], "]"}]], "Input",
  CellChangeTimes->{{3.757769150843001*^9, 3.757769154243264*^9}, {
   3.758276581945362*^9, 3.758276583075118*^9}},
- CellLabel->
-  "In[127]:=",ExpressionUUID->"f784ccf6-07f5-4576-8b62-c9c1e85c04a3"],
+ CellLabel->"In[7]:=",ExpressionUUID->"f784ccf6-07f5-4576-8b62-c9c1e85c04a3"],
 
 Cell[BoxData[
  FormBox[
@@ -646,9 +672,8 @@
  CellChangeTimes->{{3.757769154558042*^9, 3.7577691626113*^9}, {
    3.757769617898608*^9, 3.7577696533545313`*^9}, 3.7578287200170727`*^9, 
    3.757828765494636*^9, 3.757835435982698*^9, 3.7578355211607018`*^9, 
-   3.758276583311789*^9},
- CellLabel->
-  "Out[127]=",ExpressionUUID->"a6c24978-6a42-4e9f-a867-80ed321e9863"]
+   3.758276583311789*^9, 3.772183706682643*^9},
+ CellLabel->"Out[7]=",ExpressionUUID->"0c16b6ef-6d4f-4e30-b17d-83880a510a5a"]
 }, Open  ]],
 
 Cell[CellGroupData[{
@@ -662,8 +687,7 @@
      RowBox[{"+", "20"}]}], "}"}], ",", 
    RowBox[{"PlotRange", "\[RuleDelayed]", "All"}]}], "]"}]], "Input",
  CellChangeTimes->{{3.757769607871423*^9, 3.757769651885653*^9}},
- CellLabel->
-  "In[128]:=",ExpressionUUID->"38630a6f-4f21-4ca0-a2c0-3d40bbce384d"],
+ CellLabel->"In[8]:=",ExpressionUUID->"38630a6f-4f21-4ca0-a2c0-3d40bbce384d"],
 
 Cell[BoxData[
  FormBox[
@@ -951,7 +975,7 @@
 BfYGbMnBfBvde7dte7SJJd49+UcOfBIk83OK7VHcXp5zw54cmDalKxYa2iP6
 02UStv/k4LvxkEf8Pzv04HrD1uGhHJT9//uU/wHB5W3g
         "]]},
-      Annotation[#, "Charting`Private`Tag$66583#1"]& ]}, {}, {}},
+      Annotation[#, "Charting`Private`Tag$2806#1"]& ]}, {}, {}},
    AspectRatio->NCache[GoldenRatio^(-1), 0.6180339887498948],
    Axes->{True, True},
    AxesLabel->{None, None},
@@ -988,13 +1012,12 @@
    Ticks->{Automatic, Automatic}], TraditionalForm]], "Output",
  CellChangeTimes->{{3.757769608419174*^9, 3.7577696543386173`*^9}, 
    3.757828721891801*^9, 3.757828766940044*^9, 3.757835437374585*^9, 
-   3.7578355225401373`*^9, 3.758276589466311*^9},
- CellLabel->
-  "Out[128]=",ExpressionUUID->"f43d30ac-6f1e-4c6a-a478-47da276753e9"]
+   3.7578355225401373`*^9, 3.758276589466311*^9, 3.772183708980582*^9},
+ CellLabel->"Out[8]=",ExpressionUUID->"2a2f4242-8fc7-4862-8f23-02243204dfb4"]
 }, Open  ]]
 },
-WindowSize->{808, 833},
-WindowMargins->{{-1635, Automatic}, {-91, Automatic}},
+WindowSize->{1680, 934},
+WindowMargins->{{0, Automatic}, {Automatic, 0}},
 FrontEndVersion->"11.3 for Mac OS X x86 (32-bit, 64-bit Kernel) (March 5, \
 2018)",
 StyleDefinitions->"Default.nb"
@@ -1011,30 +1034,30 @@
 (*NotebookFileOutline
 Notebook[{
 Cell[CellGroupData[{
-Cell[580, 22, 1101, 23, 52, "Input",ExpressionUUID->"b345f780-c762-422b-bb72-4f3dcbf7d3d9"],
-Cell[1684, 47, 3343, 76, 244, "Output",ExpressionUUID->"2780a80e-bda8-45c2-b1b0-3eb6caa89a36"]
+Cell[580, 22, 1288, 28, 52, "Input",ExpressionUUID->"b345f780-c762-422b-bb72-4f3dcbf7d3d9"],
+Cell[1871, 52, 4880, 101, 244, "Output",ExpressionUUID->"46789aab-38ca-4d38-86ae-0d31fd88bfd6"]
 }, Open  ]],
 Cell[CellGroupData[{
-Cell[5064, 128, 255, 6, 30, "Input",ExpressionUUID->"8e07609f-09e3-40d7-af74-38b08a5e8f91"],
-Cell[5322, 136, 2045, 56, 104, "Output",ExpressionUUID->"368b90c4-a174-42ff-88ff-fa878b289f90"]
+Cell[6788, 158, 250, 5, 30, "Input",ExpressionUUID->"8e07609f-09e3-40d7-af74-38b08a5e8f91"],
+Cell[7041, 165, 2068, 56, 104, "Output",ExpressionUUID->"72823a99-8940-40bd-ba34-c77fb08f6e38"]
 }, Open  ]],
 Cell[CellGroupData[{
-Cell[7404, 197, 389, 10, 30, "Input",ExpressionUUID->"755b5a3a-b723-4917-b599-cbfec71b6ba8"],
-Cell[7796, 209, 3439, 78, 244, "Output",ExpressionUUID->"57c09952-dd78-4249-b11e-a32c2dddede6"]
+Cell[9146, 226, 384, 9, 30, "Input",ExpressionUUID->"755b5a3a-b723-4917-b599-cbfec71b6ba8"],
+Cell[9533, 237, 3455, 77, 244, "Output",ExpressionUUID->"a724236f-251a-42ae-affa-770d3b405a37"]
 }, Open  ]],
-Cell[11250, 290, 602, 13, 50, "Input",ExpressionUUID->"31e3dfa2-15a7-4036-b188-62331ca14f94"],
+Cell[13003, 317, 601, 13, 50, "Input",ExpressionUUID->"31e3dfa2-15a7-4036-b188-62331ca14f94"],
 Cell[CellGroupData[{
-Cell[11877, 307, 528, 12, 30, "Input",ExpressionUUID->"89e2d575-eabc-4561-9cef-87861999c7e7"],
-Cell[12408, 321, 16734, 292, 244, "Output",ExpressionUUID->"5aa8ebaa-551f-4695-88d2-561a8f47d302"]
+Cell[13629, 334, 527, 12, 30, "Input",ExpressionUUID->"89e2d575-eabc-4561-9cef-87861999c7e7"],
+Cell[14159, 348, 16757, 292, 244, "Output",ExpressionUUID->"8ffbcc70-de1b-4e04-b51f-0cc52b8f204f"]
 }, Open  ]],
-Cell[29157, 616, 177, 4, 30, "Input",ExpressionUUID->"23a7d6e0-f7d1-43e1-8301-83d26edf4abc"],
+Cell[30931, 643, 177, 4, 30, "Input",ExpressionUUID->"23a7d6e0-f7d1-43e1-8301-83d26edf4abc"],
 Cell[CellGroupData[{
-Cell[29359, 624, 304, 7, 30, "Input",ExpressionUUID->"f784ccf6-07f5-4576-8b62-c9c1e85c04a3"],
-Cell[29666, 633, 640, 17, 61, "Output",ExpressionUUID->"a6c24978-6a42-4e9f-a867-80ed321e9863"]
+Cell[31133, 651, 299, 6, 30, "Input",ExpressionUUID->"f784ccf6-07f5-4576-8b62-c9c1e85c04a3"],
+Cell[31435, 659, 657, 16, 61, "Output",ExpressionUUID->"0c16b6ef-6d4f-4e30-b17d-83880a510a5a"]
 }, Open  ]],
 Cell[CellGroupData[{
-Cell[30343, 655, 389, 10, 30, "Input",ExpressionUUID->"38630a6f-4f21-4ca0-a2c0-3d40bbce384d"],
-Cell[30735, 667, 18707, 325, 244, "Output",ExpressionUUID->"f43d30ac-6f1e-4c6a-a478-47da276753e9"]
+Cell[32129, 680, 384, 9, 30, "Input",ExpressionUUID->"38630a6f-4f21-4ca0-a2c0-3d40bbce384d"],
+Cell[32516, 691, 18723, 324, 244, "Output",ExpressionUUID->"2a2f4242-8fc7-4862-8f23-02243204dfb4"]
 }, Open  ]]
 }
 ]
diff --git a/arbitrary_act_f.ipynb b/arbitrary_act_f.ipynb
index e5ec8a8..5cbcaf0 100644
--- a/arbitrary_act_f.ipynb
+++ b/arbitrary_act_f.ipynb
@@ -14,7 +14,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def lrelu(x, alpha=0.01):\n",
+    "    return np.maximum(alpha*x,x)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -23,13 +33,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 196,
    "metadata": {},
    "outputs": [],
    "source": [
     "def HCAL_act(x):\n",
     "    \n",
-    "    return np.divide(a,np.add(1.,np.exp(np.add(-x,a))))\n",
+    "\n",
+    "    return lrelu(np.minimum(2.+0.01*x,x))\n",
     "    \n",
     "    \n",
     "    "
@@ -37,16 +48,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 197,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "0.013425036143057525"
+       "0.0"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 197,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -57,7 +68,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 198,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -66,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 199,
    "metadata": {},
    "outputs": [
     {
@@ -75,13 +86,13 @@
        "<BarContainer object of 200 artists>"
       ]
      },
-     "execution_count": 20,
+     "execution_count": 199,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -96,7 +107,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -108,7 +119,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -117,7 +128,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -126,7 +137,7 @@
        "<BarContainer object of 300 artists>"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -289,7 +300,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.5"
+   "version": "3.7.3"
   }
  },
  "nbformat": 4,
diff --git a/architectures/bicycle_GAN.py b/architectures/bicycle_GAN.py
index f580ccb..c4ae545 100644
--- a/architectures/bicycle_GAN.py
+++ b/architectures/bicycle_GAN.py
@@ -8,29 +8,32 @@
 
 from architectures.utils.NN_building_blocks import *
 from architectures.utils.NN_gen_building_blocks import *
-from architectures.utils.arbitrary_act import *
+# from architectures.utils.arbitrary_act import *
 
-def lrelu(x, alpha=0.2):
+def lrelu(x, alpha=0.001):
     return tf.maximum(alpha*x,x)
 
-# def tf_HCAL_act(x, mask):
+def shifted_lrelu(x,  max_val, alpha=0.001):
+    return tf.minimum(max_val+alpha*x,x)    
 
-#     output = tf.where(mask,
-#                       tf.multiply(6.120,tf.nn.sigmoid(tf.subtract(x,5.))), 
-#                       tf.multiply(1.530,tf.nn.sigmoid(tf.subtract(x,5.))) 
-#                         )
-    
-#     return output
+def tf_HCAL_act(x, mask, max_val_out=6120., max_val_in=1530.):
 
-def tf_HCAL_act(x, mask):
-    
     output = tf.where(mask,
-                      tf.maximum(0.,tf.minimum(6120.,x)) , 
-                      tf.maximum(0.,tf.minimum(1530.,x)) 
+                      lrelu(shifted_lrelu(x, max_val=max_val_out)), 
+                      lrelu(shifted_lrelu(x, max_val=max_val_in)), 
                         )
-
+    
     return output
 
+# def tf_HCAL_act(x, mask, max_val_out=6120., max_val_in=1530.):
+    
+#     output = tf.where(mask,
+#                       tf.maximum(0.,tf.minimum(max_val_out,x)) , 
+#                       tf.maximum(0.,tf.minimum(max_val_in,x)) 
+#                         )
+
+#     return output
+
 pretrain=None
 # some dummy constants
 LEARNING_RATE = None
@@ -42,7 +45,6 @@
 PATH = None
 SEED = None
 rnd_seed=1
-PREPROCESS=None
 LAMBDA=.01
 EPS=1e-6
 CYCL_WEIGHT=None
@@ -80,7 +82,7 @@
         min_true=min_true, max_true=max_true, 
         min_reco=min_reco, max_reco=max_reco,
         d_sizes=d_sizes, g_sizes_enc=g_sizes_enc, g_sizes_dec=g_sizes_dec, e_sizes=e_sizes, 
-        pretrain=pretrain, lr=LEARNING_RATE, beta1=BETA1, preprocess=PREPROCESS,
+        lr=LEARNING_RATE, beta1=BETA1,
         cost_type=COST_TYPE, cycl_weight=CYCL_WEIGHT, latent_weight=LATENT_WEIGHT, kl_weight=KL_WEIGHT,
         discr_steps=DISCR_STEPS, gen_steps=GEN_STEPS, vae_steps=VAE_STEPS,
         batch_size=BATCH_SIZE, epochs=EPOCHS,
@@ -193,7 +195,7 @@
                          n_H_A, n_W_A, n_C),
                     name='inner_outer',
                 )
-
+           
         G = bicycleGenerator(self.input_A, self.n_H_B, self.n_W_B, g_sizes_enc, g_sizes_dec, 'A_to_B')
 
         D = Discriminator_minibatch(self.input_B, d_sizes, 'B')
@@ -380,14 +382,13 @@
 
         e_cost_latent_cycle = tf.reduce_mean(tf.abs(self.z - z_recon), axis=1)
         self.e_cost_latent_cycle=tf.reduce_mean(e_cost_latent_cycle)
-        
-        self.e_cost_kl = -0.5 * tf.reduce_mean(1 + 2*tf.log(z_encoded_log_sigma) - tf.square(z_encoded_mu) - tf.square(z_encoded_log_sigma))
+        self.e_cost_kl = 0.5 * tf.reduce_mean(-1 + z_encoded_mu ** 2 + z_encoded_log_sigma**2 - 2*tf.log(z_encoded_log_sigma))
         
         #TOTAL COSTS
         
         self.d_cost = self.d_cost_fake_vae_GAN + self.d_cost_fake_lr_GAN + 2*self.d_cost_real 
-        self.g_cost = self.g_cost_vae_GAN + self.g_cost_lr_GAN + cycl_weight*self.g_cost_cycl + self.e_cost_latent_cycle
-        self.e_cost = latent_weight*self.e_cost_latent_cycle + kl_weight*self.e_cost_kl + self.g_cost_vae_GAN + self.g_cost_cycl
+        self.g_cost = self.g_cost_vae_GAN + self.g_cost_lr_GAN + cycl_weight*self.g_cost_cycl + latent_weight*self.e_cost_latent_cycle
+        self.e_cost = kl_weight*self.e_cost_kl + self.g_cost_vae_GAN + cycl_weight*self.g_cost_cycl + latent_weight*self.e_cost_latent_cycle
 
         self.d_train_op = tf.train.AdamOptimizer(
                 learning_rate=lr, 
@@ -440,7 +441,6 @@
         self.path=path
         self.lr = lr
 
-        self.preprocess=preprocess
         self.cost_type=cost_type
         self.gen_steps=gen_steps
         self.vae_steps=vae_steps
@@ -621,14 +621,8 @@
                     print('Saving a sample...')
 
 
-                    if self.preprocess!=False:
-                        draw_nn_sample(validating_A, validating_B, 1, self.preprocess,
-                                        self.min_true, self.max_true, 
-                                        self.min_reco, self.max_reco,
-                                        f=self.get_sample_A_to_B, is_training=True,
-                                        total_iters=total_iters, PATH=self.path)
-                    else:
-                        draw_nn_sample(validating_A, validating_B, 1, self.preprocess,
+
+                    draw_nn_sample(validating_A, validating_B, 1,
                                         f=self.get_sample_A_to_B, is_training=True,
                                         total_iters=total_iters, PATH=self.path)
 
@@ -696,35 +690,21 @@
                 validating_NN[i]=self.get_sample_A_to_B(validating_A[i].reshape(1,self.n_H_A,self.n_W_A,self.n_C))
             
             print('ET Distribution plots are being printed...')
-            if self.preprocess != False:
-                validation_MC_hist= denormalise(validating_B, self.min_reco, self.max_reco).reshape(validating_size, self.n_H_B*self.n_W_B)
-                validation_MC_hist = np.sum(validation_MC_hist,axis=1)
-                max_MC_hist = np.max(validation_MC_hist)
 
-                validation_NN_hist= denormalise(validating_NN, self.min_reco, self.max_reco).reshape(validating_size, self.n_H_B*self.n_W_B)
-                validation_NN_hist = np.sum(validation_NN_hist,axis=1)
-                max_NN_hist = np.max(validation_NN_hist)
 
-                validation_true_hist= denormalise(validating_A, self.min_true, self.max_true).reshape(validating_size, self.n_H_A*self.n_W_A)
-                validation_true_hist = np.sum(validation_true_hist,axis=1)
-                max_true_hist = np.max(validation_true_hist)
+            validation_MC_hist= validating_B.reshape(validating_size, self.n_H_B*self.n_W_B)
+            validation_MC_hist = np.sum(validation_MC_hist,axis=1)
+            max_MC_hist = np.max(validation_MC_hist)
 
-                validation_NN_hist_rescaled=(validation_NN_hist/max_NN_hist)*max_MC_hist
+            validation_NN_hist= validating_NN.reshape(validating_size, self.n_H_B*self.n_W_B)
+            validation_NN_hist = np.sum(validation_NN_hist,axis=1)
+            max_NN_hist = np.max(validation_NN_hist)
 
-            else:
-                validation_MC_hist= validating_B.reshape(validating_size, self.n_H_B*self.n_W_B)
-                validation_MC_hist = np.sum(validation_MC_hist,axis=1)
-                max_MC_hist = np.max(validation_MC_hist)
-
-                validation_NN_hist= validating_NN.reshape(validating_size, self.n_H_B*self.n_W_B)
-                validation_NN_hist = np.sum(validation_NN_hist,axis=1)
-                max_NN_hist = np.max(validation_NN_hist)
-
-                validation_true_hist= validating_A.reshape(validating_size, self.n_H_A*self.n_W_A)
-                validation_true_hist = np.sum(validation_true_hist,axis=1)
-                max_true_hist = np.max(validation_true_hist)
-                
-                validation_NN_hist_rescaled=(validation_NN_hist/max_NN_hist)*max_MC_hist
+            validation_true_hist= validating_A.reshape(validating_size, self.n_H_A*self.n_W_A)
+            validation_true_hist = np.sum(validation_true_hist,axis=1)
+            max_true_hist = np.max(validation_true_hist)
+            
+            validation_NN_hist_rescaled=(validation_NN_hist/max_NN_hist)*max_MC_hist
 
 
             plt.clf()
diff --git a/architectures/utils/NN_gen_building_blocks.py b/architectures/utils/NN_gen_building_blocks.py
index 19b8b17..8f589b9 100644
--- a/architectures/utils/NN_gen_building_blocks.py
+++ b/architectures/utils/NN_gen_building_blocks.py
@@ -1922,8 +1922,8 @@
             skip_conv_outputs.append(output)
             output=conv_concat(output, z, self.latent_dims)
             
-            print('After conv layer%i' %i)
-            print('shape: ', output.get_shape())
+            #print('After conv layer%i' %i)
+            #print('shape: ', output.get_shape())
 
         assert i == self.conv_count
 
@@ -1949,8 +1949,8 @@
                                    reuse,
                                    is_training)
             output = conv_concat(output, z, self.latent_dims)
-            print('After deconv layer %i' %i)
-            print('Shape', output.get_shape()) 
+            #print('After deconv layer %i' %i)
+            #print('Shape', output.get_shape()) 
         output = tf.concat([output, skip_conv_outputs[skip_layer-1]], axis =3)
         output = self.g_dec_conv_layers[-1].forward(output,
                        reuse,
@@ -2714,12 +2714,12 @@
                 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, 
+                                                    False, keep_prob=0.8, 
                                                     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=tf.nn.relu, w_init=w_init_last)
+                                                    False, keep_prob=0.8, 
+                                                    act_f=tf.nn.softplus, w_init=w_init_last)
 
                 self.e_name=e_name
                 self.latent_dims=latent_dims
diff --git a/architectures/utils/toolbox.py b/architectures/utils/toolbox.py
index 67fa32f..3dbf2a6 100644
--- a/architectures/utils/toolbox.py
+++ b/architectures/utils/toolbox.py
@@ -163,93 +163,10 @@
     
     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=[]
@@ -268,6 +185,7 @@
     
     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])) :
+            print(i)
             pos_rejected.append(i)
 
     reco_filtered=np.delete(reco,pos_rejected,axis=0)
@@ -294,30 +212,6 @@
 
     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:
@@ -325,145 +219,57 @@
 
     with open(true_path+'sample{0}.pickle'.format(i), 'rb') as f:
         true=pickle.load(f, encoding='latin1')
-    
+        true_img=true['pic']
+        true_TIS=true['L0HadronDec_TIS']
+        true_TOS=true['L0HadronDec_TOS']
     #cut that extra produced pixel
     #true=true[:,1:true.shape[1]-1,1:true.shape[2]-1,:]
     
-    return true, reco
+    return true_img, true_TIS, true_TOS, 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):
+def load_data(true_path, reco_path, n_batches, startbatch, test_size=None):
 
     if n_batches == 1:
 
         #delete undetected particles
-        true, reco = load_batch(true_path, reco_path, 0)
+        true, true_TIS, true_TOS, reco = load_batch(true_path, reco_path, startbatch)
         #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)
+        true, true_TIS, true_TOS, reco = load_batch(true_path, reco_path, startbatch)
 
-        for i in range(1, n_batches):
+        for i in range(startbatch+1, startbatch+n_batches):
 
-            true_temp, reco_temp = load_batch(true_path, reco_path, i)
+            true_temp, true_TIS_temp, true_TOS_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)
+            true_TIS=np.concatenate((true_TIS, true_TIS_temp))
+            true_TOS=np.concatenate((true_TOS, true_TOS_temp))
             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]
+    m = reco.shape[0]
+    train_size = m - test_size
 
-        train_reco = reco[0:train_size]
-        test_reco = reco[train_size:m]
+    train_true = true[0:train_size]
+    test_true = true[train_size:m]
 
-        return train_true, test_true, min_true, max_true, train_reco, test_reco, min_reco, max_reco
+    train_TIS_true = true_TIS[0:train_size]
+    test_TIS_true = true_TIS[train_size:m]
 
-    else:
-        m = reco.shape[0]
-        train_size = m - test_size
+    train_TOS_true = true_TOS[0:train_size]
+    test_TOS_true = true_TOS[train_size:m]
 
-        train_true = true[0:train_size]
-        test_true = true[train_size:m]
+    train_reco = reco[0:train_size]
+    test_reco = reco[train_size:m]
 
-        train_reco = reco[0:train_size]
-        test_reco = reco[train_size:m]
+    return train_true, test_true, train_TIS_true, test_TIS_true, train_TOS_true, test_TOS_true, train_reco, test_reco
 
-        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,
+def draw_one_sample(train_true, train_reco,
     min_true=None, max_true=None, min_reco=None, max_reco=None, 
     save=False, PATH=None):
 
@@ -472,10 +278,6 @@
     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
 
@@ -501,34 +303,7 @@
     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 = train_true[j]
-    X_batch_B = train_reco[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,
+def draw_nn_sample(X_A, X_B, i,
     min_true=None, max_true=None, min_reco=None, max_reco=None, f=None, 
     save=True, is_training=False, total_iters=None, PATH=None):
 
@@ -550,19 +325,13 @@
         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('RealET from sim')
     plt.xlabel('X')
     plt.ylabel('Y')
     ax = plt.gca()
-    im = ax.imshow(X_A.reshape(n_H_A,n_W_A)/1000)
+    im = ax.imshow(X_A.reshape(n_H_A,n_W_A))
     # create an axes on the right side of ax. The width of cax will be 5%
     # of ax and the padding between cax and ax will be fixed at 0.05 inch.
     divider = make_axes_locatable(ax)
@@ -577,7 +346,7 @@
     plt.xlabel('X')
     plt.ylabel('Y')
     ax = plt.gca()
-    im = ax.imshow(X_B.reshape(n_H_B,n_W_B)/1000)
+    im = ax.imshow(X_B.reshape(n_H_B,n_W_B))
     # create an axes on the right side of ax. The width of cax will be 5%
     # of ax and the padding between cax and ax will be fixed at 0.05 inch.
     divider = make_axes_locatable(ax)
@@ -592,7 +361,7 @@
     plt.xlabel('X')
     plt.ylabel('Y')
     ax = plt.gca()
-    im = ax.imshow(sample_nn.reshape(n_H_B,n_W_B)/1000)
+    im = ax.imshow(sample_nn.reshape(n_H_B,n_W_B))
     # create an axes on the right side of ax. The width of cax will be 5%
     # of ax and the padding between cax and ax will be fixed at 0.05 inch.
     divider = make_axes_locatable(ax)
@@ -613,57 +382,6 @@
     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
@@ -837,4 +555,251 @@
 #     return cropped_true, cropped_reco
 
 
+# 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 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 = train_true[j]
+#     X_batch_B = train_reco[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 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 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 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 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 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
diff --git a/calo_images_piplus.ipynb b/calo_images_piplus.ipynb
index 49bc2a0..a742d9b 100755
--- a/calo_images_piplus.ipynb
+++ b/calo_images_piplus.ipynb
@@ -6,11 +6,18 @@
    "metadata": {},
    "outputs": [
     {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Welcome to JupyROOT 6.16/00\n"
+     ]
+    },
+    {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/hep/davide/miniconda3/envs/root_env/lib/python2.7/site-packages/root_numpy/_tree.py:5: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility\n",
-      "  from . import _librootnumpy\n"
+      "/disk/lhcb_data2/davide/miniconda3/envs/root_env/lib/python3.7/site-packages/root_numpy/__init__.py:46: RuntimeWarning: numpy 1.17.2 is currently installed but you installed root_numpy against numpy 1.9.3. Please consider reinstalling root_numpy for this numpy version.\n",
+      "  RuntimeWarning)\n"
      ]
     }
    ],
@@ -18,26 +25,35 @@
     "import root_numpy as rn\n",
     "import ROOT as r\n",
     "import numpy as np\n",
-    "import pandas as pd\n",
+    "#import pandas as pd\n",
     "import matplotlib.pyplot as plt"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "\n",
-    "file_name='B2Dmunu_full'\n",
-    "file_path='/disk/lhcb_data/davide/HCAL_project_full_event/'+file_name+'.root'\n",
+    "file_name='B2Dmunu'\n",
+    "file_path='/disk/lhcb_data2/davide/HCAL_project_full_event/'+file_name+'.root'\n",
     "tree_name='Bd2Dmu/DecayTree'\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#r.TBrowser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -48,32 +64,50 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 18,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "#b=r.TBrowser()"
+    "j"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
     "batch_size=20000\n",
-    "#n_batches=2\n",
-    "N = j\n",
-    "n_batches= N//batch_size"
+    "n_batches=1\n",
+    "#N = j\n",
+    "#n_batches= N//batch_size"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
-    "particle = 'pi1'\n",
+    "particle = 'K'\n",
     "variable = 'ET'\n",
     "\n",
     "cal_zone = 'inner'\n",
@@ -90,21 +124,21 @@
     "    )\n",
     "    \n",
     "    cellsET_inner_dict[j]=np.array([cellsET_inner_dict[j][i] for i in range(batch_size)])\n",
-    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j), cellsET_inner_dict[j])\n",
+    "    #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j), cellsET_inner_dict[j])\n",
     "\n",
-    "if N % batch_size != 0:\n",
+    "#if N % batch_size != 0:\n",
+    "#    \n",
+    "#    cellsET_inner_dict[j+1]=rn.root2array(\n",
+    "#        filenames=file_path,\n",
+    "#        treename=tree_name,\n",
+    "#        branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n",
+    "#        start=n_batches*batch_size,\n",
+    "#        stop=N,\n",
+    "#    ) \n",
+    "#    cellsET_inner_dict[j+1]=np.array([cellsET_inner_dict[j+1][i] for i in range((N % batch_size))])\n",
+    "#    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsET_inner_dict[j+1])\n",
     "    \n",
-    "    cellsET_inner_dict[j+1]=rn.root2array(\n",
-    "        filenames=file_path,\n",
-    "        treename=tree_name,\n",
-    "        branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n",
-    "        start=n_batches*batch_size,\n",
-    "        stop=N,\n",
-    "    ) \n",
-    "    cellsET_inner_dict[j+1]=np.array([cellsET_inner_dict[j+1][i] for i in range((N % batch_size))])\n",
-    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsET_inner_dict[j+1])\n",
-    "    \n",
-    "particle = 'pi1'\n",
+    "particle = 'K'\n",
     "variable = 'ET'\n",
     "\n",
     "cal_zone='outer'\n",
@@ -120,118 +154,70 @@
     "        stop=(j+1)*batch_size,\n",
     "    )\n",
     "    cellsET_outer_dict[j]=np.array([cellsET_outer_dict[j][i] for i in range(batch_size)])\n",
-    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j),  cellsET_outer_dict[j])\n",
+    "    #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j),  cellsET_outer_dict[j])\n",
     "\n",
-    "if N % batch_size != 0:\n",
-    "    \n",
-    "    cellsET_outer_dict[j+1]=rn.root2array(\n",
-    "        filenames=file_path,\n",
-    "        treename=tree_name,\n",
-    "        branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n",
-    "        start=n_batches*batch_size,\n",
-    "        stop=N,\n",
-    "    ) \n",
-    "    cellsET_outer_dict[j+1]=np.array([cellsET_outer_dict[j+1][i] for i in range((N % batch_size))])\n",
-    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1),  cellsET_outer_dict[j+1]) "
+    "#if N % batch_size != 0:\n",
+    "#    \n",
+    "#    cellsET_outer_dict[j+1]=rn.root2array(\n",
+    "#        filenames=file_path,\n",
+    "#        treename=tree_name,\n",
+    "#        branches=particle+'_L0Calo_HCAL_Cells'+variable+'_'+cal_zone,# \"B0_L0HadronDecision_TOS\",\"B0_L0HadronDecision_TIS\"],\n",
+    "#        start=n_batches*batch_size,\n",
+    "#        stop=N,\n",
+    "#    ) \n",
+    "#    cellsET_outer_dict[j+1]=np.array([cellsET_outer_dict[j+1][i] for i in range((N % batch_size))])\n",
+    "#    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1),  cellsET_outer_dict[j+1]) "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "SyntaxError",
-     "evalue": "invalid syntax (<ipython-input-7-7befa847dcbe>, line 6)",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-7-7befa847dcbe>\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m    if cellsET_inner_dict[j][i][1]: and not cellsET_inner_dict[j][i][2]:\u001b[0m\n\u001b[0m                                      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
-     ]
-    }
-   ],
-   "source": [
-    "cellsET_inner_dict_TOS={}\n",
-    "\n",
-    "for j in range(n_batches):\n",
-    "    cellsET_inner_dict_TOS[j]=[]\n",
-    "    for i in range(100):\n",
-    "        if cellsET_inner_dict[j][i][1]: and not cellsET_inner_dict[j][i][2]:\n",
-    "            cellsET_inner_dict_TOS[j].append(cellsET_inner_dict[j][i][0])\n",
-    "    cellsET_inner_dict_TOS[j]=np.array(cellsET_inner_dict_TOS[j])\n",
-    "    \n",
-    "cellsET_inner_dict_TIS={}\n",
-    "\n",
-    "for j in range(n_batches):\n",
-    "    cellsET_inner_dict_TIS[j]=[]\n",
-    "    for i in range(100):\n",
-    "        if cellsET_inner_dict[j][i][2]:\n",
-    "            cellsET_inner_dict_TIS[j].append(cellsET_inner_dict[j][i][0])\n",
-    "    cellsET_inner_dict_TIS[j]=np.array(cellsET_inner_dict_TIS[j])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(17, 32, 32)"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "cellsET_inner_dict_TOS[0].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
-    "cellsET_outer_dict_TOS={}\n",
+    "particle='K'\n",
+    "L0Calo_HCAL_TriggerET ={}\n",
     "\n",
     "for j in range(n_batches):\n",
-    "    cellsET_outer_dict_TOS[j]=[]\n",
-    "    for i in range(100):\n",
-    "        if cellsET_outer_dict[j][i][1] and not cellsET_inner_dict[j][i][2]:\n",
-    "            cellsET_outer_dict_TOS[j].append(cellsET_outer_dict[j][i][0])\n",
-    "    cellsET_outer_dict_TOS[j]=np.array(cellsET_outer_dict_TOS[j])\n",
-    "    \n",
-    "cellsET_outer_dict_TIS={}\n",
-    "\n",
-    "for j in range(n_batches):\n",
-    "    cellsET_outer_dict_TIS[j]=[]\n",
-    "    for i in range(100):\n",
-    "        if cellsET_outer_dict[j][i][2]:\n",
-    "            cellsET_outer_dict_TIS[j].append(cellsET_outer_dict[j][i][0])\n",
-    "    cellsET_outer_dict_TIS[j]=np.array(cellsET_outer_dict_TIS[j])"
+    "    L0Calo_HCAL_TriggerET[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=particle+'_L0Calo_HCAL_TriggerET',\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    L0Calo_HCAL_TriggerET[j]=np.array([L0Calo_HCAL_TriggerET[j][i] for i in range(batch_size)])\n",
+    "    #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j),  cellsET_outer_dict[j])\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fcc1894d710>"
+       "6577"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 23,
      "metadata": {},
      "output_type": "execute_result"
-    },
+    }
+   ],
+   "source": [
+    "(L0Calo_HCAL_TriggerET[0]<0).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAD4CAYAAAAAczaOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAARSUlEQVR4nO3cf6zddX3H8efLVgF1jWVcWNfbrDVpVCAB5IbVsRi3mtGhsWwJSU0czULShDCHi4kpW5bFP5qwZDFKMkgaVMp0ks4fo2FD7arGLCHgRZlQCqMTR+9a6dWFifsDA773x/2YnLXn3ntK7z2lfJ6P5Jvv9/s+n8+5n09v+zrffs73nFQVkqQ+vO5MD0CSND6GviR1xNCXpI4Y+pLUEUNfkjqy8kwPYDEXXHBBrV+//kwPQ5LOKo888siPq2rixPqrPvTXr1/P9PT0mR6GJJ1VkvznsLrLO5LUEUNfkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdcTQl6SOGPqS1JFX/SdypVer9Tv/aaR2P7ztfcs8Eml0XulLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjhj6ktQRQ1+SOmLoS1JHDH1J6oihL0kdMfQlqSOGviR1xNCXpI6MFPpJ3pLki0meTHIoybuSnJ9kf5Kn2371QPtbkxxO8lSSawbqVyZ5rD12e5Isx6QkScONeqX/KeCrVfV24DLgELATOFBVG4ED7ZwkFwPbgEuALcAdSVa057kT2AFsbNuWJZqHJGkEi4Z+klXAu4FPA1TVz6vqeWArsKc12wNc1463AvdW1YtV9QxwGLgqyRpgVVU9WFUF3DPQR5I0BqNc6b8VmAU+m+R7Se5K8ibgoqo6BtD2F7b2a4EjA/1nWm1tOz6xfpIkO5JMJ5menZ09pQlJkuY3SuivBN4J3FlVVwD/S1vKmcewdfpaoH5ysWp3VU1V1dTExMQIQ5QkjWKU0J8BZqrqoXb+ReZeBJ5rSza0/fGB9usG+k8CR1t9ckhdkjQmi4Z+Vf0IOJLkba20GXgC2Adsb7XtwH3teB+wLck5STYw94btw20J6IUkm9pdOzcM9JEkjcHKEdt9GPh8kjcAPwD+mLkXjL1JbgSeBa4HqKqDSfYy98LwEnBzVb3cnucm4G7gPOCBtkmSxmSk0K+qR4GpIQ9tnqf9LmDXkPo0cOmpDFCStHT8RK4kdcTQl6SOGPqS1BFDX5I6YuhLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjhj6ktQRQ1+SOmLoS1JHDH1J6oihL0kdMfQlqSOGviR1xNCXpI4Y+pLUEUNfkjpi6EtSRwx9SerISKGf5IdJHkvyaJLpVjs/yf4kT7f96oH2tyY5nOSpJNcM1K9sz3M4ye1JsvRTkiTN51Su9H+nqi6vqql2vhM4UFUbgQPtnCQXA9uAS4AtwB1JVrQ+dwI7gI1t23L6U5Akjep0lne2Anva8R7guoH6vVX1YlU9AxwGrkqyBlhVVQ9WVQH3DPSRJI3BqKFfwNeTPJJkR6tdVFXHANr+wlZfCxwZ6DvTamvb8Yn1kyTZkWQ6yfTs7OyIQ5QkLWbliO2urqqjSS4E9id5coG2w9bpa4H6ycWq3cBugKmpqaFtJEmnbqQr/ao62vbHga8AVwHPtSUb2v54az4DrBvoPgkcbfXJIXVJ0pgsGvpJ3pTkV355DPwe8DiwD9jemm0H7mvH+4BtSc5JsoG5N2wfbktALyTZ1O7auWGgjyRpDEZZ3rkI+Eq7u3Il8PdV9dUk3wH2JrkReBa4HqCqDibZCzwBvATcXFUvt+e6CbgbOA94oG2SpDFZNPSr6gfAZUPqPwE2z9NnF7BrSH0auPTUhylJWgp+IleSOmLoS1JHDH1J6oihL0kdMfQlqSOGviR1xNCXpI4Y+pLUEUNfkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdcTQl6SOGPqS1BFDX5I6YuhLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjowc+klWJPlekvvb+flJ9id5uu1XD7S9NcnhJE8luWagfmWSx9pjtyfJ0k5HkrSQU7nSvwU4NHC+EzhQVRuBA+2cJBcD24BLgC3AHUlWtD53AjuAjW3bclqjlySdkpFCP8kk8D7groHyVmBPO94DXDdQv7eqXqyqZ4DDwFVJ1gCrqurBqirgnoE+kqQxGPVK/5PAx4BfDNQuqqpjAG1/YauvBY4MtJtptbXt+MT6SZLsSDKdZHp2dnbEIUqSFrNo6Cd5P3C8qh4Z8TmHrdPXAvWTi1W7q2qqqqYmJiZG/LGSpMWsHKHN1cAHklwLnAusSvI54Lkka6rqWFu6Od7azwDrBvpPAkdbfXJIXZI0Jote6VfVrVU1WVXrmXuD9htV9SFgH7C9NdsO3NeO9wHbkpyTZANzb9g+3JaAXkiyqd21c8NAH0nSGIxypT+f24C9SW4EngWuB6iqg0n2Ak8ALwE3V9XLrc9NwN3AecADbZMkjckphX5VfQv4Vjv+CbB5nna7gF1D6tPApac6SEnS0vATuZLUEUNfkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdcTQl6SOGPqS1BFDX5I6YuhLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjhj6ktQRQ1+SOmLoS1JHDH1J6oihL0kdMfQlqSOLhn6Sc5M8nOTfkhxM8vFWPz/J/iRPt/3qgT63Jjmc5Kkk1wzUr0zyWHvs9iRZnmlJkoYZ5Ur/ReB3q+oy4HJgS5JNwE7gQFVtBA60c5JcDGwDLgG2AHckWdGe605gB7CxbVuWcC6SpEUsGvo152ft9PVtK2ArsKfV9wDXteOtwL1V9WJVPQMcBq5KsgZYVVUPVlUB9wz0kSSNwUhr+klWJHkUOA7sr6qHgIuq6hhA21/Ymq8Fjgx0n2m1te34xPqwn7cjyXSS6dnZ2VOZjyRpASOFflW9XFWXA5PMXbVfukDzYev0tUB92M/bXVVTVTU1MTExyhAlSSM4pbt3qup54FvMrcU/15ZsaPvjrdkMsG6g2yRwtNUnh9QlSWMyyt07E0ne0o7PA94LPAnsA7a3ZtuB+9rxPmBbknOSbGDuDduH2xLQC0k2tbt2bhjoI0kag5UjtFkD7Gl34LwO2FtV9yd5ENib5EbgWeB6gKo6mGQv8ATwEnBzVb3cnusm4G7gPOCBtkmSxmTR0K+q7wNXDKn/BNg8T59dwK4h9WlgofcDJEnLyE/kSlJHDH1J6oihL0kdMfQlqSOGviR1xNCXpI4Y+pLUEUNfkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdcTQl6SOGPqS1BFDX5I6YuhLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjhj6ktSRRUM/ybok30xyKMnBJLe0+vlJ9id5uu1XD/S5NcnhJE8luWagfmWSx9pjtyfJ8kxLkjTMKFf6LwEfrap3AJuAm5NcDOwEDlTVRuBAO6c9tg24BNgC3JFkRXuuO4EdwMa2bVnCuUiSFrFo6FfVsar6bjt+ATgErAW2Antasz3Ade14K3BvVb1YVc8Ah4GrkqwBVlXVg1VVwD0DfSRJY3BKa/pJ1gNXAA8BF1XVMZh7YQAubM3WAkcGus202tp2fGJ92M/ZkWQ6yfTs7OypDFGStICRQz/Jm4EvAR+pqp8u1HRIrRaon1ys2l1VU1U1NTExMeoQJUmLGCn0k7yeucD/fFV9uZWfa0s2tP3xVp8B1g10nwSOtvrkkLokaUxGuXsnwKeBQ1X1iYGH9gHb2/F24L6B+rYk5yTZwNwbtg+3JaAXkmxqz3nDQB9J0hisHKHN1cAfAY8lebTV/hy4Ddib5EbgWeB6gKo6mGQv8ARzd/7cXFUvt343AXcD5wEPtE2SNCaLhn5V/SvD1+MBNs/TZxewa0h9Grj0VAYoSVo6fiJXkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdcTQl6SOGPqS1BFDX5I6YuhLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjhj6ktQRQ1+SOmLoS1JHDH1J6oihL0kdMfQlqSOGviR1ZNHQT/KZJMeTPD5QOz/J/iRPt/3qgcduTXI4yVNJrhmoX5nksfbY7Umy9NORJC1klCv9u4EtJ9R2AgeqaiNwoJ2T5GJgG3BJ63NHkhWtz53ADmBj2058TknSMls09Kvq28B/n1DeCuxpx3uA6wbq91bVi1X1DHAYuCrJGmBVVT1YVQXcM9BHkjQmr3RN/6KqOgbQ9he2+lrgyEC7mVZb245PrA+VZEeS6STTs7Ozr3CIkqQTLfUbucPW6WuB+lBVtbuqpqpqamJiYskGJ0m9e6Wh/1xbsqHtj7f6DLBuoN0kcLTVJ4fUJUlj9EpDfx+wvR1vB+4bqG9Lck6SDcy9YftwWwJ6IcmmdtfODQN9JEljsnKxBkm+ALwHuCDJDPBXwG3A3iQ3As8C1wNU1cEke4EngJeAm6vq5fZUNzF3J9B5wANtkySN0aKhX1UfnOehzfO03wXsGlKfBi49pdFJkpaUn8iVpI4Y+pLUEUNfkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdcTQl6SOGPqS1BFDX5I6YuhLUkcMfUnqiKEvSR0x9CWpI4a+JHXE0Jekjhj6ktQRQ1+SOmLoS1JHDH1J6oihL0kdMfQlqSNjD/0kW5I8leRwkp3j/vmS1LOxhn6SFcDfAr8PXAx8MMnF4xyDJPVs3Ff6VwGHq+oHVfVz4F5g65jHIEndWjnmn7cWODJwPgP85omNkuwAdrTTnyV5agxjW0oXAD8+04MYM+c8j/z1GEYyPv6ezx6/Maw47tDPkFqdVKjaDexe/uEsjyTTVTV1pscxTs65D8757Dfu5Z0ZYN3A+SRwdMxjkKRujTv0vwNsTLIhyRuAbcC+MY9Bkro11uWdqnopyZ8AXwNWAJ+pqoPjHMOYnLVLU6fBOffBOZ/lUnXSkrok6TXKT+RKUkcMfUnqiKG/BJJcn+Rgkl8kWfDWriQrknwvyf3jGt9yGGXOSdYl+WaSQ63tLeMe51Ia9ff8WvqqkSTnJ9mf5Om2Xz1Puz9rfzaPJ/lCknPHPdalcgpzfkuSLyZ5sv0df9e4x/pKGPpL43HgD4Fvj9D2FuDQ8g5nLEaZ80vAR6vqHcAm4Oaz/Gs3Fp3za/CrRnYCB6pqI3Cgnf8/SdYCfwpMVdWlzN2ksW2so1xai865+RTw1ap6O3AZZ8m/a0N/CVTVoapa9FPDSSaB9wF3Lf+oltcoc66qY1X13Xb8AnP/KNaOY3zLYcTf82vtq0a2Anva8R7gunnarQTOS7ISeCNn9+dvFp1zklXAu4FPA1TVz6vq+bGN8DQY+uP1SeBjwC/O9EDGLcl64ArgoTM7kmU37KtGztoXOuCiqjoGcy/iwIUnNqiq/wL+BngWOAb8T1V9fayjXFqLzhl4KzALfLYt196V5E3jHOQrNe6vYThrJfkX4NeGPPQXVXXfCP3fDxyvqkeSvGepx7ccTnfOA8/zZuBLwEeq6qdLNb7lsARzHumrRl5NFprziP1XM3d1vAF4HviHJB+qqs8t3SiX1unOmbnsfCfw4ap6KMmnmFsG+sslGuKyMfRHVFXvPc2nuBr4QJJrgXOBVUk+V1UfOv3RLY8lmDNJXs9c4H++qr58+qNaXksw57Puq0YWmnOS55KsqapjSdYAx4c0ey/wTFXNtj5fBn4LeNWG/hLMeQaYqapf/s/1i8y/9v+q4vLOmFTVrVU1WVXrmXuT6xuv5sBfCknC3Jrnoar6xJkez5i81r5qZB+wvR1vB4b9b+dZYFOSN7bf+WbOkjc157HonKvqR8CRJG9rpc3AE+MZ3mmqKrfT3IA/YO6V/0XgOeBrrf7rwD8Paf8e4P4zPe7lnjPw28wtbXwfeLRt157psS/37xm4Fvh34D+YWxY642M/jTn/KnN3sDzd9ufPM+ePA08yd4fT3wHnnOmxj2HOlwPT7e/3PwKrz/TYR9n8GgZJ6ojLO5LUEUNfkjpi6EtSRwx9SeqIoS9JHTH0Jakjhr4kdeT/AFIPxE44VIXbAAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -243,29 +229,87 @@
     }
    ],
    "source": [
-    "batch=10\n",
-    "n=4\n",
+    "plt.hist(L0Calo_HCAL_TriggerET[0][L0Calo_HCAL_TriggerET[0]<0],bins=30);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fdf22912470>"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "batch=0\n",
+    "n=10\n",
     "plt.imshow(cellsET_inner_dict[batch][n],cmap='gray')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fcc18901d90>"
+       "array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],\n",
+       "       [ 0.,  0.,  0., ...,  0.,  0.,  0.],\n",
+       "       [24.,  0.,  0., ...,  0., 24.,  0.],\n",
+       "       ...,\n",
+       "       [ 0.,  0., 24., ..., 24., 24., 24.],\n",
+       "       [ 0.,  0.,  0., ...,  0.,  0.,  0.],\n",
+       "       [ 0.,  0.,  0., ...,  0.,  0.,  0.]], dtype=float32)"
       ]
      },
-     "execution_count": 19,
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cellsET_inner_dict[batch][n]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fdf22b0e940>"
+      ]
+     },
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -277,30 +321,30 @@
     }
    ],
    "source": [
-    "batch=10\n",
-    "n=4\n",
+    "batch=0\n",
+    "n=3\n",
     "plt.imshow(cellsET_outer_dict[batch][n],cmap='gray')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
     "for j in range(n_batches):\n",
     "\n",
-    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j), cellsET_inner_dict[j])\n",
+    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_inner/batch_'+str(j), cellsET_inner_dict[j])\n",
     "    #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1), cellsET_inner_dict[j+1])\n",
     "\n",
-    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j),  cellsET_outer_dict[j])\n",
+    "    np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_outer/batch_'+str(j),  cellsET_outer_dict[j])\n",
     "    #np.save('/disk/lhcb_data/davide/HCAL_project_full_event/npy/'+file_name+'/'+variable+'_'+cal_zone+'/batch_'+str(j+1),  cellsET_outer_dict[j+1]) \n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 125,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -429,21 +473,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.15"
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
   }
  },
  "nbformat": 4,
diff --git a/create_reco_images.ipynb b/create_reco_images.ipynb
index 744bdb9..4a866db 100644
--- a/create_reco_images.ipynb
+++ b/create_reco_images.ipynb
@@ -107,7 +107,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -115,10 +115,10 @@
     "ET_outer_dict={}\n",
     "\n",
     "i=0\n",
-    "while os.path.exists('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu_full/ET_inner/batch_'+str(i)+'.npy'):\n",
-    "#while i < 2:\n",
-    "    ET_inner_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu_full/ET_inner/batch_'+str(i)+'.npy')\n",
-    "    ET_outer_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu_full/ET_outer/batch_'+str(i)+'.npy')\n",
+    "while os.path.exists('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu/ET_inner/batch_'+str(i)+'.npy'):\n",
+    "#while i < 5:\n",
+    "    ET_inner_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu/ET_inner/batch_'+str(i)+'.npy')\n",
+    "    ET_outer_dict[i]=np.load('/disk/lhcb_data/davide/HCAL_project_full_event/npy/B2Dmunu/ET_outer/batch_'+str(i)+'.npy')\n",
     "\n",
     "    i+=1\n",
     "    "
@@ -126,12 +126,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1008x432 with 2 Axes>"
       ]
@@ -155,7 +155,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fa29749f898>"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(mean_inner_ET[15:17,13:19])\n",
+    "plt.imshow(mean_inner_ET[14:18,14:18])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -164,7 +197,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -177,14 +210,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "((20000, 28, 32), (20000, 26, 32))\n"
+      "(20000, 28, 32) (20000, 26, 32)\n"
      ]
     }
    ],
@@ -197,61 +230,56 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
+    "#not actually needed\n",
     "def delete_undetected_events(X_inner, X_outer):\n",
-    "\n",
+    "    count =0\n",
+    "    total =0 \n",
     "    pos_rejected={}\n",
     "    \n",
     "    for i in range(len(X_inner)):\n",
     "        pos_rejected[i]=[]\n",
     "        \n",
     "        for j in range(X_inner[i].shape[0]):\n",
-    "            \n",
+    "            total+=1\n",
     "            equal_inner = np.array_equal(X_inner[i][j],np.zeros_like(X_inner[i][j]))\n",
     "            equal_outer = np.array_equal(X_outer[i][j],np.zeros_like(X_outer[i][j]))\n",
-    "            \n",
-    "                \n",
+    "            if equal_inner and equal_outer:\n",
+    "                count+=1\n",
+    "                pos_rejected[i].append(j)\n",
+    "           \n",
     "    X_inner_filtered={}\n",
     "    X_outer_filtered={}\n",
     "    for i in range(len(X_inner)):\n",
     "    \n",
     "        X_inner_filtered[i]=np.delete(X_inner[i],pos_rejected[i],axis=0)\n",
     "        X_outer_filtered[i]=np.delete(X_outer[i],pos_rejected[i],axis=0)\n",
-    "        \n",
-    "    return X_inner_filtered, X_outer_filtered"
+    "    print('Removed {0} empty events over a total of {1} events'.format(count, total))\n",
+    "    return X_inner_filtered, X_outer_filtered, pos_rejected\n",
+    "ET_inner_filtered, ET_outer_filtered, pos_rejected = delete_undetected_events(ET_inner_dict,ET_outer_dict)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "\n",
-    "ET_inner_filtered, ET_outer_filtered = delete_undetected_events(ET_inner_dict,ET_outer_dict)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f55a0625810>"
+       "<matplotlib.image.AxesImage at 0x7fa26e17ecc0>"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -263,30 +291,31 @@
     }
    ],
    "source": [
+    "i=1\n",
     "plt.subplot(1,2,1)\n",
-    "plt.imshow(ET_inner_filtered[0][2].reshape(28,32),cmap='gray')\n",
+    "plt.imshow(ET_inner_filtered[0][i].reshape(28,32),cmap='gray')\n",
     "plt.subplot(1,2,2)\n",
-    "plt.imshow(ET_outer_filtered[0][2].reshape(26,32),cmap='gray')"
+    "plt.imshow(ET_outer_filtered[0][i].reshape(26,32),cmap='gray')"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f55a0522d90>"
+       "<matplotlib.image.AxesImage at 0x7fa20cf16f60>"
       ]
      },
-     "execution_count": 33,
+     "execution_count": 48,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -299,14 +328,14 @@
    ],
    "source": [
     "\n",
-    "i=11\n",
+    "i=2\n",
     "plt.imshow(np.flip(insert(ET_inner_filtered[0][i],double_size(ET_outer_filtered[0][i])).reshape(52,64),axis=0))\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
@@ -316,15 +345,7 @@
       "Done batch 1\n",
       "Done batch 2\n",
       "Done batch 3\n",
-      "Done batch 4\n",
-      "Done batch 5\n",
-      "Done batch 6\n",
-      "Done batch 7\n",
-      "Done batch 8\n",
-      "Done batch 9\n",
-      "Done batch 10\n",
-      "Done batch 11\n",
-      "Done batch 12\n"
+      "Done batch 4\n"
      ]
     }
    ],
@@ -334,52 +355,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mean_output=output_pics[0].mean(axis=0, keepdims=True).reshape(52,64)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(20000, 52, 64, 1)"
+       "<matplotlib.image.AxesImage at 0x7fa20d8d1cf8>"
       ]
      },
-     "execution_count": 35,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "output_pics[0].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for i in range(len(output_pics)):\n",
-    "    with open('/disk/lhcb_data/davide/HCAL_project_full_event/reco/sample'+str(i)+'.pickle', 'wb') as handle:\n",
-    "        pickle.dump(output_pics[i], handle, protocol=pickle.HIGHEST_PROTOCOL)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "a=np.array([output_pics[0][i].sum() for i in range(len(output_pics[0]))])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
+    },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -391,7 +391,116 @@
     }
    ],
    "source": [
-    "plt.hist(a/1000,range=(0.5,120),bins=70);"
+    "plt.imshow(mean_output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fa20d8bc588>"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(mean_output[25:27,28:34])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7fa20d8119b0>"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(mean_output[24:28,30:34])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(len(output_pics)):\n",
+    "    with open('/disk/lhcb_data/davide/HCAL_project_full_event/reco/sample'+str(i)+'.pickle', 'wb') as handle:\n",
+    "        pickle.dump(output_pics[i], handle)\n",
+    "    #with open('/disk/lhcb_data/davide/HCAL_project_full_event/reco/rejected'+str(i)+'.pickle', 'wb') as handle:\n",
+    "    #    pickle.dump(pos_rejected[i], handle)\n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a=np.array([output_pics[0][i].sum() for i in range(len(output_pics[0]))])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "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.hist(a/1000,range=(0.0,120),bins=70);"
    ]
   },
   {
@@ -404,21 +513,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.15"
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
   }
  },
  "nbformat": 4,
diff --git a/create_true_images.ipynb b/create_true_images.ipynb
index d075625..c2deba4 100644
--- a/create_true_images.ipynb
+++ b/create_true_images.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import pandas as pd\n",
+    "#import pandas as pd\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "import os\n",
@@ -20,68 +20,163 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "with open('/disk/lhcb_data/davide/HCAL_project_full_event/csv/MCtracker_info.pickle', 'rb') as f:\n",
-    "    tracks=pickle.load(f)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "width_X=8404.0\n",
     "width_Y=6828.0\n",
     "#number of events\n",
     "batch_size=20000\n",
-    "n_batches=11\n",
-    "\n",
     "X_pixels=64\n",
     "Y_pixels=52"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "11"
+       "True"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "len(tracks['xProjections'])"
+    "with open('/disk/lhcb_data/davide/HCAL_project_full_event/csv/MCtracker_info.pickle', 'rb') as f:\n",
+    "    tracks=pickle.load(f)\n",
+    "    \n",
+    "n_batches=len(tracks['xProjections'])\n",
+    "\n",
+    "tracks['pi1_xProjection'][0][0] in tracks['xProjections'][0][0][0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['xProjections'][j][i][0]/=(width_X/2)\n",
+    "        tracks['xProjections'][j][i][0]*=32\n",
+    "        tracks['xProjections'][j][i][0]+=32\n",
+    "\n",
+    "        \n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['yProjections'][j][i][0]/=(width_Y/2)\n",
+    "        tracks['yProjections'][j][i][0]*=26\n",
+    "        tracks['yProjections'][j][i][0]+=26\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['pi1_xProjection'][j][i]/=(width_X/2)\n",
+    "        tracks['pi1_xProjection'][j][i]*=32\n",
+    "        tracks['pi1_xProjection'][j][i]+=32\n",
+    "\n",
+    "        \n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['pi1_yProjection'][j][i]/=(width_Y/2)\n",
+    "        tracks['pi1_yProjection'][j][i]*=26\n",
+    "        tracks['pi1_yProjection'][j][i]+=26       \n",
+    "        \n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['pi2_xProjection'][j][i]/=(width_X/2)\n",
+    "        tracks['pi2_xProjection'][j][i]*=32\n",
+    "        tracks['pi2_xProjection'][j][i]+=32\n",
+    "\n",
+    "        \n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['pi2_yProjection'][j][i]/=(width_Y/2)\n",
+    "        tracks['pi2_yProjection'][j][i]*=26\n",
+    "        tracks['pi2_yProjection'][j][i]+=26\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['K_xProjection'][j][i]/=(width_X/2)\n",
+    "        tracks['K_xProjection'][j][i]*=32\n",
+    "        tracks['K_xProjection'][j][i]+=32\n",
+    "\n",
+    "        \n",
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks['K_yProjection'][j][i]/=(width_Y/2)\n",
+    "        tracks['K_yProjection'][j][i]*=26\n",
+    "        tracks['K_yProjection'][j][i]+=26        "
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([ 26.366026  ,  32.283485  ,  43.76675   ,  40.5049    ,\n",
+       "        26.017092  ,  25.059456  ,  11.166256  ,  32.01572   ,\n",
+       "        46.174244  ,  37.074677  ,  29.652033  ,  42.82162   ,\n",
+       "        -4.8200912 ,   5.0072193 ,  17.069355  ,  23.731718  ,\n",
+       "        44.455063  ,  55.73885   ,  30.468227  ,  56.224937  ,\n",
+       "        26.463978  ,  12.707497  ,  41.476982  ,  32.009785  ,\n",
+       "        11.1635895 ,  29.462578  ,  43.270424  ,  40.199158  ,\n",
+       "        37.376354  ,  31.979446  ,  -5.9480743 ,  33.48986   ,\n",
+       "        -0.35655975,  11.592337  ,  46.973446  ,  40.964615  ,\n",
+       "        24.896637  ,  40.067432  ,  -4.4417343 ,  10.579229  ,\n",
+       "       -16.302044  ,  30.109873  ,  36.19085   ,  10.674828  ,\n",
+       "        34.354465  ,  51.943687  ,  37.02441   ,  68.699234  ,\n",
+       "         4.2089787 ,  29.306755  ,  31.927109  ,  17.94367   ,\n",
+       "        46.051395  ,  40.864464  ,   9.20113   ,  30.551847  ,\n",
+       "        59.26765   ,  21.558033  ,  36.4137    ,  43.763763  ,\n",
+       "        31.440235  ,  29.761326  ,  39.14627   ,  21.2994    ,\n",
+       "        13.478554  ,  31.528143  ,  62.70546   ,  18.237343  ,\n",
+       "        35.2656    ,  12.071615  ,  20.394001  ,  28.785568  ,\n",
+       "        35.621407  ,  54.64473   ,   8.858938  ,  72.147156  ,\n",
+       "        47.763863  ,  25.496136  ,  26.082474  ,  26.931595  ,\n",
+       "        27.804598  ,  38.213768  ,  63.684364  , -12.207516  ,\n",
+       "        -1.8446388 ,  44.428505  ,  -7.9377556 ,  50.85122   ,\n",
+       "        45.11862   ,  35.516087  ,  62.596184  ,   9.868935  ],\n",
+       "      dtype=float32),)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "for j in range(n_batches):\n",
-    "    for i in range(batch_size):\n",
-    "        tracks[\"xProjections\"][j][i][0]/=(width_X/2)\n",
-    "        tracks[\"yProjections\"][j][i][0]/=(width_Y/2)\n",
-    "        \n",
-    "        tracks[\"xProjections\"][j][i][0]*=32\n",
-    "        tracks[\"yProjections\"][j][i][0]*=26\n",
-    "       \n",
-    "        tracks[\"xProjections\"][j][i][0]+=32\n",
-    "        tracks[\"yProjections\"][j][i][0]+=26\n",
-    "        "
+    "tracks['xProjections'][0][0]"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#for j in range(n_batches):\n",
+    "#    for i in range(batch_size):\n",
+    "#        tracks[\"xProjections\"][j][i][0]/=(width_X/2)\n",
+    "#        tracks[\"yProjections\"][j][i][0]/=(width_Y/2)\n",
+    "#        \n",
+    "#        tracks[\"xProjections\"][j][i][0]*=32\n",
+    "#        tracks[\"yProjections\"][j][i][0]*=26\n",
+    "#       \n",
+    "#        tracks[\"xProjections\"][j][i][0]+=32\n",
+    "#        tracks[\"yProjections\"][j][i][0]+=26\n",
+    "#        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
    "metadata": {
     "scrolled": true
    },
@@ -92,49 +187,74 @@
     "for n in range(n_batches):\n",
     "    \n",
     "    pic = np.zeros(shape=(Y_pixels,X_pixels,1),dtype=np.float32)\n",
-    "    batch_size = tracks['regions'][0].shape[0]\n",
+    "    batch_size = tracks['pi1_region'][0].shape[0]\n",
+    "    pics_dict[n]={}\n",
+    "    pics_dict_flip[n]={}\n",
+    "    pics_dict[n]['pic']=np.array([pic for i in range(0,batch_size)])\n",
+    "    pics_dict_flip[n]['pic']=np.array([pic for i in range(0,batch_size)])\n",
     "    \n",
-    "    pics_dict[n]=np.array([pic for i in range(0,batch_size)])\n",
-    "    pics_dict_flip[n]=np.array([pic for i in range(0,batch_size)])\n",
-    "    \n",
+    "    pics_dict[n]['L0HadronDec_TIS']=np.empty(shape=(batch_size,),dtype='bool')\n",
+    "    pics_dict[n]['L0HadronDec_TOS']=np.empty(shape=(batch_size,),dtype='bool')\n",
     "    \n",
     "    for event in range(batch_size):\n",
-    "        \n",
-    "        for ntrack in range(tracks['yProjections'][n][event][0].shape[0]):\n",
+    "        #if event not in pos_rejected[n]:\n",
+    "            pics_dict[n]['L0HadronDec_TIS'][event]=tracks['L0HadronDec_TIS'][n][event]\n",
+    "            pics_dict[n]['L0HadronDec_TOS'][event]=tracks['L0HadronDec_TOS'][n][event]\n",
     "            \n",
-    "            y=int(np.floor(tracks['yProjections'][n][event][0][ntrack]))\n",
-    "            x=int(np.floor(tracks['xProjections'][n][event][0][ntrack]))\n",
+    "            for ntrack in range(tracks['yProjections'][n][event][0].shape[0]):\n",
     "            \n",
-    "            if 0<x<X_pixels:\n",
-    "                if 0<y<Y_pixels:\n",
+    "                y=int(np.floor(tracks['yProjections'][n][event][0][ntrack]))\n",
+    "                x=int(np.floor(tracks['xProjections'][n][event][0][ntrack]))\n",
+    "            \n",
+    "                if 0<x<X_pixels:\n",
+    "                    if 0<y<Y_pixels:\n",
     "    \n",
-    "                    pics_dict_flip[n][event][y,x]=tracks['realETs'][n][event][0][ntrack]\n",
+    "                        pics_dict_flip[n]['pic'][event][y,x]+=tracks['realETs'][n][event][0][ntrack]\n",
     "            \n",
-    "        pics_dict[n][event]=np.flip(pics_dict_flip[n][event], axis=0)\n",
+    "            pics_dict[n]['pic'][event]=np.flip(pics_dict_flip[n]['pic'][event], axis=0)\n",
     "\n",
     "        "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#pics_dict_filtered={}\n",
+    "#for n in range(n_batches):\n",
+    "#    \n",
+    "#    pics_dict_filtered[n]={}\n",
+    "#    \n",
+    "#for n in range(n_batches):\n",
+    "#    \n",
+    "#    pics_dict_filtered[n]['pic']=np.delete(pics_dict[n]['pic'],pos_rejected[n],axis=0)\n",
+    "#    pics_dict_filtered[n]['L0HadronDec_TIS']=np.delete(pics_dict[n]['L0HadronDec_TIS'],pos_rejected[n],axis=0)\n",
+    "#    pics_dict_filtered[n]['L0HadronDec_TOS']=np.delete(pics_dict[n]['L0HadronDec_TOS'],pos_rejected[n],axis=0)\n",
+    "#"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7f7d97368b90>"
+       "<matplotlib.colorbar.Colorbar at 0x7f294be28208>"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAATEAAAD8CAYAAAAfZJO2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADbZJREFUeJzt3X+s3XV9x/Hny/70xxhUhXQtW3FpGCwZxdxBGcviqLDqjLAEF5xb+keT/sMSzMwUtszMbX9Alqj7YzFphNlkTEDUQYgTSYUsy1jhIlUpFYvIoCuzTkGcy7oW3vvjfIv3tudyz7333HPPhz4fyc05n8/9Hr6vcO599fv9nG+/TVUhSa163VIHkKSFsMQkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTFlRiSbYmeSLJk0muH1YoSRpU5nvFfpJlwLeBy4GDwMPA+6vq8ZleszKrajVvnNf+JJ06/pef8H91JINsu3wB+7kIeLKqngJIchtwJTBjia3mjVycLQvYpaRTwZ7aPfC2CzmdXAc8O2V8sJubJsmOJJNJJo9yZAG7k6STLaTE+h3qnXRuWlU7q2qiqiZWsGoBu5Okky2kxA4CZ08ZrwcOLSyOJM3NQkrsYWBjknOSrASuAe4eTixJGsy8F/ar6liSPwTuBZYBt1TVvqElk6QBLOTTSarqS8CXhpRFkubMK/YlNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDVt1hJLckuSw0kemzK3Jsl9SQ50j2csbkxJ6m+QI7HPAFtPmLse2F1VG4Hd3ViSRm7WEquqfwZ+eML0lcCu7vku4Koh55Kkgcx3TeysqnoOoHs8c6YNk+xIMplk8ihH5rk7Sepv0Rf2q2pnVU1U1cQKVi327iSdYuZbYt9Lshagezw8vEiSNLj5ltjdwLbu+TbgruHEkaS5GeQSi88CDwLnJjmYZDtwI3B5kgPA5d1YkkZu+WwbVNX7Z/jWliFnkaQ584p9SU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtNmLbEkZye5P8n+JPuSXNfNr0lyX5ID3eMZix9XkqYb5EjsGPChqjoP2Axcm+R84Hpgd1VtBHZ3Y0kaqVlLrKqeq6qvdc9/DOwH1gFXAru6zXYBVy1WSEmayZzWxJJsAC4E9gBnVdVz0Cs64Mxhh5Ok2QxcYkneBHwe+GBVvTiH1+1IMplk8ihH5pNRkmY0UIklWUGvwG6tqi90099Lsrb7/lrgcL/XVtXOqpqoqokVrBpGZkl6xSCfTga4GdhfVR+f8q27gW3d823AXcOPJ0mvbvkA21wK/AHwzSR7u7k/AW4E7kiyHXgGeN/iRJSkmc1aYlX1L0Bm+PaW4caRpLnxin1JTRvkdFKnkKf/8pJp4w1/9uDQ9/Gdv56+j1/84+HvYzHce2jvtPFv/dymJUqiqTwSk9Q0S0xS0ywxSU1LVY1sZ6dlTV0cP9DU0vvR72+eNv7Zv/+3Of83nvnor00b//xf/OuCMumn9tRuXqwfznRVxDQeiUlqmiUmqWmWmKSmWWKSmubC/mvIjz5wwmL1ra++WH30iomT5lZ8ZXKomaT5cGFf0inDEpPUNEtMUtP8C+CvIbOtgZ1okPWv//jI9As6193kBZ0aLx6JSWqaJSapaZaYpKa5JqZplv3yudPG47oG9oPt02+s+Oab27ixoobPIzFJTbPEJDXNEpPUNNfETiEvvePt08bLHvjaydvse2JUcWZ05F2/Om286p8ePmkb18B0nEdikppmiUlqmiUmqWmuiZ1C+q2BjaN+a2DSTDwSk9Q0S0xS0ywxSU2zxCQ1zYV9LciJf2F8HC6W1anFIzFJTZu1xJKsTvJQkq8n2ZfkY938OUn2JDmQ5PYkKxc/riRNN8iR2BHgsqq6ANgEbE2yGbgJ+ERVbQSeB7YvXkxJ6m/WNbHq/eu6/90NV3RfBVwG/F43vwv4c+BTw4/42vQ/v3PxtPEbvrhn2vh1m84/6TUv7318UTPNh2tgWmoDrYklWZZkL3AYuA/4DvBCVR3rNjkIrFuciJI0s4FKrKpeqqpNwHrgIuC8fpv1e22SHUkmk0we5cj8k0pSH3P6dLKqXgAeADYDpyc5fjq6Hjg0w2t2VtVEVU2sYNVCskrSSWZdE0vyVuBoVb2Q5PXAO+kt6t8PXA3cBmwD7lrMoK81J66BnWgc17+kcTTIxa5rgV1JltE7crujqu5J8jhwW5K/Ah4Fbl7EnJLU1yCfTn4DuLDP/FP01sckacl4xb6kpllikppmiUlqmiUmqWmWmKSmWWKSmmaJSWqaJSapaZaYpKZZYpKaZolJapolJqlplpikpllikppmiUlqmiUmqWmWmKSmWWKSmjbIPfab8t0bL5k2Puf6B5coiaS5OHrFxCvP68HBf289EpPUNEtMUtMsMUlNS1WNbGenZU1dnC0j25+kNu2p3bxYP8wg23okJqlplpikpllikppmiUlqmiUmqWmWmKSmWWKSmmaJSWqaJSapaZaYpKYNXGJJliV5NMk93ficJHuSHEhye5KVixdTkvqby5HYdcD+KeObgE9U1UbgeWD7MINJ0iAGKrEk64HfBj7djQNcBtzZbbILuGoxAkrSqxn0SOyTwIeBl7vxm4EXqupYNz4IrBtyNkma1awlluQ9wOGqemTqdJ9N+97TJ8mOJJNJJo9yZJ4xJam/Qe6xfynw3iTvBlYDp9E7Mjs9yfLuaGw9cKjfi6tqJ7ATevcTG0pqSerMeiRWVTdU1fqq2gBcA3y1qj4A3A9c3W22Dbhr0VJK0gwWcp3YR4A/SvIkvTWym4cTSZIGN6d/sq2qHgAe6J4/BVw0/EiSNDiv2JfUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1DRLTFLTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9Q0S0xS0ywxSU2zxCQ1zRKT1LTlg2yU5Gngx8BLwLGqmkiyBrgd2AA8DfxuVT2/ODElqb+5HIn9ZlVtqqqJbnw9sLuqNgK7u7EkjdRCTievBHZ1z3cBVy08jiTNzaAlVsBXkjySZEc3d1ZVPQfQPZ65GAEl6dUMtCYGXFpVh5KcCdyX5FuD7qArvR0Aq3nDPCJK0swGOhKrqkPd42Hgi8BFwPeSrAXoHg/P8NqdVTVRVRMrWDWc1JLUmbXEkrwxyc8cfw5cATwG3A1s6zbbBty1WCElaSaDnE6eBXwxyfHt/6GqvpzkYeCOJNuBZ4D3LV5MSepv1hKrqqeAC/rM/wDYshihJGlQXrEvqWmpqtHtLPk+8O/AW4D/GtmO58+cw9NCRjDnsM035y9U1VsH2XCkJfbKTpPJKVf+jy1zDk8LGcGcwzaKnJ5OSmqaJSapaUtVYjuXaL9zZc7haSEjmHPYFj3nkqyJSdKweDopqWkjLbEkW5M8keTJJGN1/7EktyQ5nOSxKXNrktyX5ED3eMYSZzw7yf1J9ifZl+S6Mc25OslDSb7e5fxYN39Okj1dztuTrFzKnF2mZUkeTXLPGGd8Osk3k+xNMtnNjdV73mU6PcmdSb7V/YxeMoqcIyuxJMuAvwXeBZwPvD/J+aPa/wA+A2w9YW7cbvx4DPhQVZ0HbAau7f4fjlvOI8BlVXUBsAnYmmQzcBPwiS7n88D2Jcx43HXA/injccwIbdyU9G+AL1fVL9H7Wz77GUXOqhrJF3AJcO+U8Q3ADaPa/4AZNwCPTRk/Aaztnq8FnljqjCfkvQu4fJxzAm8AvgZcTO+ix+X9fh6WKNv67hfrMuAeIOOWscvxNPCWE+bG6j0HTgO+S7fOPsqcozydXAc8O2V8sJsbZ2N748ckG4ALgT2MYc7uNG0vvVs03Qd8B3ihqo51m4zD+/9J4MPAy934zYxfRmjjpqRvA74P/F13ev7p7q43i55zlCWWPnN+NDoPSd4EfB74YFW9uNR5+qmql6pqE72jnYuA8/ptNtpUP5XkPcDhqnpk6nSfTcfhZ/TSqno7vaWYa5P8xlIH6mM58HbgU1V1IfATRnSKO8oSOwicPWW8Hjg0wv3Px0A3fhylJCvoFditVfWFbnrsch5XVS8AD9Bbwzs9yfE7pyz1+38p8N7uX/K6jd4p5ScZr4zAwm5KOkIHgYNVtacb30mv1BY95yhL7GFgY/fpz0rgGno3VhxnY3Xjx/Ru6nYzsL+qPj7lW+OW861JTu+evx54J71F3vuBq7vNljRnVd1QVeuragO9n8WvVtUHGKOM0M5NSavqP4Fnk5zbTW0BHmcUOUe8+Pdu4Nv01kf+dCkXIvtk+yzwHHCU3p8q2+mtkewGDnSPa5Y446/TO735BrC3+3r3GOb8FeDRLudjwEe7+bcBDwFPAp8DVi31+97legdwzzhm7PJ8vfvad/z3Ztze8y7TJmCye9//EThjFDm9Yl9S07xiX1LTLDFJTbPEJDXNEpPUNEtMUtMsMUlNs8QkNc0Sk9S0/wfHiXmRhcu0+wAAAABJRU5ErkJggg==\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 432x288 with 2 Axes>"
       ]
      },
      "metadata": {
@@ -144,12 +264,14 @@
     }
    ],
    "source": [
-    "plt.imshow(pics_dict[0][11].reshape(52,64))"
+    "i=2\n",
+    "plt.imshow(pics_dict[0]['pic'][i].reshape(52,64));\n",
+    "plt.colorbar()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -160,24 +282,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "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"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "plt.hist(pics_dict[0].sum(axis=(1,2))/1000, range=(0,300),bins=70);"
+    "plt.hist(pics_dict[0]['pic'].sum(axis=(1,2))/1000, range=(0,300),bins=70);"
    ]
   },
   {
@@ -261,21 +370,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.15"
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
   }
  },
  "nbformat": 4,
diff --git a/trigger_efficiency_bicycle_GAN.ipynb b/trigger_efficiency_bicycle_GAN.ipynb
index 92e586f..405fb5b 100644
--- a/trigger_efficiency_bicycle_GAN.ipynb
+++ b/trigger_efficiency_bicycle_GAN.ipynb
@@ -8,6 +8,7 @@
    "source": [
     "import numpy as np\n",
     "import os \n",
+    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n",
     "import pickle\n",
     "\n",
     "import tensorflow as tf\n",
@@ -26,7 +27,7 @@
    "source": [
     "task='TEST'\n",
     "\n",
-    "PATH='HCAL_bycicleGAN_test97'"
+    "PATH='test12'"
    ]
   },
   {
@@ -38,27 +39,26 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "LEARNING_RATE:8e-05\n",
+      "LEARNING_RATE:0.0004\n",
       "BETA1:0.5\n",
       "BATCH_SIZE:16\n",
-      "EPOCHS:4\n",
-      "SAVE_SAMPLE_PERIOD:200\n",
+      "EPOCHS:3\n",
+      "SAVE_SAMPLE_PERIOD:400\n",
       "SEED:1\n",
-      "d_sizes:{'conv_layers': [(4.0, 4, 2, False, 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306c50>), (8, 4, 2, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306e10>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306e48>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306e80>), (64, 4, 1, 'bn', 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306eb8>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306ef0>), (32, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306f28>), (8, False, 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306f60>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad306f98>}\n",
-      "g_sizes_dec:{'deconv_layers': [(64, 4, 2, 'bn', 1, <function relu at 0x7f32c17dfae8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a048>), (32, 4, 2, 'bn', 0.8, <function relu at 0x7f32c17dfae8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a080>), (16, 4, 2, 'bn', 1, <function relu at 0x7f32c17dfae8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a0b8>), (8.0, 4, 2, 'bn', 1, <function relu at 0x7f32c17dfae8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a0f0>), (1, 4, 2, False, 0.8, <function identity at 0x7f32c1df6950>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a128>)]}\n",
-      "g_sizes_enc:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a160>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a198>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a1d0>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a208>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f32ad30a240>)]}\n",
-      "e_sizes:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a2b0>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a2e8>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a320>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a358>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a390>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a3c8>), (128, 'bn', 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a400>), (16, False, 0.8, <function lrelu at 0x7f32b30b29d8>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a438>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.RandomNormal object at 0x7f32ad30a470>}\n",
-      "preprocess:False\n",
+      "d_sizes:{'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacad9b0>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadb70>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadba8>), (64, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadbe0>), (128, 4, 1, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadc18>)], 'dense_layers': [(512, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadc50>), (64, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadc88>), (16, False, 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadcc0>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadcf8>}\n",
+      "g_sizes_dec:{'deconv_layers': [(64, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadd30>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadd68>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadda0>), (8.0, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacaddd8>), (1, 4, 2, False, 0.8, <function identity at 0x7fcabdb328c8>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacade10>)]}\n",
+      "g_sizes_enc:{'latent_dims': 128, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacade48>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacade80>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadeb8>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadef0>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7fcaaacadf28>)]}\n",
+      "e_sizes:{'latent_dims': 128, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacadf98>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacadfd0>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb1048>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb1080>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb10b8>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb10f0>), (128, 'bn', 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb1128>), (16, False, 0.8, <function lrelu at 0x7fcab0a15ea0>, <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb1160>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.RandomNormal object at 0x7fcaaacb1198>}\n",
       "cost_type:FEATURE\n",
-      "validating_size:2000\n",
-      "test_size:2000\n",
+      "validating_size:1000\n",
+      "test_size:1000\n",
       "n_batches:2\n",
       "reco_path:/disk/lhcb_data/davide/HCAL_project_full_event/reco/\n",
       "true_path:/disk/lhcb_data/davide/HCAL_project_full_event/true/\n",
       "discr_steps:1\n",
       "gen_steps:1\n",
       "vae_steps:1\n",
-      "latent_weight:2\n",
+      "latent_weight:1\n",
       "cycl_weight:1\n",
       "kl_weight:1\n"
      ]
@@ -87,7 +87,6 @@
     "    g_sizes_enc = hyper_dict['g_sizes_enc']\n",
     "    g_sizes_dec = hyper_dict['g_sizes_dec']\n",
     "    e_sizes = hyper_dict['e_sizes']\n",
-    "    preprocess = hyper_dict['preprocess']\n",
     "    cost_type = hyper_dict['cost_type']\n",
     "    validating_size=hyper_dict['validating_size']\n",
     "    cycl_weight=hyper_dict['cycl_weight']\n",
@@ -95,6 +94,7 @@
     "    kl_weight=hyper_dict['kl_weight']\n",
     "    discr_steps=hyper_dict['discr_steps']\n",
     "    gen_steps=hyper_dict['gen_steps']\n",
+    "    vae_steps=hyper_dict['vae_steps']\n",
     "    \n",
     "\n",
     "if task == 'TEST' and not os.path.exists(PATH+'/hyper_parameters.pkl'):\n",
@@ -111,102 +111,28 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#dim=1\n",
-    "#select=False\n",
-    "#test_size=000\n",
-    "#if preprocess=='normalise':\n",
-    "#    train_true_p, test_true_p, min_true, max_true, train_reco, test_reco, min_reco, max_reco = load_data(true_path, reco_path, n_batches, select=select, n_cells=dim*dim, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
-    "#else:\n",
-    "#    train_true_K, test_true_K, train_reco, test_reco = load_data(true_path_K, reco_path, n_batches,  select=select, n_cells=None, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
-    "#    train_true_p, test_true_p, _, _ = load_data(true_path_p, reco_path, n_batches,  select=select, n_cells=None, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
-    "#\n",
-    "#train_true_p, train_true_K, train_reco = delete_undetected_events_triple(train_true_p, train_true_K, train_reco)\n",
-    "#test_true_p, test_true_K, test_reco = delete_undetected_events_triple(test_true_K, test_true_K, test_reco)\n",
-    "#\n",
-    "#train_true = train_true_p + train_true_K\n",
-    "#test_true = test_true_p + test_true_K"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_batches=1\n",
-    "reco_path = '/disk/lhcb_data/davide/HCAL_project_single_pion/DKpi_cells_inout/reco/'\n",
-    "true_path_pions = '/disk/lhcb_data/davide/HCAL_project_single_pion/DKpi_cells_inout/true_lowdef/piplus/'\n",
-    "true_path_kaons = '/disk/lhcb_data/davide/HCAL_project_single_pion/DKpi_cells_inout/true_lowdef/Kminus/'"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dim=1\n",
-    "select=False\n",
-    "test_size=2000\n",
-    "if preprocess=='normalise':\n",
-    "    train_true, test_true, min_true, max_true, train_reco, test_reco, min_reco, max_reco = load_data(true_path, reco_path, n_batches, select=select, n_cells=dim*dim, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
-    "else:\n",
-    "    train_true_pions, test_true_pions, train_reco, test_reco = load_data(true_path_pions, reco_path, n_batches,  select=select, n_cells=None, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
-    "    train_true_kaons, test_true_kaons, _, _ = load_data(true_path_kaons, reco_path, n_batches,  select=select, n_cells=None, energy_fraction=1, preprocess=preprocess, test_size=test_size)\n",
+    "test_size=3000\n",
+    "n_batches=2\n",
+    "start_batch=2\n",
+    "\n",
+    "train_true, test_true, train_TIS_true, test_TIS_true, train_TOS_true, test_TOS_true, train_reco, test_reco = load_data(true_path, reco_path, n_batches, start_batch,  test_size=test_size)\n",
     "    \n",
-    "train_true, train_reco = delete_undetected_events_double(train_true_kaons, train_reco)\n",
-    "test_true_pions, test_true_kaons,_ = delete_undetected_events_triple(test_true_kaons, test_true_pions, test_reco)\n",
-    "#test_true_pions, _ = delete_undetected_events_double(test_true_pions, test_reco)"
+    "train_true, train_reco = delete_undetected_events_double(train_true, train_reco)\n",
+    "test_true, test_reco = delete_undetected_events_double(test_true, test_reco)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "test_true=test_true_kaons+test_true_pions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 42,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 792x288 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "if preprocess != False:\n",
-    "    draw_one_sample(train_true, train_reco, preprocess,\n",
-    "                    min_true=min_true, max_true=max_true, \n",
-    "                    min_reco=min_reco, max_reco=max_reco,\n",
-    "                    save=False, PATH=PATH\n",
-    "                   )\n",
-    "else:\n",
-    "    draw_one_sample(train_true,train_reco)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 237,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(44508, 52, 64, 1)"
+       "(3000, 52, 64, 1)"
       ]
      },
-     "execution_count": 237,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -217,7 +143,54 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 238,
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 792x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#if preprocess != False:\n",
+    "draw_one_sample(train_true, train_reco,\n",
+    "                    min_true=min_true, max_true=max_true, \n",
+    "                    min_reco=min_reco, max_reco=max_reco,\n",
+    "                    save=False, PATH=PATH\n",
+    "                   )\n",
+    "#else:\n",
+    "#    draw_one_sample(train_true,train_reco)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((37000, 52, 64, 1), (3000, 52, 64, 1))"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_true.shape, test_true.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -227,7 +200,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 239,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -244,9 +217,8 @@
     "                   min_reco=min_reco, max_reco=max_reco,\n",
     "                   d_sizes=d_sizes, g_sizes_enc=g_sizes_enc, g_sizes_dec=g_sizes_dec, e_sizes=e_sizes,\n",
     "                   lr=LEARNING_RATE, beta1=BETA1,\n",
-    "                   preprocess=preprocess, cost_type=cost_type,\n",
-    "                   cycl_weight=cycl_weight, latent_weight=latent_weight, kl_weight=kl_weight,\n",
-    "                   discr_steps=discr_steps, gen_steps=gen_steps,\n",
+    "                   cost_type=cost_type, cycl_weight=cycl_weight, latent_weight=latent_weight, kl_weight=kl_weight,\n",
+    "                   discr_steps=discr_steps, gen_steps=gen_steps, vae_steps=vae_steps,\n",
     "                   batch_size=BATCH_SIZE, epochs=EPOCHS,\n",
     "                   save_sample=SAVE_SAMPLE_PERIOD, path=PATH, seed= SEED)\n",
     "    \n",
@@ -265,7 +237,7 @@
     "        \n",
     "    # Add ops to save and restore all the variables.\n",
     "    \n",
-    "    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)\n",
+    "    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.15)\n",
     "    \n",
     "    with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n",
     "        \n",
@@ -328,7 +300,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 240,
+   "execution_count": 10,
    "metadata": {
     "scrolled": false
    },
@@ -342,98 +314,44 @@
       "Encoder_B\n",
       "Convolution\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
-      "Encoder output shape (?, 16)\n",
+      "Encoder output shape (?, 128)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
-      "After conv layer1\n",
-      "shape:  (?, 26, 32, 24)\n",
-      "After conv layer2\n",
-      "shape:  (?, 13, 16, 32)\n",
-      "After conv layer3\n",
-      "shape:  (?, 7, 8, 48)\n",
-      "After conv layer4\n",
-      "shape:  (?, 4, 4, 80)\n",
-      "After conv layer5\n",
-      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 576)\n",
-      "After deconv layer 1\n",
-      "Shape (?, 4, 4, 80)\n",
-      "After deconv layer 2\n",
-      "Shape (?, 7, 8, 48)\n",
-      "After deconv layer 3\n",
-      "Shape (?, 13, 16, 32)\n",
-      "After deconv layer 4\n",
-      "Shape (?, 26, 32, 24)\n",
+      " and input for generator decoder shape (?, 1, 1, 1024)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
-      "After conv layer1\n",
-      "shape:  (?, 26, 32, 24)\n",
-      "After conv layer2\n",
-      "shape:  (?, 13, 16, 32)\n",
-      "After conv layer3\n",
-      "shape:  (?, 7, 8, 48)\n",
-      "After conv layer4\n",
-      "shape:  (?, 4, 4, 80)\n",
-      "After conv layer5\n",
-      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 576)\n",
-      "After deconv layer 1\n",
-      "Shape (?, 4, 4, 80)\n",
-      "After deconv layer 2\n",
-      "Shape (?, 7, 8, 48)\n",
-      "After deconv layer 3\n",
-      "Shape (?, 13, 16, 32)\n",
-      "After deconv layer 4\n",
-      "Shape (?, 26, 32, 24)\n",
+      " and input for generator decoder shape (?, 1, 1, 1024)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "Encoder_B\n",
       "Convolution\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
-      "Encoder output shape (?, 16)\n",
+      "Encoder output shape (?, 128)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 32)\n",
+      "Feature output shape (?, 64)\n",
       "Logits shape (?, 1)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 32)\n",
+      "Feature output shape (?, 64)\n",
       "Logits shape (?, 1)\n",
       "Discriminator_B\n",
       "Input for convolution shape  (?, 52, 64, 1)\n",
       "minibatch features shape (?, 10)\n",
-      "Feature output shape (?, 32)\n",
+      "Feature output shape (?, 64)\n",
       "Logits shape (?, 1)\n",
       "Generator_A_to_B\n",
       "Input for generator encoded shape (?, 52, 64, 1)\n",
-      "After conv layer1\n",
-      "shape:  (?, 26, 32, 24)\n",
-      "After conv layer2\n",
-      "shape:  (?, 13, 16, 32)\n",
-      "After conv layer3\n",
-      "shape:  (?, 7, 8, 48)\n",
-      "After conv layer4\n",
-      "shape:  (?, 4, 4, 80)\n",
-      "After conv layer5\n",
-      "shape:  (?, 2, 2, 144)\n",
       "Output of generator encoder, \n",
-      " and input for generator decoder shape (?, 1, 1, 576)\n",
-      "After deconv layer 1\n",
-      "Shape (?, 4, 4, 80)\n",
-      "After deconv layer 2\n",
-      "Shape (?, 7, 8, 48)\n",
-      "After deconv layer 3\n",
-      "Shape (?, 13, 16, 32)\n",
-      "After deconv layer 4\n",
-      "Shape (?, 26, 32, 24)\n",
+      " and input for generator decoder shape (?, 1, 1, 1024)\n",
       "Generator output shape (?, 52, 64, 1)\n",
       "\n",
       " Evaluate model on test set...\n",
-      "INFO:tensorflow:Restoring parameters from HCAL_bycicleGAN_test97/HCAL_bycicleGAN_test97bicycle.ckpt\n",
+      "INFO:tensorflow:Restoring parameters from test12/test12bicycle.ckpt\n",
       "Model restored.\n"
      ]
     }
@@ -450,7 +368,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 277,
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scale=test_reco_NN.std()/test_reco.std()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.6232238"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "scale"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -458,7 +405,7 @@
     "test_reco_MC_hist = np.sum(test_reco_MC_hist,axis=1)\n",
     "max_MC_hist = np.max(test_reco_MC_hist)\n",
     "\n",
-    "test_reco_NN_test=test_reco_NN/1.8\n",
+    "test_reco_NN_test=test_reco_NN/0.9\n",
     "test_reco_NN_hist= test_reco_NN_test.reshape(test_reco_NN_test.shape[0],test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
     "test_reco_NN_hist = np.sum(test_reco_NN_hist,axis=1)\n",
     "max_NN_hist = np.max(test_reco_NN_hist)\n",
@@ -472,7 +419,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 278,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -482,12 +429,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 279,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1296x432 with 3 Axes>"
       ]
@@ -499,19 +446,19 @@
    "source": [
     "plt.subplot(1,3,1)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_reco = plt.hist(test_true_hist/1000,bins=30, edgecolor='black');\n",
+    "h_reco = plt.hist(test_true_hist/1000,bins=30,range=(0,190), edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "plt.ylabel('dN/dE_T', fontsize=15)\n",
     "plt.title('Total true E_T/event', fontsize=15)\n",
     "plt.subplot(1,3,2)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_reco = plt.hist(test_reco_MC_hist/1000,bins=30, edgecolor='black');\n",
+    "h_reco = plt.hist(test_reco_MC_hist/1000,bins=30,range=(0,140), edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "\n",
     "plt.title('Total Reco E_T/event from Geant4', fontsize=15)\n",
     "plt.subplot(1,3,3)\n",
     "plt.tick_params(labelsize=12);\n",
-    "h_nn = plt.hist(test_reco_NN_hist/1000, bins=30,  edgecolor='black');\n",
+    "h_nn = plt.hist(test_reco_NN_hist/1000, bins=30,range=(0,140),  edgecolor='black');\n",
     "plt.xlabel('E_T (GeV)', fontsize=15)\n",
     "\n",
     "plt.title('Total Reco E_T/event from BicycleGAN', fontsize=15)\n",
@@ -522,12 +469,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 280,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x288 with 1 Axes>"
       ]
@@ -537,10 +484,10 @@
     }
    ],
    "source": [
-    "idx = np.arange(0,25, step=25/30)\n",
+    "idx = np.arange(0,140, step=140/30)\n",
     "diff=plt.bar(idx, \n",
     "             height=(h_nn[0]-h_reco[0]), edgecolor='black', \n",
-    "             linewidth=1, color='lightblue',width = 0.6, align = 'edge') \n",
+    "             linewidth=1, color='lightblue',width = 3, align = 'edge') \n",
     "plt.xlabel('E (GeV)')\n",
     "plt.ylabel('dN/dE')\n",
     "plt.title(\"NN output - MC output\")\n",
@@ -551,12 +498,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 281,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 864x360 with 2 Axes>"
       ]
@@ -566,17 +513,21 @@
     }
    ],
    "source": [
-    "\n",
     "plt.subplot(1,2,1)\n",
     "plt.tick_params(labelsize=15);\n",
-    "h_reco = plt.hist(diffMC/1000,bins=30,edgecolor='black');\n",
+    "\n",
+    "\n",
+    "h_reco = plt.hist(diffMC/1000,bins=30, range=(-110,25), edgecolor='black');\n",
     "plt.xlabel('ET recoMC - ET tracking (GeV)', fontsize=15)\n",
     "plt.ylabel('dN/dETdiff', fontsize=15)\n",
     "plt.title('Resolution as simulated by Geant4', fontsize=15)\n",
     "plt.subplot(1,2,2)\n",
     "plt.tick_params(labelsize=15);\n",
-    "h_nn = plt.hist(diffNN/1000,bins=30, edgecolor='black');\n",
+    "\n",
+    "\n",
+    "h_nn = plt.hist(diffNN/1000,bins=30, range=(-110,25), edgecolor='black');\n",
     "plt.xlabel('ET recoNN - ET tracking (GeV)', fontsize=15)\n",
+    "\n",
     "#plt.ylabel('dN/dETdiff', fontsize=15)\n",
     "plt.title('Resolution as simulated by NN', fontsize=15)\n",
     "fig = plt.gcf()\n",
@@ -588,52 +539,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 282,
+   "execution_count": 26,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "(44508,)"
-      ]
-     },
-     "execution_count": 282,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "test_true_hist[np.where(test_true_hist<175000)].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 283,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(44497,)"
-      ]
-     },
-     "execution_count": 283,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "test_reco_NN_hist[:-11].shape"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 284,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x360 with 2 Axes>"
       ]
@@ -644,13 +555,13 @@
    ],
    "source": [
     "plt.subplot(1,2,1)\n",
-    "plt.hist2d(test_true_hist/1000,test_reco_NN_hist/1000,bins=30);\n",
+    "plt.hist2d(test_true_hist/1000,test_reco_NN_hist/1000,  range=([[0,140],[0,140]]), bins=30);\n",
     "plt.xlabel('True ET (GeV)', fontsize=15)\n",
     "plt.ylabel('NN Reco ET (GeV)', fontsize=15)\n",
     "fig=plt.gcf()\n",
     "fig.set_size_inches(5,5)\n",
     "plt.subplot(1,2,2)\n",
-    "plt.hist2d(test_true_hist/1000,test_reco_MC_hist/1000,bins=30);\n",
+    "plt.hist2d(test_true_hist/1000,test_reco_MC_hist/1000, range=([[0,140],[0,140]]), bins=30);\n",
     "plt.xlabel('True ET (GeV)', fontsize=15)\n",
     "plt.ylabel('MC Reco ET (GeV)', fontsize=15)\n",
     "fig=plt.gcf()\n",
@@ -660,7 +571,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 285,
+   "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -670,7 +581,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 286,
+   "execution_count": 28,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -680,16 +591,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 287,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(192600.06, 300480.0)"
+       "(279970.38, 550056.0)"
       ]
      },
-     "execution_count": 287,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -700,22 +611,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 288,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.image.AxesImage at 0x7fd5c7c25ef0>"
+       "<matplotlib.image.AxesImage at 0x7fca1c62be80>"
       ]
      },
-     "execution_count": 288,
+     "execution_count": 30,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -725,27 +636,27 @@
     }
    ],
    "source": [
-    "plt.imshow(test_reco_NN[10].reshape(52,64))"
+    "plt.imshow(test_reco_NN[14].reshape(52,64))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 267,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7fd5c8371d30>"
+       "<matplotlib.colorbar.Colorbar at 0x7fca1c52b9e8>"
       ]
      },
-     "execution_count": 267,
+     "execution_count": 31,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 4 Axes>"
       ]
@@ -756,31 +667,31 @@
    ],
    "source": [
     "plt.subplot(1,2,1)\n",
-    "plt.imshow(test_reco_inner_NN[3].reshape(28,32))\n",
+    "plt.imshow(test_reco_inner_NN[4].reshape(28,32))\n",
     "plt.colorbar()\n",
     "plt.subplot(1,2,2)\n",
-    "plt.imshow(test_reco_outer_NN[3].reshape(26,32))\n",
+    "plt.imshow(test_reco_outer_NN[4].reshape(26,32))\n",
     "plt.colorbar()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 268,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7fd5c8286dd8>"
+       "<matplotlib.colorbar.Colorbar at 0x7fca1c3cf5c0>"
       ]
      },
-     "execution_count": 268,
+     "execution_count": 32,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 4 Axes>"
       ]
@@ -791,16 +702,16 @@
    ],
    "source": [
     "plt.subplot(1,2,1)\n",
-    "plt.imshow(test_reco_inner[0].reshape(28,32))\n",
+    "plt.imshow(test_reco_inner[4].reshape(28,32))\n",
     "plt.colorbar()\n",
     "plt.subplot(1,2,2)\n",
-    "plt.imshow(test_reco_outer[0].reshape(26,32))\n",
+    "plt.imshow(test_reco_outer[4].reshape(26,32))\n",
     "plt.colorbar()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 269,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -812,16 +723,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 270,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(2093, 12641)"
+       "(531, 188)"
       ]
      },
-     "execution_count": 270,
+     "execution_count": 34,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -832,7 +743,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 289,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -844,16 +755,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 290,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(1902, 17156)"
+       "(172, 124)"
       ]
      },
-     "execution_count": 290,
+     "execution_count": 36,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -864,7 +775,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 291,
+   "execution_count": 37,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -874,12 +785,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 297,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKwAAAJhCAYAAABsASgZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3Xt8z3X/x/Hne5sdGJItDLM5RGrrYK5QTjkMl5yiMKSSoiikuqiLSlYOubqQooNTzhXJxUI51FW3LofiVw5RiLkqUsQctr1/f2x27fCd7bt9t++HPe632/e29v68Pu/P6/O9uN3qeX3e74+x1goAAAAAAABwCh9vNwAAAAAAAABkRmAFAAAAAAAARyGwAgAAAAAAgKMQWAEAAAAAAMBRCKwAAAAAAADgKARWAAAAAAAAcBQCKwAAAAAAADgKgRUAAAAAAAAchcAKAAAAAAAAjuLn7QacKiQkxEZERHi7DQAAAAAAgCvG1q1bj1lrQ/OqI7DKRUREhLZs2eLtNgAAAAAAAK4YxpiD+aljSSAAAAAAAAAchcAKAAAAAAAAjkJgBQAAAAAAAEchsAIAAAAAAICjEFgBAAAAAADAUbweWBljGhhj/mGM2WGMOWWM+a8xZr0xprWLWj9jzLPGmB+NMWeNMbuNMY8aY4yL2jLGmFeMMYnptduNMT2L564AAAAAAABQUF4PrCSNlBQn6d+SRkiaIOkaSWuNMYOy1c6Q9LyktZIelbRD0lRJz7qY931JQyS9m/7zuKSFxph+RXAPAAAAAAAA8BBjrfVuA8Y0kbTNWns201iQpK8lhUq6xlqbbIy5MX1sirV2eKbapZLulBRprT2aPtZZ0nJJj1lr/5k+5qO0UCxSUri19tyl+oqJibFbtmzx4J0CAAAAAC7l7Nmz+vXXX3X27FklJyd7ux0A+eTn56fAwECFhoYqMDDwkrXGmK3W2pg85/RYdwVkrf23i7EkY8xHkoZLqizpsKR70g+/mq38VUndJXVR2hNYSq9NkjQr05ypxphpkuZJukPSag/eBgAAAACgEP744w/9/PPPCg0NVeXKleXn5ycXu78AcBhrrZKTk/Xnn3/q0KFDqlSpksqXL1/oeZ2wJDA3YZKSJZ1I/z1G0s/W2oPZ6r6SlCqpQaaxGEk7rLVJ2Wq/TP/ZQAAAAAAAxzh27JiqVaumChUqqFSpUoRVwGXCGKNSpUqpQoUKqlatmo4fP+6ReR0ZWBlj6kvqJulDa+3p9OEwSUey11przyttf6qqmYZd1kpKTP9Z1cUxAAAAAICXnD9/XkFBQd5uA0AhBAUF6dy5S+7AlG+OC6yMMeUkLZV0RtKwTIeCJOV212fTj+dVezbTcVfXHmiM2WKM2fLrr7+61TcAAAAAoHB4qgq4vHny77CjAqv0zdZXSqopqYu19lCmw0mSAnI5NTD9eF61gZmO52CtnWmtjbHWxoSGhrrVOwAAAAAAADzDMYGVMcZf0geSGkvqYa3dmK0kUWlL/VydV1H/W+6Xa22msUQXxwAAAAAAAOAAjgisjDF+kpZIaiOpn7X2IxdlWyVVNsaEZxtvqLT72JqtNtoYk/1dirdmOg4AAAAAANywe/duGWO0aNEib7dSrHr27Kl69ep5u40SxeuBlTHGR9JcSZ0lPWytze1P/ZL0n0OzjQ+VdF7S8kxjiyWVljQg23UekXRM0ieF7xwAAAAAgPzZsGGDjDEyxmjChAkuayZPnpxRs2HDhhzHjx49qieeeEL169dXmTJlFBQUpPr16+vxxx/Xvn37cr12//79M+bN64OSY8KECZo/f76328iVn7cbkDRJUi9JGyUlGWP6ZDu+1lr7s7V2uzHmbUnDjTFlJX0lqa2kuyU9Z63NvMxvhaT1kl5JfyLr+/S6xpLut9aeFQAAAADgsnDbS5/oyO8utyIudlWvCtLnT99R4PMDAwM1b948PfnkkzmOzZ07V4GBgTp7Nud/sm7atEmdO3fW+fPn1bt3bw0ZMkS+vr769ttvtWjRIr322ms6f/68y2s+9NBDat26dcbvx44d07Bhw9S5c2d1797drf7r1q2rpKQk+fv7u3UenGfChAmKiYlRnz7ZYxhncEJgdUv6z+bpn+xaSvo5/Z8flnRI0n2S+ks6IOkxSVMzn2CttcaYLpLGSeorqYKk3ZLirLULPNs+AAAAAKAoHfk9SQde+qu325AkRTy9qlDn33nnnVq6dKm+/vpr3XTTTRnjO3fu1I4dO3T33XdryZIlWc45cuSIunTpogoVKmj9+vWKjIzMcjw+Pl6jRo3K9ZqNGzdW48aNM34/cOCAhg0bphtuuCHfYcW5c+fk5+cnX19fBQZm333Hmc6cOaPSpUt7uw0UkNeXBFprW1hrzSU+GzLVXrDWPmetjbDWBlhr61pr/2mttS7m/dNa+7i1toq1NtBaexNhFQAAAADAm1q1aqUqVapo3rx5WcbnzJmjsLAwtWrVKsc5L7/8sk6cOKG33norR1glSaVLl9Y//vEPj/X4+uuvyxijdevWaeTIkQoLC1NQUJB+/fXXXPew+u6779S2bVuVLl1a11xzjYYMGaJt27YVuvbkyZN68sknVbNmTfn7+6tq1aoaOnSoTp48maWuUaNGql27tr799lu1bdtWZcuWVbdu3TKO//e//9XDDz+sqlWryt/fX5GRkXr22WdzPJVmrdWECRMUERGhoKAgNWjQQAkJCW59f/npuX379qpcubJSUlJynD9q1Cj5+Pjo4MGDbvdfuXJltW7dWtu3b1fz5s1VunRpValSRc8//7wuRidnz56VMUbHjx9XQkJCxnLQzHt0TZ8+XVFRUQoODtZVV12l6Ohovfjii259D4XlhCesAAAAAAAoEXx9fdW7d2+9++67mjBhgnx9fZWSkqIFCxYoLi5OPj45nytZvny5IiIi1LJly2Lt9fHHH1e5cuX01FNP6dy5cwoKCtLvv/+eoy4xMVHNmzfXuXPnNGzYMFWqVElLly7VgAEDClWblJSkFi1aaP/+/Ro4cKDq1KmjXbt2acaMGfrqq6+0efNmlSpVKqP+5MmTatOmje6880517949Y9nizz//rFtvvVXnz5/Xgw8+qGrVqumrr77S+PHj9d133+m9997LmOPvf/+7xo0bp5YtW2rEiBE6dOiQevTooerVq+frO8tvz3FxcVqzZo3WrVun2NjYLHMsWrRIt912m2rUqOF2/5J06NAhtW/fXnFxcerVq5dWrFihMWPGqFatWoqLi5O/v7/mzZunQYMGqWbNmho5cqQkqXz58pKkGTNm6NFHH1X37t31yCOPKDU1Vbt379bGjRs1evTofH0PHmGt5ePi06BBAwsAAAAAKB7fffddrsdqPPVRMXZyaQXt5dNPP7WS7KxZs+w333xjJdnVq1dba61ds2aNlWS/+eYbO2vWLCvJfvrpp9Zaa0+ePGkl2U6dOnnqFuyPP/5oJdnRo0e7PD5jxgwrycbExNgLFy5kObZr1y4ryS5cuDBjbPDgwVaS3bBhQ8bYhQsXbOPGjQtV+9xzz9nAwEC7c+fOLD0sXrzYSrLz5s3LGLv11lutJDtlypQc93PffffZkJAQm5iYmGX85ZdftpLs5s2brbXWHj161JYqVcq2bNnSJicnZ9S9//77VpKtW7euy+8rs/z2fOrUKVu6dGnbr1+/LHWff/65lWRnzJjhdv/WWlupUqUsf7astTYlJcXWrVvXNm3aNMv5FStWtLGxsTnuoV27dvbmm2/O815zc6m/y9ZaK2mLzUcu4/UlgQAAAAAAlCTR0dGKjo7OWBY4d+5c3XjjjYqOjs5Re3EZWbly5Yq1R0l68MEH5eeX98KsVatW6aabblLz5v/bltrPz0+DBw8uVO2iRYvUqFEjVa5cWceOHcv4NGvWTH5+flq/fn2Weh8fHz300ENZxlJSUrR06VJ16NBBpUqVyjJPmzZtJCljnjVr1ujChQsZG9pf1LVrV9WsWTPP78GdnoODg9W5c2d98MEHWTbZX7BggUqVKqUePXq43f9FERERateuXZbvpXnz5tq/f3++7qF8+fI6ePCgtmzZkq/6okJgBQAAAABAMevbt6+WL1+uo0ePavny5erbt6/LuotBVfY9m4qDq/2ysktNTdWhQ4dUp06dHMeuvfbaAtdaa7V3715t2LBBoaGhWT5VqlRRcnKyfvnllyznVK5cWUFBQVnGjhw5oj///FNz587NMc8tt6S9A+7iPAcOHJCU9ibEvPpzxd2ee/furVOnTmnlypWS/hdOtWvXThUrVnS7/4siIiJy9FahQgX99ttved6DJI0ePVqBgYFq2LChateurQcffFCrVhXuZQMFwR5WAAAAAAAUs7i4OD399NPq06ePzp07p969e7usK1u2rKpVq6ZvvvmmmDtUjvDnUowxOcZszvej5bv24rKw5s2b65lnnnE5T0hISJbfXfWbmpoqSbrnnntc7pMlSdWqVcvSg6v+8sPdnmNjYxUSEqIFCxaoR48eWrt2rX755Zcsfxbc6f+izE+HZe8vP6KiorR3716tWbNGa9euVUJCgt5880117NhRH374YYG/H3cRWAEASrzYZbFKPJ1YpNcIKxOmhO7uvWEGAABcuapUqaJWrVrp448/VmxsrKpUqZJrbZcuXTRt2jR98sknuuOOO4qxy7z5+PgoPDxce/fuzXHs+++/L1RtZGSkTp48qdatWxe4v4tvODx//nye81x8omz37t267rrrshzbu3dvlg3eXXG354tL/95++239/vvvWrBggYKDg9WpU6cC9e+uSwVPZcqU0V133aW77rpLqampGj58uF599VVt3rxZzZo182gfuSGwAgCUeImnE7Xz3p1Feo2oOVFFOj8AALj8jB07Vo0bN87xlrjsnnzySc2fP18DBgzQJ598kmPJV1JSkkaNGqUpU6YUYbe569Chg2bMmKGNGzdm7E2VnJys1157rVC1vXr10rhx4/T++++rW7duWY4lJyfr1KlTqlChwiV78/f311133aWFCxfqP//5jxo2bJjleFJSklJSUhQcHKx27drJz89PU6dOVadOnTKeVPrggw/0ww8/uFwqWNie4+LiNGPGDM2fP1/Lly9X165dVbp06QL1767g4GCdOHEix/jx48czliRKaUHcTTfdJEn5XlboCQRWAAAAAAB4QePGjdW4ceM866pXr673339fXbt21fXXX6+4uDg1aNBAPj4++u6777RkyRIdO3bMa4HVqFGjtHjxYt15550aMmSIKleurCVLlujcuXOSsj7J407t3/72NyUkJKhHjx7q3bu3GjVqpJSUFO3bt0/Lli3TK6+8op49e+bZ36RJk/T555+radOmuu+++3TjjTfqzJkz2r17t5YuXarVq1dnbJQ+cuRIxcfHq02bNurWrZsOHjyoN954Q/Xr11dKSkqe13K35yZNmigiIkKjRo3SqVOnFBcXV+D+3dWwYUO9//77GjdunGrXrq1y5cqpQ4cOatasmWrUqKEmTZooLCxMBw4c0PTp01WlShW1bNnS7esUFIEVAAAAAAAO17JlS3377bd65ZVX9K9//Uvz58+XtVaRkZG65557NGTIEK/1Vq1aNW3cuFGPP/64pkyZojJlyuiee+7R3XffrebNmyswMLBAtaVLl9aGDRs0ceJELV68WEuXLlVQUJAiIiJ077335ntpWqVKlfSf//xH48eP1/Lly/X222+rXLlyqlmzpoYPH6569epl1L744osqV66cXnvtNT3xxBO6/vrrtXTpUr3zzjv6+uuv87yWuz0bY9S7d2+NHz9e11xzjctlf+70746JEyfq5MmTevnll/Xnn3+qbt266tChgx555BEtWbJE//znP/XHH3+ocuXK6tKli5599lmVL1++QNcqCJPfTbdKmpiYGOvtVzgCAIpH1JyoYlkSWNTXAADgcrZr164c+wZddNtLn+jI70nF3JFrVa8K0udPO2sfKadauHChevfura1bt2a80c4TtXC2S/1dliRjzFZrbUxe8/CEFQAAAADA0QiInC8pKSnLW/ouXLigqVOnKiQkRFFRUQWuRclFYAUAAAAAAArl1ltv1W233abo6Gj98ccfWrJkibZv365p06bleLueO7UouQisAAAAAABAoXTq1EkffPCB5s+fr+TkZNWvX19z5sxRv379ClWLkovACgAAAAAAFMq4ceM0btw4j9ei5PLxdgMAAAAAAABAZgRWAAAAAAAAcBSWBAJAMYpdFqvE04lFfp2wMmFK6J5Q5NcBAAAAgKJAYAUAxSjxdKJ23ruzyK8TNYfXAQMAAAC4fLEkEAAAAAAAAI5CYAUAAAAAAABHIbACAAAAAACAoxBYAQAAAAAAwFEIrAAAAAAAQJ7Onj0rY4xeeuklb7dSrJ5++mkFBgZ6u40Sh7cEAgAAAACcbUqU9Mchb3eRpny4NMz9tz5v2LBBLVu2lCT961//Uvv27bMcnz17tu677z6tXbtWrVu3LvA52Y0dO1bPPfdcvnr88ccfFRER4c5t4TI1c+ZMnT9/Xo8++qi3W8kVgRUAAAAAwNn+OCSN/cPbXaQZW77QUzz77LM5wqeiOEeSunXrptq1a2cZ69u3r5o0aaJBgwZlGQ8NDb3kXIGBgUpKSlKpUqXc7gPOMnPmTP35558EVgAAAAAAQLrlllu0detWffDBB+ratWuRnXNRdHS0oqOjs4z17dtXkZGR6tOnT77mSE5OVmpqqvz9/S+bpXFnzpxR6dKlvd0GCoE9rAAAAAAAKCYPPPCAwsPDNWbMGFlri+ycglqzZo2MMZo7d67i4+MVGRmpgIAAbdu2Ldc9rA4fPqwePXqobNmyqlChgvr06aPDhw8Xuvb8+fN68cUXVa9ePQUEBOiaa67Rvffeq6NHj2ap69mzp/z8/HT48GF1795dFSpUUIMGDTKOnzx5Uk8++aRq1qwpf39/Va1aVUOHDtXJkydz3P8777yjevXqKTAwUPXr19e7777r1veXn54HDRokf39//fbbbznOnzlzpowx2rRpk9v9N2rUSLVr19YPP/ygjh07Kjg4WCEhIRoyZIguXLiQUVe5cmVt3bpVe/bskTFGxpgsQeSiRYvUsGFDlS9fXmXLllW9evU0dOhQt74HT+AJKwAAAAAAiom/v7+effZZPfjgg1q8eLF69uxZJOcU1oQJE2St1aBBgxQQEJDrcsHTp0/rjjvu0IEDBzR48GDVqVNHa9asUadOnQpVm5qaqq5du2r9+vW6//77deONN+qnn37S1KlT9dlnn2nbtm0qX/5/yzOttWrbtq1uvPFGxcfHZwQ0SUlJatGihfbv36+BAweqTp062rVrl2bMmKGvvvpKmzdvzlji+NZbb2nAgAG65ZZbFB8fr99//11DhgxReHh4vr6z/PYcFxen119/XUuXLtVDDz2UZY4FCxaoevXqatq0qdv9S9KpU6fUqlUrtW3bVpMmTdKmTZs0bdo0Va5cWaNHj5YkTZ8+XSNHjtTZs2c1YcIESZKvr6+ktL3SevXqpVatWmn8+PHy8/PT/v379fHHH+frO/Aoay0fF58GDRpYAPC0G2bfcEVd50pRHN8X/5sAAHBp3333Xe4Hx5QrvkbyUsBePv30UyvJzpo1y164cMHWrl3b1q1b1yYnJ1trrX3nnXesJLt27dpCnZMfkmxcXJzLY6tXr7aSbNWqVe2pU6eyHEtKSrKSbHx8fMbYhAkTrCQ7Z86cLLU9evQoVO2cOXOsJPvxxx9nqf3iiy+sMca+8MILGWP33HOPlWQfe+yxHPfz3HPP2cDAQLtz584s44sXL7aS7Lx586y11p49e9ZWrFjR1q1b1545cyajbsuWLdYYYwMCAlx+X5nlt+fU1FRbo0YN26xZsyx1hw8ftj4+Pvapp55yu39rrb311lutJDtjxowstW3atLHVq1fPMtagQQNbt27dHPfw8MMP25CQEJuSkpLn/ebmkn+XrbWStth85DIsCQQAAAAAoBj5+flpzJgx2rNnj+bPn19k5xRGv379FBwcnGfdqlWrVLFiRcXFxWUZd7WEzJ3aRYsWqVatWrr55pt17NixjE/t2rVVrVo1rV+/Psc5gwcPdjlPo0aNVLly5SzzNGvWTH5+fhnzfPHFFzp+/LgeeughBQUFZZzfoEEDtWjRIs/vwZ2ejTHq3bu3Nm/erMOHD2ecv3DhQqWmpmb5fvLb/0WlSpXSgAEDsoy1bNlShw8f1vnz5/O8h/Lly+vkyZNat25dvu65KBFYAQAAAABQzHr37q369evr+eefz7K/kKfPKajIyMh81R04cEA1a9bMWFJ20bXXXluo2t27d2v//v0KDQ3N8fnpp5/0yy+/ZKk3xigiIiLLmLVWe/fu1YYNG3LMUaVKFSUnJ2fMc+DAAUlS3bp1c/TiaswVd3qOi4uTtVYLFy7MGFuwYIFuuOEGRUVFud3/RVWrVpWfX9bdnypUqCBrrU6cOJHnPQwdOlSRkZGKjY1VtWrV1KdPHy1evFjJycn5+g48iT2sAAAAAAAoZj4+Pho7dqzuvvtuvf322woICCiScwoq81NGl2KtlTHG5XhhalNTU1WvXj1NnTrV5XXLlCmT5XcfHx/5+/vnmNdaq+bNm+uZZ55xOU9ISEiWHlz1l1/u9Hz99dcrOjpaCxYs0MiRI7Vnzx5t375d8fHxBer/ouxhYGauvufswsLCtGPHDq1fv14JCQn6+OOP9e677yomJkabNm3K958LTyCwAgAAAADAC7p3764bb7xR48aNyzWQ8MQ5RSkyMlL/93//p5SUlCxhyffff1+o2tq1a+ubb77RHXfcIR+fgi0O8/HxUWRkpE6ePKnWrVvneR9S2lNS7du3z3Jsz549+bqeuz3HxcXpqaee0q5du7Rw4UIZY9SrV68C9e+uSwVz/v7+at++fcb3MGXKFA0fPlxLly5Vv379PNrHpbAkEAAAAAAALzDG6Pnnn9fhw4c1c+bMIjunKHXo0EHHjx/Xu+++m2X8n//8Z6Fqe/XqpWPHjukf//hHjmPWWh07dixf/fXq1Uvbt2/X+++/n+NYcnJyxjK5xo0bq2LFipo5c6aSkpIyarZt26YNGzbk+1ru9NyrVy8ZY7RgwQItXLhQt99+u2rUqFGg/t0VHBzs8tzjx4/nGLv55pslSb/99luBrlVQPGEFACiQ2GWxSjydWKTXCCsTpoTuCUV6DQAAAG/q1KmT/vKXv+irr74q0nOKyuDBg/XGG29owIAB2r59u2rXrq01a9YoMTHt3xMzP8njTu19992nFStWaMSIEdq0aZNatGghf39//fDDD1q+fLkGDBigp59+Os/+/va3vykhIUE9evRQ79691ahRI6WkpGjfvn1atmyZXnnlFfXs2VMBAQEaP368HnroId1+++3q27evTpw4oalTpyo6Olq7d+/O81ru9ly9enU1a9ZMr776qk6dOqUnnniiwP27q2HDhtqwYYOeeOIJ3XLLLSpVqpR69OihPn366PTp02rZsqXCw8P1888/6/XXX1eZMmXUuXNnt69TGARWAIACSTydqJ337izSa0TNiSrS+QEAwGWifLg0try3u0hTPtzjU77wwguKjY0t8nOKQnBwsDZs2KDHH39cb775pnx9fdWxY0dNnDhR1113nQIDAwtU6+Pjow8++EDTpk3T7NmzNWrUKPn5+al69erq0KGDunbtmq/+SpcurQ0bNmjixIlavHixli5dqqCgIEVEROjee+9Vs2bNMmoHDhwoX19fvfzyy3rqqadUs2ZNTZ06VTt37sxXYFWQnuPi4rRx48aMwKgw/bvjb3/7mw4cOKC33npLkydPVkBAgHr06KH+/fvrnXfe0cyZM/Xbb78pJCREt912m5599tl8b8TvKSY/m26VRDExMXbLli3ebgPAFSZqTlSRhzzFdZ0r5RrFdZ3iuhcAAC5Xu3bt0nXXXeftNuAhX3zxhZo0aaL33ntP3bp181gtnC+vv8vGmK3W2pi85mEPKwAAAAAAUGCZ93yS0vZrmjJlikqVKqWmTZsWuBYlG0sCAQAAAABAgXXt2lWVKlVSTEyMLly4oJUrV2bsjxQaGlrgWpRsBFYAAAAAAKDAOnTooNmzZ2vFihVKSkpSrVq1NHnyZA0bNqxQtSjZCKwA4AoUViasyDcsDysTVqTzAwAA4PIwdOhQDR061OO1KNkIrADgCpTQPcHbLQAAAABAgbHpOgAAAAAAAByFwAoAAAAAAACOQmAFAAAAAAAARyGwAgAAAAAAgKMQWAEAAAAAAMBRCKwAAAAAAADgKARWAAAAAAAAcBQCKwAAAAAArjB79uxR27ZtddVVV8kYo9mzZ3u7pctao0aNVLt27TzrevbsqXr16hVDR1c+P283AABAbsLKhClqTlSxXAcAADhX7LJYJZ5O9HYbktL+vSGhe4Lb523YsEEtW7bM9XhcXJzGjRunyMjIfM03ZswYjR07Ntfj/fv31969ezV27FiFhISoSZMm7rZcrMaOHavnnnsuX7U//vijIiIiirYheB2BFQDAsQryL4MAAODKk3g6UTvv3entNiSp0P9n2gMPPKAWLVrkGK9Zs6ZCQ0M1b968LOMzZ87U5s2bNWfOHPn4/G+RVHR0dK7XOHv2rL788ks98sgjevzxxwvVb3Hp1q1bjieY+vbtqyZNmmjQoEFZxkNDQ4uzNbfMmzdP1lpvt3FFILACAAAAAKCYNGrUSH369Mn1ePZj69at0+bNm9W7d2/5+eXvP+F/+eUXSdJVV12VZ21KSopSUlLk7++fr7mLSnR0dI4Qrm/fvoqMjLzk95VZcnKyUlNTvXovpUqV8tq1rzRe38PKGBNsjBlrjFlpjDlqjLHGmNku6manH8vtMzpTbcQl6t4s1hsEAAAAAKCY9O/fXzVq1JAkvfjiizLGyBgjKW1ZojFGs2bN0qRJk1SrVi0FBATo3//+tyTJWqspU6aofv36CggIUKVKldS/f38lJmZdjjl79mwZY7RmzRr9/e9/V7Vq1VSmTBnFxsbq0KFDkqTp06erTp06CgwMVMOGDbVt2zaP3ueaNWtkjNHcuXMVHx+vyMhIBQQEZFznpZfapFoSAAAgAElEQVRe0u23367Q0FAFBATo2muv1QsvvKDk5OQcc506dUqjRo3Stddem3Hf7du315dffnnJHnbt2qVq1arphhtuyPiOXO1hVblyZbVu3Vrbt29X8+bNVbp0aVWpUkXPP/98jqexrLWKj49XeHi4goKC1LBhQ61bt65E7o3lhCesQiSNkXRU0hZJHXOpe0PSOhfjj0mKkbTaxbEVkpZlG9tXsDYBAAAAACicP//8U8eOHcsxXrZsWQUEBBR6/oceekg33XSThg0bps6dO6t79+45al599VUlJydr4MCBGeGJJA0ZMkTTp09XmzZtNHjwYB04cEDTpk3Tp59+qm3btqlixYpZ5hk9erQCAgL05JNPKjExUZMnT1bnzp3Vu3dvzZ07V4MGDdKZM2f08ssvq2vXrtq3b5/Hn0CaMGGCrLUaNGiQAgICMpYLTpw4UV26dNFdd92lgIAAbdq0SWPGjFFiYqJmzJiRcf7p06fVtGlT7dixQ7169dJjjz2mM2fO6LPPPtNnn32mRo0aubzuli1b1L59e9WsWVOrV6/W1Vdffck+Dx06pPbt2ysuLk69evXSihUrNGbMGNWqVUtxcXEZdaNHj1Z8fLzuuOMOPfnkk/rpp5/UvXt3VatWzQPf1uXFCYHVUUnVrLVHjDF+ki64KrLWfiHpi8xjxpjSkl6TtNNa6yqu/T9r7XxPNwwAAAAAQEEMGzZMw4YNyzH+zjvvqH///oWev3HjxqpSpYqGDRumG264weVyul9//VV79+5V+fLlM8a+/fZbTZ8+XZ06ddLy5csznspq2rSpunTpovj4eE2aNCnLPD4+Ptq0aVPGUsWUlBRNmjRJJ06c0LfffqsyZcpIkipUqKBHH31Ua9as0Z133lnoe8zs999/1+7duxUcHJxl/NChQxnXl6TBgwcrMjJSkyZN0vPPP58RbMXHx+ubb77Rm2++qQceeCCjfuTIkbnuRbVx40bdeeed+stf/qLly5fnuLYr33//vVavXq127dpJkgYOHKj69evrjTfeyAisjh49qokTJ6pVq1b6+OOPM/Ysa9asmTp27Ki6deu68c1c/ry+JNBae85ae6SAp3eVVFbSnNwKjDFBxpigAs4PAAAAAIDHDB8+XGvXrs3xiY2NLbYe4uLisoRVkrRy5UpJaUHNxbBKkjp37qy6devqww8/zDHPgw8+mGVfrdtuuy1j/sxh0cXxffs8v+CpX79+LgOji9dPSUnRiRMndOzYMbVs2VLJycn6+uuvM+qWLFmiOnXq6P77788xR+bv4aKVK1eqXbt2at26tVatWpWvsEqSIiIiMsIqKS3sa968ufbv358xlpCQoOTkZA0ZMiTLBvt//etfc2xIXxI44QmrwrhXUrKk3J6iekzSaEkyxuyT9A9r7fRi6g0AAAAAgCyuu+46tW7d2qs9REZG5hg7cOCApLT+srvuuuu0atWqHOMX98q66OIm7+Hh4S7Hf/vttwL1eymu7kWSPvroI40bN05bt27NsW/ViRMnJKXtF7V//3516dLFZTiV3ZEjR9StWze1aNFCS5cula+vb777jIiIyDFWoUKFLN/Jxf8N6tSpk6O2Tp06+uGHH/J9vSvBZRtYGWOqSmolabW19udsh1MlrZe0XNJBSWGSBkiaZoyJsNaOzGXOgZIGSjn/ggHwnthlsUo8nZh3YSGFlQlTQveEIr8OAAAA4E1BQbkvQnIV3OS2NC63wCa38dzmKQxX97Jx40Z16tRJt99+u1577TWFhYUpICBAP/74owYOHKjU1NQs9fkJqyQpNDRU9erV08aNG5WQkKAOHTrku8/8fCcX/9md/w2uZJdtYCWpr9KWNM7OfsBae0hSlsg6/e2An0gabox53Vq738V5MyXNlKSYmJiS96cBcKjE04naee/OIr9O1JyoIr8GAAAA4EQXnwD67rvvdPvtt2c5tnv3bpdPCDnVokWLFBwcrHXr1snf3z9jfMWKFVnqjDGqVauWdu7M339r+Pv7a8WKFerYsaO6deumlStXqk2bNh7r++LTYnv37s3xpNu+ffvceqLrSuD1PawKoZ+kE5JW5qfYWpsiaZLS7rlVEfYFAAAAAMBl5eJm6JMnT87yNM/KlSu1Z88ej2+WXpR8fX3l4+OjlJSUjLHk5GRNnjw5R+3dd9+tvXv3avbs2TmOuXqqKSgoSCtXrtStt96qzp0765NPPvFY323btpWvr6+mTp2a5SmwVatWFcn+X053WT5hZYxpKOk6Sa9Za8+5cerB9J8hnu8KAAAAAIBL+/LLLxUYGJhjvGLFimrfvr0XOkpz/fXXa/DgwXrttdfUrl073XnnnTp48KCmTZum8PBwjRo1ymu9uatLly6aPn26WrVqpT59+uj06dNauHChy6V2Tz/9tFasWKH7779f69atU5MmTXT27Fl99tlnuu222zRixIgc55QuXVqrVq3K+J5Wr16tZs2aFbrvsLAwjRgxQhMmTFDbtm3VpUsX/fTTT5o5c6auv/76LAFcSXBZBlZK22xdusTbAXNxcVv9XzzYCwAAAACgCIWVCXPM9g1hZcIKdf5bb72lt956K8d4gwYNvBpYSdLUqVNVq1YtzZo1SyNGjFD58uV19913a/z48apYsaJXe3NH69atNW/ePL300ksaMWKEKlasqJ49eyouLk633HJLltrg4GB99tlnGjdunN577z0tWbJEFSpUUExMjJo2bZrrNYKDg7V69Wq1bdtWf/3rX5WQkKAmTZoUuvf4+HiVK1dOr7/+up544gndcMMNWrZsmaZMmaIjR44Uev7LiXHSxl3GGD9JFyTNsdb2z6XGX1KipF+stfVzqbnaWvtbtrFASZ9JulFSrfR9rnIVExNjt2zZ4v5NAPC4qDlRxbKHVXFs7s7G7iVXcf05BgDgcrVr1y6Xb6gDINWtW1d169bVhx9+6O1W8pTX32VjzFZrbUxe8zjiCStjzKOSrtL/9tSKNsY8k/7PH1prd2Qq7yipoqSJl5hysjEmXNLnkn6SVElpe17VkfRMXmEVgJKJIAkAAACANyUlJeV48+FHH32kvXv3atCgQV7qyjscEVhJekJSjUy/35z+kaTDkjIHVvdKSpU07xLzfSxpYPrnaklnJG2X9LS19n0P9QwAAAAAAOAxixcv1htvvKGOHTsqJCREO3bs0KxZs1SzZk098MAD3m6vWDkisLLWRrhR2zkfNQslLSxMTwAAAAAAAMUpOjpaV111laZNm6bjx4+rQoUK6tWrl8aPH6+yZct6u71i5YjACgAAAAAAoKS75ZZbtHr1am+34Qg+eZcAAAAAAAAAxYfACgAAAADgCE56iz0A93ny7zCBFQAAAADA63x9fXXhwgVvtwGgEC5cuCBfX1+PzEVgBQAAAADwurJly+rkyZPebgNAIZw8edJjm8MTWAEAAAAAvO7qq6/WiRMndOzYMZ0/f57lgcBlwlqr8+fP69ixYzpx4oSuvvpqj8zLWwIBAAAAAF4XEBCg8PBw/fbbbzpw4IBSUlK83RKAfPL19VXZsmUVHh6ugIAAj8xJYAUAAAAAcISAgABVqVJFVapU8XYrALyMJYEAAAAAAABwFAIrAAAAAAAAOAqBFQAAAAAAAByFwAoAAAAAAACOQmAFAAAAAAAARyGwAgAAAAAAgKMQWAEAAAAAAMBRCKwAAAAAAADgKARWAAAAAAAAcBQCKwAAAAAAADgKgRUAAAAAAAAchcAKAAAAAAAAjkJgBQAAAAAAAEchsAIAAAAAAICjEFgBAAAAAADAUQisAAAAAAAA4CgEVgAAAAAAAHAUAisAAAAAAAA4CoEVAAAAAAAAHIXACgAAAAAAAI5CYAUAAAAAAABHIbACAAAAAACAoxBYAQAAAAAAwFH8vN0AAAAlQViZMEXNiSryayR0TyjSawAAAADFgcAKAIBiUBxBUlEHYgAAAEBxYUkgAAAAAAAAHIXACgAAAAAAAI5CYAUAAAAAAABHIbACAAAAAACAoxBYAQAAAAAAwFEIrAAAAAAAAOAoBFYAAAAAAABwFAIrAAAAAAAAOAqBFQAAAAAAAByFwAoAAAAAAACOQmAFAAAAAAAARyGwAgAAAAAAgKMQWAEAAAAAAMBRCKwAAAAAAADgKARWAAAAAAAAcBQCKwAAAAAAADgKgRUAAAAAAAAchcAKAAAAAAAAjkJgBQAAAAAAAEfxemBljAk2xow1xqw0xhw1xlhjzGwXdRHpx1x93nRR72eMedYY86Mx5qwxZrcx5lFjjCmWGwMAAAAAAECB+Hm7AUkhksZIOippi6SOedSvkLQs29g+F3UzJA2QNEvSV5LaSpoq6WpJzxeiXwAAAAAAABQhJwRWRyVVs9YeMcb4SbqQR/3/WWvnX6rAGHOj0sKqKdba4enDbxpjlkoaZYyZZa09WujOAQAAAAAA4HFeXxJorT1nrT3izjnGmCBjTNAlSu5J//lqtvFXJQVI6uLO9QAAAAAAAFB8vB5YFcBjks5IOmOM+d4Y84iLmhhJP1trD2Yb/0pSqqQGRdwjAAAAAAAACsgJSwLzK1XSeknLJR2UFKa0ZX/TjDER1tqRmWrDJOV4astae94Yc1xS1WLoFwAAAAAAAAVw2QRW1tpDklpnHkt/O+AnkoYbY1631u5PPxQk6WQuU51NP56DMWagpIGSFB4e7om2AQAAAAAA4KbLcUlgBmttiqRJSruPVpkOJSltrypXAtOPu5pvprU2xlobExoa6tFeAQAAAAAAkD+XzRNWl3Bxn6qQTGOJkqKyFxpj/CVVTD8OwANil8Uq8XTR/pUKKxNWpPMDAAAAAJzlSgisaqf//CXT2FZJbYwx4elLCS9qqLSnsbYWV3PAlS7xdKJ23rvT220AAAAAAK4gl82SQGPM1S7GAiWNkpQs6eNMh5ak/xya7ZShks4rbeN2AAAAAAAAOJAjnrAyxjwq6Sr9L0CLNsY8k/7PH1prd0iabIwJl/S5pJ8kVZLUT1IdSc9kfpLKWrvdGPO20jZjLyvpK0ltJd0t6TlrLUsCAQAAAAAAHMoRgZWkJyTVyPT7zekfSTosaYfSnqC6+Ba/qyWdkbRd0tPW2vddzPmwpEOS7pPUX9IBSY9Jmurx7gEAAAAAAOAxjgisrLUR+ahZKGmhG3NekPRc+gcAAAAAAACXictmDysAAAAAAACUDARWAAAAAAAAcBQCKwAAAAAAADgKgRUAAAAAAAAchcAKAAAAAAAAjkJgBQAAAAAAAEchsAIAAAAAAICjEFgBAAAAAADAUQisAAAAAAAA4CgEVgAAAAAAAHAUAisAAAAAAAA4CoEVAAAAAAAAHIXACgAAAAAAAI5CYAUAAAAAAABHIbACAAAAAACAoxBYAQAAAAAAwFEIrAAAAAAAAOAoBFYAAAAAAABwFAIrAAAAAAAAOAqBFQAAAAAAAByFwAoAAAAAAACOQmAFAAAAAAAARyGwAgAAAAAAgKP4ebsBAEUndlmsEk8nFuk1wsqEFen8AAAAAICSh8AKuIIlnk7Uznt3ersNAAAAAADcwpJAAAAAAAAAOAqBFQAAAAAAAByFwAoAAAAAAACOQmAFAAAAAAAARyGwAgAAAAAAgKMQWAEAAAAAAMBRCKwAAAAAAADgKARWAAAAAAAAcBQCKwAAAAAAADgKgRUAAAAAAAAchcAKAAAAAAAAjkJgBQAAAAAAAEfx83YDAADAM8LKhClqTlSxXCehe0KRXwcAAAAlF4EVAABXiOIKkYojFAMAAEDJxpJAAAAAAAAAOAqBFQAAAAAAAByFwAoAAAAAAACOQmAFAAAAAAAARyGwAgAAAAAAgKMQWAEAAAAAAMBR/LzdAAAAuLyElQlT1JyoIr9GQveEIr0GAAAAnIvACgAAuKU4gqSiDsQAAADgbCwJBAAAAAAAgKMQWAEAAAAAAMBRCKwAAAAAAADgKARWAAAAAAAAcBQCKwAAAAAAADiK1wMrY0ywMWasMWalMeaoMcYaY2a7qGtgjPmHMWaHMeaUMea/xpj1xpjWLmoj0udx9XmzWG4MAAAAAAAABeLn7QYkhUgaI+mopC2SOuZSN1JSK0nvSZomKVjSfZLWGmMGW2tnuDhnhaRl2cb2eaJpAAAAAAAAFI0CB1bGGH+lhU1J1toThejhqKRq1tojxhg/SRdyqfunpP7W2rOZepgh6WtJLxpjZllrk7Od83/W2vmF6A0AAAAAAADFLN9LAo0xZY0xDxpjlhhj/ispSdJPko4ZY84ZY/5jjHnZGHOrOw1Ya89Za4/ko+7fmcOq9LEkSR9JqiCpci59BxljgtzpCQAAAAAAAN6TZ2BljKlqjHldUqKkNyR1l+QvaY+kL5T2hNNRSTcpbdnev40xW40xvYqs66zCJCVLcvWU12OSzkg6Y4z53hjzSDH1BAAAAAAAgAK65JJAY8xzkkZICpC0VtIiSZ9ba/e7qC0t6S+SYiXFSXrXGPOYpIHW2h2ebjz9mvUldZP0obX2dKZDqZLWS1ou6aDSQq0BkqYZYyKstSOLoh8AAAAAAAAUXl57WI2U9Lqkidbao5cqtNaekbRB0gZjzCilbZ4+VlIXSR4PrIwx5SQtVdoTVMOy9XJIUuts9W9K+kTScGPM67mEbgMlDZSk8PBwT7cMAAAAAACAfMhrSWBta+3wvMKq7GyaldbaBpJmFrw919L3pFopqaakLukBVV49pUiapLR7bpVLzUxrbYy1NiY0NNSTLQMAAAAAACCfLvmElbU2sbAXsNb+t7BzZJb+dsIPJDWW1M1au9GN0w+m/wzxZE8AAAAAAADwnLyWBDqKMcZP0hJJbSTFWWs/cnOK2uk/f/FoYwAAAAAAAPCYPN8S6BTGGB9JcyV1lvSwtXbRJWqvdjEWKGmU0t4o+HFR9QkAAAAAAIDC8egTVsaYupK+U9o2Vvme2xjzqKSr9L8ALdoY80z6P3+Y/pbBSZJ6SdooKckY0yfbNGuttT+n//NkY0y4pM8l/SSpkqR+kupIeiY/e14BAAAAAADAO4piSaBJ/7jjCUk1Mv1+c/pHkg4r7S2Dt6T/3jz9k11LSRcDq4+V9ra/gZKuVtqbBLdLetpa+76bvQEAAAAAAKAYeTSwstbuUQGWGVprI/JR08KN+RZKWuhuHwAAAAAAAPC+y2rTdQAAUDKElQlT1JyoIr9GQveEIr0GAAAACobACgAAOE5xBElFHYgBAACg4C6btwQCAAAAAACgZHDrCStjTKokm49St94SCAAAAAAAAFzkbqi0Sa4Dq6skXSspSNI3kn4vZF8AAAAAAAAoodwKrC71pj5jTFlJUyQ1kdStcG0BAAAAAACgpPLYHlbW2lOSBkpKlvSip+YFAAAAAABAyeLRTdettamSPpXUxZPzAgAAAAAAoOQoircEBkqqUATzAgAAAAAAoATwaGBljKknqYekfZ6cFwAAAAAAACWHW5uuG2PevsQ81SXdJslX0ohC9gUAAAAAAIASyq3ASlL/PI7vljTRWvtOwdoBAAC4ssQui1Xi6cQivUZYmTAldE8o0msAAAAUJ3cDq8hcxlMlnbDW/lnIfgAAAK4oiacTtfPenUV6jag5UUU6PwAAQHFzK7Cy1h4sqkYAAAAAAAAAqWjeEggAAAAAAAAUGIEVAAAAAAAAHMWjgZUxpq4xJsUYk+zJeQEAAAAAAFByuLvpen6Y9A8AAAAAAADgNo8GVtbaPWKZIQAAAAAAAAqBcAkAAAAAAACOQmAFAAAAAAAARymKPawAAAAcL6xMmKLmRBXLdQAAAOAetwMrY0wVSc9IipVUVZK/izJrrSUMAwAAjpXQPcHbLQAAACAXboVKxpiqkr6SVEnSt5ICJB2UdE5SzfT5vpb0h2fbBAAAAAAAQEnh7h5Wf5dUWVI7a+2N6WPvWGvrKS2wSpAUJKmb51oEAAAAAABASeJuYBUraY21dl32A9baw5J6KC2wes4DvQEAAAAAAKAEcjewqqy0pYAXpSgtoJIkWWv/lLRWUufCtwYAAAAAAICSyN3A6qSybrJ+Qmkbr2f2h6TQwjQFAAAAAACAksvdwOqgpOqZfv9G0h3GmNKSZIzxkdRW0mHPtAcAAAAAAICSxt3Aar2klsaYUum/z5EUJunfxpiJkj6XdL2kxZ5rEQAAAAAAACWJn5v1byltGWCIpKPW2vnGmAaShkiKTq9ZJOlFz7UIAAAAAACAksStwMpa+72kl7ONDTPGjJdUU9IBa+3PHuwPAAAAAAAAJYy7T1i5ZK39VdKvnpgLAAAAAAAAJZu7e1gBAAAAAAAAReqSgZUxZqoxpnJBJzfGdDXG9Cro+QAAAAAAACh58nrCKk7SfmPMDGPMrfmZ0BhT3hjzkDFmm6RlkioWtkkAAAAAAACUHHntYVVL0guSBkoaaIz5SdLnkrZIOqq0NwYGKi2UqiepkaSGkgIk7ZLU0Vq7umhaBwAAAAAAwJXokoGVtfaEpEeNMS9LelhSf0m90j82W7mRlCJpvaTXJH1krU31dMMAAAAAAAC4suXrLYHW2p8kjZY02hhzvaTbJYUr7cmqJEm/SNohabO19mQR9QoAAAAAAIASIF+BVWbW2m8lfVsEvQAAAAAAAAB5broOAAAAAAAAFCsCKwAAAAAAADgKgRUAAAAAAPj/9u49TLOqvhP990dQukVDi3ih2nQw4pk4SWMy4nG8HEW8MInJaByiuRhRh+GYqBCd6OkYjW1OMkMmRoJ4C6gBJ/GKF7yM0xpRcsQ4jIQZSZ6YiApoN8ErRLERkHX+eHdLUVR11Vtd+61d7/v5PM/77Kq917vXeqnVuzbfWmttGBSBFQAAAACDIrACAAAAYFAEVgAAAAAMyrKBVVU9qqq2TaIxAAAAALCSEVYfT/LMntsBAAAAAElWFlhV760AAAAAgI41rAAAAAAYFIEVAAAAAIOy0sCq9doKAAAAAOisNLDaWVXfH+N1S6+tBgAAAGBqrTSwqjFfK55qWFV3raqdVfWBqrqmqlpVnbtE2YOr6mVV9aWqurGqPldVz6uqOywMX1WHVtWrqmpPV/ayqvqllbYLAAAAgPWx4hFWrbWDxnmN0YYjkrw8yYOTfGaZsq9P8ntJPprkeUk+m+SsJC9bpOx7kjw/yV90228keVtVPWOMtgEAAAAwYQevdwOSXJPkvq213VV1cJKbFytUVQ9KcnKSM1prL+x2v7Gq3pXkJVV1Tmvtmq7sk5I8IclprbVXd/velORTSf6oqt7RWvtevx8LAAAAgNVY96cEtta+11rbvYKiT+u2Zy7Yf2aSQ5I8eUHZvUnOmVfPrUlek+ReSY5fdYMBAAAA6NW6B1ZjODbJta21qxbsvyTJrRlNKZxf9rOttb0Lyn662z44AAAAAAzSRgqs5pLcYSRWa+2mjNan2rpc2SR7uu3WRY6lqk6pqs9U1We+9rWvHWBzAQAAAFiNlaxhdb8k1/XdkBXYnOSflzh2Y3d8ftnF1qi6cd7xO2itnZ3k7CQ59thj2+qaCQAAAMCBWMkIq5OSPGj+jqq6V1Uds1jhqnpSVb15LRq3wN6M1qpazKbu+HJlN807DgAAAMAArSSw2pnkuAX7fj3JZUuU/6mMQq61tiejqX63U1V3TnKP3Dbdb8my8/btWeQYAAAAAAOwkdawujTJfapq24L9D8noc1y6oOwxVbVpQdmHzjsOAAAAwABtpMDqnd321AX7T01yU5L3zdv3jiR3SXLyvh1VdVCS5yb5epIL+2smAAAAAAdiJYuu966qnpdkS24L0I6pqpd2X7+/tfbZ1tpl3dpYL6yquyW5JMkTkjw1yStaa/On+V2Q5GNJXtWNyPp8V+5hSZ7dWrsxAAAAAAzSIAKrJL+V5Efnff/T3StJvpLks93Xz0lydZJnJXlmkiuTnJbkrPkna621qnpykt9P8mtJ7p7kc0l+tbX21l4+AQAAAABrYhCBVWvtqBWWuznJK7rXcmW/k+Q3uxcAAAAAG8RKA6ujqupR879Pkqr6v5LUwrIH3iwAAAAAZtVKA6uTutd8leQTi5StJO0A2gQAAADADFtJYPVXEUABAAAAMCHLBlatteMm0A4AAAAASJIctN4NAAAAAID5BvGUQAAAVm/u0LlsP2/7ROrZdeKu3usBANhvYFVVz1jtiVtrb1ntewEAWLlJhUiTCMUAAJLlR1idm9svuL6SJwDuKyOwAgAAAGBsywVWz1pk31OS/HySi5J8Isk/JblPksckeVSS9yd579o1EQAAAIBZst/AqrV23vzvq+pnk/ybJE9qrX1gQfFXVNWTkrwzyRvWtJUAAAAAzIxxnxL4O0neu0hYlSRprV2Q5H1JXnagDQMAAABgNo0bWD0oyRXLlLkiyTGraw4AAAAAs27cwOqmjEKr/XlQkptX1xwAAAAAZt24gdXHkvxsVT2vqmr+gRp5fpKfSfKXa9VAAAAAAGbLck8JXGhHRk8DPDPJb1bVJ5Ncm+TeSR6Z5H5JvtmVAwAAAICxjRVYtda+UFX/OsnrkjwuyY8tKPLRJM9trX1xjdoHAAAAwIwZd4RVWmtXJHlCVW1N8tNJDktyfZLLWmu717h9AAAAAMyYZQOrqnpykl2ttb3z93fhlIAKAAAAgDW1kkXX35Pka1X17qp6elVt6btRAAAAAMyulQRWT0vy/iSPTfKWJNdW1Ueq6jlVdWSvrQMAAABg5iwbWLXW3tVa+5Uk90zyxCTnJdme0cLrX66qT1XVb1XV0f02FQAAAIBZsJIRVkmS1trNrbUPt9ZOSTKX5FFJXp3k3kn+S5J/qKrLq2pnVf1UP80FAAAAYNqtOLCar418srX2wtba/TN6WuDvJ2lJfjfJpVX1par64zVsKwAAAAAzYFWB1UKttf/dWnt5a+2YJA9IsiPJNUlOW4vzAwAAADA71iSwmq+19oXW2h+11h6e5L5rfX4AAAAAptuaB1bztd02sn8AACAASURBVNb+qc/zAwAAADB9Dl6uQFX91SrO21prj17F+wAAAACYccsGVkkeuYrztlW8BwAAAABWFFjdb4XnOjbJf05ydJLvr7pFAAAAAMy0ZQOr1tpV+zteVT+S5D8l+eWM1sT6b0letCatAwAAAGDmrGSE1aKq6m5JfifJqUk2JbksyW+11j6+Rm0DAAAAYAaNHVhV1Q8l+fUkv5vkiCRfTvLS1tp/XeO2AQAwY044/4TsuWFPr3XMHTqXXSfu6rUOAODAjBVYVdUvJDk9o3Wqvp3kJUnOaK19r4e2AQAwY/bcsCeXn3R5r3VsP297r+cHAA7cigKrqnpoklcmeXhGC6q/LskrWmtf77FtAAAAAMygZQOrqnp7kl/svr0gyYtba1f02ioAAAAAZtZKRlg9NUlLckWS7yT53apa7j2ttXbSAbYNAAAAgBm00jWsKskDutdKtCQCKwAAAADGtpLA6jG9twIAAAAAOssGVq21iybREAAAAABIkoPWuwEAAAAAMJ/ACgAAAIBB2e+UwKr64irP21pr91/lewEAAACYYcutYXVQRk/8m+/OSY7svr4lyTeS3GPeua5JctNaNRAAAACA2bLfKYGttaNaa/fb90ryoCS7k3w6o6cHbmqtHZlkU5Ljk/yPJF9Jcky/zQYAAABgWo27htUfJNmS5LjW2kWttVuTpLV2a2vtExmFWId35QAAAABgbOMGVr+Q5ILW2qJT/lprNya5IMlTDrRhAAAAAMymcQOreyS50zJl7tSVAwAAAICxjRtYfSHJiVV12GIHq+ruSU5MstqnCwIAAAAw48YNrN6QZC7JJVX1jKo6qqo2d9uTMlp0/T5JXrvWDQUAAABgNhw8TuHW2muq6gFJnp/kzxYpUknOaq29bi0aBwAAAMDsGSuwSpLW2mlV9fYkz07y00kOS3J9kr9Jcm5r7VNr20QAAAAAZsnYgVWStNb+Oslfr3FbAAAAAGB1gdV6qapzk5y0nyIvba39QVUdleRLS5R5U2vt5DVuGozlhPNPyJ4b9vRez9yhc73XAQAAAGttQwVWSf40yV8usv+0JMcm+fCC/RckOX/Bvit6aBeMZc8Ne3L5SZevdzMAAABgkDZUYLXYVMSqukuS1yW5vLX2Nwve8rettT+fVPsAAAAAOHAHrXcD1sAvJLlbkvMWO1hVm6tq82SbBAAAAMBqTUNgdVKSW5IsNpLqtCTfTfLdqvp8VT13oi0DAAAAYGwbakrgQlW1Ncljk3y4tXbtvEO3JvlYkvcluSrJXJKTk7ymqo5qrb1o4o0FAAAAYEU2dGCV5NcyGiV27vydrbWrkzxu/r6qemOSC5O8sKre0Fr7wsKTVdUpSU5Jkm3btvXUZAAAAAD2Z6NPCXxGkm8l+cByBVtr30/yyow+82OXKHN2a+3Y1tqx97znPde0oQAAAACszIYNrKrqIUkemORtrbXvrfBtV3XbI/ppFQAAAAAHasMGVhkttp4s8XTAJRzdbb+6xm0BAAAAYI1syMCqqu6c5JeS/H1r7ZJFjh++yL5NSV6S0RMFP9J7IwEAAABYlY266PrPJblHkj9a4vgfV9W2JBcn+XKSe2e03tUDkry0W5QdAAAAgAHaqIHVSUluTfJflzj+kYye9ndKksOTfDfJZUl2tNbeM5EWAgAAALAqGzKwaq09aZnjb0vytgk1BwAAAIA1tCHXsAIAAABgegmsAAAAABgUgRUAAAAAgyKwAgAAAGBQBFYAAAAADIrACgAAAIBBEVgBAAAAMCgCKwAAAAAGRWAFAAAAwKAIrAAAAAAYFIEVAAAAAIMisAIAAABgUARWAAAAAAyKwAoAAACAQRFYAQAAADAoAisAAAAABkVgBQAAAMCgCKwAAAAAGBSBFQAAAACDIrACAAAAYFAEVgAAAAAMisAKAAAAgEERWAEAAAAwKAIrAAAAAAZFYAUAAADAoAisAAAAABgUgRUAAAAAgyKwAgAAAGBQBFYAAAAADIrACgAAAIBBEVgBAAAAMCgCKwAAAAAGRWAFAAAAwKAIrAAAAAAYlIPXuwEAAGwMc4fOZft523uvAwBAYAUAwIrsOnHXejcBAJgRpgQCAAAAMCgCKwAAAAAGRWAFAAAAwKAIrAAAAAAYFIEVAAAAAIMisAIAAABgUARWAAAAAAyKwAoAAACAQRFYAQAAADAoAisAAAAABkVgBQAAAMCgCKwAAAAAGBSBFQAAAACDIrACAAAAYFAEVgAAAAAMisAKAAAAgEERWAEAAAAwKBsqsKqqo6qqLfF644KyB1fVy6rqS1V1Y1V9rqqeV1W1Xu0HAAAAYHkHr3cDVumCJOcv2HfFgu9fn+TkJOckuSTJE5KcleTwJL/XdwMBAAAAWJ2NGlj9bWvtz5c6WFUPyiisOqO19sJu9xur6l1JXlJV57TWrplEQwEAAAAYz4aaEjhfVW2uqs1LHH5atz1zwf4zkxyS5Mm9NQwAAACAA7JRA6vTknw3yXer6vNV9dwFx49Ncm1r7aoF+y9JcmuSB0+gjQAAAACswkabEnhrko8leV+Sq5LMZTT17zVVdVRr7UVdubkkuxe+ubV2U1V9I8nWxU5eVackOSVJtm3btvatBwAAAGBZGyqwaq1dneRx8/d1Twe8MMkLq+oNrbUvJNmc5J+XOM2N3fHFzn92krOT5Nhjj21r1W4AAAAAVm6jTgn8gdba95O8MqPP8thu996M1qpazKbuOAAAAAADtOEDq86+taqO6LZ7MpoWeDtVdeck9+iOAwAAADBA0xJYHd1tv9ptL01yn6pauBDVQzL6zJdOqmEAAAAAjGdDBVZVdfgi+zYleUmSW5J8pNv9zm576oLipya5KaNF2wEAAAAYoA216HqSP+5GTV2c5MtJ7p3kGUkekOSl3aLsaa1dVlVvzmgh9rsluSTJE5I8NckrWmumBAIAAAAM1EYLrD6S5JTudXiS7ya5LMmO1tp7FpR9TpKrkzwryTOTXJnktCRnTaitAAAAAKzChgqsWmtvS/K2FZa9OckruhcAsIE84vQLs/u6fh/qu3XL5ly84/he62CY5g6dy/bztk+knl0n7uq9HgCYRhsqsAIAZsPu6/bmytOf2GsdR+34UK/nZ7gmFSJNIhQDgGm1oRZdBwAAAGD6GWEFwMwz/QyGw79HACARWAGA6WcwIP49AgCJKYEAAAAADIzACgAAAIBBEVgBAAAAMCjWsAIAgA3qhPNPyJ4b9vRax9yhc9l14q5e6wCAhQRWAACwQe25YU8uP+nyXuvYft72Xs8PAIsxJRAAAACAQRFYAQAAADAoAisAAAAABsUaVrDApBYvBWbL1i2bc9SOD/Vex8U7ju+1DobpEadfmN3X7e29Hn0MAJgUgRUsMInFS4HZM4n/ye87EGO4dl+3N1ee/sTe69HHAIBJMSUQAAAAgEExwgoAoEeTmK63dcvmXs8PADBpAisAgB5NaroeAMA0MSUQAAAAgEExwgoAGIspbgAA9E1gBQCMxRQ3AAD6JrACgCmxdcvmHLXjQxOpBwAA+iSwAoApcfGO49e7CQAAsCYsug4AAADAoBhhBQDMJFMoYWXmDp3L9vO2T6SeXSfu6r0eADYGgRUAMJNMoYSVmVSINIlQDICNw5RAAAAAAAZFYAUAAADAoAisAAAAABgUa1gBAEAPJrFY+dyhc72eHwDWi8AKAAB64Il3ALB6pgQCAAAAMCgCKwAAAAAGRWAFAAAAwKAIrAAAAAAYFIEVAAAAAIMisAIAAABgUARWAAAAAAyKwAoAAACAQRFYAQAAADAoAisAAAAABkVgBQAAAMCgCKwAAAAAGBSBFQAAAACDIrACAAAAYFAOXu8GAMBSHnH6hdl93d7e69m6ZXPvdQAAACsnsAJgsHZftzdXnv7E9W4GAAAwYaYEAgAAADAoAisAAAAABkVgBQAAAMCgWMMKYIImuYj4xTuO770eAACAPgisACZoUouIH7XjQ73XAQAA0BdTAgEAAAAYlA0zwqqqHpzk15Icn+R+SW5I8ndJ/nNr7S/nlTsqyZeWOM2bWmsn99tSAACGbOuWzRMZiWp6NgCs3oYJrJK8KMljk7w7yWuS3DXJs5J8tKp+o7X2+gXlL0hy/oJ9V/TeSgAABm1SIZLp2QCwehspsHp1kme21m7ct6OqXp/kfyX5g6o6p7V2y7zyf9ta+/NJNxIAAACAA7Nh1rBqrX1qfljV7dub5INJ7p7kPgvfU1Wbq2rzhJoIAAAAwBrYMIHVfswluSXJtxbsPy3Jd5N8t6o+X1XPnXjLAAAAABjbRpoSeAdV9S+TPCXJ+1trN3S7b03ysSTvS3JVRoHWyUleU1VHtdZetJ/znZLklCTZtm1bn00HAGbFGduT66/ut47DtiUvuLzfOjKZxcq3bjE4HgDYwIFVVf1wkndlNIrqBfv2t9auTvK4BWXfmOTCJC+sqje01r6w2Dlba2cnOTtJjj322NZT0wGAWXL91cnO6/utY+dh/Z6/44l3AMCkbMgpgd26VB9I8mNJntyFVEtqrX0/ySsz+ryP7b+FAAAAAKzWhhthVVV3TvLeJA9L8pTW2kUrfOtV3faIXhoGALBeDts2mVFWE5p6yGyaO3Qu28/b3nsdu07c1WsdAKyNDRVYVdXBSd6Z5PFJfrW19sEx3n50t/3qmjcMAGA9TSpEmtDUQ2bTJIKkvgMxANbOhpkSWFUHJXlLkicleU5r7e1LlDt8kX2bkrwko6cJfqTPdgIAAABwYDbSCKtXJvnlJBcl2VtVT19w/KOttWuT/HFVbUtycZIvJ7l3kmckeUCSly633hUAAAAA62sjBVb/qts+unst9Jgk12Y0guqU7nV4Rk8RvCzJjtbaeybQTgAAAAAOwIYJrFprx62w3NuSvK3f1gDwiNMvzO7r9vZax9Ytm3s9PwAAMEwbJrACYFh2X7c3V57+xPVuBgAAMIU2zKLrAAAAAMwGgRUAAAAAgyKwAgAAAGBQBFYAAAAADIpF1wEAmC1nbE+uv7r3aj55yBFJNv7DKSbxVNhk9GTYi3cc33s9AGwMAisAAGbL9VcnO6/vvZr77jys9zomYVJPhT1qx4d6rwOAjUNgBQDAcExi9NNh2/o9PwBwwARWAAAMx4RGPwEAw2bRdQAAAAAGxQgrgCm0dcvm3tcC2bplc6/nB2B51+w8Okfma73W8deb7plpWDx+Uk44/4TsuWHPejdjTcwdOpddJ+5a72YAM0pgBTCFPGUJYDYcma/1PoXyyClZPH5S9tywJ5efdPl6N2NNbD9v+3o3AZhhpgQCAAAAMChGWAF0HnH6hdl93d5e6zCNDmC29D09+8pNvZ5+6swdOtf7qKG5Q+d6PT/ArBBYAXR2X7c3V55ujQ4A1k7vv1d29nv6aWM9JoCNQ2AFAADAupnEQvUWkIeNR2AFAADAupnEQvUWkIeNx6LrAAAAAAyKEVYAwPCcsT25/up+6zhsW/KC6Xj0PDB7JvGwmLs9sNfT307fDyiY5GcB1obACgAYnuuvTnZe328dOw/r9/wAPZrEw2K2n7ej1/PPN02fBVgbpgQCAAAAMChGWAEA45nUdD0AAGaWwAoAGM8kpusBADDTBFYAYIFvAAAYFIEVAFjgGwAABsWi6wAAAAAMihFWwOA94vQLs/u6vb3Xs3XL5t7rYIYdtq3/UVamHdK3SfVjhmUSP/cknzzkiCRP7L0eADYGgRUweLuv25srT3cDywY3iSDJtEP6JhCdTRP6ud/XNQyAeUwJBAAAAGBQjLBiQznh/BOy54Y9vdYxd+hcr+cH6M2Epu2YsgUrZArl2I7a8aFez791y+ZcvOP4XuuYNn3/TJLkbg9M//9W7jdd/1ZgFgis2FD23LAnl59kOgLAokzXgmHxb3JsfS8BMInwZdpMYlmG7eft6P9pvedt7/f8wJoTWMEUm8Ri5f5SCQAAwFoTWMEUm8Ri5f5SCQAAwFqz6DoAAAAAg2KEFXBAtm7ZPJEFUgEANoJJLMmQJH+96bRk56/0W4mFyoF1JLACDoj1qwAAbjOJJRmSjMIqC5UDU8yUQAAAAAAGxQgrgGl0xvbk+qv7reOwbR7ZDgBTbO7mW7J9AqOs5m6+pfc6gI1HYAUwja6/uv9pAjsP6/f8AMC62vWVPf3fTyTuKYBFCawAWJ3DtvV/g2kUF32aRB/eVw8wCB4WMybXSWAdCawAWJ1JBEn+4kqfhKEwczwsZkyuk8A6sug6AAAAAINihBUAw2UqAgBryUNJADYMgRUAw+WGH4C15KEkABuGKYEAAAAADIoRVgAAwPqb1NNn+2Y6+yDN3XxLtp+3vd86Dp3LrhN39VrHNDnh/BOy54Y9vdfj57JxCawAAID1Ny3TwKflc0yZXV/Z0/t00L4DsWmz54Y9ufyk/v+9+LlsXAIrgEmaxGKvib+6AgAAG5rACmCSJrHYKwAAwAZn0XUAAAAABsUIK9bEJBfMAwAAGNdROz7U6/nv9sBeTz9Rx7zp0WkHf7PXOm69aUvvP5Nkun4us0ZgxZqY1IJ5AAAAq3Hl6U/s9fzbz9vR6/knqR38zan5/7tp+rnMmqkNrKrq4CS/neTZSY5McmWS1yR5bWutrWPTYGILb3/ykCOS9PuLeapM4udiMXQAgKk1iRFDRx/94lx7p35X97nXzbf2ev5p84jTL8zu6/b2WsfWLZtz8Y7je61jaKY2sEry+iQnJzknySVJnpDkrCSHJ/m9dWwXTGzh7fvuPKz3OqaKBdEBADgAfY/iSkYjhnof/eT/I8ay+7q9vf/sJxGGDs1ULrpeVQ/KKKw6o7V2Smvtja21pyY5P8lLqurI9W0hAAAAAEuZ1hFWT+u2Zy7Yf2aSE5M8OaMRWLBuJpGQX7mp9yomNr1xIkzXAwCYTodt633U0Nx957L9vO291pFMZrreV9oR/c/WOGxb8oLpWCfr/ke/uPe1su5/9K2ZteVepjWwOjbJta21qxbsvyTJrUkePPkmwe1NYrhwdvZfhWl0AAAM3gSCkV291zAyiT98P/J7r+7//1emaNrhV+90UO/TNCcRhg7NVE4JTDKXZPfCna21m5J8I8nWibcIAAAAgBWpaXxgXlV9IaMRVg9f5NjVSb7YWjtukWOnJDml+/ZfJPmHPts5QUck+fp6N4INTR/iQOlDHCh9iAOlD3Gg9CEOlD7EgZim/vOjrbV7LldoWqcE7k1yyBLHNnXH76C1dnaSs/tq1Hqpqs+01o5d73awcelDHCh9iAOlD3Gg9CEOlD7EgdKHOBCz2H+mdUrgnoymBd5OVd05yT264wAAAAAM0LQGVpcmuU9VLXzk10My+syXTr5JAAAAAKzEtAZW7+y2py7Yf2qSm5K8b7LNWXdTN82RidOHOFD6EAdKH+JA6UMcKH2IA6UPcSBmrv9M5aLrSVJVb0ryrCTnJLkkyROSPDXJK1prO9exaQAAAADsxzQHVndK8pKMQqsjk1yZ5LVJzmrT+qEBAAAApsDUBlYAAAAAbEzTuobVzKuqg6vqZVX1paq6sao+V1XPq6pa77YxHFX14Kr6k6r6bFV9u6r+qao+VlWPW6SsPsWKVNXxVdW619ELjh1aVa+qqj1dP7qsqn5pvdrKcFTVXFWdXVVfqarvddt3V9UPzyvjOsSiqmpbVb2p6xt7q+qLVfWnVfUjC8q5Bs24qrprVe2sqg9U1TXd76pzlyi74muOvjU7VtqHxrnP7sr7HTcjxrkOLXjfkvfY3fGpuw4dvN4NoDevT3Jybr+G11lJDk/ye+vYLoblRUkem+TdSV6T5K4ZTaP9aFX9Rmvt9fPK6lMsq6runNH06xuSHLpIkfckOT7JnyT5xyRPS/K2qrpza+0tE2sog1JVP57koiTfTvKnSXYnuVeSRya5S5J/7oq6DnEHVXWPJP8jySFJXpfRMhA/meT/TvLEqvqJ1tr1XXHXII5I8vIk1yT5TJKf20/Zca45+tbsWGkfGuc+O/E7bpaMcx1KsqJ77GQar0OtNa8peyV5UJKW5FUL9r8ryY1JjlzvNnoN45Xk4Uk2Ldi3Ock/JPlmkoO7ffqU14peSX47ybVJzuj6zNHzjj2p23fqvH0HJfl0955D1rv9XuvSZyqjm7VLk9x1P+Vch7yW6hu/0fWNf7tg/2nd/l/svncN8kpGwebW7uuDuz5x7iLlVnzN0bdm6zVGH1rRfXa33++4GXqttA8teM+S99jd8am8DpkSOJ2e1m3PXLD/zIz+cTx5ss1hqFprn2qt3bhg394kH0xy9yT36XbrUyyrqn40yUuT7Ehy/SJFnpZkb0Z/OUyStNZuzeivjvfK6C9CzJ7jkzw4yctba9+pqs01enDKQq5DLGXftNE9C/bv+/6GbusaRFpr32ut7V5B0XGuOfrWDFlpHxrjPjvxO26mjHEdSrKie+xkSq9DAqvpdGySa1trVy3Yf0mSWzP6HwPYn7kktyT5Vve9PsVKvDrJZ5Ocu8TxY5N8trtZm+/T3VY/mk0ndNsbqurTSb6b5MaqurCqfmJeOdchlnJhtz2rqh5eVVur6vFJ/iCj68tHuuOuQYxjnGuOvsU4Ft5nJ37HsX/L3WMnU3odElhNp7mM1v+4ndbaTUm+kWTrxFvEhlFV/zLJU5K8v7W276/S+hT7VVU/l9H8++e1bgzyIhbtR7ltFIR+NJv+j277ziRfSfKLSV6Y5Jgkf1VV+/qF6xCLaq1dkuS5SX48ycUZ9aOPZDTt5vGttVu6oq5BjGOca46+xYoscZ+d+B3HElZ4j51M6XXIouvTaXNuW6B2oRu743AH3dO43pXRCIcXzDukT7Gkqtqc0V9+3thau3Q/RTcn+d4i+2+cd5zZc9due1lr7cR9O6vqM0k+meQ/ZhRguQ6xP3ty22iqL2QUeL4oyQeq6me7vzi7BjGOca45+hbL2s99duJ3HIsY4x47mdLrkMBqOu3NaK7zYjZ1x+F2ugviB5L8WJJ/01q7et5hfYr9+Z0kW7rt/izVjzbNO87s2fdz/4v5O1trF1fVlUkePa+c6xB3UFVPSfKOJD/VWvu7bvf7q+pvknwoyXMyWqTWNYhxjHPN0bfYr2XusxO/41jcSu+xkym9DpkSOJ32ZDQk8Ha6R2HeI3dclJQZ1/WN9yZ5WEZPU7poQRF9ikVV1VyS30pydpItVXV0VR2d0SOYk2RbVd2v+3rRfjRvn340m/b93P9pkWPXZrQw7b5yrkMs5rQkn58XVu3z4YxGMjyq+941iHGMc83Rt1jSCu6zE7/jWGDMe+xkSq9DAqvpdGmS+1TVtgX7H5LRz3y54YTMkKo6OKO1Yx6f5BmttQ8uUkyfYin3yuivOf9Pks/Pez2/O/6xJJd1X1+a5Jiq2rTgHA+dd5zZ8z+77X0XOXbfJF/rvnYdYin3SfJDi+yvjPrGvqdOugYxjnGuOfoWi1rhfXbidxx3NM49djKl1yGB1XR6Z7c9dcH+U5PclOR9k20OQ1VVByV5S5InJXlOa+3tSxTVp1jKlzJaJHvh613d8ecneUb39TuS3CXJyfve3PXB5yb5em570hez5YKMhqn/+6r6QehQVT+b0QKhu7pdrkMs5XNJHlBVD12w/6kZTYX4TPe9axDjGOeao29xB2PcZyd+x3FH49xjJ1N6HbKG1RRqrV1WVW9O8sKqultGj0N9QkY3bq9orW3I4YD04pVJfjnJRUn2VtXTFxz/aGvtWn2KpbTWrk9y/sL9VfWT3Zf/vbV2Rff1BRn9NehV3V8QP59RH3pYkme31m5ceB6mX2vta1X1soyuRxdW1bsyGr5+WkY3a2d05VyHWMofJvmZJB+tqtcl+WJGi66fkuSaJK/ryrkGkSSpqudltC7Mvj/eH1NVL+2+fn9r7bNjXnP0rRmzkj6UFd5nJ37HzaIV9qGV3mMnU3odqv0/GZGNqqrulOQlSZ6V5MgkVyZ5bZKzlnkcJjOkqj6R2xY0XsxjWmuf6MrqU6xYVe1M8vIkD5j/y7Sq7prk95M8LaO1iT6X5L+01t66Hu1kOKrqmRk9NelfJPl2Rotl/3Zr7Zp5ZVyHWFRVHZPkdzOaPnNkRo+B/0iSl81f3Ng1iCTpHujwo0scflZr7dyu3IqvOfrWbFlJHxrnPrs7p99xM2Sl16FF3rczi9xjd8em7joksAIAAABgUKxhBQAAAMCgCKwAAAAAGBSBFQAAAACDIrACAAAAYFAEVgAAAAAMisAKAAAAgEERWAEAAAAwKAIrAAAAAAZFYAUAMGBV9ZiqalX1i+vdlnFV1X+sqpur6sfXuy0AwMYisAIAWEIXFC33Oq6qnrnCsj94rbD+g5KckeR/Jzl/iTKHV9WOqvpEVX21qm6qqm9X1d9V1Z9V1c9XVR3Af4P/1LX5D1dQ9pyu7G92u16X5KtJXrna+gGA2VStreh+CQBg5swLll6xn2LnJtmS5MkL9h+V5KQkV3Vlbqe1tnMF9f9Kkr9I8quttbcucvzfJjmvq//KJBcluSbJnZPcP8mju2Pnt9ZWNUKrqu6X5AtJvpbkvq21m5cod+i8ure21r7R7X9xkj9M8ojW2qdW0wYAYPYIrAAAlrAvsGqtjT1CqaqOS/LxJBe11o5bZf0XJ/nJJPdpre1dcOz4JLuS3JLk+Une3Fq7dUGZTUmenuQJrbWnrqYN3Xk+kuTxSf5da+09S5T590nemOStrbVfnbd/LsnVSd7eWnv6atsAAMwWUwIBAAaoW/fp4Unev0hY9UNJ3pDk4CSnttbeuDCsSpLW2o2ttTcm+ZUl6vjlqvp4VX2rqm6sqr+vqpdW1SELip7dbf/Dfpq879jZ83e21vYk+f+SnFhVP7yf9wMA/IDACgBgmB7XbT+5yLHjkjwgyZeTvHm5E7XWblm4r6relOStSY5O8p4kr03yzST/b5L/XlUHzyt+QUZrUT2hqrYtcq6fTPLQJP/YDASnJQAAA9tJREFUWrtokSZcnOSQJI9arq0AAMnor3IAAOxHVe1c4tCNrbXTe6r2kd32M4sce0S3vai19v1xT1xVz0zy7CTvzWh9rL3zju1M8vIkz01yZpK01m6uqnOTvLh7384Fp9w3uuqcJar8n932UUk+OG57AYDZYw0rAIAlrOBpfte31rYs8d7jcgBrWFXVp5I8LKMFzPcsOPa6JL+e5A9bazsWee/ORU75J62167rjl2W0NtY99+2b994fSnJtki+21v7PefuPTvKPGY3qut++KYjd9ME9Se6a0aLsX1ukPQ9N8ukk72it/dLK/gsAALPMCCsAgGWsZtH1NXCPbvutRY7ta89SgdrLF9l3bpLrquouSR6U5OtJfrNq0Y/2vSQPnL+jtXZFVX0iyWOSnJDkw92hf5fk8IzCqDuEVZ1vdtsjljgOAHA7AisAgGHaN01v07yv97mm225d7I3zA7aq+mRum0KYJHfPKPC6ZxYPtvbn7IwCq5NzW2B1crddajpgkmzutgs/BwDAoiy6DgAwTF/ttvdY5NjF3fa4qhr3fu76bntZa63291rkve/JaGTWz1fVvavq/hktAP+FJBfup859n+Gr+ykDAPADAisAgGH6bLf98UWOfSLJFUl+JMmzxjlpa+07Sf4uyU9U1eFjvvemJOcluVOSkzIaXVVJzmn7Xxh132f4X+PUBwDMLoEVAMAwfaLb/uuFB7onAz4nyS1JzqqqZy020qqq7pTkLouc+1VJ7pzkzVV1h0Xjq+ruVfWvlmjXvql//yHJM5PcnNH6WPuz7zN8fJlyAABJPCUQAGBJ854S+Ir9FHtfa+0OI4fW4CmBd0myO8kVrbWHLFHmSRmNeDosyZVJLsroiX2bkswleVxG0/E+m+TR858IWFWvTfIbGS2IvivJ1Rktnn6/JI9K8mettecsUe9FXZkkeXdr7cT9fI6DunN/p7W22GgxAIA7sOg6AMDy9rc4+ZXpYapba+27VXVuRk/ye2Br7e8XKXNBt47UKUl+JskTk2xJcmOSryT5UJJ3JflvrbVbF7z3uVX14YxGaj2ue983MwqX/ijJn++neWfntsDq7GU+yuMyWhz+BcuUAwD4ASOsAAAGqqqOSvK5JH/aWjttfVuzOlX17iSPTnL/1tr1y5UHAEisYQUAMFittSuTvDrJKVW1dZ2bM7aq+qkkv5Bkp7AKABiHKYEAAMP2+0luSHJURmtabSRHJnlZkjesd0MAgI3FlEAAAAAABsWUQAAAAAAGRWAFAAAAwKAIrAAAAAAYFIEVAAAAAIMisAIAAABgUARWAAAAAAzK/w/9TVvStG3MZQAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 1440x720 with 1 Axes>"
       ]
@@ -890,9 +801,9 @@
    ],
    "source": [
     "\n",
-    "a_MC=plt.hist(total_MC/1000,bins=40,  histtype='step',  label='MC Triggered events',)#  range=(0,160))\n",
-    "a_NN=plt.hist(total_NN/1000,bins=40,  histtype='step',   label='NN Triggered events',)#  range=(0,160))\n",
-    "b=plt.hist(test_true_hist/1000,bins=40,histtype='step',  label='ET from Tracking',)# range=(0,160))\n",
+    "a_MC=plt.hist(total_MC/1000,    range=(0,140), bins=40,  histtype='step',  label='MC Triggered events',)#  range=(0,160))\n",
+    "a_NN=plt.hist(total_NN/1000,    range=(0,140), bins=40,  histtype='step',   label='NN Triggered events',)#  range=(0,160))\n",
+    "b=plt.hist(test_true_hist/1000, range=(0,140), bins=40,histtype='step',  label='ET from Tracking',)# range=(0,160))\n",
     "plt.tick_params(labelsize='xx-large')\n",
     "plt.xlabel('ET (GeV)', fontsize=20)\n",
     "plt.ylabel('dN/dET (a.u.)', fontsize=20)\n",
@@ -904,7 +815,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 293,
+   "execution_count": 215,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -932,22 +843,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 298,
+   "execution_count": 216,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([1.380e+02, 4.840e+02, 1.030e+03, 1.918e+03, 2.517e+03, 2.729e+03,\n",
-       "       2.916e+03, 2.822e+03, 2.972e+03, 2.889e+03, 2.822e+03, 2.693e+03,\n",
-       "       2.392e+03, 2.185e+03, 1.957e+03, 1.849e+03, 1.639e+03, 1.463e+03,\n",
-       "       1.203e+03, 1.146e+03, 9.150e+02, 8.120e+02, 7.300e+02, 5.780e+02,\n",
-       "       4.780e+02, 3.630e+02, 2.780e+02, 2.030e+02, 1.490e+02, 9.500e+01,\n",
-       "       6.700e+01, 3.900e+01, 2.000e+01, 8.000e+00, 6.000e+00, 1.000e+00,\n",
-       "       0.000e+00, 0.000e+00, 0.000e+00, 2.000e+00])"
+       "array([  0.,   1.,  19.,  32.,  60., 104., 137., 142., 170., 205., 216.,\n",
+       "       200., 183., 197., 147., 166., 166., 130., 107., 113.,  90.,  72.,\n",
+       "        71.,  47.,  42.,  37.,  32.,  31.,  18.,   7.,  11.,  11.,   6.,\n",
+       "         6.,   3.,   4.,   4.,   6.,   0.,   4.])"
       ]
      },
-     "execution_count": 298,
+     "execution_count": 216,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -958,7 +866,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 299,
+   "execution_count": 217,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -972,12 +880,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 302,
+   "execution_count": 304,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1080x720 with 1 Axes>"
       ]
@@ -987,10 +895,10 @@
     }
    ],
    "source": [
-    "idx = np.arange(0,15, step=15/40)\n",
+    "idx = np.arange(0,140, step=140/40)\n",
     "#plt.subplot(1,2,2)\n",
-    "plt.bar(idx,eff_NN, width=.2, label='Efficiency simulated by NN')\n",
-    "plt.bar(idx,eff_MC, width=.2,alpha=0.5, label='Efficiency simulated by MC')\n",
+    "plt.plot(idx,eff_NN, label='Efficiency simulated by NN')\n",
+    "plt.plot(idx,eff_MC, label='Efficiency simulated by MC')\n",
     "plt.legend(fontsize='xx-large')\n",
     "plt.tick_params(labelsize='xx-large')\n",
     "plt.xlabel('ET (GeV)', fontsize=20)\n",
@@ -1011,14 +919,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 303,
+   "execution_count": 219,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1031,7 +932,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 304,
+   "execution_count": 220,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1041,12 +942,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 308,
+   "execution_count": 221,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 576x432 with 1 Axes>"
       ]
@@ -1062,8 +963,8 @@
     "four_cells_diff_MC= np.array([\n",
     "       four_cells(test_reco[i]).sum() - test_true[i].sum() for i in range(len(test_reco))\n",
     "])\n",
-    "plt.hist(four_cells_diff_NN/1000, bins=30,  label = 'NN max 4 cells ET - E tracking',histtype='step')\n",
-    "plt.hist(four_cells_diff_MC/1000, bins=30,  label = 'MC max 4 cells ET - E tracking', histtype='step')\n",
+    "plt.hist(four_cells_diff_NN/1000, bins=30,range=(-200,0),  label = 'NN max 4 cells ET - E tracking',histtype='step')\n",
+    "plt.hist(four_cells_diff_MC/1000, bins=30,range=(-200,0),  label = 'MC max 4 cells ET - E tracking', histtype='step')\n",
     "plt.legend(loc=2);\n",
     "plt.xlabel('Sum of 4 max cells ET  - ET true (GeV)')\n",
     "plt.ylabel('dN/dET')\n",
@@ -1074,19 +975,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 309,
+   "execution_count": 222,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "four cells diff mean 110.7673110961914, std 1938.0076904296875\n"
+      "four cells diff mean -746.0126953125, std 1924.9454345703125\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeoAAAGECAYAAAD5k2MQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xu8HWV99/3PDwIkKhqBQDEBgzUK4gE1j9Jie1PwxEGgChZUTlLRKtYDqFHuR7FFGmgfRe+2KkolqOVQLEoNKpSDWG9BA2IMAiVgSjahEAIBLIly+D1/zLXCYmftvdbe2Ydr7/15v17rtdbMXDPrmjWz1nfmmlkzkZlIkqQ6bTbeFZAkSQMzqCVJqphBLUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcyg1lNExN4R0dfWvSIiXjuO9YmI+FpEPBARPx2vemhyaF+fI+KUiPjGONfnTyNiZUT8JiJePp51GUkRMSsibo2I6WP4nj+NiN3H6v3GkkE9DBExLyLWj/eXvFYl7J8oPz7tjz+IiJvauh8vn2Or+xMdJvca4HXAnMx81RjPCgARsWNEfCUiVpV63hER50TErmPw3udExKkDDBvV9bBsIGVEPH80pj9RlbBf12/d/vuI+ERb9/qyfre6bxpgcn8HnJCZz8jMn4/lfACU5fvLiNisrd+pEXFOeT23lFncb7xvRMQpg0x6AfC1zFzfNs7rIuKqiHg4ItZExI0R8bFuYR4R0yNibUTs02HY5yLiotL5d8BfdZvnicigHp5/AH423pWo3Kry49P++Elm7t7qBn7Ekz9Sz8jM0zpM57nAisz8n05vEhHTRnMmImJb4P8CTwP+CNgaeAXwQ5oNiPE0authRLwG+P3RmPYk8aZ+6/YJmXla27r9HuAnbcMH2tN7LtAxxEd73W7zHODwLmX2jIi9eplYRGwFHA18o63fYcBFwD8Dz83MbYE/A+YAOw02vRL2FwBH9XufzYEjgEWl1yXAn0TEjr3UcyIxqIcoIg4H1gJXdCl3SkT8S9nyfLhstb4gIj4eEfeW5q7Xt5U/NiJuLmXviIh3tw37WERc2/riRsRflD3Tbluir4mI/1u2RldGxDGl/1YR8XcRcWdE3BMRX4qIGT3M+6siYklEPFTG+2y3cTZFRBwHfBX4g7JX8umyt95XPpP/Br5Wyr4rIpZHxP0RcUlEPKdtOhkR742I28rn+9cR8fsR8ZMyLxdGxJYDVONDwEPAkZl5ezbWZubXMvP/tL3Hnm2f9S8iYu+2YYMt29b8nFjWi7sj4tgy7Hjg7cBHy/z/W9t4Pa2Hw1HWs/8DnNBD2Z4/24h4dkR8NyJWR3Mo47sRMacM26Z8Dm8q3c8oy/OoAd53m2j2+FeVaX27bdiB0eytrS3L5KU9zMf08l1dU8b7WUTs0NsnNnTlO/gbYHPgFxFxe+m/oqzbS4H/iYhpEbFbRFxd6nVTRBzUNp1zIuIfI+J7ZR35cUT8XkScWT6XW6J7k/oZwKdj8A2DM4COLTsdvBpYm5l9pY4BfBb4q8z8SmbeD5CZt2bm+zPztlJus4hYEBG3l+VwYURsU6a5CHhLRDyt7X3eQJNh3yvTWw9cD7yeySYzffT4AJ4J/CfNFuApwDcGKXsKsJ5mZZoGnAv8GjgZ2AJ4F/DrtvIH0OzBBPC/gEeAV5RhmwHXlGnOAx4AXt6lrjsDD9NscW4BbAvsUYadSbP1uQ3NHuK/AX9Thu0N9LVNZwXw2vL6JzSBBfAMYM8B3vsp0xikjlcDf96lzDHAf/Sb9mPA6cBWwAxgH+A+mj3drWhC5pq2cbLM7zOB3YHf0gTc84BnAb8Cjh7g/a8FTulSx9nAGmD/sqxeV7pn9bBsW/PzV2U57V+GP7sMPwc4dbjr4TDX848An2/77J4/SNmeP9uyDr6FpnVia+BfgG+3Tev1wH8D2wNfAS4a5H0X0+xlPbt8bv+r9H8FcC9NWGxOs2e3Atiqw/q84bMD3k3zPXhaGe+VwDMHeO8N0+h1ve3y+T2/37RvLMt2Rpm35cAngC1p1vWHgRe2rR/3lfpOB66k+Z05qszHqcBVXd5/Hk3A/XnpdypwTnk9t5R5BnBX22f3DQb4XgDvAxa3de9apjG3y2fxQZrv2xya7/GXgfPahv8n8I627vOAM/tN4wvAZ0fy+1DDwz3qoflr4OzMXNlj+R9l5g8y8zGaH6VZwMLMfBQ4H5gbETMBMnNxPrnH9kPgMpqmVjLzCZov3l/S/Ciekd2PZ70d+PfMPC8zH83MNZl5Y9m6fRfwocy8PzMfBk6je9MXwKPA8yNiu8z8TWZeO0jZ55Q9gPbH03t4j148AXwqM3+bmeto5vWfMvOGzPwt8HGavfC5beOcnpkPZeZNwDLgssy8IzMfpNkiH2ivYzua8AAgIg4q8/JwRFxWer8DuDQzL83MJzLzcmAJTegOumyLR2n2Nh7NzEuB3wAvHGT+h7oe9iwidqIJrU8OYbSePtuyDn4rMx8p691naDZcKMMvo/meXEGzcfPu/m9U6rgjsB/wnsx8oHxuPyyD3wV8OTOvy8zHM3MRzcbDnl3m4VGaDYnnl/Guz8yHBin/7X7r9ru6TH8ovpCZK8u6vSdNSC7MzN9l5pXAd2k2wFsuLvVdD1wMrM/MczPzcZqNmW571An8v8Ano2m27mQ9zfLqZa96Js3GRMt25bn9e3R++dweiYgjS+93AydnZl/5Hp8CHNq2p38upfk7Ip4JHMyTzd4tD5f3n1QM6h5FxB7Aa4HPDWG0e9perwPuK1+eVjc0X0IiYr9omrfvj4i1ND/yrRWczFwBXEWzhfsPPbz3TsDtHfrPotlruL71IwN8v/Tv5jjgBcAtpWnwwEHKrsrMmf0eHY8zD8PqbDtJheYY23+1OjLzNzR7tLPbyvRfFv27nzHAe60BNhzzysxLMnMmTZN4q7n8ucBh7T/cNCfB7Qjdly2wpmzMtTwyUH2GuR62xt052k6AGqDYmTQbDQ8OYdI9fbYR8bSI+HJE/FdEPETTSjQzmmONLWcBL6Y5EWnNAO+3E3B/Zj7QYdhzgRP7LYudaNaRwXwd+AFwfmlOPyMithik/CH91u2vdJn+ULRvgD0HWFk21lv+i5FZtzcoG4h3AscPUuwrwA6twxODeICmxaSltRzbv0eHl+/RDTR7/tAsu4vbltvNwONA6xDEuTTHoGcDhwLLO+ywbE1zSGhSMah7tzdNSN4ZzbHRk2iOmdywqRMuW7HfojlrcYeyAl9K01TaKrM/8Ac0ext/28NkV9L5ZKD7aL68u7f9yDwrmxNgBpWZt2XmETRNk6cDF43gXvJQ9L836yqaLzkApU7b0jTVbaorgEOi7azYDlYCX+/3w/30zFzYy7Ltov+87s0w18PMvDPbToAaoNi+wN9GxH+X6QP8JCLe1mN9B3MiTUvBqzPzmcAfl/4BG04O+jLND/JfxMBnm68Etmm1RnUY9pl+y+JpmXneYBUre+WfzswXAX8IHEi/k5fGUPsyXwXs1G/925mRWbf7+980h+ae1mlgaQn8NE2LzmDr71KaDfqWW2jq++Yu778S2K/fspuemXeV97+T5gTUtwNH0qwn/e0G/KLL+0w4BnXvzqIJvj3K40s0x8neMALT3pLmmMxq4LGI2I+2EyIiYjvgbODPaY65vakE92C+Cbw2It5aTkjZNiL2KFvmXwE+FxHbl+nPjoiu8xER74iIWWUara3WxwcbZ4z8M3BsROxRgvE04LrSCrGpPktzHPTr0ZwkFRGxNc060PINmmXyhojYPJoTk/aO5kSpQZdtD+6hOd7bMprrITQ/sC9rmz7Am2iaVDfV1jQbiWvLSUKf6je89fe8d9Js2Jzbb28bgMy8m6ZJ/R+jOUFti4hohf5XgPdExKvLsnp6RBxQltmAIuJPIuIl5f0eomkKr2Hdvg74H5oTCreI5iTFN9EcOhtRmXk18Eua35iBfJ1mfX7jIGV+StNSMrtMN2k20j4VzUmfzy7LZh5P7i1Dsy5/JiKeCxv+i31wv2kvojnJcS+a37gNynf/lcDlg87oBGRQ96gcV/vv1oPmOOL6zFw9AtN+mOb484U0zUZvozkW3XIW8J1yDHQNTRP0V6P569BA07yTpon1ROB+mhNUXlYGf4zmBJVrSxPkvzP4MdGWNwI3lWbTzwOH92uCbvec2Ph/1G/p4T2GLDOvoDnG9i3gbpog6+WYey/Tvo/mOOF64D9ojoHdSBM6f1HKrKQ5XvYJmkBeSXNC1mY9LNtuzgZeVJoDvz2a62GZl3v7TR+aQzbrBh2xN2fSnCB1H81JQ99vDYiIVwIfBo4qh4dOp9mzXDDAtI6kCdNbaE4e+2Cp/xKa49R/T/N5L6c5saub36P5+9BDNE2uP6Tt70Ud/Fu/dXskNmQ2kpm/Aw6iOSZ/H/CPNJ/RLaPxfjR71dsMNLAsm091KfM7mpPc3tHW7wLgraXfSpp5uZDmt+1fSrHP03w3LouIh2nWkVf3m/xFNBvOV5QNtnYHAVdn5qpB53ACimZjR5KkkRERs2iaqV8+Qht5vbzndcBxmblsLN5vLBnUkiRVzKbvCSwi3t6heXmwyxVKkiYY96glSaqYe9SSJFVsrC76Pqjtttsu586dO97VkCRpTFx//fX3ZWYvF5rqLajLhQW+SnPFoKT5n+OtNJenm0tzfdq3ZuYDERE0p9m3rll8TGYOejGGuXPnsmTJkl6qIknShBcR/9W9VKPXpu/PA9/PzF1p/ot7M83/G6/IzHk0V29q/d9xP5qLvM+juRzdF3utjCRJeqquQR3Nxc//mObCC5QLw6/lqRdEXwQcUl4fDJybjWtprlAz6e4PKknSWOhlj/p5NFdb+lpE/DwivlqupbxD68ow5Xn7Un42T72ofB9PvYC8JEnqUS/HqKfR3OP1/Zl5XUR8noEv6wedL9a+0X/AIuJ4yp1adt555x6qIUmq2aOPPkpfXx/r1w90ZeGpZ/r06cyZM4ctthjsZmyD6yWo+4C+zLyudF9EE9T3RMSOmXl3adq+t638Tm3jz6G5A8xTZOZZNNd5Zf78+f6ZW5ImuL6+Prbeemvmzp1Lc17x1JaZrFmzhr6+PnbZZZdhT6dr03e5MP/KiGjdtGFf4Fc0F09v3WXlaOA75fUlwFHl7ih7Ag92uHi6JGmSWb9+Pdtuu60hXUQE22677Sa3MPT6P+r3A9+MiC2BO4BjaUL+wog4juaG44eVspfS/DVrOc3fs47dpBpKkiYMQ/qpRuLz6OnvWZl5Y2bOz8yXZuYhmflAZq7JzH0zc155vr+Uzcx8X2b+fma+pNx2TpKkURcRHHnkkRu6H3vsMWbNmsWBBx64od/3vvc95s+fz2677cauu+7KSSed1HFac+fO5S1vefLuvBdddBHHHHMMAOeccw6bbbYZS5cu3TD8xS9+MStWrBjZGaKSK5NJkiafvRZeyV1rR+4ul7NnzuDHC/YZtMzTn/50li1bxrp165gxYwaXX345s2c/+cejZcuWccIJJ7B48WJ23XVXHnvsMc4666wBp7dkyRJuuukmdt99942GzZkzh8985jNccMEFw5+pHhjUkqRRcdfadaxYeMCITW/ugsU9ldtvv/1YvHgxhx56KOeddx5HHHEEP/rRjwA444wzOPnkk9l1110BmDZtGu9973sHnNZJJ53Eaaedxje/+c2Nhh144IFcc8013HrrrbzwhS/sMPbI8KYckqRJ5fDDD+f8889n/fr1LF26lFe/+tUbhi1btoxXvvKVPU/rrW99KzfccAPLly/faNhmm23GRz/6UU477bQRqfdADGpJ0qTy0pe+lBUrVnDeeeex//77b9K0Nt98cz7ykY/wN3/zNx2Hv+1tb+Paa6/l17/+9Sa9z2AMaknSpHPQQQdx0kknccQRRzyl/+67787111+/UfnHH3+cPfbYgz322INPfvKTTxl25JFHcs0113DnnXduNN60adM48cQTOf3000d2BtrfY9SmLEkTzHBOfurlBCeNvXe+850861nP4iUveQlXX331hv4f+chHePOb38xrXvMaXvCCF/DEE09w5pln8uEPf5gbb7yx47S22GILPvShD7Fw4UL22WfjZX3MMcdwxhln8PDDD4/KvBjUklQM5+SnXk9w0tiaM2cOH/jABzbq/9KXvpQzzzyTI444gkceeYSI4IADui/z4447jlNPPbXjsC233JK//Mu/7Ph+IyEyx//qnfPnz0/vRy1pvM1dsHhYQT2SZzZPZDfffDO77bbbhu7x+HtWjfp/LgARcX1mzu9lfPeoJUmjYiKGao08mUySpIoZ1JIkVcygliSNmBrOe6rJSHweBrUkaURMnz6dNWvWGNZF637U06dP36TpeDKZJGlEzJkzh76+PlavXj3eVanG9OnTmTNnziZNw6CWJI2ILbbYgl122WW8qzHp2PQtSVLFDGpJkipmUEuSVDGDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFDGpJkipmUEuSVLFp410BSRppey28krvWrhvyeLNnzhiF2kibxqCWNOnctXYdKxYeMN7VkEaETd+SJFWsp6COiBUR8cuIuDEilpR+20TE5RFxW3l+dukfEfGFiFgeEUsj4hWjOQOSJE1mQ9mj/pPM3CMz55fuBcAVmTkPuKJ0A+wHzCuP44EvjlRlJUmaajal6ftgYFF5vQg4pK3/udm4FpgZETtuwvtIkjRl9RrUCVwWEddHxPGl3w6ZeTdAed6+9J8NrGwbt6/0e4qIOD4ilkTEktWrVw+v9pIkTXK9nvW9V2auiojtgcsj4pZBykaHfrlRj8yzgLMA5s+fv9FwSZLU4x51Zq4qz/cCFwOvAu5pNWmX53tL8T5gp7bR5wCrRqrCkiRNJV2DOiKeHhFbt14DrweWAZcAR5diRwPfKa8vAY4qZ3/vCTzYaiKXJElD00vT9w7AxRHRKv/Pmfn9iPgZcGFEHAfcCRxWyl8K7A8sBx4Bjh3xWkuSNEV0DerMvAN4WYf+a4B9O/RP4H0jUjtJkqY4r0wmSVLFDGpJkipmUEuSVDGDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFDGpJkipmUEuSVDGDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqti08a6AJE1ks2fOYO6CxcMa78cL9hmFGmmyMaglaRMMN2yHE+6ammz6liSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFes5qCNi84j4eUR8t3TvEhHXRcRtEXFBRGxZ+m9VupeX4XNHp+qSJE1+Q9mj/gBwc1v36cDnMnMe8ABwXOl/HPBAZj4f+FwpJ0mShqGnoI6IOcABwFdLdwD7ABeVIouAQ8rrg0s3Zfi+pbwkSRqiXveozwQ+CjxRurcF1mbmY6W7D5hdXs8GVgKU4Q+W8pIkaYi6BnVEHAjcm5nXt/fuUDR7GNY+3eMjYklELFm9enVPlZUkaarpZY96L+CgiFgBnE/T5H0mMDMiWvezngOsKq/7gJ0AyvBnAff3n2hmnpWZ8zNz/qxZszZpJiRJmqy6BnVmfjwz52TmXOBw4MrMfDtwFXBoKXY08J3y+pLSTRl+ZWZutEctSZK625T/UX8M+HBELKc5Bn126X82sG3p/2FgwaZVUZKkqWta9yJPysyrgavL6zuAV3Uosx44bATqJknSlOeVySRJqphBLUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFDGpJkipmUEuSVDGDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklSxaeNdAUkazF4Lr+SuteuGNM7smTNGqTbS2DOoJVXtrrXrWLHwgPGuhjRubPqWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKdQ3qiJgeET+NiF9ExE0R8enSf5eIuC4ibouICyJiy9J/q9K9vAyfO7qzIEnS5NXLHvVvgX0y82XAHsAbI2JP4HTgc5k5D3gAOK6UPw54IDOfD3yulJMkScPQNaiz8ZvSuUV5JLAPcFHpvwg4pLw+uHRThu8bETFiNZYkaQrp6Rh1RGweETcC9wKXA7cDazPzsVKkD5hdXs8GVgKU4Q8C23aY5vERsSQilqxevXrT5kKSpEmqp6DOzMczcw9gDvAqYLdOxcpzp73n3KhH5lmZOT8z58+aNavX+kqSNKUM6azvzFwLXA3sCcyMiGll0BxgVXndB+wEUIY/C7h/JCorSdJU08tZ37MiYmZ5PQN4LXAzcBVwaCl2NPCd8vqS0k0ZfmVmbrRHLUmSupvWvQg7AosiYnOaYL8wM78bEb8Czo+IU4GfA2eX8mcDX4+I5TR70oePQr0lSZoSugZ1Zi4FXt6h/x00x6v7918PHDYitZMkaYrzymSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFDGpJkipmUEuSVDGDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklQxg1qSpIpNG+8KSNJUNHvmDOYuWDzkcX68YJ9RqpFqZVBL0jgYTuAONdg1Odj0LUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmq2LTxroCkqWGvhVdy19p1Qx5v9swZo1AbaeIwqCWNibvWrmPFwgPGuxrShGPTtyRJFTOoJUmqmEEtSVLFDGpJkipmUEuSVDGDWpKkihnUkiRVzKCWJKliXYM6InaKiKsi4uaIuCkiPlD6bxMRl0fEbeX52aV/RMQXImJ5RCyNiFeM9kxIkjRZ9bJH/RhwYmbuBuwJvC8iXgQsAK7IzHnAFaUbYD9gXnkcD3xxxGstSdIU0TWoM/PuzLyhvH4YuBmYDRwMLCrFFgGHlNcHA+dm41pgZkTsOOI1lyRpChjSMeqImAu8HLgO2CEz74YmzIHtS7HZwMq20fpKP0mSNEQ9B3VEPAP4FvDBzHxosKId+mWH6R0fEUsiYsnq1at7rYYkSVNKT0EdEVvQhPQ3M/NfS+97Wk3a5fne0r8P2Klt9DnAqv7TzMyzMnN+Zs6fNWvWcOsvSdKk1stZ3wGcDdycmZ9tG3QJcHR5fTTwnbb+R5Wzv/cEHmw1kUuSpKHp5X7UewFHAr+MiBtLv08AC4ELI+I44E7gsDLsUmB/YDnwCHDsiNZYkqQppGtQZ+Z/0Pm4M8C+Hcon8L5NrJckScIrk0mSVDWDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFpo13BSRNPHstvJK71q4b0jizZ84YpdpIk5tBLWnI7lq7jhULDxjvakhTgk3fkiRVzKCWJKliBrUkSRUzqCVJqphBLUlSxQxqSZIqZlBLklQx/0ctSRPE7JkzmLtg8bDG+/GCfUahRhoLBrUkTRDDDdvhhLvqYdO3JEkVM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFugZ1RPxTRNwbEcva+m0TEZdHxG3l+dmlf0TEFyJieUQsjYhXjGblJUma7HrZoz4HeGO/fguAKzJzHnBF6QbYD5hXHscDXxyZakqSNDV1DerMvAa4v1/vg4FF5fUi4JC2/udm41pgZkTsOFKVlSRpqhnuMeodMvNugPK8fek/G1jZVq6v9NtIRBwfEUsiYsnq1auHWQ1Jkia3kT6ZLDr0y04FM/OszJyfmfNnzZo1wtWQJGlyGG5Q39Nq0i7P95b+fcBObeXmAKuGXz1Jkqa24Qb1JcDR5fXRwHfa+h9Vzv7eE3iw1UQuSZKGblq3AhFxHrA3sF1E9AGfAhYCF0bEccCdwGGl+KXA/sBy4BHg2FGosyRJU0bXoM7MIwYYtG+Hsgm8b1MrJUmSGl6ZTJKkihnUkiRVzKCWJKliBrUkSRXrejKZJGlimz1zBnMXLB7WeD9esM8o1EhDYVBL0iQ33LAdTrhr5Nn0LUlSxQxqSZIqZlBLklQxg1qSpIoZ1JIkVcygliSpYga1JEkV83/U0hS218IruWvtuiGPN3vmjFGojaRODGppCrtr7TpWLDxgvKshaRA2fUuSVDGDWpKkihnUkiRVzKCWJKliBrUkSRUzqCVJqph/z5IkdTR75owh35N69swZw77/tTozqCVJHQ0ncIca7OrOoJYmieFcZcwrjEn1M6ilScKrjEmTkyeTSZJUMYNakqSKGdSSJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLFDGpJkirmBU8kSSNmONcHb43nNcI7M6glSSNmuGHrNcIHZtO3JEkVM6glSaqYTd+SpHHnva8HZlBLlRnO7SrBW1ZqYvPe1wMzqKXKeLtKSe0MamkUDWfv2D1jqTdT5a9gBrU0itw7lkbPVPkrmGd9S5JUMfeoNeUMtzl6IjWVSZo8RiWoI+KNwOeBzYGvZubC0XgfaTiG0xw90ZrKJE0eIx7UEbE58A/A64A+4GcRcUlNo0RyAAAJi0lEQVRm/mqk30uTx3D/kjQcnqwlTW0T7T/bo7FH/SpgeWbeARAR5wMHA5MyqDflP682pT6p9pOuNuXsUkl1mWj/2R6NoJ4NrGzr7gNePQrvM6CxDM/hBsxEaEp1L/dJblRJGi+RmSM7wYjDgDdk5p+X7iOBV2Xm+/uVOx44vnS+ELh1kMluB9w3ohUdH85HXSbDfEyGeQDnozaTYT5qn4fnZuasXgqOxh51H7BTW/ccYFX/Qpl5FnBWLxOMiCWZOX9kqjd+nI+6TIb5mAzzAM5HbSbDfEyGeWgZjf9R/wyYFxG7RMSWwOHAJaPwPpIkTXojvkedmY9FxAnAD2j+nvVPmXnTSL+PJElTwaj8jzozLwUuHcFJ9tREPgE4H3WZDPMxGeYBnI/aTIb5mAzzAIzCyWSSJGnkeK1vSZIqVk1QR8RhEXFTRDwREfPb+s+NiHURcWN5fGmA8beJiMsj4rby/Oyxq/1T6jHQfLwuIq6PiF+W545/zI2IUyLirrb53X/sav+UenScjzLs4xGxPCJujYg3DDD+LhFxXVkeF5QTC8dVqUfrc10RETcOUG5FWU43RsSSsa7nYHpdPyLijWX5LI+IBWNdz24i4m8j4paIWBoRF0fEzAHKVbksun2+EbFVWd+Wl+/B3LGv5cAiYqeIuCoibi7f8w90KLN3RDzYtq59cjzq2k23dSQaXyjLYmlEvGI86rlJMrOKB7Abzf+prwbmt/WfCyzrYfwzgAXl9QLg9Mrm4+XAc8rrFwN3DTD+KcBJFS+PFwG/ALYCdgFuBzbvMP6FwOHl9ZeAvxjveepXv/8P+OQAw1YA2413HYe7ftCcxHk78Dxgy7K8XjTede9Xx9cD08rr0wf6vta4LHr5fIH3Al8qrw8HLhjvever347AK8rrrYH/7DAPewPfHe+69jAvg64jwP7A94AA9gSuG+86D/VRzR51Zt6cmYNd9KSbg4FF5fUi4JBNr9XQDTQfmfnzzGz9n/wmYHpEbDW2tevdIMvjYOD8zPxtZv4aWE5z2dgNIiKAfYCLSq9xWx6dlPq9FThvvOsySjZcxjczfwe0LuNbjcy8LDMfK53X0lxvYaLo5fNt/z26CNi3rHdVyMy7M/OG8vph4Gaaq0pORgcD52bjWmBmROw43pUaimqCuotdIuLnEfHDiPijAcrskJl3Q7MSAtuPXfWG7C3AzzPztwMMP6E00fzTeDXhD6LTJWL7f8G3Bda2/RB3KjOe/gi4JzNvG2B4ApeVQxTHD1BmPHVbP3pZRjV5J80eTyc1LotePt8NZcr34EGa70V1SrP8y4HrOgz+g4j4RUR8LyJ2H9OK9a7bOjLRvg8bGdP7UUfEvwO/12HQyZn5nQFGuxvYOTPXRMQrgW9HxO6Z+dCoVbSLYc5Ha9zdaZr6Xj9AkS8Cf02z8v01TRPtO4df20HrMpz56LRX0P+vA72UGRU9ztMRDL43vVdmroqI7YHLI+KWzLxmpOs6kMHmgd7Wj3H7/J9SiR6WRUScDDwGfHOAyYzrshhA1d+BoYiIZwDfAj7Y4Tf1BprLXP6mnAvxbWDeWNexB93WkQmxLAYzpkGdma8dxji/BX5bXl8fEbcDLwD6nzRwT0TsmJl3l2aNeze5wgPXacjzARARc4CLgaMy8/YBpn1PW/mvAN8dViV7MMz56OUSsffRNC9NK3sTHS8jOxq6zVNETAPeDLxykGmsKs/3RsTFNE2dYxYOvS6XQdaPni7jO9p6WBZHAwcC+2Y5mNhhGuO6LAbQy+fbKtNX1rlnAfePTfV6ExFb0IT0NzPzX/sPbw/uzLw0Iv4xIrbLzKqun93DOlLF92FTVN/0HRGzornHNRHxPJotujs6FL0EOLq8PhoYdM92rJWzWhcDH8/MHw9Srv3YyZ8Cy0a7bkN0CXB4Oat1F5rl8dP2AuVH9yrg0NKrpuXxWuCWzOzrNDAinh4RW7de07R8VLMMelw/qr+Mb0S8EfgYcFBmPjJAmVqXRS+fb/vv0aHAlQNtjIyHcrz8bODmzPzsAGV+r3VcPSJeRZMXa8ault31uI5cAhxVzv7eE3iwdZh0whjvs9laD5ofnT6aved7gB+U/m+hOfnqFzRNMW9qG+erlDOSaY7/XAHcVp63qWw+/jfwP8CNbY/tO8zH14FfAktpVrAda5qPMuxkmrNebwX2a+t/KU+e2f48mgBfDvwLsNV4r2OlXucA7+nX7znApW31/kV53ETTTDvu9W6ra8f1o30eSvf+NGfy3l7bPJT6Lac5btj6LrTOkJ4Qy6LT5wv8Fc2GB8D0st4vL9+D5413nfvV/zU0zb9L25bB/sB7Wt8P4IS2395rgT8c73p3mI+O60i/+QjgH8qy+iVt/2KZKA+vTCZJUsWqb/qWJGkqM6glSaqYQS1JUsUMakmSKmZQS5JUMYNakqSKGdRS5SLi8bZbDd4YA9y2MprbRd5YbufXfnvCP+xQ9syI+OPyelpEnBbNLUlb45zcpU7nRMS7+/U7JCIujYgtI+KackUuSZvIL5JUv3WZuUe3Qpn5p9DcR5jmVpgHdioXEdsAe2bmB0uvU2muyf2SzFxfrvR0Ype3O4/mdrJfbut3OHBeZv4uIq4A/oyBr+EtqUfuUUtTz6HA9wEi4mnAu4D3Z+Z6aG57mJmntApHxDsi4qdlT/vL5ZK+/w7s2rqkaZnOa2lu3EB5fvtYzZA0mRnUUv1m9Gv6/rNNnN5ewPXl9fOBO7O5J/FGImI3mj3jvcpe/ePA2zPzceBfae7rDXAQcFXbdJYB/88m1lMSNn1LE0FPTd9DsCOwutOAiDgW+ADNtfP/ENiX5k5jPyv3Z5jBk3emOw/4W+DzNM3e57amk5mPR8TvImLrgTYCJPXGoJamnnU0N42A5qYRO7cCNTO/BnwtIpYBm9Pc0GBRZn68w3R+DOwYES+jCfXD+w3fClg/KnMgTSE2fUtTz800Td5kc4vJs4G/j4jpAOUY9Jal7BXAoRGxfRm2TUQ8t4ybwIXAIpo7Xm0I5YjYFlidmY+OzSxJk5dBLdWv/zHqhZs4vcXA3m3dJwN3A8si4ufAj2jCd1Vm/ormFq2XRcRS4HKapvOW84CXAef3e48/obntqaRN5G0upSkoIv4DODAz147S9P8V+Hhm3joa05emEveopanpRGDn0ZhwRGwJfNuQlkaGe9TSBBQRFwO79Ov9scz8wXjUR9LoMaglSaqYTd+SJFXMoJYkqWIGtSRJFTOoJUmqmEEtSVLF/n+gl8tnrL5hKgAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 576x432 with 1 Axes>"
       ]
@@ -1109,16 +1010,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 329,
+   "execution_count": 223,
    "metadata": {},
    "outputs": [],
    "source": [
-    "i=7"
+    "i=2"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 330,
+   "execution_count": 224,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1131,12 +1032,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 331,
+   "execution_count": 225,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 720x576 with 6 Axes>"
       ]
@@ -1147,7 +1048,7 @@
    ],
    "source": [
     "plt.subplot(1,3,1)\n",
-    "plt.gca().set_title('RealET from sim')\n",
+    "plt.gca().set_title('RealET from sim (GeV)')\n",
     "plt.xlabel('X')\n",
     "plt.ylabel('Y')\n",
     "ax = plt.gca()\n",
@@ -1161,7 +1062,7 @@
     "plt.subplots_adjust(wspace=0.4,hspace=0.2)\n",
     "\n",
     "plt.subplot(1,3,2)\n",
-    "plt.gca().set_title('RecoET Geant 4')\n",
+    "plt.gca().set_title('RecoET Geant 4 (GeV)')\n",
     "#plt.imshow(X_B.reshape(n_H_B,n_W_B))\n",
     "plt.xlabel('X')\n",
     "plt.ylabel('Y')\n",
@@ -1176,7 +1077,7 @@
     "plt.subplots_adjust(wspace=0.4,hspace=0.2)\n",
     "\n",
     "plt.subplot(1,3,3)\n",
-    "plt.gca().set_title('RecoET from NN')\n",
+    "plt.gca().set_title('RecoET from NN (GeV)')\n",
     "#plt.imshow(sample_nn.reshape(n_H_B,n_W_B)/10)\n",
     "plt.xlabel('X')\n",
     "plt.ylabel('Y')\n",
@@ -1197,6 +1098,319 @@
   },
   {
    "cell_type": "code",
+   "execution_count": 226,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.colorbar.Colorbar at 0x7fc42f7f4898>"
+      ]
+     },
+     "execution_count": 226,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.subplot(1,2,1)\n",
+    "plt.imshow(test_reco_inner_NN[0].reshape(28,32))\n",
+    "plt.colorbar()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.imshow(test_reco_outer_NN[0].reshape(26,32))\n",
+    "plt.colorbar()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 227,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('/disk/lhcb_data/davide/HCAL_project_full_event/csv/MCtracker_info.pickle', 'rb') as f:\n",
+    "    tracks=pickle.load(f)\n",
+    "    \n",
+    "pos_rejected={}\n",
+    "i=0\n",
+    "while os.path.exists('/disk/lhcb_data/davide/HCAL_project_full_event/reco/rejected'+str(i)+'.pickle'):\n",
+    "#while i < 5:\n",
+    "    file_path = '/disk/lhcb_data/davide/HCAL_project_full_event/reco/rejected'+str(i)+'.pickle'\n",
+    "    with open(file_path, 'rb') as handle:\n",
+    "        pos_rejected[i]=pickle.load(handle)\n",
+    "    i+=1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 228,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "width_X=8404.0\n",
+    "width_Y=6828.0\n",
+    "#number of events\n",
+    "batch_size=3000\n",
+    "n_batches=len(tracks['xProjections'])\n",
+    "\n",
+    "X_pixels=64\n",
+    "Y_pixels=52"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 229,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for j in range(n_batches):\n",
+    "    for i in range(batch_size):\n",
+    "        tracks[\"xProjections\"][j][i][0]/=(width_X/2)\n",
+    "        tracks[\"yProjections\"][j][i][0]/=(width_Y/2)\n",
+    "        \n",
+    "        tracks[\"xProjections\"][j][i][0]*=32\n",
+    "        tracks[\"yProjections\"][j][i][0]*=26\n",
+    "       \n",
+    "        tracks[\"xProjections\"][j][i][0]+=32\n",
+    "        tracks[\"yProjections\"][j][i][0]+=26"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 236,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inner={}\n",
+    "outer={}\n",
+    "\n",
+    "\n",
+    "for n in range(start_batch,n_batches):\n",
+    "    \n",
+    "    inner[n]={}\n",
+    "    outer[n]={}\n",
+    "    \n",
+    "    inner[n]['TOS']=np.empty(shape=(batch_size,),dtype='bool')\n",
+    "    inner[n]['TIS']=np.empty(shape=(batch_size,),dtype='bool')\n",
+    "    inner[n]['ET']=np.empty(shape=(batch_size,))\n",
+    "    \n",
+    "    outer[n]['TOS']=np.empty(shape=(batch_size,),dtype='bool')\n",
+    "    outer[n]['TIS']=np.empty(shape=(batch_size,),dtype='bool')\n",
+    "    outer[n]['ET']=np.empty(shape=(batch_size,))\n",
+    "    \n",
+    "    for event in range(batch_size):\n",
+    "            \n",
+    "            if event not in pos_rejected[n]:\n",
+    "                \n",
+    "                value_inner, pos_inner = get_4_max_cells(test_reco_inner[event])\n",
+    "                value_outer, pos_outer = get_4_max_cells(test_reco_outer[event])\n",
+    "                \n",
+    "                inner[n]['ET'][event]=value_inner.sum()\n",
+    "                outer[n]['ET'][event]=value_outer.sum()\n",
+    "                \n",
+    "                if value_inner.sum()>3680:\n",
+    "                    \n",
+    "                    for ntrack in range(3):\n",
+    "                    \n",
+    "                        y=int(np.floor(tracks['yProjections'][n][event][0][ntrack]))\n",
+    "                        x=int(np.floor(tracks['xProjections'][n][event][0][ntrack]))\n",
+    "                        \n",
+    "\n",
+    "                        if pos[0]==y or pos[0]==y+1 or pos[1]==x or pos[1]==x+1:\n",
+    "                            inner[n]['TOS'][event]=True\n",
+    "                            \n",
+    "                        else:\n",
+    "                            inner[n]['TIS'][event]=True\n",
+    "                            \n",
+    "                        \n",
+    "                if value_outer.sum()>3680:\n",
+    "                    \n",
+    "                    for ntrack in range(3):\n",
+    "                    \n",
+    "                        y=int(np.floor(tracks['yProjections'][n][event][0][ntrack]))\n",
+    "                        x=int(np.floor(tracks['xProjections'][n][event][0][ntrack]))\n",
+    "                        \n",
+    "\n",
+    "                        if pos[0]==y or pos[0]==y+1 or pos[1]==x or pos[1]==x+1:\n",
+    "                            outer[n]['TOS'][event]=True\n",
+    "                        else:\n",
+    "                            outer[n]['TIS'][event]=True\n",
+    "                            \n",
+    "                    \n",
+    "                        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 307,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "TOS_evts = plt.hist(inner[2]['ET'][inner[2]['TOS']],range=(0.001,1.25e4),bins=100)\n",
+    "TIS_evts = plt.hist(inner[2]['ET'][inner[2]['TIS']],range=(0.001,1.25e4),bins=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 325,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.5181666666666667"
+      ]
+     },
+     "execution_count": 325,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "(inner[2]['TIS'].mean()+outer[2]['TIS'].mean())/2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 308,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "tot_evts=plt.hist(inner[2]['ET'],range=(0.001,1.25e4),bins=100);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 314,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#eff_MC = np.zeros_like(b[0])\n",
+    "TIS_eff_NN = np.zeros_like(tot_evts[0])\n",
+    "TOS_eff_NN = np.zeros_like(tot_evts[0])\n",
+    "for i in range(len(tot_evts[0])):\n",
+    "    if tot_evts[0][i]!=0:\n",
+    "        TIS_eff_NN[i]=TIS_evts[0][i]/tot_evts[0][i]\n",
+    "        TOS_eff_NN[i]=TOS_evts[0][i]/tot_evts[0][i]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 315,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "idx2 = np.arange(0.001,1.25e4, step=1.25e4/100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 316,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(100,)"
+      ]
+     },
+     "execution_count": 316,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "idx2.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 318,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fc453e19be0>]"
+      ]
+     },
+     "execution_count": 318,
+     "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": [
+    "plt.plot(idx2,TOS_eff_NN)\n",
+    "plt.plot(idx2,TIS_eff_NN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 320,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{0: array([False, False, False, ..., False, False, False]),\n",
+       " 1: array([False,  True, False, ..., False, False,  True]),\n",
+       " 2: array([False, False, False, ..., False, False, False]),\n",
+       " 3: array([ True, False,  True, ..., False, False, False]),\n",
+       " 4: array([False, False, False, ..., False,  True, False])}"
+      ]
+     },
+     "execution_count": 320,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tracks['L0HadronDec_TIS']"
+   ]
+  },
+  {
+   "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
diff --git a/true_root_to_df_DKpi.ipynb b/true_root_to_df_DKpi.ipynb
index 5e7668a..f571dd1 100644
--- a/true_root_to_df_DKpi.ipynb
+++ b/true_root_to_df_DKpi.ipynb
@@ -6,17 +6,24 @@
    "metadata": {},
    "outputs": [
     {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Welcome to JupyROOT 6.16/00\n"
+     ]
+    },
+    {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/home/hep/davide/miniconda3/envs/root_env/lib/python2.7/site-packages/root_numpy/_tree.py:5: RuntimeWarning: numpy.dtype size changed, may indicate binary incompatibility\n",
-      "  from . import _librootnumpy\n"
+      "/disk/lhcb_data2/davide/miniconda3/envs/root_env/lib/python3.7/site-packages/root_numpy/__init__.py:46: RuntimeWarning: numpy 1.17.2 is currently installed but you installed root_numpy against numpy 1.9.3. Please consider reinstalling root_numpy for this numpy version.\n",
+      "  RuntimeWarning)\n"
      ]
     }
    ],
    "source": [
     "import root_numpy as rn\n",
-    "import pandas as pd\n",
+    "#import pandas as pd\n",
     "import numpy as np\n",
     "import ROOT as r\n",
     "import pickle\n",
@@ -25,24 +32,236 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "\n",
-    "file_name='B2Dmunu_full'\n",
-    "file_path='/disk/lhcb_data/davide/HCAL_project_full_event/'+file_name+'.root'\n",
+    "file_name='B2Dmunu'\n",
+    "file_path='/disk/lhcb_data2/davide/HCAL_project_full_event/'+file_name+'.root'\n",
     "tree_name='Bd2Dmu/DecayTree'\n",
     "\n"
    ]
   },
   {
    "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#b=r.TBrowser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f = r.TFile(file_path)\n",
+    "t = f.Get(tree_name)\n",
+    "N=t.GetEntries()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "batch_size=20000\n",
+    "\n",
+    "n_batches= N//batch_size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "93510"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "N"
+   ]
+  },
+  {
+   "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
-    "b=r.TBrowser()"
+    "pion1_X_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_X_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi1_L0Calo_HCAL_xProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion1_X = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_X[j]= np.array([pion1_X_temp[j][i][0] for i in range(pion1_X_temp[j].shape[0])])\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pion1_X_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_X_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi1_L0Calo_HCAL_xProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion1_X = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_X[j]= np.array([pion1_X_temp[j][i][0] for i in range(pion1_X_temp[j].shape[0])])\n",
+    "    \n",
+    "    \n",
+    "pion1_Y_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_Y_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi1_L0Calo_HCAL_yProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion1_Y = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_Y[j]= np.array([pion1_Y_temp[j][i][0] for i in range(pion1_Y_temp[j].shape[0])])\n",
+    "\n",
+    "pion1_realET_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_realET_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi1_L0Calo_HCAL_realET'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion1_realET = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_realET[j]= np.array([pion1_realET_temp[j][i][0] for i in range(pion1_realET_temp[j].shape[0])])\n",
+    "    \n",
+    "pion1_region_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_region_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi1_L0Calo_HCAL_region'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion1_region = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion1_region[j]= np.array([pion1_region_temp[j][i][0] for i in range(pion1_region_temp[j].shape[0])])\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pion2_X_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_X_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi2_L0Calo_HCAL_xProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion2_X = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_X[j]= np.array([pion2_X_temp[j][i][0] for i in range(pion2_X_temp[j].shape[0])])\n",
+    "    \n",
+    "    \n",
+    "pion2_Y_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_Y_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi2_L0Calo_HCAL_yProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion2_Y = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_Y[j]= np.array([pion2_Y_temp[j][i][0] for i in range(pion2_Y_temp[j].shape[0])])\n",
+    "\n",
+    "pion2_realET_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_realET_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi2_L0Calo_HCAL_realET'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion2_realET = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_realET[j]= np.array([pion2_realET_temp[j][i][0] for i in range(pion2_realET_temp[j].shape[0])])\n",
+    "    \n",
+    "pion2_region_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_region_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['pi2_L0Calo_HCAL_region'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "pion2_region = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    pion2_region[j]= np.array([pion2_region_temp[j][i][0] for i in range(pion2_region_temp[j].shape[0])])\n",
+    "    "
    ]
   },
   {
@@ -51,27 +270,118 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "f = r.TFile(file_path)\n",
-    "t = f.Get(tree_name)\n",
-    "j=t.GetEntries()"
+    "K_X_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_X_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['K_L0Calo_HCAL_xProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "K_X = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_X[j]= np.array([K_X_temp[j][i][0] for i in range(K_X_temp[j].shape[0])])\n",
+    "    \n",
+    "    \n",
+    "K_Y_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_Y_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['K_L0Calo_HCAL_yProjection'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "K_Y = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_Y[j]= np.array([K_Y_temp[j][i][0] for i in range(K_Y_temp[j].shape[0])])\n",
+    "\n",
+    "K_realET_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_realET_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['K_L0Calo_HCAL_realET'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "K_realET = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_realET[j]= np.array([K_realET_temp[j][i][0] for i in range(K_realET_temp[j].shape[0])])\n",
+    "    \n",
+    "K_region_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_region_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['K_L0Calo_HCAL_region'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "K_region = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    K_region[j]= np.array([K_region_temp[j][i][0] for i in range(K_region_temp[j].shape[0])])\n",
+    "    "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "batch_size=20000\n",
-    "#n_batches=2\n",
+    "L0Hadron_TIS_dict_temp={}\n",
     "\n",
-    "N = j\n",
-    "n_batches= N//batch_size"
+    "for j in range(n_batches):\n",
+    "    L0Hadron_TIS_dict_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['B0_L0HadronDecision_TIS'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "L0Hadron_TIS_dict = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    L0Hadron_TIS_dict[j]= np.array([L0Hadron_TIS_dict_temp[j][i][0] for i in range(L0Hadron_TIS_dict_temp[j].shape[0])])\n",
+    "\n",
+    "L0Hadron_TOS_dict_temp={}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    L0Hadron_TOS_dict_temp[j]=rn.root2array(\n",
+    "        filenames=file_path, \n",
+    "        treename=tree_name,\n",
+    "        branches=['B0_L0HadronDecision_TOS'],\n",
+    "        start=j*batch_size,\n",
+    "        stop=(j+1)*batch_size,\n",
+    "    )\n",
+    "    \n",
+    "L0Hadron_TOS_dict = {}\n",
+    "\n",
+    "for j in range(n_batches):\n",
+    "    L0Hadron_TOS_dict[j]= np.array([L0Hadron_TOS_dict_temp[j][i][0] for i in range(L0Hadron_TOS_dict_temp[j].shape[0])])\n",
+    "    \n",
+    " \n",
+    " "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -99,57 +409,64 @@
     "        stop=(j+1)*batch_size,\n",
     "    )\n",
     "    \n",
-    "realETs_dict={}\n",
+    "\n",
+    "realETs={}\n",
     "particle='pi1'\n",
     "\n",
     "for j in range(n_batches):\n",
-    "    realETs_dict[j]=rn.root2array(\n",
+    "    realETs[j]=rn.root2array(\n",
     "        filenames=file_path, \n",
     "        treename=tree_name,\n",
     "        branches=[particle+'_L0Calo_HCAL_realETs'],\n",
     "        start=j*batch_size,\n",
     "        stop=(j+1)*batch_size,\n",
-    "    )\n",
-    "    \n",
-    "regions_dict={}\n",
-    "particle='pi1'\n",
-    "\n",
-    "for j in range(n_batches):\n",
-    "    regions_dict[j]=rn.root2array(\n",
-    "        filenames=file_path, \n",
-    "        treename=tree_name,\n",
-    "        branches=[particle+'_L0Calo_HCAL_region'],\n",
-    "        start=j*batch_size,\n",
-    "        stop=(j+1)*batch_size,\n",
-    "    )"
+    "    )\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
     "true_events={\n",
     "            'xProjections':xProjections_dict, \n",
     "            'yProjections':yProjections_dict, \n",
-    "            'realETs':realETs_dict,\n",
-    "            'regions':regions_dict,\n",
+    "            'realETs': realETs,\n",
+    "    \n",
+    "            'L0HadronDec_TIS':L0Hadron_TIS_dict,\n",
+    "            'L0HadronDec_TOS':L0Hadron_TOS_dict, \n",
+    "    \n",
+    "            'pi1_xProjection':pion1_X,\n",
+    "            'pi1_yProjection':pion1_Y,\n",
+    "            'pi1_realET':pion1_realET,\n",
+    "            'pi1_region':pion1_region,\n",
+    "    \n",
+    "            'pi2_xProjection':pion2_X,\n",
+    "            'pi2_yProjection':pion2_Y,\n",
+    "            'pi2_realET':pion2_realET,\n",
+    "            'pi2_region':pion2_region,\n",
+    "   \n",
+    "            'K_xProjection':K_X,\n",
+    "            'K_yProjection':K_Y,\n",
+    "            'K_realET':K_realET,\n",
+    "            'K_region':K_region,\n",
+    "    \n",
     "            }"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "11"
+       "4"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -160,7 +477,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -178,21 +495,21 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 2",
+   "display_name": "Python 3",
    "language": "python",
-   "name": "python2"
+   "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 2
+    "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython2",
-   "version": "2.7.15"
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
   }
  },
  "nbformat": 4,