From ba7550892cce179664a41661c49cf96af93f6b09 Mon Sep 17 00:00:00 2001
From: Kiana Setoodehnia <kiana.setoodehnia@xfel.eu>
Date: Mon, 14 Oct 2019 09:06:17 +0200
Subject: [PATCH 1/3] Added the notebook for bad pixels frequency map.

---
 notebooks/FastCCD/Offset_Time_Evolution.ipynb | 734 ++++++++++++++++++
 1 file changed, 734 insertions(+)
 create mode 100644 notebooks/FastCCD/Offset_Time_Evolution.ipynb

diff --git a/notebooks/FastCCD/Offset_Time_Evolution.ipynb b/notebooks/FastCCD/Offset_Time_Evolution.ipynb
new file mode 100644
index 000000000..6aa5fac08
--- /dev/null
+++ b/notebooks/FastCCD/Offset_Time_Evolution.ipynb
@@ -0,0 +1,734 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Offset Analysis for FastCCD Dark Runs Obtained at -57 degC in DetLab\n",
+    "\n",
+    "#### Authors: Simon Parschat, Kiana Setoodehnia, Michele Cascella - August 2019\n",
+    "\n",
+    "10 subsequent 1-hour-long dark runs were taken on 20/08/2019 in DetLab. FastCCD was cooled down to -57 degC to ensure a better temperature stability during these runs. This is due to the fact that the chiller from LBNL is too strong and our 20-Watts CCD heater is not able to maintain a stable temperature at setpoint = -40 degC. Our previous dark runs, which were taken at -40 degC (e.g., runs 20 and 26) indicated that the temperature runs away (starts to decrease) after about only an hour, whereas at -57 degC, a better temperature stability is achieved over a much longer period of time.\n",
+    "\n",
+    "This notebook analyzes the FastCCD baseline at -57 degC and injects a bad pixels frequency map into the calibration database."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "in_folder = \"/gpfs/exfel/exp/DETLAB/201931/p900104/raw\" # Path to raw data\n",
+    "out_path = '/gpfs/exfel/exp/DETLAB/201931/p900104/scratch' # Path for saving the outputs, if any\n",
+    "path_template = 'RAW-R{:04d}-DA01-S{{:05d}}.h5' # Data source format\n",
+    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image/pixels' # Actual data arrays are saved here\n",
+    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value' # Temperature values are saved here\n",
+    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # Path to find control data, e.g., bias voltage and so on\n",
+    "trainId_path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/trainId' # Path to read trainID from the data\n",
+    "runs = [41, 42, 43, 44, 45, 46, 47, 48, 49, 50] # Dark run numbers (all with high gain)\n",
+    "sequences = [-1] # Sequences to correct, set to -1 for all, a given range is also allowed\n",
+    "bad_pixel_offset_sigma = 5. # Any pixel whose offset is beyond 5 standard deviations from median(offset), is a bad pixel\n",
+    "bad_pixel_noise_sigma = 5. # Any pixel whose noise is beyond 5 standard deviations from median(noise), is a bad pixel\n",
+    "sigmaNoise = 5. # Any pixel whose signal exceeds sigmaNoise*noise will be masked\n",
+    "frame_number = 100 # Number of frames over which an OffsetMap is derived: every 100 frames, an offsetmap is calculated\n",
+    "cal_db_interface = \"tcp://max-exfl016:8020\" # The calibration database interface to use\n",
+    "cal_db_timeout = 300000 # Timeout on calibration database requests\n",
+    "temp_limits = 5 # To find calibration constants later on, the sensor temperature is allowed to vary by 5 units\n",
+    "db_output = True # Output constants to the calibration database\n",
+    "use_dir_creation_date = True # To be used to retrieve calibration constants later on (for database time derivation)\n",
+    "creation_time = None # Creation time is necessary for the calibration database. At first, we initialize it to None \n",
+    "fix_temperature = False # The temperature is not fixed in calibration database\n",
+    "temperature_k_fixed = 233 # Fixed temperature in Kelvin, used only if temperature is fixed.\n",
+    "threshold = 0.001 # Threshold to be set on the bad pixels frequency map (pixels with frequencies above 0.1% are masked)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import h5py\n",
+    "import math\n",
+    "import time\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "import datetime\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib\n",
+    "%matplotlib inline\n",
+    "import matplotlib.cm as cm\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from XFELDetAna import xfelpyanatools as xana\n",
+    "from cal_tools.tools import get_dir_creation_date\n",
+    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
+    "from iCalibrationDB.detectors import DetectorTypes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Output Folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Results may be saved in /gpfs/exfel/exp/DETLAB/201931/p900104/scratch/r0041_r0042_r0043_r0044_r0045_r0046_r0047_r0048_r0049_r0050/ directory.\n"
+     ]
+    }
+   ],
+   "source": [
+    "out_folder  = \"{}/{}\".format(out_path, \"_\".join([\"r{:04d}\".format(r) for r in runs]))\n",
+    "if not os.path.isdir(out_folder):\n",
+    "    os.makedirs(out_folder)\n",
+    "print(\"Results may be saved in {}/ directory.\".format(out_folder))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Main calculations are done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "offset_train_id_reading = [] # Train ID every time an offsetmap is calculated (every 100 frames)\n",
+    "Temperature = []\n",
+    "Temperature_reading = [] # Temperature every time an offsetmap is calculated (every 100 frames)\n",
+    "offset = []\n",
+    "noise = []\n",
+    "\n",
+    "for run in runs:\n",
+    "    Non_empty_Im = np.ndarray(shape=(0,1934,960)) # Size of the image array\n",
+    "    Non_empty_Train_ID = np.ndarray(shape=(0)) # We only have one train id and one temperature value per frame\n",
+    "    Temperature = np.ndarray(shape=(0))\n",
+    "    ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
+    "    dirlist = sorted(os.listdir(ped_dir))\n",
+    "    \n",
+    "    if (sequences[0]== -1):\n",
+    "        sequences_ = range(len(dirlist))\n",
+    "    else :\n",
+    "        sequences_ = sequences\n",
+    "\n",
+    "    for seq in sequences_:\n",
+    "        fp_name = path_template.format(run)\n",
+    "        fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
+    "        filename = fp_path.format(seq)\n",
+    "        with h5py.File(filename, 'r') as f:\n",
+    "            im = f[h5path][()] \n",
+    "            im = np.bitwise_and(im, 0b0011111111111111).astype(np.float32) # Removing gain bit from data\n",
+    "            trainID = f[trainId_path][()]\n",
+    "            temperature = f[h5path_t][()]\n",
+    "        # Checking to ensure no frame in im-array is empty: \n",
+    "        # If all elements in im[i,:,:] (for a specific i) are equal to 0, then np.any(im) would be a false statement\n",
+    "        # because 0 = false\n",
+    "        emptyFrames = [] \n",
+    "        for i in range(im.shape[0]):\n",
+    "            if not np.any(im[i,:,:]): \n",
+    "                emptyFrames.append(i)\n",
+    "       \n",
+    "        # Non_empty_Im.shape[0] is the total number of non-empty frames per sequence:\n",
+    "        Non_empty_Im = np.append(Non_empty_Im, np.delete(im, np.s_[emptyFrames], axis=0), axis=0)\n",
+    "        Non_empty_Train_ID = np.append(Non_empty_Train_ID, (np.delete(trainID, np.s_[emptyFrames], axis=0)))\n",
+    "        Temperature = np.append(Temperature, (np.delete(temperature, np.s_[emptyFrames], axis=0)))\n",
+    "        \n",
+    "        # We flatten the Non_empty_Im, Non_empty_Train_ID and Temperature arrays so that we can go through all the non\n",
+    "        # empty frames in 100-frame chunks and take a mean and standard deviation of data every 100 frames until\n",
+    "        # the number of frames that are left is less than 100. The last number of frames which are below 100 are \n",
+    "        # ignored (but they represent a very small fraction of data):\n",
+    "        while (Non_empty_Im.shape[0] >= frame_number):\n",
+    "            offset.append(np.mean(Non_empty_Im[:frame_number],axis=0))\n",
+    "            noise.append(np.std(Non_empty_Im[:frame_number],axis=0))\n",
+    "            Non_empty_Im = Non_empty_Im[frame_number:]\n",
+    "            offset_train_id_reading.append(Non_empty_Train_ID[seq])\n",
+    "            Non_empty_Train_ID = Non_empty_Train_ID[frame_number:]\n",
+    "            Temperature_reading.append(Temperature[seq])\n",
+    "            Temperature = Temperature[frame_number:]\n",
+    "print(\"Main calculations are done.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Shape Checks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "offset shape:  (2732, 1934, 960)\n",
+      "noise shape:  (2732, 1934, 960)\n",
+      "Time shape:  (2732,)\n",
+      "Temperature shape:  (2732,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('offset shape: ', np.array(offset).shape)\n",
+    "print('noise shape: ', np.array(noise).shape)\n",
+    "print('Time shape: ', np.array(offset_train_id_reading).shape)\n",
+    "print('Temperature shape: ', np.array(Temperature_reading).shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Time Evolution of CCD Temperature\n",
+    "\n",
+    "The following pattern is not new and has been also observed in the Hera South Data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(10, 5))\n",
+    "ax1 = fig.add_subplot(111)\n",
+    "# CCD is triggering at 10 Hz and there are 60 seconds in a minute:\n",
+    "ax1.plot(np.subtract(offset_train_id_reading, offset_train_id_reading[0])/600, Temperature_reading) \n",
+    "ax1.set_xlabel('Time (minutes)')\n",
+    "ax1.set_ylabel(\"Temperature (degC)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Offset and Noise (averaged over columns and rows) vs. Temperature"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAFNCAYAAAAU+fu/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydd5gW1dXAf2fmLdt7AxaWXqUIAiKiYMWGxt5iT2KMaZoYTftMounFmGqJsSvYhdhRmqAgVdoCS9mF7b29deZ+f8ywLmxhkV0Qub/neZ+dcufeM3dmZ86cc+65opRCo9FoNBqNRrMvxpEWQKPRaDQajeaLiFaSNBqNRqPRaNpBK0kajUaj0Wg07aCVJI1Go9FoNJp20EqSRqPRaDQaTTtoJUmj0Wg0Go2mHbSSpDkqEZE3ReT6w9RWfxFRIuI5xHoeF5H7ukuuA7R1g4gsORxtHQwicq+IPN2N9e0UkTO6q76jiZ64nw7nParRHA1oJekYQUQWiEiNiPiPtCzdgVLqHKXUE0dajp7CvV63HGk5vkjoF7hGozncaCXpGEBE+gPTAAXM6qE2DsnKovny8UW/J77o8mk0miOPVpKODa4DPgIeB1pcVCJyooiUiojZattXRGSdu2yIyN0iUiAiVSIyR0TS3H17XVA3i0gh8L67/QW3zjoRWSQio1rVnS4ic0WkXkRWiMh9rV1CIjJcRN4VkWoRyReRyzs6odaWFhEZLCIL3TYrRWR2J8edLCJLRaRWRIpE5AZ3+3kistqVrUhE7u2kjjQR+a+IFLvWuVfd7W1cXG4fDW6njlQRmSciFW4d80Qk1913P45S+3cRaRSRvx+of9y+fd2VfzkwqCP53fKzRGSD2w8LRGSEu/1uEXlxv7J/FZEH3eVkEfmPiJSIyB73Gpqtzv9DEfmLiFQDHfVhjIjMFpEGEVklImNbtTXClafWlW+Wu/3rwDXAXW6fzG1V3zgRWede/9kiEtPBObeRz73Hfyoiu0SkXESeFJFkt/wTInKnu9zHvZa3ueuD3esgIpLhXr9ad9tiEWn32er2ZZF7nVaKyLRW++4V53/sSbdvNojICa32H+/2V4N7j7d7nq3Kf01ENrnlN4rI+M76uIP+6vB+Fsey909xXN+Nbt/miMgD7j29WUSOb3XsThH5QXvX6mD6UKM5rCil9O9L/gO2AbcBE4AIkN1qXwFwZqv1F4C73eXv4ShXuYAfeAh4zt3XH8cy9SQQD8S6228CEt3yDwBrWtX9vPuLA0YCRcASd1+8u34j4AHGA5XAqA7OaQFwi7v8HPATHKU/Bji5g2P6AQ3AVYAXSAfGufumA6PdOsYAZcBF+52rx13/HzAbSHXrOdXdfsPe82nVpgIGu8uPA/e5y+nAJW5fJLr9/mp759eV/nH7dY5b7jhgz/6ytKprKNAEnOnKf5d7j/iAPKAZSHLLmkAJcKK7/qp7H8QDWcBy4Butzj8KfNuVMbadtu/FuQcvddv+AbDDXfa6cvzYleU093oN27//WtW305WhN5AGbAJu7eC828iHc79uAwYCCcDLwFOt7uW57vLVOP8rs1vte81d/g3w71bnMA2QDmS41r32HuBOoBSIadU3QeBct99/A3zk7vMBu4Dvu21c6vbjfR20c5l7D0wEBBjsXtsu9zFdu58rcZ4rMTgfSjtwPspM4D7gg65cq4PpQ/3Tv8P5O+IC6F8PX2A42X2YZrjrm4Hvt9p/H/CYu5yI8/LMc9c3Aae3KtvLrcvDZ4rDwE7aTnHLJLsPzcjeh3GrtvcqSVcAi/c7/iHg/zqoewGfKUlPAg8DuQfoi3uAV7rYbw8Af3GX956rx+0DG0ht55iuvFQ6eqmNA2raO78D9U+rvh3eat+v95el1b6fAXNarRs4L9Tp7voS4Dp3+UygwF3OBkK0Un5wFM4PWp1/4QH69V7cF3+rtkvcl+I0HKXBaLX/OeDejvoP58V7bav13wP/7qDtNvIB84HbWq0P47N7fBBQ68r4b+AbwG633BPAHe7yL4HX9l7ng/z/rAHGtuqb91rtGwkE3OVTgGJaKQ7A0k7up7eB77azvct9TNfu50da7fs2sKnV+migtivX6lD6UP/0ryd/2pz55ed64B2lVKW7/iytXG7u+sXiBHRfDKxSSu1y9+UBr7gm8FocpcnCeVnupWjvgoiYIvJbcdxz9TgPRYAMIBPnxVPU3rFuW5P3tuW2dw2Q04VzvAvna3m56z64qYNyfXGsAW0Qkcki8oE47q864FZX7vbqqFZK1XRBrg4RkTgRech189QDi4AUaeX63I/O+qe9vt3VTh176d16v1LKdo/t4256Fkf5AceC8mwrGbxASSsZHsKxKO2ltQwd0VLGbXu3K1NvoMjd1vo8+tA5pa2Wm3EsQgds22WfvnCXPTjW1gKgEUeBnQbMA4pFZBhwKrDQPeYPONaZd0Rku4jc3VHjInKn6wKrc/svmX3vs/3PJUac2KnewB6lVOsZyTu7xh3d65+3jzuirNVyoJ31/a9FR9eqy32o0RxOdODilxgRiQUuB0wR2ftw8uO8jMcqpdYqpTaKyC7gHPZ9IYLzQrlJKfVhO3X3dxdbP7SvBi4EzsBRkJJxvpQFqMBxdeQCW9zyffdra6FS6syDPU+lVCnwNVeuk4H3RGSRUmrbfkWLgEkdVPMs8HfgHKVUUEQeoH0lqQhIE5EUpVTtfvuacNxnuLJ0puDdiWO1mKyUKhWRccBqnL6Cfft1b7vt9o+rWEVx+nOzu7lfJ20X43zl7z1e3GP3uJteAP4kTozUV4AprWQI4Vglox3Uvb/c7dFy3d24k1xXJoC+ImK0eon347P7pSt1H4j96yjGUf720g+nL/e+7BfiuLZ8Sqk9IrIQx52UCqwBUEo14FzPO8WJwftARFYopea3bsiNP/oRcDqwQSlli8je/48DUQL0ERFppSj1owOlH+datReXVkznfdyag7mfD4mu9qFGc7jRlqQvNxfhWH5G4nwNjwNGAItxHvR7eRb4Do5J/4VW2/8N3C8ieQAikikiF3bSXiLOS7QK5+H66707lFIWTrzHva4VZfh+MswDhorIV0XE6/4mihtQ3Bkicpn7QgdHKVPuee/PM8AZInK5iHjECXYe10r2aldBmoSj8LVBKVUCvAn8U5zga6+InOLuXguMEpFxbkDqvZ2InYjzpV0rTjD8/+23vwwnTmYvHfZPO307kn2thfszBzhPRE4XES/OyymE475BKVWB4+77L7BDKbWp1bm/g6NAJYkT9DxIRE7tpK32mCAiF7sWku+5bX8EfIzzYr7LPb/pwAU48Vbt9Ul38BzwfREZICIJOPfs7FZK4ELgdhxLHzj98m0cN5QFICLnixPILUA9zr3X3v2XiKOAVQAeEfk5kNRFOZe5x37HvXcvpmOFH+BR4AciMkEcBrv/xwfq49YczP18SBxEH2o0hxWtJH25uR74r1KqUClVuveHYzG5Rj4bAv0cTuDy+63ccgB/BV7HMYE34LzIJnfS3pM4pvs9wEa3fGtux7EulQJPue2GoOVL8izgSpyv3VLgdziWrwMxEfhYRBpdeb+rlNqxfyGlVCFOUOydQDWOJWDvyKrbgF+65/lzHEWiI76KE7eyGSjHedGjlNqCE1vxHrAVJ7anIx7ACRyuxOmnt/bb/1fgUnFGCT3Yhf65Hcd1UYoTK/LfjhpWSuXjBBD/zW3/AuACpVS4VbFncSyCz+53+HU4Ab8bcRTSF3HitA6G13BirGpw+vJipVTEbX8WjlWzEvgnTmzUXuvYf4CRrqvv1YNssyMew7kXF+EEHQdxlKC9LMRRbvYqSUtwPgAWtSozBOeaN+IoM/9USi1op623cRTsLTj/J0G65p7E7ZuLceKEanD67+VOyr8A3I9z/RpwAu7TutDHres4mPv5UOmwD8UZPffjHmxbo+kQ2dfFrdEcPkTkd0COUqozq4dGo9FoNEcEbUnSHDbEyfMzxjX/TwJuBl450nJpNBqNRtMeOnBbczhJxHGx9cZxU/0Jx/Wi0Wg0Gs0XDu1u02g0Go1Go2kH7W7TaDQajUajaQetJGk0Go1Go9G0w5cqJikjI0P179//SIuh0Wg0Gs1hYeXKlZVKqczD1d7ZM+JVVfXBpbBauS70tlJqZg+J1KN8qZSk/v3788knnxxpMTQajUajOSy4MyYcNqqqLZa/3VlC/7aYvba2N3vBUcGXSknSaDQajUbTcyjAxj5guS8LWknSaDQajUbTRRSW0kqSRqPRaDQazT44lqRjJ3WQVpI0Go1Go9F0Ge1u02g0Go1Go9kPhcI6hpJQayVJo9FoNBpNl9HuNo1Go9FoNJr9UICllSSNRqPRaDSatmhLkkaj0Wg0Gs1+KNAxSRqNRqPRaDTtceyMbdNKkkaj0Wg0mi6iUDomSaPRaDQajaYNCqxjR0fSSpJGo9FoNJqu4WTcPnYwjrQAGo1G82WkuKmOddXFqMMQ5FodbObBtR/y5q7NPd6W5lhHsA7ydzSjLUkajUbTzWyoKeXy+U8gCNcNOYG7xp7Wo+3duuAVVlXswWMYpPhjmZKT16PtaY5dFGAfQ+42bUnSaDSabmZ15W6UUgSsCAtLCg5YPmxFqQ03f+726iNBospGRKgPh7p8XMiKsrJ890Edo9FoS5JGo9FoPjcz+47gya2fUBpo4M4x0zstWxqo5doP/05TNMi3hp7NtQOnHXR7f5t2Ib9Z+QEjUrM4s++QLh932ZvPsK2uigSvjwVf+TpxXt9Bt63RfJnRSpJGo9F0Mxkx8bxz7q1dKru8qoCQFSGqbF4q+vhzKUlDUjJ47PTLDuqYqG2zrqoUAFsp9jTVMyQl46Db1hxbONOSHN3WoYNBu9s0Go3mCDIpfRB+04tHDC7pO/mwtesxDL4xajJew2Ra7wEMSk4/bG1rjm5sJQf1O5rRliSNRqM5guTEpvDGjLtptsKk+OK6te6t9WVsrS9nes4w4jxtXWn3nDCde06Y3q1tar7cHGuWJK0kaTQazRHGZ3rwmQf3ON66p5Kv/+1FlFL86/aLGdE3e5/9OxsruXrxIwAct6sP/516Y7fJqzl2UQjWMeSEOnbOVKPRaL5EPL9oDTWNAWqbgjz9/qo2+/c01yJA0Iqwo7Hi8Auo+dJyLLnbtJKk0WiOCmrDAerCgSMtxheGk0bk4fd68Hs9nDxyQJv9kzMGcFrOCHLjUrl37KwjIKHmy8hed5tOAaDRaDRfEJaUFnDr0tkIwr+nXsHU7IFHWqQWLMumYEc5vXulkhDv77F2wpaFzzRb1k8fN4Q5vTKwlWJATlqb8h7D5LcTLvlcbe1prqE5GmZIUvaBC2uOMQRLHTv2Fa0kaTSaLzxzi9YTti0A5hWu/0IpST/+1cusXldIbIyPpx+6hcTEmG6tXynFNxa9yHt7tnJW7lD+Ne0SRJyv87zs1G5tC+CTyh188+OnAPju8DO5dtCUbm9Dc/TizN127ChJx86ZajSaHmfr9jKu+tojfO17T1JV3dht9V7afxx+00OM6eGSAeO6rd7uYNXaXYRCUYKhCDuLKru9/spgEwuKnazd7+/ZRlXo82fm7gorq3cRsS1CdpSF5fk92pbm6ORYcrdpJUmj0XQbjzy5mOLSWgp2lDPv7XXdVu/EzDxWzPoBK2b9kBMy+nVbvd3BBZeNo2m0ReaYJIYP6dXt9af54xiSnIHf9DAsJZM0/6GnCagJNROMRtrdd17uWDJjEon3+Pn6kFMPuS3NlwulHHfbwfyOZrS7TaPRdBv9+qSxYvVOFNC3T9s4mUMhxvR2a33dxZzEddSfEGWVlFIarqevt3tdYIYIw1Oz2NpQyfDULAw5tC/zxzd/wq9XzSfW9DL33BvpE5+MaXz2IsuNS+XdM39wqGIfEZRSvFu4jYhtcU7/YYfcV5r2sY9y69DBoJUkjUbTbZSU12HbCtMUSsprj7Q4PYZSig/3FJISE0N5sBHEmeZjVXkxfQe0VZIaw2E8hhDjOXhFryrUxLzCjVjK5vVdG7h73Gmkx8R/btmf3bqaiG1jiMUPPvwfy8v2MCWnH0+fecU+yhJAWaCev2x8j5zYJG4fPgOPYXZQ6xeDZ/PXct+K9wFheWkR+dXVDElN5/9OPA2PcXRbNL4oOKPbjp2+1EqSRqPpNrIyEvH5PIhAemrCkRanx/jjiiU8tm6l88Iw/EhsGDtskuNPAhyF6Q/r3qewsYZpGUO4d/EHmIYwZ9aVjM7MOai2Unxx9IlPpjzQSE5cIim+2EOS/avDxvPLFe/hNz0sL9sNCKsriimoq2JoauY+ZX+2+jWWVWzHZ5r0i0/j4rzxh9R2d7K4bBsv7VzDJXnjmJYzGICd9TWELQul4JWCTdQFQ6ypKGFidh9mDRpxhCX+sqBHt3UrImICnwB7lFLn77fvGuBH7moj8E2l1Fp330zgr4AJPKqU+m1Py6rRaA6Nb940nf79MkiI93PatOFHWpweY8GuHQSiUQC84iESNvCZJvFeZ+qPuYXreaZgJSErwselhYRtBTb8b/uWg1aSPIbBvJk3s7m2nBEp2ftYezbVlGMrRbMd5J5PXmdochYPTLoEr2G2jIDbn0lZ/RiT3ov+iakU1dezrqqUjJh4+iWmtCkb4/G6Lis56IzgPUljJMS3ls0mbFu8X5LP0vN+QILXz9dHT2JDdRlhy8LEZFVZMaDIiP38ljfNvhxro9sOx13/XWATkNTOvh3AqUqpGhE5B3gYmOwqVv8AzgR2AytE5HWl1MbDIK9Go/mc+LweLjyn7eizOdtX81rhOm4eOoXTeg9t2d7YFMIwhLjYtvOKHS4qgo0ErQh94z9fLNG0rH5sKC5jSkZfVtbs4pfr3uTErP4IYIpBv8RUGmvqMA1h5oAhB6yvKRrCQIhtNddanMfH+Izcfco9s/UTfr9xLghg+wnaUYqaarh52WNsrC9iRvYI/jD+qjbK0o+W/Y+1VSVsqinj/yaexa9OPIu8xJR2XYG/Gnch/932ITmxSZzb57jP1T89gSHSEm8kSMs5ZsbG8+zMKwGoD4eYk/8pA5JTOan3FyvY/2jHOsqzaB8MPaokiUgucB5wP3DH/vuVUktbrX4E7H0KTAK2KaW2u/U8D1wIaCVJoznKKG2u55dr3iRsW6yp3sPqi36EzzD56JPt/PTXr2KI8Of7Lue4EX0Ou2yrKou4YfHTKKX42bhzuHzg8V067txBQ9leV41SUPhuMTG7gqxJ28I7agNhZbG2ag+xHh9BFeGqweOYOX0kphgk+DpXBpdVbOEHq55CMPjHpJsYm5rXYdkXCj/G8Di5o6IqiFIeBMWG+kIAFpRtpiRYS+/YfZW/XnFJbK6tcJcTGbafi601yb5YvjfyjC71yZrqIr7z8fMkeWN5dOpXyYlN7tJxn4c4j4/HTr6WuYXrOb/vccS3M3lvks/PLaNP6DEZjlX03G3dywPAXYDdhbI3A2+6y32Aolb7drvbNBrNUYbf9Dhf/gixphfT/er/37ufEolYhMJR5i/adERke23XOoJWlJBt8XTBii4fd9vxk3nugit487LrSax3gpmNqGPR8IhBjMdDxI6igCe2rSDZH3NABQng9d2fELYtQnaEt4vXtNkftixu//BlZsz7F8OScxwrCsKE1AGoiEkCiVhRA6UgaimU5TziGyJB7ln9PN/95AnunnAKPx5/Gn+f9hVO6d1+Us49zbVsrS/vcn8A/G3TB1SGmtjVVMUru9rK3hUWf7SVn/7mVVas2XnAsoFohLpIgIDVfioDjaY76DFLkoicD5QrpVaKyPQDlJ2BoySdvHdTO8VUB8d+Hfg6QL9+2qSq0XzRSPXH8fSp17OkrICZuSMwxXlxn3/WGJatKMAwhNNPPTJBta2HiHfFgbCrqIr6hgDHjejD2CwntuhP913OS6+vZOL4/qSPTGJp2U5GpmTzraUv4jeEWf267qa6IPcEFpVvRoCzeo1ts/+Dkm0sLC6g2YoQKY7ywORrsFGcmjWciO0MzJ700oMEVRCP8pJkFhMKLOH53Qbvl23EVjbxnvn8etwVADyxaSX/Wv8R5+QN4+cTT0dEWFG5i1s+fAaAO0edznWDJ3dJ9hMzB7C6ugiUYmxa7oEP2I/a+mbu/eNcIhGLZSu388Yz38bvb380YGMkxDeXzSZsR3mveHNLTJLm8GDrwO1uYSowS0TOBWKAJBF5Wil1betCIjIGeBQ4RylV5W7eDfRtVSwXKG6vEaXUwzixTJxwwgntKlIajebIMiatN2PSeu+zbfKEAbz+9O2IAbExRyYm6aK8sby4cw22UtwwtHNlYM2nRdx174uIwMmTB7Powy0kJMTwzz9eww+/MxOAZWU7qAo1kR2XyKLzv0N9JEi/hK7HOp2UOZRHJ92G1zQZnNTWDdY/IRUbRazpZUhSJo0hhaVsFFDSXE+qP5a5597I+3sKmJZtEKy9gCDCtNhBPKImAoKyDW547wX6Jabw1OZVKOC5LWu5dtjxDEpOZ3nFLsKWhY1ifkl+l5WkW4aczMSM/iR4/AxOyuryOe/FNIwWpdU0DMToWG01RFqUWjmGcvZ8EdApALoJpdQ9wD0AriXpB+0oSP2Al4GvKqW2tNq1AhgiIgOAPcCVwNU9JatGozkyxMUduYBtgLHpfVh8/vcJWVGyYxM7LbtpawmWZRO1bJau2E44YlFb28T8RZu58uKJVEWauWXJbEJWlBd2rGGcfwBFjfX8cfo5jMvqWibuubs2cNfH/wPgXydfwvTeg/bZPywlixfPuJ5t9ZWUNjdw18fzAHh2y2pWlZfgMz28cf6NXDdsAuHgB9QFBFQzcWoX9Q0ngcCb9UXUBiPEmB7SYuIIRCOYYrSMAJvVbzSzd6ykMRrim8OndbkvRYRxaX0PXLADEhNi+OO9l7FwaT5nTh+Jz9v+6ykYjRBjenlk6tXM2bGSywaM11akw4hCdOB2TyIitwIopf4N/BxIB/7pjk6IKqVOUEpFReR24G2cFACPKaU2HG5ZNRrNl5+u5h06a8ZI3pq/ntq6AOkpcRTsqMBWsGLldh55YhG5I9KwJzvhl4FohKXVhYQsi58teZe5F1/XpTbe2b2FkOWkFvigeFsbJQlgRGo2I1Kz+eXKdwi7cU+f1pQSsi0MEVaU76ZvQgpe/8n4/DOIRlbzfNGZhMKO68owLbyGgQD3TnKCssdn9iHZ50zM2zc+lUXnfr9L8nY3Y0flMnZUx666hz9dzu9WLiQrLgEV10BdJMCS8gI+PPcHbRJhanoOnQKgm1FKLQAWuMv/brX9FuCWDo55A3jjMIin0Wg0ByQ9NYEn/nETAHf+ZDYAHo/BmvW7ASjaXEXSlBiqrGaGJmWxpb6BWI+XIanpzNn8KXFeL+cNHNZmSH5duJlblz9CcaCGa/NmsKDYh8cwuHLQZyPtbKUoDTSQE5vY4pK6bdRJbK0vx1KKqVmD+NvaBaT5YzjVDcYW8ZKc9jAAeQ1r8W57CwVcNmgsveKS6ZuQzMx+QymoqyI95tASVB4u/rPhEyylqA03gicAAnWRANsaKhiWnH2kxTsmUAqdTFKj0Wg0HfPtb5zOfX/8H2kpcXy8cgcA4XRFldUMwMa6Up4773rKmppYU1bCz5fMB4HmSITLh4/ep67F5ZvY3VxNyI7wVuknrLv0zpZ9u5uqSPbFc+PC51lfXcLotN7MPv06DBF2Nm7n3Mz/YIjN6LTTuXLGfxAjkxTvlcC+k+BePmgMqf5YmqNhLsgb2WJ1uert51hdUUxmbDzvXnjz55o25XAya+AInti0Co+YeEwvQTtCjOElLzaN5ubwPu7bRbt3cOeiNxmQlMpjZ13SpdGFAPMLC/jH2o+4YOBwbhw1oadO5ShGemTuNhHZCTQAFq5XSUTSgNlAf2AncLlSqsYtfw/OgC8L+I5S6u1uFwqtJGk0Gk27RG27w/m++vfL4NEHrwfggiv/SpUvgJJ9x42Mz+qDaRi8uX0LYSuKYRgUNza0qWtkSi62UpiY9PFnMuqF32GIwaxBeSys2IDP8FBSaxJRsLa6mOpQMxkx8VTX/pFTU7Y5lVi7wbBQdh2R0AL8cZfu04aIcFZfJ4lnZXMT/1q9nNzEJJaVOjmVKgJNFDbUtkxLsqhsC3XhAOf0Oe4LNV/bjydO57oR40mLiUWAtTW76e9J45pb/0NVTSM3XT2V6y6bAsC9y96nvLmJhnCIt3Zu4dKhBx5laCvFrfNfJWxbrK8qZUbfgfRP6t4Ji492FD1qSZqhlKpstX43MF8p9VsRudtd/5GIjMSJVR4F9AbeE5GhSimruwXSSpJGo/nCUxVs4scr5wLwmxMuIM3fs9NM3Lt0Po+vX8WE7N48f8GVeDtRFHaf1ExzZhSU44rYm0zAtm1Mw+DHJ06nNhQkwevjxtFt5z7bXR2gdlcKlhHl3boSQspCsJhfth4b55k/OCWN/Op6JmT0Id3vWIkaIrHYMU5b5aEc8mJLEfHg8XU+Gu37899g6Z5CfKbJtH79WVy6k7EZvRiYnA7AW3vW85PVrwGwvqaYGb2Gke6PZ0jSkXdniQh9Ez9LUjklayALlubT0BTEthUvz1vFsGm5RCyL/knJ7GisJqyiDE5J71r9QKLPT20ogIG0TDOj2ZfDOLrtQmC6u/wETtjOj9ztzyulQsAOEdmGk4R6WXcLcEAlSUROAKbhaGsBYD3wnlKquruF0Wg0mvb428aFLCp1rCZ/37iInx9/To+1pZTiyQ2rAdhYVU5+dSXHZXSsIDRnR1EmEAXnNesoLg+9/TGltQ18+7ypPHP+5R0e3xQOoyyTUEiRmABhcQK3rbAfvM0EozbFgSA+POyorSGqbLxi8tjOsSyPr8XAZkXDKbx99oWIkcozW7fy2KY3uXzQcVzffw2R8Arik+7E43UsKRHbbkk6d/mgsTx25qX7KIG7m2uxbIuIsllQls9LhauwleKRk77KhPSOM4AfTpRS/OiTV5lXtJ7Ts4YhAiKQcVI617/9AoiQ5POhUPhMD7saa7o0wlBEePWCa5m3YzNTe+eRqed8a4NCsHtmdJsC3hERBTzkpvfJVkqVACilSkRkb26JPjizdOylxxJOd8akNyMAACAASURBVKgkicgNwHdw5ldbCeTj5Ds6GcfctR74mVKqsCcE02g0mr3kxCbhNTyAIieu56a7AOdFOa1Pfz4uKSLFH8uA5M7dLZNTBvJR/XYSzBiGpGaztrqYExP78dT7qwhHLTbXVrAlvoZYj5fHz84mFH6ARP8JDEz/AyImZw0czI1jx7O1uoo7pkzlpcI1+A0Pc3dupKhWiDU9hKwINoqIbbO2spjKYDNb62ooaB4JKKKRWqKRnYTFIlB3D8+esIG1tb1pbChFsIhUrSYjx8mC/ZfTz+VPy5fQPzmV8wYN2yehJsDl/SewqqqQ2nAzISvK7uZavGLyyNYF3PrxTiamD+DBidccVjdcIBpBoCVmqibczP92b8BG8X55PtneOCQo5NdWEsq0UCiSfX78pokBZMcldLmtfkkp3Db2xJ45kS8Jn8OSlCEin7Raf9hVglozVSlV7CpC74rI5k7q63LC6UOlM0tSPI7QgfZ2isg4YAiglSSNRtOjfG34SWTFJiLi5PHpaR6beTHb66rJTUwm9gDBzMuLKghHYwh6fNw17Qwm5PTm3TVbuMf7JpbXZoenlgaaaYhAWd3fifU20xgoI8l3IZlJp2IaBj886bN8RD9JPxOACVl9uH/t6wxN6oVpx/Lunq1MzerPte/NxhDB9Ebw+R133PPjnqeh5iEALuwDhijGphQj7ntD2Z8Z/nslJPLH0zq2xCV5Y/nniU5aupVVu7hzxYtkxiSwvGo7lrJZWb2T/PpSRqV0/OG+qryYB9d8yLQ+/bl51MRO++9ALC0u5Ia3X0QQnj7nMibm5JLkjWlxbyrACAtRZZNd4iNxWAJh2+KBU89jdXkJeUkpnJijZ2PoLhSfK+N2pVKq04n0lFLF7t9yEXkFx31WJiK9XCtSL2DvXDldTjh9qHSoJCml/tHZgUqpzzc5j0aj0Rwkphhc3L/tNB091p5hMCQ1o0tlh6dlsqW6EkOEfkmOlSu7dyJ1A6IoBd74AKbXcaEVNSSRlxBGsNlW6CHTjSXe2VhBWbCWE9IHtUzb8uiO58hM2U25VcDWimw8PsXSym0o8RKwLJL8HnBjlnJjGhEcpSFkmSBQH/GTHRMGFKb38037MiE9jwUzndF2Ny19lI11xcSYXvrGp3V63Nfmv0xVsJmPSosYm9GLBK+fwSnpHQbCd8bs/HWELOc8X9y6nok5uWyvryKqbETAUoqZl4yhdnsjN199MgP6fXbdjkvPOej2NAdCsLp5dJuIxAOGUqrBXT4L+CXwOnA98Fv372vuIa8Dz4rIn3FCgYYAy7tVKJfO3G0P7rdJAZXAB0qpJT0hjEajOXaoCwX57ccL8Xk83D3plANabL6o/OaUM3lg5TLOzBvEUwUreHP3RsYk9cUwxH25R1vK/mXDBZxcuZuK6mz+dsc4APLri7ll2UOICCdlDGNndRSf6cGOLcEQ8JpRUhMbaAz7wR+hrj4BwwNpvjTKwxUAFAVS6RtbA8BP18+kKhLLnkAm888/jTgpwB97wSGf50Mn3sCG2mIGJmQSjtosKt/BpOzcdtMGxHt91AQDKOBbC16jLhRiTEYOc849+IkTLhkyijd3OhMyzBo0guLGeryYKFvAUChbuHLmCeQmpdAQDnHn4jcIW1F+ceIZpMXEdVhvSVMD17/9Ao2RMI+c8RVGpR/5wPSjgc9pSToQ2cArbg4xD/CsUuotEVkBzBGRm3G8VpcBKKU2iMgcYCPOP9i3emJk215hOmJlO9vSgD+IyGyl1AM9IZBGozk2+N3yRbywdT0GQoo/hu9PmNptdStnmFmbxI09wU1vvkJpUwMLdhdgJocI2xaFjTXkJfaitLmRNG8SRdFKUMLQ2P6srU5jbP9epCQ6CRy3NZQCELDCLK3YSnG1FxGYPqAXAYrxikEw6kHEsRT5TQ8BK0pjsJrv9FuGIYo/bLmMC3t9wKb6HC4c/i0W7tnOnQOOIz1hMDClS+fxXP5alpTs5JujJ7drgfEaHsal9aOyuYmTXvsLps/CH05gzVV3tin7zNlXMGfrOnrFJfLL5e8TtKIsL9u9T1qFYDSKIcLW4gp++9oCJg3K5dvnnNxSR9S2CUajnJI7gBVX3wbAvz79iBvffZE4r5eBsX3Y1lDO8OQcdjXW8W5RAXua6nitYCMKRVMkzLbaagYmp/Gv0y5so4Q/vWk1W2ursJXiz6uW8J8zL+lSP2nodkuSUmo70MZU7M7nenoHx9wP3N+tgrRDZ+62J9rbLiL/BpYCWknSaDSfG7/Hg4EgArGe7stGkl9dweXznidqWTxxzqWckHPwM9J3WHdJBbVNASYN6tuigAWiERSglGCIQYwppPnj+MmEUyhuruPtbQXsrqlAKcX6HSVIk8GH+btYUVDElKF5TM8exatFKyhsqmJ80gher3NG8R0XN5ntwbXkxuSyvGgDfn+UUMjDtOz+7Gio5ht9P+TUtE0IcFZ2IfGeJk7PLiIprZpLBl7UpfMJRiOsqSwBBb9Y/p6rzBSx4orbOzzm8fXL8cVFEIGop57ChlpqQgFGp2WzuqaIRG8MQ5OyuXP8NCzbZt7OzSwtKeSaYeNaFKSFe3bwtfdexmsYeAsEq1GxZmcJg3IyOPf44ZQ3NXL+M09TEwhw98mncPMEJ6njK9s2ErYtPJbBFcNH02g3MyQxmxveeRFL2ST7YogqZ2qYZcWFNFtRygONvLlzCxcPHrXPeYzN7IXPMBERJmZ13z3yZUcp6QlL0heWg34yKaUCh+PrTKNpj6LKWmylyMvUCd6OJjbWlrK0bDtn9RlOvwQnnuWuidNI9cfgMz3cPLr7MhvPzv+UulAQgP98urLblKR3P93KHU/NQwEXjB/Bb66cCUBOfAL1oRDY8N9pV7GhtoSMmHhuX/oStlJE7AjihAkRSg0QUxpP2LKIWs7LPN7j55ETvwFAcaCUWlmOISZL615HzGbKGzcR5+lDfXMsftPDgyd9BYA1u5bgFacOr7g5kMXAtqsJNj2B1382psexCFUFm7l98Ss0R8L8ddqF9E90rsGF/3uKHfXV+D0mSikE2uSEaoqE8Jom5c0NPJP/MalxjgtLuYHTZ736HwSY1DeDjU1FoBQPTLqKqVmDMUTIy/RTELXolx7TUueTm1YRti3CtoUv3sDf6LRZ1eBkLP+wsJCmcBhLKR5fs4rEBB+GCGcNGMCcwhV4RPG3Le8Rsi1MMQjbJiDUhgNuripI9sdAOIStFAOT28ZQnZU3hBfPv5rmSIRJ3ahIHwvoaUk6QEQ8wFdxIss1msPK+59u466nnOn8fnXl2ZwzftgRlkjTGY/mL+UvGz5gREoOW2rLiSqbhzcv5fzwOHaUV3P3RTOYmJOLzzQ7TNa4qbaUXY3VnNZrKD6za4+rU3MH8OymtSjg7AFDuu18XlmxoWWM8QcbClq2b6mucobnR6P8aPlc9gRqGZWSQ9iysJSNGLS4yiTGqcEQIc7fNpbnpaJ51EarnGxLJpiGwlZwzZBRZHjzOD69D9e89ys8ZjnfGxgliqsk+Sfi82ZieobSVHsHTpjGz4lN+g1WdCOzC0ezpq4AUPxm5Xwemn4ZEcsiv9aJaQqHLX40/lQqmhu5dvhnCS9fK1zDz9e8TqzpJRKOEDGioIRZORNYUVXI2JQ8XqvPJ2JbbKovIUgEU4T1NXuYmjWY7Y2VvLVnAyE7yoOb3ufmIVPxGCan5Azg/aICBOGaMWN5Y1E+g7LTuHKq43GZnNsXn+khatukJMTww4VvAZCZbWN4FKZp0RSJICKuC89L1FYk+2LxmSYRy+Kfp11EaXMDfROSGZ3RfgB3e9vLmht5r3Abk3L6MqSLSSg1X146C9xuwInRam02agYWAt/oYbk0mjYs3ryTUNSJzVu4aftRpyRt2l2O32syMLvtgzdq29z75nw2l1Xy85kzGNP76B+V84/Ni4komy31FUSVTVTZNESCvL5yI6GwxS0vvURlopNh5HfTZjJr8L4jsDbVlnLFgv8iCFOzB/LPKR0nZGzNyPQsRqRnEopaTMjq3W3n85UTRrFoszNP2/QRAz7bEbIhBpTHpiRQj6UU62pKnIFnBhAF5T5pL0zdzl23rWBDSRZl5eOxe+cTNMZy5+pXKGyuYkxqhJPj92AhLKrpzfFJlWxvTiJO0rh+6ERmb5vHqf0+RETxabMwMMbJCJ2SdAMxMWdgRUsINOwN07Boqv8pEOG05EweijkPgBrazwM8Obsv47P2Hdb/zI7lRJVNwIpgGxHEAJRiWupAfn3iLMqbG1laXERNMMCFfUcxu+gjBIOpWYNRSpETk0Scx4dpCb3jUlpyK63YtQepN52s1kNj+fj+fd17vRMTWXrL12gIh7hyzvPOW0iBFVb4fR5spYgGPZhem2jIZEavgRQ21fKLKWdwUi8n4WVRQx3P5K9mcHI6x6Vndyk+TSnFha8/RXWwGVMMPrziG50Gfx+LKOiRudu+qHQWk5R4OAXRHJsopVi4cTte0+SkYXmdPsiunDqW99ZuxVaKr57SdnqH7sKybQyRbg36fW7JGv48dzEK+PP153HKyIH77H8vfxtz128mEIly12tv8dY3b+i2to8UUzIH8GH5dnyGye3DTubdki2ckjiYJ1esxecxicYqAtEoBsK6ipIWJamirpH567dhZisEIWBFyK8rP0Brn/HIpytYV1GKrRR/+GQxD552aCO7gpEoJfUNRJVzXyilUEAkamEYgh2D+xIXEj0x1EUDxCsf9RIEAWUJynL23zd1CaahmDqwkKh9G3adQdROZEPd6QTtKBP9SzkreRcAFyRuJ90bQCGsjl4JQMiuQyF4DZsqO5asnE9QKOqtWJ7e+gEDErOYYA7FsraAZBC2avCKjSHRltdabnwSu6pqifd79+oeGECqP7bNuUujiVIQUTY+E5Q4p9o/y3Ffba6poDoYQER4p3gTURuUKH6z9m1WVu9mYEImL07/BgUNFRyf/llam0Fp6cSaXne5/XQCsV4vsV4v3zv+JO5Y+AaihP+bfA6hpCAZvkS+9v5L7E38fP/JZ5ETv+8r6zsL57K2ohi/x8PA5HTOzjuwVdFWiormJqLKJsYUaoIBrSS1QbS7bS+ue+0cYLi7aSPwtlIq2vFRGk3X+e8Hn/Dvdz5CAXdfNINLTux4EsphvTNZfN83e1SedzZt5Y5X3iApxs+cm64iN8XJe7O8Kp/lVVu4oM9kKkN1VIbqOS17rJsF+sAs21JIMOK8qD4p2NNGScpOTHBGLnlMeicntVvHD1c/zCfVWzk+dRB/Hn/rIZ3n4eBvUy5lQ00p/RJSSfHF8vURzsilsfG5FFbWMmZYb763cB4+08ONo508c82hMGfe9yiWrfB4hBNn9WdbQwW/PP7cLrc7KCUNr2EAwpCUruU62p/CmlpeW7+J43Ky+fbL8whbFjFiEkhSIPDW5i3M/VU+fsOEFqOfUFtlYxqxeP0+MIJgu+Z4H4DCQjBaRt6FQdnEShCTCB7xMC6uoiWXcbYv4LrpFCelORasKVln8tu175EdX0dd82kYpmOVvPXDB4lR63g5ksC94x5hYlYuyyp3MX/3zxgSV8yLZccTDHoQUSzOL+eDuU9iGgZjJuSwtrqUXvFJ9E1MAZz23i7eQF04wMZAIalJAaKWQTQag2kIhgiZsY5Csr2+GqUUQSuKWLHEmF6UUqys3o0CChoq+Lh8Fxf1HwPA0vICiptr+cbEExiWkUGcx8up/ft3ei3G9+3DmHAWIsLYPr2YX72ZTF8C3rgoCBhxUfd674vXMJwPHSXt7m8P0zD486nn8uCaZZw/YBiDtLutDU4KAG1JQkR6Ax8AJcBqnA+I84E/i8iMvdkxNZpDYdX2PQTCjs69Zmdxp0rS52VDURm/mPMu/TJTuf+qs/F7O1ZsHl66gohlUx8I8e7mbdx44gSKA1X8ZN0ThOwIb5QsJ2pbKGBNTQE/Gtk1F9DXz5jE2p3FxHi9XDalbcbo43N789AVF7K9qoYLR+/rdrJtRVmomhXVTq6YVTXbKGyqoF98Ztc74QhgisGYtLburr0KYmNTiPOr8vB7PWR4HSvG9vJqLNtRIqJRxfW5UwhKlEmZXZ8zbExGDoYYWMpmUq/PAnJD0SgbysoZkpFOot/faR1XPjmb6uYAhhvzAhBQVsvUbM0xilh/yEnc2GoyBMuGsGURjATw1sVgeW2M3mHHoqTgq2vP5seDlvNhdS9SQzbn5m7ntc1jCXoEpaKsbspkZsouFBC0PcQZUWwEy3Rcy0HbYmHxUBQ2o1PjKaqtw1aK81Nf5tQUR5F6ZGcukzJ+QN+4dN6qGcHbNSPxRP2Eml1BG6JI1MDnUaytdtIPVAWb+bSqlFjTS35jMfeufR2FIj05gM8bduRp8FMbtfBGfMSZTv9dMug4PigqoKS5gfsnn8UbpatJ9yXw9/VLUYbjlEn1OVOCLKvYzrc+eg5bKZaWFzAr93jivQa2UizZtYvhGRlkJzhlI5bFvW+9T355JdkSy7bSKkSESxc9TLOE3c4GDAEbgsEo7GcI+/v0Wfx1zVKGpWYwI3ffjxJwrdh7dtAUCTMzbyimq0jNGjiCE3v1I0NbkDrkME5we8Tp7DP418C/9s+HJCLfAX6Dk/1SozkkDsf3yC/mvMumPRXsKK/hzdX5XDRp36HAZQ2N3PzMy9QHg8wcMZT8skpMQzixv+MeiLhKEUDYdmZ7D6sohc0VXZbhuH45vPmTmzEN6VBJmzKgH1MG7Dt9wrOLV/PbVxfQKz0e3MndBUjxfrEm3tzdVEtNuJnjUnrRHIngMQxMA7Y1bqVXbC+SvSltjnno8YW88e6niAhxcT5uvHoqI/tk0SctiT3V9fTqlcTN77+MIJzWbyB/P31Wl2SZk/8pzdEIAP9dv4rJvfqilOLyZ2azvbqa5JgY3rvlRmI6uA5KKRpDYWylMPe/Qd31EX0LOWPCOmwlPLt8CuXBJFAgjQqJB2+zEI5XIAaDYmr463ELabI8rG9IZ1RCNeneEJc8fwm/rzoFf14TniFBFLCgvi8nJZZgAY+Uj2F6UhEFoRT6qCTOiYO3i9Zyw8glpPibeX/3MGY8XAvAS5eWEGtGCVge+njKAMiNS+M040RWVxRy27hT+HPpEgJWlBuOO56/lXxEcmwsuanJbKqtINHr58a3XiIQjdIny8Ai0mLZFBSGmNR5QkjUR8Qb4YHlCzljwAjGZufwxFnOh8L3P57N/NKNiAixPi/NUSdAPSfeuVdXlBY6FieB94u38GbRJgCSmlKpqHasrP/+ynnsCVdDo4cXNq7HEkWq+InxeVBAo6sgKQWG6Uy6YhhCWmJbV+Hr2zfxfP46Enw+zug7mN4J+1poX92+kXs+fBuAjdXl/HDCKQB88/3XeHfXNgYmpzLvouvxd3HAwLFCD05w+4Wks6t/olLqhv03KqUeFJH8nhNJcyxx0vD+fLS1CIApQ3tmfqW9Ck4wEsXnaTuK6uU1G9heWY2lFFsrqnjjm9cR7/eTFuc8ePPis/j+0Iv4sHIjF/c9iVd2L6UsWMsdwy/usgyLNu7g+4/PxTQM/vutSxnV1/HRNIcjbKuoYlh2Bv52cgX9Zd4SlILiqiZuMM8kkFHJ+X0mk+T74nzlLi3dzo1LnkEBE+L7sW5NHV7T4LQztlNvVyMIvz7u92TG7Gv58npNxHDyJIXE4l/LljMyO4u3fnIzAHO3beKOJXOxxOaTsj3sqasHoE8H7si9zOg30B3dppjpjm4LWxYby8odV4EdYN6nmyivbmTm8cP49/bF1IYD/OL4c+gVl4yI8K9LZ/H3xR8xNCuD51ava6nbFwTbgDH9CvGYNrYNw3JL8EbCNDf6aapMIr7JpskrkOi8SL4/cBWD4mqxlTAioRqPoUj1BZk8eScrw1lEAmbLPXp1xiaSTUcRODlxNw9XjUEpSKr7mDsWL+CknBq+27+ILE+I1FyLzXtyQeDRHRO5Y+gSikNJVJVMgXHw0c4iXl+5lUAkyq9KFhCyLSKWRTDGJpoHZrzJroYaLGVTGwqAbRBWUUoaLXxxgIAnaNM7vRbbFsobc1qG1z+zdR1Pb9zIiIxMXvqKk0X7oz1F2CZgK8JW1HmZ2optlVUMS84mmSSImNiGTSBquy5IqLYbgFiUKO5c/YKzUUHUEwsItSrEE9dfjIhw0/rHP/uyEmdckSFC2Lb2NyTx1KY1RJWTkHJx8U6uGDpmn/076mqIWDaWstlWWwU48Yh7s3tvra1iS3UlozOP/kEU3Y2tLUkAtDuxrUtzdwuiOTa56uRxDOudidc0GZ134IfR2p0lKKUYN6Dro5aCEced5zVNGoPhNvtH987Ba5r4BCbm9aFvalurh8/0EGN6SfDEcv+YG7rc9l7mLF1HOGoBFm+t3sKovs4Q8VkPPUVlUxN9U5N57etfbTMjuzihNQDkenO44rizD7rtnuYvyz9wXvICKxsKsTzxhBTUWdWIOMGw88sWcWWek9G4oLSKkpoGbrp2KvHxfnxekzmNBeQvrsRrGMy+9gqOy8mmPFwPCSFMoN6q46xHHwfgr7PO5YwhgzuUJ87jbXFvJXodt5Df4+Ha48fy7Jp1HN8rh1+/8gGRqM3TO1ZQn9FI1La5b+3b/MMdQTdn7XrWlpRS2tjYUq9XhNiAQThqsXbTALIzq4laJnVeHzGeCD5/hOTJTZhem8RmL0NTykjyB9keSGSq7UFQ1EV9ZPsCxBpRxqeV8u3kdTxXNphS8RDvDZPubXJe/grSPJ89ZjfW7iJopRFnFTPQ14RXFDPiKvh9WgiANZHe3LjlUlRUuDlrHbWVz5PmPZtANIJtQnMkQiDq/B88tHYFzVaE3Y312P4QveJqqQ4mEcJEBLx2DKNTMqiLBEiKbnRSGKBI8wcpafYhgG05STTXlJW0yKhq47H8QWxLiIRNJM7CjhgkmY5Cn5Hsw/DaKBRKPvt4MTyCBXhNwUZhqb2BXIACW8HU4f2dwuvdKXvdzONhO0p2XCKmtYLqhnyS4y7FNJ0calcPH8sfVi4ixvTwaWEZ973xIGcPGcIfzp2JiHDBwOE8tuETIrbN1cPGtZyHhATlU2CBivbIxPJHNUqBpS1JACSLSHufygJ0/imn0RwE4wd2PJt4a15fsZFfvTgfgB9eeCqXnzTmAEc4XD11HL9/fSGxPg9Th7eNbTl5UB5zbrqKhlCQqnA5V83/NqYVxx+m3EOvxBSKmiv4/aYXCdkRPq7K53+n/rLrJ+fylUkjWbZlF4YIp49xXvCVjU2UNjQQsWy2VVTTFAqTGLNvrMzdF83gvpfmk5eZynkThrdX9RFnsJHFWopBgREyCcc6L5aQZeI3nZQNtbVxvFSwlsysRL71wutYJpwzcAh/utYZlv7bP63AVoqQZfHIuuVsXFxB37R4N0EiWGJhuZOczt+2vVMl6X/b81smRJ2z5VNOzxuEUoq1JaX4TJNt1c4cZ7ZShKJRwrZT1rYVG0rKSI6J4a1NW1BAeUMjpoClHDfckD4ZVDcGkJgiTBSIjbLEzVakML0Kw4BhWaVMSCpEUJSGEvhz6WiaLA/39FqDCASiBtdlb8Mjip/mreJX5SPAELxitWgPrW2eKbFhUuNLabASidoGUSC/KY2xKcUYSmEaEygI7iDRNDin1+NEwhFSZDmJabdQE4qjWUWwMiIogdHpmVR4txCNeLi0z0fkJVfREI7hjxvPxjIFFRWenvZ1AM574//ZO+8AO8py/3/ed2bOnLq9b3az2fROQkijd6QjTcCLWBDsXuVa71X0erELiiJ6rVeEi7GgdER6CwkhfdPrbra308+Zmff9/TEnu4mbQBBQf5fzyR/ZnXln5p2Zc3aeecr3+Thh7VfppR2/XYrQ0DIugWsNM8GYzrm/+RV9mRTH1I3j/i3+u7VZArm0R0AaBIP+Y8bDwzIkeeX5CemFc6sORnnoA9eRx+O4B77l60kBMudX04XU6JWImjZJLwdiNAweEdvp6PsuoEik72N8rd8D9brZC7l08iwMBAtu/SEaeGDzFj567BKay8r40/Y20o6DpzV3bFrNieN8WQcjJSHtn6dxQMK30hpPKSzj0JpebyWK4TafJ4HD1c4+9SbMpUiRV2TN7k5yjosG1uzad8RG0hXHH8XZR08jFDAJHKb9xdRavwrqmie+TbgkgVZJfrHxHj676BrkAZlTAsEHV36fvlycL8y6klmlLUc0h1PnTOaxLzZhGIJowRCqi0VpKClh9+AQU2sqeWBHG5sHO7nuqOOpjfgJrG9fNIu3L3rjk9nfSKZVN2I8sxnP0ASsIHnpYAhJe6oM23BxlMG2VS+hNm8hWyHIVPiPx0c6RgUZQ6ZJzvUwDMH9e7bgasXO+ADTx9WxLzPEWdWzuHvXJgCObnxlL+J5E6dz16a1KK25YpovTpj3PNZ1dRcqczTvWnoU2/b1UT3dYlnnagA29fZw5dO/8b0UGUE2qPCyClUICxmGwdaefpTSXDB5N4ahEcKjxMmzZ7iabNqiunaYYMihVKeJSl/1u8FWrMxXohE8EB/HZRU7GXCDNBhZlPa72CMESknAGJGekCiuq1zHxkw5T+pxICRpLXj3mrOZEB4mS44rmp8HYFdqkPfW7WR3thyFicBFaUlOS7SlcEwPaYFGky/dSUhksYXB5ApfWiFmZ6mOxunJl6BkhqU//S45laNkgkF7uhRPCxzPICAdtCNRdhxTavboDfSJEsxSl4fahwmXOihPEjZL6c2nEQKmlPvfrSo7MmKQBj2bRNpDa0FLeSUXPfEjpsRq/GuB7y1a2jSOPf0JvnruGSP39hOTT+dr6x6hziqlriLMiwO7Obo8ihASrbO4XjcdqWdQ2mVc5AQqgmG01kysrGBfPEE0EKCmkCM1pbyKgDRACCrtEKf97qc0xUppLiulJ5HClJLGkhKyjkNnMsnFv76LdD7P9847nNesPgAAIABJREFUlzNewUj/v46fk1QMt6G1fvfh1gkhiu2Si/zdueako1mxbS+e0rz31IWvaVsHRUAf2nWe9zy+/+TzDKazlJZVEFdDgKC1vJ5N8TYaQ418cdZVLO/fTMS0WbbnGRzt8v0t93L7MR854jmURoIH/d6TTLEvngBgW6qD+4efwLQU1z3xAvec86XXdH7/SE6e3Motjz9HJu1wxdI53LlpLUHDZHZsIusTOwgIi1w0h7wwjtgeRWZjKA1NlaNhzZvedjpf+vPjTKut5okh33gSCH5/+nuwpMG/3f/QyNgVHR1cMsc3HG985DGWrV3P2dOn8I2zz0QIwfzaBl6++sMorYlYvoVjmybvnH8Ud768huMmjOeGs45HCsF3XnyKghuIgQGHrCOwDEkoI7D2gRESJCa7EM7hDIWwtYmjPDb3V1Nd2Y9CMJCLUVkVJ5uwmR1PcFblLvYUniFCQIuV5upxz+Npwde75vLR9sVY5LmyejWVBvR60J0LI5DcNTCJj9RsAKA1mGIKKRZHutFonkiMR2lYm6hhbaKWy8cvxxQeCM2ZZaspNR0mBAf4Q/9MLJFjfbqB6+Y/ybzyTr694STaMs0IBJVBRX1wNynPZn2inpnRTnryMfqdEKZwKTWyXLT4GV8uoGMicRXC0xI7mPfDwUE/HOh5vmFXWZ1ACE04kvcbnwpNb48H+SA5x+XGVf+FYW2jO9OK1r43KmtmMaK+O2mVux2d1rSnBjGExNMaSxp87twl9OaGWFA5ahT/6OlVpOMBOsw8e3ODEIBlOyJcO/EKHHctQ/pYnm3/NBqYEruaJQ3XIYTg9++8ijVdncyoqSFo+fpM57VOpyoUIeXkuXnVM2wd6mdvYpgyO0SSHCXC5h133c22/gHmNzaQzOXwtOYnK1e+pY0keOMb3P4zc8Rp+0KIUuBi4EpgOnBkMZIiRd4gmqrK+NNnrnnN2331uSf58csrMaXk4Xe8i9byg8XrfrNqHb9YvgpXKU6bOoeTZs2iNlzFqtQTPLXt95jC5KbZ3+C46pm8PLid3+19lqAIMKP09SWal4dDlAZt0o5DeXUcQyqk1ETLRtU14k6aBztXMCFSx8LKf06F8bbuXhQaQ0ruXbuJXMrFlR5Ts4v43NJ30N4/yCfc2xEG2DMSfDJ6Ju3xBB9asnhkH2dMmcwZUyazLxnnhLt3gNZ4WpN2HEptg3OnT+OBTX5C7TH14/jU/z5IS3UZd672PUb3btzMJ44/lvoSX7/nrzu+A3zxtJP54mknA9CeepbuzFq2dNioPWGQGtczAb+n2scuOJG2DZ00Tinhf90/gdC4uRRnZE+mN5FijezigZ6ZuJ4kVJlhXDBJKKb41rgVmBLySnBnogIDzQQzjyU0Jprzy7bgygQpFaDPC5DBYcgNcXSkhyojx5psGT8a9JPNP1y+daSdyQx7kDWZanYnY0yu7SFoubjKZK6dAiDpGSgNhlAkFDyXnM5R4XYurVmPIeDmY/7Ix9d+mZSbZ37sYZqCPYDmueGJvJxsYm+2gqbSOGEjR42VpMRMYQjNjPJOdjvV5FyTXsfPLVJaMNGaxUDS4/jmRu7v/QsaKLEthhy/qjAoPFIaykMpWsqeQ6JpDPeysm8pIP2UI+mfm0IjUSgEi0pbcfE4Z/xEblj9fQSChZUz+I+ZfjH1xMoKBtJpPOGhAn6lnGN5JMRHmFpbw11Pf4jGWg8pNI/veJYlDX5ziHDAYknz2O/rknp/2QM7N7N9eACtoSufAAlxnSMz1A8IVnXsG8kNnFP71vYRFHWSDkAIEQLOxzeM5gMx4EKK4bYi/wC6U0k+8sj9eEpx6xnn0BA7stS4X6x92VdIVorbVr3It04966D1+zuTCwQBI8C7pr0NgN+t/BkajStcenO9RMwI88on8oMFH2Igl2Bh5ZTXdT62aXLv9VeztqOTlNHB7/t/itYQFqOVa59b8wva4nuQQvLd+dePMcw87fDywO/R2mNexSWYMvC65vS3kMjlfM+CUtiGQcgy0Rqm1FRTH6pAxCR4Ao1GZA3ed/IxGIZ/zVVBE0lK/49uTTjKhJJy9iaGmVRWQSzghyZPbG3hqQ+8D4Hg3bcvY1tPP4YEXVq4DkoRtsYaRodiILuNRzv+DYFiwdRSHtv6NrSrCQZMkniYhsQLwH9dfw5/2r0SsVX7Cc3BPDeeezoA5z3+KJVBP6k7ZPg5NhMC8RHJAEtolg+2EDPzDFo5rqvZjNICw0ih0NjCYUeuCk8IwlpwZdkOBDA9OMh9KV/bqccJUGP5hQbjgkPc3PQ0u50In9t7HIaUXFTXNno8qUbOL+WZhSo0f5nyc5BZP9CNpxUlRhxTKDwtWFKyHVNo5kTbySkTW3oM5MOUGhkEUBcapptyAobLzNheZkY76cyV8ItnqxhI2UQSOa5dcj69uSEmR8fz7c13Y0uL3NNhIiWSqJSwwPeoSa3356SjXBCGf++bYgMsqdrJvlwJy9dHIB2ko/sFIo2CrMqzLTnaKvS2C87jka3bCJoGX912OzPKOmkbrsMoPLTXb5yDZ+7GlB4r1syD447oI8HXjjuLk8a10hCJcfVDy0i5DgKBUr4auaDQYUbD+u4jV3//v0kx3AaAEOLXwAnAI8D3gceAbVrrJ/4+UytS5GBue2k5K/b5fzBvWfE83zjlyCq9JpSWs2mgD4CljWPfJi+dN4tkPs9QOsN1x46G8QT+g11phSlGkzWnxBr914U3gIpwiJMmt7K8vxs5INEoyqKjX8v+fAJH+2rPQ85opZXWGlcpXh78DS/2/xrQ5FSK42qufWMmdhj6crtYM/AnxkePpjlyDF2ZTs6bOZUt3X10DMf59OknsL1vgJhts6DZdzaHwwFs28BRHuESi18+uIIdHf2cvHQy/3b3gxhS8qvrL2daQzWmlPzh/Ct5Yc9elraMBxSOymPJEJWF7vO7OwcQhofr7n90gSEFTiHf5XCs3dPJshVraWpeSbBUgQDLHObm895GPJejPGDzqT8+TEU4zFnTCwawJ0cSjLWGj/3qXnoTKWoWJAgYBx+v27NxERhak9WCTzYsJygEjyeq+VrXXLLKYFKog5nhfTja4IzoAI1mnk7XAg2W1ESEO1JmHzR84yzrGTRYOaSAZitFhZll0AuzMtnIJDtemJxESg9XC+yC4bQ6NY7H4z20BIf4bedMvnLMMizp8sxgK0sqdhF3bWoCSYQAQ2sCwsUUmspACkdJhNDkXBNP+TucGe1ECKiz40TtIfqdah5r38W89kY6Ey5bq5aTU3k87RFsNDBXxqDMZt1wAw2hYXamqmgsi2NKhch7nD5uM56SlJopbOkxKdJLT3kVG4bH09EF505roiPTy0cnXzJyjU0DJjYOE5ZlvEu/QMDwOKZyNzXRQosTo5m77z4FBJzQNPa7rpTmW3c9xsrNe/nEZSexeFYLAAHD4PyJvojrT065iO+8+BznTpzKbc++SCqfZ0ZtDW09vVjAya0Txuz3rUaxd5vPLGAQaAM2aa09IUSxHrLIP4yc645qHhXEAo+E3158Bf+z7mVay8o5a+Ko9yftOOxLxmktq+B9SxaM2a7UKmXYiWMKg7D55oo32kaQ/fU+lhj1iHxx1pX8YOu9TI2NY3GlX902nM1y3rI7aE/E+eQJabTpewwc9UqqHW8Mv9v9adLeIBuGH2FLuoKskpRb5XzzzJtHxjT/lYRCxvMVm7XQZLwct93zDBrBfdu34EgNeNz652f5wbsuxPUUb/vWLxhMZmiphUvOuRd0lvGxizm5/pP+/sd10nr8brKpAHr7WbQrj8vnzqIqcvh75HqKn235NM3Tu+hOBWjGr15ylcE500fDmGdOn3JQzz43EyCdDBIM5xnqi/BE2w5cpThuoRoJhXnar0QbVDa397UwLzJEjARzQv59ubSsD/B1eL7fO517BmupNNIcW+2H0+pNh6cSVTQEsjySrPflC4Ae16ZEOljSo9MJUmtlaXcibBwoR5oWq2Q98yK9SKEJiCQt0kOjyaGJWVmynsktO08gr23OrF5PaSCJFDAj2kVC2aR0gKSyCUqHvJKgwRQu+7JlNASHAehJxdiSrCbvSc4uRKkFEKlOUFMl6e+P8JN1T4HhMMENYEcMQLB06lRWbt5OeXUF+3Ll7MuVozWYhkIKOKq6HUsqTKEO8oJVh3zPWX15kI1DO/G05qG9K5kcGA8C/th7M9sTa5EoJhZS/CwJwUJBxvnHz+LRlVt98dBTRsv6c67Llr4+OtoH+cnONXgxuP7Xf2D1V/8VgCfatvPJ+x6k0g6yx0niaMWaXV08cM3VOJ5ianUV++IJErkcM2prDvs5eytQlAAooLWeK4SYhh9qe1QI0QPEhBB1Wuuuv9sMixQpcODDS4ojd/dGAwE+ePSig5YNZ7OcdufPSeTznDahle+fObaQ8zPTPs+LA8uZEptKReDQTTjfKCQSgYHWLgajRtK0kiZuPfqDB419rmMPfek0SmvueKmU/zrzbSjtsrT6PW/qHAEUvvdEa4XSfpv7QWcQpRRSSrYN9PORR+6nxLb54VnnUREKUxss4wOTTmJl/2PEt0zk+dpBQnae4UR0ZL9G4X5u6eplIOkbe7XNG9A6ixSwI/En5lX6eSlTjx3AlRAIulx6Zh3H15/yqvPOexmaG7oQAsKRPH35Jkw5yPjwxQeN2/8Z2xRv4/6OPzGv6mjq1kxh874+ZoSq2aZ8j2Q8aVMWyxbm7oeTgtrh+spdmELj6NH9BRC+VICGJdFufhufwJBnk9cQAFIK7km2IJDEjAwx09c+qrf86jBPw+pcOTon2JKP8c6WVcTMHLXaYUbQN77yhSa0Gpge7qZLlRM28pRVJKi1U0jl+pICGmrtQWyp0RYMeiFSKghKETXyvtEW9AsXhIBZlft4aGAmWgu6nSj11jAZFSAQ86gjTlk0iSg8MMtxOKFuNa6SBGr2csrRaxl0S/hV5yKyCsDjuPKdhAyHXalyagrhyt3DTTSWdJBxbJ7f6kt0DOkBTKWQhubRzpf5w62+ivi5H9qCY+SwhM3OdBlVdoq+bJREKkdJJE9lTRTm2rieR2WDyZahZUStJm584XeUVe6iZ6gSz54MQpAoH33n/8DDfyRd7tKn0xh5ww+1aVi7rYOLF/sVkk2FPo5FKIbb9qO13gR8AfiCEGIBcAXwohCiXWu99O8xwSJF9nPNnPn8eed2NJr3HXX069rXxv5eUq5D1nP5y64dhxxTFihjXlkr5YHXr7jreMPsHPwOpozQUvYxpDxYD6lnKEgqKwkEBJvao1Bo77Yr1c1Ptz/M1JJxXDX+ZIQQzKutxzIktjY4c8JMTql7dSPhjeLtTV/lpYHf0hiaS9vO3wMuVYFqZCGv66bnnqStvxdTSu5Yv4aPHrMER2VwnVuYHcuj567hvKPasUyXP7+8mCfWHYNpSC45yeC/t15KhdWKIevwFDhuoUu9BqUUX9v0cQCyiRpESRKtBSJ7ZEm0thnE0RYmDgqBECks6bIu+QQXcnDTZK0132n7BhiKTfE2fnjeV2iKjeNXz6ziW1ufxlUKbQgECqUFOgctpQOME1lM4YfIAgJcLZAaEgpihWitLfz2G7bhsjInCUvfSArgooVB2jNoDORR+N4prTUWgpPC3ZhCc0K4h4fSFQghaA0OjQQ9JH7ekQYsPM4tW01nPsaCUBdRw6HDiZAvGD5B6QsRCd+9R04bDORLmBzqKXgJJKbQaO1rXX1+yoPE3SAxI0ulmSKq8tSGkrjaJK8M+rK+sTu9chuG0AjpsSD4HGHpgjXEhpI5PDcU4rQqj6DhG8CTogO8NNCMow36sjGMVB2OMtABwIX0cAg3H8e0Xfo7StmfabevrZqaWXHQBmmC7M3bWNJl08DpyMEk67sW8p4TdyGl5i97H6GmrB+BoKU2jC097Oo8kVAzqWyQA9+zMhF3JDFbhRRGxr9huwsq70VGKbYlOQxa65XASiHEDfi5SkWK/F2ZWlnFyvd84NUHHgHzausYX1LGpv5e3jP30AbX3bs+TF9uB6awee+ku7CN6JgxfdkdWDJEaaD+FY+3Y/DrdCfvASSmLKW57LqD1u/NbSZguRhSEy7bNbL8C+t+xa5UN8v7NzEl1sjCyqnURWPcf9l0+tMbmFY191XPdTDzDIncWmqjF2Obr68ypzY0mbMbPwvA98vOoD/fR409us9pldU839EOaCaV+x3UM24/eZVC4xI1BzG1h2UoFk1t4+uX/AKAWzedicIj7b3ELddfQ3f7bDY5Nq5ahyEVaSeAq/0QazoDa5+dg1Qhzn/7kSWqG9LgX1q/z/L+B6gJlLJl6IdIoQkb3WPGaq39WisNSM3u7n6aYuO4eOFsXt7dSW8iSSz4IvMje8grEzfsi2ZKnfErtTTktebhdJiwUISEweKQr57d4fmq1kNemEEviEeOPidKWSCLQDA5MMhZ0Q4AbARCCLTWhKRvfJnaJSA0DoJeL0ildEFokgpKDIkHlFhJtDCYHuylxsxiCGgNJNiULxnJd9oft066Qe4bmIfWsDtTQYM9TFDkmRjpRwhoCg4SFC5VZhJLukgBWriUGhkGvRhB6TAx1ochFIP5ILWBBAIISg9DaDwtmB3rojqYQDvV+9UWqDOH+NL4DWgEP+5chAxohvIhFs06nuVbh5hZWs396yUICORgan0XWgtqp3QSlSlyCsYF+imzsqAUkEXjMrlqJa7UCDSdKJRWSGxa7H4k0GAN8ZDIkVJBJgRGCz8MT+AWskmEN3p9Lj76n1ujrMibzyslbv87cJvWeuDA5VprDTwphDgFCGut73uT51ikyBtO3lMM5bIYQtKTSh1yTG9uGwCOzrAntYrJJQe/G7zUv4znen8KwIXjvkpTdN5hjyew8FPBBUKMrcI6vWkezyf+hNKCeRWjDXiD0kIWxPVs6W8Xz61l5+C/orXLhp6nmd+w7LDHTeW3sLHnepR26E3dy9GNDx527GvFlCa1wYO9bDcsPo45tXWUBGyWjvMTZwMyxv6nTlZFsD0Pw8iypf34EY+ZEBK0H8qri1VxypK5bOit49+fbqM2NozWc6mqXwPAO6dfzo937mBqfTUnT594xPN9bN0Ontm7kxnVU6hosFDao9Qaq2QihEAWSpq0J6it8nOdwgGL71zlK4Tftflb1AX8vJ29+QrS2iaHYFXeIQxktabZGkQA44wAspBgPslK8ETBg7M11ziS1+QfF6YE4iNeHAUHdMgSvtGGIK8lCsGz8UYe3FODITQfnvdkIQEbGs08npYkPMNvIaIhX1DpBvCUICD9g7bnykaO/0JfC6aAyxtXAIXcEyRuYRZb0rVMDXfTlS9hUqCPGaH1LE+1EjQz2NIlr2ShDQ3sdCpoNgcZVkG6c8NgSESgl/ZkKVErz1F2J6bvyuLsyo3khSbp2TSVv4ubjvcbPYx/8Ck2dvWwsGoFx876XwCGvCjV9hAeknXZWjxMQKCVjTRcbLMKS/sSGuNtm5TZQthoZF/qEUShzckpszfgxQTbnx1V3y/dZjAw0UXmoWKDwLEh7Agih5CSKFJM3N7POuBeIUQWWAX0AkFgMnAU8Chw05s+wyJF3gQ29PUwnM3iasV92zbxzVPHVsqZwsbVOUBQbY99GK8e/B2q8OhZM/THVzSSJlZ8CkuWImWYxpJ/GbN+XLiJ/5z1FfpyfUwrmT6y/Ka51/Dbvc8wOdbI3PJWAFxvCK1B4+KogTH7OhBXJdDa7xnneP2vOPaNQArBWa2TD1rm6SxCGGjt4Qkw9NuIJ3fwrqXX4qkkAsnFzd/mie4f0BiazYwyX6JhZnUtvzznm3SnkjhyNct7fg8IaiuS3PWhK17TvHKOw77Qt5gy3SOv1zEj8nnsYB+tsbH3XQjBOfXn81DXA0wtm05r6dhqppiRHXlMWMLB0SGENhFAVvia0fsNnKgcfaBUGoo6K85gMkzWMghKj7RXaPeBYl2mnEmBOBro9qDegKyGUCHvSWjNvnw5CsGwslkeb0IIuB6wCsZOg6EABabLunyIiNT0OEH2d9hQYvQhF++L0LurgvSwjZicxgh4rOltZHy4DwHszZYyLhxHacHLySaGvTB9+TBXV6/CkorzrLXscMqxhUenW4YWQQyhSVLBqlwIgSSdChIO5xjoKeXilo2EjDQd+WqU9kM3lsxhCoEtXPDWA/49ef+J/eScbezuXUXA9L9nVeaw783SmojMM6RMcjpAffRWSsMD7Iv/nKTjG0mGGGYgt5FBNhE0asmpbiCMF/aN4AkLR6UFck2gTfAMyJeB3QfSkmTzLkUOpqiTVEBr/Ufgj0KIycCxQD0QB+4A3q+1fvNLaYoUeZOYU11LXTTKruEh3jHj0O1Nrmj5IRuGH6I5cjRl9liPQ8yqJen6ibylRoSdg9+hxD6ayvCJY8YaMsKEik+84pxqg3VjPDNVdinXTzrnoGWRwNSCB0IQDczhvvYbUdrl1PpPEjHLDxorsND7gxzi9fecUtqjP7eLUquegBF+9Q2AiFXLgqoPsyP+EC3hqQyk7iCss3QlP0R/fAcIyYTqu7mi5QcAdMR/TldiGfWxK8nnnsVzNtGWjSALnoeX+n7JjNJTX9O8tXAwC3pGEk3IrmJ6+emHHX/BuIu5YNzFh12f0DY1IoGHIK0COMoiJEcrLrUQeFojAAdGcmriysKQmopYirwnCIg8w8omqUIIAWeGdyPYnx6j2e1BWgmEtplg5WnLRQBNueGQUSbHzvRbtdzStoRrJq2iNxNkbknigMo7gy7PxMXPbRLC/6PvJ4QLbDTDO8sxAi7NJd0gYFJwgNl2LxLNHlni985D8P665wkLr+AT9L1daJgW8A31mkAFVRW3YMkY16+8hQY7yoAT5gOl66iPddIvWwhZHlpragJJVueqUUhKRA5b5hBoGoO+sFE6+zTdgzegdZ5AIDCi8DzgBak2MngI9uQq6HFLsLVHOnsJ2axCifF42hfv6POUL1upPVyVwBRBpLQxLIXWkkhoNFRbURom6cYRGs47bhbDW1OcdswUxtWMbXZdpJi4fRBa663A1r/DXIoU+bsRCQR49Mp3k8znKbHtQ46psJs5vub9h93HWfWf5S9dNxM0SrDcB9gz3IkUAebX/55I4M1rWxDPrcYPxGj60o+zM1uLBp7v/RmnFcrk9yOERAoLpRWGCB5qd6+Je9u/QHt6NQEZ5urWnx8yT+tQTC+7hOlll9CffpKB1B0IJIbuR5MHDcPpe4jYR5P3+tg58A00DnsGbiRsSLTOMMEsZ43ri1NNiI41Ql8NE5vuwTLKSpMks0EqRctr3seB1BvDBAoGQ6WZIe7ESKogmYKxlFUmQemHDx2tQBiFkGmGkyMbSKkAO/K1aAQloRzbMzXEDI9xgTj7Q5OVUvihN0OzMZ9jrWNiijTXlm9ComnLlvBw2vcuDhtRvrz3VJx0gNtm/gkb3zgbVDaGFEjhe0S0Blu7jLcypJTJ1t4p5CdnKS80lRWGZlJpLwZ+DlStmaLfC2IKKJNu4VMHaQWmBKswTgAxeqgJ+WX3SU+wJV1HvTVMdaQLKTXVJTtJ6ggCm3JrPFXSb7+yIxsDCXllsGbPNupmLUKpJFo7gIcpPHrdEAApbdHlleBpQQ4LB4tpoW4kqpCztYcHhxcihGZWqN33OgGKNGjfyA/LUj9ZXo5+H5ZdehU3PvUoreWV3LDIb1lT5DDoYuJ2kSJvCaQQhzWQjoSSQB0XNX8dgOf23MeownF2zFhPZeiI/wxDRGgoeSdC/O1fvbLgQkxZQt7LEbCPReZ2ARA1q8aMjdmzmFT5X8SzL9JY+t6/+Zj72ZN+CaVdUIKB/B7qQzPGjNEFaQBxiAdNRegEplR+ibSzk9JAK/sG/hWEpDR8AQCGCCOFjUIWPF8ZhAgRtaYRcv3k5znlr82LtJ+Xv78Au2GYfE8J4pbX96cvn22GyBYEECDPotBWEp7N+mwdloCMMmnOD1EaTrNDO0wJKJSGuMpjCEFM5qk3+3Gx0DrAO2rWI9Dk9P46NTALITY0VEpNn9LEpCIifF/TzGCKh/1LQnnFIJVSQxl8ed8Sjop0siZVx8VlG2gIJOlwg+R8EQDGBzKEpYctPM6d9RSnSsHqoXFs39uMXZnlyZXzWHDiXgSahGtSa6ZxEb7ydMFFldcmWikUNhGdKWg7jX7u395wFAPJZWS8OkxZqJRzTFobXwARp7PntBFvV6OdpFcFsaSiqdq/L5728ChoWe13WQESDwOFQpJXBs1WPx35UmaHutB4JJ0p1JhxBBqvIAcLYBlNeKqLxvBJVEbnsyPVxpl17xiZb10kxu1vu+h1fSbeKvhGZ9FIKvL/Kf2Z59nQ+xlCZjPz6n6IKY/sTb/I62NW7e3sHrqN8tCxxOyxFTE7B79BV+JuhBAoPLR5FOWBJmLWaxems4xyFo97HE9nMESY0vCjKO0xo/SMQ46vjV5AbfSC13ycQ3F0+WWsGLiLaruVanustyyReZKdve9FyhCTav9A0PLHrBu4gx2Jh5hZfhWTSi4EIJtvwzSqESKAZfjXwZBh5jXcw2DmGSpCJ6FUPzl3BxsSa8l5DwOwcfAultZ+9jXN2zQNvvr5o9m655fUV55DVUUUT+Ux/sY2LkFjNJ+l2kyihEGpkWVmsJOQdIl7NrFwHoEmpQy2OA5aC19TqbBdmUyTESFqZBbwk6lzrkUKXzQ1LAT7A6TVBjSYLvkD9JfQgimBQQSanU4JM+xBBjyb3nSU+wZnM8XsZUo4gxQOQanYkI+BgKyW2NoPYE2LdRKQmqnhHu7ZGqS5N04mpFGYWCiqzDyG0AQKQVupte8RM0+kpvI/6I//ACO/DDSkDpChPzv2P7ihnUAbSpsI4WBbik9/5WG6ehJ8+jPNVJqbAciJGmKiH4cATRXHkXYcDFkJBd0ngDrTz+5IKIuoTKLCBejbAAAgAElEQVQQTLL6kWhcDKrKfoKld/P4xuepqvQ9VPF0lNJwgrwymCG/wITqaUQjNkII/jYzu8h+ip6kIv/fsrn/JnJeD46K0516mMbY4fMqirxxlNhzmV37o8Ou91QK8NDaYHX/3ezI34VAcnXrzykLvPZe0UIYmMI3gA9nHL0ZLK15D0uq332Ql6hvIMmHP3MnA4NpvvbVhzEDWZTK0p+8m8byz5N0Olk98BOUzvNc901MiJ6KIQP0xL+H43UAkr7Ez2govxGAkNVCyGpBa81jPavYl2lnVmwKhngCgNrQoRPklc6jVALTqByzTmuPQOmHmT4rieA57t2zjMF8J3Mq3sW8Sj+k6roeTz2/laqKKHNmjnvF62BYByb0jl6LsPSbrpYaWcxCCEgKTbVhojQMqrFNC/o9SY2UmEKxLWdQZftv68OeQZ3pobQgVEhUCsKIseJqxdnRnQBkPZOQ4Yf/9qTK6HTLSGLjN0kIoAigkAhgtxelQuXIacEEK4UB1BkZbjj5z5iGIutY2IVyf1ePVt+5unCqGpzsFob7LyRkzSjoTh3cc9DzuoA8ECQSOot8fgV7Os/kssu+RCya4ZHHzuekt83AkFGM1DJsy8MWGb7x2C2s7clz3pQkSxp8z2xA+NcUIFa4vkJrP9FbCAztMTT0bkBzbF2MASWQQpMJmBj4ffR+99KtxILdJNrn8oX3/udI78Air51i4vZfIYT4BvAVIAM8BMwFPq61vuNNnluRv4FSey5ZtwONJhr45+wa/1aktcL3fBgywqrep/DrnxRb4k+wsOqqf+zkXiN/HUZ7/JnN9PYlcVyPRGof5QH8ZF/PF+YPyCgSA0SAgIwgC6HGiL2IePZRQBMO+FpVWmu29H2K3tT9BOyTeKQ3RV7l6MqO5z0ttwNQGRz7uXa9ATa2nwIMUhJ8Dy21X/yrEaqQ4wIaRcbpATRtg78ZMZJu/uGjPPrkRjRw079fxIKjWg7aw8DQbtbtugg7mKRDNVMTbMfRBjYOAWPU66G1nxy+vzFqsyGpNPycJOlqBgpSB0kvSEKESLhBnhiuxrQUJ4f2UlWohluRKeOpdDkxkePCWMdIL8GM9pCFXCCJf5Cw4RY0lWBKYJA16QY6nFIG3Fuw2EYysA0hngYgnqpiRUcl/cMxPrP0zwfIEGiMgjSA6/nzNaU30kTXLTSn1UA42I7Smlz+OUz8HQg5Wi5fVXE7Q/GvErRPpLTkswghGEh9F1fkMAzFsYtWMCH0OKYh6czfMTKH8yb/hvMnw4EdsAS68FAWgBrRMIq7NlEzT16ZmIYv0hkyEjQU7B9pa7pUKRLFtFlrkRLcCY+yq+vdTGx883IG3woUjaSDOUNr/SkhxEVAO3Ap8Dh+lVuRfzJmVH2J2sgZBM0Gom9i8nCR14ZllDO1+hsAlA+/l4H8bgSSSbHj/8Eze/3MmdGINAS2YRIOiZG3/v05KgEjxrnNP6Uz/RJNkeN8TSSgMnYNwcBspLAIBfwKw7zXRW/qPjQOudyjGHoBAoEprUMaR/vZvvcv5JxhgkGPnuFfjzGShLBorPgveuK3EQudDYNPYagUzQckge/c00s25xKwDPZ2DI4xkla13UZ1Qw9SQl22kzW5cYDBvNDOgj6QpCNfT9gYJpFopCW6GdC40gbDD2+ZBU8MQFLZ9HklOHmTfVtriFWmoTEAQT+Tptyu5qzKb6MzCXT+CtCgC//Ar27crxrtKN+w8BA89fRchlQJTneUd/XtQGvJZW/LM6ugSaWUwzGtW1AaDrR3H98wn9qSfjZ3Xca8SUMo1cvEmt8fcAUkWvuNgQV6v1MJVTBoDEYb/qbz60jk23AIUkIegc3k8WezvfNWtJbgnc4l1/4IKQTX39jAnNg+ctogYLgjOUz7UQgmN24ABJvaZ2IWWrzEzBxCCCzpFq6N72UToxv6MgNaolyJMP3MqvqqN7fF0P91iorbY9n/enA2cJfWeuBQCZlF/jkQwqAqXBRE/2fmipbb2J1aSaXd8jeF2v7ZmDqpjl//8H3EExlkeA3J/KMABK3RBqOlgRZKAy1jto3Yo2rnSmkso5KAWYvj9WObDVzQeC1duXZOrD5nzLYHEh+aQs6wsSyPlSuOYuGUg9dr7dE5+GU8nWQg+RPOb3oCRyti1mhY7ePXnc5NNz9ATXWMM0+eyV8Ti2VGPB6WFiCigMbJm5gBv0ovrk16nEoIZrnv1osoLU3ipKbyzU+tR4gY3fl7RwyTLesXs6vHJNM3lU2b/NBS8ApF2ew0nhY8vH0Sn2meRZe3l52pIPVmmn7PpsxQ+P6wUYurd2gCTRP+BU+NZ+W69YxExpQGKQhG9xAVOaTQ1MQyNFoZNAJHTMDUu5HmeC495U66h3IcN/95+oY+CsDu/lKaK4ZxtSCRlwQt30Ap2a/9JCQKC1AE7cUj12og8V3AJedsIJt7iXBwKbY1mSmNL6LUMDf8eDmOsxeA9c9/iLbpK6gNTOWclj0kM38knWslElzv6045Fob0S/H3eeNoNPaS1SbCT+/H05JVmQZqzQQDymacFUcAe9JVrEs1kBmMcG7VFZTWbaG18iTCdtFIer0UE7cP5l4hxCb8cNsHhRDVwNjynSJFihwRprSZGDv2Hz2NN5Saqhg1VTG2decLXgB5yCq/w3H3H1fyw589QXNTBT/42h9Q5g6igRkYMnRE28+bNZsbvvxBtNrOKcdefYgRqjAfBVpjCEnor9S2p0yq5fZvvxPTlJjmWE2pvbvrmTDNQErNzi0tXHrqtwkaEd597W0sPHEjOzbVc/Rlw4hYBxNCp7NCNLFje5zzzj2KM28wkFLwnRsno8V2pJB85NzPkU5V81LbXr6y7WEcV7H2xYkEm1KgYcXjVXAKlIbL+PHuKYSkQ0TkuLx0KwpIqACW8JvhdliTmRZ9H/FkFplcixcSyJxGWQItNFEvT6Xhl8KVCIkUoLQmaF9Ie9dptDZNJhKK0hqKMjC0BktnEWhKwr42Uca1qA3ECRQUtYGCwaj53i/OIRaNM3f6O7mgoM0Zto8jnXsaQYCANeoBNI0KMCpw3OdGliU7Ygy1LaZkWiNyQh6tyognDSKFCv0D07iUMZF1eY0hAmzaU0FN3SDb9tYTrs3Q65ZgZDxqKtMINElhQ1gQsnNUtgRZUPHRI/osFXkVdDHcdhBa688IIb4OxLXWnhAiDbwxpTJFihT5P0Vd6UfZ2bsaQ0aoiBx50cAdy15AaU13T5w1G/o5btFra2C8euMKrnrnLQip2Lq5DXjkoPVCWLRU/5ie+I8oj7ydgDm2197Df1nP1295iHAowI+/ezUN9WVorfnRz5/k+RXbqSxv4fkVpxKLZWhbv5Arz/XdVQN9pTz02yUg4IP25cyaXIslg5xxs7/fy274Ga6nwIM/3Ps+PvEei7A1g1BgAuEAnLJwCis37GFH+wA72k0e+l4pWgsqI773xMsH2PjoVMbNbaeiF7wluwiYDmHhMCLt6KzjY19ZRmNNGVYWrFwh/iT8//s7qtFTt/tl/TpAucigEPzqkW088IBN0H6Bu793DaFgFkMY+I4iQcxQ2EYeXVAYF0Ig0X6oT/j/P7+qBYA1G1dzwZmLACiLvg/ldRAKnoohx3puli6YyNYd3Whg4+Z9JFI5hoZ3c9qpP8Y0PWorOvE8iWEoMonqke2Oq/8mbYP/Q7k9janOMTz6VBuXLw5jRa4AocnJRsLS7x/Xl9Ns0xKEZnCvBUUH0htCMXH7rxBChIEPAc3A+4EGYCpQ7NlWpEiRg4gGFzO7aeNr3u7YhRP585NtSCmYNqnu1Tf4K2Ile0i4Gtt2mThp9yHHlIROpSR0+OLv397zEp6nyGTzPLt8G5deuIAt27r5zR9W4nmK9o5BpJyF5yk+/sGTRzc8oGlsMpHHkgeLdiZSox61zl6XABcQMAMMJTJs3NHF3MkNfP5a3wVzwrtvwXEsv6Re5vn3H9zPpHFV7FpVz85V9UipmBQcYNK4HvZ5IRY1+lIEhqP45GWfp6O3koeePJ9s3pc2iNgWqazD5s1nUF4yTNDO4wabGDepDQ94fkU5maxDwMoyPHASCdFJwD4VCIIQI+1ABIUcKOHnpASD5+N5L/HCmrNGzi13QAuPnoH3o9QgjrudSOhMgoGDKxLfefEipkysJRiwuO2XT7BtZw/JVIBc3sTzBNmshW18iJS7laOmjMo9RKwGFtR8xv+lFGZPa2TV+p+DBjvggtqHaRiARnSXsPWJiZCOMGF+jt//+tecdcpMLjjrKIq8PopG0sH8HHgJWFr4vR1YRtFIKlKkyBuEVQhvSTmajPxamNx8Lut2/wSlttJQ/mlc10MpTSBw5ConZ58xm53/3YdpSY6Z3wLA0HAaz/PzhTxX8cdlHyGXc6isGNUfk1KgCjEh2x57vGkTanl+zS7/Fw1nXX8b1eVRso5HLu9SVR7hu5+9mN54itMXT+X+p9tAgGFK/vzCZp6ytqNdjTQV0tNUliYpj6S564H59B8XQgrNolA3ZdEsQaubxbN38PjqaaDAcRyE1uxuz7B119lorfncB09nXm2aoFHD3oX7+N+elZx/ikbKftAu+fxTVNc8jNYJ2jvegW35VYGOexJlpRXY9lmEI+cC0Nf/FPAiaE04MFrdZsgKlEoAGkOUjrkmQggWzfN74n3zPy7m0afbmNRSwwOP1DCUeJq6qjP5+PsvP6L7Fg6eyO7uSupr+3j6uXN4+zlBNDmOmf2vLF/xMuOnVvC7+1fheZotO7pZesxEqitjr77jIoekmLg9lola68uFEFcAaK0zopi5XaRIkTeQJ57bguN4mIZk4+ZOjl/sN8kdSj9INr+Fqtg7D6l/tB8pQ8yd4ItNbt7axXnXfQ9Pab5648UcPc/v9p7Lu2ze2sXECdVEwmOV1i86bz4nHDuFUNAiXFg/oaUayzJQSlFbXUI0YhONHLztv99wDj/82ZMsOrplxLg6kHOOn8XytbuQUrJ1Tw+e0vQMJPd31GN3zxBvv+l/EMB5i2byky++A9OU3PijhxhOZvGUx43vuo9j52xne0clrQ39IDSfuvgxzv/UhwEoe9dfKI1sQgjY0VXlu36knzckpWBicxWbd3ajNWzY0sXbTvT71r3v8hYuP2c+4ZDDQN9vUJ5DKPR2LMu//pu2TWXmlJdBC7btOYHTT7z+oHNbMHc8d/x2OVrD4vmjjYDrq5eRTP0O256PZbWOLH9q+VY6u4c57/Q5hAu900piId5+9nwA5sx4N/Duw97nQzFtUivxxO/YsL6XKy+YydYdPTiuYumCVr594yQ8T/Hw4xtIZ/IYUhK0rVffaZFXRBeNpIPICyFCFJzKQoiJQO5NnVWRIkXeUrzjwmP48a+eprI8wrzZzQAksy+wp/9jaO2QzD7JpLrfv8pefP70wGoyWd/78Ys7n+G396xgfHMlL67aRUfnENGIzZ0/uRb7EA/LAz1E4Cek337zv7C+rYMTj50yZjxA/2CKZCpL30AKT2lM4+AHyHd//ThKgyp4pNAwqqoEyvDFEbOOx3Ntu8j1ZLBMg6F4BjTEQkkWzfRFIyfU+81kBWI05wj42q9OZu7kyXQPlLCvr2ykDj7r+UN2dw6C9nWWOrqGuODa26mvKcEyDF5ua6exppQ7bnkKKYcxjNqRuTU0fJc7//gNtK7iA9eMTYjfvqsPKQWe0mza1jWy3DTqKSv58EFjl6/ayX/efD+e0qzZ2M5Nn7nwkNfzb2HhvAksnDeB+x9dxy3//SgguObyJVz19kUYhuT2b/4LTz2/hYXzWohFX38Pw7c6xeq2g/kivohkkxDi18CxwDVv5qSKFCny1uKqSxZx2QULMM3Rnm+eShTWurh6+Ij3lcnkR35u29SJ6yqee3HHiOGgPEVPb4KmcQdn8iqleWn1LirKI0ycMNouZlJrDZNaD98+5r9/+TT5vMvqdXvZtLmTWTMOrppz3VEBxJBt4rp+VzHX802lkCepr6mgo3+Y8ZEYf1nu94RzCtKNw6kQe7rLaawaoqOvjL7BKBMa+rj57tNG547k5a2+cemXF/plaEIDQhBP5bjsrHmkM3k2buukbzDJcCKN4yoQgvaeYW77n2fp7ktw9cWLR/LCjprZylEzbz/suedd11dHkoJs3j3sOIDB4TQacByP/sHUK479W9mxp5e846G1Zvuu3pHlTQ3lXHXxojflmG81dLG67WC01n8WQqwCFuP/mfmY1rrvTZ9ZkSJF3lJY1sFl9yWhU6mOvY9MfiMNZUfeq23+3PE8+/w2AFzPFzgU+MbOrr39LF00icaG8jHbffvWh3nwL+v9n79yKfPmjD+i482YWs+mrV2YpmRc4+h+u3uG6R9IkXMKxoOAvOPhFRq23vKZi9jVMcjpS6dRWRoB4Ad3PsX6db66dmUsSOdgEu1JPvrtK2ioHqSrpwzXKeRvWWLE+IrYJqn9RooWBQdTQUdJ+xVuxy6YSDbrsG1PHwiB42mEFCPCjfc8vAbHVazbtI97f/7BMec5FE/z7IvbmTm1gZYmP/QZCgYwDYnrqVf10Jx63DTWb95He+cg/3rtm9M97YoLF7JhcyeO4/HeK/5vyWy8FRBCGMBKoENrfa4QogK4G2gBdgGXaa0HC2M/C7wXvyP0R7XWD78ZczrSrMZGwCiMP8GXv9dH5vsuUqRIkb8BIST1ZZ96zdudc9YcysvDOP+PvfMOj6ra+vC7p6WHhDQCoYTeO0gTpCNFREWKYgFREHvHcr3ftV/LxYYKimJBwYIgSO9Kk947CaT3nsmUs78/zjAkJJlMGhA47/OMzpxz9t5rBjizZu21fstqJy4ugznfbMbL08gb/7qNsFD/Usdt+Ps4dkWNrCxfc9BtJ+nd18dy6HAsjRoGE1BL7V+2fedpXvjXLwBYg43OKJa9kJT0zoPneOyum4rMNXVsL4ICfDAa9cz7dRs6BTw9DNQPDiIqSk/zxqGcOZeCxWrHz8uTdEflnB6BsEo8jDruHN2N09HJ3NCpEbO+Wg9AcIAPL7yzGABPTzUXyGjQccewTpxPyKBT6wjm/vAXQiglJp8DTHt+AUkpWej0OhZ+NpWgQB/atAh3KoB3LePzMhr1PDNtsFufaUUJru3L5+/UrDY/NZFqzEl6HDgKXPiH+gKwTkr5thDiBcfr54UQrYHxQBvUivu1QojmUkp7SZNWBnckAOYB7YHD4Mw1lIDmJGloaFx1CCHo7Uj8llLSulU4YWEBKFLy8+JddOnUkMaNQoqNa9QwmMPH4hCCMhvcFsZkNNC5Y1EHYeWaQ87nilVx9CMpil5XvIzPZDQwfriqEXU2JoVlGw5j0Ot494Ux+Hp74OVpZNGyPRw7nUBcUiYZJ+PVgVIgAJtdMrhPS6bfdSMWq40tO05y/HQiLZuGsW3PWRRFElk/mOzcAgJreTP+lq4EB/oipeTIiXj2H45hyrhexewCiEvMUKNONoVzsWkEBfqw91CMY3tU8veu09w/vuSxGtcS1VPdJoSIAEYAbwBPOQ6PBm5yPJ8PbASedxz/SUpZAJwVQpwCugPbqtoudyJJPaSUrSu6wKXhs0vOtUSVGOgMvCSlfK/QuSggGzWUZpNSdq2oDRoaGtcnM//9K9t3ngHAx8cDS4EVvUHPz99Ox8+v6PbQmy+P4btF2wkN8WfkkA6VWveOMV3Y9NcxpIRBHZtwIi0Db08jeWYr0XFp6ITg1oHtXM7x9H0DuWNIJ4ICfPDzuWjr+FvUW+Gr/1vGYYeTZLWpP6BNRj2nopJo2jCE3QfPceREPPkFNg4ejaNti7rkm63867HhRNQJRAiITcjg21+3UzvAh627TmMusPHRvA3c3L9tqXbpdQIvTzXpvVfXxnyzaCtgY8zNmv7Q9UI1RZJmAc8BhfUZwqSU8eqaMl4IcSE5sB6wvdB1MY5jVY47TtI2IURrKWX5FeJULg2fFSYNeAworcyhv5b/pKGhUVF27YlyPs/LK3DkNAty8wqKOUnnzqeyadMxgoP8GDagDbX83WuJUhJtW0eweukzmAss+PlenEdKyYnoJOqFBuBbggxBYYQQNKqn5v5s+us4f/y5j1uGd6RvH7XNx9TxvTl+JhFFkQzp24r5v26nlp8XN3RUS/FDavuqydQC/P09mf3ahCLzSyl5aOYCsnPNahsWRWI06Kkd4FOiPY/c359vFm3jhk6NaN5YrYBrUK82S75+GIvVVsSR07h2qaDidrAQYleh13OklHMuvBBCjASSpJS7hRA3uTFfSQbIEo5VGnecpPmojlICaum/Kr4qZfuyBpYSPnMipUwCkoQQrrtXamhoXNX8ve0kySnZDBvcDk/PK69Dk5Wdj2KXdOscybadpxEC7p3Ym7+3n2LIwNbUCSsucDh77gZSUnPIzMpn3YYj3Da6fK1RLsVo1GM0FnW0hBC0aBRWyoiSyc4x85+3lmK3K+zdf44lix7D18eDiPBAfvp4ivO6+27vgV5/sTowMSUbDw8D5gIbmdnF++gpiiQv36IKYUrJv54YQVJKNgP7tCzRjjtHdeHOUcU/Ew+TAY9yiHZq1HActQDlJKWM3aDewC1CiOGAJ+AvhPgeSBRChDuiSOFAkuP6GKB+ofERQFy5rXIDd/5mzwMmAQe5mJPkLiWFz9xFAquFEBL4orDXWRghxIOo7VJo0KBBBZbR0NCoDNu2n+K1t5YiJRw6HMvLL4y6ovbsP3ieZ1/+GSklrzw/kvsn9aZ2oA/BQX7cd3fpFU9t20QQdS4VqUiaNim95P9yY7PZL6p+2xVstpJzUy9tytuqaR08TAYURXKTI0erMHq9jjeeu4UfFu9kUJ+W3NSzuA7Umahk3vngT0KD/XnxuRF4OZK+Na5vqlonSUo5E5gJ4IgkPSOlvFsI8S5wL/C24/9LHEOWAguEEB+gJm43A3ZWqVEO3HGSzkkpl5Z34gqEzy6lt5QyzrEHuUYIcUxKufnSixzO0xyArl27Vku4TUNDo3RS0nKQEiwWG0nJWVfaHDb/fQKLoxx+zfojvPbKGLfGDR3Yhu07TxMa7EezpuWL9lQnRqMBg0GHzaZgMOicLVzKonaAD7/MfpDUjFwi6gSUeE2vLk3o1aVJqXPM+mQ1x08kcPZsMitXH2LMLZ0r9B6uJg4fjeX4yQQG9GvlrEbUcB/JZVXcfhtYJISYApwDxgJIKQ8LIRYBRwAbMKM6KtvAPSfpmBBiAfAHhZS23ZAAKDF8JqW82x3DpJRxjv8nCSEWo2auF3OSNDQ0rixDB7Xl0OFYEpMyeerRoVfaHAYPaM3yVQew2xVGj+xU9gAHH85eS0xsOknJWaxee7hcY6sTXx8PXn1xNMtX7GfU8I74+LjOZSqMt5fJ2f6jIkTUDeT4SVVJO7xO8S3KqwWr1U5uXkGZTs+586k89fxPKFKycvVB5nxy3+Ux8Jqienu3SSk3olaxIaVMBUoU1ZJSvoGaylOtuOMkeaE6R0MKHStTAqC08Jk7RgkhfACdlDLb8XwI8B93xmpoaFxeTCYDM5+9etIKWzYP549Fj6FIWa5cmYh6gZw8nQhAnavMIbixV3Nu7FVyW5Tq5MlHh9K+XX2Cg3zpWqg329VEekYuU6Z/TVZWPhPH9WDyPTeWem1aei5CJ7CabSSlZJd6nYZrKpCTVGNxR3G7fN0Gy0AIMc0x7+dCiDqo8gD+gCKEeAJoDQQDix0JiAZggZRyZVXaoaGhce1yqXq3Ozz96FA6tW9AcJCfsyluecnPt3A+Jo3GkSHFcoRqInq9joBa3vj7VbzSrywWL93D7DnraRwZwqx3J5Q77+nAoRjy8i3Y7ArLVux36SR1aFefkcM6sGd/NI88VD2q39cDWoPbQgghPFGlv9ugbpsBIKWc7O4il4TPPi90PAE1K/1SsoDKCZVo1AgSEjN5460/MBj1vPLiLdQOLLn8WEPjAnv2RvG/D1cR2SiEl1+8BVMVVVYZjXqGDipdH6gscnMLuP3Oj7FYbISE+LFwwYwqsetK8sHHq1ix+iAA77w2lq6dG1X5Gl/N34zVZuf0mST27It2CoG6S/u2EXh7mbBZ7Yy82fXXRk5OAZu3HCc9PZe/t54sJgKqUTZSXl9OUnHJ1+J8B9QBhgKbUJ0aLU6pUSV8PX8LR47FceDgeX5atMPltYlJWTw0Yz5Tp39NXHzGZbKwdDKz8pn18Wrmzd9SasWRRtXzwayVxMSm88+uM2zddvJKm8PGzce4+/45/OfNJRQ4EsaTk7OdyeM1mbXrj2C3K9htCouX7K6WNWyOyj2bXcFqdf3vyG5XOHgohuRCBQKBAT4s/HY6vyyY4TKKBHD0WBw5OWZsdoVVhVTRNcqHIkW5HlcDQohAIUQbIURjIYQ7vg/gXk5SUynlWCHEaCnlfEcSd7U0ktO4/mhQPwiT0QDIYl3ZL+XHhds5dToRKSXf/bCV558ZfnmMLIWPP13Dxs3H0et1BAZ4M6aSujoa7qHX60EIzBY73j5XviT9v+//Sb7ZSkpqNnq9QLFLAgK8qyzCdSUR4JTo0+vd/l4pF+F1ahEVnYLRaCC8lCq8C7z93jI2/3UCnRB8+dlk6jkaCmdl5ZOQmImfr6dLO1u3qovBqAezlRv7XP4cr2uFmpKTJISoBcwAJgAmIBl1RyxMCLEdmC2l3OBqDnf+FVsd/88QQrQFElA78mpoVJoJ43oQUS8Qg1FPrx5NXV7btEmo6lAJrgodG6ETOHT7nAJ+1ytno5JJz8ijY/sG6HTV+1mYC9RbkslkIDOzuEji5SY8PIDYuHSEEMz57H6ysvJp3apaOiRcdiaO68E33/2FTieYNLFntazxzmtjWbJ8Hy2b16FFszour93y90ksFjXatHP3GcbU60J8QgaTp81DAjf2asZLz5Wu0xUXn4GlQI3wHTh4vsrew/VGDdpu+wX4FrhRSllk+0EI0QWYJIRoLKX8qrQJ3JPyv4IAACAASURBVHGS5gghAoGXUQWcfIFXKm6zxrVKZlY+OTlm6tUNdHuMTifo17dkhd9L6dC+Pr5+Hih2SZdqyI0oL4/PGExggA+1/L0YNeL67Vt18HAMz85ciBCCUcM78vBDA6p1vdG3dGbeN1vw9jZdFTkls96dyN/bTtKyRTiNGgZfaXPKRWZGHjt3nqFtuwjCw4tHcSZN7MXggW3w9jLhX4k2La4IDfFn6n193brWZDRQUGBDCPBxtHU5eSoRCZjNVvbsi3Y5XlEuhkAuCHRqlA+JqDFOkpRysItzu4Ey95BdOkmOfbssKWU6qkZR4/IaqXF9cPZsMg8//h2KonDvpD5MHNejytf45bddpKTkAPDjwh3MfO7Klp37+npWu0NQEzh5Su0fZrXaOHCo+n+dTxzXg1tGdMTT03hVVJD5+XkybIjarDYhMZOjR+Po2iWyWG+4qw0pJdOnfU1mRh46nWDBwhn4lVDFVlILl6pk/95ovvh4DW3aRTD98aEuI5HTH+rPrI/X0KB+bfr0UhO8u3aJJLJhMGejU3jg/n4u1woNVVuI6nSCBg2Cqu5NXGfUkN02J0KI3sA+KWWuEOJuoDPwoZTStVdNGU6SlFIRQjwCLKoaUzWuVfbuP4fdkXi5fsNRt52kggIrPy3aidGkZ+xt3VyWbrdtE+FMtmzXtqSiSI0rwcD+rVm99hApKTlMm9r/sqzp63v1OSDZ2WamPjQPu10hqLYv381/qNg1R47E8vkXG+jcqSH33ec6ybgws2atZPWqgwwd1o7HHx8GqE7O5k3HUBRJv5talehc5OdbSE/PJTw8oNiWsGKXJCdloSgSk8lARkZeiU5SdfPWvxeTmpLD+ehUevRuTpfupf8Wv3lIe24eUrRtqLeXic8+vMettU6dTkSnEyiK5MjRamn1pXF18hnQQQjRAbVV2leo23CuvWrc225bI4R4BlgI5F44KKVMq5itGtcivXo05ct5m7Ba7Ywa6f7W01ffbOb3pXsRAhRF4e4JvUq9dvDANtSPqI2iSFq3qlsVZleKfQfO8fKrv+Hj48GsdyeUuF1RFWt89MkamjWrw7NPDrsqIieXUsvfi88/vvdKm1EuFi/cwb5dUdw15Uaat6zc36WzZ5P57fddNGwQjNVqx2KxEZ+Qgd2uFEsifuLJH7DZFA4diiEyMph+/VqVOu+a1Yf46MNV1K0XwMlTal/PJUv2cvfdvQkK8mPxr7v48ssNCATx8Rncfkc3jEaD01lKT89lyv1zycsrYNiw9jzx1M1F5tcbdDRpHMrJU4l4exkJq+aIUWmEhtUiOysfKSVBwRVp8+k+7dvWp379IE6dTmTSxNLvNRouqJkSADYppRRCjEaNIH0lhHDrpuWOk3RBD6mw6IdE23rTKMShI7EoUqLTCf7664TbLR0KCmxIKQHhTMh0RcsW4ZW0tOr4/oet5OYWkJdnYfXaQ9w7qU+Vr/HOu8tJSMwiLj6DG3s3d24xaFScY4djmffZegrMVk4cjePHZU9War5nn/+JtPRcjEY9/fq2ZN/+aO6a0KvEKqvCeTBZWWrSeU6OmWee/pH4uHSefX4Effq0AGDunA3k5VmIjkpRBwgBUjJt2tdkZZlp2SKcggL138y2rSf5et4mAgN8+HzuZGrX9uXY0TgsBVasFjsbNx4t5iTZbQqnTiYigPx8K7ExaUQ2rtqCCCklH777J39tOs64u3oytoTk7zfeG8+GtYdp0iyMRo1DqnT9S/H0NPLFJ/cipbzuiy0qRU3bb4NsIcRMYBJwoxBCDxjdGVhmTaeUMrKEh+YgaRShcKi/PNVNUyf34+Yh7Rk5vCMT7ryhOkyrNm7o3gQPkwGjUU+H9g2qZQ2LQzemoMBGNReNXTd4eBgcX5Lg4eXWfdIliqMeWgiBn58nfn5epeYjeRXqo9a0mdpE9++/ThB1NpnsnAK++Gy983yHjg3w9DSi0zlu0451UtPysNoUDh6OxdFulGPH4lDskqxsM7t3nQWgXfv6BNb2BeD227s55z1zOpFHp33Nf9/6g9Awf6ftaak5LPppOylV2K7j/LlU1qw8SGZGHnNnr8duK54s7efvxS23daVNu/pVtm5ZaA5S5ZBSlOtxFTAOtb3aZIeIdT3gXXcGlhpJEkK8KaV80fF8sJRyTVVYqnFtclPflqSl5ZKQkMFdE9wvFfb19eSpJ658U9SKMPb2bnTu1BAvLxN1q2GrDUDnuJmbTIYyhfY03COyaRgvvX47Rw6cZ8SYrpWe779vjePnX/+hSeMQ5n2zBYvFxlvvLKNf35bFokl5eRbn8717omnVsi5Wm4JFUUAvyCuwOiKr8MLMURw+HEtIiC/Tp31DXp4FnU44HWcV9e+H4vA9rBYbgQ7Ver1O53CyBJ6FnLP331nO8WPxnD6ViMWqDrTb7bz4/CIURWHJ4t38sLBq1MKDgv3wMKlbgMEh/uj0V8UXpkYlqSk6SReQUiYIIX4FLoTiU4DF7ox1FUkaVuj5OxW0TeM6QacT3HFbVx55eJDzJn090KRxaLU5SAAPPXAT3t4mmjYJpXs3LYBbVfS8sQVTZgyiTt3K/9k1bRrGzOdHMnRIO3Q6gcmkJzDAu8SI6qBBbQDw8/Vk9OjOAJw8laD6OgKycszcMuoDxtw6i+joFNq3r4+XlwfZOQXY7AoWm0IhcS4uRJKc+x9SsuufMwDs33+OuNh0FEWy4PutThtqBXoj9AKbImncOASTyYCXlwm7XUFKSEzIrPRncgEfHw/mfv8Qz708mk++nKxFcK4BJDUvkiSEmIqqmfSF41A94Hd3xtZ8SVgNjWuYQQPbMGhgmytthoYb1Krlzacf38P+/efo3bt5iQ7BizNH8eLMomKHffq04I/l+wAwGfXk5qrRpmXL9vHYY0PUiwrPJS86RM7jakMtAArMqthm3boBFBRYQUJwsK9zeE5uAYoEo0HH2Ak9aN68Dgf3nWPW/1Y553zvzT/IzMzn0aeGObfkKoLdpvDmq4s5sO8cw2/pxJPPX1nZDo0qQAJXgeNTTmYA3YEdAFLKk0IItxLwXEWSQoUQTwkhni703PmovM0aGhoa1xaRjUK4dXQXQspRpbVr1xnn83yzFXQCdILU9GyiolJQFIWg2j54eRnx9jYVSZq9EEMKDw9ASPWGPsrRHudcVApCkaBIYqNTnWO8vDzQ6QRCCLy9PWjYKIQBQ9ri6+0BQtCwQW3WrznMzm2nmD2rch2ozp9L5Zij1P7PpXtLzEnSqHlc8MndfVwFFEgpnXvdQgi1F5YbuIokzQX8SniuoaGhcd2QmZFH9JlkWrWLcKnjVVFCghy31guRIceP9G3bTvPPtjMYDHr+9+HdJCVl0bRpKM89+xPxcRnojDrM+WrUKC4hE51jip8WbOXY0XjC69ZyTmm12Vm14gB5uQXU8vdEAIrNzqb1R3jt34tp0yaC3Hz1OyQxKdupTO3tY6LAbMVg0KM3uK7zycrK57uvNuFfy5sJ9/TGYNATXi+AoCBfUlNzaNWmXolz5OaY2bT+KE2ahdGiHNIe+/dEseKPfQwb2ZGOXRq5PU6jCrg6HJ/ysEkI8SLgJYQYDDwM/OHOQCGvEjevKujatavctWvXlTZDQ+O6wmy28t5rS0hKyOTJF0cReRX01assG1Yf4vuvNtO1RxNW/L4Hq8VOs5bhfPT1FJfjfv1pO5vWHmH8Pb3p1beFW2spiuSzz9Zx+kwiZ04nkZWjSgPoEEi7xNPTyPMvjKRvv6LtewYMfLvIz3SdI0ojdDqklOj14mLkRjj/g8mkV/uXFTqm1wvs9otzGVAFF5s0C+PMsTg8PAyMvKMby37fQ+dujWnWvA5bNx/j7sl96eloFPvmq4vZvPEoep2Ohx4dxC23qUnxlgIb8fEZRNSvXaIswhPTvuHkiQQE8OlXU2gYWbYMQF5uAbcOfc9Zyr941dP4+BStKExPy2Xxzzup3yCIQcPaXbP5UEKI3VLKylcguIlH4whZ97XyJfZH3f3iZbXxUhzdQ6YAQ1D/0q+SUs51Z6yWk6ShoVEp1v65n783HsNuV5j11jI+/HJy2YOuYqSUvPufJdhsduJj07BZVEfj2OFYl+Niz6fx9WcbsFhsvPHyryzd8ILLjvQX0OkEM2YMAmD9usO8+Zb6A3fkiA4sW7afkBA/OpcQKTHoBLZCjo0a5ZJIBDabRFHUUnepqI7EhSudemQSAgK9MZutGI16srMvNgvWG3QIu0LU6USkBLPZxi8/7UBK+Gf7Kf7edAyAV19YxOq/Xr742SkSRRT94W3yMNCwUfGednExaRiMeuLj1Kaznl5GkpOy3HKSMjPznFWAUkrS03KLOUlv/Os3Du0/j8GoJyDQh249mpQ5r4ab1LzYyqNSyg9Rd8UAEEI87jjmEs1J0tDQqBTno1OcIolxsZdXiN9qtXM+KoWIhkGYTFVzOxNC4OVtIjsrv0h0BWDquNlkpOfxyttjad+5aHNdbx8PhE6gN+jw9fMsl17YBQYMbEP7Dg3Q6XTUru3DY48PK3WeYUPbsWz5fgAG9m/FrWO64uPrydT71e8BnV7gaTBit9lp17EBe/ZGoygSnZDYHX5Sp84NufX2bvj4ejDjoW+QikKjyBD69m1JVmY+2zYdJfZ8OqCW8+fkmNWITIENKJpvUivAW9W7VCS1anm7fJ/zv9zE9/O2ADBuUk92bD1Fm3YRdOoa6dbnFFYngIaRwZyLSqF+gyDq1qsNQEJcBk8+PB+7XaFWLW/sioIRPeZ8SxkzarhNzVTcvhe41CG6r4RjxdCcJA0NjUqRkpztrLIyOyqrSkNKyco/9hETncqAoW2Z9/kGTCY9T84chX+t8vUNUxTJ41O+4nx0CqF1Apjzw7Qy82bcQUpJdkY+COlUg79A7Pk0bDaFbz5bzwdz7y8yLrC2D7eO7camdUe4a/KNFd7eCS6U9O3K0Xr8yWG0aRuBokiGDG2HXq9us7VoWYczp5OpE16L92fdRXpaLo0ahzoL4Sbe9jHJKdkgoEXLurRx9EH84qspnD6ZSPcbmuDlreoq3XpHVz5+dwVhdWph8DDw26J/aN22HvUiAtm14zR3T+578bOJScNul+gNgrjYdJfvcfnve5zP9+2KYu53xfvcuUKnE8z59iFSkrMICvZzfk7/efkXUpJUMUyDXtC3fysaNAqm9yVblRqVpIZEkoQQE4CJQKQQYmmhU35AasmjiuLSSRJCtARGo2oKSCAOWCqlPFohizU0NK45xt/Th783HUdRJLePc62avuPvE3z03+XYbQqr/9xPVmYeQieI+GErUx4eWK51c3PMnDmViKJI4mPTSU3NJjSsFkcPnefp6d+iKJIX/zOGArON8HqBtO2oqqLbbHZee24RRw6cZ+pjgxlyS9EWOlJKENLZBqQwer0OvUFPx27FIx7xseksXrgTi8XGR+/8yeCbO1QomuQuer2OocOKNnsVQvDhJ/cSE5NKeN1ATCYDgbV9kVKyZfNxzPlWTCaD+vYAQyGnMiKiNhERtYvMFxpWi9feGw/A0L5vIqXk1MlEpj8+mGdfuqXItQ89Moi01Bz8a3kx4tbOLm2/aXBrFi/8B4AhIzq4/Z7tdoUjB2OoUzeAkFB/Qi/pN5eXW+B8np9vJfpsMooisVntmDy0mEDVUWMiSVuBeCAYeL/Q8WzggDsTuFLcfh6YAPwE7HQcjgB+FEL8JKV8uyIWa2hoXFs0bhrGmHHdiY9NZ/iYLi6vPXIw1plMnJWZp5YI2yUZaTnlXtfP34t+g9qwYfUhuvZoQkioqufz6rOLsDlUqd945Tc89HqQkjc/mUTbjg04tPcce/45Q0GBjdnvr8A/wJvsbDP9h7bFYNCj0+kweRjU3B0hivxq/mT+A2Sk5xXbagPw9DIihECnE+rW2xX6HtEbdDRsVDSvZ+WKA3zy4WqQkjphtfDwNICEyEj3k+w7dGrIkcOxeHubiKgfVOx8w8gQPv9mqltzPfz4UAYOaYeHh4FG5egX9+7rS/l703EQ8Pn8qdS7xKlr3TaC2Bg1imWzKUSfTSEhPpPNG44yaFg7t9fRKIMaEkmSUkYD0YD7bSAuwZVrPQVoI6UsEj8XQnwAHAY0J0lDQ4N1qw6y7LfdWK128vOtvPPR3aVe26RZGAaDDptNwdvb5BRO9PYtudeZK6SU5OaYEUKNIFwod5fKRS0eqUCB1YoQguizybTt2ACjh4ECqx10ApuEN178BSTs2XGac2eSCalTizk/TGftiv0UmK38/P1253xPTv0Gc76Fma/fxo0DWhexJ7C2L//9dBJ7/zlDv4Ftqq2aasu6I5w5Hs/Isd0JCnFPmSUpIRObzY5iV2gQGcz4iT0JCw+gfUf3ew6+9f4ETp9KpF792vj4eFTUfCflKfe/wK4dpzGbreh0gpNH44s5SV6FdKR8fD3UQKCU1K0XWGl7NQpRQ5ykCwghsrlotQm1uW2ulLJMpVRXTpIC1EX1wgoT7jinoaGhgYeHAYRA6ASenq4bxt44oDXnolI4F5XC4OHt+fjdFRiNem4d273c6+Zkm9m1/TRSwpGDMcz7ZC3nziYTGRnMvj3nALW0XQG4KD9EYlyGcw6LxYZwJGf/vf4oBQU2os8k06VHE+55sD/RZ5OdTpLeoCM/rwC7XfLrD9uLOUkArdrUo1WbeuV+L+5yeN853v3Xb1gtNnZvP81H3z7o1rjbxnbj5MkE8vMsTHt4EGF1apU96BL0Bh3NW4aXe1zVov4pSlny9/SI0V1Yu/IQil3hhVdvJTU5m/B6gbR25F1pVAE1UHFbSlnk14QQ4lZUBe4yceUkPQGsE0KcBM47jjUAmgKPVMBODQ2Na5C+A1uTl1dAUmIWt5WRk6TTCSY90M/5+rvFzVxc7RpfP09at6/PscOxhNWpxdKFOygosOHn74XRkcSs1wksUiLtknxHc9naQT7odQK7XUGvczhRUjq3x6xWO9IhptgwMoRZX01m1/ZTtG4XwX+e+xmdTmHQiPYlG1XNZGbkYrHYkIokJSnL7XF+fl68/tad1WhZ6aSlZHPiSBztuzTCu5IRqMZNwzhyUP06qt+g+Jbfzm0nsVntSCnZ/tdJpj02uFLraVybSCl/F0K84M61pTpJUsqVQojmqN5WPVQXPgb4R0qptSPX0NAA1GThm29xnahbXeu+N/tekhMzSU/N5rlp36rd5kP9GXZrJywWG19/ss55/ZkTCQC07xLJ0BEdObA7ijvu7sn3czeRn1dAYJAfsefT0Ot1TkkDgNbtImjdTo1E/LDsCcz5VkLK0c8sNTmbT99ZjrevBzOeG46Xd8UdBZtNQacT2BVZxMarldwcMw/e+SlWi53QOrWY8/OMSm1D/vutO9i47giNIkNo2qJOsfNmsxXF0QujrEpLjYpT0zSohRC3FXqpA7pSBW1JkFIqQoizgMUxYZzmIGloaFwt6HSCsPAAwsIDePT5ERzYG8WkqTcRGh4AQPz5dP5cvBudTnDHpF7OMU+8dLHJ7HCHMvTWjcd486VfCAj0oU8JW2l2u53Z7/5JanI2z/1nDMGh7m1ZzfnfKrZtOoZOr6NuRG0mFoqklZfGzcIwGvQYjXo6dG1U4XlKwmq1kZWRT+1g3yrLp0pNzsacZ3HoWSWj2BX0hoq3dvH28WD4JdWIhRl3dy9yssxYrDamTOtf4XU0yqCGOUlA4a7SNiAKtXK/TFxVt3UEPgdqoUaQBBAhhMgAHpZS7iltrIaGhsblJCkhk9nvrcBuV8jKyCf2fCrWAhv/98EEpj8zDINRrVpzRa+bWvLHXy+V6iB8+t8VrF9xEIAnJ8/ju2VPumVbrUBv9AY9OkG5taAuJaJhMF/8PIP4mPQSK+wqSm6Omftv/ZCsjDz6DGzNy++Mq5J5/Wt5YXck0nt4mtC5oUBeGby8TDzy9LBqXUODmpiTdH/ZV5WMq0jSN8BDUsodhQ8KIXoAXwPui1toaGhoVIDcbDOZGXmERwS6jG6cOZGAoigUmK3s2X4aq9WGlPDDV5t56a2xbq/nao3cQm07Cgrc38rpO7gtq5fuxeRhpHOPpm6PK8yuradYtWQPw27tTJeeTalTt2qrtf5ef5TM9DwAtqw9UmXz5uVaMOj1WOw2rFZbpSNJVcHubac4fiiWIaM7ERzq/rapxkVEDYskCSFCgKlAIwr5PVLKMnsouXKSfC51kByTbhdC+FTATg0NDQ23SYzLYPr4z7AW2Bg94QYeeGJIqdd27BZJg8gQzp5KYsDwdmxYeQiANh3cL3Evi8dfGsX56BSyMvL417vuR1p+nr+F/DwL5nwrK5fsZvIj5Usmzs0x8+8nf8RqsbFt43EWrX+u0gnQl1KvYZC6VyAd1YpVRN36tZn0UH82rj7IuPv6OB2kvNwCfvxyE57eJu68rw9GY/nXfOOFhWzdeJwefZvzyn/Hu7z2k7eX8+cvu2jbuQEH90SjSMmyX/9hwcpnKvS+rmskNXG7bQmwBVgLlCtlyNXfzBVCiOXAt1ysbqsP3AOsrICRGhoaGm5zaF80BfkWbDaFdcsPuHSSPL1MfFyoHH74mK7YrHbalEMHqCy8fTyY/cO0co/r2L0xe3eeRUpJmw7l3yITQjgr74Rw3aqkorTp0IBHXxjJrq0nuWvqTVU695339eHO+/oUOfb5+ytYs2QfQghMJgNj7+1TyuiSiY9JZ/MaNeL117qjxJ1PpW4JApcA5nwLyxbtREqcDhKoVXcaFUHUuO02wFtK+XxFBrqqbntMCHEzF9uSXKhu+1RK+WeFzNTQ0NBwE4NBj81RwaXTl++m3KIatYrKy5gJPWndvgEenkYaNXFfXfoC3j4evPXZPWxYcZABw9vj6WWqBith5B3dGHlHt2qZ+1KOH4xFUdSQxOF95xh7b/nG+9YqKj7q5yLXy8PTSOPmdYg5l4qPrweZmXkoiqzQn4WGg5oXSVomhBheEd+lrOq2FcCKCpulUa0kxWcQE5VC+66RGIxXdp9fQ6Oq8fX3wsPDiMViIzDI90qbUykq67S17dSQtp2qLlH7SlO/UTBRp5MQQtCoaVi5x/v5efH2Z/ew7OddjLi9K37+3qVeK4Rg1vwHOHMikYZNQkhKyOTMiUR69G1embdwfVPznKTHgReFEAWAFcfmcmUVt0tFCDFHSume1KtGtZAQm860Oz4FJJ1uaMKrsyZeaZM03GTt8v188d5KWrStx6sfjHfmY5w4HEtsdCq9B7bC5OFaufp6oPMNjXno6aGcOZHIuPvLtx2jcXUz/dmbsVhseHl7MPbe3hWao1P3JnTq3sSta00eRlo6tK4aNg6lYTn6xWmUQA1zki5V3C4PriQAapd2Chhe0QU1qobo00kAmPOtHDlwvoyrrw6O7j/PuuX7GTW++3V9k/rivZVkZeRxcHcU+/+Jomuvppw8EsdT932JlJK1yxrzxux7rrSZVxwhBCMu0/aPxuUlKNSf/3x412Vbb8lPO/jtu60MHNmBe6YPuGzrXpPUoLYkQoiWUspjQogS1W7dkTJyFUlKRu3bVvjTkI7X1+833FVCpxsa07J9BKeOxvHgU0OvtDllkpaSzZP3zgVg+S//sHTHKxWqaLkW8PQykpWhOriBtdVC0a0bjjo71x/YFXUFrdPQuLawFFj5/N0VKIpk0Td/MXR0Z8LqBlxps2o0VS0BIITwBDYDHqh+yS9SylcdwZqFqKX7UcCdUsp0x5iZwBTUarXHpJSrSpj6KeBB4P0SzkmgTI/Z1bfUGWCglPJcCW+oZoQurmWEICMtB4vZRlZm/pW2pkziY9Kcz6Uiyc+1YAy4Pp2kC3o7Jg8jqcnZNGkZTpOWddDpBIoiNe0WDY0qxGDUExjkS062GYNB5zLJW8NNqn67rQAYIKXMEUIYgb+EECuA24B1Usq3Hb3WXgCeF0K0BsYDbYC6wFohRPNLO4JcSAuSUlZYft3Vt9QsIBAo5iQB/63oghpVw9IftxN1Ut1ym/v+Ssbc1fMKW+SaS/tV6Q3Vq7x7NTNibDd++XYrAbW9ad2xPgC9B7Tmrmn9OXsigfseHXSFLdTQuHbQ6XR8+uM0dm09RbsuDatcY0qj8kgpJZDjeGl0PCRqdf1NjuPzgY3A847jP0kpC4CzQohTqH1mt5U0vxBCD4yguJjkB2XZ5koC4FMX5z4ua2KN6iWkzsVwsakKxd+qCw/Pojbqq7k9wdXMlMcGM+7+Pnh5ezg/ByEEdz1405U1TKNEtm88xu5tpxh5Z3caamXjNZLAIF8Gj+p4pc24ZqgOxW2HI7MbaIoqNbRDCBEmpYwHkFLGCyEu/AOsB2wvNDzGcaw0/gDMwEGgXJ2hr/5vV40S6dGvBWF1A0hOzOTO+2+80uaUSb0GwYybfCNrl+3jjnv7VJvWS03B108L+ZeH7Kx8Pnt7OQDTXxiBn//l+fyiTyfxf08sQErJmiV7+X37K5dlXQ2Nq5ryJ24HCyF2FXo9R0o5p8iU6lZZRyFEALBYCNHWxXwlGeDKdYuQUrZ339yLaE5SDWXfzjNkpuei2CVLftzBxBoQhbj/scHc/1j5WjJoaAB8/9l6Nq06iEBtGPvQs5enwPb4oRikQ6HZnG+5LGtqaFzVVKwtSYqUsqtb00uZIYTYCAwDEoUQ4Y4oUjiQ5LgsBrUDyAUigDgX064QQgyRUq4ur+Eu9zyESn1X12hcGRo1DUMIgaeXkXZdrh2ROQ2NkvD0NCKlRJESD6/q05CyWe0oysVofO2QCsuraGhouIkQIsQRQUII4QUMAo4BS4ELeuz3ovZgw3F8vBDCQwgRCTQDdrpYYjtqdCpfCJElhMgWQmS5Y1tZittSCPE70MWdyTQuH2F1A5i7+DHizqdWaX8qDY2rkQKLnQsNzCwF5epP6Tbff7ae7z/fgE6v479fTSY1MYtGTcMIqxdAckImNw2rULReQ+Pao+pzksKB2R/YgQAAIABJREFU+Y68JB2wSEq5TAixDVgkhJiCWkQ2FkBKeVgIsQg4AtiAGZdWtl3C+0BP4KC8EBp2E3e227YLIbpJKf8pz8Qa1U9wmD/BYVq5uMa1j4enwZHkLvD0rJ5I0o9zNwGg2BVefOgbdDqB0Am+WvIECGp8axQNjaqiqhO3pZQHgE4lHE8FBpYy5g3gDTeXOAkcKq+DBO45Sf2BaUKIKCCXiz1PtJ9VGhoal4W7HrwJk4cBgeCOCraxKAudHuw2CUJgtdiQUm2OmpGWQ+MW4dWypoZGjaSGtSUB4oGNDu2lggsHKyUBUIibK2GYhoaGRqUxeRi568EK68GVijnfwmdvLyM7Mx+DQY/VouYjterQgKT4DHr0a0lk8zpVvq6GRo2m5jlJZx0Pk+PhNmU6SVLKaCFEH6CZlPJrIUQIoMWdNTQ0ajx/LNzB+uX7sdsUDKaLt8N2XRpx9/T+GAx6hKgZfao0NC4HQlaPTlJ1IqX8v4qOLVPRTwjxKqrC5UzHISPwfUUX1NDQ0LhaMBr12KwKiiJp06kBdRvUpkP3SDIzchnV9f94YtIcLBYrVqvNrfk2/bmfN55YwKHdUUWOH91/jrMnEqrhHWhoXAGkKN/jCiGEmCOEaFfKOR8hxGQhhMtOy+5st41BTajaAyCljBNCaHWxGhoaNZ683AKEAClVFfh5fzyJlJLhnV4F4OyJBGbcOZuYqBTG3N2LDt0iyUjLof+IjphMRW+fibHpvP/iL1gsdnZuPsbiXf9Gp9Px2/y/mP/RWqSUvPTBBG64qeWVeKsaGlVHzYkkzQZecThKh4BkwBNVMsAfmAf84GoCd5wki0MKQILqfVXKZA0NDY2rhPqNQtDrdej1qvYYqC1iuvZuxv5/zuDt40FSfCZSwu8LtrN84Q6QcGz/eR7/9xgA3nl+ERv+3E9AbV8sVjWnyWKxO7fp9u04Q4HZihBwZF+05iRp1HhqynablHIfcKcQwhfoiio1kA8clVIed2cOd5ykRUKIL4AAIcRUYDIw110jHboHu4BYKeXIS861BL4GOgMvSSnfK3RuGPAhoAe+lFK+7e6aGhoaGu4gASklUkLh6uDHXrmFP3/5hw7dInn35d+QUlK3fm1io1KwWmzERKfy5jM/EhRWiw3L94OAjFRHf04hkBLefGoBiTEZhNWv7Zw3pE6ty/wONTSqgRriJF1ASpmD2hy33LiTuP2eEGIwkAU0B/4lpVxTjjUeB46ihrYuJQ14DLi18EGHY/UpMBhVfvwfIcRSKeWRcqyroaGh4ZJVi3dhs6nRn/XL9jP1abWY9+l755KemsNv3/7NM2/czvGDMQwe3ZnvPl1HWnIW8TGpHNx1Vp1EUOKXxta1R1DskrjzaeplQpCS6Frk9+ShGF6Z+jUGg543v3mABm421FUUhWP7zhFSJ4CQugFlD9DQqCg1MHG7Mrjbu+0g4IV6Kzjo7uRCiAhgBKrg01OXnpdSJgFJQogRl5zqDpySUp5xzPMTMBpVXVNDQ0OjSsjPdUqmYCmwAmpEKS0lC5tVwWDU8+YzPyElrFmyh4WbXgRgRKeLjW6FKOQjKRe/PRSH/q+Hl4H8PB06vY4eA1q5tOeXrzaTmZYLwLIftvHwv0a79T4+fuU3Ni7dC8BHvz9OfTedKw2NCnEdOUnuVLc9gNoT5TbgDlQF7sluzj8LeA5QyrrwEuoB5wu9jnEc09DQ0CgXeTlmbNaSOxbc9+jgC91OmDhN1WESQhAaHuA8fmEXLjM9zzmuU8+mzudlafimJedgtyvYrHa2rzvq8touNzbHw9OIydNIp15NXV5bmH1bT2LOtyCRnDwU4/Y4DY0KIcv5uEqoSE61O5GkZ4FODnlwhBBBwFbUrHBXxowEkqSUu4UQN5XTrpJqBkv8qIUQDwIPAjRooPUw09DQuMiSb7Yw5/WlePt6MnvF04SEF92KSojLwORhRCoXt8WklCTEpCMl6HQCvV6gKJLAIF8eGfcpGak5TH9hJDmZeQQG+bJtw7GLE+oFwi7R6QWKXb1l6XQCu10ipSQlMZNHb/uIdt0bM/X5EcU0mIbc1pXmbSPQ63Xliga1v6EJCefTsFnttNR6OWpUMzVtu00I0Qv4ElXjsYEQogPwkJTy4bLGuuMkxQDZhV5nUzTKUxq9gVuEEMNRS+78hRDfSynvdnPN+oVeRwBxJV0opZwDzAHo2rVrDfuj09DQqE7mf7ASRZHkZOWz/Iet3PfM8CLnM9NysdsVFLtCRoqaeC2E4L5HB/Pjl5vo0rMp46f249iB86SnZrNw7mZsNjsf/Os3crPN6HRqLzmzWd2q63FjCw7vjsI3wIuE8+kA2O0Xb0tbVh7Ekmch5kwyQaH+xJ9LY/BtXWjR/uLtrlEFFL73bzsFgMGo5+ieaOo2DC73HBoa1zD/A4YCSwGklPuFEH3dGeiOkxQL7BBCLEGN5owGdgohnnIsVmLvEynlTBwClI5I0jNuOkgA/wDNhBCRjvXHAxPdHKuhoVHDsBTY2PvXCeo3CaVuo6r7gvfwMJKfo+Yd+fp7FTs/atwNRJ9OIjszj2nPX0yNvHNKX+6ccvEe2rRVXfbtOM3P87bgaTRit9pAShS7pFvvZnTr15LQOrV4dfp8LAU2crLN6kAp8fQyYjAZ8PQy4eNlJP5cGooimf/BKqxWO2t/382ou3oScyaZSY8PZufG4xhNekZP6o3BqHfrfd40qiO/fb0Fg0FP226RlfjENDTcoAaGI6SU5y+J3Ja8B38J7jhJpx2PCyxx/L9CgpJCiGkAUsrPhRB1UOUB/AFFCPEE0FpKmSWEeARYhSoBME9Kebgi62loaFz9vP7wfA7uOI2UMHv5U1XmKM38ZBLvPrWAeo1CGHl3r2LnPb1NPPP67W7N1fGGJsz6YRqZ6XmsXridTasOoRPQs19LBozpQkZKNlabAkLg4WnAZlOw2xRuv/9GJj0yCICs9Fw2/XmA0HoBvD5DbVxgs9j54/ttFJitHNoVRU5WPgBJselMf8W9xO37nhnO0DtvwD/QBx8/T7fGaGhUiJpZ3XbeseUmhRAm1Kp61wmCDtyRAKhwz5NCc2zEoVEgpfy80PEE1K20ksb8CfxZ2bU1NDSufk4djMGcZ8HT28T500lV5iS1v6EJ3/39istrkmLTMedbaOAQk3RF4xbhALTu2ICWHRpQq7Yv/UZ1BCAjPdfRJNdGgdmG0aTHjrrFtnfrSbx9PZj5/kRG3dXTUcEmQUpngrjeoMNitjozwY9c0tqkLMIbBJXreg2N64hpqLqL9VDTeVYDM9wZWGZ1m4aGhkZVYs4rIC25qF7QtFdHExDsS7sbmtCpT/PLZsuB7aeY0v9NHr75XX6ft9ntcSYPA03aRBDZMtyZfB0U6o/NZgcpMZoMWC12QJIQk8bRvefYveUk7z6/kIzUHArMVhS7WvSr2BUatwzHP8CHIbd3UTUFhOCOB/pVx1vGblfYsf4IZ46WmOapoVE2Nay6TUqZIqW8S0oZJqUMlVLefaEYrSzc1UnS0NDQqDSxUclMH/ouNqudMVP6MvUldTspIzWH7Iw8UhMysdvs4FH6rWnHusN8OHMRDZqF8e8vH8DTy1RhexbP2+SUB/h17gZunexWLicLPlrDz3M2gpT8+8vJdOzVjAM7zyAdjo/VobmkPnc0x5WSA9tPM6Hna/j4eThreBUpOXMsngKzlY3LD6DTqU7S2RMJVIeb9Mkrv7Lxj30oUvL2tw/SqnMjAHZuPMqhf84y7M7uRRK/FUVBCFGsEk/jOuYqcHzKgyO/+VGgEYX8HinlLWWN1SJJGhoal41f52zAarEhpeSPb/92Hl/w0RrsNoW46BRnpVZpfP5/i0lPzub43nNsX1u5VMWIyBDn87CIQLfH7d9+ioJ8CzabnRP71WLfVh0bOB0Jnf7irVXoHM6FEGoSuZTkZpsxGAx4epuoHaI2I/DwNCIEKIpEsSucP51UqfcGcHRvNMsXbCM786LG04mDMZjzLQBEnUgE4NypRN545Dt+mbuRF++Z47x265pDjG7zInf3fp2kuPRK26NR8xGoOUnleVwF/A5EAR8D7xd6lEmZkSQhRHPgMyBMStlWCNEeuEVK+XqFzdXQ0Lguadu9CSt+3A5QpKdZ15ta8teKA+j0Opq0ca0b26JjQzJSc5BSVqhcvjATHxtKWlI2WRm5PPbGWLfH3ffMcF5/eD7+gT4Mur0rALVD/Pl6zbPs2nyc9t0jeXLi5+Rmm3n8tTEEh9bC29eDp+6czYUkpLbdGzFyQk/adW9M1IkE4qJT2b3xKJtXqk0NQsIq1+ct+mQiM++Zg5SStYt387+fHwFg2iujee+ZH6lTP4i+IzoAanWhAKQiKTBfjIL9NHsdNqudrPRc/lpxgNumVM8WoEYN4+pwfMqDWUr5UUUGurPdNhdVUPILACnlASHEAkBzkjQ0rjP2bDnB9x+u4oYBrRn38EAAMlKyeeGuz0lNymLmR5PofGPpOUUDbu2CXic4dzqpyNbWU/8dx6339yW0bgD+ga5Fccc/PJDEmDSato2gQbOyk60TY9LwreVdYtWXl48Ht07uS16OmeBw93uete7SiAU7Xi12PKxeICMm9ADglx2vIqXkzx+385/p89UkbZ3a/BYpGTS6Cz0HtQGgbddI2naNpEOPxiTHZ2AwGrhzen+37SmJtKQshBAUmK1FokDtujdm/uaXilzbtE09prwwkj1bjjP+4YFYCqzYrHZuvLk9Z4/Fo9MJ2vdwXwFc4xrm6okOlYcPhRCvoiZsO3sRSSn3lDXQHSfJW0q585L9aFu5TdTQ0KjxvP7wfPJzCzh9OJauN7WkSet6bFq2j7joFKwWO9+896dLJwmg3y2dix3T6XQ0LSOCdIF3nviBqOPxRB2Lp0vflvRwOBol8ePHq/nxk7UYTXo+/uMp6jYKKXJ+5/ojvDljPgjBuOkDmPDoELdscBchBDs3HsNitiIEePp6kp9rQegEjVoUj4KF1avNB788WiVrd+jZhBsGtuLo3nPM+PetLq+12xUO7zrD8f3n2b3lODPvmYPVYqPn4DZqbzpJqa1dNK5Dap6T1A6YBAzgYps06XjtEndyklKEEE0cEyKEuAOIr5idGhoaNZkLv5UsFhsmTyMALTo2QKfT4eFlpFPvZtVug7evB3q9Dikl3r4eLq9dt3g3VosNm03hwPbTxc6fPBSD1WqnIN/C4V1RVWqnzWonP7eAcdP64+PnSe0Qf2wWVYRSKpKk+IwqXe9S4qJT2b72CJlpOfwyd5PLa4/uiWLHuqOkp2Tz46frMOcVYLPa2bbmEFaLHavFxsY/9larvRo1iBpW3QaMARpLKftJKfs7HmU6SOCekzQDdautpRAiFngCmF5xWzU0NCrCvDeXcme7mXz52u9XzAaLo1LLZDKQ7Wj42rJjQ2aveJq3vp/Gfc8OdzW8Snjl8/sZN2MQT783wbkFZDFbeWH8p4xtO5O1v/7jvPaOB/uj0+vw8fPEbrfz2KgPWPL1xVL/IWO7Exjsi4+fJ+Mdgo9VQWJsOhP7vsnYHv9h69ojWG0KBRa7QxZA5fypxCpbr0QbYtIQOkFBvrVIEnjUiQSeHvcJ7z33k/PPs079IBDg4WWkfpNQPDxNDrXvizsICTFp1WqvRs2hBiZu7wfc308vhDtikmeAQY7uuTopZXZZYzQ0NKqWrPRcfpu7AbtN4fevN3PH9IEEBFdI9L5SdB/Qil0bj+EX4EPDQknTdRsGX7Z+YQHBfkx6cliRY3v/OsHxfdGY8yx8+foSBt3eDYDBY7sTGOJPcJ1aPD76f9htdqJOxNNjcFvCImqzauF2UhMyAXVr7o1vp1WJjTs3HsOcb8FuU/hz4Q4sBTbVIRE4f1kH1SmemJ2amMX/XvwZo8nAk2/eUWZ+lis69mxKr8FtObo3modeGuU8/vL9c0lNzOLInnM0bBrG2Af74+vvRWCIPwnnU2nfownvL5yB1WLj1anzOLbvHACdelV/lFCjhnB1OD7lIQw4JoT4h6I5SWVKALhT3fY48DVqY9u5QojOwAtSytUVt1dDQ6M8ePt6EhjiT05WPt6+HviU0IfscvDSp/cQF5VCcHgAv87ZwN8rDzDxsSH0ublDta5rt9lZ+4saIRo0tjt6fdEg+IX8Hk9vE627Xuxd9vFLP7Ppj71IReLpZaLAbEGv0zm36Y7sPuu89vTh2Cqzt1OvphgNeqQiCQ7z53xOsnqi0JfLkd1RpMRn0ntIW6eDOX/WKvZuPYUQgkVzN/HAcxWPzOkNep59b3yx42kpOc59091/nWTsg/05cfA86SnZSAkrF+5k2suj8fLx4P/mTmbRFxsIDg9g1KTibV00rkOuni208lC8ysJN3Encniyl/FAIMRQIBe5HdZo0J0lD4zJhMOqZveo5juw+S6sukRhNV0YHVqfTEdE4lOiTCSz6fD0Ws5V3nvie3sPaV6vY4KLZ61j4yRoAMlKzGTdjcJHzYfWD+GLdTGLPJtPuhibO40d3R2HOs+DhaWTcI4PQ63V06NmUl+/5guiTCQwY09WZ3zRu+sAqszciMoTvN80kP8/CZ68vJeZMMjq9DsHFBOhVP/+DokgWfbGRn3b8C71eR2jdAOefbUh45SQASqNBk1CiT6pbfQNGq0n0jVvVxdvHA5vVTu+h7ZzX+gf68MALI6vFDo2ay1WyheY2UkrXSXkucOdOe+HONxz4Wkq5X2jSqxoalx2/QB9uGNQWgLizycRGJdOxd3Pnl6qiKBzbE01QnVqERdR2NVW5kVIWcYL8ArxRbKoSs6+/V6UdJLtd4cT+c9SpH0RgSPFtxLSkLNW5EJCWmFXCDBBaL5DQekUFIR985Vbef2YB4Q2DGT6xFz5+niz9dgsnDqgCkCsWbKPXkLZkZeTRu4qjYV4+Hnj5ePDAc8PJyczDy8eTgztPk5OZj8nTgN3RANecb8FuV9DrdUx4eCBhEbUxGPT0G9G+Su25wEeLH2fJt1uo3ziUHgPVykCDQc//t3ff4VFVWwOHf2vSQ++99yZVQMQGYkPFLvaKXntXsKJe/SzXXkD0YscuF0QFKYIiIoL03iH0Tkidsr4/zhACaZNkJpNJ1vs858mZU9cG5rCyzy6JFePZt+cQVaoX/RWfKSciJEkSkZmq2ldEkjk6agFUVSsXdI1AkqR5IvIL0AwYJiKVONKFzhhTwpLW7eT2AS+iqnTp25pn/e1oRjzxHVO+mYMCr4+/j6Zt6x91nqry69h5pKakc+blvQOujZo7fTnPDhlNpaqJvDL2Huo0rE7aoQxnzB+PknYoI0cSBTDlu78Z/fx4OvRsztC3riUqOirPe7x8z6f8+csSoqJcjJwyNEeyc+61fZn500IABl5zYq7XWL9iKxtXbqf3gA7EJzqv07qf3IYxc5w5upfP28BPX8yibraJYF1Rwpxfl+P1+hj59FieHHVjQH8mhVGnQTX+76MhAMyctJj3/28C7bs3pX3XJkwbP5+LbjyJWP/fRVSUiwEXdg96DNnFxkVz6ZCjx2BatXgzu3ccQH3OuE63PHpeHmcbE1E1SRUAVLXIDTgDeUreBHQB1qlqqojUwHnlZowpQZnpbjat3s7f05fjznR6JS2YuSpr//yZK0lPyyQmLprVizbnSJImfTmbEU99h/pgy7pd3PrUhQHd94s3fyEzw83+PcnMGP8Pl91+OrFx0YhLnLF/KuTeDX/Ek9+RmpzO3F+Xs3Tu+nwHI/zzlyVk+kd6XjhrNQMu7XnU/h8+/p2D+1IAmPDJTG5/9pKj9iet3cl9F74OCG2/bMwLXxw9wbfX42XY1e+SkeYmNi6amx49jxX/bKRe05p8+940UJw500Ks75md6JvtddZ5V5eOdj4t2td3egB6nAEkjclX5CRJxY40zyRJRNqq6gqcBAmgub1lMyY8vF4fdw/8D9s376FSlcSsXlIVqxxpwF2zXlW2rNuFJ9NDnWy1JYctn7eezHQnuVo6d13A9+7ZvwMr5m9EROjU22nvU6t+NZ79cAjz/1hF/wt75Pq6rXm7+qxZkgRAvQJ6vh1OUMQlxMbnfCzVblCNmNgo/3rOV4nbNu1BREhPzWRTAF3r+13Qg0tu6cdnr/+ctS0lOa3A88qqCpUSGD31EfbtPkTt+kXqKW3Ki8hquF1bRO7Pa6eqvlrQBfKrSbofuIXcJ4ELaKRKY0xwHDqQStLanXi9PjzuQ5x33UlsWr2dmx4dlHXM4a7ssfEx7Ni8F3offY3sPeISK+ScoiMvm1ZtxyWCK8rF9k17adfN6T12XO+W+dYO3frUhXz44gSO79eeWgVM+TH4rgF8/PJP1G1Une4nt82x/5J/9aNm3aogcOqgnCN2dzupNb0HdGTF/I3c9vRFOfZHRUfxf5/fzk9jZnHSwC5Ur+00RWjfvRnR0VGg0PWknPctT2LjYqjTIPBJfk35JGQfPavUiwIqUoyQ80ySVPUW/8/iTSBkjCm2ytUqcNJ5XZkxbh59zjqO2565OEftzWV3nM7bw76mSvWKnHBmxxzXOOuKE5jy7d9kpLu54u7Ap99I3p+K1+fDpcKhbLPJF+SZIaPZtXUfS+es47jeLWnePu9pRy6/YwAX3nwaMbFRudZKuVwu+l3UI8/zo6KjeOSNa/KNp123prTr1vSobft3H8Lln09t7/bQjoBtTJkROTVJ21T1meJcIJBxkmJwRtg+PBvldOA9VXXneZIxJqhEhEfeupaH37wmz55kP376B263lwN7U1j4x+ocvbUat6rLVwufQ1VxuQIZbN9x5/OXMnL491SvXZkzL+9d8Al+qs6TVLOt5yc2ruSHNdi9fT8+n+L1+ti5ZV/BJ5RD+3YdJC4hlsSKgdc+GlNKFLvSK5Cn0gggBnjX//ka/7abi3tzY0zh5NcuMCY2Omt/TB4Jh4gUurt+7QbVePL9mwp1DsCzn9zKd+9N47gTWtGiQ8NCn59dZoaH//13OgAX3HRq0BKqgVf3ZfXiJA7tT+XWJwNryF6e/PjpH4x86ltiYqJ57Yf7adK6XrhDytUvX81m9aLNXPKvftRplLM9ngmuCOrdVuzBzwJ50hyvqtl/JZ0mIguLe2NjTHANe/d6vhs5jYYta3P8ae3DHQ5N29TjgVevCsq1Pn3lR74f9SsAacnpXPdIcAY4rFApnsfevT4o1zrW2qVJ7N62nx6ntc8xQnikmPTFLDyZXlCY++vyUpkkLflrLe8+/g2ZGR6WzlnLu5OHhjuksi9CkiRVLfaEg4F8c70ikjWErYg0B7z5HG+MCYPqtSsz5MkLOPvKPkEd/dqd6eGXr2bz15QlQbtmYS2ctRqfV/F5lfl/rAxbHIFa+vc6Hhj0Gi/c/hHvPPp1uMMpskE3nUp0TBRxCbGccEangk8IA6/HCwiqzmtTUwK0kEsEC6Qm6SHgVxFZh/N+rwk2TpIx5car93/OjB/mIyI8/MbVnDIotIMd5qZtt2asWZyUtV7abVy5DQUyUjNZtXBTuMMpsv4XH0+fs44jJjaa6Ji8BwMNp+P6tOLGR89n1cKNXHH3meEOp+zT4L9uE5FGwCdAXZzBqkf5p0OrDnwFNAU2AJep6j7/OcNwxnH0Aner6qTgRuUoMElS1aki0gpog5MkrVDVjAJOM8aUEfN+W4H6FEX5bcKCsCRJNzxyLlEuARGue6jok76WlFMGdWPCJ7+zZ/sBbn58UMEnlFLL563nxTs/pkbdKgwffQuVqpW+KUtEhPNvOLngA03wBL92yAM8oKr/+Gf1mCcik4Hrgamq+oKIDAWGAo+ISHtgMNABqA9MEZHWqhr0t1x5vm4TkZMPL0AvoCpQBejl32aMKQc69mqBiDPgY+8BOYcWKAkJFeK4dfhF3PrUhVlTjpRmqxZuYuv6XWSkZTLpy9nhDqfI3n9mLDs272X1ws1M/e7vcIdTKhw6kMrrD47hs1d/xucrn6/3RAu3FERVt6nqP/71ZGA50AAYBHzsP+xj4AL/+iDgS1XNUNX1wBrg6GH6gyS/mqSHctmmQGegIc4gTcaYMu6RN69l4pezqVqjIief1zXc4USEHZv2gEJGuputG3aFO5wia92lCeuXb0V9SrN29Qs+oYxZPnc9S+eu49RB3anpHxD1oYvfZMOKrQD4vF6ufSg4nQgiSgjbGYlIU6Ar8BdQR1W3gZNIiUht/2ENgOy/fST5twVdfoNJHjXDoYj0BR4DtgF3hiIYY0zpE5cQyyB7nVEop13Yg3kzVrB90x7ufnFwuMMpslueupBuJ7eleu3KtOzUKNzhlKgdm/cwbPBbeD0+fvpkJqNnPQXA7m1HxtPauHJ7uMILqyK0SaopInOzfR6lqqNyXFekIvAdcK+qHsynA0puO0KSugUymGR/4Al/AM+r6uRQBGKMMWVFXEIsj713Y7jDKDaXy0XP/h3CHUZYJO93Rpf3uL0c2HMoa/sdz1/Gf+75lLj4WG5+8oIc56kq4/47g+2bdnPV/edQqWpiicVcIorWY223quY9ZD5ZA1d/B3yuqt/7N+8QkXr+WqR6wE7/9iQge9beENha6KgCkN8EtwNxao4OAI+p6h+hCMAYY0z5syNpLzExUVSvUyXcoeSqRceGXH7XGcyZupRrHhyYtf3UQd05NZ/OC9+/N40P/j0OgAV/rGLk1EdDHmuJC37vNgH+Cyw/ZtLZ8cB1wAv+n+OybR8jIq/iNNxuBcwJblSO/GqSfsDJ1vbgtCY/aqeqnh+KgIwxxpRtP378O+8+/g2IMPyjWzm+X/EGPz24L4Xd2/bTrF39oI0RJiJccc9ZXHHPWYU6b/XizVnrO5PK3lQ3QkhG3D4RZzaPxSKywL/tUZzk6GsRuQnYBFwKoKpLReRrYBlOz7g7QtGzDfJPkmxiW2OMKQEet5eM9EwqVEoIdygl4su3fsHnc97bfPXWpGIlSTu37OXoVJc9AAAgAElEQVS2/i/g9Xo59YIe3PvyFcELtAiufXAgsyctJjPDw/VDy2ij7iAnSao6k7znWct1ahFVfQ54LriR5JRfw+0Zob65MaZs2bBiK8//azQVKifw1OhbqFqzUrhDKvV2bd3HnWe+RMrBVG5+4kIuuPnUcIcUci2Pa8TubfsBaN+jeIODrl64GZ/PR0aamzlTlwYjvGKp36wWb018mH07D9LphJbhDickJIAJq8uKyJxQyBRaZrqbHZv3BDQbe3l3cG8K6WmZ4Q4jIo1+fjybV+9g9YJN/PjpzLDEsHn1dq7q+AiXtX6Alf+sD0sMhTH/95WkpaTj9fgYN3p6uMMpEY+8cz3XPHgOQ566gOseOa/gE/LR5aTW1GlUg6goF1feG/4Rt5fOWctt/Z9n2BVvM+KJb8MdTvAVdkqSCP8vx5KkciB5fyo39H6KIX2f4Y0Hx4Q7nFLtveHfcXmnoVzU6kEW/bk63OFEnFadGhGfGEt0bBRN24ZnXJ2fPv6NvTsPkLwvhW/e/iUsMRRGlRoVcWd4AKhYuXy8botPiOXK+87molv6ExVdvCH3KlRKYOTUYfyw4TXOvfakIEVYdD999gder+Lz+Jj6bdkcgDPYg0mWZgEnSSJS+sajL0Fej5dHL3+LgQ3vYvS/xzLtuzl89eYkUpLTwh1agVYt2MCBPYdwZ3qY/n3Z/NIGy8TPZwFON97v35sW5mgiz1UPnM2wETfw7zF3cOLZncMSQ9eT2xEbF0NsfAw9Ty+dk7Jml7wvhbj4GADSU91hjiZyBXNS5+Jo36M5IoAIjVrVCXc4oVGOapICGSepD/ABUBFoLCKdgVtV9fZQB1eabFixlWV/r8Xn9fHtu1OIiYvB5/WxeuEmHv/vkHCHly9V8Hqdhv8+e92Wr64nt+XPiYsA6HfR8WGOJvKsW7qFdx77hgqV4nn2s9upUTc03bv3704msVI8sXExOfb1PKMT705/HI/HS8OWdZk/Yzm1GlSjYcu6IYmluE48pwtTvv6LpHU7ue3fl4Q7HFNMZ1/dh4z0THZt3cfld50R7nBMMRWYJAGvAWfijEuAqi4sj3O31WtaiwqVEwChRt0qbN+4G59P2bVlb7hDK1C9JjWJjYvG51MaldL/KEqLJz64mSV/raVarUo0bFFGfwsMoY9fnMDOpL24olxMHPMHV90f/Mlox7zyI2P+M4HEygmMmP4kNfzTRRy2dvFmHjz3ZbxeH11OasviWatQVf7zw0O07Nw46PEUV0KFOF745u5wh2GCxOVycdEt/cIdRkhF+iu0wggkSUJVNx9TlRmS8QhKs8SK8Tzy7o38OXEhFSon8MXrEwGNiJqZBs1r89L397F64SZOPr9buMMp1USETr3LZo+UktD++GYsnr0GVaXVcaFJSCZ++jset5fMtExeuuNDlv61hpPO68bDI25ERHj7oTGkpzoN7/+Zvgyvx0dcfAzrliaVyiTJmIhT+v/bC5pAkqTN/lduKiKxwN04M/SWK3t3HODJq9/F6/GSUDGemNhoUKVJm3rhDi0gbbo2pU3XpuEOw5Rxg+8+kw7HtyCxUnzI5voaeP0pfPLCeGLjY1ny52p8PmXmhPnc+OR+atWvRsNWdVgxz+nVVqtBNbZv3IMP6HVm6W+fZEypVwYaYxdGIEnSv4A3cGbYTQJ+Ae4IZVClUcrBNFQVj9tLekoGT350K3u27+e0C8tuuxWfz8cPHzo9hS69fQAVq5SxOYhM0IkIx/VpFdJ7XH7v2Zxz/cnExsdw94AX2Jm0h6q1KuPOcDP/t+Xc8eIVVKlekYx0NxNGO8O9udPdDLvkdaJjojnn2pM46+q+IY3RmDLNkqQjVHU3cFUJxFKqNWpVl6sfHMgfP85n8L1n0+O04g2jHwmmffs3Hz73PzweH1vX7+KxUTeHOyRjAKhU1els++YvQ1m3NInEivHcfuqzAHQ7pR1PfuL0KzmcJAGsX7YVBVY/8Dkdere09nnGFEGIpiUptQLp3fZmLpsPAHNVdVwu+8qsS+8YwKV3DAh3GCUmM8ONKqjPlzWOizGhdnDvIVbM30D7Hs0LrL2MS4ilXY/m/DXJ6ZGYnpLB0jlrs/YPvv9svnz1Z6JiXHi96nQTV+Wf6cstSTKmqCKgLW6wBPK6LR5oC3zj/3wxsBS4SUROU9V7QxWcCa8zBp/AzqQ97N52gBsfGxTucCLarIkLee7mD4iKdvHKuPtp1blJuEMqlTIz3Aw56RlSk9OpXL0in8z7N1FRBQ/n1vWUdrTt1ow1izYx5Okj3eivfGAgzdo3oHbDGtw38GVnowh9BnYJVRGMKfOsJuloLYF+quoBEJEROO2SBgCLQxibCbPomCgG33MWmeluKlevGO5wItq7j36Fz+vD5/Ux4olveHX8g+EOqVTambSXg3tTAKezxIE9yVSvffRYS16PlwW/r6Bu45rUbVqLXf42SQkV44hLjCW+QlzWsa/c9RGzf16A2+0BFfDXJC37aw2nXFB22xMaEzJlYIDIwggkSWoAVMB5xYZ/vb6qekUkI2SRmbDbuHIr9w38D+5MD3e9fAVnXH5CuEOKWI1b12PPNucr1LKTdUPPS6WqFZw8xqeIS0jIlvAc9vIdHzL754WoKg1a1Gbzim3UaFCV/bsOkZ6awTsPj6Hvuc5QFxuWJZGemolEu1Cc9hQK7N1xsETLZUxZIr5wR1ByApmW5CVggYh8KCIfAfOB//inKZkSyuBMeM2ZspTMDDcet5efP/0j3OFEtOEf/4vB957FjY9fwL+etVGV81KlRkXuf+NaOp3QimHv3URChfgcx6yYu4701AxUlfVLknBneti1eS8+n4/4xFhadDwy9MCdL19F/ea16XZyW8CZbkaAdscXb+Z5Y8o1m5bkCFX9r4j8BPTE+UXsUVXd6t/9UCiDM+HVa0AnvnxjIpnpbs67odwNsh5UsXExxZ7tvLw4/dJenH5przz3N2pZh+0bd+PO8NDhhJYs/XMNHU9oxR3/uYqk1dtp3Lo+t57yLO4MN5fffSZuj+L1wsBr+zL5q9l0O7UtbbpakmRMUVmbpJzSgW04jbhbikhLVf0tdGGZ0qBx67p8sfgF3JkeKlQqH7OTm9Jp/bIkHrvsDQAO7UsBn6Iovc/ozNOf30VipXhEhMat6jHqqW/ZvHo76lNGPfUdqcnpHNybzPrlWxARlvy1jrSUDBIr5qylMsYUQClXvdsKfN0mIjcDvwGTgKf9P4eHNixTWsTGxViCZMLu6zcnsnf7AfZuP4DP6zSIEHEmbv71uzlsXb8r69j6zWo7owKLUKdRdeITY1FVDu5NITPDQ8qBNHYmlf45F40prUQLt0SyQGqS7gGOB2ar6mki0hYnWTLGmBKRvC8la71JuwZsW7eT+i3q8O2IqWSkZRITG83nC18gvkIc2zfuAhRVpUadKsTGxdKoVR2mfP0XAK4oF1HRgTTHNMbkKsITn8II5EmRrqrpACISp6orgDaB3kBEokRkvohMyGWfiMibIrJGRBaJSLds+zaIyGIRWSAicwO9nzGm7Gl5XGOiY6OIjo2m1xnH8f3Gt3hp/IOkHUrHneEhM8NNWorT2bZZ+wbExsUQlxDLmsWbWTl/A9O+nUO3U9oSFe2i14CONGheO8wlMiYyHR5x22qSjkgSkarA/4DJIrIP2FrAOdndgzMhbuVc9p0NtPIvvYAR/p+HneafFsUYU45d+cC5xCXEIiIMvOEUpnw9mwbNa1OnUQ22rt9F1eqVqFzDGcur/6W9qVmvGu5MD88N+QAAn09p2q4Bz311dziLYUzkUy1XbZIC6d12oX91uIj8ClQBJgZycRFpCAwEngPuz+WQQcAnqqrAbBGpKiL1VHVbQNEbY8qF2PgYrrh/IAC3nfosG5Y7v6eJSwDYvyeZPdv2U7thdQA693Uqu7ue3JY5kxeDCCec3TkMkRtjIlm+SZKIuIBFqtoRQFVn5Hd8Ll4HHgYq5bG/AbA52+ck/7ZtOG89fxERBd5T1VF5xHgLcAtA48Y2SJ8xZd3hBAmgSvWKHNh7iLbdm1GzftUcxw4deSMzJ8ynXpOatOvRvCTDNKbMivRXaIWRb5Kkqj4RWSgijVV1U2EuLCLnAjtVdZ6InJrXYbnd1v/zRFXdKiK1cV7zrcht2AF/8jQKoEePHuXor84Y43Z7iI6JYv+eZNSnWa0sk9Zsx53ppVn7BvS7uGd4gzSmrClH/9MG0nC7HrBURKaKyPjDSwDnnQicLyIbgC+BfiLy2THHJAGNsn1uiL+90+EBK1V1JzAWZzBLY0w5d1yfVoiAK0pIPZiGO8PD9g272bvDmfZl9qRF3HHac9x75gtM/GxmmKM1puyxhttHK1J3f1UdBgwD8NckPaiqVx9z2HjgThH5EqfB9gFV3eaf8sSlqsn+9TOAZ4oShzGmbHlmzJ1M+GgGLTs15ufPZjJj7Fy6ndqOdUuTmPzln+xK2ktmhhsU5k5byllX9w13yMaUHQr4IjzzKYRAGm7PEJEmQCtVnSIiiUBUUW8oIv/yX3ck8BNwDrAGSAVu8B9WBxgrIodjHKOqATUWN8aUbZ+8+AMTPpxBdEwU70x9jIfevp71S7fwwLkv43F7adCiNjXrViUz08Nld58V7nCNKXvKT45UcJIkIkNwGkZXB1rgNKweCfQP9CaqOh2Y7l8fmW27Anfkcvw6wLqiGGNymPnDP2Smu3G5hGV/r6Nfk54c3HcIj8eLz+cjeV8KXyx7OdxhGlNmRfortMIIpE3SHTjtiw4CqOpqwEZiM8aExWV3n4XLJVStVZke/doD4PX6cEW5QKQ8vQkwJjwOj5UU6BLBAmmTlKGqmf5XX4hINOWqss0YU5oMvO4kzrr6RFwuQURQVWo3rEFUlIuoKBeNW9fNOtad6eHPH+dTp0lN2nRrFsaojSk7ylNNUiBJ0gwReRRIEJEBwO3AD6ENyxhj8hYV5VSCv3rnh0z+4k9OPK8bL417gA3Lt9D3vKzZjXjlzg+Z/dMCVJX/G/sA7Xu2CFfIxpQNSrmqJgnkddtQYBewGLgVp7H146EMyhhjCnLoQCpTvpqNqjL75wVUq1mJM67oQ2LF+KxjNixNIj01ExB+/HA613UZykfPjg1f0MZEOGfuNi3UEskCSZIOTx1yqapeoqrv+xtcG2NM2CRWiqdJ2/rEJcZSu1ENqtXJOT3kXa9cQ50mNenQqwXTvp7Njo27+e6dSWzbsCsMERtTRvgKuUSwQF63nQ+8LiK/4QwKOUlVPaENyxhj8udyuXhjyqNsXL6Vxm3qER2T83G26I+V7N2+n+S9h4iJjSYzw4PX66NClcQwRGxM2RDptUOFEcg4STeISAxwNnAl8K6ITFbVm0MenTHG5CM2LoZWXZoctW37pt08cdmbuDPc+LyKO8ODiJCZ4fxupwr7dx6gcrUK4QjZmMhmbZJyUlU38DNOTdI8nFdwxhhT6owdMYXNq7axfeNuKlVLwBXlIrHSkXZK6lO83gh/B2BM2BSy+3+E1zoVmCSJyFki8hHOqNiXAB/gzOdmjDGlzoHdyVnrCRUTGLvpLT5b+jKxCTGgirigXtNaBV7Hml4ak7vyNHdbIDVJ1wP/A1qr6nWq+pO1STLGlFZO+6QooqJdTsPuhFhSDqaRmZoJgHqVOb8szPca/33qG86pfjNDz3sZr8dbEmEbEzlCUJMkIqNFZKeILMm2rbqITBaR1f6f1bLtGyYia0RkpYicGYJSAoG1SRqc/bOInAhcqao5phMxxphwu+TOM0k7lIE7w801w5yWAQkV4446plGrnJXhG5Zv4Y27PqJWw2r8Pm4e6lOWz13LuiVJOdo9GWOC7iPgbeCTbNuGAlNV9QURGer//IiItAcGAx2A+sAUEWmtqkH/jSaQ3m2ISBecRtuXAeuB74MdiDHGBENsfAw3Db/4qG1RUVGIC9TfFOn1ez5m/dIt3PjUxXTv35H0lHRGDv2C5X+vZe3iGOo1rcWuLXtJqBBHgxY2C5MxWRQkBE36VPU3EWl6zOZBwKn+9Y9x5oB9xL/9S1XNANaLyBqgJ/BnsOPKM0kSkdY4mdoVwB7gK0BU9bRgB2GMMaGUmZaRlSABrFuyBXeGmw+f+Z73n/gGUJq0qUdsQgyCsH/PIdxuHwf3pZKZ7iaxUkLYYjem1Cl8e72aIjI32+dRqjoqgPPqqOo255a6TUQO/8bSAJid7bgk/7agy69N0gqgP3CeqvZV1bcAezlvjIk48RXiady2Pi6XULlGRWJio4hPjCWhYhxejxevx8e+3cnc/tJVPPbJbaQmpwHg8ynzpi0Nc/TGlDJayAV2q2qPbEsgCVJ+JI+ogi6/120X49Qk/SoiE3G6/+cWmDHGlGoiwru/PcnmVdup37w2aSkZbF27g7nTljDm5Qmg0LxDI8669mQAmrStz8blW4mrEEefgV3CHL0xpUsJDia5Q0Tq+WuR6gE7/duTgEbZjmsIbA1FAHkmSao6FhgrIhWAC4D7gDoiMgIYq6q/hCIgY4wJheiYaJp1aEhmhpsXbnqPlfPWc/0TF3L1w+dzcO8hrnn0yPBvz359L798PpMep3ckoaK9ajPmKCWXJI0HrgNe8P8cl237GBF5FafhditgTigCCKR3WwrwOfC5iFQHLsVpYW5JkjEm4iydvYYV89aTnpLBx8+P4/uNb+U45r4Bz7N/90G+ef1nRs//P2rUq5bLlYwph5SQzMcmIl/gNNKuKSJJwFM4ydHXInITsAkn/0BVl4rI18AywAPcEYqebRBg77bDVHUv8J5/McaYUmP7hl0krd5O51PaEROb96Otcet6uKJcxCfG0aFXyxz7VZXkfYfwur1ERblIOZhmSZIxfoKG5HWbql6Rx67+eRz/HPBc0AM5RqGSJGOMKY22rd/JbX2eBKDzye14+qt7svYd2H2QhErxxMbFAlCjXlUeeOt6Zv00nxufvuSo66gqIsITn93BmJd+4MTzutO4Tf2SK4gxkaAcjUZvSZIxJuJtWrkNgPSUDFbOXZe1/cUho/j169mICG/8+jituzZjxd9refaadwD46+cFfLvxbQBmTfiH/7txJFVqVuK1yY/x2uTHSr4gxkSCcpQkBTTBrTHGlGbte7ckKiYKgBPO7Zq1/bexfwNODdG4kVMBWPrXmqz9h/anZq1/8fIPuDM87N+VzB/j55VE2MZEnsNtkgqzRDBLkowxEW/Zn6vxup12m7N++Cdre6WqCVm/9Xbs47Q/Ovv6k6lSsyIAA646MevYE8/vTmx8DFFRLjr2aV1SoRsTcUS1UEsks9dtxpiI17RDQ0SE+ApxdDqxDWmH0vF5fezfdQhEQJXRT33LqKFfcMLAbny19s2s9keHDX7gXPqc240KVRKpUbdqGEtjTCkX4YlPYViSZIyJeHUa1+SDec+zdd1OEGFwi3vw+Y6u5z+45xCoMvXLWQy45iS6ntI+x3WskbYxBdFylSTZ6zZjTJlQo141Op3Yhpn/+5uMtEzcGR7qNqsJ4LRXyvZg37V5T7jCNCayKc53qTBLBLMkyRhTqsydvIgXb3iXhTOW5XmM5vPgPfWS3sQlxBITF80dL13NxAOjmbD7fSrXcNohRcdGcfJFPYMetzHlRjlquG2v24wxpUbyvhSevvRVMtPdzBw7h2+2vkd8YtxRx/z436m8de8n1G5YgxPO686UMTM59dLeeNw+lv21mttfvorzbu1HWkoGnU9uBzhzt3224jVWzVtHs46NclzTGBO4SG+MXRiWJBlTzo16+FO+e/0nup9+HM/+8AhRUcGvYPb5fBzcc4gqNSsd1Vj6sAO7DzLl85nUb1Ena5uI5HrsyEe+QH3Kjk27+d+7zuxIE96fhricuB8d9EpWTdPKv9fx9m/DAdi2YSfTvvqTfiJ0OrFNsItojCmDLEkyphzKSMtg6uczqdmwBt+8OgEUFv22jE3LkmjWqXFQ7+X1eLm775OsW7SRnmd35envHshxzGPnvcjahRsRl4tK1SuQme6mer0qfPHiONYu2sRN/76cxm2dRtXRMVFkpuV9v+yv4jatdCYG93q93NbrcXw+5acPp/PZyteo1aB6UMtpTLlhNUnGmLLE6/USFRWV9fmVm0bwx7i/EYH6LeqyY+Mu4irEUbd57aDfe9u6nWxYloTX4+PPH+aRmZ5JbHzsUcesX7IZr8dpwLB/50H/ebv4/s2JZKRlsmn5FvbtPADA+bcNYOw7k6hSszJ7tu5zLiByJDlSzapVuvzecwDISM3E5zvyYN+2bqclScYUhQK+8pMkWcNtY8qwtJR0hhx3P2fFDGbM899lbd+2fieZaU7isG/7fnxeH+kpGaQlpwPO67Fx707i4+Ffk3IwNa/LB6Rus1rUalAdcQkd+7Rhz7b9LJm5gv27DvDiDe/y2m3vOw/eLJK1+FSJinZxYE8yGamZZKRmMvbtSXgyvUcSJAAUfL6s33DV60W9XlKSnSqnxEoJ9L2gBy6X0KZ7Mzr1tddtxhRNIXu2RXitk9UkGVOGzZu8iI1LkwD47NlvufLRiwG4771beXXISOo2r82scXNRn/MwS09xkqTJn/zG+w9/htfjZcvq7Tz6+d1FjuHQ/lR2bNqN+pSV89YypPODuFxC7ca12LJmB+IS5/7CkTZI/gEgb3ruclIPpPHNqz9mXc/jH1kbQFygPnCSqpwP5BnfzOaW553JxZ/47K4il8EYk02EJz6FYTVJxpRBP4yYxNXNb2fq579lvYbK/rppw9LNrFmwkUW/reDekbfQ6aR2DHnpauq3qAs4bZZUFZ9PyUjNKFYsu5J2Z00Z4s7w4PN6SU/JYO+O/biiXLhcQlSM6+hG2v6YO/RpxaX3nUPV2pWzdrlcR467atgF9Dq7C7e9fBWuKBcIVK9TJWt/l1NzDhhpjCkmq0kyxpQ2ox75lIn/ncaA607htleuz/O4zPRM3rzzA1DYsWEXFatVICM1k1Mv75N1zJcvjsPr8XJoXwqpyWm8On34Udc4+6b+bFu/k33b9zPkxauztn/3xo98+vS3dDmtA7e/dj3rFm+k8ykdSKgYn2c8h1/hHVahSiKH9qdy7ZMX487wEhMXw1f/Gc/ebfv9Rxx5qA6/+HX27TjAFUMHMe2LWYg4rwK3r99FXEIsTds14ppHLwKg99ld2bxqG3MmLmD8e1Ocex8qXoJnjDlGOWuTZEmSMRFg95Y9fPPyeAC+f+1HLrzrHOo2zb2RtdfrO6qNz7M/DKVy9Uo0yjblRoPW9Vi/eBPuDDetujfLcY2Y2GhufemaHNtHP/Yl7gw3c39ZyJDOD6Kq1G9Rl5HzXsxxrMftYeWctdRvVZdqdauwb/sBajWqwcHdB/F6vEz9fCZvzXoOgBEPfJJ13lk3nEKFKhWoXLMyX/zfOHxeH798/BufrX4dgOV/reHtez+meadGnHBuVwAyM9y8dfeHrPpnA+f9qz+x8TGoKqdfeWKOuIwxxaGH33GXC5YkGVPCZnz7JyPu/Yj2J7Ti0TH3Eh1T8NcwJj7mqM+xCbF5HAnxiXG06tac9Us2Ub1uVVp3b0Fs3NHnzxo7J2v9g0fG8NqMpwOKvXKNiuzZug93phuAzHQ3G5ZuzjFZLMDwi19h0W/LEJfgyfSA+tidtNsZ/wiO6m1XpVZlDuxyerWdcskJdOvfiZ2bdvPNKxOI8UbTb/AJWce269WSd/589qh7zZ+2lCWzVpGeksGP709jzJo38Xq8VK1VGWNMkEX4K7TCsCTJmCJSVeZPW0LFqom07t4i4PNevWkEqclp/PG/v5k3eRG9zulW4DlValRm2Of3MP7diZx76wCq18l7lnoR4c0/n2PT8i00aFU3R4IEzlxmvgwPADXqBT7j/YHdyQDExMXQ+eT2rJy7jisfvTDXQR8X/76c9JQMYhNi8PkAcRETF4PX48HnhYz0zKxjRy95hW9f+5HjTmpHt/4dAajduCafrnqdg3sPUbdJrXzjOjyGUnyFONr0aE6lahUCLpMxphDsdZsxJhCfPfstX788DlXlia8fCCjZgSPJgc/ry6o9CUS/K/rS74q+AR0bHRNN8+Oa5H2twScy6ZMZiAiX3H9uwDH0HtiNOT/Pp3L1SrTq3py9Ow5Qp3HNXI/t0KcNc39ZCAjiEsBHZob7SDf9bL+NVqySyPXDL81xjcRKCSRWSjhq28E9yUz8aAaN29an90Dnz7xes9q8N/d5Nq/cRpfTOgRcHmNMEVhNkjGmIMtmrSQ9JQNXlIvV/6wLOEnq0KcNy2evQkTodFK7EEd5hNfrY8J7k0lNTmPV/PWgEBMXzap562jbs1WO41fNW8fBPcl0H3BcVk3R41/ey9Y120lLyeC+U54iMy2T5696kwmHPs1Rm7Rk1koAxCXEx8fiiYkisXICB3btx+sueq+5Z654k2WzVxMdE8Xz4x+mo3+KkbpNa+fZTssYE0SWJBljCnLj81eStHobFatV4Jyb+wd83vM/PcqcnxfQrGMj6jWvU/AJQTLhvcmMevgz1Oejnn9kbXemh7Y9W+Y4du4vCxl+0X8Ql3DBnWdx0/NXAuByuWjYuj57t+/HJUJMXAzValfO9XVb74HdmDV+LvGJcbw+42m2b9xNfGIsQ89+jphYofMpRavxObArGa/bS0xMNAf3JBfpGsaYoor8bv2FYUmSMUXUqltzPl37TqHPi0uI46SLeoUgovylJqehPh9er4+kVdsAUJ/yzSsTeGzMPUcdu3bhBrweLx63l+V/rclxrep1q/Lab8+w+Pfl9L2wZ673G/rJnWxesZVajWqQWCmBBq3qATBy7ovsTNpD51OKNobRsE9uZ9TQL2hxXGN6nxtY7Z0xJkgUZ3T7csKSJGPKiQvvOptdm3aTcjCNNfPXs2n5FgC69uuY49gzrz+N37+fw4GdBxjywpW5Xq9F5ya06Jx3uyeXy0WT9g1zbG/QqolGSZIAAAxOSURBVF5WwlQUzTs15oUfHyny+caYYrKaJGNMWROfGMfd79wMgMfj4bvXfqRR2wb0Oa9HjmOr1qrM238+V9IhGmMigSVJxpiyLDo6mssfGhTuMIwxEUdtCABjjDHGmBwUtByNuG0T3BpjjDHG5MJqkowxxhgTOHvdZowxxhiTi3LUcDvkr9tEJEpE5ovIhFz2iYi8KSJrRGSRiHTLtu8sEVnp3zc01HEaY4wxpgCqzjhJhVkiWEm0SboHWJ7HvrOBVv7lFmAEOIkV8I5/f3vgChEp2shzxhhjjAke1cItESykSZKINAQGAh/kccgg4BN1zAaqikg9oCewRlXXqWom8KX/WGOMMcaEkfp8hVoiWahrkl4HHgby+lNqAGzO9jnJvy2v7cYYY4wJm0LWIllNUu5E5Fxgp6rOy++wXLZpPttzu88tIjJXRObu2rWrCJEaY4wxJiCK07utMEsEC2VN0onA+SKyAed1WT8R+eyYY5KARtk+NwS25rM9B1Udpao9VLVHrVq1ghW7McYYY3KjvsItESxkSZKqDlPVhqraFBgMTFPVq485bDxwrb+XW2/ggKpuA/4GWolIMxGJ9Z8/PlSxGmOMMaZgCqhPC7UEorT2aC/xcZJE5F8AqjoS+Ak4B1gDpAI3+Pd5ROROYBIQBYxW1aUlHasxxhhjslENeu1Qth7tA3DeJP0tIuNVdVlQb1QEJZIkqep0YLp/fWS27Qrckcc5P+EkUcYYY4wpJQKtHSqErB7tACJyuEd7+UiSjDHGGFNGBL+dUW492nsF+yZFUaaSpHnz5u0WkY3hjiMANYHd4Q4iRKxskassl8/KFpmsbAVrEoRrBCyZfZOm6Lc1C3lavIjMzfZ5lKqOyvY54B7tJa1MJUmqGhHd20Rkrqr2CHccoWBli1xluXxWtshkZSt9VPWsEFw24B7tJa0kpiUxxhhjjMlLqe3RXqZqkowxxhgTWUpzj3ZLksJjVMGHRCwrW+Qqy+WzskUmK1s5UVp7tItG+LwqxhhjjDGhYG2SjDHGGGNyYUlSEInIcBHZIiIL/Ms5/u1XZdu2QER8ItIll/MvFZGl/v09jtk3zD9c+0oRObOkypTt/sUtW3URmSwiq/0/q/m3x4jIxyKyWESWi8iwslI2/77jRORP/9/rYhGJLytl8+9vLCKHROTBkipTtnuH6t/kABGZ5//7mici/Uq6bP44QvnvslQ+T/z7CvzOiEhn/zGLReQHEans315qnyf+fUUuW6DnmyBTVVuCtADDgQcLOKYTsC6Pfe2ANjijk/fItr09sBCIA5oBa4GoCCvbS8BQ//pQ4EX/+pXAl/71RGAD0LSMlC0aWAR09n+uUVb+3rLt/w74pqB7RFLZgK5Aff96R2BLSZctxOUrtc+TQL8zOL2hTvGv3wg8618vtc+TIJQt7M+T8rhYTVLJuwL4IrcdqrpcVVfmsmsQzhc/Q1XX48x11zOEMRZVnmXDKcPH/vWPgQv86wpUEJFoIAHIBA6GMsgiKkrZzgAWqepCAFXdo6rekEZZNEUpGyJyAbAOKBW9UPJQ6LKp6nxVPTxGy1KcgfDiQhpl0RXl7640P08C/c60AX7zr08GLvavl+bnSXHLFinPkzLFkqTgu1NEFonI6GNfTfhdTt4PtbzkNmR7g6IGWAzFKVsdVd0G4P9Z27/9WyAF2AZsAv6jqnuDHHcgQlG21oCKyCQR+UdEHg5+2AEJetlEpALwCPB0KAIuhFD8vWV3MTBfVTOCE26hhaJ8pfl5Euh3Zglwvn/9Uo4MRFianyfFLVtpeZ6UK5YkFZKITBGRJbksg4ARQAugC86X9JVjzu0FpKrqksLeNpdtQe+WGKay9QS8QH2cqv8HRKR5sQtzjDCVLRroC1zl/3mhiPQvdmGOEaayPQ28pqqHglGGvISpbIfP7wC8CNxavFLkew97nhxdtkC/MzcCd4jIPKASTo0RlO7nSXHLViLPE3M0GyepkFT19ECOE5H3gQnHbB5M4WuRoISGbA9x2XaISD1V3SYi9YCd/u1XAhNV1Q3sFJE/gB44r3GCJkxlSwJmqOpu/7V/AroBUwsVfAHCVLZewCUi8hJQFfCJSLqqvl3I8PMVprIhIg2BscC1qrq2kGEHLIz/Lkvr8ySg74yqrsB5/YSItAYG+neV5udJcctWIs8TczSrSQoi/4PosAtxqk0P73PhVJ1+WYRLjwcGi0iciDQDWgFzihNrYQWhbOOB6/zr1wHj/OubgH7iqAD0BlYEK+5AhLBsk4DjRCRRnDYSpwDLghV3IEJVNlU9SVWbqmpT4HXg+WAnSAUJVdlEpCrwIzBMVf8IZsyFEcJ/l6X5eRLQd0ZEDr/2dQGPAyP9u0rz86S4ZQv786RcCnfL8bK0AJ8Ci3F6IIwH6mXbdyowO5dzPsDfkw3nC5UEZAA7gEnZjnsMpxfKSuDsCCxbDZzfeFb7f1b3b6+I0ztqKc4X/qGyUjb/vqv9ZVsCvFSWypbt+OGEp3dbqP5NPo7TrmVBtqV2WSmff19pfp7k+p05pmz3AKv8ywscGRi5tD9Pily2/M63JXSLjbhtjDHGGJMLe91mjDHGGJMLS5KMMcYYY3JhSZIxxhhjTC4sSTLGGGOMyYUlScYYY4wxubAkyZgwEZEacmSm8O1y9MzhseGOLzcicqOI1A3h9SuIyHT/GDHH7vtMnPniinrt3iIyU5yZ71eIyCgRSRCRC0TkieJFbowpiyxJMiZM1JmgsouqdsEZMO61w59VNbOg80NFRKLy2X0jUKgkyT/wXaBuBr5RVV9h7hFADPWAr4D7VbUN0B5n7KCKOIMsXiwi8cG8pzEm8lmSZEwpJCLXicgcf63SuyLiEpFoEdkvIi+LM8HlJBHpJSIzRGSdiJzjP/dmERnr379SRB4P8Lr/FpE5QE8ReVpE/hZnPqqR/hGML8eZj+qrw7VdIpLkH6H6cE3NFP/6v0XkPRGZDHzov8er/nsvEpGb8yj6VRwZ+drlj3GZiPwA1MxWjuP95Z4nIj+LSJ1sMSwSkVn+P6cF/lPuAv6rqnMAVNWnql+p6i51Bov7HTgnSH99xpgywpIkY0oZEemIM/p6H38tUzTOPF0AVYBfVLUbzsSXw4H+OFNUPJPtMj3953QDrhSRLgFc9x9V7amqfwJvqOrxQCf/vrNU9Suc0acvD7C2qytwnqpeA9wC7FTVnsDxOBN4Nj6m3PFAQ1VN8m+6BGeS0o7AbUAf/3FxwBvAxaraHfgMeNZ/zofAzarah6Mncu0IzMsn1rnASQWUxxhTztgEt8aUPqfjJBJzRQQgAdjs35emqpP964uBA6rqEZHFQNNs15ikqvsAROR/OLOGR+dz3UycCV0P6y8iDwHxODU484CfC1mOcaqa7l8/A2gnItmTslY4c20dVhvYm+3zycAX/ldvSSIy3b+9HdABmOIvR5R/f00g9nBtETAG588yEDtxZo43xpgsliQZU/oIMFpVj2pM7G/bk732xoczz9/h9ezf52PnG9ICrpvmf+2EiCQCbwPdVHWLiPwbJ1nKjYcjNdLHHpNyTJluV9X8ZixPy+Uauc2bJMAiVT2q5kdEauVz7aVAd5yJa3MT77+/McZksddtxpQ+U4DL/DUjh3vBNS7gnGOdISJV/QnPIOCPQlw3ASfp2i0ilYCLs+1LBipl+7wBJ/ngmOOONQm4/XAjbhFpIyIJ2Q9Q1V1AfLaefb/hzFbvEpEGOLOegzNxaQMR6em/VqyIdPCf7xaRHv7jBme7/FvATYf3+dtYXZctsWrNkdnajTEGsJokY0odVV0sIk/jvE5yAW7gX8DWQlxmJs7rphbAp6q6ACCQ66rqHhH5GCdp2Aj8lW33h8AHIpKG0+5pOPC+iGwH5pC394DGwAL/K7KdOMnbsabitD2aDnwLnOaPYyVO0oSqZojIJcCb/iQuGngFp7boRpyG4sn+4w/4z9kqIlcCb4hIDZwaqunA1/77ngbcn0/8xphySPw17MaYMsLfc6yjqt4b7lgKS0SOx3ktd0MRz6+oqof8648B1VX1gQLOqQ98pKpnFOWexpiyy2qSjDGlhqr+Lc6Aj64ijpV0vog8jPNs2wBcH8A5jYAHi3AvY0wZZzVJxhhjjDG5sIbbxhhjjDG5sCTJGGOMMSYXliQZY4wxxuTCkiRjjDHGmFxYkmSMMcYYkwtLkowxxhhjcvH/OLhOjudLUi8AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(10, 5))\n",
+    "cm = plt.cm.get_cmap('viridis')\n",
+    "z = np.subtract(offset_train_id_reading, offset_train_id_reading[0])/600\n",
+    "sc = plt.scatter(Temperature_reading, np.mean(offset, axis=(1,2)) - np.mean(offset[0], axis=(0,1)), c=z, s=5, cmap=cm)\n",
+    "plt.xlabel('Temperature (degC)')\n",
+    "plt.ylabel(\"Average Corrected Offset per 100 Frames (ADU)\")\n",
+    "plt.title(\"Average is calculated over both rows and columns.\")\n",
+    "plt.colorbar(sc, label='Time (minutes)')\n",
+    "plt.show()\n",
+    "\n",
+    "fig = plt.figure(figsize=(10, 5))\n",
+    "cm = plt.cm.get_cmap('viridis')\n",
+    "z = np.subtract(offset_train_id_reading, offset_train_id_reading[0])/600\n",
+    "sc = plt.scatter(Temperature_reading, np.mean(noise, axis=(1,2)), c=z, s=5, cmap=cm)\n",
+    "plt.xlabel('Temperature (degC)')\n",
+    "plt.ylabel(\"Average Noise per 100 Frames (ADU)\")\n",
+    "plt.title(\"Average is calculated over both rows and columns.\")\n",
+    "plt.colorbar(sc, label='Time (minutes)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Offset and Noise (averaged over columns and rows) vs. Time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(10, 5))\n",
+    "cm = plt.cm.get_cmap('viridis')\n",
+    "z = Temperature_reading\n",
+    "sc = plt.scatter(np.subtract(offset_train_id_reading, offset_train_id_reading[0])/600, \n",
+    "                 np.mean(offset, axis=(1,2)) - np.mean(offset[0], axis=(0,1)), c=z, s=5, cmap=cm)\n",
+    "plt.xlabel('Time (minutes)')\n",
+    "plt.ylabel(\"Average Corrected Offset per 100 Frames (ADU)\")\n",
+    "plt.title(\"Average is calculated over both rows and columns.\")\n",
+    "plt.colorbar(sc, label='Temperature (degC)')\n",
+    "plt.show()\n",
+    "\n",
+    "fig = plt.figure(figsize=(10, 5))\n",
+    "cm = plt.cm.get_cmap('viridis')\n",
+    "z = Temperature_reading\n",
+    "sc = plt.scatter(np.subtract(offset_train_id_reading, offset_train_id_reading[0])/600, np.mean(noise, axis=(1,2)), \n",
+    "                 c=z, s=5, cmap=cm)\n",
+    "plt.xlabel('Time (minutes)')\n",
+    "plt.ylabel(\"Average Noise per 100 Frames (ADU)\")\n",
+    "plt.title(\"Average is calculated over both rows and columns.\")\n",
+    "plt.colorbar(sc, label='Temperature (degC)')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bad Pixels\n",
+    "\n",
+    "The bad pixel maps are generated based on the offset and noise maps. Any pixel whose offset or noise at any moment of time is below or above 5 standard deviations from medians of the offsetmap or noisemap at that moment of time is a bad pixel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bad_pixels = np.zeros(np.array(offset).shape, np.uint32)\n",
+    "\n",
+    "mnoffset = np.nanmedian(offset)\n",
+    "stdoffset = np.nanstd(offset)\n",
+    "\n",
+    "mnnoise = np.nanmedian(noise)\n",
+    "stdnoise = np.nanstd(noise)\n",
+    "\n",
+    "bad_pixels[(noise < mnnoise-bad_pixel_noise_sigma*stdnoise) | (noise > mnnoise+bad_pixel_noise_sigma*stdnoise) |\n",
+    "           (offset < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
+    "           (offset > mnoffset+bad_pixel_offset_sigma*stdoffset)] = 1 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We have assigned a value of 1 to these bad pixels to make a probability density (frequency) plot. There are as many bad pixel maps as there are offset maps and noise maps. By summing them (bad pixel maps) all up and divinding the sum by their total number, one arrives at a frequency of being a bad pixel for each pixel. 0% (frequency = 0) means the pixel is never considered bad in any of the bad pixel maps and 100% (frequency = 1) means the pixel is considered a bad pixel on all bad pixel maps.\n",
+    "\n",
+    "Also one has to ensure the duration of the dark run(s) from which the bad pixel frequency map is derived is long enough (say 100,000 frames which should be just under 4 hours).\n",
+    "\n",
+    "Moreover, we add the pixels in the hole (center of the FastCCD) as well as 4 rows in the center of the detector, which we call overscan region:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_circular_mask(h, w, center=None, radius=None):\n",
+    "\n",
+    "    import numpy as np\n",
+    "    import math\n",
+    "    \n",
+    "    if center is None: # use the middle of the image\n",
+    "        center = [int(w/2), int(h/2)]\n",
+    "    if radius is None: # use the smallest distance between the center and image walls\n",
+    "        radius = min(center[0], center[1], w-center[0], h-center[1])\n",
+    "\n",
+    "    Y, X = np.ogrid[:h, :w]\n",
+    "    dist_from_center = np.sqrt((X - center[0])**2 + (Y-center[1])**2)\n",
+    "    mask = dist_from_center < radius\n",
+    "    \n",
+    "    return mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mask = np.zeros(np.array(offset).shape, np.uint32)\n",
+    "\n",
+    "# Defining a circular mask + a rectangular mask (overscan) for the hole in the middle of the CCD:\n",
+    "h, w = (1934, 960) # 1934 = number of FastCCD rows, 960 = number of FastCCD columns\n",
+    "hole_mask_bool = create_circular_mask(h-4, w, radius=61.5, center=(w//2,(h-4)//2))\n",
+    "hole_mask = np.zeros(hole_mask_bool.shape, np.uint32)\n",
+    "hole_mask[hole_mask_bool] = 1 # value is given as 1 for the reason stated above\n",
+    "\n",
+    "overscan_mask = np.full((4, w), 1) # value is given as 1 for the reason stated above\n",
+    "\n",
+    "mask[:,:,:] = np.insert(hole_mask, (h-4)//2, overscan_mask, 0)  \n",
+    "\n",
+    "# Assigning this masked area as bad pixels_freq:\n",
+    "bad_pixels = np.bitwise_or(bad_pixels, mask)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# To ensure the duration of the dark runs from which the bad pixel frequency map is derived is long enough:\n",
+    "assert bad_pixels.shape[0] > 1000, \"Insufficient statistics: at least 100,000 frames are needed for a reliable static \\\n",
+    "bad pixel map.\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "bad_pixels_freq = np.sum(bad_pixels, axis=0)/bad_pixels.shape[0]\n",
+    "\n",
+    "fig = xana.heatmapPlot(np.log2(bad_pixels_freq), aspect=1, \n",
+    "                       x_label='Column Number', y_label='Row Number', \n",
+    "                       lut_label='2^(Bad Pixel Frequency)', x_range=(0, 960), y_range=(0, 1934), \n",
+    "                       title = 'Bad Pixels Frequency Map - log2 plot', panel_x_label='Columns Stat', \n",
+    "                       panel_y_label='Rows Stat', interpolation=\"none\")\n",
+    "fig.set_size_inches(20, 10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Examples of Setting a Threshold\n",
+    "\n",
+    "The idea is to enable the users to set a threshold on the bad pixel frequency map. These thresholds could be, for instance, 10%, 5%, 1% and 0.1%. To do this, one needs to set to zero the values of all pixels whose probability of being a bad pixel is below the threshold."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Pixels whose frequency of becoming bad is below the threshold are good and therefore, their values should be 0 to be\n",
+    "# consistent with the other bad pixel maps from short dark runs:\n",
+    "\n",
+    "bad_pixels_freq[bad_pixels_freq < threshold] = 0 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 4 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig = xana.heatmapPlot(bad_pixels_freq, aspect=1, x_label='Column Number', y_label='Row Number', \n",
+    "                       add_panels = False, lut_label='Bad Pixel Frequency', x_range=(0, 960), y_range=(0, 1934), \n",
+    "                       title = 'Bad Pixels Frequency Map, Threshold = {}'.format(threshold), \n",
+    "                       panel_x_label='Columns Stat', panel_y_label='Rows Stat', cmap='viridis', vmin = 0, vmax=0.1,\n",
+    "                       interpolation=\"none\")\n",
+    "fig.set_size_inches(20, 10)\n",
+    "\n",
+    "fig = xana.heatmapPlot(np.log2(bad_pixels_freq), aspect=1, x_label='Column Number', y_label='Row Number', \n",
+    "                       lut_label='2^(Bad Pixel Frequency with threshold of {})'.format(threshold), x_range=(0, 960), \n",
+    "                       y_range=(0, 1934), title = 'Bad Pixels Frequency Map with threshold of {} - log2 plot'\n",
+    "                       .format(threshold), panel_x_label='Columns Stat', panel_y_label='Rows Stat', interpolation=\"none\")\n",
+    "fig.set_size_inches(20, 10)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Calibration Constant Conditions\n",
+    "\n",
+    "Bias voltage, detector gain, integration time and creation time are all identical for all sequences in a run. However, generally speaking, they may not be identical from run to run but we made sure they are for the set of runs we have here. The temperature is the only variable that may change from one sequence to the next within a run; however, the change in the temperature is below 1 degC. We have therefore, used sequence 0 of the first run to derive the parameters such as bias voltage, detector gain, integration time, temperature and creation time, which will be injected into the calibration database as identifiers for later retrieval of the same calibration constants."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Calibration database interface: tcp://max-exfl016:8020\n",
+      "Sending constants to the calibration database: True\n",
+      "\n",
+      "*******************************************************\n",
+      "The conditions of the constant are as follows:\n",
+      "Based on sequence 0 of run 41:\n",
+      "From file: /gpfs/exfel/exp/DETLAB/201931/p900104/raw/r0041/RAW-R0041-DA01-S00000.h5\n",
+      "Bias voltage is 79 V\n",
+      "Detector gain is set to x8 (high gain gain)\n",
+      "Detector integration time is set to 1 ms\n",
+      "Temperature is not fixed.\n",
+      "Mean temperature was -57.05 °C / 216.10 K\n",
+      "Creation time: 2019-08-27T08:51:55.535228\n"
+     ]
+    }
+   ],
+   "source": [
+    "sequences = 0 # We take the detector conditions (gain, bias, etc.) from sequence 0 of the first run in \"runs\" list\n",
+    "\n",
+    "gain_dict = {\n",
+    "        \"high gain\" : 8,\n",
+    "        \"medium gain\" : 2,\n",
+    "        \"low gain\" : 1,\n",
+    "        \"auto gain\" : 0\n",
+    "    }\n",
+    "    \n",
+    "gain_setting_1 = gain_dict[\"high gain\"]   \n",
+    "gain_setting_2 = gain_dict[\"medium gain\"]\n",
+    "gain_setting_3 = gain_dict[\"low gain\"]\n",
+    "gain_setting_4 = gain_dict[\"auto gain\"]\n",
+    "    \n",
+    "for run in [runs[0]]:\n",
+    "    ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
+    "    dirlist = sorted(os.listdir(ped_dir))\n",
+    "    fp_name = path_template.format(run)\n",
+    "    fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
+    "    filename = fp_path.format(sequences)\n",
+    "    with h5py.File(filename, 'r') as f:\n",
+    "        bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
+    "        det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
+    "        integration_time = int(f['{}/exposure/exposure_time/value'.format(h5path_cntrl)][0])\n",
+    "        \n",
+    "        if fix_temperature:\n",
+    "            temperature_k = temperature_k_fixed\n",
+    "        else:\n",
+    "            temperature = np.mean(f[h5path_t])\n",
+    "            temperature_k = temperature + 273.15\n",
+    "                    \n",
+    "    for gain, value in gain_dict.items():   \n",
+    "        if det_gain == value:\n",
+    "            gain_setting = gain\n",
+    "        \n",
+    "    if use_dir_creation_date:\n",
+    "        creation_time = get_dir_creation_date(in_folder, run)\n",
+    "    if creation_time:\n",
+    "        print('Calibration database interface: {}'.format(cal_db_interface))\n",
+    "        print(\"Sending constants to the calibration database: {}\\n\".format(db_output))\n",
+    "        print(\"*******************************************************\")\n",
+    "        print(\"The conditions of the constant are as follows:\")\n",
+    "        print(\"Based on sequence {} of run {}:\".format(sequences, run))\n",
+    "        print(\"From file: {}\".format(filename))\n",
+    "        print(\"Bias voltage is {} V\".format(bias_voltage))\n",
+    "        print(\"Detector gain is set to x{}\".format(det_gain), \"({} gain)\".format(gain_setting))\n",
+    "        print(\"Detector integration time is set to {}\".format(integration_time), 'ms')\n",
+    "        if fix_temperature:\n",
+    "            print(\"Using a fixed temperature of {}\".format(temperature_k), \"K\")\n",
+    "        else:\n",
+    "            print(\"Temperature is not fixed.\")\n",
+    "            print(\"Mean temperature was {:0.2f} °C / {:0.2f} K\".format(temperature, temperature_k))\n",
+    "        print(\"Creation time: {}\".format(creation_time.isoformat()))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Sending Bad Pixel Frequency Map as a Constant to the Calibration Database"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The Calibration constant bad_pixels_freq_thresh is sent to the calibration database as StaticBadPixels.\n",
+      "Threshold on the frequency was set to 0.001.\n",
+      "Creation time is: 2019-08-27 08:51:55.535228\n"
+     ]
+    }
+   ],
+   "source": [
+    "dictionary = {} \n",
+    "dictionary['StaticBadPixels'] = bad_pixels_freq.data\n",
+    "\n",
+    "for const in dictionary:\n",
+    "    metadata = ConstantMetaData()\n",
+    "    dconst = getattr(Constants.CCD(DetectorTypes.fastCCD), const)()\n",
+    "    dconst.data = dictionary[const]\n",
+    "    metadata.calibration_constant = dconst\n",
+    "    \n",
+    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                    integration_time=integration_time,\n",
+    "                                    gain_setting=det_gain,\n",
+    "                                    temperature=temperature_k,\n",
+    "                                    pixels_x=1934,\n",
+    "                                    pixels_y=960,\n",
+    "                                    freq_threshold=threshold)\n",
+    "    \n",
+    "    for parm in condition.parameters:\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            parm.lower_deviation = temp_limits\n",
+    "            parm.upper_deviation = temp_limits\n",
+    "\n",
+    "    device = Detectors.fastCCD1\n",
+    "    metadata.detector_condition = condition\n",
+    "    \n",
+    "    # Specifying the a version for this constant:\n",
+    "    if creation_time is None:\n",
+    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "    else:\n",
+    "        metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
+    "    \n",
+    "    if db_output:\n",
+    "        metadata.send(cal_db_interface, timeout=cal_db_timeout)    \n",
+    "        \n",
+    "print(\"The Calibration constant bad_pixels_freq_thresh is sent to the calibration database as StaticBadPixels.\")\n",
+    "print(\"Threshold on the frequency was set to {}.\".format(threshold))\n",
+    "print(\"Creation time is: {}\".format(creation_time))"
+   ]
+  },
+  {
+   "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
-- 
GitLab


From e5408d257c5153e0560b310bce8fa2ee5a8f0485 Mon Sep 17 00:00:00 2001
From: Kiana Setoodehnia <kiana.setoodehnia@xfel.eu>
Date: Mon, 14 Oct 2019 09:42:58 +0200
Subject: [PATCH 2/3] Deleted the other notebooks I don't want to merge.

---
 ...haracterize_Darks_NewDAQ_FastCCD_NBC.ipynb |  574 --------
 ...s_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb | 1016 -------------
 ...orrectionNotebook_NewDAQ_FastCCD_NBC.ipynb | 1279 -----------------
 .../FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb   |  505 -------
 4 files changed, 3374 deletions(-)
 delete mode 100644 notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb
 delete mode 100644 notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb
 delete mode 100644 notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb
 delete mode 100644 notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb

diff --git a/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb b/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb
deleted file mode 100644
index 6ee85833c..000000000
--- a/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb
+++ /dev/null
@@ -1,574 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# FastCCD Dark Characterization\n",
-    "\n",
-    "Author: I. Klačková, S. Hauf, Version 1.0\n",
-    "\n",
-    "The following notebook provides dark image analysis of the FastCCD detector.\n",
-    "\n",
-    "Dark characterization evaluates offset and noise of the detector and gives information about bad pixels. Resulting maps are saved as .h5 files for a latter use."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:38.999974Z",
-     "start_time": "2018-12-06T10:54:38.983406Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "in_folder = \"/gpfs/exfel/exp/SCS/201930/p900074/raw/\" # input folder, required\n",
-    "out_folder = 'gpfs/exfel/data/scratch/haufs/test/' # output folder, required\n",
-    "path_template = 'RAW-R{:04d}-DA05-S{{:05d}}.h5' # the template to use to access data\n",
-    "run = 321 # which run to read data from, required\n",
-    "number_dark_frames = 0 # number of images to be used, if set to 0 all available images are used\n",
-    "cluster_profile = \"noDB\" # ipcluster profile to use\n",
-    "operation_mode = \"FF\" #o r \"FF\". FS stands for frame-store and FF for full-frame opeartion\n",
-    "sigma_noise = 10. # Pixel exceeding 'sigmaNoise' * noise value in that pixel will be masked\n",
-    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image/pixels' # path in the HDF5 file the data is at\n",
-    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value'  # path to find temperature at\n",
-    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # path to control data\n",
-    "cal_db_interface = \"tcp://max-exfl016:8020\" # calibration DB interface to use\n",
-    "local_output = False # output also in as H5 files\n",
-    "temp_limits = 5 # limits within which temperature is considered the same\n",
-    "sequence = 0 # sequence file to use\n",
-    "multi_iteration = False # use multiple iterations\n",
-    "use_dir_creation_date = True # use dir creation date\n",
-    "bad_pixel_offset_sigma = 5. # offset standard deviations above which to consider pixel bad \n",
-    "bad_pixel_noise_sigma = 5. # noise standard deviations above which to consider pixel bad \n",
-    "fix_temperature = 0. # fix temperature to this value, set to 0 to use slow control value"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:39.190907Z",
-     "start_time": "2018-12-06T10:54:39.186154Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
-    "from iCalibrationDB.detectors import DetectorTypes"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:39.467334Z",
-     "start_time": "2018-12-06T10:54:39.427784Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import XFELDetAna.xfelprofiler as xprof\n",
-    "\n",
-    "profiler = xprof.Profiler()\n",
-    "profiler.disable()\n",
-    "from XFELDetAna.util import env\n",
-    "env.iprofile = cluster_profile\n",
-    "\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "\n",
-    "from XFELDetAna import xfelpycaltools as xcal\n",
-    "from XFELDetAna import xfelpyanatools as xana\n",
-    "from XFELDetAna.plotting.util import prettyPlotting\n",
-    "prettyPlotting=True\n",
-    "from XFELDetAna.xfelreaders import ChunkReader\n",
-    "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
-    "from cal_tools.tools import get_dir_creation_date\n",
-    "\n",
-    "import numpy as np\n",
-    "import h5py\n",
-    "import matplotlib.pyplot as plt\n",
-    "from iminuit import Minuit\n",
-    "\n",
-    "import time\n",
-    "import copy\n",
-    "\n",
-    "from prettytable import PrettyTable\n",
-    "\n",
-    "%matplotlib inline\n",
-    "\n",
-    "def nImagesOrLimit(nImages, limit):\n",
-    "    if limit == 0:\n",
-    "        return nImages\n",
-    "    else:\n",
-    "        return min(nImages, limit)\n",
-    "    \n",
-    "sigmaNoise = sigma_noise"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
-    "file_loc = 'proposal:{} runs:{}'.format(proposal, run)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:40.058101Z",
-     "start_time": "2018-12-06T10:54:40.042615Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "if operation_mode == \"FS\":\n",
-    "    x = 960 # rows of the FastCCD to analyze in FS mode \n",
-    "    y = 960 # columns of the FastCCD to analyze in FS mode \n",
-    "    print('\\nYou are analyzing data in FS mode.')\n",
-    "else:\n",
-    "    x = 1934 # rows of the FastCCD to analyze in FF mode \n",
-    "    y = 960 # columns of the FastCCD to analyze in FF mode\n",
-    "    print('\\nYou are analyzing data in FF mode.\\n')\n",
-    "    \n",
-    "ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
-    "fp_name = path_template.format(run)\n",
-    "\n",
-    "import datetime\n",
-    "creation_time = None\n",
-    "if use_dir_creation_date:\n",
-    "    creation_time = get_dir_creation_date(in_folder, run)\n",
-    "\n",
-    "fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
-    "\n",
-    "print(\"Reading data from: {}\\n\".format(fp_path))\n",
-    "print(\"Run is: {}\".format(run))\n",
-    "print(\"HDF5 path: {}\".format(h5path))\n",
-    "if creation_time:\n",
-    "    print(\"Using {} as creation time\".format(creation_time.isoformat()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:40.555804Z",
-     "start_time": "2018-12-06T10:54:40.452978Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "filename = fp_path.format(sequence)\n",
-    "sensorSize = [x, y]\n",
-    "chunkSize = 100 #Number of images to read per chunk\n",
-    "#Sensor area will be analysed according to blocksize\n",
-    "blockSize = [sensorSize[0]//2, sensorSize[1]//4] \n",
-    "xcal.defaultBlockSize = blockSize\n",
-    "cpuCores = 8 #Specifies the number of running cpu cores\n",
-    "memoryCells = 1 #FastCCD has 1 memory cell\n",
-    "#Specifies total number of images to proceed\n",
-    "nImages = fastccdreaderh5.getDataSize(filename, h5path)[0] \n",
-    "nImages = nImagesOrLimit(nImages, number_dark_frames)\n",
-    "print(\"\\nNumber of dark images to analyze: \",nImages)\n",
-    "commonModeBlockSize = blockSize\n",
-    "commonModeAxisR = 'row'#Axis along which common mode will be calculated\n",
-    "run_parallel = True\n",
-    "profile = False\n",
-    "\n",
-    "with h5py.File(filename, 'r') as f:\n",
-    "    bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
-    "    det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
-    "    integration_time = int(f['{}/acquisitionTime/value'.format(h5path_cntrl)][0])\n",
-    "    temperature = np.mean(f[h5path_t])\n",
-    "    temperature_k = temperature + 273.15\n",
-    "        \n",
-    "    if fix_temperature != 0.:\n",
-    "        temperature_k = fix_temperature\n",
-    "        print(\"Using fixed temperature\")\n",
-    "    print(\"Bias voltage is {} V\".format(bias_voltage))\n",
-    "    print(\"Detector gain is set to x{}\".format(det_gain))\n",
-    "    print(\"Detector integration time is set to {}\".format(integration_time))\n",
-    "    print(\"Mean temperature was {:0.2f} °C / {:0.2f} K\".format(temperature, temperature_k))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:41.584031Z",
-     "start_time": "2018-12-06T10:54:41.578462Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "reader = ChunkReader(filename, fastccdreaderh5.readData, \n",
-    "                     nImages, chunkSize, \n",
-    "                     path = h5path, \n",
-    "                     pixels_x = sensorSize[0],\n",
-    "                     pixels_y = sensorSize[1],)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:41.899511Z",
-     "start_time": "2018-12-06T10:54:41.864816Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "noiseCal = xcal.NoiseCalculator(sensorSize, memoryCells, \n",
-    "                                cores=cpuCores, blockSize=blockSize,\n",
-    "                               runParallel=run_parallel)\n",
-    "histCalRaw = xcal.HistogramCalculator(sensorSize, bins=1000, \n",
-    "                                      range=[0, 10000], parallel=False, \n",
-    "                                      memoryCells=memoryCells, \n",
-    "                                      cores=cpuCores, blockSize=blockSize)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### First Iteration"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Characterization of dark images with purpose to create dark maps (offset, noise and bad pixel maps) is an iterative process. Firstly, initial offset and noise maps are produced from raw dark data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:55:21.238009Z",
-     "start_time": "2018-12-06T10:54:54.586435Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "for data in reader.readChunks():\n",
-    "    data = np.bitwise_and(data.astype(np.uint16), 0b0011111111111111).astype(np.float32)\n",
-    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
-    "    data = data[:,:,dx != 0]\n",
-    "    histCalRaw.fill(data)\n",
-    "    #Filling calculators with data\n",
-    "    noiseCal.fill(data)\n",
-    "          \n",
-    "offsetMap = noiseCal.getOffset() #Produce offset map\n",
-    "noiseMap = noiseCal.get() #Produce noise map\n",
-    "noiseCal.reset() #Reset noise calculator\n",
-    "print(\"Initial maps were created\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:56:20.686534Z",
-     "start_time": "2018-12-06T10:56:11.721829Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "#**************OFFSET MAP HISTOGRAM***********#\n",
-    "ho,co = np.histogram(offsetMap.flatten(), bins=700)\n",
-    "\n",
-    "do = {'x': co[:-1],\n",
-    "     'y': ho,\n",
-    "     'y_err': np.sqrt(ho[:]),\n",
-    "     'drawstyle': 'bars',\n",
-    "     'color': 'cornflowerblue',\n",
-    "     }\n",
-    "\n",
-    "fig = xana.simplePlot(do, figsize='1col', aspect=2, \n",
-    "                      x_label = 'Offset (ADU)', \n",
-    "                      y_label=\"Counts\", y_log=True,\n",
-    "                      )\n",
-    "                      \n",
-    "\n",
-    "#*****NOISE MAP HISTOGRAM FROM THE OFFSET CORRECTED DATA*******#\n",
-    "hn,cn = np.histogram(noiseMap.flatten(), bins=200)\n",
-    "\n",
-    "dn = {'x': cn[:-1],\n",
-    "     'y': hn,\n",
-    "     'y_err': np.sqrt(hn[:]),\n",
-    "     'drawstyle': 'bars',\n",
-    "     'color': 'cornflowerblue',\n",
-    "     }\n",
-    "\n",
-    "fig = xana.simplePlot(dn, figsize='1col', aspect=2, \n",
-    "                      x_label = 'Noise (ADU)', \n",
-    "                      y_label=\"Counts\", \n",
-    "                      y_log=True)\n",
-    "\n",
-    "\n",
-    "#**************HEAT MAPS*******************#\n",
-    "fig = xana.heatmapPlot(offsetMap[:,:,0],\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Offset (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmin=3000, vmax=4500)\n",
-    "\n",
-    "fig = xana.heatmapPlot(noiseMap[:,:,0],\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Noise (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmax=2*np.mean(noiseMap))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:56:22.741284Z",
-     "start_time": "2018-12-06T10:56:20.688393Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "\n",
-    "## offset\n",
-    "\n",
-    "metadata = ConstantMetaData()\n",
-    "offset = Constants.CCD(DetectorTypes.fastCCD).Offset()\n",
-    "offset.data = offsetMap.data\n",
-    "metadata.calibration_constant = offset\n",
-    "\n",
-    "# set the operating condition\n",
-    "condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                integration_time=integration_time,\n",
-    "                                gain_setting=det_gain,\n",
-    "                                temperature=temperature_k,\n",
-    "                                pixels_x=1934,\n",
-    "                                pixels_y=960)\n",
-    "for parm in condition.parameters:\n",
-    "    if parm.name == \"Sensor Temperature\":\n",
-    "        parm.lower_deviation = temp_limits\n",
-    "        parm.upper_deviation = temp_limits\n",
-    "\n",
-    "device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "metadata.detector_condition = condition\n",
-    "\n",
-    "# specify the version for this constant\n",
-    "if creation_time is None:\n",
-    "    metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "else:\n",
-    "    metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
-    "metadata.calibration_constant_version.raw_data_location = file_loc\n",
-    "metadata.send(cal_db_interface)\n",
-    "\n",
-    "## noise\n",
-    "\n",
-    "metadata = ConstantMetaData()\n",
-    "noise = Constants.CCD(DetectorTypes.fastCCD).Noise()\n",
-    "noise.data = noiseMap.data\n",
-    "metadata.calibration_constant = noise\n",
-    "\n",
-    "# set the operating condition\n",
-    "condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                integration_time=integration_time,\n",
-    "                                gain_setting=det_gain,\n",
-    "                                temperature=temperature_k,\n",
-    "                                pixels_x=1934,\n",
-    "                                pixels_y=960)\n",
-    "\n",
-    "for parm in condition.parameters:\n",
-    "    if parm.name == \"Sensor Temperature\":\n",
-    "        parm.lower_deviation = temp_limits\n",
-    "        parm.upper_deviation = temp_limits\n",
-    "\n",
-    "\n",
-    "device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "metadata.detector_condition = condition\n",
-    "\n",
-    "# specify the a version for this constant\n",
-    "if creation_time is None:\n",
-    "    metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "else:\n",
-    "    metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
-    "metadata.calibration_constant_version.raw_data_location = file_loc\n",
-    "metadata.send(cal_db_interface)\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from cal_tools.enums import BadPixels\n",
-    "bad_pixels = np.zeros(offsetMap.shape, np.uint32)\n",
-    "mnoffset = np.nanmedian(offsetMap)\n",
-    "stdoffset = np.nanstd(offsetMap)\n",
-    "bad_pixels[(offsetMap < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
-    "           (offsetMap > mnoffset+bad_pixel_offset_sigma*stdoffset)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
-    "\n",
-    "mnnoise = np.nanmedian(noiseMap)\n",
-    "stdnoise = np.nanstd(noiseMap)\n",
-    "bad_pixels[(noiseMap < mnnoise-bad_pixel_noise_sigma*stdnoise) | \n",
-    "           (noiseMap > mnnoise+bad_pixel_noise_sigma*stdnoise)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
-    "\n",
-    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Bad Pixel Value (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmin=0, vmax=32)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "metadata = ConstantMetaData()\n",
-    "badpix = Constants.CCD(DetectorTypes.fastCCD).BadPixelsDark()\n",
-    "badpix.data = bad_pixels.data\n",
-    "metadata.calibration_constant = badpix\n",
-    "\n",
-    "# set the operating condition\n",
-    "condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                integration_time=integration_time,\n",
-    "                                gain_setting=det_gain,\n",
-    "                                temperature=temperature_k,\n",
-    "                                pixels_x=1934,\n",
-    "                                pixels_y=960)\n",
-    "\n",
-    "for parm in condition.parameters:\n",
-    "    if parm.name == \"Sensor Temperature\":\n",
-    "        parm.lower_deviation = temp_limits\n",
-    "        parm.upper_deviation = temp_limits\n",
-    "\n",
-    "\n",
-    "device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "metadata.detector_condition = condition\n",
-    "\n",
-    "# specify the a version for this constant\n",
-    "if creation_time is None:\n",
-    "    metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "else:\n",
-    "    metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
-    "metadata.calibration_constant_version.raw_data_location = file_loc\n",
-    "metadata.send(cal_db_interface)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "histCalCorr = xcal.HistogramCalculator(sensorSize, bins=200, \n",
-    "                                      range=[-200, 200], parallel=False, \n",
-    "                                      memoryCells=memoryCells, \n",
-    "                                      cores=cpuCores, blockSize=blockSize)\n",
-    "\n",
-    "\n",
-    "for data in reader.readChunks():\n",
-    "    data = np.bitwise_and(data.astype(np.uint16), 0b0011111111111111).astype(np.float32)\n",
-    "    data -= offsetMap.data\n",
-    "    histCalCorr.fill(data)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ho,eo,co,so = histCalCorr.get()\n",
-    "\n",
-    "\n",
-    "d = [{'x': co,\n",
-    "      'y': ho,\n",
-    "      'y_err': np.sqrt(ho[:]),\n",
-    "      'drawstyle': 'steps-mid',\n",
-    "      'errorstyle': 'bars',\n",
-    "      'errorcoarsing': 2,\n",
-    "      'label': 'Offset corr.'\n",
-    "     },\n",
-    "    \n",
-    "     ]\n",
-    "     \n",
-    "\n",
-    "fig = xana.simplePlot(d, aspect=1, x_label='Energy(ADU)', \n",
-    "                      y_label='Number of occurrences', figsize='2col',\n",
-    "                      y_log=True, x_range=(-50,500),\n",
-    "                      legend='top-center-frame-2col')"
-   ]
-  },
-  {
-   "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.7"
-  },
-  "latex_envs": {
-   "LaTeX_envs_menu_present": true,
-   "autocomplete": true,
-   "bibliofile": "biblio.bib",
-   "cite_by": "apalike",
-   "current_citInitial": 1,
-   "eqLabelWithNumbers": true,
-   "eqNumInitial": 1,
-   "hotkeys": {
-    "equation": "Ctrl-E",
-    "itemize": "Ctrl-I"
-   },
-   "labels_anchors": false,
-   "latex_user_defs": false,
-   "report_style_numbering": false,
-   "user_envs_cfg": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb b/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb
deleted file mode 100644
index 001a9c3ea..000000000
--- a/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb
+++ /dev/null
@@ -1,1016 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# FastCCD Dark Characterization\n",
-    "\n",
-    "Author: I. Klačková, S. Hauf, K. Setoodehnia and M. Cascella\n",
-    "\n",
-    "The following notebook provides dark image analysis of the FastCCD detector.\n",
-    "\n",
-    "Dark characterization evaluates offset and noise of the FastCCD detector, corrects the noise for Common Mode (CM), and defines bad pixels relative to offset and CM corrected noise. Bad pixels are then excluded and CM corrected noise is recalculated excluding the bad pixels. Resulting offset and CM corrected noise maps, as well as the bad pixel map are sent to the calibration database."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:38.999974Z",
-     "start_time": "2018-12-06T10:54:38.983406Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Initial Parameters:\n",
-    "\n",
-    "in_folder = \"/gpfs/exfel/exp/SCS/201930/p900074/raw\" # input folder, required\n",
-    "out_folder = '/gpfs/exfel/data/scratch/setoodeh/DarkRuns' # output folder, required\n",
-    "path_template = 'RAW-R{:04d}-{}-S{{:05d}}.h5' # the template to use to access data\n",
-    "path_inset = 'DA05'\n",
-    "run = 351 # which run to read data from, required\n",
-    "number_dark_frames = 0 # number of images to be used, if set to 0 all available images are used\n",
-    "cluster_profile = \"noDB\" # ipcluster profile to use\n",
-    "# The two operation modes for FastCCD have fixed names which cannot be changed:\n",
-    "operation_mode = \"FF\" # FS stands for frame-store and FF for full-frame opeartion. \n",
-    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image/pixels' # path to the data in the HDF5 file \n",
-    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value'  # path to find temperature\n",
-    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # path to find control data\n",
-    "cal_db_interface = \"tcp://max-exfl016:8020\" # the calibration database interface to use\n",
-    "cal_db_timeout = 300000 # timeout on calibration database requests\n",
-    "temp_limits = 5 # to find calibration constants later on, the sensor temperature is allowed to vary by 5 units\n",
-    "sequence = 0 # sequallence file to use\n",
-    "use_dir_creation_date = True # To be used to retrieve calibration constants later on (for database time derivation)\n",
-    "bad_pixel_offset_sigma = 5. # Any pixel whose offset is beyond 5 standard deviations, is a bad pixel\n",
-    "bad_pixel_noise_sigma = 5. # Any pixel whose noise is beyond 5 standard deviations, is a bad pixel\n",
-    "sigmaNoise = 5. # Any pixel whose signal exceeds 'sigmaNoise'*noiseCM (common mode corrected noise) will be masked\n",
-    "fix_temperature = 0. # Fixed operation temperature in Kelvins. If set to 0, mean value of the data file's temperature is used.\n",
-    "chunkSize = 100 # Number of images to read per chunk\n",
-    "cpuCores = 40 # Specifies the number of running cpu cores\n",
-    "commonModeAxis = 1 # Axis along which common mode will be calculated (0: along rows, 1: along columns)\n",
-    "ADU_to_electron_upper = 6.1 # According to Table 6.1 of Ivana Klačková's master's thesis, for upper hemisphere: conversion\n",
-    "                            # gain is 1 ADU = 6.1e-\n",
-    "ADU_to_electron_lower = 6.2 # and for lower hemisphere: conversion gain is 1 ADU = 6.2e-\n",
-    "run_parallel = True # For parallel computation \n",
-    "db_output = True # Output constants to the calibration database"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:39.467334Z",
-     "start_time": "2018-12-06T10:54:39.427784Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Required Packages:\n",
-    "\n",
-    "import copy\n",
-    "import datetime\n",
-    "import os\n",
-    "import time\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "\n",
-    "import h5py\n",
-    "from IPython.display import display, Markdown\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
-    "import numpy as np\n",
-    "from prettytable import PrettyTable\n",
-    "\n",
-    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
-    "from iCalibrationDB.detectors import DetectorTypes\n",
-    "from cal_tools.tools import get_dir_creation_date\n",
-    "from cal_tools.enums import BadPixels\n",
-    "from XFELDetAna import xfelpyanatools as xana\n",
-    "from XFELDetAna import xfelpycaltools as xcal\n",
-    "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
-    "from XFELDetAna.util import env\n",
-    "env.iprofile = cluster_profile\n",
-    "import XFELDetAna.xfelprofiler as xprof\n",
-    "profiler = xprof.Profiler()\n",
-    "profiler.disable()\n",
-    "from XFELDetAna.xfelreaders import ChunkReader"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:39.467334Z",
-     "start_time": "2018-12-06T10:54:39.427784Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Output Folder Creation:\n",
-    "if not os.path.exists(out_folder):\n",
-    "    os.makedirs(out_folder)\n",
-    "\n",
-    "# Number of Images:\n",
-    "def nImagesOrLimit(nImages, limit):\n",
-    "    if limit == 0:\n",
-    "        return nImages\n",
-    "    else:\n",
-    "        return min(nImages, limit)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
-    "file_loc = 'proposal:{} runs:{}'.format(proposal, run)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:40.058101Z",
-     "start_time": "2018-12-06T10:54:40.042615Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Detector Operation Mode, Calibration Database Settings, and Some Initial Run Parameters & Paths:\n",
-    "\n",
-    "display(Markdown('### Initial Settings'))\n",
-    "if operation_mode == \"FS\":\n",
-    "    x = 960 # rows of the FastCCD to analyze in FS mode \n",
-    "    y = 960 # columns of the FastCCD to analyze in FS mode \n",
-    "    print('\\nYou are analyzing data in FS mode.')\n",
-    "else:\n",
-    "    x = 1934 # rows of the FastCCD to analyze in FF mode \n",
-    "    y = 960 # columns of the FastCCD to analyze in FF mode\n",
-    "    print('\\nYou are analyzing data in FF mode.')\n",
-    "    \n",
-    "ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
-    "fp_name = path_template.format(run, path_inset)\n",
-    "fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
-    "filename = fp_path.format(sequence)\n",
-    "\n",
-    "creation_time = None\n",
-    "if use_dir_creation_date:\n",
-    "    creation_time = get_dir_creation_date(in_folder, run)\n",
-    "        \n",
-    "print('Calibration database Interface: {}'.format(cal_db_interface))\n",
-    "print(\"Sending constants to the calibration database: {}\".format(db_output))\n",
-    "print(\"HDF5 path to data: {}\".format(h5path))\n",
-    "print(\"Run number: {}\".format(run))\n",
-    "print(\"Reading data from: {}\".format(filename))\n",
-    "if creation_time:\n",
-    "    print(\"Using {} as creation time\".format(creation_time.isoformat()))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:40.555804Z",
-     "start_time": "2018-12-06T10:54:40.452978Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Reading Parameters such as Detector Bias, Gain, etc. from the Data:\n",
-    "\n",
-    "memoryCells = 1 # FastCCD has 1 memory cell\n",
-    "sensorSize = [x, y]\n",
-    "blockSize = [sensorSize[0]//2, sensorSize[1]] # Sensor area will be analysed according to blocksize\n",
-    "xcal.defaultBlockSize = blockSize\n",
-    "nImages = fastccdreaderh5.getDataSize(filename, h5path)[0] # Specifies total number of images to proceed\n",
-    "nImages = nImagesOrLimit(nImages, number_dark_frames)\n",
-    "profile = False\n",
-    "gain_setting = None\n",
-    "\n",
-    "with h5py.File(filename, 'r') as f:\n",
-    "    bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
-    "    det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
-    "    integration_time = int(f['{}/acquisitionTime/value'.format(h5path_cntrl)][0])\n",
-    "    temperature = np.mean(f[h5path_t])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:40.555804Z",
-     "start_time": "2018-12-06T10:54:40.452978Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Printing the Parameters Read from the Data File:\n",
-    "\n",
-    "display(Markdown('### Evaluated Parameters'))\n",
-    "print(\"Number of dark images to analyze:\",nImages)   \n",
-    "\n",
-    "if det_gain == 8:\n",
-    "    gain_setting = \"high\"\n",
-    "elif det_gain == 2:\n",
-    "    gain_setting = \"medium\"\n",
-    "elif det_gain == 1:\n",
-    "    gain_setting = \"low\"\n",
-    "else:\n",
-    "    gain_setting = \"auto\"\n",
-    "\n",
-    "print(\"Bias voltage is {} V\".format(bias_voltage))\n",
-    "print(\"Detector gain is set to x{}\".format(det_gain), \"({} gain)\".format(gain_setting))\n",
-    "print(\"Detector integration time is set to {}\".format(integration_time), 'ms')\n",
-    "\n",
-    "if fix_temperature != 0.:\n",
-    "    print(\"Using a fixed temperature of {} K\".format(fix_temperature))\n",
-    "else:\n",
-    "    # This is needed while sending the \n",
-    "    # calibration constant to the DB later\n",
-    "    fix_temperature = temperature + 273.15\n",
-    "    print(\"Temperature is not fixed.\")\n",
-    "    print(\"Mean temperature was {:0.2f} °C / {:0.2f} K\".format(temperature, fix_temperature))\n",
-    "\n",
-    "print(\"Output: {}\".format(out_folder))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:41.899511Z",
-     "start_time": "2018-12-06T10:54:41.864816Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Reading Files in Chunks:\n",
-    "\n",
-    "# Chunk reader returns an iterator to access the data in the file within the ranges:\n",
-    "\n",
-    "reader = ChunkReader(filename, fastccdreaderh5.readData, nImages, chunkSize, path = h5path, pixels_x = sensorSize[0],\n",
-    "                     pixels_y = sensorSize[1],)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:54:41.899511Z",
-     "start_time": "2018-12-06T10:54:41.864816Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "# Calculator:\n",
-    "\n",
-    "# noiseCal is a noise map calculator, which internally also produces a per-pixel mean map, i.e. an offset map: \n",
-    "    \n",
-    "noiseCal = xcal.NoiseCalculator(sensorSize, memoryCells, cores=cpuCores, blockSize=blockSize, runParallel=run_parallel)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### First Iteration\n",
-    "\n",
-    "Characterization of dark images with purpose to create dark maps (offset, noise and bad pixel maps) is an iterative process. Firstly, initial offset and noise maps are produced from raw dark data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T10:55:21.238009Z",
-     "start_time": "2018-12-06T10:54:54.586435Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "for data in reader.readChunks():\n",
-    "    data = np.bitwise_and(data.astype(np.uint16), 0b0011111111111111).astype(np.float32)\n",
-    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
-    "    data = data[:,:,dx != 0]\n",
-    "    noiseCal.fill(data) # Filling calculators with data\n",
-    "          \n",
-    "offsetMap = noiseCal.getOffset() # Producing offset map\n",
-    "noiseMap = noiseCal.get() # Producing noise map\n",
-    "noiseCal.reset() # Resetting noise calculator\n",
-    "print(\"Initial maps are created.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Offset and Noise Maps prior to Common Mode Correction\n",
-    "\n",
-    "In the following, the histogram of the FastCCD offset, FastCCD offset map, as well as the initial uncorrected noise map are plotted:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#************** OFFSET MAP HISTOGRAM ***********#\n",
-    "ho,co = np.histogram(offsetMap.flatten(), bins=700) # ho = offset histogram; co = offset bin centers\n",
-    "do = {'x': co[:-1],\n",
-    "     'y': ho,\n",
-    "     'y_err': np.sqrt(ho[:]),\n",
-    "     'drawstyle': 'bars',\n",
-    "     'color': 'cornflowerblue',\n",
-    "     'label': 'Raw Signal (ADU)'\n",
-    "     }\n",
-    "fig = xana.simplePlot(do, figsize='1col', aspect=1, x_label = 'Raw Signal (ADU)', y_label=\"Counts\", \n",
-    "                      x_range = (3400,4000), title = 'Offset Histogram')\n",
-    "#fig.savefig('Offset_Hist.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
-    "\n",
-    "t0 = PrettyTable()\n",
-    "t0.title = \"Raw Signal\"\n",
-    "t0.field_names = [\"Mean\",\"Median\", \"Standard Deviation\"]\n",
-    "t0.add_row([\"{:0.3f} (ADU)\".format(np.mean(data)), \"{:0.3f} (ADU)\".format(np.median(data)), \"{:0.3f} (ADU)\".format(np.std(data))])\n",
-    "print(t0,'\\n')\n",
-    "\n",
-    "#************** OffsetMAP *******************#\n",
-    "fig = xana.heatmapPlot(offsetMap[:,:,0], x_label='Column Number', y_label='Row Number',  aspect=1,\n",
-    "                       x_range=(0,y), y_range=(0,x), vmin=3000, vmax=4300, lut_label='Offset (ADU)', \n",
-    "                       panel_x_label='Columns Stat (ADU)', panel_y_label='Rows Stat (ADU)', \n",
-    "                       panel_top_low_lim = 3000, panel_top_high_lim = 4500, panel_side_low_lim = 3000, \n",
-    "                       panel_side_high_lim = 5000, title = 'OffsetMap')\n",
-    "#fig.savefig('RawOffsetMap.pdf', format='pdf', dpi=400, bbox_inches='tight')\n",
-    "\n",
-    "#************** Raw NoiseMAP *******************#\n",
-    "fig = xana.heatmapPlot(noiseMap[:,:,0], x_label='Column Number', y_label='Row Number', aspect=1,\n",
-    "                       lut_label='Uncorrected Noise (ADU)', x_range=(0,y),\n",
-    "                       y_range=(0,x), vmax=2*np.mean(noiseMap), panel_x_label='Columns Stat (ADU)', \n",
-    "                       panel_y_label='Rows Stat (ADU)', panel_top_low_lim = 0, panel_top_high_lim = 20, \n",
-    "                       panel_side_low_lim = 0, panel_side_high_lim = 50, title = 'Uncorrected NoiseMap')\n",
-    "#fig.savefig('RawNoiseMap.pdf', format='pdf', dpi=400, bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Offset Correction:\n",
-    "\n",
-    "offsetCorrection = xcal.OffsetCorrection(sensorSize, offsetMap, nCells = memoryCells, cores=cpuCores, gains=None,\n",
-    "                                         runParallel=run_parallel, blockSize=blockSize)\n",
-    "\n",
-    "offsetCorrection.debug()\n",
-    "\n",
-    "# Common Mode Correction:\n",
-    "# This is the new method subtracting the median of all pixels that are read out at the same time along a row:\n",
-    "cmCorrection = xcal.CommonModeCorrection([data.shape[0], data.shape[1]], [data.shape[0]//2, data.shape[1]], \n",
-    "                                         commonModeAxis, parallel=False, dType=np.float32, stride=10,\n",
-    "                                         noiseMap=noiseMap.astype(np.float32), minFrac=0)\n",
-    "\n",
-    "cmCorrection.debug()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Histogram Calculators:\n",
-    "\n",
-    "# For offset corrected data:\n",
-    "histCalCorrected = xcal.HistogramCalculator(sensorSize, bins=600, range=[-200, 200], memoryCells=memoryCells, \n",
-    "                                            cores=cpuCores, gains=None, blockSize=blockSize)\n",
-    "# For common mode corrected data:\n",
-    "histCalCMCorrected = xcal.HistogramCalculator(sensorSize, bins=600, range=[-200, 200], memoryCells=memoryCells, \n",
-    "                                              cores=cpuCores, gains=None, blockSize=blockSize)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Second Iteration\n",
-    "\n",
-    "During the second iteration, the data are offset corrected and then common mode corrected to produced a common mode corrected noise map. The common mode correction is calculated by subtracting out the median of all pixels that are read out at the same time along a row."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for data in reader.readChunks():\n",
-    "    \n",
-    "    data = data.astype(np.float32)\n",
-    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
-    "    data = data[:,:,dx != 0] \n",
-    "    data = offsetCorrection.correct(data) # Offset correction\n",
-    "    offset_corr_data = copy.copy(data) # I am copying this so that I can have access to it in the table below \n",
-    "    histCalCorrected.fill(data)\n",
-    "    cellTable=np.zeros(data.shape[2], np.int32) # Common mode correction\n",
-    "    data = cmCorrection.correct(data.astype(np.float32), cellTable=cellTable) # Common mode correction\n",
-    "    histCalCMCorrected.fill(data)\n",
-    "    noiseCal.fill(data)  # Filling noise calculator with common mode (CM) corrected data\n",
-    "    \n",
-    "noiseMapCM = noiseCal.get() # Produces CM corrected noise map\n",
-    "ho, eo, co , so = histCalCorrected.get()\n",
-    "hCM, eCM, cCM ,sCM = histCalCMCorrected.get()\n",
-    "print(\"Offset and common mode corrections are applied.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# I am copying these so that I can replot them later after the calculators are reset:\n",
-    "\n",
-    "ho_second_trial = copy.copy(ho)\n",
-    "co_second_trial = copy.copy(co)\n",
-    "hCM_second_trial = copy.copy(hCM)\n",
-    "cCM_second_trial = copy.copy(cCM)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Signal after Offset and Common Mode Corrections\n",
-    "\n",
-    "Here, the offset corrected signal is compared to the common-mode corrected signal (in the form of binned histograms):  "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "do = [{'x': co,\n",
-    "     'y': ho,\n",
-    "     'y_err': np.sqrt(ho[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'cornflowerblue',\n",
-    "     'label': 'Offset Corrected Signal'\n",
-    "     },\n",
-    "     {'x': cCM,\n",
-    "     'y': hCM,\n",
-    "     'y_err': np.sqrt(hCM[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'red',\n",
-    "     'label': 'Common Mode Corrected Signal'\n",
-    "     }]\n",
-    "      \n",
-    "fig = xana.simplePlot(do, figsize='2col', aspect=1, x_label = 'Corrected Signal (ADU)', y_label=\"Counts\", \n",
-    "                      x_range = (-20,20), legend='top-right-frame-1col', title = 'Corrected Signal - 2nd Iteration')\n",
-    "#fig.savefig('Corrected_Signal_Hist_1.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
-    "\n",
-    "t0 = PrettyTable()\n",
-    "t0.title = \"Comparison of the First Round of Corrections - Bad Pixels Included\"\n",
-    "t0.field_names = [\"After Offset Correction\",\"After Common Mode Correction\"]\n",
-    "t0.add_row([\"Mean: {:0.3f} (ADU)\".format(np.mean(offset_corr_data)), \"Mean: {:0.3f} (ADU)\".format(np.mean(data))])\n",
-    "t0.add_row([\"Median: {:0.3f} (ADU)\".format(np.median(offset_corr_data)), \"Median: {:0.3f} (ADU)\".format(np.median(data))])\n",
-    "t0.add_row([\"Standard Deviation: {:0.3f} (ADU)\".format(np.std(offset_corr_data)), \"Standard Deviation: {:0.3f} (ADU)\".format(np.std(data))])\n",
-    "print(t0,'\\n')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Noise Map after Common Mode Correction\n",
-    "\n",
-    "In the following, the effect of common mode correction on the noise is shown. Finally common mode corrected noise map (noiseMapCM) is displayed and compared to the initial uncorrected noise map:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "#*****NOISE MAP HISTOGRAM FROM THE COMMON MODE CORRECTED DATA*******#\n",
-    "hn,cn = np.histogram(noiseMap.flatten(), bins=200, range=(2,40)) # hn: histogram of noise, cn: bin centers for noise\n",
-    "hn_CM,cn_CM = np.histogram(noiseMapCM.flatten(), bins=200, range=(2,40))\n",
-    "\n",
-    "dn = [{'x': cn[:-1],\n",
-    "     'y': hn,\n",
-    "     #'y_err': np.sqrt(hn[:]),\n",
-    "     'drawstyle': 'steps-mid',#'bars',\n",
-    "     'color': 'blue',#'cornflowerblue',\n",
-    "     'label': 'Uncorrected Noise'\n",
-    "     },\n",
-    "    {'x': cn_CM[:-1],\n",
-    "     'y': hn_CM,\n",
-    "     #'y_err': np.sqrt(hn_CM[:]),\n",
-    "     'drawstyle': 'steps-mid',#'bars',\n",
-    "     'color': 'crimson',#'red',#'cornflowerblue',\n",
-    "     #'ecolor': 'crimson',\n",
-    "     'label': 'Common Mode Corrected Noise'\n",
-    "     }]\n",
-    "fig = xana.simplePlot(dn, figsize='2col', aspect=1, x_label = 'Noise (ADU)', y_label=\"Counts\", \n",
-    "                      x_range=(0,40), y_range=(0,1e6), y_log=True, legend='top-center-frame-1col',\n",
-    "                      title = 'Noise Comparison')\n",
-    "\n",
-    "#fig.savefig('Noise_CM_1_Hist.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
-    "\n",
-    "fig = xana.heatmapPlot(noiseMapCM[:,:,0], aspect=1, x_label='Column Number', y_label='Row Number',\n",
-    "                       lut_label='Common Mode Corrected Noise (ADU)', x_range=(0,y), y_range=(0,x), \n",
-    "                       vmax=2*np.mean(noiseMapCM), panel_top_low_lim = 0, panel_top_high_lim = 20, panel_side_low_lim = 0,\n",
-    "                       panel_side_high_lim = 50, title = 'Common Mode Corrected Noise', \n",
-    "                       panel_x_label='Columns Stat (ADU)', panel_y_label='Rows Stat (ADU)')\n",
-    "\n",
-    "#fig.savefig('NoiseMapCM.pdf', format='pdf', dpi=400, bbox_inches='tight')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Resetting the calculators so we can do a third iteration later:\n",
-    "\n",
-    "noiseCal.reset()\n",
-    "histCalCorrected.reset()\n",
-    "histCalCMCorrected.reset()\n",
-    "cmCorrection.reset()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Initial BadPixelMap\n",
-    "This is generated based on the offset and CM corrected noise maps:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bad_pixels = np.zeros(offsetMap.shape, np.uint32)\n",
-    "mnoffset = np.nanmedian(offsetMap)\n",
-    "stdoffset = np.nanstd(offsetMap)\n",
-    "bad_pixels[(offsetMap < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
-    "           (offsetMap > mnoffset+bad_pixel_offset_sigma*stdoffset)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
-    "\n",
-    "mnnoise = np.nanmedian(noiseMapCM)\n",
-    "stdnoise = np.nanstd(noiseMapCM)\n",
-    "bad_pixels[(noiseMapCM < mnnoise-bad_pixel_noise_sigma*stdnoise) | \n",
-    "           (noiseMapCM > mnnoise+bad_pixel_noise_sigma*stdnoise)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
-    "\n",
-    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),aspect=1, x_label='Column Number', y_label='Row Number', \n",
-    "                       lut_label='2^(Assigned Value to Bad Pixels)', x_range=(0,y), y_range=(0,x), \n",
-    "                       title = 'Bad Pixels Map Excluding Non-Sensitive Areas', panel_x_label= 'Columns Stat', \n",
-    "                       panel_y_label='Rows Stat')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Here, we are adding the pixels in the hole (center of the FastCCD) as well as 4 rows in the center of the detector, which we call overscan region:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def create_circular_mask(h, w, center=None, radius=None):\n",
-    "\n",
-    "    import numpy as np\n",
-    "    import math\n",
-    "    \n",
-    "    if center is None: # use the middle of the image\n",
-    "        center = [int(w/2), int(h/2)]\n",
-    "    if radius is None: # use the smallest distance between the center and image walls\n",
-    "        radius = min(center[0], center[1], w-center[0], h-center[1])\n",
-    "\n",
-    "    Y, X = np.ogrid[:h, :w]\n",
-    "    dist_from_center = np.sqrt((X - center[0])**2 + (Y-center[1])**2)\n",
-    "\n",
-    "    mask = dist_from_center < radius\n",
-    "    return mask"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mask = np.zeros(offsetMap.shape, np.uint32)\n",
-    "\n",
-    "\n",
-    "# Defining a circular mask + a rectangular mask (overscan) for the hole in the middle of the CCD:\n",
-    "h, w = (x,y)\n",
-    "hole_mask_bool = create_circular_mask(h-4, w, radius=61.5, center=(w//2,(h-4)//2))\n",
-    "hole_mask = np.zeros(hole_mask_bool.shape, np.uint32)\n",
-    "hole_mask[hole_mask_bool] = BadPixels.NON_SENSITIVE.value\n",
-    "\n",
-    "overscan_mask = np.full((4, w), BadPixels.OVERSCAN.value) \n",
-    "\n",
-    "mask[:,:,0] = np.insert(hole_mask, (h-4)//2, overscan_mask, 0)  \n",
-    "\n",
-    "# Assigning this masked area as bad pixels:\n",
-    "bad_pixels = np.bitwise_or(bad_pixels, mask)\n",
-    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),aspect=1, x_label='Column Number', y_label='Row Number', \n",
-    "                       lut_label='2^(Assigned Value to Bad Pixels)', x_range=(0,y), y_range=(0,x), panel_top_low_lim = 0, \n",
-    "                       panel_top_high_lim = 20, panel_side_low_lim = 0, panel_side_high_lim = 20, \n",
-    "                       title = 'Bad Pixels Map Including Non-Sensitive Areas', panel_x_label='Columns Stat', \n",
-    "                       panel_y_label='Rows Stat', vmax=20)\n",
-    "\n",
-    "#fig.savefig('BadPixelMap_1.svg', format='svg', dpi=1200, bbox_inches='tight') "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Third Iteration\n",
-    "\n",
-    "During the third iteration, the bad pixel map is applied to the data. Bad pixels are masked. Offset and common mode corrections are applied once again to the data, which now have bad pixdels excluded, to produce a common mode corrected noise map:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# bad_pixels is an array of (1934, 960, 1) filled with zeros except at indices where we have the actual bad pixels, whose\n",
-    "# values are set to be: 2 (2^1: BadPixels.OFFSET_OUT_OF_THRESHOLD.value), or\n",
-    "# 262144 (2^18: BadPixels.OVERSCAN.value), or 524288 (2^19: BadPixels.NON_SENSITIVE.value). These indices can be found\n",
-    "# using np.argwhere(bad_pixels != 0)\n",
-    "\n",
-    "event_threshold = sigmaNoise*np.median(noiseMapCM) # for exclusion of possible cosmic ray events\n",
-    "noiseCal.setBadPixelMask(bad_pixels != 0)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for data in reader.readChunks():\n",
-    "    data = data.astype(np.float32)\n",
-    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
-    "    data = data[:,:,dx != 0]\n",
-    "    data_copy = offsetCorrection.correct(copy.copy(data))\n",
-    "    cellTable=np.zeros(data_copy.shape[2], np.int32)\n",
-    "    data_copy = cmCorrection.correct(data_copy.astype(np.float32), cellTable=cellTable)\n",
-    "    data[data_copy > event_threshold] = np.nan # cosmic rays\n",
-    "    data = np.ma.MaskedArray(data, np.isnan(data), fill_value=0) # masking cosmics, the default fill_value is 1e+20 \n",
-    "    data = offsetCorrection.correct(data)\n",
-    "    offset_corr_data2 = copy.copy(data) # I am copying this so that I can have access to it in the table below\n",
-    "    histCalCorrected.fill(data)\n",
-    "    cellTable=np.zeros(data.shape[2], np.int32)\n",
-    "    data = cmCorrection.correct(data.astype(np.float32), cellTable=cellTable)\n",
-    "    histCalCMCorrected.fill(data)\n",
-    "    noiseCal.fill(data) \n",
-    "\n",
-    "noiseMapCM_2nd = noiseCal.get().filled(0) # the masked pixels are filled with zero\n",
-    "ho2, eo2, co2, so2 = histCalCorrected.get()\n",
-    "hCM2, eCM2, cCM2 ,sCM2 = histCalCMCorrected.get()\n",
-    "print(\"Final iteration is Performed.\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Plots of the Final Results\n",
-    "\n",
-    "The following plot and table compare the offset and common mode corrected signal with and without the bad pixels:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "do_Final = [{'x': co_second_trial,\n",
-    "     'y': ho_second_trial,\n",
-    "     'y_err': np.sqrt(ho_second_trial[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'blue',#'cornflowerblue',\n",
-    "     'errorstyle': 'bars',\n",
-    "     'label': 'Offset Corrected Signal, Bad Pixels Included - 2nd Trial'\n",
-    "     },\n",
-    "    {'x': cCM_second_trial,\n",
-    "     'y': hCM_second_trial,\n",
-    "     'y_err': np.sqrt(hCM_second_trial[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'red',\n",
-    "     'errorstyle': 'bars',\n",
-    "     'ecolor': 'crimson',\n",
-    "     'label': 'Common Mode Corrected Signal, Bad Pixels Included - 2nd Trial' \n",
-    "     },\n",
-    "    {'x': co2,\n",
-    "     'y': ho2,\n",
-    "     'y_err': np.sqrt(ho2[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'black', #'cornflowerblue',\n",
-    "     'errorstyle': 'bars',\n",
-    "     'label': 'Offset Corrected Signal, Bad Pixels Excluded - 3rd Trial'\n",
-    "     },\n",
-    "    {'x': cCM2,\n",
-    "     'y': hCM2,\n",
-    "     'y_err': np.sqrt(hCM2[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'orange', #'cornflowerblue',\n",
-    "     'errorstyle': 'bars',\n",
-    "     'label': 'Common Mode Corrected Signal, Bad Pixels Excluded - 3rd Trial'\n",
-    "     }]\n",
-    "\n",
-    "fig = xana.simplePlot(do_Final, figsize='2col', aspect=1, x_label = 'Corrected Signal (ADU)', \n",
-    "                      y_label=\"Counts (Logarithmic Scale)\", y_log=True, x_range=(-40,40), legend='bottom-left-frame-1col',\n",
-    "                      title = 'Comparison of Corrected Signal')\n",
-    "#fig.savefig('Corrected_Signal_Hist_2.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
-    "\n",
-    "# offset_corr_data2 and data most likely have some nan's => I am going to use nanmean, nanmedian and nanstd functions:\n",
-    "t0 = PrettyTable()\n",
-    "t0.title = \"Comparison of the Second Round of Corrections - Bad Pixels Excluded\"\n",
-    "t0.field_names = [\"After Offset Correction\",\"After Common Mode Correction\"]\n",
-    "t0.add_row([\"Mean: {:0.3f} (ADU)\".format(np.nanmean(offset_corr_data2)), \"Mean: {:0.3f} (ADU)\".format(np.nanmean(data))])\n",
-    "t0.add_row([\"Median: {:0.3f} (ADU)\".format(np.nanmedian(offset_corr_data2)), \"Median: {:0.3f} (ADU)\".format(np.nanmedian(data))])\n",
-    "t0.add_row([\"Standard Deviation: {:0.3f} (ADU)\".format(np.nanstd(offset_corr_data2)), \"Standard Deviation: {:0.3f} (ADU)\".format(np.nanstd(data))])\n",
-    "print(t0,'\\n')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Final NoiseMap\n",
-    "\n",
-    "The effect of exclusion of bad pixels on common mode corrected noise is shown below. Finally common mode corrected noise map with bad pixels excluded (noiseMapCM_2nd) is displayed:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "#*****NOISE MAP HISTOGRAM FROM THE COMMON MODE CORRECTED DATA*******#\n",
-    "hn_CM2,cn_CM2 = np.histogram(noiseMapCM_2nd.flatten(), bins=200, range=(2,40))\n",
-    "\n",
-    "dn2 = [{'x': cn[:-1],\n",
-    "     'y': hn,\n",
-    "     #'y_err': np.sqrt(hn[:]),\n",
-    "     'drawstyle': 'steps-mid',#'bars',\n",
-    "     'color': 'blue', #'cornflowerblue',\n",
-    "     'label': 'Uncorrected Noise'\n",
-    "     },\n",
-    "    {'x': cn_CM[:-1],\n",
-    "     'y': hn_CM,\n",
-    "     #'y_err': np.sqrt(hn_CM[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'red',\n",
-    "     #'ecolor': 'crimson',\n",
-    "     'label': 'Common Mode Corrected Noise prior to Bad Pixels Exclusion'\n",
-    "     },\n",
-    "    {'x': cn_CM2[:-1],\n",
-    "     'y': hn_CM2,\n",
-    "     #'y_err': np.sqrt(hn_CM2[:]),\n",
-    "     'drawstyle': 'steps-mid',\n",
-    "     'color': 'black', #'cornflowerblue',\n",
-    "     'label': 'Common Mode Corrected Noise after Bad Pixels Exclusion'\n",
-    "     }]\n",
-    "\n",
-    "fig = xana.simplePlot(dn2, figsize='2col', aspect = 1, x_label = 'Noise (ADU)', y_label=\"Counts\", y_log=True, \n",
-    "                      x_range=(0,40), y_range=(0,1e6), legend='top-right-frame-1col', title = 'Final Noise Comparison')\n",
-    "\n",
-    "#fig.savefig('Noise_Hist_2.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
-    "\n",
-    "fig = xana.heatmapPlot(np.log2(noiseMapCM_2nd[:,:,0]), aspect=1, x_label='Column Number', y_label='Row Number',\n",
-    "                       lut_label='Noise (ADU)', x_range=(0,y), y_range=(0,x), vmax=2*np.mean(noiseMapCM_2nd), \n",
-    "                       title = 'Final Common Mode Corrected Noise (Bad Pixels Excluded)', \n",
-    "                       panel_x_label='Columns Stat (ADU)', panel_y_label='Rows Stat (ADU)')\n",
-    "#fig.savefig('NoiseMapCM_2nd.pdf', format='pdf', dpi=400, bbox_inches='tight') "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Final Bad Pixel Map\n",
-    "\n",
-    "Lastly, the final bad pixel map is generated based on the OffsetMap and the noiseMapCM_2nd (common mode corrected noise after exclusion of the initial bad pixels):"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "bad_pixels = np.zeros(offsetMap.shape, np.uint32)\n",
-    "mnoffset = np.nanmedian(offsetMap)\n",
-    "stdoffset = np.nanstd(offsetMap)\n",
-    "bad_pixels[(offsetMap < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
-    "           (offsetMap > mnoffset+bad_pixel_offset_sigma*stdoffset)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
-    "\n",
-    "mnnoise = np.nanmedian(noiseMapCM_2nd)\n",
-    "stdnoise = np.nanstd(noiseMapCM_2nd)\n",
-    "bad_pixels[(noiseMapCM_2nd < mnnoise-bad_pixel_noise_sigma*stdnoise) | \n",
-    "           (noiseMapCM_2nd > mnnoise+bad_pixel_noise_sigma*stdnoise)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
-    "\n",
-    "bad_pixels = np.bitwise_or(bad_pixels, mask)\n",
-    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),aspect=1, x_label='Column Number', y_label='Row Number', \n",
-    "                       lut_label='2^(Assigned Value to Bad Pixels)', x_range=(0,y), y_range=(0,x), panel_top_low_lim = 0, \n",
-    "                       panel_top_high_lim = 20, panel_side_low_lim = 0, panel_side_high_lim = 20, \n",
-    "                       title = 'Final Bad Pixels Map', panel_x_label='Columns Stat', \n",
-    "                       panel_y_label='Rows Stat', vmax=20)\n",
-    "#fig.savefig('BadPixelMap_2.svg', format='svg', dpi=1200, bbox_inches='tight') "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "display(Markdown('### Statistics on the Bad Pixels'))\n",
-    "num_bad_pixels = np.count_nonzero(bad_pixels)\n",
-    "num_all_pixels = x*y\n",
-    "percentage_bad_pixels = num_bad_pixels*100/num_all_pixels\n",
-    "print(\"Number of bad pixels: {:0.0f}, i.e. {:0.2f}% of all pixels\".format(num_bad_pixels, percentage_bad_pixels))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Electronic Noise\n",
-    "\n",
-    "According to Table 6.1 (page 80) of Ivana Klačková's master's thesis: \"Conversion gain for the FastCCD is: lower hemisphere = 6.2e-/ADU and upper hemisphere = 6.1e-/ADU.\"\n",
-    "\n",
-    "The following Tables present the noise along lower hemisphere, upper hemisphere, and the entire FastCCD detector at different stages. Here, the values in the first table (in ADU and e-) are the mean of noise per pixel, where noise is considered to be the initial uncorrected noise, CM corrected noise after second trial (including bad pixels) and CM corrected noise after third trial (excluding bad pixels). \n",
-    "\n",
-    "The values of the second table (in electrons) are the standard deviation of noise per pixel."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# noiseMap refers to the initial uncorrected noise, noiseMapCM refers to common mode corrected noise with inclusion of \n",
-    "# bad pixels, and noiseMapCM_2nd refers to common mode corrected noise without inclusion of bad pixels:\n",
-    "\n",
-    "ADU_to_electron = (ADU_to_electron_upper + ADU_to_electron_lower)/2 # Average of ADU_to_electron for the entire detector \n",
-    "\n",
-    "print(\"Abbreviations:\")\n",
-    "print(\" - ED = Entire Detector; LH: Lower Hemisphere; UH: Upper Hemisphere\")\n",
-    "print(\" - CM Noise: Common Mode Corrected Noise\")\n",
-    "print(\" - BP: Bad Pixels\\n\")\n",
-    "      \n",
-    "t0 = PrettyTable()\n",
-    "t0.title = \"Averages of Noise per Pixel\"\n",
-    "t0.field_names = [\"Uncorrected Noise\",\"CM Noise, BP Incl.\", \"CM Noise, BP Excl.\"]\n",
-    "t0.add_row([\"ED: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMap),np.mean(noiseMap)*ADU_to_electron), \"ED: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM), np.mean(noiseMapCM)*ADU_to_electron), \"ED: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM_2nd), np.mean(noiseMapCM_2nd)*ADU_to_electron)])\n",
-    "t0.add_row([\"LH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMap[:x//2,:]), np.mean(noiseMap[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM[:x//2,:]), np.mean(noiseMapCM[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM_2nd[:x//2,:]), np.mean(noiseMapCM_2nd[:x//2,:])*ADU_to_electron_lower)])\n",
-    "t0.add_row([\"UH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMap[x//2:,:]), np.mean(noiseMap[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM[x//2:,:]), np.mean(noiseMapCM[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM_2nd[x//2:,:]), np.mean(noiseMapCM_2nd[x//2:,:])*ADU_to_electron_upper)])\n",
-    "print(t0,'\\n')\n",
-    "\n",
-    "t1 = PrettyTable()\n",
-    "t1.title = \"Standard Deviations of Noise per Pixel\"\n",
-    "t1.field_names = [\"Uncorrected Noise\",\"CM Noise, BP Incl.\", \"CM Noise, BP Excl.\"]\n",
-    "t1.add_row([\"ED: {:0.2f} e-\".format(np.std(noiseMap)*ADU_to_electron), \"ED: {:0.2f} e-\".format(np.std(noiseMapCM)*ADU_to_electron), \"ED: {:0.2f} e-\".format(np.std(noiseMapCM_2nd)*ADU_to_electron)])\n",
-    "t1.add_row([\"LH: {:0.2f} e-\".format(np.std(noiseMap[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} e-\".format(np.std(noiseMapCM[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} e-\".format(np.std(noiseMapCM_2nd[:x//2,:])*ADU_to_electron_lower)])\n",
-    "t1.add_row([\"UH: {:0.2f} e-\".format(np.std(noiseMap[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} e-\".format(np.std(noiseMapCM[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} e-\".format(np.std(noiseMapCM_2nd[x//2:,:])*ADU_to_electron_upper)])\n",
-    "print(t1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Calibration Constants"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "dictionary = {} \n",
-    "dictionary['Offset'] = offsetMap.data\n",
-    "dictionary['Noise'] = noiseMapCM_2nd.data\n",
-    "dictionary['BadPixelsDark'] = bad_pixels.data\n",
-    "\n",
-    "for const in dictionary:\n",
-    "    metadata = ConstantMetaData()\n",
-    "    dconst = getattr(Constants.CCD(DetectorTypes.fastCCD), const)()\n",
-    "    dconst.data = dictionary[const]\n",
-    "    metadata.calibration_constant = dconst\n",
-    "    \n",
-    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                integration_time=integration_time,\n",
-    "                                gain_setting=det_gain,\n",
-    "                                temperature=fix_temperature,\n",
-    "                                pixels_x=1934,\n",
-    "                                pixels_y=960)\n",
-    "    \n",
-    "    for parm in condition.parameters:\n",
-    "        if parm.name == \"Sensor Temperature\":\n",
-    "            parm.lower_deviation = temp_limits\n",
-    "            parm.upper_deviation = temp_limits\n",
-    "\n",
-    "    device = Detectors.fastCCD1\n",
-    "    metadata.detector_condition = condition\n",
-    "    \n",
-    "    # Specifying the a version for this constant:\n",
-    "    if creation_time is None:\n",
-    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "    else:\n",
-    "        metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
-    "    \n",
-    "    if db_output:\n",
-    "        metadata.calibration_constant_version.raw_data_location = file_loc\n",
-    "        metadata.send(cal_db_interface, timeout=cal_db_timeout)    \n",
-    "\n",
-    "print(\"Calibration constants (offsetMap, noiseMapCM_2nd and bad_pixels) are sent to the calibration database.\")\n",
-    "print(\"Creation time is: {}\".format(creation_time))"
-   ]
-  },
-  {
-   "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.7"
-  },
-  "latex_envs": {
-   "LaTeX_envs_menu_present": true,
-   "autocomplete": true,
-   "bibliofile": "biblio.bib",
-   "cite_by": "apalike",
-   "current_citInitial": 1,
-   "eqLabelWithNumbers": true,
-   "eqNumInitial": 1,
-   "hotkeys": {
-    "equation": "Ctrl-E",
-    "itemize": "Ctrl-I"
-   },
-   "labels_anchors": false,
-   "latex_user_defs": false,
-   "report_style_numbering": false,
-   "user_envs_cfg": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb b/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb
deleted file mode 100644
index c80d17a47..000000000
--- a/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb
+++ /dev/null
@@ -1,1279 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# FastCCD Data Correction ##\n",
-    "\n",
-    "Authors: I. Klačková, S. Hauf, Version 1.0\n",
-    "\n",
-    "The following notebook provides correction of images acquired with the FastCCD."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:23.218849Z",
-     "start_time": "2018-12-06T15:54:23.166497Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "in_folder = \"/gpfs/exfel/exp/SCS/201802/p002170/raw/\" # input folder, required\n",
-    "out_folder = '/gpfs/exfel/data/scratch/xcal/test/' # output folder, required\n",
-    "path_template = 'RAW-R{:04d}-{}-S{{:05d}}.h5' #  path template in hdf5 file\n",
-    "path_inset = 'DA05'\n",
-    "run = 277 # run number\n",
-    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image' # path in HDF5 file\n",
-    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value' # temperature path in HDF5 file\n",
-    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # path to control data\n",
-    "cluster_profile = \"noDB\" #ipcluster profile to use\n",
-    "cpuCores = 16 #Specifies the number of running cpu cores\n",
-    "operation_mode = \"FF\" # FS stands for frame-store and FF for full-frame opeartion\n",
-    "split_evt_primary_threshold = 7. # primary threshold for split event classification in terms of n sigma noise\n",
-    "split_evt_secondary_threshold = 4. # secondary threshold for split event classification in terms of n sigma noise\n",
-    "split_evt_mip_threshold = 1000. # MIP threshold for event classification\n",
-    "cal_db_interface = \"tcp://max-exfl016:8015#8025\" # calibration DB interface to use\n",
-    "cal_db_timeout = 300000000 # timeout on caldb requests\n",
-    "sequences = [-1] # sequences to correct, set to -1 for all, range allowed\n",
-    "chunk_size_idim = 1 # H5 chunking size of output data\n",
-    "overwrite = True # overwrite existing files\n",
-    "do_pattern_classification = True # classify split events\n",
-    "sequences_per_node = 1 # sequences to correct per node\n",
-    "limit_images = 0 # limit images per file \n",
-    "correct_offset_drift = False  # correct for offset drifts\n",
-    "use_dir_creation_date = True # use dir creation data for calDB queries\n",
-    "time_offset_days = 0 # offset in days for calibration parameters\n",
-    "photon_energy_gain_map = 2. # energy in keV\n",
-    "fix_temperature = 0. # fix temperature to this value, set to 0 to use slow control value\n",
-    "flipped_between = [\"2019-02-01\", \"2019-04-02\"] # detector was flipped during this timespan\n",
-    "temp_limits = 5 # limits within which temperature is considered the same\n",
-    "\n",
-    "def balance_sequences(in_folder, run, sequences, sequences_per_node):\n",
-    "    import glob\n",
-    "    import re\n",
-    "    import numpy as np\n",
-    "    if sequences[0] == -1:\n",
-    "        sequence_files = glob.glob(\"{}/r{:04d}/*{}-S*.h5\".format(in_folder, run, path_inset))\n",
-    "        seq_nums = set()\n",
-    "        for sf in sequence_files:\n",
-    "            seqnum = re.findall(r\".*-S([0-9]*).h5\", sf)[0]\n",
-    "            seq_nums.add(int(seqnum))\n",
-    "        seq_nums -= set(sequences)\n",
-    "        nsplits = len(seq_nums)//sequences_per_node+1\n",
-    "        while nsplits > 8:\n",
-    "            sequences_per_node += 1\n",
-    "            nsplits = len(seq_nums)//sequences_per_node+1\n",
-    "            print(\"Changed to {} sequences per node to have a maximum of 8 concurrent jobs\".format(sequences_per_node))\n",
-    "        return [l.tolist() for l in np.array_split(list(seq_nums), nsplits)]\n",
-    "    else:\n",
-    "        return sequences"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:23.455376Z",
-     "start_time": "2018-12-06T15:54:23.413579Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import XFELDetAna.xfelprofiler as xprof\n",
-    "\n",
-    "profiler = xprof.Profiler()\n",
-    "profiler.disable()\n",
-    "from XFELDetAna.util import env\n",
-    "env.iprofile = cluster_profile\n",
-    "\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "\n",
-    "from XFELDetAna import xfelpycaltools as xcal\n",
-    "from XFELDetAna import xfelpyanatools as xana\n",
-    "from XFELDetAna.plotting.util import prettyPlotting\n",
-    "prettyPlotting=True\n",
-    "from XFELDetAna.xfelreaders import ChunkReader\n",
-    "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
-    "\n",
-    "import numpy as np\n",
-    "import h5py\n",
-    "import matplotlib.pyplot as plt\n",
-    "from iminuit import Minuit\n",
-    "\n",
-    "import time\n",
-    "import copy\n",
-    "import os\n",
-    "\n",
-    "from prettytable import PrettyTable\n",
-    "\n",
-    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
-    "from iCalibrationDB.detectors import DetectorTypes\n",
-    "from cal_tools.tools import get_dir_creation_date\n",
-    "\n",
-    "from datetime import timedelta\n",
-    "\n",
-    "%matplotlib inline\n",
-    "\n",
-    "if sequences[0] == -1:\n",
-    "    sequences = None\n",
-    "    \n",
-    "offset_correction_args = (0.2459991787617141, 243.21639920846485)\n",
-    "t_base = 247.82\n",
-    "\n",
-    "if \"#\" in cal_db_interface:\n",
-    "    prot, serv, ran = cal_db_interface.split(\":\")\n",
-    "    r1, r2 = ran.split(\"#\")\n",
-    "    cal_db_interface = \":\".join(\n",
-    "        [prot, serv, str(np.random.randint(int(r1), int(r2)))])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:23.679069Z",
-     "start_time": "2018-12-06T15:54:23.662821Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "if operation_mode == \"FS\":\n",
-    "    x = 960 # rows of the FastCCD to analyze in FS mode \n",
-    "    y = 960 # columns of the FastCCD to analyze in FS mode \n",
-    "    print('\\nYou are analyzing data in FS mode.')\n",
-    "else:\n",
-    "    x = 1934 # rows of the FastCCD to analyze in FF mode \n",
-    "    y = 960 # columns of the FastCCD to analyze in FF mode\n",
-    "    print('\\nYou are analyzing data in FF mode.')\n",
-    "    \n",
-    "ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
-    "out_folder  = \"{}/r{:04d}\".format(out_folder, run)\n",
-    "fp_name = path_template.format(run, path_inset)\n",
-    "fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
-    "\n",
-    "print(\"Reading data from: {}\\n\".format(fp_path))\n",
-    "print(\"Run is: {}\".format(run))\n",
-    "print(\"HDF5 path: {}\".format(h5path))\n",
-    "print(\"Data is output to: {}\".format(out_folder))\n",
-    "\n",
-    "import datetime\n",
-    "creation_time = None\n",
-    "if use_dir_creation_date:\n",
-    "    creation_time = get_dir_creation_date(in_folder, run) + timedelta(days=time_offset_days)\n",
-    "if creation_time:\n",
-    "    print(\"Using {} as creation time\".format(creation_time.isoformat()))\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:23.913269Z",
-     "start_time": "2018-12-06T15:54:23.868910Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "\n",
-    "sensorSize = [x, y]\n",
-    "chunkSize = 100 #Number of images to read per chunk\n",
-    "blockSize = [sensorSize[0]//2, sensorSize[1]//4] #Sensor area will be analysed according to blocksize\n",
-    "xcal.defaultBlockSize = blockSize\n",
-    "memoryCells = 1 #FastCCD has 1 memory cell\n",
-    "#Specifies total number of images to proceed\n",
-    "\n",
-    "commonModeBlockSize = blockSize\n",
-    "commonModeAxisR = 'row'#Axis along which common mode will be calculated\n",
-    "run_parallel = True\n",
-    "profile = False\n",
-    "\n",
-    "temperature_k = 291\n",
-    "filename = fp_path.format(sequences[0] if sequences else 0)\n",
-    "with h5py.File(filename, 'r') as f:\n",
-    "    bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
-    "    det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
-    "    integration_time = int(f['{}/acquisitionTime/value'.format(h5path_cntrl)][0])\n",
-    "    print(\"Bias voltage is {} V\".format(bias_voltage))\n",
-    "    print(\"Detector gain is set to x{}\".format(det_gain))\n",
-    "    print(\"Detector integration time is set to {}\".format(integration_time))\n",
-    "    temperature = np.mean(f[h5path_t])\n",
-    "    temperature_k = temperature + 273.15\n",
-    "    if fix_temperature != 0.:\n",
-    "        temperature_k = fix_temperature\n",
-    "        print(\"Using fixed temperature\")\n",
-    "    print(\"Mean temperature was {:0.2f} °C / {:0.2f} K at beginning of run\".format(temperature, temperature_k))\n",
-    "    \n",
-    "\n",
-    "if not os.path.exists(out_folder):\n",
-    "    os.makedirs(out_folder)\n",
-    "elif not overwrite:\n",
-    "    raise AttributeError(\"Output path exists! Exiting\")    \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:24.088948Z",
-     "start_time": "2018-12-06T15:54:24.059925Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "dirlist = sorted(os.listdir(ped_dir))\n",
-    "file_list = []\n",
-    "total_sequences = 0\n",
-    "fsequences = []\n",
-    "for entry in dirlist:\n",
-    "\n",
-    "    #only h5 file\n",
-    "    abs_entry = \"{}/{}\".format(ped_dir, entry)\n",
-    "    if os.path.isfile(abs_entry) and os.path.splitext(abs_entry)[1] == \".h5\":\n",
-    "        \n",
-    "        if sequences is None:\n",
-    "            for seq in range(len(dirlist)):\n",
-    "                \n",
-    "                if path_template.format(run, path_inset).format(seq) in abs_entry:\n",
-    "                    file_list.append(abs_entry)\n",
-    "                    total_sequences += 1\n",
-    "                    fsequences.append(seq)\n",
-    "        else:\n",
-    "            for seq in sequences:\n",
-    "                \n",
-    "                if path_template.format(run, path_inset).format(seq) in abs_entry:\n",
-    "                    file_list.append(os.path.abspath(abs_entry))\n",
-    "                    total_sequences += 1\n",
-    "                    fsequences.append(seq)\n",
-    "sequences = fsequences"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T18:43:39.776018Z",
-     "start_time": "2018-12-06T18:43:39.759185Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import copy\n",
-    "from IPython.display import HTML, display, Markdown, Latex\n",
-    "import tabulate\n",
-    "print(\"Processing a total of {} sequence files\".format(total_sequences))\n",
-    "table = []\n",
-    "\n",
-    "\n",
-    "for k, f in enumerate(file_list):\n",
-    "    table.append((k, f))\n",
-    "if len(table):  \n",
-    "    md = display(Latex(tabulate.tabulate(table, tablefmt='latex', headers=[\"#\", \"file\"])))      "
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As a first step, dark maps have to be loaded."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:28.254544Z",
-     "start_time": "2018-12-06T15:54:24.709521Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "offsetMap = None\n",
-    "badPixelMap = None\n",
-    "noiseMap = None\n",
-    "for i, g in enumerate([8, 2, 1]):\n",
-    "    ## offset\n",
-    "    metadata = ConstantMetaData()\n",
-    "    offset = Constants.CCD(DetectorTypes.fastCCD).Offset()\n",
-    "    metadata.calibration_constant = offset\n",
-    "\n",
-    "    # set the operating condition\n",
-    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                    integration_time=integration_time,\n",
-    "                                    gain_setting=g,\n",
-    "                                    temperature=temperature_k,\n",
-    "                                    pixels_x=1934,\n",
-    "                                    pixels_y=960)\n",
-    "\n",
-    "    for parm in condition.parameters:\n",
-    "        if parm.name == \"Sensor Temperature\":\n",
-    "            parm.lower_deviation = temp_limits\n",
-    "            parm.upper_deviation = temp_limits\n",
-    "\n",
-    "\n",
-    "    device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "    metadata.detector_condition = condition\n",
-    "\n",
-    "\n",
-    "\n",
-    "    # specify the version for this constant\n",
-    "    if creation_time is None:\n",
-    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "        metadata.retrieve(cal_db_interface)\n",
-    "    else:\n",
-    "        metadata.calibration_constant_version = Versions.Timespan(device=device,\n",
-    "                                                                  start=creation_time)\n",
-    "        metadata.retrieve(cal_db_interface, when=creation_time.isoformat(), timeout=3000000)\n",
-    "\n",
-    "\n",
-    "    if offsetMap is None:\n",
-    "        offsetMap = np.zeros(list(offset.data.shape)+[3], np.float32)\n",
-    "    offsetMap[...,i] = offset.data\n",
-    "\n",
-    "    offset_temperature = None\n",
-    "    for parm in condition.parameters:\n",
-    "\n",
-    "        if parm.name == \"Sensor Temperature\":\n",
-    "            offset_temperature = parm.value\n",
-    "\n",
-    "    print(\"Temperature of detector when dark images (gain {}) for offset calculation \".format(g) +\n",
-    "              \"were taken at: {:0.2f} K @ {}\".format(offset_temperature,\n",
-    "                                                     metadata.calibration_constant_version.begin_at))\n",
-    "\n",
-    "    ## noise\n",
-    "    metadata = ConstantMetaData()\n",
-    "    noise = Constants.CCD(DetectorTypes.fastCCD).Noise()\n",
-    "    metadata.calibration_constant = noise\n",
-    "\n",
-    "    # set the operating condition\n",
-    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                    integration_time=integration_time,\n",
-    "                                    gain_setting=g,\n",
-    "                                    temperature=temperature_k,\n",
-    "                                    pixels_x=1934,\n",
-    "                                    pixels_y=960)\n",
-    "\n",
-    "\n",
-    "    for parm in condition.parameters:\n",
-    "        if parm.name == \"Sensor Temperature\":\n",
-    "            parm.lower_deviation = temp_limits\n",
-    "            parm.upper_deviation = temp_limits\n",
-    "\n",
-    "\n",
-    "    device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "    metadata.detector_condition = condition\n",
-    "\n",
-    "    # specify the version for this constant\n",
-    "    if creation_time is None:\n",
-    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "        metadata.retrieve(cal_db_interface)\n",
-    "    else:\n",
-    "        metadata.calibration_constant_version = Versions.Timespan(device=device,\n",
-    "                                                                  start=creation_time)\n",
-    "        metadata.retrieve(cal_db_interface, when=creation_time.isoformat(), timeout=3000000)\n",
-    "\n",
-    "    if noiseMap is None:\n",
-    "        noiseMap = np.zeros(list(noise.data.shape)+[3], np.float32)\n",
-    "    noiseMap[...,i] = noise.data\n",
-    "\n",
-    "\n",
-    "    ## bad pixels \n",
-    "\n",
-    "    metadata = ConstantMetaData()\n",
-    "    bpix = Constants.CCD(DetectorTypes.fastCCD).BadPixelsDark()\n",
-    "    metadata.calibration_constant = bpix\n",
-    "\n",
-    "    # set the operating condition\n",
-    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
-    "                                    integration_time=integration_time,\n",
-    "                                    gain_setting=g,\n",
-    "                                    temperature=temperature_k,\n",
-    "                                    pixels_x=1934,\n",
-    "                                    pixels_y=960)\n",
-    "\n",
-    "    for parm in condition.parameters:\n",
-    "        if parm.name == \"Sensor Temperature\":\n",
-    "            parm.lower_deviation = temp_limits\n",
-    "            parm.upper_deviation = temp_limits\n",
-    "\n",
-    "\n",
-    "    device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "    metadata.detector_condition = condition\n",
-    "\n",
-    "    # specify the version for this constant\n",
-    "    if creation_time is None:\n",
-    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "        metadata.retrieve(cal_db_interface)\n",
-    "    else:\n",
-    "        metadata.calibration_constant_version = Versions.Timespan(device=device,\n",
-    "                                                                  start=creation_time)\n",
-    "        metadata.retrieve(cal_db_interface, when=creation_time.isoformat(), timeout=3000000)\n",
-    "\n",
-    "    if badPixelMap is None:\n",
-    "        badPixelMap = np.zeros(list(bpix.data.shape)+[3], np.uint32)\n",
-    "    badPixelMap[...,i] = bpix.data\n",
-    "        \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Loading cti and relative gain values"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:28.343869Z",
-     "start_time": "2018-12-06T15:54:28.271344Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "## relative gain\n",
-    "\n",
-    "metadata = ConstantMetaData()\n",
-    "relgain = Constants.CCD(DetectorTypes.fastCCD).RelativeGain()\n",
-    "metadata.calibration_constant = relgain\n",
-    "\n",
-    "# set the operating condition\n",
-    "condition = Conditions.Illuminated.CCD(bias_voltage=bias_voltage,\n",
-    "                                       integration_time=integration_time,\n",
-    "                                       gain_setting=0,\n",
-    "                                       temperature=temperature_k,\n",
-    "                                       pixels_x=1934,\n",
-    "                                       pixels_y=960, photon_energy=photon_energy_gain_map)\n",
-    "device = Detectors.fastCCD1\n",
-    "\n",
-    "\n",
-    "metadata.detector_condition = condition\n",
-    "\n",
-    "# specify the a version for this constant\n",
-    "metadata.calibration_constant_version = Versions.Now(device=device)\n",
-    "metadata.retrieve(cal_db_interface)\n",
-    "\n",
-    "relGain = relgain.data[::-1,...]\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "relGainCA = copy.copy(relGain)\n",
-    "relGainC = relGainCA[:relGainCA.shape[0]//2,...]\n",
-    "ctiA = np.ones(relGainCA.shape[:2])\n",
-    "cti = np.ones(relGainC.shape[:2])\n",
-    "i = 0\n",
-    "idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
-    "mn1 = np.nanmean(relGainC[i, ~idx, 0])\n",
-    "\n",
-    "for i in range(1, relGainC.shape[0]):\n",
-    "    idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
-    "    mn2 = np.nanmean(relGainC[i, ~idx, 0])\n",
-    "    cti[i,:] = mn2/mn1\n",
-    "ctiA[:relGainCA.shape[0]//2,...] = cti\n",
-    "\n",
-    "relGainC = relGainCA[relGainCA.shape[0]//2:,...]\n",
-    "\n",
-    "\n",
-    "cti = np.ones(relGainC.shape[:2])\n",
-    "i = -1\n",
-    "idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
-    "mn1 = np.nanmean(relGainC[i, ~idx, 0])\n",
-    "\n",
-    "for i in range(relGainC.shape[0]-1, 1, -1):\n",
-    "    idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
-    "    mn2 = np.nanmean(relGainC[i, ~idx, 0])\n",
-    "    cti[i,:] = mn2/mn1\n",
-    "\n",
-    "ctiA[relGainCA.shape[0]//2:,...] = cti\n",
-    "\n",
-    "relGainCA = copy.copy(relGain)\n",
-    "relGainC = relGainCA[:relGainCA.shape[0]//2,...]\n",
-    "for i in range(relGainC.shape[1]):\n",
-    "    idx = (relGainC[:,i, 0] < 0.95) | (relGainC[:,i,0] > 1.05)\n",
-    "    relGainC[idx,i,0] = np.nanmean(relGainC[~idx,i,0])\n",
-    "    relGainC[idx,i,1] = np.nanmean(relGainC[~idx,i,1])\n",
-    "    relGainC[idx,i,2] = np.nanmean(relGainC[~idx,i,2])\n",
-    "relGainCA[:relGainCA.shape[0]//2,...] = relGainC\n",
-    "relGainC = relGainCA[relGainCA.shape[0]//2:,...]\n",
-    "for i in range(relGainC.shape[1]):\n",
-    "    idx = (relGainC[:,i, 0] < 0.95) | (relGainC[:,i,0] > 1.05)\n",
-    "    relGainC[idx,i,0] = np.nanmean(relGainC[~idx,i,0])\n",
-    "    relGainC[idx,i,1] = np.nanmean(relGainC[~idx,i,1])\n",
-    "    relGainC[idx,i,2] = np.nanmean(relGainC[~idx,i,2])\n",
-    "relGainCA[relGainCA.shape[0]//2:,...] = relGainC\n",
-    "relGainC = relGainCA*ctiA[...,None]\n",
-    "\n",
-    "relGain = relGainC"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "import dateutil.parser\n",
-    "flipped_between = [dateutil.parser.parse(d) for d in flipped_between]\n",
-    "flip_rgain = creation_time >= flipped_between[0] and creation_time <= flipped_between[1]\n",
-    "flip_rgain &= (metadata.calibration_constant_version.begin_at.replace(tzinfo=None) >= flipped_between[0] \n",
-    "               and metadata.calibration_constant_version.begin_at.replace(tzinfo=None) <= flipped_between[1])\n",
-    "print(\"Accounting for flipped detector: {}\".format(flip_rgain))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T15:54:28.771629Z",
-     "start_time": "2018-12-06T15:54:28.346051Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "#************************Calculators************************#\n",
-    "\n",
-    "\n",
-    "cmCorrection = xcal.CommonModeCorrection([x, y], \n",
-    "                                         commonModeBlockSize, \n",
-    "                                         commonModeAxisR,\n",
-    "                                         nCells = memoryCells, \n",
-    "                                         noiseMap = noiseMap,\n",
-    "                                        runParallel=True,\n",
-    "                                        stats=True)\n",
-    "\n",
-    "patternClassifierLH = xcal.PatternClassifier([x//2, y], \n",
-    "                                              noiseMap[:x//2, :], \n",
-    "                                              split_evt_primary_threshold, \n",
-    "                                             split_evt_secondary_threshold,\n",
-    "                                             split_evt_mip_threshold,\n",
-    "                                              tagFirstSingles = 0, \n",
-    "                                              nCells=memoryCells, \n",
-    "                                              cores=cpuCores, \n",
-    "                                              allowElongated = False,\n",
-    "                                              blockSize=[x//2, y],\n",
-    "                                              runParallel=True)\n",
-    "\n",
-    "\n",
-    "\n",
-    "patternClassifierUH = xcal.PatternClassifier([x//2, y], \n",
-    "                                              noiseMap[x//2:, :], \n",
-    "                                              split_evt_primary_threshold, \n",
-    "                                              split_evt_secondary_threshold,\n",
-    "                                              split_evt_mip_threshold,\n",
-    "                                              tagFirstSingles = 0, \n",
-    "                                              nCells=memoryCells, \n",
-    "                                              cores=cpuCores, \n",
-    "                                              allowElongated = False,\n",
-    "                                              blockSize=[x//2, y],\n",
-    "                                              runParallel=True)\n",
-    "\n",
-    "                                   \n",
-    "\n",
-    "\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:08:51.886343Z",
-     "start_time": "2018-12-06T16:08:51.842837Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "#*****************Histogram Calculators******************#\n",
-    "\n",
-    "histCalOffsetCor = xcal.HistogramCalculator([x, y], \n",
-    "                                             bins=500, \n",
-    "                                             range=[-50, 1000],\n",
-    "                                             nCells=memoryCells, \n",
-    "                                             cores=cpuCores,\n",
-    "                                             blockSize=blockSize)\n",
-    "\n",
-    "histCalPcorr = xcal.HistogramCalculator([x, y], \n",
-    "                                         bins=500, \n",
-    "                                         range=[-50, 1000],\n",
-    "                                         nCells=memoryCells, \n",
-    "                                         cores=cpuCores,\n",
-    "                                         blockSize=blockSize)\n",
-    "\n",
-    "histCalPcorrS = xcal.HistogramCalculator([x, y], \n",
-    "                                         bins=500, \n",
-    "                                         range=[-50, 1000],\n",
-    "                                         nCells=memoryCells, \n",
-    "                                         cores=cpuCores,\n",
-    "                                         blockSize=blockSize)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Applying corrections"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:08:52.441784Z",
-     "start_time": "2018-12-06T16:08:52.437284Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "patternClassifierLH._imagesPerChunk = 500\n",
-    "patternClassifierUH._imagesPerChunk = 500\n",
-    "patternClassifierLH.debug()\n",
-    "patternClassifierUH.debug()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:08:53.042555Z",
-     "start_time": "2018-12-06T16:08:53.034522Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "histCalOffsetCor.debug()\n",
-    "histCalPcorr.debug()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:08:53.551111Z",
-     "start_time": "2018-12-06T16:08:53.531064Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "def copy_and_sanitize_non_cal_data(infile, outfile, h5base):\n",
-    "    \n",
-    "    if h5base.startswith(\"/\"):\n",
-    "        h5base = h5base[1:]\n",
-    "    dont_copy = ['pixels']\n",
-    "    dont_copy = [h5base+\"/{}\".format(do)\n",
-    "                for do in dont_copy]\n",
-    "\n",
-    "    def visitor(k, item):\n",
-    "        if k not in dont_copy:\n",
-    "            if isinstance(item, h5py.Group):\n",
-    "                outfile.create_group(k)\n",
-    "            elif isinstance(item, h5py.Dataset):\n",
-    "                group = str(k).split(\"/\")\n",
-    "                group = \"/\".join(group[:-1])\n",
-    "                infile.copy(k, outfile[group])\n",
-    "                \n",
-    "    infile.visititems(visitor)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:55.917179Z",
-     "start_time": "2018-12-06T16:09:01.603633Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "mean_im = None\n",
-    "single_im = None\n",
-    "mean_im_cc = None\n",
-    "single_im_cc = None\n",
-    "drift_lh = []\n",
-    "drift_uh = []\n",
-    "offsetMap = np.squeeze(offsetMap)\n",
-    "noiseMap = np.squeeze(noiseMap)\n",
-    "badPixelMap = np.squeeze(badPixelMap)\n",
-    "relGain = np.squeeze(relGain)\n",
-    "for k, f in enumerate(file_list):\n",
-    "    with h5py.File(f, 'r', driver='core') as infile:\n",
-    "        out_fileb = \"{}/{}\".format(out_folder, f.split(\"/\")[-1])\n",
-    "        out_file = out_fileb.replace(\"RAW\", \"CORR\")\n",
-    "        #out_filed = out_fileb.replace(\"RAW\", \"CORR-SC\")\n",
-    "\n",
-    "        data = None\n",
-    "        noise = None\n",
-    "        try:\n",
-    "            with h5py.File(out_file, \"w\") as ofile:\n",
-    "            \n",
-    "                copy_and_sanitize_non_cal_data(infile, ofile, h5path)\n",
-    "                data = infile[h5path+\"/pixels\"][()]\n",
-    "                nzidx = np.count_nonzero(data, axis=(1,2))\n",
-    "                data = data[nzidx != 0, ...]\n",
-    "                if limit_images > 0:\n",
-    "                    data = data[:limit_images,...]\n",
-    "                oshape = data.shape\n",
-    "                data = np.moveaxis(data, 0, 2)\n",
-    "                ddset = ofile.create_dataset(h5path+\"/pixels\",\n",
-    "                                             oshape,\n",
-    "                                             chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
-    "                                             dtype=np.float32)\n",
-    "                \n",
-    "                ddsetm = ofile.create_dataset(h5path+\"/mask\",\n",
-    "                                             oshape,\n",
-    "                                             chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
-    "                                             dtype=np.uint32, compression=\"gzip\")\n",
-    "                \n",
-    "                ddsetg = ofile.create_dataset(h5path+\"/gain\",\n",
-    "                                             oshape,\n",
-    "                                             chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
-    "                                             dtype=np.uint8, compression=\"gzip\")\n",
-    "                \n",
-    "                gain = np.right_shift(data, 14)\n",
-    "                \n",
-    "                gain[gain != 0] -= 1\n",
-    "                \n",
-    "                fstride = 1\n",
-    "                if not flip_rgain:  # rgain was taken during flipped orientation\n",
-    "                    fstride = -1\n",
-    "                \n",
-    "                data = np.bitwise_and(data, 0b0011111111111111).astype(np.float32)                \n",
-    "                omap = np.repeat(offsetMap[...,None,:], data.shape[2], axis=2)\n",
-    "                rmap = np.repeat(relGain[:,::fstride,None,:], data.shape[2], axis=2)\n",
-    "                nmap = np.repeat(noiseMap[...,None,:], data.shape[2], axis=2)\n",
-    "                bmap = np.repeat(badPixelMap[...,None,:], data.shape[2], axis=2)\n",
-    "                offset = np.choose(gain, (omap[...,0], omap[...,1], omap[...,2]))\n",
-    "                rg = np.choose(gain, (rmap[...,0], rmap[...,1], rmap[...,2]))\n",
-    "                noise = np.choose(gain, (nmap[...,0], nmap[...,1], nmap[...,2]))\n",
-    "                bpix = np.choose(gain, (bmap[...,0], bmap[...,1], bmap[...,2]))\n",
-    "                \n",
-    "                data -= offset\n",
-    "                data *= rg\n",
-    "                \n",
-    "                if correct_offset_drift:\n",
-    "                    lhd = np.mean(data[x//2-10:x//2,y//2-5:y//2+5,:], axis=(0,1))\n",
-    "                    data[:x//2, :, :] -= lhd\n",
-    "                    drift_lh.append(lhd)\n",
-    "                    \n",
-    "                    uhd = np.mean(data[x//2:x//2+10,y//2-5:y//2+5,:], axis=(0,1))                    \n",
-    "                    data[x//2:, :, :] -= uhd\n",
-    "                    drift_uh.append(lhd)\n",
-    "                \n",
-    "                histCalOffsetCor.fill(data)\n",
-    "\n",
-    "               \n",
-    "                ddset[...] = np.moveaxis(data, 2, 0)\n",
-    "                ddsetm[...] = np.moveaxis(bpix, 2, 0)\n",
-    "                ddsetg[...] = np.moveaxis(gain, 2, 0).astype(np.uint8)\n",
-    "                \n",
-    "                if mean_im is None:\n",
-    "                        mean_im = np.nanmean(data, axis=2)\n",
-    "                        single_im = data[...,0]\n",
-    "                        \n",
-    "                if do_pattern_classification:\n",
-    "                \n",
-    "                    ddsetcm = ofile.create_dataset(h5path+\"/pixels_cm\",\n",
-    "                                         oshape,\n",
-    "                                         chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
-    "                                         dtype=np.float32)\n",
-    "\n",
-    "                    ddsetc = ofile.create_dataset(h5path+\"/pixels_classified\",\n",
-    "                                         oshape,\n",
-    "                                         chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
-    "                                         dtype=np.float32, compression=\"gzip\")\n",
-    "\n",
-    "                    ddsetp = ofile.create_dataset(h5path+\"/patterns\",\n",
-    "                                                 oshape,\n",
-    "                                                 chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
-    "                                                 dtype=np.int32, compression=\"gzip\")\n",
-    "                    \n",
-    "\n",
-    "                    patternClassifierLH._noisemap = noise[:x//2, :, :]\n",
-    "                    patternClassifierUH._noisemap = noise[x//2:, :, :]\n",
-    "\n",
-    "                    data = cmCorrection.correct(data)  # correct for the row common mode\n",
-    "                    ddsetcm[...] = np.moveaxis(data, 2, 0)\n",
-    "\n",
-    "                    dataLH = data[:x//2, :, :]\n",
-    "                    dataUH = data[x//2:, :, :]\n",
-    "\n",
-    "                    dataLH, patternsLH = patternClassifierLH.classify(dataLH)\n",
-    "                    dataUH, patternsUH = patternClassifierUH.classify(dataUH)\n",
-    "\n",
-    "                    data[:x//2, :, :] = dataLH\n",
-    "                    data[x//2:, :, :] = dataUH\n",
-    "\n",
-    "                    patterns = np.zeros(data.shape, patternsLH.dtype)\n",
-    "                    patterns[:x//2, :, :] = patternsLH\n",
-    "                    patterns[x//2:, :, :] = patternsUH\n",
-    "\n",
-    "                    data[data < split_evt_primary_threshold*noise] = 0\n",
-    "                    ddsetc[...] = np.moveaxis(data, 2, 0)\n",
-    "                    ddsetp[...] = np.moveaxis(patterns, 2, 0)\n",
-    "\n",
-    "                    histCalPcorr.fill(data)\n",
-    "                    data[patterns != 100] = np.nan\n",
-    "                    histCalPcorrS.fill(data)\n",
-    "\n",
-    "                    if mean_im_cc is None:\n",
-    "                        mean_im_cc = np.nanmean(data, axis=2)\n",
-    "                        single_im_cc = data[...,0]\n",
-    "               \n",
-    "        except Exception as e:\n",
-    "            print(\"Couldn't calibrate data in {}: {}\".format(f, e))\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:56.094985Z",
-     "start_time": "2018-12-06T16:10:55.918900Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if correct_offset_drift:\n",
-    "    lhds = np.concatenate(drift_lh)\n",
-    "    uhds = np.concatenate(drift_uh)\n",
-    "    fig = plt.figure(figsize=(10,5))\n",
-    "    ax = fig.add_subplot(111)\n",
-    "    ax.plot(lhds, label=\"Lower hem.\")\n",
-    "    ax.plot(uhds, label=\"Upper hem.\")\n",
-    "    ax.set_xlabel(\"Frame #\")\n",
-    "    ax.set_xlabel(\"Offset drift (ADU)\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:56.126409Z",
-     "start_time": "2018-12-06T16:10:56.096242Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if do_pattern_classification:\n",
-    "    print(\"******************LOWER HEMISPHERE******************\\n\")\n",
-    "\n",
-    "    patternStatsLH = patternClassifierLH.getPatternStats()\n",
-    "    fig = plt.figure(figsize=(15,15))\n",
-    "    ax = fig.add_subplot(4,4,1)\n",
-    "    sfields = [\"singles\", \"first singles\", \"clusters\"]\n",
-    "    mfields = [\"doubles\", \"triples\", \"quads\"]\n",
-    "    relativeOccurances =  []\n",
-    "    labels = []\n",
-    "    for i, f in enumerate(sfields):\n",
-    "        relativeOccurances.append(patternStatsLH[f])\n",
-    "        labels.append(f)\n",
-    "    for i, f in enumerate(mfields):\n",
-    "        for k in range(len(patternStatsLH[f])):\n",
-    "            relativeOccurances.append(patternStatsLH[f][k])\n",
-    "            labels.append(f+\"(\"+str(k)+\")\")\n",
-    "    relativeOccurances = np.array(relativeOccurances, np.float)\n",
-    "    relativeOccurances/=np.sum(relativeOccurances)\n",
-    "    pie = ax.pie(relativeOccurances, labels=labels, autopct='%1.1f%%', shadow=True)\n",
-    "    ax.set_title(\"Pattern occurrence\")\n",
-    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
-    "    a = ax.axis('equal')\n",
-    "\n",
-    "    smaps = [\"singlemap\", \"firstsinglemap\", \"clustermap\"]\n",
-    "    for i, m in enumerate(smaps):\n",
-    "\n",
-    "        ax = fig.add_subplot(4,4,2+i)\n",
-    "\n",
-    "        pmap = ax.imshow(patternStatsLH[m], interpolation=\"nearest\", vmax=2*np.nanmedian(patternStatsLH[m]))\n",
-    "        ax.set_title(m)\n",
-    "        cb = fig.colorbar(pmap)\n",
-    "\n",
-    "    mmaps = [\"doublemap\", \"triplemap\", \"quadmap\"]\n",
-    "    k = 0\n",
-    "    for i, m in enumerate(mmaps):\n",
-    "\n",
-    "        for j in range(4):\n",
-    "            ax = fig.add_subplot(4,4,2+len(smaps)+k)\n",
-    "            pmap = ax.imshow(patternStatsLH[m][j], interpolation=\"nearest\", vmax=2*np.median(patternStatsLH[m][j]))\n",
-    "            ax.set_title(m+\"(\"+str(j)+\")\")\n",
-    "            cb = fig.colorbar(pmap)\n",
-    "            k+=1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:56.176160Z",
-     "start_time": "2018-12-06T16:10:56.127853Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if do_pattern_classification:\n",
-    "    patternStatsUH = patternClassifierUH.getPatternStats()\n",
-    "    fig = plt.figure(figsize=(15,15))\n",
-    "    ax = fig.add_subplot(4,4,1)\n",
-    "    sfields = [\"singles\", \"first singles\", \"clusters\"]\n",
-    "    mfields = [\"doubles\", \"triples\", \"quads\"]\n",
-    "    relativeOccurances =  []\n",
-    "    labels = []\n",
-    "    for i, f in enumerate(sfields):\n",
-    "        relativeOccurances.append(patternStatsUH[f])\n",
-    "        labels.append(f)\n",
-    "    for i, f in enumerate(mfields):\n",
-    "        for k in range(len(patternStatsUH[f])):\n",
-    "            relativeOccurances.append(patternStatsUH[f][k])\n",
-    "            labels.append(f+\"(\"+str(k)+\")\")\n",
-    "    relativeOccurances = np.array(relativeOccurances, np.float)\n",
-    "    relativeOccurances/=np.sum(relativeOccurances)\n",
-    "    pie = ax.pie(relativeOccurances, labels=labels, autopct='%1.1f%%', shadow=True)\n",
-    "    ax.set_title(\"Pattern occurrence\")\n",
-    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
-    "    a = ax.axis('equal')\n",
-    "\n",
-    "    smaps = [\"singlemap\", \"firstsinglemap\", \"clustermap\"]\n",
-    "    for i, m in enumerate(smaps):\n",
-    "\n",
-    "        ax = fig.add_subplot(4,4,2+i)\n",
-    "\n",
-    "        pmap = ax.imshow(patternStatsUH[m], interpolation=\"nearest\", vmax=2*np.nanmedian(patternStatsUH[m]))\n",
-    "        ax.set_title(m)\n",
-    "        cb = fig.colorbar(pmap)\n",
-    "\n",
-    "    mmaps = [\"doublemap\", \"triplemap\", \"quadmap\"]\n",
-    "    k = 0\n",
-    "    for i, m in enumerate(mmaps):\n",
-    "\n",
-    "        for j in range(4):\n",
-    "            ax = fig.add_subplot(4,4,2+len(smaps)+k)\n",
-    "            pmap = ax.imshow(patternStatsUH[m][j], interpolation=\"nearest\", vmax=np.median(patternStatsUH[m][j]))\n",
-    "            ax.set_title(m+\"(\"+str(j)+\")\")\n",
-    "            cb = fig.colorbar(pmap)\n",
-    "            k+=1\n",
-    "\n",
-    "    print(\"******************UPPER HEMISPHERE******************\\n\")        "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:56.190150Z",
-     "start_time": "2018-12-06T16:10:56.177570Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if do_pattern_classification:\n",
-    "    t0 = PrettyTable()\n",
-    "    t0.title = \"Total number of Counts after all corrections\"\n",
-    "    t0.field_names = [\"Hemisphere\",\"Singles\", \"First-singles\", \"Clusters\"]\n",
-    "    t0.add_row([\"LH\", patternStatsLH['singles'], patternStatsLH['first singles'], patternStatsLH['clusters']])\n",
-    "    t0.add_row([\"UH\", patternStatsUH['singles'], patternStatsUH['first singles'], patternStatsUH['clusters']])\n",
-    "\n",
-    "    print(t0)\n",
-    "\n",
-    "    t1 = PrettyTable()\n",
-    "\n",
-    "    t1.field_names = [\"Index\",\"D-LH\", \"D-UH\", \"T-LH\", \"T-UH\", \"Q-LH\", \"Q-UH\"]\n",
-    "\n",
-    "    t1.add_row([0, patternStatsLH['doubles'][0], patternStatsUH['doubles'][0], patternStatsLH['triples'][0], patternStatsUH['triples'][0], patternStatsLH['quads'][0], patternStatsUH['quads'][0]])\n",
-    "    t1.add_row([1, patternStatsLH['doubles'][1], patternStatsUH['doubles'][1], patternStatsLH['triples'][1], patternStatsUH['triples'][1], patternStatsLH['quads'][1], patternStatsUH['quads'][1]])\n",
-    "    t1.add_row([2, patternStatsLH['doubles'][2], patternStatsUH['doubles'][2], patternStatsLH['triples'][2], patternStatsUH['triples'][2], patternStatsLH['quads'][2], patternStatsUH['quads'][2]])\n",
-    "    t1.add_row([3, patternStatsLH['doubles'][3], patternStatsUH['doubles'][3], patternStatsLH['triples'][3], patternStatsUH['triples'][3], patternStatsLH['quads'][3], patternStatsUH['quads'][3]])\n",
-    "\n",
-    "    print(t1)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:56.203219Z",
-     "start_time": "2018-12-06T16:10:56.191509Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if do_pattern_classification:\n",
-    "    doublesLH = patternStatsLH['doubles'][0] + patternStatsLH['doubles'][1] + patternStatsLH['doubles'][2] + patternStatsLH['doubles'][3]\n",
-    "    triplesLH = patternStatsLH['triples'][0] + patternStatsLH['triples'][1] + patternStatsLH['triples'][2] + patternStatsLH['triples'][3]\n",
-    "    quadsLH = patternStatsLH['quads'][0] + patternStatsLH['quads'][1] + patternStatsLH['quads'][2] + patternStatsLH['quads'][3]\n",
-    "    allsinglesLH = patternStatsLH['singles'] + patternStatsLH['first singles']\n",
-    "    eventsLH = allsinglesLH + doublesLH + triplesLH + quadsLH\n",
-    "\n",
-    "    doublesUH = patternStatsUH['doubles'][0] + patternStatsUH['doubles'][1] + patternStatsUH['doubles'][2] + patternStatsUH['doubles'][3]\n",
-    "    triplesUH = patternStatsUH['triples'][0] + patternStatsUH['triples'][1] + patternStatsUH['triples'][2] + patternStatsUH['triples'][3]\n",
-    "    quadsUH = patternStatsUH['quads'][0] + patternStatsUH['quads'][1] + patternStatsUH['quads'][2] + patternStatsUH['quads'][3]\n",
-    "    allsinglesUH = patternStatsUH['singles'] + patternStatsUH['first singles']\n",
-    "    eventsUH = allsinglesUH + doublesUH + triplesUH + quadsUH\n",
-    "\n",
-    "    reloccurLH = np.array([allsinglesLH/eventsLH, doublesLH/eventsLH, triplesLH/eventsLH, quadsLH/eventsLH])\n",
-    "    reloccurUH = np.array([allsinglesUH/eventsUH, doublesUH/eventsUH, triplesUH/eventsUH, quadsUH/eventsUH])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:10:56.212586Z",
-     "start_time": "2018-12-06T16:10:56.204731Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if do_pattern_classification:\n",
-    "    fig = plt.figure(figsize=(10,5))\n",
-    "    ax = fig.add_subplot(1,2,1)\n",
-    "    labels = ['singles', 'doubles', 'triples', 'quads']\n",
-    "    pie = ax.pie(reloccurLH, labels=labels, autopct='%1.1f%%', shadow=True)\n",
-    "    ax.set_title(\"Pattern occurrence LH\")\n",
-    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
-    "    a = ax.axis('equal')\n",
-    "    ax = fig.add_subplot(1,2,2)\n",
-    "    pie = ax.pie(reloccurUH, labels=labels, autopct='%1.1f%%', shadow=True)\n",
-    "    ax.set_title(\"Pattern occurrence UH\")\n",
-    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
-    "    a = ax.axis('equal')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:13:12.889583Z",
-     "start_time": "2018-12-06T16:13:11.122653Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "ho,eo,co,so = histCalOffsetCor.get()\n",
-    "\n",
-    "\n",
-    "d = [{'x': co,\n",
-    "      'y': ho,\n",
-    "      'y_err': np.sqrt(ho[:]),\n",
-    "      'drawstyle': 'steps-mid',\n",
-    "      'errorstyle': 'bars',\n",
-    "      'errorcoarsing': 2,\n",
-    "      'label': 'Offset corr.'\n",
-    "     },\n",
-    "    \n",
-    "     ]\n",
-    "     \n",
-    "\n",
-    "fig = xana.simplePlot(d, aspect=1, x_label='Energy(ADU)', \n",
-    "                      y_label='Number of occurrences', figsize='2col',\n",
-    "                      y_log=True, x_range=(-50,500),\n",
-    "                      legend='top-center-frame-2col')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:12:57.289742Z",
-     "start_time": "2018-12-06T16:12:45.529734Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "if do_pattern_classification:\n",
-    "    h1,e1L,c1L,s1L = histCalPcorr.get()\n",
-    "    h1s,e1Ls,c1Ls,s1Ls = histCalPcorrS.get()\n",
-    "\n",
-    "\n",
-    "    d = [\n",
-    "         {'x': c1L,\n",
-    "          'y': h1,\n",
-    "          'y_err': np.sqrt(h1[:]),\n",
-    "          'drawstyle': 'steps-mid',\n",
-    "          'label': 'Split event corrected'},\n",
-    "         {'x': c1Ls,\n",
-    "          'y': h1s,\n",
-    "          'y_err': np.sqrt(h1s[:]),\n",
-    "          'drawstyle': 'steps-mid',\n",
-    "          'label': 'Single pixel hits'}\n",
-    "    ]\n",
-    "\n",
-    "\n",
-    "    fig = xana.simplePlot(d, aspect=1, x_label='Energy(ADU)', \n",
-    "                          y_label='Number of occurrences', figsize='2col',\n",
-    "                          y_log=True, x_range=(0,200),x_log=False,\n",
-    "                          legend='top-center-frame-2col')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Mean Image of first Sequence ##"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:11:08.317130Z",
-     "start_time": "2018-12-06T16:11:05.788655Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "fig = xana.heatmapPlot(mean_im,\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Signal (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmin=-50, vmax=500)\n",
-    "\n",
-    "if do_pattern_classification:\n",
-    "    fig = xana.heatmapPlot(mean_im_cc,\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Signal (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmin=-50, vmax=500)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "collapsed": true
-   },
-   "source": [
-    "## Single Shot of first Sequnce ##"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2018-12-06T16:11:10.908912Z",
-     "start_time": "2018-12-06T16:11:08.318486Z"
-    },
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "fig = xana.heatmapPlot(single_im,\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Signal (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmin=-50, vmax=500)\n",
-    "\n",
-    "if do_pattern_classification:\n",
-    "    fig = xana.heatmapPlot(single_im_cc,\n",
-    "                       x_label='Columns', y_label='Rows',\n",
-    "                       lut_label='Signal (ADU)',\n",
-    "                       x_range=(0,y),\n",
-    "                       y_range=(0,x), vmin=-50, vmax=500)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
-   "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.7"
-  },
-  "latex_envs": {
-   "LaTeX_envs_menu_present": true,
-   "autocomplete": true,
-   "bibliofile": "biblio.bib",
-   "cite_by": "apalike",
-   "current_citInitial": 1,
-   "eqLabelWithNumbers": true,
-   "eqNumInitial": 1,
-   "hotkeys": {
-    "equation": "Ctrl-E",
-    "itemize": "Ctrl-I"
-   },
-   "labels_anchors": false,
-   "latex_user_defs": false,
-   "report_style_numbering": false,
-   "user_envs_cfg": false
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
diff --git a/notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb b/notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb
deleted file mode 100644
index 908d75fea..000000000
--- a/notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb
+++ /dev/null
@@ -1,505 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Statistical analysis of calibration factors#\n",
-    "\n",
-    "Author: Mikhail Karnevskiy, Steffen Hauf, Version 0.1\n",
-    "\n",
-    "A description of the notebook."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cluster_profile = \"noDB\" # The ipcluster profile to use\n",
-    "start_date = \"2019-01-30\" # date to start investigation interval from\n",
-    "end_date = \"2019-08-30\" # date to end investigation interval at, can be \"now\"\n",
-    "nconstants = 10 # Number of time stamps to plot. If not 0, overcome start_date.\n",
-    "dclass=\"CCD\" # Detector class\n",
-    "db_module = \"fastCCD1\" # detector entry in the DB to investigate\n",
-    "constants = [\"Noise\", \"Offset\"] # constants to plot\n",
-    "\n",
-    "gain_setting = [0,1,2,8] # gain stages\n",
-    "bias_voltage = [79] # Bias voltage\n",
-    "temperature = [235, 216, 245] # Operation temperature\n",
-    "integration_time = [1, 50] # Integration time\n",
-    "pixels_x=[1934] # number of pixels along X axis\n",
-    "pixels_y=[960] # number of pixels along Y axis\n",
-    "max_time = 15 # max time margin in minutes to match bad pixels\n",
-    "parameter_names = ['bias_voltage', 'integration_time', 'temperature', \n",
-    "                   'gain_setting', 'pixels_x', 'pixels_y'] # names of parameters\n",
-    "\n",
-    "separate_plot = ['integration_time', 'gain_setting', 'temperature'] # Plot on separate plots\n",
-    "photon_energy = 9.2 # Photon energy of the beam\n",
-    "out_folder = \"/gpfs/exfel/data/scratch/karnem/test_FCCD/\" # output folder\n",
-    "use_existing = \"\" # If not empty, constants stored in given folder will be used\n",
-    "cal_db_interface = \"tcp://max-exfl016:8015#8025\" # the database interface to use\n",
-    "cal_db_timeout = 180000 # timeout on caldb requests\",\n",
-    "plot_range = 3 # range for plotting in units of median absolute deviations"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "import copy\n",
-    "import datetime\n",
-    "import dateutil.parser\n",
-    "import numpy as np\n",
-    "from operator import itemgetter\n",
-    "import os\n",
-    "import sys\n",
-    "import warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "\n",
-    "from iCalibrationDB import Constants, Conditions, Detectors, ConstantMetaData\n",
-    "from cal_tools.tools import get_from_db\n",
-    "from cal_tools.ana_tools import (save_dict_to_hdf5, load_data_from_hdf5, \n",
-    "                                 HMType, hm_combine,\n",
-    "                                 combine_lists, get_range)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Prepare variables\n",
-    "spShape = (967, 10) # Shape of superpixel\n",
-    "\n",
-    "parameters = [globals()[x] for x in parameter_names]\n",
-    "\n",
-    "constantsDark = {'Noise': 'BadPixelsDark',\n",
-    "                 'Offset': 'BadPixelsDark'}\n",
-    "print('Bad pixels data: ', constantsDark)\n",
-    "\n",
-    "# Define parameters in order to perform loop over time stamps\n",
-    "start = datetime.datetime.now() if start_date.upper() == \"NOW\" else dateutil.parser.parse(\n",
-    "    start_date)\n",
-    "end = datetime.datetime.now() if end_date.upper() == \"NOW\" else dateutil.parser.parse(\n",
-    "    end_date)\n",
-    "\n",
-    "# Create output folder\n",
-    "os.makedirs(out_folder, exist_ok=True)\n",
-    "\n",
-    "# Get getector conditions\n",
-    "det = getattr(Detectors, db_module)\n",
-    "dconstants = getattr(Constants, dclass)(det.detector_type)\n",
-    "\n",
-    "print('CalDB Interface: {}'.format(cal_db_interface))\n",
-    "print('Start time at: ', start)\n",
-    "print('End time at: ', end)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "parameter_list = combine_lists(*parameters, names = parameter_names)\n",
-    "print(parameter_list)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "# Retrieve list of meta-data\n",
-    "constant_versions = []\n",
-    "constant_parameters = []\n",
-    "constantBP_versions = []\n",
-    "\n",
-    "# Loop over constants\n",
-    "for c, const in enumerate(constants):\n",
-    "    \n",
-    "    if use_existing != \"\":\n",
-    "        break\n",
-    "    \n",
-    "    # Loop over parameters\n",
-    "    for pars in parameter_list:\n",
-    "    \n",
-    "        if (const in [\"Offset\", \"Noise\", \"SlopesPC\"] or \"DARK\" in const.upper()):\n",
-    "            dcond = Conditions.Dark\n",
-    "            mcond = getattr(dcond, dclass)(**pars)\n",
-    "        else:\n",
-    "            dcond = Conditions.Illuminated\n",
-    "            mcond = getattr(dcond, dclass)(**pars,\n",
-    "                                photon_energy=photon_energy)\n",
-    "\n",
-    "            \n",
-    "            \n",
-    "        print('Request: ', const, 'with paramters:', pars)\n",
-    "        # Request Constant versions for given parameters and module\n",
-    "        data = get_from_db(det,\n",
-    "                           getattr(dconstants,\n",
-    "                                   const)(),\n",
-    "                           copy.deepcopy(mcond), None,\n",
-    "                           cal_db_interface,\n",
-    "                           creation_time=start,\n",
-    "                           verbosity=0,\n",
-    "                           timeout=cal_db_timeout,\n",
-    "                           meta_only=True,\n",
-    "                           version_info=True)\n",
-    "        \n",
-    "        if not isinstance(data, list):\n",
-    "                continue\n",
-    "            \n",
-    "        data = sorted(data, key=itemgetter('begin_at'), reverse=True)\n",
-    "        print('Number of retrieved constants: {}'.format(len(data)) )\n",
-    "                \n",
-    "        if const in constantsDark:\n",
-    "            # Request BP constant versions\n",
-    "            dataBP = get_from_db(det,\n",
-    "                                 getattr(dconstants, \n",
-    "                                         constantsDark[const])(),\n",
-    "                                 copy.deepcopy(mcond), None,\n",
-    "                                 cal_db_interface,\n",
-    "                                 creation_time=start,\n",
-    "                                 verbosity=0,\n",
-    "                                 timeout=cal_db_timeout,\n",
-    "                                 meta_only=True,\n",
-    "                                 version_info=True)\n",
-    "        \n",
-    "            if not isinstance(data, list) or not isinstance(dataBP, list):\n",
-    "                continue\n",
-    "            print('Number of retrieved darks: {}'.format(len(dataBP)) )\n",
-    "            found_BPmatch = False\n",
-    "            for d in data:\n",
-    "                # Match proper BP constant version\n",
-    "                # and get constant version within\n",
-    "                # requested time range\n",
-    "                if d is None:\n",
-    "                    print('Time or data is not found!')\n",
-    "                    continue\n",
-    "\n",
-    "                dt = dateutil.parser.parse(d['begin_at'])\n",
-    "\n",
-    "                if (dt.replace(tzinfo=None) > end or \n",
-    "                    (nconstants==0 and dt.replace(tzinfo=None) < start)):\n",
-    "                    continue\n",
-    "                    \n",
-    "                if nconstants>0 and constant_parameters.count(pars)>nconstants-1:\n",
-    "                    break\n",
-    "\n",
-    "                closest_BP = None\n",
-    "                closest_BPtime = None\n",
-    "\n",
-    "                for dBP in dataBP:\n",
-    "                    if dBP is None:\n",
-    "                        print(\"Bad pixels are not found!\")\n",
-    "                        continue\n",
-    "\n",
-    "                    dt = dateutil.parser.parse(d['begin_at'])\n",
-    "                    dBPt = dateutil.parser.parse(dBP['begin_at'])\n",
-    "\n",
-    "                    if dt == dBPt:\n",
-    "                        found_BPmatch = True\n",
-    "                    else:\n",
-    "\n",
-    "                        if np.abs(dBPt-dt).seconds < (max_time*60):\n",
-    "                            if closest_BP is None:\n",
-    "                                closest_BP = dBP\n",
-    "                                closest_BPtime = dBPt\n",
-    "                            else:\n",
-    "                                if np.abs(dBPt-dt) < np.abs(closest_BPtime-dt):\n",
-    "                                    closest_BP = dBP\n",
-    "                                    closest_BPtime = dBPt\n",
-    "\n",
-    "                        if dataBP.index(dBP) ==  len(dataBP)-1:\n",
-    "                            if closest_BP:\n",
-    "                                dBP = closest_BP\n",
-    "                                dBPt = closest_BPtime\n",
-    "                                found_BPmatch = True\n",
-    "                            else:\n",
-    "                                print('Bad pixels are not found!')\n",
-    "\n",
-    "                    if found_BPmatch:\n",
-    "                        print(\"Found constant {}: begin at {}\".format(const, dt))\n",
-    "                        print(\"Found bad pixels at {}\".format(dBPt))\n",
-    "                        constantBP_versions.append(dBP)\n",
-    "                        constant_versions.append(d)\n",
-    "                        constant_parameters.append(copy.deepcopy(pars))\n",
-    "                        found_BPmatch = False\n",
-    "                        break\n",
-    "        else:\n",
-    "            constant_versions += data\n",
-    "            constant_parameters += [copy.deepcopy(pars)]*len(data)\n",
-    "\n",
-    "# Remove dublications\n",
-    "constant_versions_tmp = []\n",
-    "constant_parameters_tmp = []\n",
-    "constantBP_versions_tmp = []\n",
-    "for i, x in enumerate(constant_versions):\n",
-    "    if x not in constant_versions_tmp:\n",
-    "        constant_versions_tmp.append(x)\n",
-    "        constant_parameters_tmp.append(constant_parameters[i])\n",
-    "        if i<len(constantBP_versions)-1:\n",
-    "            constantBP_versions_tmp.append(constantBP_versions[i])\n",
-    "constant_versions=constant_versions_tmp\n",
-    "constantBP_versions=constantBP_versions_tmp\n",
-    "constant_parameters=constant_parameters_tmp\n",
-    "\n",
-    "print('Number of stored constant versions is {}'.format(len(constant_versions)))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_rebined(a, rebin):\n",
-    "    return a[:,:,0].reshape(\n",
-    "                int(a.shape[0] / rebin[0]),\n",
-    "                rebin[0],\n",
-    "                int(a.shape[1] / rebin[1]),\n",
-    "                rebin[1])\n",
-    "    \n",
-    "def modify_const(const, data, isBP = False):\n",
-    "    return data\n",
-    "\n",
-    "ret_constants = {}\n",
-    "constant_data = ConstantMetaData()\n",
-    "constant_BP = ConstantMetaData()\n",
-    "for i, constant_version in enumerate(constant_versions):\n",
-    "\n",
-    "    const = constant_version['data_set_name'].split('/')[-2]\n",
-    "    qm = db_module\n",
-    "    \n",
-    "    print(\"constant: {}, module {}\".format(const,qm))\n",
-    "    constant_data.retrieve_from_version_info(constant_version)\n",
-    "    \n",
-    "    for key in separate_plot:\n",
-    "        const = '{}_{}'.format(const, constant_parameters[i][key])\n",
-    "    \n",
-    "    if not const in ret_constants:\n",
-    "        ret_constants[const] = {}\n",
-    "    if not qm in ret_constants[const]:\n",
-    "            ret_constants[const][qm] = []\n",
-    "    \n",
-    "    cdata = constant_data.calibration_constant.data\n",
-    "    ctime = constant_data.calibration_constant_version.begin_at\n",
-    "    \n",
-    "    cdata = modify_const(const, cdata)\n",
-    "    \n",
-    "    if len(constantBP_versions)>0:\n",
-    "        constant_BP.retrieve_from_version_info(constantBP_versions[i])\n",
-    "        cdataBP = constant_BP.calibration_constant.data\n",
-    "        cdataBP = modify_const(const, cdataBP, True)\n",
-    "        \n",
-    "        if cdataBP.shape != cdata.shape:\n",
-    "            print('Wrong bad pixel shape! {}, expected {}'.format(cdataBP.shape, cdata.shape))\n",
-    "            continue\n",
-    "        \n",
-    "        # Apply bad pixel mask\n",
-    "        cdataABP = np.copy(cdata)\n",
-    "        cdataABP[cdataBP > 0] = np.nan\n",
-    "    \n",
-    "        # Create superpixels for constants with BP applied\n",
-    "        cdataABP = get_rebined(cdataABP, spShape)\n",
-    "        toStoreBP = np.nanmean(cdataABP, axis=(1, 3))\n",
-    "        toStoreBPStd = np.nanstd(cdataABP, axis=(1, 3))\n",
-    "\n",
-    "        # Prepare number of bad pixels per superpixels\n",
-    "        cdataBP = get_rebined(cdataBP, spShape)\n",
-    "        cdataNBP = np.nansum(cdataBP > 0, axis=(1, 3))\n",
-    "    else:\n",
-    "        toStoreBP = 0\n",
-    "        toStoreBPStd = 0\n",
-    "        cdataNBP = 0\n",
-    "\n",
-    "    # Create superpixels for constants without BP applied\n",
-    "    cdata = get_rebined(cdata, spShape)\n",
-    "    toStoreStd = np.nanstd(cdata, axis=(1, 3))\n",
-    "    toStore = np.nanmean(cdata, axis=(1, 3))\n",
-    "    \n",
-    "    # Convert parameters to dict\n",
-    "    dpar = {p.name: p.value for p in constant_data.detector_condition.parameters}\n",
-    "    \n",
-    "    print(\"Store values in dict\", const, qm, ctime)\n",
-    "    ret_constants[const][qm].append({'ctime': ctime,\n",
-    "                                     'nBP': cdataNBP,\n",
-    "                                     'dataBP': toStoreBP,\n",
-    "                                     'dataBPStd': toStoreBPStd,\n",
-    "                                     'data': toStore,\n",
-    "                                     'dataStd': toStoreStd,\n",
-    "                                     'mdata': dpar})  \n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "if use_existing == \"\":\n",
-    "    print('Save data to {}/CalDBAna_{}_{}.h5'.format(out_folder, dclass, db_module))\n",
-    "    save_dict_to_hdf5(ret_constants,\n",
-    "                      '{}/CalDBAna_{}_{}.h5'.format(out_folder, dclass, db_module))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "if use_existing == \"\":\n",
-    "    fpath = '{}/CalDBAna_{}_*.h5'.format(out_folder, dclass)\n",
-    "else:\n",
-    "    fpath = '{}/CalDBAna_{}_*.h5'.format(use_existing, dclass)\n",
-    "\n",
-    "print('Load data from {}'.format(fpath))\n",
-    "ret_constants = load_data_from_hdf5(fpath)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Parameters for plotting\n",
-    "\n",
-    "keys = {\n",
-    "    'Mean': ['data', '', 'Mean over pixels'],\n",
-    "    'std': ['dataStd', '', '$\\sigma$ over pixels'],\n",
-    "    'MeanBP': ['dataBP', 'Good pixels only', 'Mean over pixels'],\n",
-    "    'NBP': ['nBP', 'Fraction of BP', 'Fraction of BP'],\n",
-    "    'stdBP': ['dataBPStd', 'Good pixels only', '$\\sigma$ over pixels'],\n",
-    "    'stdASIC': ['', '', '$\\sigma$ over ASICs'],\n",
-    "    'stdCell': ['', '', '$\\sigma$ over Cells'],\n",
-    "}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print('Plot calibration constants')\n",
-    "\n",
-    "# loop over constat type\n",
-    "for const, modules in ret_constants.items():\n",
-    "\n",
-    "        const = const.split(\"_\")\n",
-    "        print('Const: {}'.format(const))\n",
-    "\n",
-    "        # Loop over modules\n",
-    "        for mod, data in modules.items():\n",
-    "            print(mod)\n",
-    "\n",
-    "            ctimes = np.array(data[\"ctime\"])\n",
-    "            ctimes_ticks = [x.strftime('%y-%m-%d') for x in ctimes]\n",
-    "\n",
-    "            if (\"mdata\" in data):\n",
-    "                cmdata = np.array(data[\"mdata\"])\n",
-    "                for i, tick in enumerate(ctimes_ticks):\n",
-    "                    ctimes_ticks[i] = ctimes_ticks[i] + \\\n",
-    "                        ', V={:1.0f}'.format(cmdata[i]['Sensor Temperature']) + \\\n",
-    "                        ', T={:1.0f}'.format(\n",
-    "                        cmdata[i]['Integration Time'])\n",
-    "\n",
-    "            sort_ind = np.argsort(ctimes_ticks)\n",
-    "            ctimes_ticks = list(np.array(ctimes_ticks)[sort_ind])\n",
-    "\n",
-    "            # Create sorted by data dataset\n",
-    "            rdata = {}\n",
-    "            for key, item in keys.items():\n",
-    "                if item[0] in data:\n",
-    "                    rdata[key] = np.array(data[item[0]])[sort_ind]\n",
-    "\n",
-    "            nTimes = rdata['Mean'].shape[0]\n",
-    "            nPixels = rdata['Mean'].shape[1] * rdata['Mean'].shape[2]\n",
-    "            nBins = nPixels\n",
-    "\n",
-    "            # Avoid too low values\n",
-    "            if const[0] in [\"Noise\", \"Offset\"]:\n",
-    "                rdata['Mean'][rdata['Mean'] < 0.1] = np.nan\n",
-    "                if 'MeanBP' in rdata:\n",
-    "                    rdata['MeanBP'][rdata['MeanBP'] < 0.1] = np.nan\n",
-    "                    \n",
-    "            if 'NBP' in rdata:\n",
-    "                rdata['NBP'] = rdata['NBP'].astype(float)\n",
-    "                rdata[\"NBP\"][rdata[\"NBP\"] == (spShape[0] * spShape[1])] = np.nan\n",
-    "                rdata[\"NBP\"] = rdata[\"NBP\"] / spShape[0] / spShape[1] * 100\n",
-    "\n",
-    "            # Reshape: ASICs over cells for plotting\n",
-    "            pdata = {}\n",
-    "            for key in rdata:\n",
-    "                if len(rdata[key].shape)<3:\n",
-    "                    continue\n",
-    "                pdata[key] = rdata[key][:, :, :].reshape(nTimes, nBins).swapaxes(0, 1)\n",
-    "\n",
-    "            # Plotting\n",
-    "            for key in pdata:\n",
-    "                if len(pdata[key].shape)<2:\n",
-    "                    continue\n",
-    "\n",
-    "                if key == 'NBP':\n",
-    "                    unit = '[%]'\n",
-    "                else:\n",
-    "                    unit = '[ADU]'\n",
-    "\n",
-    "                title = '{}, module {}, {}'.format(\n",
-    "                    const[0], mod, keys[key][1])\n",
-    "                cb_label = '{}, {} {}'.format(const[0], keys[key][2], unit)\n",
-    "\n",
-    "                fname = '{}/{}_{}'.format(out_folder, const[0], mod.replace('_', ''))\n",
-    "                for item in const[1:]:\n",
-    "                    fname = '{}_{}'.format(fname, item)\n",
-    "                fname = '{}_ASIC_{}.png'.format(fname, key)\n",
-    "                \n",
-    "                vmin,vmax = get_range(pdata[key][::-1].flatten(), plot_range)\n",
-    "                hm_combine(pdata[key][::-1], htype=HMType.mro,\n",
-    "                          x_label='Creation Time', y_label='ASIC ID',\n",
-    "                          x_ticklabels=ctimes_ticks,\n",
-    "                          x_ticks=np.arange(len(ctimes_ticks))+0.3,\n",
-    "                          title=title, cb_label=cb_label,\n",
-    "                          vmin=vmin, vmax=vmax,\n",
-    "                          fname=fname,\n",
-    "                          pad=[0.125, 0.125, 0.12, 0.185])\n"
-   ]
-  }
- ],
- "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.7"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
-- 
GitLab


From 36062898b1c4c03e949d2a87c2ff9c58e62ccdef Mon Sep 17 00:00:00 2001
From: Karim Ahmed <karim.ahmed@xfel.eu>
Date: Tue, 15 Oct 2019 09:19:43 +0200
Subject: [PATCH 3/3] Revert "Deleted the other notebooks I don't want to
 merge."

This reverts commit e5408d257c5153e0560b310bce8fa2ee5a8f0485.
revert commit
---
 ...haracterize_Darks_NewDAQ_FastCCD_NBC.ipynb |  574 ++++++++
 ...s_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb | 1016 +++++++++++++
 ...orrectionNotebook_NewDAQ_FastCCD_NBC.ipynb | 1279 +++++++++++++++++
 .../FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb   |  505 +++++++
 4 files changed, 3374 insertions(+)
 create mode 100644 notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb
 create mode 100644 notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb
 create mode 100644 notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb
 create mode 100644 notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb

diff --git a/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb b/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb
new file mode 100644
index 000000000..6ee85833c
--- /dev/null
+++ b/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC.ipynb
@@ -0,0 +1,574 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# FastCCD Dark Characterization\n",
+    "\n",
+    "Author: I. Klačková, S. Hauf, Version 1.0\n",
+    "\n",
+    "The following notebook provides dark image analysis of the FastCCD detector.\n",
+    "\n",
+    "Dark characterization evaluates offset and noise of the detector and gives information about bad pixels. Resulting maps are saved as .h5 files for a latter use."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:38.999974Z",
+     "start_time": "2018-12-06T10:54:38.983406Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "in_folder = \"/gpfs/exfel/exp/SCS/201930/p900074/raw/\" # input folder, required\n",
+    "out_folder = 'gpfs/exfel/data/scratch/haufs/test/' # output folder, required\n",
+    "path_template = 'RAW-R{:04d}-DA05-S{{:05d}}.h5' # the template to use to access data\n",
+    "run = 321 # which run to read data from, required\n",
+    "number_dark_frames = 0 # number of images to be used, if set to 0 all available images are used\n",
+    "cluster_profile = \"noDB\" # ipcluster profile to use\n",
+    "operation_mode = \"FF\" #o r \"FF\". FS stands for frame-store and FF for full-frame opeartion\n",
+    "sigma_noise = 10. # Pixel exceeding 'sigmaNoise' * noise value in that pixel will be masked\n",
+    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image/pixels' # path in the HDF5 file the data is at\n",
+    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value'  # path to find temperature at\n",
+    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # path to control data\n",
+    "cal_db_interface = \"tcp://max-exfl016:8020\" # calibration DB interface to use\n",
+    "local_output = False # output also in as H5 files\n",
+    "temp_limits = 5 # limits within which temperature is considered the same\n",
+    "sequence = 0 # sequence file to use\n",
+    "multi_iteration = False # use multiple iterations\n",
+    "use_dir_creation_date = True # use dir creation date\n",
+    "bad_pixel_offset_sigma = 5. # offset standard deviations above which to consider pixel bad \n",
+    "bad_pixel_noise_sigma = 5. # noise standard deviations above which to consider pixel bad \n",
+    "fix_temperature = 0. # fix temperature to this value, set to 0 to use slow control value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:39.190907Z",
+     "start_time": "2018-12-06T10:54:39.186154Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
+    "from iCalibrationDB.detectors import DetectorTypes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:39.467334Z",
+     "start_time": "2018-12-06T10:54:39.427784Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import XFELDetAna.xfelprofiler as xprof\n",
+    "\n",
+    "profiler = xprof.Profiler()\n",
+    "profiler.disable()\n",
+    "from XFELDetAna.util import env\n",
+    "env.iprofile = cluster_profile\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "from XFELDetAna import xfelpycaltools as xcal\n",
+    "from XFELDetAna import xfelpyanatools as xana\n",
+    "from XFELDetAna.plotting.util import prettyPlotting\n",
+    "prettyPlotting=True\n",
+    "from XFELDetAna.xfelreaders import ChunkReader\n",
+    "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
+    "from cal_tools.tools import get_dir_creation_date\n",
+    "\n",
+    "import numpy as np\n",
+    "import h5py\n",
+    "import matplotlib.pyplot as plt\n",
+    "from iminuit import Minuit\n",
+    "\n",
+    "import time\n",
+    "import copy\n",
+    "\n",
+    "from prettytable import PrettyTable\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "def nImagesOrLimit(nImages, limit):\n",
+    "    if limit == 0:\n",
+    "        return nImages\n",
+    "    else:\n",
+    "        return min(nImages, limit)\n",
+    "    \n",
+    "sigmaNoise = sigma_noise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
+    "file_loc = 'proposal:{} runs:{}'.format(proposal, run)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:40.058101Z",
+     "start_time": "2018-12-06T10:54:40.042615Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "if operation_mode == \"FS\":\n",
+    "    x = 960 # rows of the FastCCD to analyze in FS mode \n",
+    "    y = 960 # columns of the FastCCD to analyze in FS mode \n",
+    "    print('\\nYou are analyzing data in FS mode.')\n",
+    "else:\n",
+    "    x = 1934 # rows of the FastCCD to analyze in FF mode \n",
+    "    y = 960 # columns of the FastCCD to analyze in FF mode\n",
+    "    print('\\nYou are analyzing data in FF mode.\\n')\n",
+    "    \n",
+    "ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
+    "fp_name = path_template.format(run)\n",
+    "\n",
+    "import datetime\n",
+    "creation_time = None\n",
+    "if use_dir_creation_date:\n",
+    "    creation_time = get_dir_creation_date(in_folder, run)\n",
+    "\n",
+    "fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
+    "\n",
+    "print(\"Reading data from: {}\\n\".format(fp_path))\n",
+    "print(\"Run is: {}\".format(run))\n",
+    "print(\"HDF5 path: {}\".format(h5path))\n",
+    "if creation_time:\n",
+    "    print(\"Using {} as creation time\".format(creation_time.isoformat()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:40.555804Z",
+     "start_time": "2018-12-06T10:54:40.452978Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "filename = fp_path.format(sequence)\n",
+    "sensorSize = [x, y]\n",
+    "chunkSize = 100 #Number of images to read per chunk\n",
+    "#Sensor area will be analysed according to blocksize\n",
+    "blockSize = [sensorSize[0]//2, sensorSize[1]//4] \n",
+    "xcal.defaultBlockSize = blockSize\n",
+    "cpuCores = 8 #Specifies the number of running cpu cores\n",
+    "memoryCells = 1 #FastCCD has 1 memory cell\n",
+    "#Specifies total number of images to proceed\n",
+    "nImages = fastccdreaderh5.getDataSize(filename, h5path)[0] \n",
+    "nImages = nImagesOrLimit(nImages, number_dark_frames)\n",
+    "print(\"\\nNumber of dark images to analyze: \",nImages)\n",
+    "commonModeBlockSize = blockSize\n",
+    "commonModeAxisR = 'row'#Axis along which common mode will be calculated\n",
+    "run_parallel = True\n",
+    "profile = False\n",
+    "\n",
+    "with h5py.File(filename, 'r') as f:\n",
+    "    bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
+    "    det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
+    "    integration_time = int(f['{}/acquisitionTime/value'.format(h5path_cntrl)][0])\n",
+    "    temperature = np.mean(f[h5path_t])\n",
+    "    temperature_k = temperature + 273.15\n",
+    "        \n",
+    "    if fix_temperature != 0.:\n",
+    "        temperature_k = fix_temperature\n",
+    "        print(\"Using fixed temperature\")\n",
+    "    print(\"Bias voltage is {} V\".format(bias_voltage))\n",
+    "    print(\"Detector gain is set to x{}\".format(det_gain))\n",
+    "    print(\"Detector integration time is set to {}\".format(integration_time))\n",
+    "    print(\"Mean temperature was {:0.2f} °C / {:0.2f} K\".format(temperature, temperature_k))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:41.584031Z",
+     "start_time": "2018-12-06T10:54:41.578462Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "reader = ChunkReader(filename, fastccdreaderh5.readData, \n",
+    "                     nImages, chunkSize, \n",
+    "                     path = h5path, \n",
+    "                     pixels_x = sensorSize[0],\n",
+    "                     pixels_y = sensorSize[1],)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:41.899511Z",
+     "start_time": "2018-12-06T10:54:41.864816Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "noiseCal = xcal.NoiseCalculator(sensorSize, memoryCells, \n",
+    "                                cores=cpuCores, blockSize=blockSize,\n",
+    "                               runParallel=run_parallel)\n",
+    "histCalRaw = xcal.HistogramCalculator(sensorSize, bins=1000, \n",
+    "                                      range=[0, 10000], parallel=False, \n",
+    "                                      memoryCells=memoryCells, \n",
+    "                                      cores=cpuCores, blockSize=blockSize)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### First Iteration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Characterization of dark images with purpose to create dark maps (offset, noise and bad pixel maps) is an iterative process. Firstly, initial offset and noise maps are produced from raw dark data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:55:21.238009Z",
+     "start_time": "2018-12-06T10:54:54.586435Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "for data in reader.readChunks():\n",
+    "    data = np.bitwise_and(data.astype(np.uint16), 0b0011111111111111).astype(np.float32)\n",
+    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
+    "    data = data[:,:,dx != 0]\n",
+    "    histCalRaw.fill(data)\n",
+    "    #Filling calculators with data\n",
+    "    noiseCal.fill(data)\n",
+    "          \n",
+    "offsetMap = noiseCal.getOffset() #Produce offset map\n",
+    "noiseMap = noiseCal.get() #Produce noise map\n",
+    "noiseCal.reset() #Reset noise calculator\n",
+    "print(\"Initial maps were created\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:56:20.686534Z",
+     "start_time": "2018-12-06T10:56:11.721829Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#**************OFFSET MAP HISTOGRAM***********#\n",
+    "ho,co = np.histogram(offsetMap.flatten(), bins=700)\n",
+    "\n",
+    "do = {'x': co[:-1],\n",
+    "     'y': ho,\n",
+    "     'y_err': np.sqrt(ho[:]),\n",
+    "     'drawstyle': 'bars',\n",
+    "     'color': 'cornflowerblue',\n",
+    "     }\n",
+    "\n",
+    "fig = xana.simplePlot(do, figsize='1col', aspect=2, \n",
+    "                      x_label = 'Offset (ADU)', \n",
+    "                      y_label=\"Counts\", y_log=True,\n",
+    "                      )\n",
+    "                      \n",
+    "\n",
+    "#*****NOISE MAP HISTOGRAM FROM THE OFFSET CORRECTED DATA*******#\n",
+    "hn,cn = np.histogram(noiseMap.flatten(), bins=200)\n",
+    "\n",
+    "dn = {'x': cn[:-1],\n",
+    "     'y': hn,\n",
+    "     'y_err': np.sqrt(hn[:]),\n",
+    "     'drawstyle': 'bars',\n",
+    "     'color': 'cornflowerblue',\n",
+    "     }\n",
+    "\n",
+    "fig = xana.simplePlot(dn, figsize='1col', aspect=2, \n",
+    "                      x_label = 'Noise (ADU)', \n",
+    "                      y_label=\"Counts\", \n",
+    "                      y_log=True)\n",
+    "\n",
+    "\n",
+    "#**************HEAT MAPS*******************#\n",
+    "fig = xana.heatmapPlot(offsetMap[:,:,0],\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Offset (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmin=3000, vmax=4500)\n",
+    "\n",
+    "fig = xana.heatmapPlot(noiseMap[:,:,0],\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Noise (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmax=2*np.mean(noiseMap))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:56:22.741284Z",
+     "start_time": "2018-12-06T10:56:20.688393Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "## offset\n",
+    "\n",
+    "metadata = ConstantMetaData()\n",
+    "offset = Constants.CCD(DetectorTypes.fastCCD).Offset()\n",
+    "offset.data = offsetMap.data\n",
+    "metadata.calibration_constant = offset\n",
+    "\n",
+    "# set the operating condition\n",
+    "condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                integration_time=integration_time,\n",
+    "                                gain_setting=det_gain,\n",
+    "                                temperature=temperature_k,\n",
+    "                                pixels_x=1934,\n",
+    "                                pixels_y=960)\n",
+    "for parm in condition.parameters:\n",
+    "    if parm.name == \"Sensor Temperature\":\n",
+    "        parm.lower_deviation = temp_limits\n",
+    "        parm.upper_deviation = temp_limits\n",
+    "\n",
+    "device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "metadata.detector_condition = condition\n",
+    "\n",
+    "# specify the version for this constant\n",
+    "if creation_time is None:\n",
+    "    metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "else:\n",
+    "    metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
+    "metadata.calibration_constant_version.raw_data_location = file_loc\n",
+    "metadata.send(cal_db_interface)\n",
+    "\n",
+    "## noise\n",
+    "\n",
+    "metadata = ConstantMetaData()\n",
+    "noise = Constants.CCD(DetectorTypes.fastCCD).Noise()\n",
+    "noise.data = noiseMap.data\n",
+    "metadata.calibration_constant = noise\n",
+    "\n",
+    "# set the operating condition\n",
+    "condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                integration_time=integration_time,\n",
+    "                                gain_setting=det_gain,\n",
+    "                                temperature=temperature_k,\n",
+    "                                pixels_x=1934,\n",
+    "                                pixels_y=960)\n",
+    "\n",
+    "for parm in condition.parameters:\n",
+    "    if parm.name == \"Sensor Temperature\":\n",
+    "        parm.lower_deviation = temp_limits\n",
+    "        parm.upper_deviation = temp_limits\n",
+    "\n",
+    "\n",
+    "device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "metadata.detector_condition = condition\n",
+    "\n",
+    "# specify the a version for this constant\n",
+    "if creation_time is None:\n",
+    "    metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "else:\n",
+    "    metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
+    "metadata.calibration_constant_version.raw_data_location = file_loc\n",
+    "metadata.send(cal_db_interface)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from cal_tools.enums import BadPixels\n",
+    "bad_pixels = np.zeros(offsetMap.shape, np.uint32)\n",
+    "mnoffset = np.nanmedian(offsetMap)\n",
+    "stdoffset = np.nanstd(offsetMap)\n",
+    "bad_pixels[(offsetMap < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
+    "           (offsetMap > mnoffset+bad_pixel_offset_sigma*stdoffset)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
+    "\n",
+    "mnnoise = np.nanmedian(noiseMap)\n",
+    "stdnoise = np.nanstd(noiseMap)\n",
+    "bad_pixels[(noiseMap < mnnoise-bad_pixel_noise_sigma*stdnoise) | \n",
+    "           (noiseMap > mnnoise+bad_pixel_noise_sigma*stdnoise)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
+    "\n",
+    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Bad Pixel Value (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmin=0, vmax=32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "metadata = ConstantMetaData()\n",
+    "badpix = Constants.CCD(DetectorTypes.fastCCD).BadPixelsDark()\n",
+    "badpix.data = bad_pixels.data\n",
+    "metadata.calibration_constant = badpix\n",
+    "\n",
+    "# set the operating condition\n",
+    "condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                integration_time=integration_time,\n",
+    "                                gain_setting=det_gain,\n",
+    "                                temperature=temperature_k,\n",
+    "                                pixels_x=1934,\n",
+    "                                pixels_y=960)\n",
+    "\n",
+    "for parm in condition.parameters:\n",
+    "    if parm.name == \"Sensor Temperature\":\n",
+    "        parm.lower_deviation = temp_limits\n",
+    "        parm.upper_deviation = temp_limits\n",
+    "\n",
+    "\n",
+    "device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "metadata.detector_condition = condition\n",
+    "\n",
+    "# specify the a version for this constant\n",
+    "if creation_time is None:\n",
+    "    metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "else:\n",
+    "    metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
+    "metadata.calibration_constant_version.raw_data_location = file_loc\n",
+    "metadata.send(cal_db_interface)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "histCalCorr = xcal.HistogramCalculator(sensorSize, bins=200, \n",
+    "                                      range=[-200, 200], parallel=False, \n",
+    "                                      memoryCells=memoryCells, \n",
+    "                                      cores=cpuCores, blockSize=blockSize)\n",
+    "\n",
+    "\n",
+    "for data in reader.readChunks():\n",
+    "    data = np.bitwise_and(data.astype(np.uint16), 0b0011111111111111).astype(np.float32)\n",
+    "    data -= offsetMap.data\n",
+    "    histCalCorr.fill(data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ho,eo,co,so = histCalCorr.get()\n",
+    "\n",
+    "\n",
+    "d = [{'x': co,\n",
+    "      'y': ho,\n",
+    "      'y_err': np.sqrt(ho[:]),\n",
+    "      'drawstyle': 'steps-mid',\n",
+    "      'errorstyle': 'bars',\n",
+    "      'errorcoarsing': 2,\n",
+    "      'label': 'Offset corr.'\n",
+    "     },\n",
+    "    \n",
+    "     ]\n",
+    "     \n",
+    "\n",
+    "fig = xana.simplePlot(d, aspect=1, x_label='Energy(ADU)', \n",
+    "                      y_label='Number of occurrences', figsize='2col',\n",
+    "                      y_log=True, x_range=(-50,500),\n",
+    "                      legend='top-center-frame-2col')"
+   ]
+  },
+  {
+   "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.7"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb b/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb
new file mode 100644
index 000000000..001a9c3ea
--- /dev/null
+++ b/notebooks/FastCCD/Characterize_Darks_NewDAQ_FastCCD_NBC_New_Common_Mode.ipynb
@@ -0,0 +1,1016 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# FastCCD Dark Characterization\n",
+    "\n",
+    "Author: I. Klačková, S. Hauf, K. Setoodehnia and M. Cascella\n",
+    "\n",
+    "The following notebook provides dark image analysis of the FastCCD detector.\n",
+    "\n",
+    "Dark characterization evaluates offset and noise of the FastCCD detector, corrects the noise for Common Mode (CM), and defines bad pixels relative to offset and CM corrected noise. Bad pixels are then excluded and CM corrected noise is recalculated excluding the bad pixels. Resulting offset and CM corrected noise maps, as well as the bad pixel map are sent to the calibration database."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:38.999974Z",
+     "start_time": "2018-12-06T10:54:38.983406Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Initial Parameters:\n",
+    "\n",
+    "in_folder = \"/gpfs/exfel/exp/SCS/201930/p900074/raw\" # input folder, required\n",
+    "out_folder = '/gpfs/exfel/data/scratch/setoodeh/DarkRuns' # output folder, required\n",
+    "path_template = 'RAW-R{:04d}-{}-S{{:05d}}.h5' # the template to use to access data\n",
+    "path_inset = 'DA05'\n",
+    "run = 351 # which run to read data from, required\n",
+    "number_dark_frames = 0 # number of images to be used, if set to 0 all available images are used\n",
+    "cluster_profile = \"noDB\" # ipcluster profile to use\n",
+    "# The two operation modes for FastCCD have fixed names which cannot be changed:\n",
+    "operation_mode = \"FF\" # FS stands for frame-store and FF for full-frame opeartion. \n",
+    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image/pixels' # path to the data in the HDF5 file \n",
+    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value'  # path to find temperature\n",
+    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # path to find control data\n",
+    "cal_db_interface = \"tcp://max-exfl016:8020\" # the calibration database interface to use\n",
+    "cal_db_timeout = 300000 # timeout on calibration database requests\n",
+    "temp_limits = 5 # to find calibration constants later on, the sensor temperature is allowed to vary by 5 units\n",
+    "sequence = 0 # sequallence file to use\n",
+    "use_dir_creation_date = True # To be used to retrieve calibration constants later on (for database time derivation)\n",
+    "bad_pixel_offset_sigma = 5. # Any pixel whose offset is beyond 5 standard deviations, is a bad pixel\n",
+    "bad_pixel_noise_sigma = 5. # Any pixel whose noise is beyond 5 standard deviations, is a bad pixel\n",
+    "sigmaNoise = 5. # Any pixel whose signal exceeds 'sigmaNoise'*noiseCM (common mode corrected noise) will be masked\n",
+    "fix_temperature = 0. # Fixed operation temperature in Kelvins. If set to 0, mean value of the data file's temperature is used.\n",
+    "chunkSize = 100 # Number of images to read per chunk\n",
+    "cpuCores = 40 # Specifies the number of running cpu cores\n",
+    "commonModeAxis = 1 # Axis along which common mode will be calculated (0: along rows, 1: along columns)\n",
+    "ADU_to_electron_upper = 6.1 # According to Table 6.1 of Ivana Klačková's master's thesis, for upper hemisphere: conversion\n",
+    "                            # gain is 1 ADU = 6.1e-\n",
+    "ADU_to_electron_lower = 6.2 # and for lower hemisphere: conversion gain is 1 ADU = 6.2e-\n",
+    "run_parallel = True # For parallel computation \n",
+    "db_output = True # Output constants to the calibration database"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:39.467334Z",
+     "start_time": "2018-12-06T10:54:39.427784Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Required Packages:\n",
+    "\n",
+    "import copy\n",
+    "import datetime\n",
+    "import os\n",
+    "import time\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "import h5py\n",
+    "from IPython.display import display, Markdown\n",
+    "import matplotlib.pyplot as plt\n",
+    "%matplotlib inline\n",
+    "import numpy as np\n",
+    "from prettytable import PrettyTable\n",
+    "\n",
+    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
+    "from iCalibrationDB.detectors import DetectorTypes\n",
+    "from cal_tools.tools import get_dir_creation_date\n",
+    "from cal_tools.enums import BadPixels\n",
+    "from XFELDetAna import xfelpyanatools as xana\n",
+    "from XFELDetAna import xfelpycaltools as xcal\n",
+    "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
+    "from XFELDetAna.util import env\n",
+    "env.iprofile = cluster_profile\n",
+    "import XFELDetAna.xfelprofiler as xprof\n",
+    "profiler = xprof.Profiler()\n",
+    "profiler.disable()\n",
+    "from XFELDetAna.xfelreaders import ChunkReader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:39.467334Z",
+     "start_time": "2018-12-06T10:54:39.427784Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Output Folder Creation:\n",
+    "if not os.path.exists(out_folder):\n",
+    "    os.makedirs(out_folder)\n",
+    "\n",
+    "# Number of Images:\n",
+    "def nImagesOrLimit(nImages, limit):\n",
+    "    if limit == 0:\n",
+    "        return nImages\n",
+    "    else:\n",
+    "        return min(nImages, limit)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "proposal = list(filter(None, in_folder.strip('/').split('/')))[-2]\n",
+    "file_loc = 'proposal:{} runs:{}'.format(proposal, run)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:40.058101Z",
+     "start_time": "2018-12-06T10:54:40.042615Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Detector Operation Mode, Calibration Database Settings, and Some Initial Run Parameters & Paths:\n",
+    "\n",
+    "display(Markdown('### Initial Settings'))\n",
+    "if operation_mode == \"FS\":\n",
+    "    x = 960 # rows of the FastCCD to analyze in FS mode \n",
+    "    y = 960 # columns of the FastCCD to analyze in FS mode \n",
+    "    print('\\nYou are analyzing data in FS mode.')\n",
+    "else:\n",
+    "    x = 1934 # rows of the FastCCD to analyze in FF mode \n",
+    "    y = 960 # columns of the FastCCD to analyze in FF mode\n",
+    "    print('\\nYou are analyzing data in FF mode.')\n",
+    "    \n",
+    "ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
+    "fp_name = path_template.format(run, path_inset)\n",
+    "fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
+    "filename = fp_path.format(sequence)\n",
+    "\n",
+    "creation_time = None\n",
+    "if use_dir_creation_date:\n",
+    "    creation_time = get_dir_creation_date(in_folder, run)\n",
+    "        \n",
+    "print('Calibration database Interface: {}'.format(cal_db_interface))\n",
+    "print(\"Sending constants to the calibration database: {}\".format(db_output))\n",
+    "print(\"HDF5 path to data: {}\".format(h5path))\n",
+    "print(\"Run number: {}\".format(run))\n",
+    "print(\"Reading data from: {}\".format(filename))\n",
+    "if creation_time:\n",
+    "    print(\"Using {} as creation time\".format(creation_time.isoformat()))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:40.555804Z",
+     "start_time": "2018-12-06T10:54:40.452978Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Reading Parameters such as Detector Bias, Gain, etc. from the Data:\n",
+    "\n",
+    "memoryCells = 1 # FastCCD has 1 memory cell\n",
+    "sensorSize = [x, y]\n",
+    "blockSize = [sensorSize[0]//2, sensorSize[1]] # Sensor area will be analysed according to blocksize\n",
+    "xcal.defaultBlockSize = blockSize\n",
+    "nImages = fastccdreaderh5.getDataSize(filename, h5path)[0] # Specifies total number of images to proceed\n",
+    "nImages = nImagesOrLimit(nImages, number_dark_frames)\n",
+    "profile = False\n",
+    "gain_setting = None\n",
+    "\n",
+    "with h5py.File(filename, 'r') as f:\n",
+    "    bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
+    "    det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
+    "    integration_time = int(f['{}/acquisitionTime/value'.format(h5path_cntrl)][0])\n",
+    "    temperature = np.mean(f[h5path_t])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:40.555804Z",
+     "start_time": "2018-12-06T10:54:40.452978Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Printing the Parameters Read from the Data File:\n",
+    "\n",
+    "display(Markdown('### Evaluated Parameters'))\n",
+    "print(\"Number of dark images to analyze:\",nImages)   \n",
+    "\n",
+    "if det_gain == 8:\n",
+    "    gain_setting = \"high\"\n",
+    "elif det_gain == 2:\n",
+    "    gain_setting = \"medium\"\n",
+    "elif det_gain == 1:\n",
+    "    gain_setting = \"low\"\n",
+    "else:\n",
+    "    gain_setting = \"auto\"\n",
+    "\n",
+    "print(\"Bias voltage is {} V\".format(bias_voltage))\n",
+    "print(\"Detector gain is set to x{}\".format(det_gain), \"({} gain)\".format(gain_setting))\n",
+    "print(\"Detector integration time is set to {}\".format(integration_time), 'ms')\n",
+    "\n",
+    "if fix_temperature != 0.:\n",
+    "    print(\"Using a fixed temperature of {} K\".format(fix_temperature))\n",
+    "else:\n",
+    "    # This is needed while sending the \n",
+    "    # calibration constant to the DB later\n",
+    "    fix_temperature = temperature + 273.15\n",
+    "    print(\"Temperature is not fixed.\")\n",
+    "    print(\"Mean temperature was {:0.2f} °C / {:0.2f} K\".format(temperature, fix_temperature))\n",
+    "\n",
+    "print(\"Output: {}\".format(out_folder))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:41.899511Z",
+     "start_time": "2018-12-06T10:54:41.864816Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Reading Files in Chunks:\n",
+    "\n",
+    "# Chunk reader returns an iterator to access the data in the file within the ranges:\n",
+    "\n",
+    "reader = ChunkReader(filename, fastccdreaderh5.readData, nImages, chunkSize, path = h5path, pixels_x = sensorSize[0],\n",
+    "                     pixels_y = sensorSize[1],)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:54:41.899511Z",
+     "start_time": "2018-12-06T10:54:41.864816Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Calculator:\n",
+    "\n",
+    "# noiseCal is a noise map calculator, which internally also produces a per-pixel mean map, i.e. an offset map: \n",
+    "    \n",
+    "noiseCal = xcal.NoiseCalculator(sensorSize, memoryCells, cores=cpuCores, blockSize=blockSize, runParallel=run_parallel)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### First Iteration\n",
+    "\n",
+    "Characterization of dark images with purpose to create dark maps (offset, noise and bad pixel maps) is an iterative process. Firstly, initial offset and noise maps are produced from raw dark data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T10:55:21.238009Z",
+     "start_time": "2018-12-06T10:54:54.586435Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "for data in reader.readChunks():\n",
+    "    data = np.bitwise_and(data.astype(np.uint16), 0b0011111111111111).astype(np.float32)\n",
+    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
+    "    data = data[:,:,dx != 0]\n",
+    "    noiseCal.fill(data) # Filling calculators with data\n",
+    "          \n",
+    "offsetMap = noiseCal.getOffset() # Producing offset map\n",
+    "noiseMap = noiseCal.get() # Producing noise map\n",
+    "noiseCal.reset() # Resetting noise calculator\n",
+    "print(\"Initial maps are created.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Offset and Noise Maps prior to Common Mode Correction\n",
+    "\n",
+    "In the following, the histogram of the FastCCD offset, FastCCD offset map, as well as the initial uncorrected noise map are plotted:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#************** OFFSET MAP HISTOGRAM ***********#\n",
+    "ho,co = np.histogram(offsetMap.flatten(), bins=700) # ho = offset histogram; co = offset bin centers\n",
+    "do = {'x': co[:-1],\n",
+    "     'y': ho,\n",
+    "     'y_err': np.sqrt(ho[:]),\n",
+    "     'drawstyle': 'bars',\n",
+    "     'color': 'cornflowerblue',\n",
+    "     'label': 'Raw Signal (ADU)'\n",
+    "     }\n",
+    "fig = xana.simplePlot(do, figsize='1col', aspect=1, x_label = 'Raw Signal (ADU)', y_label=\"Counts\", \n",
+    "                      x_range = (3400,4000), title = 'Offset Histogram')\n",
+    "#fig.savefig('Offset_Hist.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
+    "\n",
+    "t0 = PrettyTable()\n",
+    "t0.title = \"Raw Signal\"\n",
+    "t0.field_names = [\"Mean\",\"Median\", \"Standard Deviation\"]\n",
+    "t0.add_row([\"{:0.3f} (ADU)\".format(np.mean(data)), \"{:0.3f} (ADU)\".format(np.median(data)), \"{:0.3f} (ADU)\".format(np.std(data))])\n",
+    "print(t0,'\\n')\n",
+    "\n",
+    "#************** OffsetMAP *******************#\n",
+    "fig = xana.heatmapPlot(offsetMap[:,:,0], x_label='Column Number', y_label='Row Number',  aspect=1,\n",
+    "                       x_range=(0,y), y_range=(0,x), vmin=3000, vmax=4300, lut_label='Offset (ADU)', \n",
+    "                       panel_x_label='Columns Stat (ADU)', panel_y_label='Rows Stat (ADU)', \n",
+    "                       panel_top_low_lim = 3000, panel_top_high_lim = 4500, panel_side_low_lim = 3000, \n",
+    "                       panel_side_high_lim = 5000, title = 'OffsetMap')\n",
+    "#fig.savefig('RawOffsetMap.pdf', format='pdf', dpi=400, bbox_inches='tight')\n",
+    "\n",
+    "#************** Raw NoiseMAP *******************#\n",
+    "fig = xana.heatmapPlot(noiseMap[:,:,0], x_label='Column Number', y_label='Row Number', aspect=1,\n",
+    "                       lut_label='Uncorrected Noise (ADU)', x_range=(0,y),\n",
+    "                       y_range=(0,x), vmax=2*np.mean(noiseMap), panel_x_label='Columns Stat (ADU)', \n",
+    "                       panel_y_label='Rows Stat (ADU)', panel_top_low_lim = 0, panel_top_high_lim = 20, \n",
+    "                       panel_side_low_lim = 0, panel_side_high_lim = 50, title = 'Uncorrected NoiseMap')\n",
+    "#fig.savefig('RawNoiseMap.pdf', format='pdf', dpi=400, bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Offset Correction:\n",
+    "\n",
+    "offsetCorrection = xcal.OffsetCorrection(sensorSize, offsetMap, nCells = memoryCells, cores=cpuCores, gains=None,\n",
+    "                                         runParallel=run_parallel, blockSize=blockSize)\n",
+    "\n",
+    "offsetCorrection.debug()\n",
+    "\n",
+    "# Common Mode Correction:\n",
+    "# This is the new method subtracting the median of all pixels that are read out at the same time along a row:\n",
+    "cmCorrection = xcal.CommonModeCorrection([data.shape[0], data.shape[1]], [data.shape[0]//2, data.shape[1]], \n",
+    "                                         commonModeAxis, parallel=False, dType=np.float32, stride=10,\n",
+    "                                         noiseMap=noiseMap.astype(np.float32), minFrac=0)\n",
+    "\n",
+    "cmCorrection.debug()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Histogram Calculators:\n",
+    "\n",
+    "# For offset corrected data:\n",
+    "histCalCorrected = xcal.HistogramCalculator(sensorSize, bins=600, range=[-200, 200], memoryCells=memoryCells, \n",
+    "                                            cores=cpuCores, gains=None, blockSize=blockSize)\n",
+    "# For common mode corrected data:\n",
+    "histCalCMCorrected = xcal.HistogramCalculator(sensorSize, bins=600, range=[-200, 200], memoryCells=memoryCells, \n",
+    "                                              cores=cpuCores, gains=None, blockSize=blockSize)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Second Iteration\n",
+    "\n",
+    "During the second iteration, the data are offset corrected and then common mode corrected to produced a common mode corrected noise map. The common mode correction is calculated by subtracting out the median of all pixels that are read out at the same time along a row."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for data in reader.readChunks():\n",
+    "    \n",
+    "    data = data.astype(np.float32)\n",
+    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
+    "    data = data[:,:,dx != 0] \n",
+    "    data = offsetCorrection.correct(data) # Offset correction\n",
+    "    offset_corr_data = copy.copy(data) # I am copying this so that I can have access to it in the table below \n",
+    "    histCalCorrected.fill(data)\n",
+    "    cellTable=np.zeros(data.shape[2], np.int32) # Common mode correction\n",
+    "    data = cmCorrection.correct(data.astype(np.float32), cellTable=cellTable) # Common mode correction\n",
+    "    histCalCMCorrected.fill(data)\n",
+    "    noiseCal.fill(data)  # Filling noise calculator with common mode (CM) corrected data\n",
+    "    \n",
+    "noiseMapCM = noiseCal.get() # Produces CM corrected noise map\n",
+    "ho, eo, co , so = histCalCorrected.get()\n",
+    "hCM, eCM, cCM ,sCM = histCalCMCorrected.get()\n",
+    "print(\"Offset and common mode corrections are applied.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# I am copying these so that I can replot them later after the calculators are reset:\n",
+    "\n",
+    "ho_second_trial = copy.copy(ho)\n",
+    "co_second_trial = copy.copy(co)\n",
+    "hCM_second_trial = copy.copy(hCM)\n",
+    "cCM_second_trial = copy.copy(cCM)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Signal after Offset and Common Mode Corrections\n",
+    "\n",
+    "Here, the offset corrected signal is compared to the common-mode corrected signal (in the form of binned histograms):  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "do = [{'x': co,\n",
+    "     'y': ho,\n",
+    "     'y_err': np.sqrt(ho[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'cornflowerblue',\n",
+    "     'label': 'Offset Corrected Signal'\n",
+    "     },\n",
+    "     {'x': cCM,\n",
+    "     'y': hCM,\n",
+    "     'y_err': np.sqrt(hCM[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'red',\n",
+    "     'label': 'Common Mode Corrected Signal'\n",
+    "     }]\n",
+    "      \n",
+    "fig = xana.simplePlot(do, figsize='2col', aspect=1, x_label = 'Corrected Signal (ADU)', y_label=\"Counts\", \n",
+    "                      x_range = (-20,20), legend='top-right-frame-1col', title = 'Corrected Signal - 2nd Iteration')\n",
+    "#fig.savefig('Corrected_Signal_Hist_1.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
+    "\n",
+    "t0 = PrettyTable()\n",
+    "t0.title = \"Comparison of the First Round of Corrections - Bad Pixels Included\"\n",
+    "t0.field_names = [\"After Offset Correction\",\"After Common Mode Correction\"]\n",
+    "t0.add_row([\"Mean: {:0.3f} (ADU)\".format(np.mean(offset_corr_data)), \"Mean: {:0.3f} (ADU)\".format(np.mean(data))])\n",
+    "t0.add_row([\"Median: {:0.3f} (ADU)\".format(np.median(offset_corr_data)), \"Median: {:0.3f} (ADU)\".format(np.median(data))])\n",
+    "t0.add_row([\"Standard Deviation: {:0.3f} (ADU)\".format(np.std(offset_corr_data)), \"Standard Deviation: {:0.3f} (ADU)\".format(np.std(data))])\n",
+    "print(t0,'\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Noise Map after Common Mode Correction\n",
+    "\n",
+    "In the following, the effect of common mode correction on the noise is shown. Finally common mode corrected noise map (noiseMapCM) is displayed and compared to the initial uncorrected noise map:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#*****NOISE MAP HISTOGRAM FROM THE COMMON MODE CORRECTED DATA*******#\n",
+    "hn,cn = np.histogram(noiseMap.flatten(), bins=200, range=(2,40)) # hn: histogram of noise, cn: bin centers for noise\n",
+    "hn_CM,cn_CM = np.histogram(noiseMapCM.flatten(), bins=200, range=(2,40))\n",
+    "\n",
+    "dn = [{'x': cn[:-1],\n",
+    "     'y': hn,\n",
+    "     #'y_err': np.sqrt(hn[:]),\n",
+    "     'drawstyle': 'steps-mid',#'bars',\n",
+    "     'color': 'blue',#'cornflowerblue',\n",
+    "     'label': 'Uncorrected Noise'\n",
+    "     },\n",
+    "    {'x': cn_CM[:-1],\n",
+    "     'y': hn_CM,\n",
+    "     #'y_err': np.sqrt(hn_CM[:]),\n",
+    "     'drawstyle': 'steps-mid',#'bars',\n",
+    "     'color': 'crimson',#'red',#'cornflowerblue',\n",
+    "     #'ecolor': 'crimson',\n",
+    "     'label': 'Common Mode Corrected Noise'\n",
+    "     }]\n",
+    "fig = xana.simplePlot(dn, figsize='2col', aspect=1, x_label = 'Noise (ADU)', y_label=\"Counts\", \n",
+    "                      x_range=(0,40), y_range=(0,1e6), y_log=True, legend='top-center-frame-1col',\n",
+    "                      title = 'Noise Comparison')\n",
+    "\n",
+    "#fig.savefig('Noise_CM_1_Hist.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
+    "\n",
+    "fig = xana.heatmapPlot(noiseMapCM[:,:,0], aspect=1, x_label='Column Number', y_label='Row Number',\n",
+    "                       lut_label='Common Mode Corrected Noise (ADU)', x_range=(0,y), y_range=(0,x), \n",
+    "                       vmax=2*np.mean(noiseMapCM), panel_top_low_lim = 0, panel_top_high_lim = 20, panel_side_low_lim = 0,\n",
+    "                       panel_side_high_lim = 50, title = 'Common Mode Corrected Noise', \n",
+    "                       panel_x_label='Columns Stat (ADU)', panel_y_label='Rows Stat (ADU)')\n",
+    "\n",
+    "#fig.savefig('NoiseMapCM.pdf', format='pdf', dpi=400, bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Resetting the calculators so we can do a third iteration later:\n",
+    "\n",
+    "noiseCal.reset()\n",
+    "histCalCorrected.reset()\n",
+    "histCalCMCorrected.reset()\n",
+    "cmCorrection.reset()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Initial BadPixelMap\n",
+    "This is generated based on the offset and CM corrected noise maps:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bad_pixels = np.zeros(offsetMap.shape, np.uint32)\n",
+    "mnoffset = np.nanmedian(offsetMap)\n",
+    "stdoffset = np.nanstd(offsetMap)\n",
+    "bad_pixels[(offsetMap < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
+    "           (offsetMap > mnoffset+bad_pixel_offset_sigma*stdoffset)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
+    "\n",
+    "mnnoise = np.nanmedian(noiseMapCM)\n",
+    "stdnoise = np.nanstd(noiseMapCM)\n",
+    "bad_pixels[(noiseMapCM < mnnoise-bad_pixel_noise_sigma*stdnoise) | \n",
+    "           (noiseMapCM > mnnoise+bad_pixel_noise_sigma*stdnoise)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
+    "\n",
+    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),aspect=1, x_label='Column Number', y_label='Row Number', \n",
+    "                       lut_label='2^(Assigned Value to Bad Pixels)', x_range=(0,y), y_range=(0,x), \n",
+    "                       title = 'Bad Pixels Map Excluding Non-Sensitive Areas', panel_x_label= 'Columns Stat', \n",
+    "                       panel_y_label='Rows Stat')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we are adding the pixels in the hole (center of the FastCCD) as well as 4 rows in the center of the detector, which we call overscan region:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_circular_mask(h, w, center=None, radius=None):\n",
+    "\n",
+    "    import numpy as np\n",
+    "    import math\n",
+    "    \n",
+    "    if center is None: # use the middle of the image\n",
+    "        center = [int(w/2), int(h/2)]\n",
+    "    if radius is None: # use the smallest distance between the center and image walls\n",
+    "        radius = min(center[0], center[1], w-center[0], h-center[1])\n",
+    "\n",
+    "    Y, X = np.ogrid[:h, :w]\n",
+    "    dist_from_center = np.sqrt((X - center[0])**2 + (Y-center[1])**2)\n",
+    "\n",
+    "    mask = dist_from_center < radius\n",
+    "    return mask"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mask = np.zeros(offsetMap.shape, np.uint32)\n",
+    "\n",
+    "\n",
+    "# Defining a circular mask + a rectangular mask (overscan) for the hole in the middle of the CCD:\n",
+    "h, w = (x,y)\n",
+    "hole_mask_bool = create_circular_mask(h-4, w, radius=61.5, center=(w//2,(h-4)//2))\n",
+    "hole_mask = np.zeros(hole_mask_bool.shape, np.uint32)\n",
+    "hole_mask[hole_mask_bool] = BadPixels.NON_SENSITIVE.value\n",
+    "\n",
+    "overscan_mask = np.full((4, w), BadPixels.OVERSCAN.value) \n",
+    "\n",
+    "mask[:,:,0] = np.insert(hole_mask, (h-4)//2, overscan_mask, 0)  \n",
+    "\n",
+    "# Assigning this masked area as bad pixels:\n",
+    "bad_pixels = np.bitwise_or(bad_pixels, mask)\n",
+    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),aspect=1, x_label='Column Number', y_label='Row Number', \n",
+    "                       lut_label='2^(Assigned Value to Bad Pixels)', x_range=(0,y), y_range=(0,x), panel_top_low_lim = 0, \n",
+    "                       panel_top_high_lim = 20, panel_side_low_lim = 0, panel_side_high_lim = 20, \n",
+    "                       title = 'Bad Pixels Map Including Non-Sensitive Areas', panel_x_label='Columns Stat', \n",
+    "                       panel_y_label='Rows Stat', vmax=20)\n",
+    "\n",
+    "#fig.savefig('BadPixelMap_1.svg', format='svg', dpi=1200, bbox_inches='tight') "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Third Iteration\n",
+    "\n",
+    "During the third iteration, the bad pixel map is applied to the data. Bad pixels are masked. Offset and common mode corrections are applied once again to the data, which now have bad pixdels excluded, to produce a common mode corrected noise map:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# bad_pixels is an array of (1934, 960, 1) filled with zeros except at indices where we have the actual bad pixels, whose\n",
+    "# values are set to be: 2 (2^1: BadPixels.OFFSET_OUT_OF_THRESHOLD.value), or\n",
+    "# 262144 (2^18: BadPixels.OVERSCAN.value), or 524288 (2^19: BadPixels.NON_SENSITIVE.value). These indices can be found\n",
+    "# using np.argwhere(bad_pixels != 0)\n",
+    "\n",
+    "event_threshold = sigmaNoise*np.median(noiseMapCM) # for exclusion of possible cosmic ray events\n",
+    "noiseCal.setBadPixelMask(bad_pixels != 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for data in reader.readChunks():\n",
+    "    data = data.astype(np.float32)\n",
+    "    dx = np.count_nonzero(data, axis=(0, 1))\n",
+    "    data = data[:,:,dx != 0]\n",
+    "    data_copy = offsetCorrection.correct(copy.copy(data))\n",
+    "    cellTable=np.zeros(data_copy.shape[2], np.int32)\n",
+    "    data_copy = cmCorrection.correct(data_copy.astype(np.float32), cellTable=cellTable)\n",
+    "    data[data_copy > event_threshold] = np.nan # cosmic rays\n",
+    "    data = np.ma.MaskedArray(data, np.isnan(data), fill_value=0) # masking cosmics, the default fill_value is 1e+20 \n",
+    "    data = offsetCorrection.correct(data)\n",
+    "    offset_corr_data2 = copy.copy(data) # I am copying this so that I can have access to it in the table below\n",
+    "    histCalCorrected.fill(data)\n",
+    "    cellTable=np.zeros(data.shape[2], np.int32)\n",
+    "    data = cmCorrection.correct(data.astype(np.float32), cellTable=cellTable)\n",
+    "    histCalCMCorrected.fill(data)\n",
+    "    noiseCal.fill(data) \n",
+    "\n",
+    "noiseMapCM_2nd = noiseCal.get().filled(0) # the masked pixels are filled with zero\n",
+    "ho2, eo2, co2, so2 = histCalCorrected.get()\n",
+    "hCM2, eCM2, cCM2 ,sCM2 = histCalCMCorrected.get()\n",
+    "print(\"Final iteration is Performed.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plots of the Final Results\n",
+    "\n",
+    "The following plot and table compare the offset and common mode corrected signal with and without the bad pixels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "do_Final = [{'x': co_second_trial,\n",
+    "     'y': ho_second_trial,\n",
+    "     'y_err': np.sqrt(ho_second_trial[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'blue',#'cornflowerblue',\n",
+    "     'errorstyle': 'bars',\n",
+    "     'label': 'Offset Corrected Signal, Bad Pixels Included - 2nd Trial'\n",
+    "     },\n",
+    "    {'x': cCM_second_trial,\n",
+    "     'y': hCM_second_trial,\n",
+    "     'y_err': np.sqrt(hCM_second_trial[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'red',\n",
+    "     'errorstyle': 'bars',\n",
+    "     'ecolor': 'crimson',\n",
+    "     'label': 'Common Mode Corrected Signal, Bad Pixels Included - 2nd Trial' \n",
+    "     },\n",
+    "    {'x': co2,\n",
+    "     'y': ho2,\n",
+    "     'y_err': np.sqrt(ho2[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'black', #'cornflowerblue',\n",
+    "     'errorstyle': 'bars',\n",
+    "     'label': 'Offset Corrected Signal, Bad Pixels Excluded - 3rd Trial'\n",
+    "     },\n",
+    "    {'x': cCM2,\n",
+    "     'y': hCM2,\n",
+    "     'y_err': np.sqrt(hCM2[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'orange', #'cornflowerblue',\n",
+    "     'errorstyle': 'bars',\n",
+    "     'label': 'Common Mode Corrected Signal, Bad Pixels Excluded - 3rd Trial'\n",
+    "     }]\n",
+    "\n",
+    "fig = xana.simplePlot(do_Final, figsize='2col', aspect=1, x_label = 'Corrected Signal (ADU)', \n",
+    "                      y_label=\"Counts (Logarithmic Scale)\", y_log=True, x_range=(-40,40), legend='bottom-left-frame-1col',\n",
+    "                      title = 'Comparison of Corrected Signal')\n",
+    "#fig.savefig('Corrected_Signal_Hist_2.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
+    "\n",
+    "# offset_corr_data2 and data most likely have some nan's => I am going to use nanmean, nanmedian and nanstd functions:\n",
+    "t0 = PrettyTable()\n",
+    "t0.title = \"Comparison of the Second Round of Corrections - Bad Pixels Excluded\"\n",
+    "t0.field_names = [\"After Offset Correction\",\"After Common Mode Correction\"]\n",
+    "t0.add_row([\"Mean: {:0.3f} (ADU)\".format(np.nanmean(offset_corr_data2)), \"Mean: {:0.3f} (ADU)\".format(np.nanmean(data))])\n",
+    "t0.add_row([\"Median: {:0.3f} (ADU)\".format(np.nanmedian(offset_corr_data2)), \"Median: {:0.3f} (ADU)\".format(np.nanmedian(data))])\n",
+    "t0.add_row([\"Standard Deviation: {:0.3f} (ADU)\".format(np.nanstd(offset_corr_data2)), \"Standard Deviation: {:0.3f} (ADU)\".format(np.nanstd(data))])\n",
+    "print(t0,'\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Final NoiseMap\n",
+    "\n",
+    "The effect of exclusion of bad pixels on common mode corrected noise is shown below. Finally common mode corrected noise map with bad pixels excluded (noiseMapCM_2nd) is displayed:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "#*****NOISE MAP HISTOGRAM FROM THE COMMON MODE CORRECTED DATA*******#\n",
+    "hn_CM2,cn_CM2 = np.histogram(noiseMapCM_2nd.flatten(), bins=200, range=(2,40))\n",
+    "\n",
+    "dn2 = [{'x': cn[:-1],\n",
+    "     'y': hn,\n",
+    "     #'y_err': np.sqrt(hn[:]),\n",
+    "     'drawstyle': 'steps-mid',#'bars',\n",
+    "     'color': 'blue', #'cornflowerblue',\n",
+    "     'label': 'Uncorrected Noise'\n",
+    "     },\n",
+    "    {'x': cn_CM[:-1],\n",
+    "     'y': hn_CM,\n",
+    "     #'y_err': np.sqrt(hn_CM[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'red',\n",
+    "     #'ecolor': 'crimson',\n",
+    "     'label': 'Common Mode Corrected Noise prior to Bad Pixels Exclusion'\n",
+    "     },\n",
+    "    {'x': cn_CM2[:-1],\n",
+    "     'y': hn_CM2,\n",
+    "     #'y_err': np.sqrt(hn_CM2[:]),\n",
+    "     'drawstyle': 'steps-mid',\n",
+    "     'color': 'black', #'cornflowerblue',\n",
+    "     'label': 'Common Mode Corrected Noise after Bad Pixels Exclusion'\n",
+    "     }]\n",
+    "\n",
+    "fig = xana.simplePlot(dn2, figsize='2col', aspect = 1, x_label = 'Noise (ADU)', y_label=\"Counts\", y_log=True, \n",
+    "                      x_range=(0,40), y_range=(0,1e6), legend='top-right-frame-1col', title = 'Final Noise Comparison')\n",
+    "\n",
+    "#fig.savefig('Noise_Hist_2.svg', format='svg', dpi=1200, bbox_inches='tight') \n",
+    "\n",
+    "fig = xana.heatmapPlot(np.log2(noiseMapCM_2nd[:,:,0]), aspect=1, x_label='Column Number', y_label='Row Number',\n",
+    "                       lut_label='Noise (ADU)', x_range=(0,y), y_range=(0,x), vmax=2*np.mean(noiseMapCM_2nd), \n",
+    "                       title = 'Final Common Mode Corrected Noise (Bad Pixels Excluded)', \n",
+    "                       panel_x_label='Columns Stat (ADU)', panel_y_label='Rows Stat (ADU)')\n",
+    "#fig.savefig('NoiseMapCM_2nd.pdf', format='pdf', dpi=400, bbox_inches='tight') "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Final Bad Pixel Map\n",
+    "\n",
+    "Lastly, the final bad pixel map is generated based on the OffsetMap and the noiseMapCM_2nd (common mode corrected noise after exclusion of the initial bad pixels):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "bad_pixels = np.zeros(offsetMap.shape, np.uint32)\n",
+    "mnoffset = np.nanmedian(offsetMap)\n",
+    "stdoffset = np.nanstd(offsetMap)\n",
+    "bad_pixels[(offsetMap < mnoffset-bad_pixel_offset_sigma*stdoffset) | \n",
+    "           (offsetMap > mnoffset+bad_pixel_offset_sigma*stdoffset)] = BadPixels.OFFSET_OUT_OF_THRESHOLD.value\n",
+    "\n",
+    "mnnoise = np.nanmedian(noiseMapCM_2nd)\n",
+    "stdnoise = np.nanstd(noiseMapCM_2nd)\n",
+    "bad_pixels[(noiseMapCM_2nd < mnnoise-bad_pixel_noise_sigma*stdnoise) | \n",
+    "           (noiseMapCM_2nd > mnnoise+bad_pixel_noise_sigma*stdnoise)] = BadPixels.NOISE_OUT_OF_THRESHOLD.value\n",
+    "\n",
+    "bad_pixels = np.bitwise_or(bad_pixels, mask)\n",
+    "fig = xana.heatmapPlot(np.log2(bad_pixels[:,:,0]),aspect=1, x_label='Column Number', y_label='Row Number', \n",
+    "                       lut_label='2^(Assigned Value to Bad Pixels)', x_range=(0,y), y_range=(0,x), panel_top_low_lim = 0, \n",
+    "                       panel_top_high_lim = 20, panel_side_low_lim = 0, panel_side_high_lim = 20, \n",
+    "                       title = 'Final Bad Pixels Map', panel_x_label='Columns Stat', \n",
+    "                       panel_y_label='Rows Stat', vmax=20)\n",
+    "#fig.savefig('BadPixelMap_2.svg', format='svg', dpi=1200, bbox_inches='tight') "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "display(Markdown('### Statistics on the Bad Pixels'))\n",
+    "num_bad_pixels = np.count_nonzero(bad_pixels)\n",
+    "num_all_pixels = x*y\n",
+    "percentage_bad_pixels = num_bad_pixels*100/num_all_pixels\n",
+    "print(\"Number of bad pixels: {:0.0f}, i.e. {:0.2f}% of all pixels\".format(num_bad_pixels, percentage_bad_pixels))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Electronic Noise\n",
+    "\n",
+    "According to Table 6.1 (page 80) of Ivana Klačková's master's thesis: \"Conversion gain for the FastCCD is: lower hemisphere = 6.2e-/ADU and upper hemisphere = 6.1e-/ADU.\"\n",
+    "\n",
+    "The following Tables present the noise along lower hemisphere, upper hemisphere, and the entire FastCCD detector at different stages. Here, the values in the first table (in ADU and e-) are the mean of noise per pixel, where noise is considered to be the initial uncorrected noise, CM corrected noise after second trial (including bad pixels) and CM corrected noise after third trial (excluding bad pixels). \n",
+    "\n",
+    "The values of the second table (in electrons) are the standard deviation of noise per pixel."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# noiseMap refers to the initial uncorrected noise, noiseMapCM refers to common mode corrected noise with inclusion of \n",
+    "# bad pixels, and noiseMapCM_2nd refers to common mode corrected noise without inclusion of bad pixels:\n",
+    "\n",
+    "ADU_to_electron = (ADU_to_electron_upper + ADU_to_electron_lower)/2 # Average of ADU_to_electron for the entire detector \n",
+    "\n",
+    "print(\"Abbreviations:\")\n",
+    "print(\" - ED = Entire Detector; LH: Lower Hemisphere; UH: Upper Hemisphere\")\n",
+    "print(\" - CM Noise: Common Mode Corrected Noise\")\n",
+    "print(\" - BP: Bad Pixels\\n\")\n",
+    "      \n",
+    "t0 = PrettyTable()\n",
+    "t0.title = \"Averages of Noise per Pixel\"\n",
+    "t0.field_names = [\"Uncorrected Noise\",\"CM Noise, BP Incl.\", \"CM Noise, BP Excl.\"]\n",
+    "t0.add_row([\"ED: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMap),np.mean(noiseMap)*ADU_to_electron), \"ED: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM), np.mean(noiseMapCM)*ADU_to_electron), \"ED: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM_2nd), np.mean(noiseMapCM_2nd)*ADU_to_electron)])\n",
+    "t0.add_row([\"LH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMap[:x//2,:]), np.mean(noiseMap[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM[:x//2,:]), np.mean(noiseMapCM[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM_2nd[:x//2,:]), np.mean(noiseMapCM_2nd[:x//2,:])*ADU_to_electron_lower)])\n",
+    "t0.add_row([\"UH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMap[x//2:,:]), np.mean(noiseMap[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM[x//2:,:]), np.mean(noiseMapCM[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} ADU = {:0.2f} e-\".format(np.mean(noiseMapCM_2nd[x//2:,:]), np.mean(noiseMapCM_2nd[x//2:,:])*ADU_to_electron_upper)])\n",
+    "print(t0,'\\n')\n",
+    "\n",
+    "t1 = PrettyTable()\n",
+    "t1.title = \"Standard Deviations of Noise per Pixel\"\n",
+    "t1.field_names = [\"Uncorrected Noise\",\"CM Noise, BP Incl.\", \"CM Noise, BP Excl.\"]\n",
+    "t1.add_row([\"ED: {:0.2f} e-\".format(np.std(noiseMap)*ADU_to_electron), \"ED: {:0.2f} e-\".format(np.std(noiseMapCM)*ADU_to_electron), \"ED: {:0.2f} e-\".format(np.std(noiseMapCM_2nd)*ADU_to_electron)])\n",
+    "t1.add_row([\"LH: {:0.2f} e-\".format(np.std(noiseMap[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} e-\".format(np.std(noiseMapCM[:x//2,:])*ADU_to_electron_lower), \"LH: {:0.2f} e-\".format(np.std(noiseMapCM_2nd[:x//2,:])*ADU_to_electron_lower)])\n",
+    "t1.add_row([\"UH: {:0.2f} e-\".format(np.std(noiseMap[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} e-\".format(np.std(noiseMapCM[x//2:,:])*ADU_to_electron_upper), \"UH: {:0.2f} e-\".format(np.std(noiseMapCM_2nd[x//2:,:])*ADU_to_electron_upper)])\n",
+    "print(t1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Calibration Constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dictionary = {} \n",
+    "dictionary['Offset'] = offsetMap.data\n",
+    "dictionary['Noise'] = noiseMapCM_2nd.data\n",
+    "dictionary['BadPixelsDark'] = bad_pixels.data\n",
+    "\n",
+    "for const in dictionary:\n",
+    "    metadata = ConstantMetaData()\n",
+    "    dconst = getattr(Constants.CCD(DetectorTypes.fastCCD), const)()\n",
+    "    dconst.data = dictionary[const]\n",
+    "    metadata.calibration_constant = dconst\n",
+    "    \n",
+    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                integration_time=integration_time,\n",
+    "                                gain_setting=det_gain,\n",
+    "                                temperature=fix_temperature,\n",
+    "                                pixels_x=1934,\n",
+    "                                pixels_y=960)\n",
+    "    \n",
+    "    for parm in condition.parameters:\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            parm.lower_deviation = temp_limits\n",
+    "            parm.upper_deviation = temp_limits\n",
+    "\n",
+    "    device = Detectors.fastCCD1\n",
+    "    metadata.detector_condition = condition\n",
+    "    \n",
+    "    # Specifying the a version for this constant:\n",
+    "    if creation_time is None:\n",
+    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "    else:\n",
+    "        metadata.calibration_constant_version = Versions.Timespan(device=device, start=creation_time)\n",
+    "    \n",
+    "    if db_output:\n",
+    "        metadata.calibration_constant_version.raw_data_location = file_loc\n",
+    "        metadata.send(cal_db_interface, timeout=cal_db_timeout)    \n",
+    "\n",
+    "print(\"Calibration constants (offsetMap, noiseMapCM_2nd and bad_pixels) are sent to the calibration database.\")\n",
+    "print(\"Creation time is: {}\".format(creation_time))"
+   ]
+  },
+  {
+   "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.7"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb b/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb
new file mode 100644
index 000000000..c80d17a47
--- /dev/null
+++ b/notebooks/FastCCD/CorrectionNotebook_NewDAQ_FastCCD_NBC.ipynb
@@ -0,0 +1,1279 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# FastCCD Data Correction ##\n",
+    "\n",
+    "Authors: I. Klačková, S. Hauf, Version 1.0\n",
+    "\n",
+    "The following notebook provides correction of images acquired with the FastCCD."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:23.218849Z",
+     "start_time": "2018-12-06T15:54:23.166497Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "in_folder = \"/gpfs/exfel/exp/SCS/201802/p002170/raw/\" # input folder, required\n",
+    "out_folder = '/gpfs/exfel/data/scratch/xcal/test/' # output folder, required\n",
+    "path_template = 'RAW-R{:04d}-{}-S{{:05d}}.h5' #  path template in hdf5 file\n",
+    "path_inset = 'DA05'\n",
+    "run = 277 # run number\n",
+    "h5path = '/INSTRUMENT/SCS_CDIDET_FCCD2M/DAQ/FCCD:daqOutput/data/image' # path in HDF5 file\n",
+    "h5path_t = '/CONTROL/SCS_CDIDET_FCCD2M/CTRL/LSLAN/inputA/crdg/value' # temperature path in HDF5 file\n",
+    "h5path_cntrl = '/RUN/SCS_CDIDET_FCCD2M/DET/FCCD'  # path to control data\n",
+    "cluster_profile = \"noDB\" #ipcluster profile to use\n",
+    "cpuCores = 16 #Specifies the number of running cpu cores\n",
+    "operation_mode = \"FF\" # FS stands for frame-store and FF for full-frame opeartion\n",
+    "split_evt_primary_threshold = 7. # primary threshold for split event classification in terms of n sigma noise\n",
+    "split_evt_secondary_threshold = 4. # secondary threshold for split event classification in terms of n sigma noise\n",
+    "split_evt_mip_threshold = 1000. # MIP threshold for event classification\n",
+    "cal_db_interface = \"tcp://max-exfl016:8015#8025\" # calibration DB interface to use\n",
+    "cal_db_timeout = 300000000 # timeout on caldb requests\n",
+    "sequences = [-1] # sequences to correct, set to -1 for all, range allowed\n",
+    "chunk_size_idim = 1 # H5 chunking size of output data\n",
+    "overwrite = True # overwrite existing files\n",
+    "do_pattern_classification = True # classify split events\n",
+    "sequences_per_node = 1 # sequences to correct per node\n",
+    "limit_images = 0 # limit images per file \n",
+    "correct_offset_drift = False  # correct for offset drifts\n",
+    "use_dir_creation_date = True # use dir creation data for calDB queries\n",
+    "time_offset_days = 0 # offset in days for calibration parameters\n",
+    "photon_energy_gain_map = 2. # energy in keV\n",
+    "fix_temperature = 0. # fix temperature to this value, set to 0 to use slow control value\n",
+    "flipped_between = [\"2019-02-01\", \"2019-04-02\"] # detector was flipped during this timespan\n",
+    "temp_limits = 5 # limits within which temperature is considered the same\n",
+    "\n",
+    "def balance_sequences(in_folder, run, sequences, sequences_per_node):\n",
+    "    import glob\n",
+    "    import re\n",
+    "    import numpy as np\n",
+    "    if sequences[0] == -1:\n",
+    "        sequence_files = glob.glob(\"{}/r{:04d}/*{}-S*.h5\".format(in_folder, run, path_inset))\n",
+    "        seq_nums = set()\n",
+    "        for sf in sequence_files:\n",
+    "            seqnum = re.findall(r\".*-S([0-9]*).h5\", sf)[0]\n",
+    "            seq_nums.add(int(seqnum))\n",
+    "        seq_nums -= set(sequences)\n",
+    "        nsplits = len(seq_nums)//sequences_per_node+1\n",
+    "        while nsplits > 8:\n",
+    "            sequences_per_node += 1\n",
+    "            nsplits = len(seq_nums)//sequences_per_node+1\n",
+    "            print(\"Changed to {} sequences per node to have a maximum of 8 concurrent jobs\".format(sequences_per_node))\n",
+    "        return [l.tolist() for l in np.array_split(list(seq_nums), nsplits)]\n",
+    "    else:\n",
+    "        return sequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:23.455376Z",
+     "start_time": "2018-12-06T15:54:23.413579Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import XFELDetAna.xfelprofiler as xprof\n",
+    "\n",
+    "profiler = xprof.Profiler()\n",
+    "profiler.disable()\n",
+    "from XFELDetAna.util import env\n",
+    "env.iprofile = cluster_profile\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "from XFELDetAna import xfelpycaltools as xcal\n",
+    "from XFELDetAna import xfelpyanatools as xana\n",
+    "from XFELDetAna.plotting.util import prettyPlotting\n",
+    "prettyPlotting=True\n",
+    "from XFELDetAna.xfelreaders import ChunkReader\n",
+    "from XFELDetAna.detectors.fastccd import readerh5 as fastccdreaderh5\n",
+    "\n",
+    "import numpy as np\n",
+    "import h5py\n",
+    "import matplotlib.pyplot as plt\n",
+    "from iminuit import Minuit\n",
+    "\n",
+    "import time\n",
+    "import copy\n",
+    "import os\n",
+    "\n",
+    "from prettytable import PrettyTable\n",
+    "\n",
+    "from iCalibrationDB import ConstantMetaData, Constants, Conditions, Detectors, Versions\n",
+    "from iCalibrationDB.detectors import DetectorTypes\n",
+    "from cal_tools.tools import get_dir_creation_date\n",
+    "\n",
+    "from datetime import timedelta\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
+    "if sequences[0] == -1:\n",
+    "    sequences = None\n",
+    "    \n",
+    "offset_correction_args = (0.2459991787617141, 243.21639920846485)\n",
+    "t_base = 247.82\n",
+    "\n",
+    "if \"#\" in cal_db_interface:\n",
+    "    prot, serv, ran = cal_db_interface.split(\":\")\n",
+    "    r1, r2 = ran.split(\"#\")\n",
+    "    cal_db_interface = \":\".join(\n",
+    "        [prot, serv, str(np.random.randint(int(r1), int(r2)))])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:23.679069Z",
+     "start_time": "2018-12-06T15:54:23.662821Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "if operation_mode == \"FS\":\n",
+    "    x = 960 # rows of the FastCCD to analyze in FS mode \n",
+    "    y = 960 # columns of the FastCCD to analyze in FS mode \n",
+    "    print('\\nYou are analyzing data in FS mode.')\n",
+    "else:\n",
+    "    x = 1934 # rows of the FastCCD to analyze in FF mode \n",
+    "    y = 960 # columns of the FastCCD to analyze in FF mode\n",
+    "    print('\\nYou are analyzing data in FF mode.')\n",
+    "    \n",
+    "ped_dir = \"{}/r{:04d}\".format(in_folder, run)\n",
+    "out_folder  = \"{}/r{:04d}\".format(out_folder, run)\n",
+    "fp_name = path_template.format(run, path_inset)\n",
+    "fp_path = '{}/{}'.format(ped_dir, fp_name)\n",
+    "\n",
+    "print(\"Reading data from: {}\\n\".format(fp_path))\n",
+    "print(\"Run is: {}\".format(run))\n",
+    "print(\"HDF5 path: {}\".format(h5path))\n",
+    "print(\"Data is output to: {}\".format(out_folder))\n",
+    "\n",
+    "import datetime\n",
+    "creation_time = None\n",
+    "if use_dir_creation_date:\n",
+    "    creation_time = get_dir_creation_date(in_folder, run) + timedelta(days=time_offset_days)\n",
+    "if creation_time:\n",
+    "    print(\"Using {} as creation time\".format(creation_time.isoformat()))\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:23.913269Z",
+     "start_time": "2018-12-06T15:54:23.868910Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "sensorSize = [x, y]\n",
+    "chunkSize = 100 #Number of images to read per chunk\n",
+    "blockSize = [sensorSize[0]//2, sensorSize[1]//4] #Sensor area will be analysed according to blocksize\n",
+    "xcal.defaultBlockSize = blockSize\n",
+    "memoryCells = 1 #FastCCD has 1 memory cell\n",
+    "#Specifies total number of images to proceed\n",
+    "\n",
+    "commonModeBlockSize = blockSize\n",
+    "commonModeAxisR = 'row'#Axis along which common mode will be calculated\n",
+    "run_parallel = True\n",
+    "profile = False\n",
+    "\n",
+    "temperature_k = 291\n",
+    "filename = fp_path.format(sequences[0] if sequences else 0)\n",
+    "with h5py.File(filename, 'r') as f:\n",
+    "    bias_voltage = int(f['{}/biasclock/bias/value'.format(h5path_cntrl)][0])\n",
+    "    det_gain = int(f['{}/exposure/gain/value'.format(h5path_cntrl)][0])\n",
+    "    integration_time = int(f['{}/acquisitionTime/value'.format(h5path_cntrl)][0])\n",
+    "    print(\"Bias voltage is {} V\".format(bias_voltage))\n",
+    "    print(\"Detector gain is set to x{}\".format(det_gain))\n",
+    "    print(\"Detector integration time is set to {}\".format(integration_time))\n",
+    "    temperature = np.mean(f[h5path_t])\n",
+    "    temperature_k = temperature + 273.15\n",
+    "    if fix_temperature != 0.:\n",
+    "        temperature_k = fix_temperature\n",
+    "        print(\"Using fixed temperature\")\n",
+    "    print(\"Mean temperature was {:0.2f} °C / {:0.2f} K at beginning of run\".format(temperature, temperature_k))\n",
+    "    \n",
+    "\n",
+    "if not os.path.exists(out_folder):\n",
+    "    os.makedirs(out_folder)\n",
+    "elif not overwrite:\n",
+    "    raise AttributeError(\"Output path exists! Exiting\")    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:24.088948Z",
+     "start_time": "2018-12-06T15:54:24.059925Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "dirlist = sorted(os.listdir(ped_dir))\n",
+    "file_list = []\n",
+    "total_sequences = 0\n",
+    "fsequences = []\n",
+    "for entry in dirlist:\n",
+    "\n",
+    "    #only h5 file\n",
+    "    abs_entry = \"{}/{}\".format(ped_dir, entry)\n",
+    "    if os.path.isfile(abs_entry) and os.path.splitext(abs_entry)[1] == \".h5\":\n",
+    "        \n",
+    "        if sequences is None:\n",
+    "            for seq in range(len(dirlist)):\n",
+    "                \n",
+    "                if path_template.format(run, path_inset).format(seq) in abs_entry:\n",
+    "                    file_list.append(abs_entry)\n",
+    "                    total_sequences += 1\n",
+    "                    fsequences.append(seq)\n",
+    "        else:\n",
+    "            for seq in sequences:\n",
+    "                \n",
+    "                if path_template.format(run, path_inset).format(seq) in abs_entry:\n",
+    "                    file_list.append(os.path.abspath(abs_entry))\n",
+    "                    total_sequences += 1\n",
+    "                    fsequences.append(seq)\n",
+    "sequences = fsequences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T18:43:39.776018Z",
+     "start_time": "2018-12-06T18:43:39.759185Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "from IPython.display import HTML, display, Markdown, Latex\n",
+    "import tabulate\n",
+    "print(\"Processing a total of {} sequence files\".format(total_sequences))\n",
+    "table = []\n",
+    "\n",
+    "\n",
+    "for k, f in enumerate(file_list):\n",
+    "    table.append((k, f))\n",
+    "if len(table):  \n",
+    "    md = display(Latex(tabulate.tabulate(table, tablefmt='latex', headers=[\"#\", \"file\"])))      "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As a first step, dark maps have to be loaded."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:28.254544Z",
+     "start_time": "2018-12-06T15:54:24.709521Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "offsetMap = None\n",
+    "badPixelMap = None\n",
+    "noiseMap = None\n",
+    "for i, g in enumerate([8, 2, 1]):\n",
+    "    ## offset\n",
+    "    metadata = ConstantMetaData()\n",
+    "    offset = Constants.CCD(DetectorTypes.fastCCD).Offset()\n",
+    "    metadata.calibration_constant = offset\n",
+    "\n",
+    "    # set the operating condition\n",
+    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                    integration_time=integration_time,\n",
+    "                                    gain_setting=g,\n",
+    "                                    temperature=temperature_k,\n",
+    "                                    pixels_x=1934,\n",
+    "                                    pixels_y=960)\n",
+    "\n",
+    "    for parm in condition.parameters:\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            parm.lower_deviation = temp_limits\n",
+    "            parm.upper_deviation = temp_limits\n",
+    "\n",
+    "\n",
+    "    device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "    metadata.detector_condition = condition\n",
+    "\n",
+    "\n",
+    "\n",
+    "    # specify the version for this constant\n",
+    "    if creation_time is None:\n",
+    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "        metadata.retrieve(cal_db_interface)\n",
+    "    else:\n",
+    "        metadata.calibration_constant_version = Versions.Timespan(device=device,\n",
+    "                                                                  start=creation_time)\n",
+    "        metadata.retrieve(cal_db_interface, when=creation_time.isoformat(), timeout=3000000)\n",
+    "\n",
+    "\n",
+    "    if offsetMap is None:\n",
+    "        offsetMap = np.zeros(list(offset.data.shape)+[3], np.float32)\n",
+    "    offsetMap[...,i] = offset.data\n",
+    "\n",
+    "    offset_temperature = None\n",
+    "    for parm in condition.parameters:\n",
+    "\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            offset_temperature = parm.value\n",
+    "\n",
+    "    print(\"Temperature of detector when dark images (gain {}) for offset calculation \".format(g) +\n",
+    "              \"were taken at: {:0.2f} K @ {}\".format(offset_temperature,\n",
+    "                                                     metadata.calibration_constant_version.begin_at))\n",
+    "\n",
+    "    ## noise\n",
+    "    metadata = ConstantMetaData()\n",
+    "    noise = Constants.CCD(DetectorTypes.fastCCD).Noise()\n",
+    "    metadata.calibration_constant = noise\n",
+    "\n",
+    "    # set the operating condition\n",
+    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                    integration_time=integration_time,\n",
+    "                                    gain_setting=g,\n",
+    "                                    temperature=temperature_k,\n",
+    "                                    pixels_x=1934,\n",
+    "                                    pixels_y=960)\n",
+    "\n",
+    "\n",
+    "    for parm in condition.parameters:\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            parm.lower_deviation = temp_limits\n",
+    "            parm.upper_deviation = temp_limits\n",
+    "\n",
+    "\n",
+    "    device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "    metadata.detector_condition = condition\n",
+    "\n",
+    "    # specify the version for this constant\n",
+    "    if creation_time is None:\n",
+    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "        metadata.retrieve(cal_db_interface)\n",
+    "    else:\n",
+    "        metadata.calibration_constant_version = Versions.Timespan(device=device,\n",
+    "                                                                  start=creation_time)\n",
+    "        metadata.retrieve(cal_db_interface, when=creation_time.isoformat(), timeout=3000000)\n",
+    "\n",
+    "    if noiseMap is None:\n",
+    "        noiseMap = np.zeros(list(noise.data.shape)+[3], np.float32)\n",
+    "    noiseMap[...,i] = noise.data\n",
+    "\n",
+    "\n",
+    "    ## bad pixels \n",
+    "\n",
+    "    metadata = ConstantMetaData()\n",
+    "    bpix = Constants.CCD(DetectorTypes.fastCCD).BadPixelsDark()\n",
+    "    metadata.calibration_constant = bpix\n",
+    "\n",
+    "    # set the operating condition\n",
+    "    condition = Conditions.Dark.CCD(bias_voltage=bias_voltage,\n",
+    "                                    integration_time=integration_time,\n",
+    "                                    gain_setting=g,\n",
+    "                                    temperature=temperature_k,\n",
+    "                                    pixels_x=1934,\n",
+    "                                    pixels_y=960)\n",
+    "\n",
+    "    for parm in condition.parameters:\n",
+    "        if parm.name == \"Sensor Temperature\":\n",
+    "            parm.lower_deviation = temp_limits\n",
+    "            parm.upper_deviation = temp_limits\n",
+    "\n",
+    "\n",
+    "    device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "    metadata.detector_condition = condition\n",
+    "\n",
+    "    # specify the version for this constant\n",
+    "    if creation_time is None:\n",
+    "        metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "        metadata.retrieve(cal_db_interface)\n",
+    "    else:\n",
+    "        metadata.calibration_constant_version = Versions.Timespan(device=device,\n",
+    "                                                                  start=creation_time)\n",
+    "        metadata.retrieve(cal_db_interface, when=creation_time.isoformat(), timeout=3000000)\n",
+    "\n",
+    "    if badPixelMap is None:\n",
+    "        badPixelMap = np.zeros(list(bpix.data.shape)+[3], np.uint32)\n",
+    "    badPixelMap[...,i] = bpix.data\n",
+    "        \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Loading cti and relative gain values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:28.343869Z",
+     "start_time": "2018-12-06T15:54:28.271344Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "## relative gain\n",
+    "\n",
+    "metadata = ConstantMetaData()\n",
+    "relgain = Constants.CCD(DetectorTypes.fastCCD).RelativeGain()\n",
+    "metadata.calibration_constant = relgain\n",
+    "\n",
+    "# set the operating condition\n",
+    "condition = Conditions.Illuminated.CCD(bias_voltage=bias_voltage,\n",
+    "                                       integration_time=integration_time,\n",
+    "                                       gain_setting=0,\n",
+    "                                       temperature=temperature_k,\n",
+    "                                       pixels_x=1934,\n",
+    "                                       pixels_y=960, photon_energy=photon_energy_gain_map)\n",
+    "device = Detectors.fastCCD1\n",
+    "\n",
+    "\n",
+    "metadata.detector_condition = condition\n",
+    "\n",
+    "# specify the a version for this constant\n",
+    "metadata.calibration_constant_version = Versions.Now(device=device)\n",
+    "metadata.retrieve(cal_db_interface)\n",
+    "\n",
+    "relGain = relgain.data[::-1,...]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "relGainCA = copy.copy(relGain)\n",
+    "relGainC = relGainCA[:relGainCA.shape[0]//2,...]\n",
+    "ctiA = np.ones(relGainCA.shape[:2])\n",
+    "cti = np.ones(relGainC.shape[:2])\n",
+    "i = 0\n",
+    "idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
+    "mn1 = np.nanmean(relGainC[i, ~idx, 0])\n",
+    "\n",
+    "for i in range(1, relGainC.shape[0]):\n",
+    "    idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
+    "    mn2 = np.nanmean(relGainC[i, ~idx, 0])\n",
+    "    cti[i,:] = mn2/mn1\n",
+    "ctiA[:relGainCA.shape[0]//2,...] = cti\n",
+    "\n",
+    "relGainC = relGainCA[relGainCA.shape[0]//2:,...]\n",
+    "\n",
+    "\n",
+    "cti = np.ones(relGainC.shape[:2])\n",
+    "i = -1\n",
+    "idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
+    "mn1 = np.nanmean(relGainC[i, ~idx, 0])\n",
+    "\n",
+    "for i in range(relGainC.shape[0]-1, 1, -1):\n",
+    "    idx = (relGainC[i, :, 0] < 0.9) | (relGainC[i,:,0] > 1.1)\n",
+    "    mn2 = np.nanmean(relGainC[i, ~idx, 0])\n",
+    "    cti[i,:] = mn2/mn1\n",
+    "\n",
+    "ctiA[relGainCA.shape[0]//2:,...] = cti\n",
+    "\n",
+    "relGainCA = copy.copy(relGain)\n",
+    "relGainC = relGainCA[:relGainCA.shape[0]//2,...]\n",
+    "for i in range(relGainC.shape[1]):\n",
+    "    idx = (relGainC[:,i, 0] < 0.95) | (relGainC[:,i,0] > 1.05)\n",
+    "    relGainC[idx,i,0] = np.nanmean(relGainC[~idx,i,0])\n",
+    "    relGainC[idx,i,1] = np.nanmean(relGainC[~idx,i,1])\n",
+    "    relGainC[idx,i,2] = np.nanmean(relGainC[~idx,i,2])\n",
+    "relGainCA[:relGainCA.shape[0]//2,...] = relGainC\n",
+    "relGainC = relGainCA[relGainCA.shape[0]//2:,...]\n",
+    "for i in range(relGainC.shape[1]):\n",
+    "    idx = (relGainC[:,i, 0] < 0.95) | (relGainC[:,i,0] > 1.05)\n",
+    "    relGainC[idx,i,0] = np.nanmean(relGainC[~idx,i,0])\n",
+    "    relGainC[idx,i,1] = np.nanmean(relGainC[~idx,i,1])\n",
+    "    relGainC[idx,i,2] = np.nanmean(relGainC[~idx,i,2])\n",
+    "relGainCA[relGainCA.shape[0]//2:,...] = relGainC\n",
+    "relGainC = relGainCA*ctiA[...,None]\n",
+    "\n",
+    "relGain = relGainC"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "import dateutil.parser\n",
+    "flipped_between = [dateutil.parser.parse(d) for d in flipped_between]\n",
+    "flip_rgain = creation_time >= flipped_between[0] and creation_time <= flipped_between[1]\n",
+    "flip_rgain &= (metadata.calibration_constant_version.begin_at.replace(tzinfo=None) >= flipped_between[0] \n",
+    "               and metadata.calibration_constant_version.begin_at.replace(tzinfo=None) <= flipped_between[1])\n",
+    "print(\"Accounting for flipped detector: {}\".format(flip_rgain))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T15:54:28.771629Z",
+     "start_time": "2018-12-06T15:54:28.346051Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "#************************Calculators************************#\n",
+    "\n",
+    "\n",
+    "cmCorrection = xcal.CommonModeCorrection([x, y], \n",
+    "                                         commonModeBlockSize, \n",
+    "                                         commonModeAxisR,\n",
+    "                                         nCells = memoryCells, \n",
+    "                                         noiseMap = noiseMap,\n",
+    "                                        runParallel=True,\n",
+    "                                        stats=True)\n",
+    "\n",
+    "patternClassifierLH = xcal.PatternClassifier([x//2, y], \n",
+    "                                              noiseMap[:x//2, :], \n",
+    "                                              split_evt_primary_threshold, \n",
+    "                                             split_evt_secondary_threshold,\n",
+    "                                             split_evt_mip_threshold,\n",
+    "                                              tagFirstSingles = 0, \n",
+    "                                              nCells=memoryCells, \n",
+    "                                              cores=cpuCores, \n",
+    "                                              allowElongated = False,\n",
+    "                                              blockSize=[x//2, y],\n",
+    "                                              runParallel=True)\n",
+    "\n",
+    "\n",
+    "\n",
+    "patternClassifierUH = xcal.PatternClassifier([x//2, y], \n",
+    "                                              noiseMap[x//2:, :], \n",
+    "                                              split_evt_primary_threshold, \n",
+    "                                              split_evt_secondary_threshold,\n",
+    "                                              split_evt_mip_threshold,\n",
+    "                                              tagFirstSingles = 0, \n",
+    "                                              nCells=memoryCells, \n",
+    "                                              cores=cpuCores, \n",
+    "                                              allowElongated = False,\n",
+    "                                              blockSize=[x//2, y],\n",
+    "                                              runParallel=True)\n",
+    "\n",
+    "                                   \n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:08:51.886343Z",
+     "start_time": "2018-12-06T16:08:51.842837Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "#*****************Histogram Calculators******************#\n",
+    "\n",
+    "histCalOffsetCor = xcal.HistogramCalculator([x, y], \n",
+    "                                             bins=500, \n",
+    "                                             range=[-50, 1000],\n",
+    "                                             nCells=memoryCells, \n",
+    "                                             cores=cpuCores,\n",
+    "                                             blockSize=blockSize)\n",
+    "\n",
+    "histCalPcorr = xcal.HistogramCalculator([x, y], \n",
+    "                                         bins=500, \n",
+    "                                         range=[-50, 1000],\n",
+    "                                         nCells=memoryCells, \n",
+    "                                         cores=cpuCores,\n",
+    "                                         blockSize=blockSize)\n",
+    "\n",
+    "histCalPcorrS = xcal.HistogramCalculator([x, y], \n",
+    "                                         bins=500, \n",
+    "                                         range=[-50, 1000],\n",
+    "                                         nCells=memoryCells, \n",
+    "                                         cores=cpuCores,\n",
+    "                                         blockSize=blockSize)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Applying corrections"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:08:52.441784Z",
+     "start_time": "2018-12-06T16:08:52.437284Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "patternClassifierLH._imagesPerChunk = 500\n",
+    "patternClassifierUH._imagesPerChunk = 500\n",
+    "patternClassifierLH.debug()\n",
+    "patternClassifierUH.debug()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:08:53.042555Z",
+     "start_time": "2018-12-06T16:08:53.034522Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "histCalOffsetCor.debug()\n",
+    "histCalPcorr.debug()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:08:53.551111Z",
+     "start_time": "2018-12-06T16:08:53.531064Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "def copy_and_sanitize_non_cal_data(infile, outfile, h5base):\n",
+    "    \n",
+    "    if h5base.startswith(\"/\"):\n",
+    "        h5base = h5base[1:]\n",
+    "    dont_copy = ['pixels']\n",
+    "    dont_copy = [h5base+\"/{}\".format(do)\n",
+    "                for do in dont_copy]\n",
+    "\n",
+    "    def visitor(k, item):\n",
+    "        if k not in dont_copy:\n",
+    "            if isinstance(item, h5py.Group):\n",
+    "                outfile.create_group(k)\n",
+    "            elif isinstance(item, h5py.Dataset):\n",
+    "                group = str(k).split(\"/\")\n",
+    "                group = \"/\".join(group[:-1])\n",
+    "                infile.copy(k, outfile[group])\n",
+    "                \n",
+    "    infile.visititems(visitor)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:55.917179Z",
+     "start_time": "2018-12-06T16:09:01.603633Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "mean_im = None\n",
+    "single_im = None\n",
+    "mean_im_cc = None\n",
+    "single_im_cc = None\n",
+    "drift_lh = []\n",
+    "drift_uh = []\n",
+    "offsetMap = np.squeeze(offsetMap)\n",
+    "noiseMap = np.squeeze(noiseMap)\n",
+    "badPixelMap = np.squeeze(badPixelMap)\n",
+    "relGain = np.squeeze(relGain)\n",
+    "for k, f in enumerate(file_list):\n",
+    "    with h5py.File(f, 'r', driver='core') as infile:\n",
+    "        out_fileb = \"{}/{}\".format(out_folder, f.split(\"/\")[-1])\n",
+    "        out_file = out_fileb.replace(\"RAW\", \"CORR\")\n",
+    "        #out_filed = out_fileb.replace(\"RAW\", \"CORR-SC\")\n",
+    "\n",
+    "        data = None\n",
+    "        noise = None\n",
+    "        try:\n",
+    "            with h5py.File(out_file, \"w\") as ofile:\n",
+    "            \n",
+    "                copy_and_sanitize_non_cal_data(infile, ofile, h5path)\n",
+    "                data = infile[h5path+\"/pixels\"][()]\n",
+    "                nzidx = np.count_nonzero(data, axis=(1,2))\n",
+    "                data = data[nzidx != 0, ...]\n",
+    "                if limit_images > 0:\n",
+    "                    data = data[:limit_images,...]\n",
+    "                oshape = data.shape\n",
+    "                data = np.moveaxis(data, 0, 2)\n",
+    "                ddset = ofile.create_dataset(h5path+\"/pixels\",\n",
+    "                                             oshape,\n",
+    "                                             chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
+    "                                             dtype=np.float32)\n",
+    "                \n",
+    "                ddsetm = ofile.create_dataset(h5path+\"/mask\",\n",
+    "                                             oshape,\n",
+    "                                             chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
+    "                                             dtype=np.uint32, compression=\"gzip\")\n",
+    "                \n",
+    "                ddsetg = ofile.create_dataset(h5path+\"/gain\",\n",
+    "                                             oshape,\n",
+    "                                             chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
+    "                                             dtype=np.uint8, compression=\"gzip\")\n",
+    "                \n",
+    "                gain = np.right_shift(data, 14)\n",
+    "                \n",
+    "                gain[gain != 0] -= 1\n",
+    "                \n",
+    "                fstride = 1\n",
+    "                if not flip_rgain:  # rgain was taken during flipped orientation\n",
+    "                    fstride = -1\n",
+    "                \n",
+    "                data = np.bitwise_and(data, 0b0011111111111111).astype(np.float32)                \n",
+    "                omap = np.repeat(offsetMap[...,None,:], data.shape[2], axis=2)\n",
+    "                rmap = np.repeat(relGain[:,::fstride,None,:], data.shape[2], axis=2)\n",
+    "                nmap = np.repeat(noiseMap[...,None,:], data.shape[2], axis=2)\n",
+    "                bmap = np.repeat(badPixelMap[...,None,:], data.shape[2], axis=2)\n",
+    "                offset = np.choose(gain, (omap[...,0], omap[...,1], omap[...,2]))\n",
+    "                rg = np.choose(gain, (rmap[...,0], rmap[...,1], rmap[...,2]))\n",
+    "                noise = np.choose(gain, (nmap[...,0], nmap[...,1], nmap[...,2]))\n",
+    "                bpix = np.choose(gain, (bmap[...,0], bmap[...,1], bmap[...,2]))\n",
+    "                \n",
+    "                data -= offset\n",
+    "                data *= rg\n",
+    "                \n",
+    "                if correct_offset_drift:\n",
+    "                    lhd = np.mean(data[x//2-10:x//2,y//2-5:y//2+5,:], axis=(0,1))\n",
+    "                    data[:x//2, :, :] -= lhd\n",
+    "                    drift_lh.append(lhd)\n",
+    "                    \n",
+    "                    uhd = np.mean(data[x//2:x//2+10,y//2-5:y//2+5,:], axis=(0,1))                    \n",
+    "                    data[x//2:, :, :] -= uhd\n",
+    "                    drift_uh.append(lhd)\n",
+    "                \n",
+    "                histCalOffsetCor.fill(data)\n",
+    "\n",
+    "               \n",
+    "                ddset[...] = np.moveaxis(data, 2, 0)\n",
+    "                ddsetm[...] = np.moveaxis(bpix, 2, 0)\n",
+    "                ddsetg[...] = np.moveaxis(gain, 2, 0).astype(np.uint8)\n",
+    "                \n",
+    "                if mean_im is None:\n",
+    "                        mean_im = np.nanmean(data, axis=2)\n",
+    "                        single_im = data[...,0]\n",
+    "                        \n",
+    "                if do_pattern_classification:\n",
+    "                \n",
+    "                    ddsetcm = ofile.create_dataset(h5path+\"/pixels_cm\",\n",
+    "                                         oshape,\n",
+    "                                         chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
+    "                                         dtype=np.float32)\n",
+    "\n",
+    "                    ddsetc = ofile.create_dataset(h5path+\"/pixels_classified\",\n",
+    "                                         oshape,\n",
+    "                                         chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
+    "                                         dtype=np.float32, compression=\"gzip\")\n",
+    "\n",
+    "                    ddsetp = ofile.create_dataset(h5path+\"/patterns\",\n",
+    "                                                 oshape,\n",
+    "                                                 chunks=(chunk_size_idim, oshape[1], oshape[2]),\n",
+    "                                                 dtype=np.int32, compression=\"gzip\")\n",
+    "                    \n",
+    "\n",
+    "                    patternClassifierLH._noisemap = noise[:x//2, :, :]\n",
+    "                    patternClassifierUH._noisemap = noise[x//2:, :, :]\n",
+    "\n",
+    "                    data = cmCorrection.correct(data)  # correct for the row common mode\n",
+    "                    ddsetcm[...] = np.moveaxis(data, 2, 0)\n",
+    "\n",
+    "                    dataLH = data[:x//2, :, :]\n",
+    "                    dataUH = data[x//2:, :, :]\n",
+    "\n",
+    "                    dataLH, patternsLH = patternClassifierLH.classify(dataLH)\n",
+    "                    dataUH, patternsUH = patternClassifierUH.classify(dataUH)\n",
+    "\n",
+    "                    data[:x//2, :, :] = dataLH\n",
+    "                    data[x//2:, :, :] = dataUH\n",
+    "\n",
+    "                    patterns = np.zeros(data.shape, patternsLH.dtype)\n",
+    "                    patterns[:x//2, :, :] = patternsLH\n",
+    "                    patterns[x//2:, :, :] = patternsUH\n",
+    "\n",
+    "                    data[data < split_evt_primary_threshold*noise] = 0\n",
+    "                    ddsetc[...] = np.moveaxis(data, 2, 0)\n",
+    "                    ddsetp[...] = np.moveaxis(patterns, 2, 0)\n",
+    "\n",
+    "                    histCalPcorr.fill(data)\n",
+    "                    data[patterns != 100] = np.nan\n",
+    "                    histCalPcorrS.fill(data)\n",
+    "\n",
+    "                    if mean_im_cc is None:\n",
+    "                        mean_im_cc = np.nanmean(data, axis=2)\n",
+    "                        single_im_cc = data[...,0]\n",
+    "               \n",
+    "        except Exception as e:\n",
+    "            print(\"Couldn't calibrate data in {}: {}\".format(f, e))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:56.094985Z",
+     "start_time": "2018-12-06T16:10:55.918900Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if correct_offset_drift:\n",
+    "    lhds = np.concatenate(drift_lh)\n",
+    "    uhds = np.concatenate(drift_uh)\n",
+    "    fig = plt.figure(figsize=(10,5))\n",
+    "    ax = fig.add_subplot(111)\n",
+    "    ax.plot(lhds, label=\"Lower hem.\")\n",
+    "    ax.plot(uhds, label=\"Upper hem.\")\n",
+    "    ax.set_xlabel(\"Frame #\")\n",
+    "    ax.set_xlabel(\"Offset drift (ADU)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:56.126409Z",
+     "start_time": "2018-12-06T16:10:56.096242Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if do_pattern_classification:\n",
+    "    print(\"******************LOWER HEMISPHERE******************\\n\")\n",
+    "\n",
+    "    patternStatsLH = patternClassifierLH.getPatternStats()\n",
+    "    fig = plt.figure(figsize=(15,15))\n",
+    "    ax = fig.add_subplot(4,4,1)\n",
+    "    sfields = [\"singles\", \"first singles\", \"clusters\"]\n",
+    "    mfields = [\"doubles\", \"triples\", \"quads\"]\n",
+    "    relativeOccurances =  []\n",
+    "    labels = []\n",
+    "    for i, f in enumerate(sfields):\n",
+    "        relativeOccurances.append(patternStatsLH[f])\n",
+    "        labels.append(f)\n",
+    "    for i, f in enumerate(mfields):\n",
+    "        for k in range(len(patternStatsLH[f])):\n",
+    "            relativeOccurances.append(patternStatsLH[f][k])\n",
+    "            labels.append(f+\"(\"+str(k)+\")\")\n",
+    "    relativeOccurances = np.array(relativeOccurances, np.float)\n",
+    "    relativeOccurances/=np.sum(relativeOccurances)\n",
+    "    pie = ax.pie(relativeOccurances, labels=labels, autopct='%1.1f%%', shadow=True)\n",
+    "    ax.set_title(\"Pattern occurrence\")\n",
+    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
+    "    a = ax.axis('equal')\n",
+    "\n",
+    "    smaps = [\"singlemap\", \"firstsinglemap\", \"clustermap\"]\n",
+    "    for i, m in enumerate(smaps):\n",
+    "\n",
+    "        ax = fig.add_subplot(4,4,2+i)\n",
+    "\n",
+    "        pmap = ax.imshow(patternStatsLH[m], interpolation=\"nearest\", vmax=2*np.nanmedian(patternStatsLH[m]))\n",
+    "        ax.set_title(m)\n",
+    "        cb = fig.colorbar(pmap)\n",
+    "\n",
+    "    mmaps = [\"doublemap\", \"triplemap\", \"quadmap\"]\n",
+    "    k = 0\n",
+    "    for i, m in enumerate(mmaps):\n",
+    "\n",
+    "        for j in range(4):\n",
+    "            ax = fig.add_subplot(4,4,2+len(smaps)+k)\n",
+    "            pmap = ax.imshow(patternStatsLH[m][j], interpolation=\"nearest\", vmax=2*np.median(patternStatsLH[m][j]))\n",
+    "            ax.set_title(m+\"(\"+str(j)+\")\")\n",
+    "            cb = fig.colorbar(pmap)\n",
+    "            k+=1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:56.176160Z",
+     "start_time": "2018-12-06T16:10:56.127853Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if do_pattern_classification:\n",
+    "    patternStatsUH = patternClassifierUH.getPatternStats()\n",
+    "    fig = plt.figure(figsize=(15,15))\n",
+    "    ax = fig.add_subplot(4,4,1)\n",
+    "    sfields = [\"singles\", \"first singles\", \"clusters\"]\n",
+    "    mfields = [\"doubles\", \"triples\", \"quads\"]\n",
+    "    relativeOccurances =  []\n",
+    "    labels = []\n",
+    "    for i, f in enumerate(sfields):\n",
+    "        relativeOccurances.append(patternStatsUH[f])\n",
+    "        labels.append(f)\n",
+    "    for i, f in enumerate(mfields):\n",
+    "        for k in range(len(patternStatsUH[f])):\n",
+    "            relativeOccurances.append(patternStatsUH[f][k])\n",
+    "            labels.append(f+\"(\"+str(k)+\")\")\n",
+    "    relativeOccurances = np.array(relativeOccurances, np.float)\n",
+    "    relativeOccurances/=np.sum(relativeOccurances)\n",
+    "    pie = ax.pie(relativeOccurances, labels=labels, autopct='%1.1f%%', shadow=True)\n",
+    "    ax.set_title(\"Pattern occurrence\")\n",
+    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
+    "    a = ax.axis('equal')\n",
+    "\n",
+    "    smaps = [\"singlemap\", \"firstsinglemap\", \"clustermap\"]\n",
+    "    for i, m in enumerate(smaps):\n",
+    "\n",
+    "        ax = fig.add_subplot(4,4,2+i)\n",
+    "\n",
+    "        pmap = ax.imshow(patternStatsUH[m], interpolation=\"nearest\", vmax=2*np.nanmedian(patternStatsUH[m]))\n",
+    "        ax.set_title(m)\n",
+    "        cb = fig.colorbar(pmap)\n",
+    "\n",
+    "    mmaps = [\"doublemap\", \"triplemap\", \"quadmap\"]\n",
+    "    k = 0\n",
+    "    for i, m in enumerate(mmaps):\n",
+    "\n",
+    "        for j in range(4):\n",
+    "            ax = fig.add_subplot(4,4,2+len(smaps)+k)\n",
+    "            pmap = ax.imshow(patternStatsUH[m][j], interpolation=\"nearest\", vmax=np.median(patternStatsUH[m][j]))\n",
+    "            ax.set_title(m+\"(\"+str(j)+\")\")\n",
+    "            cb = fig.colorbar(pmap)\n",
+    "            k+=1\n",
+    "\n",
+    "    print(\"******************UPPER HEMISPHERE******************\\n\")        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:56.190150Z",
+     "start_time": "2018-12-06T16:10:56.177570Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if do_pattern_classification:\n",
+    "    t0 = PrettyTable()\n",
+    "    t0.title = \"Total number of Counts after all corrections\"\n",
+    "    t0.field_names = [\"Hemisphere\",\"Singles\", \"First-singles\", \"Clusters\"]\n",
+    "    t0.add_row([\"LH\", patternStatsLH['singles'], patternStatsLH['first singles'], patternStatsLH['clusters']])\n",
+    "    t0.add_row([\"UH\", patternStatsUH['singles'], patternStatsUH['first singles'], patternStatsUH['clusters']])\n",
+    "\n",
+    "    print(t0)\n",
+    "\n",
+    "    t1 = PrettyTable()\n",
+    "\n",
+    "    t1.field_names = [\"Index\",\"D-LH\", \"D-UH\", \"T-LH\", \"T-UH\", \"Q-LH\", \"Q-UH\"]\n",
+    "\n",
+    "    t1.add_row([0, patternStatsLH['doubles'][0], patternStatsUH['doubles'][0], patternStatsLH['triples'][0], patternStatsUH['triples'][0], patternStatsLH['quads'][0], patternStatsUH['quads'][0]])\n",
+    "    t1.add_row([1, patternStatsLH['doubles'][1], patternStatsUH['doubles'][1], patternStatsLH['triples'][1], patternStatsUH['triples'][1], patternStatsLH['quads'][1], patternStatsUH['quads'][1]])\n",
+    "    t1.add_row([2, patternStatsLH['doubles'][2], patternStatsUH['doubles'][2], patternStatsLH['triples'][2], patternStatsUH['triples'][2], patternStatsLH['quads'][2], patternStatsUH['quads'][2]])\n",
+    "    t1.add_row([3, patternStatsLH['doubles'][3], patternStatsUH['doubles'][3], patternStatsLH['triples'][3], patternStatsUH['triples'][3], patternStatsLH['quads'][3], patternStatsUH['quads'][3]])\n",
+    "\n",
+    "    print(t1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:56.203219Z",
+     "start_time": "2018-12-06T16:10:56.191509Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if do_pattern_classification:\n",
+    "    doublesLH = patternStatsLH['doubles'][0] + patternStatsLH['doubles'][1] + patternStatsLH['doubles'][2] + patternStatsLH['doubles'][3]\n",
+    "    triplesLH = patternStatsLH['triples'][0] + patternStatsLH['triples'][1] + patternStatsLH['triples'][2] + patternStatsLH['triples'][3]\n",
+    "    quadsLH = patternStatsLH['quads'][0] + patternStatsLH['quads'][1] + patternStatsLH['quads'][2] + patternStatsLH['quads'][3]\n",
+    "    allsinglesLH = patternStatsLH['singles'] + patternStatsLH['first singles']\n",
+    "    eventsLH = allsinglesLH + doublesLH + triplesLH + quadsLH\n",
+    "\n",
+    "    doublesUH = patternStatsUH['doubles'][0] + patternStatsUH['doubles'][1] + patternStatsUH['doubles'][2] + patternStatsUH['doubles'][3]\n",
+    "    triplesUH = patternStatsUH['triples'][0] + patternStatsUH['triples'][1] + patternStatsUH['triples'][2] + patternStatsUH['triples'][3]\n",
+    "    quadsUH = patternStatsUH['quads'][0] + patternStatsUH['quads'][1] + patternStatsUH['quads'][2] + patternStatsUH['quads'][3]\n",
+    "    allsinglesUH = patternStatsUH['singles'] + patternStatsUH['first singles']\n",
+    "    eventsUH = allsinglesUH + doublesUH + triplesUH + quadsUH\n",
+    "\n",
+    "    reloccurLH = np.array([allsinglesLH/eventsLH, doublesLH/eventsLH, triplesLH/eventsLH, quadsLH/eventsLH])\n",
+    "    reloccurUH = np.array([allsinglesUH/eventsUH, doublesUH/eventsUH, triplesUH/eventsUH, quadsUH/eventsUH])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:10:56.212586Z",
+     "start_time": "2018-12-06T16:10:56.204731Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if do_pattern_classification:\n",
+    "    fig = plt.figure(figsize=(10,5))\n",
+    "    ax = fig.add_subplot(1,2,1)\n",
+    "    labels = ['singles', 'doubles', 'triples', 'quads']\n",
+    "    pie = ax.pie(reloccurLH, labels=labels, autopct='%1.1f%%', shadow=True)\n",
+    "    ax.set_title(\"Pattern occurrence LH\")\n",
+    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
+    "    a = ax.axis('equal')\n",
+    "    ax = fig.add_subplot(1,2,2)\n",
+    "    pie = ax.pie(reloccurUH, labels=labels, autopct='%1.1f%%', shadow=True)\n",
+    "    ax.set_title(\"Pattern occurrence UH\")\n",
+    "    # Set aspect ratio to be equal so that pie is drawn as a circle.\n",
+    "    a = ax.axis('equal')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:13:12.889583Z",
+     "start_time": "2018-12-06T16:13:11.122653Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "ho,eo,co,so = histCalOffsetCor.get()\n",
+    "\n",
+    "\n",
+    "d = [{'x': co,\n",
+    "      'y': ho,\n",
+    "      'y_err': np.sqrt(ho[:]),\n",
+    "      'drawstyle': 'steps-mid',\n",
+    "      'errorstyle': 'bars',\n",
+    "      'errorcoarsing': 2,\n",
+    "      'label': 'Offset corr.'\n",
+    "     },\n",
+    "    \n",
+    "     ]\n",
+    "     \n",
+    "\n",
+    "fig = xana.simplePlot(d, aspect=1, x_label='Energy(ADU)', \n",
+    "                      y_label='Number of occurrences', figsize='2col',\n",
+    "                      y_log=True, x_range=(-50,500),\n",
+    "                      legend='top-center-frame-2col')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:12:57.289742Z",
+     "start_time": "2018-12-06T16:12:45.529734Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "if do_pattern_classification:\n",
+    "    h1,e1L,c1L,s1L = histCalPcorr.get()\n",
+    "    h1s,e1Ls,c1Ls,s1Ls = histCalPcorrS.get()\n",
+    "\n",
+    "\n",
+    "    d = [\n",
+    "         {'x': c1L,\n",
+    "          'y': h1,\n",
+    "          'y_err': np.sqrt(h1[:]),\n",
+    "          'drawstyle': 'steps-mid',\n",
+    "          'label': 'Split event corrected'},\n",
+    "         {'x': c1Ls,\n",
+    "          'y': h1s,\n",
+    "          'y_err': np.sqrt(h1s[:]),\n",
+    "          'drawstyle': 'steps-mid',\n",
+    "          'label': 'Single pixel hits'}\n",
+    "    ]\n",
+    "\n",
+    "\n",
+    "    fig = xana.simplePlot(d, aspect=1, x_label='Energy(ADU)', \n",
+    "                          y_label='Number of occurrences', figsize='2col',\n",
+    "                          y_log=True, x_range=(0,200),x_log=False,\n",
+    "                          legend='top-center-frame-2col')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Mean Image of first Sequence ##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:11:08.317130Z",
+     "start_time": "2018-12-06T16:11:05.788655Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "fig = xana.heatmapPlot(mean_im,\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Signal (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmin=-50, vmax=500)\n",
+    "\n",
+    "if do_pattern_classification:\n",
+    "    fig = xana.heatmapPlot(mean_im_cc,\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Signal (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmin=-50, vmax=500)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "## Single Shot of first Sequnce ##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2018-12-06T16:11:10.908912Z",
+     "start_time": "2018-12-06T16:11:08.318486Z"
+    },
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "fig = xana.heatmapPlot(single_im,\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Signal (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmin=-50, vmax=500)\n",
+    "\n",
+    "if do_pattern_classification:\n",
+    "    fig = xana.heatmapPlot(single_im_cc,\n",
+    "                       x_label='Columns', y_label='Rows',\n",
+    "                       lut_label='Signal (ADU)',\n",
+    "                       x_range=(0,y),\n",
+    "                       y_range=(0,x), vmin=-50, vmax=500)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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.7"
+  },
+  "latex_envs": {
+   "LaTeX_envs_menu_present": true,
+   "autocomplete": true,
+   "bibliofile": "biblio.bib",
+   "cite_by": "apalike",
+   "current_citInitial": 1,
+   "eqLabelWithNumbers": true,
+   "eqNumInitial": 1,
+   "hotkeys": {
+    "equation": "Ctrl-E",
+    "itemize": "Ctrl-I"
+   },
+   "labels_anchors": false,
+   "latex_user_defs": false,
+   "report_style_numbering": false,
+   "user_envs_cfg": false
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb b/notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb
new file mode 100644
index 000000000..908d75fea
--- /dev/null
+++ b/notebooks/FastCCD/PlotFromCalDB_FastCCD_NBC.ipynb
@@ -0,0 +1,505 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Statistical analysis of calibration factors#\n",
+    "\n",
+    "Author: Mikhail Karnevskiy, Steffen Hauf, Version 0.1\n",
+    "\n",
+    "A description of the notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cluster_profile = \"noDB\" # The ipcluster profile to use\n",
+    "start_date = \"2019-01-30\" # date to start investigation interval from\n",
+    "end_date = \"2019-08-30\" # date to end investigation interval at, can be \"now\"\n",
+    "nconstants = 10 # Number of time stamps to plot. If not 0, overcome start_date.\n",
+    "dclass=\"CCD\" # Detector class\n",
+    "db_module = \"fastCCD1\" # detector entry in the DB to investigate\n",
+    "constants = [\"Noise\", \"Offset\"] # constants to plot\n",
+    "\n",
+    "gain_setting = [0,1,2,8] # gain stages\n",
+    "bias_voltage = [79] # Bias voltage\n",
+    "temperature = [235, 216, 245] # Operation temperature\n",
+    "integration_time = [1, 50] # Integration time\n",
+    "pixels_x=[1934] # number of pixels along X axis\n",
+    "pixels_y=[960] # number of pixels along Y axis\n",
+    "max_time = 15 # max time margin in minutes to match bad pixels\n",
+    "parameter_names = ['bias_voltage', 'integration_time', 'temperature', \n",
+    "                   'gain_setting', 'pixels_x', 'pixels_y'] # names of parameters\n",
+    "\n",
+    "separate_plot = ['integration_time', 'gain_setting', 'temperature'] # Plot on separate plots\n",
+    "photon_energy = 9.2 # Photon energy of the beam\n",
+    "out_folder = \"/gpfs/exfel/data/scratch/karnem/test_FCCD/\" # output folder\n",
+    "use_existing = \"\" # If not empty, constants stored in given folder will be used\n",
+    "cal_db_interface = \"tcp://max-exfl016:8015#8025\" # the database interface to use\n",
+    "cal_db_timeout = 180000 # timeout on caldb requests\",\n",
+    "plot_range = 3 # range for plotting in units of median absolute deviations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import copy\n",
+    "import datetime\n",
+    "import dateutil.parser\n",
+    "import numpy as np\n",
+    "from operator import itemgetter\n",
+    "import os\n",
+    "import sys\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "from iCalibrationDB import Constants, Conditions, Detectors, ConstantMetaData\n",
+    "from cal_tools.tools import get_from_db\n",
+    "from cal_tools.ana_tools import (save_dict_to_hdf5, load_data_from_hdf5, \n",
+    "                                 HMType, hm_combine,\n",
+    "                                 combine_lists, get_range)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Prepare variables\n",
+    "spShape = (967, 10) # Shape of superpixel\n",
+    "\n",
+    "parameters = [globals()[x] for x in parameter_names]\n",
+    "\n",
+    "constantsDark = {'Noise': 'BadPixelsDark',\n",
+    "                 'Offset': 'BadPixelsDark'}\n",
+    "print('Bad pixels data: ', constantsDark)\n",
+    "\n",
+    "# Define parameters in order to perform loop over time stamps\n",
+    "start = datetime.datetime.now() if start_date.upper() == \"NOW\" else dateutil.parser.parse(\n",
+    "    start_date)\n",
+    "end = datetime.datetime.now() if end_date.upper() == \"NOW\" else dateutil.parser.parse(\n",
+    "    end_date)\n",
+    "\n",
+    "# Create output folder\n",
+    "os.makedirs(out_folder, exist_ok=True)\n",
+    "\n",
+    "# Get getector conditions\n",
+    "det = getattr(Detectors, db_module)\n",
+    "dconstants = getattr(Constants, dclass)(det.detector_type)\n",
+    "\n",
+    "print('CalDB Interface: {}'.format(cal_db_interface))\n",
+    "print('Start time at: ', start)\n",
+    "print('End time at: ', end)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "parameter_list = combine_lists(*parameters, names = parameter_names)\n",
+    "print(parameter_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "# Retrieve list of meta-data\n",
+    "constant_versions = []\n",
+    "constant_parameters = []\n",
+    "constantBP_versions = []\n",
+    "\n",
+    "# Loop over constants\n",
+    "for c, const in enumerate(constants):\n",
+    "    \n",
+    "    if use_existing != \"\":\n",
+    "        break\n",
+    "    \n",
+    "    # Loop over parameters\n",
+    "    for pars in parameter_list:\n",
+    "    \n",
+    "        if (const in [\"Offset\", \"Noise\", \"SlopesPC\"] or \"DARK\" in const.upper()):\n",
+    "            dcond = Conditions.Dark\n",
+    "            mcond = getattr(dcond, dclass)(**pars)\n",
+    "        else:\n",
+    "            dcond = Conditions.Illuminated\n",
+    "            mcond = getattr(dcond, dclass)(**pars,\n",
+    "                                photon_energy=photon_energy)\n",
+    "\n",
+    "            \n",
+    "            \n",
+    "        print('Request: ', const, 'with paramters:', pars)\n",
+    "        # Request Constant versions for given parameters and module\n",
+    "        data = get_from_db(det,\n",
+    "                           getattr(dconstants,\n",
+    "                                   const)(),\n",
+    "                           copy.deepcopy(mcond), None,\n",
+    "                           cal_db_interface,\n",
+    "                           creation_time=start,\n",
+    "                           verbosity=0,\n",
+    "                           timeout=cal_db_timeout,\n",
+    "                           meta_only=True,\n",
+    "                           version_info=True)\n",
+    "        \n",
+    "        if not isinstance(data, list):\n",
+    "                continue\n",
+    "            \n",
+    "        data = sorted(data, key=itemgetter('begin_at'), reverse=True)\n",
+    "        print('Number of retrieved constants: {}'.format(len(data)) )\n",
+    "                \n",
+    "        if const in constantsDark:\n",
+    "            # Request BP constant versions\n",
+    "            dataBP = get_from_db(det,\n",
+    "                                 getattr(dconstants, \n",
+    "                                         constantsDark[const])(),\n",
+    "                                 copy.deepcopy(mcond), None,\n",
+    "                                 cal_db_interface,\n",
+    "                                 creation_time=start,\n",
+    "                                 verbosity=0,\n",
+    "                                 timeout=cal_db_timeout,\n",
+    "                                 meta_only=True,\n",
+    "                                 version_info=True)\n",
+    "        \n",
+    "            if not isinstance(data, list) or not isinstance(dataBP, list):\n",
+    "                continue\n",
+    "            print('Number of retrieved darks: {}'.format(len(dataBP)) )\n",
+    "            found_BPmatch = False\n",
+    "            for d in data:\n",
+    "                # Match proper BP constant version\n",
+    "                # and get constant version within\n",
+    "                # requested time range\n",
+    "                if d is None:\n",
+    "                    print('Time or data is not found!')\n",
+    "                    continue\n",
+    "\n",
+    "                dt = dateutil.parser.parse(d['begin_at'])\n",
+    "\n",
+    "                if (dt.replace(tzinfo=None) > end or \n",
+    "                    (nconstants==0 and dt.replace(tzinfo=None) < start)):\n",
+    "                    continue\n",
+    "                    \n",
+    "                if nconstants>0 and constant_parameters.count(pars)>nconstants-1:\n",
+    "                    break\n",
+    "\n",
+    "                closest_BP = None\n",
+    "                closest_BPtime = None\n",
+    "\n",
+    "                for dBP in dataBP:\n",
+    "                    if dBP is None:\n",
+    "                        print(\"Bad pixels are not found!\")\n",
+    "                        continue\n",
+    "\n",
+    "                    dt = dateutil.parser.parse(d['begin_at'])\n",
+    "                    dBPt = dateutil.parser.parse(dBP['begin_at'])\n",
+    "\n",
+    "                    if dt == dBPt:\n",
+    "                        found_BPmatch = True\n",
+    "                    else:\n",
+    "\n",
+    "                        if np.abs(dBPt-dt).seconds < (max_time*60):\n",
+    "                            if closest_BP is None:\n",
+    "                                closest_BP = dBP\n",
+    "                                closest_BPtime = dBPt\n",
+    "                            else:\n",
+    "                                if np.abs(dBPt-dt) < np.abs(closest_BPtime-dt):\n",
+    "                                    closest_BP = dBP\n",
+    "                                    closest_BPtime = dBPt\n",
+    "\n",
+    "                        if dataBP.index(dBP) ==  len(dataBP)-1:\n",
+    "                            if closest_BP:\n",
+    "                                dBP = closest_BP\n",
+    "                                dBPt = closest_BPtime\n",
+    "                                found_BPmatch = True\n",
+    "                            else:\n",
+    "                                print('Bad pixels are not found!')\n",
+    "\n",
+    "                    if found_BPmatch:\n",
+    "                        print(\"Found constant {}: begin at {}\".format(const, dt))\n",
+    "                        print(\"Found bad pixels at {}\".format(dBPt))\n",
+    "                        constantBP_versions.append(dBP)\n",
+    "                        constant_versions.append(d)\n",
+    "                        constant_parameters.append(copy.deepcopy(pars))\n",
+    "                        found_BPmatch = False\n",
+    "                        break\n",
+    "        else:\n",
+    "            constant_versions += data\n",
+    "            constant_parameters += [copy.deepcopy(pars)]*len(data)\n",
+    "\n",
+    "# Remove dublications\n",
+    "constant_versions_tmp = []\n",
+    "constant_parameters_tmp = []\n",
+    "constantBP_versions_tmp = []\n",
+    "for i, x in enumerate(constant_versions):\n",
+    "    if x not in constant_versions_tmp:\n",
+    "        constant_versions_tmp.append(x)\n",
+    "        constant_parameters_tmp.append(constant_parameters[i])\n",
+    "        if i<len(constantBP_versions)-1:\n",
+    "            constantBP_versions_tmp.append(constantBP_versions[i])\n",
+    "constant_versions=constant_versions_tmp\n",
+    "constantBP_versions=constantBP_versions_tmp\n",
+    "constant_parameters=constant_parameters_tmp\n",
+    "\n",
+    "print('Number of stored constant versions is {}'.format(len(constant_versions)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_rebined(a, rebin):\n",
+    "    return a[:,:,0].reshape(\n",
+    "                int(a.shape[0] / rebin[0]),\n",
+    "                rebin[0],\n",
+    "                int(a.shape[1] / rebin[1]),\n",
+    "                rebin[1])\n",
+    "    \n",
+    "def modify_const(const, data, isBP = False):\n",
+    "    return data\n",
+    "\n",
+    "ret_constants = {}\n",
+    "constant_data = ConstantMetaData()\n",
+    "constant_BP = ConstantMetaData()\n",
+    "for i, constant_version in enumerate(constant_versions):\n",
+    "\n",
+    "    const = constant_version['data_set_name'].split('/')[-2]\n",
+    "    qm = db_module\n",
+    "    \n",
+    "    print(\"constant: {}, module {}\".format(const,qm))\n",
+    "    constant_data.retrieve_from_version_info(constant_version)\n",
+    "    \n",
+    "    for key in separate_plot:\n",
+    "        const = '{}_{}'.format(const, constant_parameters[i][key])\n",
+    "    \n",
+    "    if not const in ret_constants:\n",
+    "        ret_constants[const] = {}\n",
+    "    if not qm in ret_constants[const]:\n",
+    "            ret_constants[const][qm] = []\n",
+    "    \n",
+    "    cdata = constant_data.calibration_constant.data\n",
+    "    ctime = constant_data.calibration_constant_version.begin_at\n",
+    "    \n",
+    "    cdata = modify_const(const, cdata)\n",
+    "    \n",
+    "    if len(constantBP_versions)>0:\n",
+    "        constant_BP.retrieve_from_version_info(constantBP_versions[i])\n",
+    "        cdataBP = constant_BP.calibration_constant.data\n",
+    "        cdataBP = modify_const(const, cdataBP, True)\n",
+    "        \n",
+    "        if cdataBP.shape != cdata.shape:\n",
+    "            print('Wrong bad pixel shape! {}, expected {}'.format(cdataBP.shape, cdata.shape))\n",
+    "            continue\n",
+    "        \n",
+    "        # Apply bad pixel mask\n",
+    "        cdataABP = np.copy(cdata)\n",
+    "        cdataABP[cdataBP > 0] = np.nan\n",
+    "    \n",
+    "        # Create superpixels for constants with BP applied\n",
+    "        cdataABP = get_rebined(cdataABP, spShape)\n",
+    "        toStoreBP = np.nanmean(cdataABP, axis=(1, 3))\n",
+    "        toStoreBPStd = np.nanstd(cdataABP, axis=(1, 3))\n",
+    "\n",
+    "        # Prepare number of bad pixels per superpixels\n",
+    "        cdataBP = get_rebined(cdataBP, spShape)\n",
+    "        cdataNBP = np.nansum(cdataBP > 0, axis=(1, 3))\n",
+    "    else:\n",
+    "        toStoreBP = 0\n",
+    "        toStoreBPStd = 0\n",
+    "        cdataNBP = 0\n",
+    "\n",
+    "    # Create superpixels for constants without BP applied\n",
+    "    cdata = get_rebined(cdata, spShape)\n",
+    "    toStoreStd = np.nanstd(cdata, axis=(1, 3))\n",
+    "    toStore = np.nanmean(cdata, axis=(1, 3))\n",
+    "    \n",
+    "    # Convert parameters to dict\n",
+    "    dpar = {p.name: p.value for p in constant_data.detector_condition.parameters}\n",
+    "    \n",
+    "    print(\"Store values in dict\", const, qm, ctime)\n",
+    "    ret_constants[const][qm].append({'ctime': ctime,\n",
+    "                                     'nBP': cdataNBP,\n",
+    "                                     'dataBP': toStoreBP,\n",
+    "                                     'dataBPStd': toStoreBPStd,\n",
+    "                                     'data': toStore,\n",
+    "                                     'dataStd': toStoreStd,\n",
+    "                                     'mdata': dpar})  \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "if use_existing == \"\":\n",
+    "    print('Save data to {}/CalDBAna_{}_{}.h5'.format(out_folder, dclass, db_module))\n",
+    "    save_dict_to_hdf5(ret_constants,\n",
+    "                      '{}/CalDBAna_{}_{}.h5'.format(out_folder, dclass, db_module))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if use_existing == \"\":\n",
+    "    fpath = '{}/CalDBAna_{}_*.h5'.format(out_folder, dclass)\n",
+    "else:\n",
+    "    fpath = '{}/CalDBAna_{}_*.h5'.format(use_existing, dclass)\n",
+    "\n",
+    "print('Load data from {}'.format(fpath))\n",
+    "ret_constants = load_data_from_hdf5(fpath)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parameters for plotting\n",
+    "\n",
+    "keys = {\n",
+    "    'Mean': ['data', '', 'Mean over pixels'],\n",
+    "    'std': ['dataStd', '', '$\\sigma$ over pixels'],\n",
+    "    'MeanBP': ['dataBP', 'Good pixels only', 'Mean over pixels'],\n",
+    "    'NBP': ['nBP', 'Fraction of BP', 'Fraction of BP'],\n",
+    "    'stdBP': ['dataBPStd', 'Good pixels only', '$\\sigma$ over pixels'],\n",
+    "    'stdASIC': ['', '', '$\\sigma$ over ASICs'],\n",
+    "    'stdCell': ['', '', '$\\sigma$ over Cells'],\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print('Plot calibration constants')\n",
+    "\n",
+    "# loop over constat type\n",
+    "for const, modules in ret_constants.items():\n",
+    "\n",
+    "        const = const.split(\"_\")\n",
+    "        print('Const: {}'.format(const))\n",
+    "\n",
+    "        # Loop over modules\n",
+    "        for mod, data in modules.items():\n",
+    "            print(mod)\n",
+    "\n",
+    "            ctimes = np.array(data[\"ctime\"])\n",
+    "            ctimes_ticks = [x.strftime('%y-%m-%d') for x in ctimes]\n",
+    "\n",
+    "            if (\"mdata\" in data):\n",
+    "                cmdata = np.array(data[\"mdata\"])\n",
+    "                for i, tick in enumerate(ctimes_ticks):\n",
+    "                    ctimes_ticks[i] = ctimes_ticks[i] + \\\n",
+    "                        ', V={:1.0f}'.format(cmdata[i]['Sensor Temperature']) + \\\n",
+    "                        ', T={:1.0f}'.format(\n",
+    "                        cmdata[i]['Integration Time'])\n",
+    "\n",
+    "            sort_ind = np.argsort(ctimes_ticks)\n",
+    "            ctimes_ticks = list(np.array(ctimes_ticks)[sort_ind])\n",
+    "\n",
+    "            # Create sorted by data dataset\n",
+    "            rdata = {}\n",
+    "            for key, item in keys.items():\n",
+    "                if item[0] in data:\n",
+    "                    rdata[key] = np.array(data[item[0]])[sort_ind]\n",
+    "\n",
+    "            nTimes = rdata['Mean'].shape[0]\n",
+    "            nPixels = rdata['Mean'].shape[1] * rdata['Mean'].shape[2]\n",
+    "            nBins = nPixels\n",
+    "\n",
+    "            # Avoid too low values\n",
+    "            if const[0] in [\"Noise\", \"Offset\"]:\n",
+    "                rdata['Mean'][rdata['Mean'] < 0.1] = np.nan\n",
+    "                if 'MeanBP' in rdata:\n",
+    "                    rdata['MeanBP'][rdata['MeanBP'] < 0.1] = np.nan\n",
+    "                    \n",
+    "            if 'NBP' in rdata:\n",
+    "                rdata['NBP'] = rdata['NBP'].astype(float)\n",
+    "                rdata[\"NBP\"][rdata[\"NBP\"] == (spShape[0] * spShape[1])] = np.nan\n",
+    "                rdata[\"NBP\"] = rdata[\"NBP\"] / spShape[0] / spShape[1] * 100\n",
+    "\n",
+    "            # Reshape: ASICs over cells for plotting\n",
+    "            pdata = {}\n",
+    "            for key in rdata:\n",
+    "                if len(rdata[key].shape)<3:\n",
+    "                    continue\n",
+    "                pdata[key] = rdata[key][:, :, :].reshape(nTimes, nBins).swapaxes(0, 1)\n",
+    "\n",
+    "            # Plotting\n",
+    "            for key in pdata:\n",
+    "                if len(pdata[key].shape)<2:\n",
+    "                    continue\n",
+    "\n",
+    "                if key == 'NBP':\n",
+    "                    unit = '[%]'\n",
+    "                else:\n",
+    "                    unit = '[ADU]'\n",
+    "\n",
+    "                title = '{}, module {}, {}'.format(\n",
+    "                    const[0], mod, keys[key][1])\n",
+    "                cb_label = '{}, {} {}'.format(const[0], keys[key][2], unit)\n",
+    "\n",
+    "                fname = '{}/{}_{}'.format(out_folder, const[0], mod.replace('_', ''))\n",
+    "                for item in const[1:]:\n",
+    "                    fname = '{}_{}'.format(fname, item)\n",
+    "                fname = '{}_ASIC_{}.png'.format(fname, key)\n",
+    "                \n",
+    "                vmin,vmax = get_range(pdata[key][::-1].flatten(), plot_range)\n",
+    "                hm_combine(pdata[key][::-1], htype=HMType.mro,\n",
+    "                          x_label='Creation Time', y_label='ASIC ID',\n",
+    "                          x_ticklabels=ctimes_ticks,\n",
+    "                          x_ticks=np.arange(len(ctimes_ticks))+0.3,\n",
+    "                          title=title, cb_label=cb_label,\n",
+    "                          vmin=vmin, vmax=vmax,\n",
+    "                          fname=fname,\n",
+    "                          pad=[0.125, 0.125, 0.12, 0.185])\n"
+   ]
+  }
+ ],
+ "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
-- 
GitLab