{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os \n",
    "import pickle\n",
    "\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "\n",
    "from architectures.bicycle_GAN import *\n",
    "from architectures.utils.toolbox import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "task='TEST'\n",
    "\n",
    "PATH='HCAL_bycicleGAN_test31'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LEARNING_RATE:0.0002\n",
      "BETA1:0.5\n",
      "BATCH_SIZE:16\n",
      "EPOCHS:4\n",
      "SAVE_SAMPLE_PERIOD:200\n",
      "SEED:1\n",
      "d_sizes:{'conv_layers': [(4.0, 4, 2, False, 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb302b0>), (8, 4, 2, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30470>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb304a8>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb304e0>), (64, 4, 1, 'bn', 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30518>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30550>), (8, False, 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30588>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb305c0>}\n",
      "g_sizes_dec:{'deconv_layers': [(64, 4, 2, 'bn', 1, <function softplus at 0x7f39a3f4f2f0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb305f8>), (32, 4, 2, 'bn', 0.8, <function softplus at 0x7f39a3f4f2f0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30630>), (16, 4, 2, 'bn', 1, <function softplus at 0x7f39a3f4f2f0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30668>), (8.0, 4, 2, 'bn', 1, <function softplus at 0x7f39a3f4f2f0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb306a0>), (1, 4, 2, False, 0.8, <function softplus at 0x7f39a3f4f2f0>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb306d8>)]}\n",
      "g_sizes_enc:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30710>), (16, 4, 2, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30748>), (32, 4, 2, 'bn', 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30780>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb307b8>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb307f0>)]}\n",
      "e_sizes:{'latent_dims': 16, 'conv_layers': [(8.0, 4, 2, False, 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30860>), (16, 4, 2, 'bn', 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30898>), (32, 4, 2, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb308d0>), (64, 4, 2, 'bn', 1, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30908>), (128, 4, 2, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30940>)], 'dense_layers': [(256, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30978>), (128, 'bn', 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb309b0>), (16, False, 0.8, <function lrelu at 0x7f399582ba60>, <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb309e8>)], 'readout_layer_w_init': <tensorflow.python.ops.init_ops.TruncatedNormal object at 0x7f398fb30a20>}\n",
      "preprocess:False\n",
      "cost_type:FEATURE\n",
      "validating_size:1000\n",
      "test_size:5000\n",
      "n_batches:1\n",
      "reco_path:/disk/lhcb_data/davide/HCAL_project/piplus_cells_inout/piplus/reco/\n",
      "true_path:/disk/lhcb_data/davide/HCAL_project/piplus_cells_inout/piplus/true/\n",
      "discr_steps:1\n",
      "gen_steps:4\n",
      "vae_steps:4\n",
      "latent_weight:100\n",
      "cycl_weight:10\n",
      "kl_weight:1\n"
     ]
    }
   ],
   "source": [
    "if task == 'TEST' and os.path.exists(PATH+'/hyper_parameters.pkl'):\n",
    "    with open(PATH+'/hyper_parameters.pkl', 'rb') as f:  \n",
    "        hyper_dict = pickle.load(f)\n",
    "        for key, item in hyper_dict.items():\n",
    "            print(key+':'+str(item))\n",
    "     \n",
    "    reco_path = hyper_dict['reco_path']\n",
    "    true_path = hyper_dict['true_path']\n",
    "    #true_path_p = hyper_dict['true_path_p']\n",
    "    #true_path_K = hyper_dict['true_path_K']\n",
    "    n_batches = hyper_dict['n_batches']\n",
    "    test_size = hyper_dict['test_size']\n",
    "    LEARNING_RATE = hyper_dict['LEARNING_RATE']\n",
    "    BETA1 = hyper_dict['BETA1']\n",
    "    BATCH_SIZE = hyper_dict['BATCH_SIZE']\n",
    "    EPOCHS = hyper_dict['EPOCHS']\n",
    "    SAVE_SAMPLE_PERIOD = hyper_dict['SAVE_SAMPLE_PERIOD']\n",
    "    SEED = hyper_dict['SEED']\n",
    "    d_sizes = hyper_dict['d_sizes']\n",
    "    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",
    "    latent_weight=hyper_dict['latent_weight']\n",
    "    kl_weight=hyper_dict['kl_weight']\n",
    "    discr_steps=hyper_dict['discr_steps']\n",
    "    gen_steps=hyper_dict['gen_steps']\n",
    "    \n",
    "\n",
    "if task == 'TEST' and not os.path.exists(PATH+'/hyper_parameters.pkl'):\n",
    "    \n",
    "    print('Missing hyperparameter dictionary in save folder')\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "true_path=\"/disk/lhcb_data/davide/HCAL_project/piplus_cells_inout/piplus/true/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim=1\n",
    "select=False\n",
    "test_size=4000\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",
    "    \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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "h=test_reco[0].shape[0]\n",
    "w=test_reco[0].shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def HCAL():\n",
    "\n",
    "    \n",
    "    tf.reset_default_graph()\n",
    "    \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",
    "                   discr_steps=discr_steps, gen_steps=gen_steps,\n",
    "                   batch_size=BATCH_SIZE, epochs=EPOCHS,\n",
    "                   save_sample=SAVE_SAMPLE_PERIOD, path=PATH, seed= SEED)\n",
    "    \n",
    "    vars_D = [v for v in tf.trainable_variables() if 'discriminator' in v.name]\n",
    "    vars_G = [v for v in tf.trainable_variables() if 'generator' in v.name]\n",
    "    vars_E = [v for v in tf.trainable_variables() if 'encoder' in v.name]\n",
    "    \n",
    "    if task == 'TEST':\n",
    "        \n",
    "        vars_to_train=tf.trainable_variables()\n",
    "        vars_all = tf.global_variables()\n",
    "        vars_to_init = list(set(vars_all)-set(vars_to_train))\n",
    "        init_op = tf.variables_initializer(vars_to_init)\n",
    "        \n",
    "        saver=tf.train.Saver()\n",
    "        \n",
    "    # Add ops to save and restore all the variables.\n",
    "    \n",
    "    gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.333)\n",
    "    \n",
    "    with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n",
    "        \n",
    "        sess.run(init_op)\n",
    "                       \n",
    "        if task=='TEST':\n",
    "            \n",
    "            print('\\n Evaluate model on test set...')\n",
    "            \n",
    "            #if os.path.exists(PATH+'/pretrained/'+PATH+'.ckpt.index'):\n",
    "            #    saver.restore(sess,PATH+'/'+PATH+'pretrained.ckpt')\n",
    "                \n",
    "            if os.path.exists(PATH+'/'+PATH+'bicycle.ckpt.index'):\n",
    "                saver.restore(sess, PATH+'/'+PATH+'bicycle.ckpt')\n",
    "                \n",
    "            print('Model restored.')\n",
    "            \n",
    "            gan.set_session(sess)\n",
    "        \n",
    "        #test_reco_NN=gan.get_samples_A_to_B(test_true.reshape(test_true.shape[0],n_H_A,n_W_A,n_C))\n",
    "        test_reco_NN=np.zeros_like(test_true)\n",
    "        for i in range(len(test_true)):\n",
    "            test_reco_NN[i]=gan.get_sample_A_to_B(test_true[i].reshape(1,n_H_A,n_W_A,n_C))\n",
    "\n",
    "        done = True\n",
    "        while not done:\n",
    "            \n",
    "\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",
    "                              f=gan.get_sample_A_to_B, save=False, is_training=False)\n",
    "            \n",
    "            ans = input(\"Generate another?\")\n",
    "            if ans and ans[0] in ('n' or 'N'):\n",
    "                done = True\n",
    "        \n",
    "        done = True\n",
    "        while not done:\n",
    "            \n",
    "            if preprocess:\n",
    "                draw_nn_sample(test_true, test_reco, 20, 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)\n",
    "            else:\n",
    "                draw_nn_sample(test_true, test_reco, 20, preprocess,\n",
    "                              f=gan.get_sample_A_to_B, save=False, is_training=False)\n",
    "                \n",
    "            ans = input(\"Generate another?\")\n",
    "            if ans and ans[0] in ('n' or 'N'):\n",
    "                done = True\n",
    "        \n",
    "        return test_reco_NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Convolutional Network architecture detected for discriminator B\n",
      "Convolutional Network architecture detected for encoder B\n",
      "Encoder_B\n",
      "Convolution\n",
      "Input for convolution shape  (?, 52, 64, 1)\n",
      "Encoder output shape (?, 16)\n",
      "Generator_A_to_B\n",
      "Input for generator encoded shape (?, 52, 64, 1)\n",
      "Output of generator encoder, \n",
      " and input for generator decoder shape (?, 1, 1, 512)\n",
      "Generator output shape (?, 52, 64, 1)\n",
      "Generator_A_to_B\n",
      "Input for generator encoded shape (?, 52, 64, 1)\n",
      "Output of generator encoder, \n",
      " and input for generator decoder shape (?, 1, 1, 512)\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",
      "Discriminator_B\n",
      "Input for convolution shape  (?, 52, 64, 1)\n",
      "Feature output shape (?, 8)\n",
      "minibatch features shape (?, 10)\n",
      "Logits shape (?, 1)\n",
      "Discriminator_B\n",
      "Input for convolution shape  (?, 52, 64, 1)\n",
      "Feature output shape (?, 8)\n",
      "minibatch features shape (?, 10)\n",
      "Logits shape (?, 1)\n",
      "Discriminator_B\n",
      "Input for convolution shape  (?, 52, 64, 1)\n",
      "Feature output shape (?, 8)\n",
      "minibatch features shape (?, 10)\n",
      "Logits shape (?, 1)\n",
      "Generator_A_to_B\n",
      "Input for generator encoded shape (?, 52, 64, 1)\n",
      "Output of generator encoder, \n",
      " and input for generator decoder shape (?, 1, 1, 512)\n",
      "Generator output shape (?, 52, 64, 1)\n",
      "\n",
      " Evaluate model on test set...\n",
      "INFO:tensorflow:Restoring parameters from HCAL_bycicleGAN_test31/HCAL_bycicleGAN_test31bicycle.ckpt\n",
      "Model restored.\n"
     ]
    }
   ],
   "source": [
    "if __name__=='__main__':\n",
    "\n",
    "    if task == 'TEST': \n",
    "        if not os.path.exists(PATH+'/checkpoint'):\n",
    "            print('No checkpoint to test')\n",
    "        else:\n",
    "            test_reco_NN =HCAL()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "if preprocess:\n",
    "    test_reco=denormalise(test_reco, min_reco, max_reco)\n",
    "    reco_MC_hist = test_reco.reshape(test_reco.shape[0], test_reco.shape[1]*test_reco.shape[2])\n",
    "    reco_MC_hist = np.sum(reco_MC_hist,axis=1)\n",
    "    max_E=np.max(reco_MC_hist)\n",
    "    \n",
    "    test_reco_NN=denormalise(test_reco_NN, min_reco, max_reco)\n",
    "    reco_NN_hist = test_reco_NN.reshape(test_reco_NN.shape[0], test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
    "    reco_NN_hist = np.sum(reco_NN_hist,axis=1)\n",
    "    max_NN = np.max(reco_NN_hist)\n",
    "    \n",
    "    test_true=denormalise(test_true, min_true, max_true)\n",
    "    true_hist = test_true.reshape(test_true.shape[0], test_true.shape[1]*test_true.shape[2])\n",
    "    true_hist = np.sum(true_hist,axis=1)\n",
    "    max_true_E=np.max(true_hist)\n",
    "else:\n",
    "    reco_MC_hist = test_reco.reshape(test_reco.shape[0], test_reco.shape[1]*test_reco.shape[2])\n",
    "    reco_MC_hist = np.sum(reco_MC_hist,axis=1)\n",
    "    max_E=np.max(reco_MC_hist)\n",
    "    \n",
    "    reco_NN_hist = test_reco_NN.reshape(test_reco_NN.shape[0], test_reco_NN.shape[1]*test_reco_NN.shape[2])\n",
    "    reco_NN_hist = np.sum(reco_NN_hist,axis=1)\n",
    "    max_NN = np.max(reco_NN_hist)\n",
    "    \n",
    "    true_hist = test_true.reshape(test_true.shape[0], test_true.shape[1]*test_true.shape[2])\n",
    "    true_hist = np.sum(true_hist,axis=1)\n",
    "    max_true_E=np.max(true_hist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max NN 6096.728515625, Max_MC 6120.0, Max NN rescaled 6120.0\n"
     ]
    }
   ],
   "source": [
    "max_NN=test_reco_NN.max()\n",
    "max_MC=test_reco.max()\n",
    "test_reco_NN_rescaled=(test_reco_NN/test_reco_NN.max())*max_MC\n",
    "print('Max NN {0}, Max_MC {1}, Max NN rescaled {2}'.format(max_NN, max_MC, test_reco_NN_rescaled.max()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_reco_inner = get_inner_HCAL(test_reco)\n",
    "test_reco_outer = get_outer_HCAL(test_reco)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_reco_inner_NN = get_inner_HCAL(test_reco_NN_rescaled)\n",
    "test_reco_outer_NN = get_outer_HCAL(test_reco_NN_rescaled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_true=test_true.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices_MC, triggered_true_MC, triggered_reco_inner_MC, triggered_reco_outer_MC = get_triggered_events(test_true, test_reco_inner, test_reco_outer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices_NN, triggered_true_NN, triggered_reco_inner_NN, triggered_reco_outer_NN = get_triggered_events(test_true, test_reco_inner_NN, test_reco_outer_NN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a_MC=plt.hist(triggered_true_MC/1000,bins=40,histtype='step', range=(0, max_true/1000), label='MC Triggered events')\n",
    "a_NN=plt.hist(triggered_true_NN/1000,bins=40,histtype='step', range=(0, max_true/1000), label='NN Triggered events')\n",
    "b=plt.hist(true_hist/1000,bins=40,histtype='step', range=(0, max_true/1000), label='ET from Tracking')\n",
    "plt.tick_params(labelsize='xx-large')\n",
    "plt.xlabel('ET (GeV)', fontsize=20)\n",
    "plt.ylabel('dN/dET (a.u.)', fontsize=20)\n",
    "plt.legend(fontsize='xx-large')\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(20,10)\n",
    "plt.savefig(PATH+'/eff_1.png',dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  1.,  12.,  50.,  90., 129., 159., 189., 210., 193., 215., 211.,\n",
       "        194., 205., 193., 172., 151., 134., 127., 131., 111., 112.,  87.,\n",
       "         87.,  64.,  61.,  58.,  37.,  35.,  37.,  26.,  26.,  21.,  14.,\n",
       "         14.,  14.,   6.,   3.,   0.,   0.,   1.]),\n",
       " array([ 0.        ,  0.50833315,  1.01666631,  1.52499946,  2.03333262,\n",
       "         2.54166577,  3.04999893,  3.55833208,  4.06666523,  4.57499839,\n",
       "         5.08333154,  5.5916647 ,  6.09999785,  6.60833101,  7.11666416,\n",
       "         7.62499731,  8.13333047,  8.64166362,  9.14999678,  9.65832993,\n",
       "        10.16666309, 10.67499624, 11.18332939, 11.69166255, 12.1999957 ,\n",
       "        12.70832886, 13.21666201, 13.72499517, 14.23332832, 14.74166147,\n",
       "        15.24999463, 15.75832778, 16.26666094, 16.77499409, 17.28332725,\n",
       "        17.7916604 , 18.29999355, 18.80832671, 19.31665986, 19.82499302,\n",
       "        20.33332617]),\n",
       " <a list of 1 Patch objects>)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_MC\n",
    "a_NN\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_MC = np.zeros_like(b[0])\n",
    "eff_NN = np.zeros_like(b[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(b[0])):\n",
    "    if b[0][i]!=0:\n",
    "        eff_MC[i]=a_MC[0][i]/b[0][i]\n",
    "        eff_NN[i]=a_NN[0][i]/b[0][i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "eff_MC;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = np.arange(0,max_true/1000, step=(max_true/1000)/40)\n",
    "\n",
    "plt.bar(idx,eff_NN, width=0.4, label='Efficiency simulated by NN')\n",
    "plt.bar(idx,eff_MC, width=0.2, 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",
    "plt.ylabel('eff (a.u.)', fontsize=20)\n",
    "fig = plt.gcf()\n",
    "fig.set_size_inches(20,10)\n",
    "plt.savefig(PATH+'/eff_2.png',dpi=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}