emsim.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from emsim import training as tr\n",
    "from emsim import emnet\n",
    "from emsim import emsim_utils\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.autograd import Variable\n",
    "\n",
    "import cv2\n",
    "\n",
    "from emsim.unet import UNet\n",
    "import scipy.optimize as optimize\n",
    "from scipy.optimize import curve_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Write events to a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "datfile = \"/home/matt/Code/emsim/data/pixelated_tracks_thinned_4um_back_10M_300keV.txt\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'datfile' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[39m# Read a new dataset.\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m df \u001b[39m=\u001b[39m emsim_utils\u001b[39m.\u001b[39mread_electron_data(datfile,nevts\u001b[39m=\u001b[39m\u001b[39m200005\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'datfile' is not defined"
     ]
    }
   ],
   "source": [
    "# Read a new dataset.\n",
    "df = emsim_utils.read_electron_data(datfile,nevts=200005)\n",
    "# df.to_pickle(\"EM_4um_back_10M_300keV.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>event</th>\n",
       "      <th>xinc</th>\n",
       "      <th>yinc</th>\n",
       "      <th>front</th>\n",
       "      <th>energy</th>\n",
       "      <th>row</th>\n",
       "      <th>col</th>\n",
       "      <th>counts</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>-0.001015</td>\n",
       "      <td>0.002377</td>\n",
       "      <td>False</td>\n",
       "      <td>0.3</td>\n",
       "      <td>48</td>\n",
       "      <td>48</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>-0.001015</td>\n",
       "      <td>0.002377</td>\n",
       "      <td>False</td>\n",
       "      <td>0.3</td>\n",
       "      <td>48</td>\n",
       "      <td>50</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>-0.001015</td>\n",
       "      <td>0.002377</td>\n",
       "      <td>False</td>\n",
       "      <td>0.3</td>\n",
       "      <td>48</td>\n",
       "      <td>52</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>-0.001015</td>\n",
       "      <td>0.002377</td>\n",
       "      <td>False</td>\n",
       "      <td>0.3</td>\n",
       "      <td>49</td>\n",
       "      <td>46</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>-0.001015</td>\n",
       "      <td>0.002377</td>\n",
       "      <td>False</td>\n",
       "      <td>0.3</td>\n",
       "      <td>49</td>\n",
       "      <td>48</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   event      xinc      yinc  front  energy  row  col  counts\n",
       "0      1 -0.001015  0.002377  False     0.3   48   48       2\n",
       "1      1 -0.001015  0.002377  False     0.3   48   50       1\n",
       "2      1 -0.001015  0.002377  False     0.3   48   52       1\n",
       "3      1 -0.001015  0.002377  False     0.3   49   46       1\n",
       "4      1 -0.001015  0.002377  False     0.3   49   48       7"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "199996"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df.event.unique())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate random multi-electron events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created dataset for events from 0 to 198917\n"
     ]
    }
   ],
   "source": [
    "dset = tr.EMDataset(\"data/EM_5um_front_3M_100keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=False,add_shift=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frameset  = tr.EMFrameDataset(dset,frame_size=20,nelec_mean=2,nelec_sigma=0.1,noise_mean=683,noise_sigma=11.2,m_line=-2.0,b_line=30.0, lside = 0, res_factor=3)\n",
    "#frameset = tr.EMFrameDataset(dset,frame_size=4855,nelec_mean=103713,nelec_sigma=0.5,noise_mean=683,noise_sigma=11.2)\n",
    "#frameset = tr.EMFrameDataset(dset,frame_size=100,nelec_mean=88,nelec_sigma=2,noise_mean=0,noise_sigma=20)\n",
    "#frameset = tr.EMFrameDataset(dset,frame_size=100,nelec_mean=10,nelec_sigma=1,noise_mean=0,noise_sigma=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Generate many frames and fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit_line(fit_img, th = 0.5, pct_rng = 0.2, nbins_hdist = 80):\n",
    "    \n",
    "    A = fit_img/np.mean(fit_img)\n",
    "    nrows = A.shape[0]\n",
    "    ncols = A.shape[1]\n",
    "    ncts = np.sum(A[A >= th])\n",
    "    nzeros = np.sum(1-A[A < th])\n",
    "    wcts = 1 #nzeros/ncts\n",
    "    indices = np.indices((nrows,ncols))\n",
    "    irows = indices[0]\n",
    "    icols = indices[1]\n",
    "    print(\"nzeros = {}, ncts = {}, wcts = {}\".format(nzeros,ncts,wcts))\n",
    "\n",
    "    def count_loss(x):\n",
    "        m,b = x\n",
    "\n",
    "        # The loss L is:\n",
    "        #\n",
    "        # (number of 0s in the dark region) - wcts*(number of 1s in the dark region)\n",
    "        # + wcts*(number of 1s in the light region) - (number of 0s in the dark region)\n",
    "        # \n",
    "        # where wcts is the count weight, determined such that the number of counts multiplied by wcts is equal to\n",
    "        # the number of zeros.\n",
    "        L = 0\n",
    "        L1 = np.sum(1-A[(irows < m*icols + b) & (A < th)])\n",
    "        L2 = np.sum(A[(irows < m*icols + b) & (A >= th)])\n",
    "        L3 = np.sum(A[(irows >= m*icols + b) & (A >= th)])\n",
    "        L4 = np.sum(1-A[(irows >= m*icols + b) & (A < th)])\n",
    "\n",
    "        L = L1 - wcts*L2 + wcts*L3 - L4\n",
    "        #print(\"Loss is:\",-L,\"with L1 =\",L1,\"L2 =\",L2,\"L3 =\",L3,\"L4 =\",L4)\n",
    "        return -L\n",
    "    \n",
    "    initial_guess = [-1.5*nrows/ncols,2.0*nrows]\n",
    "    result = optimize.minimize(count_loss,initial_guess,method='Nelder-Mead',tol=1e-5)\n",
    "    m,b = result.x\n",
    "    Lmin = result.fun\n",
    "    print(\"m = \",m,\"b = \",b,\"Lmin=\",Lmin)\n",
    "    \n",
    "    # Force m and b.\n",
    "    m = -2.0\n",
    "    b = 90.0\n",
    "    print(\"NOTE: hard-coding m and b\")\n",
    "    \n",
    "    # Get the loss over a range of the parameters.\n",
    "    mrng = np.arange(m-pct_rng*m, m+pct_rng*m, 2*pct_rng*m/1000)\n",
    "    Lrng_m = np.array([count_loss([mval,b])/Lmin for mval in mrng])\n",
    "    brng = np.arange(b-pct_rng*b, b+pct_rng*b, 2*pct_rng*b/1000)\n",
    "    Lrng_b = np.array([count_loss([m,bval])/Lmin for bval in brng])\n",
    "    \n",
    "    # Get the histogram of mean value vs. distance.\n",
    "    dist = (5./3.)*(m*icols - irows + b) / (m**2 + 1)                          # compute distance to line for each point\n",
    "    hw, bb = np.histogram(dist.flatten(),weights=A.flatten(),bins=nbins_hdist)  # weighted histogram\n",
    "    hh, bb = np.histogram(dist.flatten(),bins=nbins_hdist)                      # unweighted (for normalization)\n",
    "    hh[hh == 0] = 0.1\n",
    "    hfinal = hw / hh                                                   # normalize the histogram\n",
    "    bcenters = (bb[1:] + bb[:-1]) / 2                                  # determine the bin centers\n",
    "    \n",
    "    return m,b,Lmin,mrng,Lrng_m,brng,Lrng_b,hfinal,bcenters\n",
    "\n",
    "# Fit the S-curve to a sigmoid.\n",
    "def fit_scurve():\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create some number of events and count them.\n",
    "th_unet = 0.2\n",
    "th_classical = 825/4.\n",
    "evts = np.arange(0,100000)\n",
    "l_frames, l_labels, l_ct_unet, l_ct_classical = [], [], [], []\n",
    "for evt in evts:\n",
    "    frame,label = frameset[evt]\n",
    "    gnd_truth = label[0]\n",
    "    \n",
    "    # Send through the model.\n",
    "    data = torch.tensor(frame).float().unsqueeze(0).unsqueeze(1).cuda()\n",
    "    output_score = model(data)\n",
    "    \n",
    "    # Compute the predicted pixel values.\n",
    "    prob = np.array(sigmoid(output_score).cpu().detach().numpy()).squeeze()\n",
    "    ct_unet = (prob > th_unet)\n",
    "    \n",
    "    # Count with a single threshold.\n",
    "    #ct_classical = (frame > th_classical)\n",
    "    \n",
    "    # Max argument classical truth.\n",
    "    #ct_classical = np.zeros(frame.shape)\n",
    "    #ct_classical[np.unravel_index(np.argmax(frame),frame.shape)] = 1\n",
    "    \n",
    "    # Threshold truth.\n",
    "    ct_classical = label[1]\n",
    "    \n",
    "    l_frames.append(frame)\n",
    "    l_labels.append(gnd_truth)\n",
    "    l_ct_unet.append(ct_unet)\n",
    "    l_ct_classical.append(ct_classical)\n",
    "    \n",
    "    if((evt-evts[0]) % (len(evts)/100) == 0):\n",
    "            print(\"{}% done\".format(int((evt-evts[0]) / (len(evts)/100))))\n",
    "            \n",
    "l_frames = np.array(l_frames)\n",
    "l_labels = np.array(l_labels)\n",
    "l_ct_unet = np.array(l_ct_unet)\n",
    "l_ct_classical = np.array(l_ct_classical)\n",
    "\n",
    "# Create a summed frame, label, and count arrays.\n",
    "frame = np.sum(l_frames,axis=0)\n",
    "label = np.sum(l_labels,axis=0)\n",
    "ct_unet = np.sum(l_ct_unet,axis=0)\n",
    "ct_classical = np.sum(l_ct_classical,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "raw_th = 0.99\n",
    "ct_th = 0.1\n",
    "m_frame,b_frame,Lmin_frame,mrng_frame,Lrng_m_frame,brng_frame,Lrng_b_frame,hdist_frame,bcenters_frame = fit_line(frame,th=raw_th)\n",
    "m_label,b_label,Lmin_label,mrng_label,Lrng_m_label,brng_label,Lrng_b_label,hdist_label,bcenters_label = fit_line(label,th=ct_th)\n",
    "m_unet,b_unet,Lmin_unet,mrng_unet,Lrng_m_unet,brng_unet,Lrng_b_unet,hdist_unet,bcenters_unet = fit_line(ct_unet,th=ct_th)\n",
    "m_classical,b_classical,Lmin_classical,mrng_classical,Lrng_m_classical,brng_classical,Lrng_b_classical,hdist_classical,bcenters_classical = fit_line(ct_classical,th=ct_th)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#frame,label = frameset[0]\n",
    "logscale = False\n",
    "nrows = frame.shape[0]\n",
    "ncols = frame.shape[1]\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(12.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "ax1 = fig.add_subplot(221)\n",
    "if(logscale):\n",
    "    plt.imshow(np.log(frame))\n",
    "    cbar = plt.colorbar()\n",
    "    cbar.set_label(\"log(counts)\")\n",
    "    #plt.title(\"Raw frame (log counts, threshold = {})\\nm = {:.2f}, b = {:.2f}\".format(raw_th,m_frame,b_frame))\n",
    "    plt.title(\"Raw frame (log counts)\\nm = {:.2f}, b = {:.2f}\".format(m_frame,b_frame))\n",
    "else:\n",
    "    plt.imshow(frame/np.max(frame))\n",
    "    cbar = plt.colorbar()\n",
    "    #plt.title(\"Raw frame (threshold = {})\\nm = {:.2f}, b = {:.2f}\".format(raw_th,m_frame,b_frame))\n",
    "    plt.title(\"Raw frame\\nm = {:.2f}, b = {:.2f}\".format(m_frame,b_frame))\n",
    "xfit = np.arange(0,ncols-1,0.1)\n",
    "yfit = m_frame*xfit + b_frame\n",
    "plt.plot(xfit[(yfit > 0) & (yfit < nrows-1)],yfit[(yfit > 0) & (yfit < nrows-1)],color='red',linewidth=2)\n",
    "\n",
    "ax2 = fig.add_subplot(222)\n",
    "plt.imshow(label/np.max(label))\n",
    "#plt.title(\"Truth (threshold = {})\\nm = {:.2f}, b = {:.2f}\".format(ct_th,m_label,b_label))\n",
    "plt.title(\"Truth\\nm = {:.2f}, b = {:.2f}\".format(m_label,b_label))\n",
    "plt.colorbar()\n",
    "xfit = np.arange(0,ncols-1,0.1)\n",
    "yfit = m_label*xfit + b_label\n",
    "plt.plot(xfit[(yfit > 0) & (yfit < nrows-1)],yfit[(yfit > 0) & (yfit < nrows-1)],color='red',linewidth=2)\n",
    "\n",
    "ax3 = fig.add_subplot(223)\n",
    "plt.imshow(ct_unet/np.max(ct_unet))\n",
    "#plt.title(\"UNet counts (threshold = {})\\nm = {:.2f}, b = {:.2f}\".format(ct_th,m_unet,b_unet))\n",
    "plt.title(\"UNet counts\\nm = {:.2f}, b = {:.2f}\".format(m_unet,b_unet))\n",
    "plt.colorbar()\n",
    "xfit = np.arange(0,ncols-1,0.1)\n",
    "yfit = m_unet*xfit + b_unet\n",
    "plt.plot(xfit[(yfit > 0) & (yfit < nrows-1)],yfit[(yfit > 0) & (yfit < nrows-1)],color='red',linewidth=2)\n",
    "\n",
    "ax4 = fig.add_subplot(224)\n",
    "plt.imshow(ct_classical/np.max(ct_classical))\n",
    "#plt.title(\"Classical counts + line info (threshold = {})\\nm = {:.2f}, b = {:.2f}\".format(ct_th,m_classical,b_classical))\n",
    "plt.title(\"Classical counts + line info\\nm = {:.2f}, b = {:.2f}\".format(m_classical,b_classical))\n",
    "plt.colorbar()\n",
    "xfit = np.arange(0,ncols-1,0.1)\n",
    "yfit = m_classical*xfit + b_classical\n",
    "plt.plot(xfit[(yfit > 0) & (yfit < nrows-1)],yfit[(yfit > 0) & (yfit < nrows-1)],color='red',linewidth=2)\n",
    "\n",
    "print(\"Total counts, truth:\",np.sum(label))\n",
    "print(\"Total counts, classical:\",np.sum(ct_classical))\n",
    "print(\"Total counts, unet:\",np.sum(ct_unet))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "frame_mult = 1./(1.-min(hdist_frame))\n",
    "\n",
    "ax1 = fig.add_subplot(121)\n",
    "plt.plot(bcenters_frame,frame_mult*(hdist_frame-min(hdist_frame)),'.-',color='black',label='frame')\n",
    "plt.plot(bcenters_label,hdist_label,'.-',color='green',label='true')\n",
    "plt.plot(bcenters_unet,hdist_unet,'.-',color='blue',label='UNet')\n",
    "plt.plot(bcenters_classical,hdist_classical,'.-',color='red',label='classical+line')\n",
    "plt.xlim([-10,10])\n",
    "plt.ylim([0.0,3.2])\n",
    "plt.xlabel(\"Distance from line (micrometers)\")\n",
    "plt.ylabel(\"Mean number of normalized counts\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save s-curve information.\n",
    "np.savez(\"scurve_edge_th02_epoch10.npz\", bcenters_frame=bcenters_frame, hdist_frame=hdist_frame, bcenters_label=bcenters_label, hdist_label=hdist_label, \n",
    "         bcenters_unet=bcenters_unet, hdist_unet=hdist_unet, bcenters_classical=bcenters_classical, \n",
    "         hdist_classical=hdist_classical)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "ax1 = fig.add_subplot(121)\n",
    "plt.plot(mrng_frame/m_frame,Lrng_m_frame,color='black',label='frame')\n",
    "plt.plot(mrng_label/m_label,Lrng_m_label,color='green',label='true')\n",
    "plt.plot(mrng_unet/m_unet,Lrng_m_unet,color='blue',label='UNet')\n",
    "plt.plot(mrng_classical/m_classical,Lrng_m_classical,color='red',label='classical')\n",
    "plt.xlabel(\"Parameter m/m$_0$\")\n",
    "plt.ylabel(\"Relative loss L/L(m$_0$)\")\n",
    "plt.legend()\n",
    "\n",
    "ax2 = fig.add_subplot(122)\n",
    "plt.plot(brng_frame/b_frame,Lrng_b_frame,color='black',label='frame')\n",
    "plt.plot(brng_label/b_label,Lrng_b_label,color='green',label='true')\n",
    "plt.plot(brng_unet/b_unet,Lrng_b_unet,color='blue',label='UNet')\n",
    "plt.plot(brng_classical/b_classical,Lrng_b_classical,color='red',label='classical')\n",
    "plt.xlabel(\"Parameter b/b$_0$\")\n",
    "plt.ylabel(\"Relative loss L/L(b$_0$)\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez(\"evt_arrays.npz\",evt_arrays=l_evt_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plot s-curve data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scurve_noedge = np.load(\"scurve_noedge_th088.npz\")\n",
    "bc_label_noedge = scurve_noedge['bcenters_label']\n",
    "h_label_noedge = scurve_noedge['hdist_label']\n",
    "bc_unet_noedge = scurve_noedge['bcenters_unet']\n",
    "h_unet_noedge = scurve_noedge['hdist_unet']\n",
    "bc_classical_noedge = scurve_noedge['bcenters_classical']\n",
    "h_classical_noedge = scurve_noedge['hdist_classical']\n",
    "\n",
    "scurve_edge = np.load(\"scurve_edge_th08.npz\")\n",
    "bc_frame_edge = scurve_edge['bcenters_frame']\n",
    "h_frame_edge = scurve_edge['hdist_frame']\n",
    "bc_label_edge = scurve_edge['bcenters_label']\n",
    "h_label_edge = scurve_edge['hdist_label']\n",
    "bc_unet_edge = scurve_edge['bcenters_unet']\n",
    "h_unet_edge = scurve_edge['hdist_unet']\n",
    "bc_classical_edge = scurve_edge['bcenters_classical']\n",
    "h_classical_edge = scurve_edge['hdist_classical']\n",
    "\n",
    "scurve_edge10 = np.load(\"scurve_edge_th08_epoch10.npz\")\n",
    "bc_label_edge10 = scurve_edge10['bcenters_label']\n",
    "h_label_edge10 = scurve_edge10['hdist_label']\n",
    "bc_unet_edge10 = scurve_edge10['bcenters_unet']\n",
    "h_unet_edge10 = scurve_edge10['hdist_unet']\n",
    "bc_classical_edge10 = scurve_edge10['bcenters_classical']\n",
    "h_classical_edge10 = scurve_edge10['hdist_classical']\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "frame_mult = 1./(1.-min(h_frame_edge))\n",
    "\n",
    "ax1 = fig.add_subplot(111)\n",
    "plt.plot(bc_frame_edge,frame_mult*(h_frame_edge-min(h_frame_edge)),'.-',color='black',label='raw frame, scaled')\n",
    "plt.plot(bc_classical_edge,h_classical_edge,'.-',color='red',label='classical')\n",
    "plt.plot(bc_unet_noedge,h_unet_noedge,'.-',color='orange',label='UNet, no edge, epoch 500')\n",
    "plt.plot(bc_unet_edge10,h_unet_edge10,'.-',color='cyan',label='UNet + edge, epoch 11')\n",
    "plt.plot(bc_unet_edge,h_unet_edge,'.-',color='blue',label='UNet + edge, epoch 500')\n",
    "plt.plot(bc_label_edge,h_label_edge,'.-',color='green',label='true')\n",
    "plt.xlim([-5,5])\n",
    "plt.ylim([0.0,1.0])\n",
    "plt.xlabel(\"Distance from line (pixels)\")\n",
    "plt.ylabel(\"Mean number of normalized counts\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Examine a large generated frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(label[0,0:50,0:50])\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_sim = frame.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#plt.hist(img_sim[(img_sim < 400)],bins=50)\n",
    "plt.hist(img_sim,bins=50)\n",
    "plt.xlabel(\"Pixel values\")\n",
    "plt.ylabel(\"Counts/bin\")\n",
    "plt.yscale(\"log\")\n",
    "print(\"Total pixels:\",len(img_sim))\n",
    "#plt.xlim([0,500])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez(\"frame_4855x4855_11occ.npz\",frame=frame)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train a network (multi-electron)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Created dataset for events from 0 to 198917\n"
     ]
    }
   ],
   "source": [
    "modeldir = '/home/jrenner/local/jerenner/emsim/models/old'\n",
    "lrate       = 1e-3   # Learning rate to use in the training.\n",
    "load_model  = True   # Load an existing model\n",
    "tr.augment  = False  # Enable/disable data augmentation\n",
    "epoch_start = 0      # Number of initial epoch\n",
    "epoch_end   = 200    # Number of final epoch\n",
    "model_load_checkpoint = \"{}/model_frames_50x50_noise683_11_front_100kev_77.pt\".format(modeldir)\n",
    "\n",
    "# Create the dataset.\n",
    "# 576x576: 2927 +/- 71\n",
    "# 100x100: 88 +/- 2\n",
    "# 50x50: 22 +/- 0.5\n",
    "#dset = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=False,add_shift=0)\n",
    "\n",
    "# \"Real-data-like\" dataset: occupancy 11, noise_mean=683, noise_sigma=11.2\n",
    "dset = tr.EMDataset(\"dataframes/EM_5um_front_3M_100keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=False,add_shift=0)\n",
    "#dataset_train   = tr.EMFrameDataset(dset,frame_size=50,nelec_mean=11,nelec_sigma=0.5,noise_mean=683,noise_sigma=11.2)\n",
    "dataset_train = tr.EMFrameDataset(dset,frame_size=20,nelec_mean=2,nelec_sigma=0.1,noise_mean=683,noise_sigma=11.2,m_line=-2.0,b_line=30.0,res_factor=3)\n",
    "\n",
    "# Create the loaders.\n",
    "train_loader = DataLoader(dataset_train, batch_size=50, shuffle=False, collate_fn=tr.my_collate_unet, num_workers=1)\n",
    "\n",
    "# Define the model.\n",
    "model = UNet(n_channels=1, n_classes=1)\n",
    "model.cuda()\n",
    "\n",
    "optimizer = optim.RMSprop(model.parameters(), lr=lrate, weight_decay=1e-8, momentum=0.9)\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min', patience=2)\n",
    "\n",
    "# Load the model from file.\n",
    "if(load_model):\n",
    "    model.load_state_dict(torch.load(model_load_checkpoint))\n",
    "    #model.load_state_dict(torch.load(model_load_checkpoint,map_location=torch.device('cpu')))\n",
    "    model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Run the training.\n",
    "for epoch in range(epoch_start,epoch_end):\n",
    "    print(\"Epoch: \",epoch)\n",
    "    model.train()\n",
    "    train_loss = tr.train_unet(model, epoch, train_loader, optimizer)\n",
    "    scheduler.step(train_loss)\n",
    "    #if(epoch % 50 == 0):\n",
    "    torch.save(model.state_dict(), \"{}/model_init_{}.pt\".format(modeldir,epoch))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), \"{}/model_frames_20x20_noise683_2e_bcsloss_edge_unweighted_front_1em4_100kev_{}.pt\".format(modeldir,epoch))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the training loss and accuracy.\n",
    "tloss = np.loadtxt(\"train.txt\")\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "ax1 = fig.add_subplot(121);\n",
    "plt.plot(tloss[:,0],tloss[:,1],label='training')\n",
    "plt.legend()\n",
    "plt.title(\"Loss\")\n",
    "plt.yscale('log')\n",
    "\n",
    "ax2 = fig.add_subplot(122);\n",
    "plt.plot(tloss[:,0],tloss[:,2],label='training')\n",
    "plt.legend()\n",
    "plt.title(\"Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test the net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UNet(\n",
       "  (inc): DoubleConv(\n",
       "    (double_conv): Sequential(\n",
       "      (0): Conv2d(1, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): ReLU(inplace=True)\n",
       "      (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): ReLU(inplace=True)\n",
       "    )\n",
       "  )\n",
       "  (down1): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (1): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU(inplace=True)\n",
       "          (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): ReLU(inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down2): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (1): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU(inplace=True)\n",
       "          (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): ReLU(inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down3): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (1): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU(inplace=True)\n",
       "          (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): ReLU(inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (down4): Down(\n",
       "    (maxpool_conv): Sequential(\n",
       "      (0): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (1): DoubleConv(\n",
       "        (double_conv): Sequential(\n",
       "          (0): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (2): ReLU(inplace=True)\n",
       "          (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "          (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "          (5): ReLU(inplace=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up1): Up(\n",
       "    (up): Upsample(scale_factor=2.0, mode=bilinear)\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU(inplace=True)\n",
       "        (3): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): ReLU(inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up2): Up(\n",
       "    (up): Upsample(scale_factor=2.0, mode=bilinear)\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU(inplace=True)\n",
       "        (3): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): ReLU(inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up3): Up(\n",
       "    (up): Upsample(scale_factor=2.0, mode=bilinear)\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU(inplace=True)\n",
       "        (3): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): ReLU(inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (up4): Up(\n",
       "    (up): Upsample(scale_factor=2.0, mode=bilinear)\n",
       "    (conv): DoubleConv(\n",
       "      (double_conv): Sequential(\n",
       "        (0): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (2): ReLU(inplace=True)\n",
       "        (3): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (4): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "        (5): ReLU(inplace=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (outc): OutConv(\n",
       "    (conv): Conv2d(16, 1, kernel_size=(1, 1), stride=(1, 1))\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigmoid = nn.Sigmoid()\n",
    "#dset = tr.EMDataset(\"dataframes/EM_5um_front_3M_100keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=False,add_shift=0)\n",
    "#dataset_train   = tr.EMFrameDataset(dset,frame_size=50,nelec_mean=11,nelec_sigma=0.5,noise_mean=683,noise_sigma=11.2)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Loop over many events and evaluate the true positives and false positives.\n",
    "# Store in arrays as:\n",
    "#\n",
    "#  [tp0 tp1 tp2 tp3 ... tpN], each number corresponding to a different NN threshold or classical threshold\n",
    "#\n",
    "tp_unet = []; fp_unet = []\n",
    "tp_classical = []; fp_classical = []\n",
    "#nn_thresholds = np.arange(0.05,1.0,0.1)\n",
    "nn_thresholds = np.concatenate((np.logspace(-4,-0.1,500), np.logspace(-0.1,0,500)))\n",
    "#nn_thresholds = np.logspace(-3,0,1000)\n",
    "classical_thresholds = np.arange(600/4,7000/4,10)\n",
    "evts = np.arange(100000,101000)\n",
    "for evt in evts:\n",
    "    \n",
    "    # Get the event and truth.\n",
    "    evt_item = dataset_train[evt]\n",
    "    evt_arr = evt_item[0]\n",
    "    evt_lbl = evt_item[1][0]\n",
    "    \n",
    "    # Send through the model.\n",
    "    data = torch.tensor(evt_arr).float().unsqueeze(0).unsqueeze(1).cuda()\n",
    "    output_score = model(data)\n",
    "    \n",
    "    # Compute the predicted pixel values.\n",
    "    prob = np.array(sigmoid(output_score).cpu().detach().numpy()).squeeze()\n",
    "    \n",
    "    # Compute the TP and FP values for unet.\n",
    "    temp_tp = []; temp_fp = []\n",
    "    for th in nn_thresholds:\n",
    "        pred = (prob > th)\n",
    "        tp = np.sum((evt_lbl == 1) & (pred == True))\n",
    "        fn = np.sum((evt_lbl == 1) & (pred == False))\n",
    "        if( (tp + fn) > 0): tp = tp / (tp + fn)\n",
    "        else: tp = 1\n",
    "        fp = np.sum((evt_lbl == 0) & (pred == True))\n",
    "        tn = np.sum((evt_lbl == 0) & (pred == False))\n",
    "        if( (fp + tn) > 0): fp = fp / (fp + tn)\n",
    "        else: fp = 0\n",
    "        temp_tp.append(tp)\n",
    "        temp_fp.append(fp)\n",
    "    tp_unet.append(temp_tp)\n",
    "    fp_unet.append(temp_fp)\n",
    "    \n",
    "    # Compute the TP and FP values for the classical threshold.\n",
    "    temp_tp = []; temp_fp = []\n",
    "    for th in classical_thresholds:\n",
    "        #pred = (evt_arr > th)\n",
    "        pred = np.zeros(evt_arr.shape)\n",
    "        pred[np.unravel_index(np.argmax(evt_arr),evt_arr.shape)] = 1\n",
    "        tp = np.sum((evt_lbl == 1) & (pred == True))\n",
    "        fn = np.sum((evt_lbl == 1) & (pred == False))\n",
    "        if( (tp + fn) > 0): tp = tp / (tp + fn)\n",
    "        else: tp = 1\n",
    "        fp = np.sum((evt_lbl == 0) & (pred == True))\n",
    "        tn = np.sum((evt_lbl == 0) & (pred == False))\n",
    "        if( (tp + tn) > 0): fp = fp / (fp + tn)\n",
    "        else: tp = 0\n",
    "        temp_tp.append(tp)\n",
    "        temp_fp.append(fp)\n",
    "    tp_classical.append(temp_tp)\n",
    "    fp_classical.append(temp_fp)\n",
    "    \n",
    "    if((evt-evts[0]) % (len(evts)/100) == 0):\n",
    "            print(\"{}% done\".format(int((evt-evts[0]) / (len(evts)/100))))\n",
    "    \n",
    "tp_unet = np.array(tp_unet)\n",
    "fp_unet = np.array(fp_unet)\n",
    "tp_classical = np.array(tp_classical)\n",
    "fp_classical = np.array(fp_classical)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tp_rate_unet = np.mean(tp_unet,axis=0)\n",
    "tp_err_unet = np.std(tp_unet,axis=0)/np.sqrt(tp_unet.shape[0])\n",
    "fp_rate_unet = np.mean(fp_unet,axis=0)\n",
    "fp_err_unet = np.std(fp_unet,axis=0)/np.sqrt(fp_unet.shape[0])\n",
    "tp_rate_classical = np.mean(tp_classical,axis=0)\n",
    "tp_err_classical = np.std(tp_classical,axis=0)/np.sqrt(tp_classical.shape[0])\n",
    "fp_rate_classical = np.mean(fp_classical,axis=0)\n",
    "fp_err_classical = np.std(fp_classical,axis=0)/np.sqrt(fp_classical.shape[0])\n",
    "\n",
    "plt.errorbar(fp_rate_unet,tp_rate_unet,xerr=fp_err_unet,yerr=tp_err_unet,label='Unet')\n",
    "plt.errorbar(fp_rate_classical,tp_rate_classical,xerr=fp_err_classical,yerr=tp_err_classical,label='Basic threshold')\n",
    "plt.xlim([0,0.02])\n",
    "plt.legend()\n",
    "plt.xlabel(\"False positive rate\")\n",
    "plt.ylabel(\"True positive rate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"NN ------------------\")\n",
    "for tpr,fpr,th in zip(tp_rate_unet,fp_rate_unet,nn_thresholds):\n",
    "    print(\"[Threshold {}] TP = {}, FP = {}\".format(th,tpr,fpr))\n",
    "print(\"Classical threshold ------------------\")\n",
    "for tpr,fpr,th in zip(tp_rate_classical,fp_rate_classical,classical_thresholds):\n",
    "    print(\"[Threshold {}] TP = {}, FP = {}\".format(th,tpr,fpr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evt_plt = 10008\n",
    "evt_item = dataset_train[evt_plt]\n",
    "evt_arr = evt_item[0]\n",
    "evt_lbl = evt_item[1][1]\n",
    "\n",
    "# Send through the model.\n",
    "data = torch.tensor(evt_arr).float().unsqueeze(0).unsqueeze(1).cuda()\n",
    "#target = torch.tensor(evt_lbl).float().cuda()\n",
    "output_score = model(data)\n",
    "\n",
    "# Compute the predicted pixel and (x,y) values.\n",
    "prob = np.array(sigmoid(output_score).cpu().detach().numpy()).squeeze()\n",
    "\n",
    "# Threshold\n",
    "# prob = np.zeros(evt_arr.shape)\n",
    "# prob[evt_arr > 80] = 1\n",
    "\n",
    "# Determine number of correct pixels\n",
    "th = 0.2\n",
    "pred = (prob > th)\n",
    "nelec = int(np.sum(evt_lbl == 1))\n",
    "nelec_pred = int(np.sum(pred))\n",
    "nspace = int(np.sum(evt_lbl == 0))\n",
    "nelec_coinc = np.sum((evt_lbl == 1) & (pred == True))\n",
    "nspace_coinc = np.sum((evt_lbl == 0) & (pred == False))\n",
    "print(\"{}/{} electrons predicted\".format(nelec_pred,nelec))\n",
    "print(\"{}/{} electrons coincided exactly\".format(nelec_coinc,nelec))\n",
    "print(\"{}/{} empty spaces coincided exactly\".format(nspace_coinc,nspace))\n",
    "\n",
    "# Information for drawing the line.\n",
    "nrows = evt_arr.shape[0]\n",
    "ncols = evt_arr.shape[1]\n",
    "indices = np.indices((nrows,ncols))\n",
    "irows = indices[0]\n",
    "icols = indices[1]\n",
    "m = -2*nrows/ncols\n",
    "b = 80\n",
    "print(\"Line drawn: m = {}, b = {}\".format(m,b))\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(18.0)\n",
    "\n",
    "ax1 = fig.add_subplot(131)\n",
    "plt.imshow(evt_arr)\n",
    "plt.colorbar()\n",
    "plt.title(\"Event\")\n",
    "\n",
    "# xfit = np.arange(0,ncols,0.1)\n",
    "# yfit = m*xfit + b\n",
    "# plt.plot(xfit[(yfit > 0) & (yfit < nrows)],yfit[(yfit > 0) & (yfit < nrows)])\n",
    "\n",
    "ax2 = fig.add_subplot(132)\n",
    "plt.imshow(evt_lbl)\n",
    "plt.colorbar()\n",
    "plt.title(\"Target\")\n",
    "\n",
    "ax3 = fig.add_subplot(133)\n",
    "#plt.imshow(np.log10(prob))\n",
    "plt.imshow(prob)\n",
    "plt.colorbar()\n",
    "plt.title(\"{}/{} electrons predicted\\n{}/{} electrons coincided exactly\\n{}/{} empty spaces coincided exactly\".format(nelec_pred,nelec,nelec_coinc,nelec,nspace_coinc,nspace))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Construct output and label arrays for 5 events.\n",
    "frames,outputs,labels = [], [], []\n",
    "for iframe in range(50):\n",
    "    frame,label = frameset[iframe]\n",
    "    frames.append(frame)\n",
    "    outputs.append(label[1])\n",
    "    labels.append(label)\n",
    "frames = np.array(frames)\n",
    "outputs = np.array(outputs)\n",
    "labels = np.array(labels)\n",
    "print(\"Frames shape is:\",frames.shape)\n",
    "print(\"Outputs shape is:\",outputs.shape)\n",
    "print(\"Labels shape is:\",labels.shape)\n",
    "\n",
    "# Convert to tensors.\n",
    "outputs[outputs == 0] = 1e-10\n",
    "outputs[outputs == 1] = 0.99999999\n",
    "frames = torch.tensor(frames)\n",
    "output = torch.tensor(np.log(outputs/(1-outputs)))\n",
    "target = torch.tensor(labels)\n",
    "\n",
    "# Compute the loss.\n",
    "sigma_dist = 1\n",
    "real_truth = target[:,0,:,:]\n",
    "th_truth = target[:,1,:,:]\n",
    "edge_truth = target[:,2,:,:]\n",
    "dist = target[:,3,:,:]\n",
    "\n",
    "final_truth = th_truth * edge_truth\n",
    "\n",
    "wts     = torch.sum(torch.exp(-(dist)**2/(2*sigma_dist**2))*th_truth,axis=(1,2))\n",
    "wt_norm = torch.sum(th_truth,axis=(1,2))\n",
    "wt_norm[wt_norm == 0] = 1\n",
    "wts /= wt_norm\n",
    "print(\"Weights are: \",wts)\n",
    "\n",
    "w_edge = 100\n",
    "bce_loss = torch.nn.BCEWithLogitsLoss(reduce=False)\n",
    "sigmoid = torch.nn.Sigmoid()\n",
    "loss0 = bce_loss(output,final_truth)\n",
    "loss1 = w_edge*sigmoid(output)*(1-edge_truth)\n",
    "loss0W = torch.exp(-(dist)**2/(2*sigma_dist**2))*(loss0)\n",
    "loss1W = torch.exp(-(dist)**2/(2*sigma_dist**2))*(loss1)\n",
    "loss = torch.mean(torch.exp(-(dist)**2/(2*sigma_dist**2))*(loss0 + loss1))\n",
    "print(\"Mean loss is \",loss)\n",
    "print(\"Mean loss0 is \",torch.mean(loss0))\n",
    "print(\"Mean loss0W is \",torch.mean(loss0W))\n",
    "print(\"Mean loss1 is \",torch.mean(loss1))\n",
    "print(\"Mean loss1W is \",torch.mean(loss1W))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist_mod = torch.sum(torch.abs(dist*(edge_truth-1)),axis=(1,2))\n",
    "dist_mod.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "iframe = 2\n",
    "show_sum = False\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(6.0)\n",
    "fig.set_figwidth(16.0)\n",
    "\n",
    "ax1 = fig.add_subplot(241)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(sigmoid(output)),axis=0),interpolation=None)\n",
    "else: plt.imshow(np.array(sigmoid(output[iframe])),interpolation=None)\n",
    "plt.colorbar()\n",
    "plt.title(\"sigmoid(Output)\")\n",
    "\n",
    "ax2 = fig.add_subplot(242)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(th_truth),axis=0),interpolation=None)\n",
    "else: plt.imshow(np.array(real_truth[iframe]),interpolation=None)\n",
    "plt.colorbar()\n",
    "plt.title(\"Real truth\")\n",
    "\n",
    "ax3 = fig.add_subplot(243)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(edge_truth), axis=0))\n",
    "else: plt.imshow(np.array(edge_truth[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"Edge truth\")\n",
    "\n",
    "ax4 = fig.add_subplot(244)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(torch.exp(-(dist)**2/(2*sigma_dist**2))),axis=0))\n",
    "else: plt.imshow(np.array(torch.exp(-(dist)**2/(2*sigma_dist**2))[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"Distance\")\n",
    "\n",
    "ax5 = fig.add_subplot(245)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(loss0), axis=0))\n",
    "else: plt.imshow(np.array(loss0[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"Loss0\")\n",
    "\n",
    "ax6 = fig.add_subplot(246)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(loss1),axis=0))\n",
    "else: plt.imshow(np.array(loss1[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"Loss1\")\n",
    "\n",
    "ax7 = fig.add_subplot(247)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(loss0W + loss1W),axis=0))\n",
    "else: plt.imshow(np.array(loss0W[iframe] + loss1W[iframe]))\n",
    "# if(show_sum): plt.imshow(np.sum(np.array(dist_mod),axis=0))\n",
    "# else: plt.imshow(np.array(dist_mod[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"LossW\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iframe = 2\n",
    "show_sum = False\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(3.0)\n",
    "fig.set_figwidth(20.0)\n",
    "\n",
    "ax1 = fig.add_subplot(151)\n",
    "if(show_sum): plt.imshow(np.sum(frames,axis=0)/np.max(np.sum(frames,axis=0)),interpolation=None)\n",
    "else: plt.imshow(np.array(frames[iframe]),interpolation=None)\n",
    "plt.colorbar()\n",
    "plt.title(\"Event\")\n",
    "\n",
    "ax2 = fig.add_subplot(152)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(real_truth),axis=0),interpolation=None)\n",
    "else: plt.imshow(np.array(real_truth[iframe]),interpolation=None)\n",
    "plt.colorbar()\n",
    "plt.title(\"Real truth\")\n",
    "\n",
    "ax3 = fig.add_subplot(153)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(th_truth),axis=0),interpolation=None)\n",
    "else: plt.imshow(np.array(th_truth[iframe]),interpolation=None)\n",
    "plt.colorbar()\n",
    "plt.title(\"Classical threshold\")\n",
    "\n",
    "ax4 = fig.add_subplot(154)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(edge_truth), axis=0))\n",
    "else: plt.imshow(np.array(edge_truth[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"Edge truth\")\n",
    "\n",
    "ax5 = fig.add_subplot(155)\n",
    "if(show_sum): plt.imshow(np.sum(np.array(final_truth), axis=0))\n",
    "else: plt.imshow(np.array(final_truth[iframe]))\n",
    "plt.colorbar()\n",
    "plt.title(\"Combined truth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Test on real data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.002438068389892578\n"
     ]
    }
   ],
   "source": [
    "# Evaluate real data\n",
    "img_data_cut = img_data[-1023:,-1440:]/12\n",
    "img_data_torch = torch.tensor(img_data_cut).float().unsqueeze(0).unsqueeze(1).cuda()\n",
    "start = time.time()\n",
    "output_score = model(img_data_torch)\n",
    "end = time.time()\n",
    "prob = np.array(sigmoid(output_score).cpu().detach().numpy()).squeeze()\n",
    "print(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f80e054b8d0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 864x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the results of the real data evaluation\n",
    "logscale = False\n",
    "view_row_low = -350\n",
    "view_row_high = -300\n",
    "view_col_low = -350\n",
    "view_col_high = -300\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "ax1 = fig.add_subplot(121);\n",
    "if(logscale):\n",
    "    plt.imshow(np.log(img_data_cut[view_row_low:view_row_high,view_col_low:view_col_high]),interpolation='none')\n",
    "    cbar = plt.colorbar()\n",
    "    cbar.set_label(\"log(counts)\")\n",
    "    plt.title(\"Scaled data (log counts)\")\n",
    "else:\n",
    "    plt.imshow(img_data_cut[view_row_low:view_row_high,view_col_low:view_col_high],interpolation='none') #np.log(frame))\n",
    "    cbar = plt.colorbar()\n",
    "    plt.title(\"Scaled data\")\n",
    "\n",
    "ax2 = fig.add_subplot(122);\n",
    "plt.imshow(prob[view_row_low:view_row_high,view_col_low:view_col_high],interpolation='none')\n",
    "plt.title(\"U-net output\")\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Real data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import struct\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.optimize as optimize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# From https://stackoverflow.com/questions/1035340/reading-binary-file-and-looping-over-each-byte\n",
    "def bytes_from_file(filename, chunksize=4):\n",
    "    with open(filename, \"rb\") as f:\n",
    "        while True:\n",
    "            chunk = f.read(chunksize)\n",
    "            if chunk:\n",
    "                yield struct.unpack('@I', chunk)[0]\n",
    "            else:\n",
    "                break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "datfile = \"/home/jrenner/local/data/electronsim/stack_1.dat\"\n",
    "freader = iter(bytes_from_file(datfile))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = []\n",
    "for i in range(5760*4092):\n",
    "    img.append(next(freader))\n",
    "img = np.array(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare for input to a NN\n",
    "img_data = img.reshape([4092,5760])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.colorbar.Colorbar at 0x7f80e9f84d90>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plt.imshow(np.log(img.reshape([5760,4092])),vmin=9.5,vmax=10.5)\n",
    "#plt.imshow(img.reshape([5760,4092])[-100:,0:100],vmin=750,vmax=10000)\n",
    "plt.imshow(img_data,interpolation='none',vmin=750,vmax=15000)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attempt to fit the edge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noise_th = 750*12\n",
    "max_th = 751*12\n",
    "fit_img = np.copy(img_data)\n",
    "fit_img[fit_img < noise_th] = 0\n",
    "fit_img[fit_img >= noise_th] = max_th\n",
    "fit_img = fit_img/np.max(fit_img)\n",
    "fit_img = np.array(fit_img,dtype=np.uint8)\n",
    "print(\"Min value:\",np.min(fit_img),\"; max value:\",np.max(fit_img))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.imshow(fit_img,interpolation='none')\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = fit_img\n",
    "th = 0.5\n",
    "nrows = A.shape[0]\n",
    "ncols = A.shape[1]\n",
    "ncts = np.sum(A >= th)\n",
    "nzeros = np.sum(A < th)\n",
    "wcts = nzeros/ncts\n",
    "indices = np.indices((nrows,ncols))\n",
    "irows = indices[0]\n",
    "icols = indices[1]\n",
    "\n",
    "def count_loss(x):\n",
    "    m,b = x\n",
    "    \n",
    "    # The loss L is:\n",
    "    #\n",
    "    # (number of 0s in the dark region) - wcts*(number of 1s in the dark region)\n",
    "    # + wcts*(number of 1s in the light region) - (number of 0s in the dark region)\n",
    "    # \n",
    "    # where wcts is the count weight, determined such that the number of counts multiplied by wcts is equal to\n",
    "    # the number of zeros.\n",
    "    L = 0\n",
    "    L1 = np.sum((irows < m*icols + b) & (A < th))\n",
    "    L2 = np.sum((irows < m*icols + b) & (A >= th))\n",
    "    L3 = np.sum((irows >= m*icols + b) & (A >= th))\n",
    "    L4 = np.sum((irows >= m*icols + b) & (A < th))\n",
    "    \n",
    "    L = L1 - wcts*L2 + wcts*L3 - L4\n",
    "    print(\"Loss is:\",-L,\"with L1 =\",L1,\"L2 =\",L2,\"L3 =\",L3,\"L4 =\",L4)\n",
    "    return -L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "initial_guess = [-nrows/ncols,nrows]\n",
    "result = optimize.minimize(count_loss,initial_guess,method='Nelder-Mead',tol=1e-6)\n",
    "m,b = result.x\n",
    "Lmin = result.fun\n",
    "print(\"m = \",m,\"b = \",b,\"Lmin=\",Lmin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "plt.imshow(fit_img,interpolation='none')\n",
    "xfit = np.arange(ncols)\n",
    "yfit = m*xfit + b\n",
    "plt.plot(xfit[(yfit > 0) & (yfit < nrows)],yfit[(yfit > 0) & (yfit < nrows)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the loss in a range near the parameters.\n",
    "mrng = np.arange(m-0.1*m, m+0.1*m, 0.2*m/100)\n",
    "Lrng = np.array([count_loss([mval,b])/Lmin for mval in mrng])\n",
    "print(mrng)\n",
    "plt.plot(mrng,Lrng)\n",
    "plt.xlabel(\"Parameter m\")\n",
    "plt.ylabel(\"Relative loss L/L(m$_0$)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def auto_canny(image, sigma=0.1):\n",
    "    v = 255/2. #np.median(image)\n",
    "    lower = int(max(0, (1.0 - sigma) * v))\n",
    "    upper = int(min(255, (1.0 + sigma) * v))\n",
    "    print(\"Lower =\",lower,\", upper=\",upper)\n",
    "    return cv2.Canny(image, lower, upper)\n",
    "\n",
    "edges = auto_canny(image=fit_img) \n",
    "\n",
    "# Show images for testing\n",
    "#cv2.imshow('edges', edges)\n",
    "plt.imshow(edges)\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the noise peak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fscale = 12.\n",
    "\n",
    "def gauss(x, amp, mu, sigma):\n",
    "    if sigma <= 0.:\n",
    "        return np.inf\n",
    "    return amp/(2*np.pi)**(0.5)/sigma * np.exp(-0.5*(x-mu)**2./sigma**2)\n",
    "\n",
    "def gaussexpo(x, amp, mu, sigma, const, mean, x0):\n",
    "    if sigma <= 0.:\n",
    "        return np.inf\n",
    "    return amp/(2*np.pi)**(0.5)/sigma * np.exp(-0.5*(x-mu)**2./sigma**2) + const * np.exp(-(x-x0)/mean)\n",
    "\n",
    "\n",
    "yh, xh, _ = plt.hist(img[(img/fscale > 7000/fscale) & (img/fscale < 9300/fscale)]/fscale,bins=50)\n",
    "xh = (xh[1:] + xh[0:-1])/2\n",
    "\n",
    "#popt, pcov = curve_fit(gaussexpo, xh, yh, [3.0e6, 8200, 300, 1000, 10, -1])\n",
    "popt, pcov = curve_fit(gauss, xh, yh, [3.0e6, 8200/fscale, 135/fscale])\n",
    "xfit = np.linspace(xh[0],xh[-1],100)\n",
    "plt.plot(xfit,gauss(xfit,*popt))\n",
    "plt.xlabel(\"Pixel values\")\n",
    "plt.ylabel(\"Counts/bin\")\n",
    "print(\"Fit mean:\",popt[1])\n",
    "print(\"Fit sigma:\",popt[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fn = np.load(\"frame_4855x4855_11occ.npz\")\n",
    "img_sim = fn['frame'].flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plt.hist(img[(img > 0) & (img < 10000)],bins=50)\n",
    "plt.hist(img_sim,bins=50,range=[0,10000],label='MC')\n",
    "plt.hist(img/12,bins=50,range=[0,10000],label='data')\n",
    "\n",
    "plt.xlabel(\"Pixel values\")\n",
    "plt.ylabel(\"Counts/bin\")\n",
    "plt.yscale(\"log\")\n",
    "plt.legend()\n",
    "print(\"Total pixels:\",len(img))\n",
    "print(\"Counts near peak\",np.sum(img[(img > 29) & (img < 33)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "177383690/935130034."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(np.abs(np.random.normal(loc=0,scale=50,size=1000)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train a network (single-electrons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#modeldir = '/home/jrenner/local/jerenner/emsim/models'\\\n",
    "modeldir = '/home/jrenner/temp/nersc'\n",
    "lrate       = 1e-3   # Learning rate to use in the training.\n",
    "load_model  = False   # Load an existing model\n",
    "tr.augment  = False  # Enable/disable data augmentation\n",
    "epoch_start = 0      # Number of initial epoch\n",
    "epoch_end   = 2000    # Number of final epoch\n",
    "model_load_checkpoint = \"{}/run_11x11_chi32_60/model_init_599.pt\".format(modeldir)\n",
    "\n",
    "# Create the datasets.\n",
    "dataset_all   = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=True,add_shift=0)\n",
    "dataset_train = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=True,nstart=0,nend=-20000,add_shift=0)\n",
    "dataset_val   = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=True,nstart=-20000,add_shift=0)\n",
    "\n",
    "# Create the loaders.\n",
    "train_loader = DataLoader(dataset_train, batch_size=1000, shuffle=True, collate_fn=tr.my_collate, num_workers=8)\n",
    "val_loader = DataLoader(dataset_val, batch_size=1000, shuffle=True, collate_fn=tr.my_collate, num_workers=8)\n",
    "#val_loader = DataLoader(dataset_val, batch_size=15, shuffle=True, collate_fn=tr.my_collate, num_workers=4)\n",
    "#test_loader = DataLoader(dataset_test, batch_size=15, shuffle=True, collate_fn=tr.my_collate, num_workers=4)\n",
    "\n",
    "# Define the model.\n",
    "#model = emnet.FCNet()\n",
    "model = emnet.basicCNN()\n",
    "model.cuda()\n",
    "\n",
    "optimizer = optim.Adam(model.parameters(), lr=lrate, betas=(0.9, 0.999), eps=1e-6, weight_decay=0.01, amsgrad=True)\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min')\n",
    "\n",
    "# Load the model from file.\n",
    "if(load_model):\n",
    "    model.load_state_dict(torch.load(model_load_checkpoint))\n",
    "    #model.load_state_dict(torch.load(model_load_checkpoint,map_location=torch.device('cpu')))\n",
    "    model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Run the training.\n",
    "#print(\"Training with weights\",sort_clsweights)\n",
    "for epoch in range(epoch_start,epoch_end):\n",
    "    print(\"Epoch: \",epoch)\n",
    "    model.train()\n",
    "    tr.train(model, epoch, train_loader, optimizer)\n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        val_loss = tr.val(model, epoch, val_loader)\n",
    "        scheduler.step(val_loss)\n",
    "#     if(epoch % 50 == 0):\n",
    "#         torch.save(model.state_dict(), \"{}/model_init_{}.pt\".format(modeldir,epoch))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), \"{}/model_short_training_{}.pt\".format(modeldir,epoch))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot the training and validation loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the training and validation losses.\n",
    "tloss = np.loadtxt(\"/home/jrenner/temp/nersc/run_11x11_chi32_60_val2_trainsched/train.txt\")\n",
    "vloss = np.loadtxt(\"/home/jrenner/temp/nersc/run_11x11_chi32_60_val2_trainsched/val.txt\")\n",
    "#vloss = np.loadtxt(\"/home/jrenner/local/jerenner/emsim/val.txt\")\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(12.0)\n",
    "\n",
    "ax1 = fig.add_subplot(121);\n",
    "plt.plot(tloss[:,0],tloss[:,1],label='training')\n",
    "plt.plot(vloss[:,0],vloss[:,1],label='validation')\n",
    "plt.legend()\n",
    "plt.title(\"Loss\")\n",
    "plt.yscale('log')\n",
    "\n",
    "ax2 = fig.add_subplot(122);\n",
    "plt.plot(tloss[:,0],tloss[:,2],label='training')\n",
    "plt.plot(vloss[:,0],vloss[:,2],label='validation')\n",
    "plt.legend()\n",
    "plt.title(\"Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate all events from a dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dset = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=True,add_shift=0)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "evts = np.arange(100000,110000)\n",
    "df, evts = emsim_utils.construct_evt_dataframe(dset,evts,model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xvals = df['xc_3x3'].values\n",
    "yvals = df['yc_3x3'].values\n",
    "rngval = 0.002\n",
    "plt.hist2d(xvals,yvals,bins=10,range=[[-rngval,rngval],[-rngval,rngval]])\n",
    "plt.colorbar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axes = pd.plotting.scatter_matrix(df[[\"error_r_NN\",\"error_r_maxpt\",\"error_r_3x3\",\"error_r_3x3_th\",\"error_r_5x5\",\"error_r_5x5_th\"]], \n",
    "                                  figsize=[15,15], alpha=0.2, hist_kwds={'bins':100})\n",
    "for i, axs in enumerate(axes):\n",
    "    for j, ax in enumerate(axs):\n",
    "        #if i == j:  # only the histograms\n",
    "        #ax.set_yscale('log')\n",
    "        ax.set_xlim(0,0.01)\n",
    "        ax.set_ylim(0,0.01)\n",
    "            \n",
    "plt.savefig(\"errors_scatter_matrix.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "err_cut = 0.1\n",
    "rng_cut = 0.005\n",
    "sigma_cut = 1e9\n",
    "nbins = 50\n",
    "\n",
    "df_plt_NN  = df[(df.error_r_3x3 < err_cut)] # & (df.sigma_r_NN < sigma_cut)]\n",
    "df_plt_3x3 = df[(df.error_r_3x3 < err_cut)] # & (df.sigma_r_NN < sigma_cut)]\n",
    "\n",
    "plt.hist(df_plt_NN.error_r_NN,range=(0,rng_cut),alpha=0.8,bins=nbins,color='blue',label='NN error')\n",
    "plt.hist(df_plt_3x3.error_r_3x3,range=(0,rng_cut),alpha=0.8,bins=nbins,color='green',label='3x3 centroid')\n",
    "plt.xlabel(\"error $\\sqrt{\\Delta x^2 + \\Delta y^2}$ (mm)\")\n",
    "plt.ylabel(\"counts/bin\")\n",
    "#plt.yscale('log')\n",
    "plt.legend()\n",
    "\n",
    "print(\"NN events:\",len(df_plt_NN[df_plt_NN.error_r_NN < rng_cut]))\n",
    "print(\"3x3 events:\",len(df_plt_3x3[df_plt_3x3.error_r_3x3 < rng_cut]))\n",
    "print(\"Mean NN error:\",np.mean(df_plt_NN[df_plt_NN.error_r_NN < rng_cut].error_r_NN))\n",
    "print(\"Mean 3x3 error:\",np.mean(df_plt_3x3[df_plt_3x3.error_r_3x3 < rng_cut].error_r_3x3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Mean 3x3 error:\",df[(df.error_r_3x3 < err_cut) & (df.sigma_r_NN < sigma_cut)].error_r_3x3.mean())\n",
    "print(\"Mean NN error: \",df[(df.error_r_NN < err_cut) & (df.sigma_r_NN < sigma_cut)].error_r_NN.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"error_r_diff\"] = df.error_r_NN - df.error_r_3x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "err_diff_cut = 0.005\n",
    "plt.hist(df[(df.error_r_diff < err_diff_cut) & (df.error_r_diff > -err_diff_cut) & (df.sigma_r_NN < 0.011)].error_r_diff,alpha=0.8,bins=50,color='blue',label='NN error')\n",
    "plt.yscale(\"log\")\n",
    "plt.xlabel(\"error difference (NN - 3x3-method)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.x_true > 0.02][['event','x_true']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save dataframe and event arrays.\n",
    "df.to_pickle(\"evts_80000_to_90000.pkl\")\n",
    "np.savez(\"evt_arrays.npz\",evt_arrays=l_evt_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_pickle(\"evts_80000_to_90000.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cut_sigma = 0.011\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(6.0)\n",
    "fig.set_figwidth(15.0)\n",
    "\n",
    "ax1 = fig.add_subplot(121)\n",
    "plt.hist(df[df.sigma_r_NN < cut_sigma].error_r_NN,bins=50)\n",
    "plt.yscale(\"log\")\n",
    "plt.xlabel(\"error $\\sqrt{\\Delta x^2 + \\Delta y^2}$ (mm)\")\n",
    "plt.ylabel(\"Counts/bin\")\n",
    "\n",
    "ax2 = fig.add_subplot(122)\n",
    "plt.hist(df[df.sigma_r_NN < cut_sigma].sigma_r_NN,bins=50)\n",
    "plt.xlabel(\"$\\sqrt{\\sigma_x^2 + \\sigma_y^2}$ of probability distribution (mm)\")\n",
    "plt.ylabel(\"Counts/bin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eff, mean_err = [], []\n",
    "cut_sigmas = np.arange(0.003,0.4,0.0005)\n",
    "for cut_sigma in cut_sigmas:\n",
    "    df_cut = df[df.sigma_r_NN < cut_sigma]\n",
    "    \n",
    "    eff.append(len(df_cut)/len(df))\n",
    "    mean_err.append(df_cut.error_r_NN.mean())\n",
    "    \n",
    "    print(\"[SIGMA = {}]: EFF = {}, ERR = {}\".format(cut_sigma,len(df_cut)/len(df),df_cut.error_r_NN.mean()))\n",
    "\n",
    "eff = np.array(eff)\n",
    "mean_err = np.array(mean_err)\n",
    "plt.plot(mean_err,eff,'.-')\n",
    "plt.xlabel(\"Mean error (mm)\")\n",
    "plt.ylabel(\"Efficiency\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test the net for individual events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dset = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_noise=True,add_shift=0)\n",
    "softmax = nn.Softmax(dim=1)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evt_plt = 80388\n",
    "evt_item = dset[evt_plt]\n",
    "evt_arr = evt_item[0]\n",
    "evt_lbl = evt_item[1]\n",
    "evt_err_ind = evt_item[2]\n",
    "\n",
    "SHIFTED_ERR_RANGE_MIN = emnet.PIXEL_ERR_RANGE_MIN # - dset.add_shift*emnet.PIXEL_SIZE\n",
    "SHIFTED_ERR_RANGE_MAX = emnet.PIXEL_ERR_RANGE_MAX # + dset.add_shift*emnet.PIXEL_SIZE\n",
    "#ERR_PIXEL_SIZE = emnet.PIXEL_SIZE*(2*dset.add_shift+1)/emnet.ERR_SIZE\n",
    "ERR_PIXEL_SIZE = (emnet.PIXEL_ERR_RANGE_MAX - emnet.PIXEL_ERR_RANGE_MIN)/emnet.ERR_SIZE\n",
    "print(\"Error grid pixel size is {}\".format(ERR_PIXEL_SIZE))\n",
    "\n",
    "x_errgrid = np.arange(0,emnet.ERR_SIZE)*ERR_PIXEL_SIZE + SHIFTED_ERR_RANGE_MIN + ERR_PIXEL_SIZE/2\n",
    "y_errgrid = np.arange(0,emnet.ERR_SIZE)*ERR_PIXEL_SIZE + SHIFTED_ERR_RANGE_MIN + ERR_PIXEL_SIZE/2\n",
    "print(x_errgrid)\n",
    "\n",
    "xbin = int(emnet.ERR_SIZE*(evt_lbl[0] - SHIFTED_ERR_RANGE_MIN)/(SHIFTED_ERR_RANGE_MAX - SHIFTED_ERR_RANGE_MIN))\n",
    "xbin = max(xbin,0)\n",
    "xbin = min(xbin,emnet.ERR_SIZE-1)\n",
    "\n",
    "ybin = int(emnet.ERR_SIZE*(evt_lbl[1] - SHIFTED_ERR_RANGE_MIN)/(SHIFTED_ERR_RANGE_MAX - SHIFTED_ERR_RANGE_MIN))\n",
    "ybin = max(ybin,0)\n",
    "ybin = min(ybin,emnet.ERR_SIZE-1)\n",
    "\n",
    "print(\"Computed index:\",(ybin*emnet.ERR_SIZE) + xbin,\"for max added shift:\",dset.add_shift)\n",
    "\n",
    "# Send through the model.\n",
    "data = torch.tensor(evt_arr).float().unsqueeze(0).unsqueeze(1).cuda()\n",
    "target = torch.tensor(np.array(evt_err_ind)).long().cuda()\n",
    "output_score = model(data)\n",
    "\n",
    "# Compute the predicted pixel and (x,y) values.\n",
    "prob = np.array(softmax(output_score).cpu().detach().numpy()).reshape([emnet.ERR_SIZE,emnet.ERR_SIZE])\n",
    "ipred = np.argmax(prob)\n",
    "xpred = int(ipred % emnet.ERR_SIZE)*ERR_PIXEL_SIZE + SHIFTED_ERR_RANGE_MIN + ERR_PIXEL_SIZE/2\n",
    "ypred = int(ipred / emnet.ERR_SIZE)*ERR_PIXEL_SIZE + SHIFTED_ERR_RANGE_MIN + ERR_PIXEL_SIZE/2\n",
    "#print(\"[Evt\",evt,\"]: Index is\",evt_err_ind,\"with predicted\",ipred,\"; x = {} (predicted {}), y = {} (predicted {})\".format(evt_lbl[0],xpred,evt_lbl[1],ypred))\n",
    "\n",
    "# Compute the sigmas of the distribution.\n",
    "sigma_x0, sigma_y0 = emsim_utils.compute_sigmas(prob,ERR_PIXEL_SIZE,SHIFTED_ERR_RANGE_MIN)\n",
    "popt, pcov = emsim_utils.fit_sigmas(prob,x_errgrid,y_errgrid,xpred,ypred,sigma_x0,sigma_y0,ERR_PIXEL_SIZE)\n",
    "fit_data = emsim_utils.mult_gaussFun_Fit((x_errgrid,y_errgrid),*popt).reshape([emnet.ERR_SIZE,emnet.ERR_SIZE])\n",
    "print(\"Gaussian fit parameters A*exp(-0.5*((x-x0)**2/varX + (y-y0)**2/varY)) + C:\")\n",
    "print(\"A = {}\".format(popt[0]))\n",
    "print(\"(x0, y0) = ({},{})\".format(popt[1],popt[2]))\n",
    "print(\"(sigma_x, sigma_y) = ({},{})\".format(popt[3]**0.5,popt[4]**0.5))\n",
    "print(\"C = {}\".format(popt[5]))\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(4.0)\n",
    "fig.set_figwidth(18.0)\n",
    "\n",
    "ax1 = fig.add_subplot(131)\n",
    "plt.imshow(evt_arr)\n",
    "plt.colorbar()\n",
    "plt.title(\"Event {}; shift ({:.3e},{:.3e}); index {}\".format(evt_plt,evt_lbl[0],evt_lbl[1],evt_err_ind))\n",
    "\n",
    "ax2 = fig.add_subplot(132)\n",
    "ax2.plot([xbin],[ybin],color='red',marker='o',markersize=10)\n",
    "plt.imshow(prob)\n",
    "plt.colorbar()\n",
    "plt.title(\"Incidence point within prediction grid\")\n",
    "\n",
    "ax3 = fig.add_subplot(133)\n",
    "plt.imshow(fit_data)\n",
    "plt.colorbar()\n",
    "plt.title(\"2D Gaussian fit\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Misc. code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Look at many events:\n",
    "xpred_err, ypred_err = [], []\n",
    "for evt_plt in np.arange(8000,9999):\n",
    "    \n",
    "    evt_item = dset[evt_plt]\n",
    "    evt_arr = evt_item[0]\n",
    "    evt_lbl = evt_item[1]\n",
    "    evt_err_ind = evt_item[2]\n",
    "\n",
    "    # Send through the model.\n",
    "    data = torch.tensor(evt_arr).float().unsqueeze(0).unsqueeze(1).cuda()\n",
    "    target = torch.tensor(np.array(evt_err_ind)).long().cuda()\n",
    "\n",
    "    output_score = model(data)\n",
    "    prob = np.argmax(np.array(softmax(output_score).cpu().detach().numpy()).reshape([10,10]))\n",
    "    xpred = (prob % tr.ERR_SIZE)*0.005/tr.ERR_SIZE + tr.ERR_RANGE_MIN + 0.005/tr.ERR_SIZE/2\n",
    "    ypred = (prob / tr.ERR_SIZE)*0.005/tr.ERR_SIZE + tr.ERR_RANGE_MIN + 0.005/tr.ERR_SIZE/2\n",
    "    print(\"[Evt\",evt_plt,\"]: Index is\",evt_err_ind,\"with predicted\",prob,\"; x = {} (predicted {}), y = {} (predicted {})\".format(evt_lbl[0],xpred,evt_lbl[1],ypred))\n",
    "    \n",
    "    xpred_err.append(xpred-evt_lbl[0])\n",
    "    ypred_err.append(ypred-evt_lbl[1])\n",
    "xpred_err = np.array(xpred_err)\n",
    "ypred_err = np.array(ypred_err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "fig.set_figheight(6.0)\n",
    "fig.set_figwidth(15.0)\n",
    "\n",
    "ax1 = fig.add_subplot(121);\n",
    "plt.hist(xpred_err)\n",
    "plt.xlabel(\"error in x-prediction (mm)\")\n",
    "print(np.where(abs(xpred_err) > 0.001))\n",
    "\n",
    "ax2 = fig.add_subplot(122)\n",
    "plt.hist(ypred_err)\n",
    "plt.xlabel(\"error in y-prediction (mm)\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For debugging the 3x3 sum operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa = np.ones([6,6])\n",
    "aa[0,2] = 4\n",
    "aa[1,2] = 2\n",
    "aa[3,2] = 8\n",
    "aa[4,2] = -2\n",
    "aa[3,1] = 5\n",
    "aa[5,0] = 10\n",
    "aa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_init   = np.unravel_index(aa.argmax(),aa.shape)\n",
    "nbsum_init = tr.sum_neighbors(aa,max_init,remove=True)\n",
    "print(\"Max at\",max_init,\"and neighbor sum\",nbsum_init)\n",
    "aa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate a dataset for noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Nevts = 1000\n",
    "noise_arr = np.arange(0.,100.,50.)\n",
    "r_mean, r_sigma = [], []\n",
    "for noise in noise_arr:\n",
    "    print(\"Running for noise\",noise)\n",
    "    dset = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",0,noise)\n",
    "    \n",
    "    shifts_x, shifts_y, shifts_r = [], [], []\n",
    "    for evt in range(Nevts):\n",
    "        evt_arr,evt_lbl = dset[evt]\n",
    "        xs,ys = evt_lbl[0],evt_lbl[1]\n",
    "        shifts_x.append(xs)\n",
    "        shifts_y.append(ys)\n",
    "        shifts_r.append((xs**2 + ys**2)**0.5)\n",
    "    \n",
    "    shifts_r = np.array(shifts_r)\n",
    "    r_mean.append(np.mean(shifts_r))\n",
    "    r_sigma.append(np.std(shifts_r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.errorbar(noise_arr,r_mean,yerr=np.array(r_sigma)/Nevts**0.5)\n",
    "plt.xlabel(\"$\\sigma$ noise (electrons)\")\n",
    "plt.ylabel(\"r-error (mm)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read a dataset and examine individual events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dset = tr.EMDataset(\"dataframes/EM_4um_back_10M_300keV.pkl\",noise_mean=0,noise_sigma=20,add_shift=10,add_noise=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evt_plt = 8\n",
    "evt_item = dset[evt_plt]\n",
    "evt_arr = evt_item[0]\n",
    "evt_lbl = evt_item[1]\n",
    "evt_err_ind = evt_item[2]\n",
    "plt.imshow(evt_arr)\n",
    "plt.colorbar()\n",
    "plt.title(\"Event {}; shift {}; index {}\".format(evt_plt,evt_lbl,evt_err_ind))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shifts_x, shifts_y, shifts_r = [], [], []\n",
    "for evt in range(1000):\n",
    "    evt_arr,evt_lbl,evt_err_ind = dset[evt]\n",
    "    xs,ys = evt_lbl[0],evt_lbl[1]\n",
    "    shifts_x.append(xs)\n",
    "    shifts_y.append(ys)\n",
    "    shifts_r.append((xs**2 + ys**2)**0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(shifts_r,bins=100)\n",
    "plt.yscale('log')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot events directly from dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_pickle(\"dataframes/EM_4um_back_10M_300keV.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evt_plt = 97\n",
    "evt_arr = np.zeros([101,101])\n",
    "df_evt = df[df.event == evt_plt]\n",
    "for row,col,counts in zip(df_evt['row'].values,df_evt['col'].values,df_evt['counts'].values):\n",
    "    evt_arr[row,col] += counts\n",
    "plt.imshow(np.log(0.1 + evt_arr))\n",
    "plt.colorbar()\n",
    "plt.title(\"Event {}; max at {}\".format(evt_plt,np.unravel_index(evt_arr.argmax(),evt_arr.shape)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ems",
   "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.10.8 | packaged by conda-forge | (main, Nov 22 2022, 08:23:14) [GCC 10.4.0]"
  },
  "vscode": {
   "interpreter": {
    "hash": "cd127c81377826759955059e10c8aeeeaa9df43b81e26c9054d98f3f9f535bfd"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}