qpTrapper_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "micro-antique",
   "metadata": {},
   "source": [
    "## To Do:\n",
    "\n",
    "### Tonight:\n",
    "\n",
    "-[x] log-log plot of IQ\n",
    "-[x] time-series plot of IQ\n",
    "-[x] simulation time periods: few seconds @ **high SNR** (20 dB)\n",
    "-[x] update correlation periods to **few micro to milliseconds**\n",
    "-[x] test run locally and hpc\n",
    "-[] run simulation of all models (including anti-correlated - pFactor=0.5 ) [time: 10ms, corr=every 2ms for 0.5ms]\n",
    "\n",
    "### Tomorrow:\n",
    "\n",
    "-[] HMM code figure out and analyze\n",
    "-[] test run\n",
    "-[] deploy on HPC\n",
    "-[] run simulation without noise in resonator.signal\n",
    "-[] run longer\n",
    "\n",
    "---\n",
    "\n",
    "## To Do Later\n",
    "\n",
    "### studies:\n",
    "\n",
    "-[] comparative study between models \n",
    "-[] comparative study of true result and \"extracted\" results\n",
    "-[] comparative study of true result, \"extracted\" and HMM results\n",
    "\n",
    "### HMM:\n",
    "\n",
    "-[] understand HMM\n",
    "-[] run HMM framework on sim data\n",
    "-[] get transition matrix from HMM\n",
    "\n",
    "### refactoring:\n",
    "\n",
    "-[] rewrite QPTrapper from scratch \n",
    "    -[] generate all prob as multiprocessed pool\n",
    "    -[] use of CUDA and cupy for matrix mul\n",
    "    -[] use of @jit and @vectorize decorators \n",
    "-[] refactor Res code\n",
    "-[] multiprocess entire driver code\n",
    "\n",
    "---\n",
    "\n",
    "# Questions:\n",
    "\n",
    "-[] walk through of Resonator stuff\n",
    "-[] no complex noise in NBResonator.signal?\n",
    "\n",
    "---\n",
    "\n",
    "### confused:\n",
    "\n",
    "- release process for each analysis\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "centered-rabbit",
   "metadata": {},
   "source": [
    "# Dev Code [Res]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "supported-israel",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import sin, cos, pi, exp, sqrt, zeros, ones, arange, mean, inf, cumsum, array, arctanh\n",
    "from numpy.random import random, choice, uniform\n",
    "from math import factorial\n",
    "from time import perf_counter\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from fitTools.Resonator import Resonator\n",
    "import numpy as np\n",
    "from scipy.signal import butter, lfilter\n",
    "import dill\n",
    "import sys\n",
    "import random as rd\n",
    "\n",
    "\"\"\"\n",
    "input paramaters\n",
    "\"\"\"\n",
    "duration = 1e-3  # seconds to record data\n",
    "sampleRate = 300e6\n",
    "N = int(duration * sampleRate)\n",
    "tauTrap = 140e-6\n",
    "tauRelease = 40e-6\n",
    "tauCommon = 4e-4\n",
    "tauRare = 1e-2\n",
    "tauRecomb = 2e-3\n",
    "phi = 0.45\n",
    "Lj = 21.2e-12\n",
    "L = 1.89e-9\n",
    "C = 0.2776e-12\n",
    "Qi = 6000\n",
    "Qe = 500\n",
    "photonRO = 2\n",
    "delKappa = -0.1\n",
    "sim_type=\"test\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "wrong-price",
   "metadata": {},
   "outputs": [],
   "source": [
    "res_obj = dill.load(open(\"results/hpc_1/nb_resonator_small_correlated_periodic_stochastic_2022_04_12-11_27_12_AM.pickle\", \"rb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "special-habitat",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qp_trapper_obj.N - int(1e-2 * sampleRate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "standing-proposition",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_IQ(rhann,ihann,tDir):\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(rhann,label=\"I\")\n",
    "    plt.plot(ihann,label=\"Q\")\n",
    "    plt.legend()\n",
    "\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(rhann,label=\"I\")\n",
    "    plt.plot(ihann,label=\"Q\")\n",
    "    plt.xscale(\"log\")\n",
    "    plt.legend()\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"{}iq_timeseries.png\".format(tDir),facecolor='white', transparent=False)\n",
    "    plt.close()\n",
    "    \n",
    "    plt.hist2d(rhann, ihann, bins=(50, 50))\n",
    "    plt.colorbar()\n",
    "    plt.xlabel(\"I\")\n",
    "    plt.ylabel(\"Q\")\n",
    "    plt.savefig(\"{}iq_color_2dhisto.png\".format(tDir),facecolor='white', transparent=False)\n",
    "    plt.close()\n",
    "\n",
    "    plt.figure(figsize=(10,8))\n",
    "    plt.subplot(2, 1, 1)\n",
    "    plt.hist2d(rhann, ihann, bins=(50, 50), cmap=matplotlib.cm.gray)\n",
    "    plt.colorbar()\n",
    "    plt.xlabel(\"I\")\n",
    "    plt.ylabel(\"Q\")\n",
    "\n",
    "    plt.subplot(2, 1, 2)\n",
    "    plt.hist2d(rhann, ihann, bins=(50, 50), norm=matplotlib.colors.LogNorm(), cmap=matplotlib.cm.gray)\n",
    "    plt.colorbar()\n",
    "    plt.xlabel(\"I\")\n",
    "    plt.ylabel(\"Q\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"{}iq_norm_2dhisto.png\".format(tDir),facecolor='white', transparent=False)\n",
    "    plt.close()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "utility-influence",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-7.723830418849954\n"
     ]
    }
   ],
   "source": [
    "resArgs = {\n",
    "    'L': L,\n",
    "    'C': C,\n",
    "    'photonRO': photonRO,\n",
    "    'Qi': Qi,\n",
    "    'Qe': Qe,\n",
    "    'sampleRate': sampleRate,\n",
    "    'delKappa': delKappa\n",
    "}\n",
    "res = NBResonator(qp_trapper_obj, **resArgs)\n",
    "\n",
    "avgTime = 4 * res.Qt * 50 / (photonRO * 2 * np.pi * res.f0)\n",
    "nAvg = int(max(avgTime * sampleRate, 1))\n",
    "window = windows.hann(nAvg)\n",
    "rhann = convolve(res.signal.real, window, mode='same') / sum(window)\n",
    "ihann = convolve(res.signal.imag, window, mode='same') / sum(window)\n",
    "\"\"\"\n",
    "save the plot\n",
    "\"\"\"\n",
    "plot_IQ(rhann,ihann,\"res_test/default_no_noise/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "rotary-interim",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "class NBResonator():\n",
    "    def __init__(self,\n",
    "                 trapper,\n",
    "                 L=1e-9,\n",
    "                 C=0.7e-12,\n",
    "                 photonRO=1,\n",
    "                 photonNoise=0.5,\n",
    "                 Qi=5e4,\n",
    "                 Qe=5e4,\n",
    "                 sampleRate=300e6,\n",
    "                 delKappa=-0.5,\n",
    "                 fd=None):\n",
    "\n",
    "        self.port1 = Resonator('R')  #Resonator Object Instantiation\n",
    "        \"\"\"\n",
    "        info from QPTrapper Sim\n",
    "        \"\"\"\n",
    "        self.N = trapper.N\n",
    "        self.Lj0 = trapper.Lj0\n",
    "        self.Lj = trapper.Lj\n",
    "        \"\"\"\n",
    "        values calculated from QPTrapper Sim\n",
    "        \"\"\"\n",
    "        self.f0 = 1 / (2 * np.pi * np.sqrt((L + self.Lj) * C))\n",
    "        self.q0 = self.Lj / (L + self.Lj)\n",
    "        \"\"\"\n",
    "        input parameters\n",
    "        \"\"\"\n",
    "        self.photonRO = photonRO\n",
    "        self.Qi = Qi\n",
    "        self.Qe = Qe\n",
    "        self.Qt = Qi * Qe / (Qi + Qe)\n",
    "        self.sampleRate = sampleRate\n",
    "        \"\"\"\n",
    "        some physical parameters\n",
    "        \"\"\"\n",
    "        self.kappa = 2 * np.pi * self.f0 / self.Qt\n",
    "        self.kappa_e = 2 * np.pi * self.f0 / self.Qe\n",
    "        self.fwhm = self.f0 / self.Qt\n",
    "        self.diameter = 2 * self.Qt / self.Qe\n",
    "        self.f = self.f0 + delKappa * self.kappa / (\n",
    "            2 * np.pi)  # the resonator drive frequency for measurement\n",
    "\n",
    "        if fd != None:\n",
    "            self.f = fd\n",
    "        self.f_form = self.f0 - (self.q0 * self.f0 * self.Lj *\n",
    "                                 np.array(trapper.freqFactors) / 2)\n",
    "        self.f_shift = self.q0 * self.f0 * self.Lj * trapper.L1 / 2\n",
    "        #        self.SNR = photonRO*self.kappa/(4*sampleRate)*(1 - 4*self.Qt/self.Qe * (1-self.Qt/self.Qe))\n",
    "        \"\"\"\n",
    "        SNR Calculation\n",
    "        \"\"\"\n",
    "        self.pSNR = photonRO * self.kappa**2 / (4 * self.kappa_e *\n",
    "                                                (0.5 + photonNoise) *\n",
    "                                                sampleRate)\n",
    "        self.pSNRdB = max(20, 10 * np.log10(self.pSNR)) #updated SNR\n",
    "        print(self.pSNRdB)\n",
    "        #        self.sigma = self.diameter/(2*np.sqrt(2*self.SNR))\n",
    "        self.sigma = 1 / np.sqrt(self.pSNR)\n",
    "        self.complex_noise = np.empty(self.N, dtype=complex)\n",
    "        self.complex_noise.real = np.random.normal(scale=self.sigma, size=self.N) #default\n",
    "        self.complex_noise.imag = np.random.normal(scale=self.sigma,size=self.N) #default\n",
    "        #self.complex_noise.real = 0 #zero noise\n",
    "        #self.complex_noise.imag = 0 #zero noise\n",
    "        #get the response at given frequency\n",
    "        #        self._get_clean_response(self.w)\n",
    "        \"\"\"\n",
    "        passing resonator paramaters to Resonator object to generate signal\n",
    "        \"\"\"\n",
    "        kwargs = dict(fr=self.f_form,\n",
    "                      Ql=self.Qt,\n",
    "                      Qc=self.Qe,\n",
    "                      a=1.,\n",
    "                      alpha=0.,\n",
    "                      delay=0.)\n",
    "        signal = self.port1._S11_directrefl(self.f, **kwargs)\n",
    "        self.signal = self.butter_lowpass_filter(\n",
    "            signal - signal[0], self.kappa, self.sampleRate) + signal[0]\n",
    "        \"\"\"\n",
    "        adding noise to signal\n",
    "        \"\"\"\n",
    "        self.signal += self.complex_noise\n",
    "        #        self.signal = self.port1._S11_directrefl(self.f,**kwargs)\n",
    "        \"\"\"\n",
    "        dictionary of all parameters from NBResonator Analysis\n",
    "        \"\"\"\n",
    "        self.dParams = {\n",
    "            'fd': self.f,\n",
    "            'f0': self.f0,\n",
    "            'Qt': self.Qt,\n",
    "            'Qi': self.Qi,\n",
    "            'Qe': self.Qe,\n",
    "            'N': self.N,\n",
    "            'q': self.q0,\n",
    "            'photonRO': self.photonRO,\n",
    "            'sampleRate': self.sampleRate,\n",
    "            'kappa': self.kappa,\n",
    "            'fwhm': self.fwhm,\n",
    "            'diameter': self.diameter,\n",
    "            'freq_shift': self.f_shift,\n",
    "            'SNR': self.pSNR,\n",
    "            'SNRdB': self.pSNRdB,\n",
    "            'sigma': self.sigma\n",
    "        }\n",
    "\n",
    "    def butter_lowpass(self, cutoff, fs, order=1):\n",
    "        nyq = 0.5 * fs\n",
    "        normal_cutoff = cutoff / nyq\n",
    "        b, a = butter(order, normal_cutoff, btype='low', analog=False)\n",
    "        return b, a\n",
    "\n",
    "    def butter_lowpass_filter(self, data, cutoff, fs, order=1):\n",
    "        b, a = self.butter_lowpass(cutoff, fs, order=order)\n",
    "        y = lfilter(b, a, data)\n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pressed-north",
   "metadata": {},
   "source": [
    "# Dev Code [QPTrapper]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ignored-booking",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "unexpected-hawaiian",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import sin, cos, pi, exp, sqrt, zeros, ones, arange, mean, inf, cumsum, array, arctanh\n",
    "from numpy.random import random, choice, uniform\n",
    "from math import factorial\n",
    "from time import perf_counter\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from fitTools.Resonator import Resonator\n",
    "import numpy as np\n",
    "from scipy.signal import butter, lfilter\n",
    "import dill\n",
    "import sys\n",
    "import random as rd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "mental-thickness",
   "metadata": {},
   "outputs": [],
   "source": [
    "qp_trapper_obj = dill.load(open(\"results/hpc_1/qp_trapper_short_run_periodic_stochastic_2022_04_12-12_00_14_AM.pickle\", \"rb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "personalized-stylus",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_histogram(vals,bins,scale,label):\n",
    "    plt.hist(vals, histtype=\"step\", bins=bins)\n",
    "    plt.yscale(scale)\n",
    "    plt.xlabel(label,fontsize=14)\n",
    "    plt.ylabel(\"Frequency\",fontsize=14)\n",
    "    plt.show()\n",
    "    \n",
    "make_histogram(qp_trapper_obj.nTrapped, bins=50, scale=\"linear\",label=\"Number of QP Trapped\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "charitable-complement",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABN7UlEQVR4nO3dd5xcVfn48c+zvWez2U0vm0YKSSAQSiBCINKr0pQiIIiIKGJF5SegoOhXAUVRkSogHaQFAkJCD6RAeiO9J5ts77vz/P64dzYzszO7s7tzdyab5/1iX8zccs7Zm2Seueec+xxRVYwxxphEkxTvBhhjjDHhWIAyxhiTkCxAGWOMSUgWoIwxxiQkC1DGGGMSUkq8G+CFwsJCLS4ujnczjDHGRGHBggUlqloUur1HBqji4mLmz58f72YYY4yJgohsDLfduviMMaYH+OurF/D8hzfHuxkx1SPvoIwx5kAxf80L9MkbSln1dsqqt8e7OTEV0wAlIq8AEVNTqOrZsazPGGPiqbRqK3mZfUlOTo1L/SUVG3hj4V1xqbs7xLqL74/An4D1QC3wL/enClgb47qMMSZu6hoq+dtrFzFzwR/j1oZ/vH5p3OruDjENUKr6rqq+Cxyrqhep6ivuz8XAl2JZlzHGxNP20tUALFr/Wpxb0nN5NUkiW0RG+N+IyHAg26O6jDEHKFVl3prnqarb2+11L/jihZbXKzbPoax6R7e3IZxmX1O8mxAzXgWoG4E5IjJHRN4FZgM/8KguY8wBalf5WmYtvJt3Fv2j2+tuam5sef38Rzfz11fPJxFWh5i78sl2j2loqqWhqbYbWtM1ngQoVX0DGA3cAHwfGKOqs7yoyxhz4GpqrgegpGJ9t9edmpzWatunq5/p9naEmr3kn+0e8+jb1/Ho29d1Q2u6xpMAJSJZwE+A61V1ETBURM70oi5jzIFMANi2d0W31lpbX8GKLXNabZ+76ulua0NX7oB2lq1hZ9kaPlj+KJ+vS9wxNK+eg3oYWABMdd9vBZ4FXvWoPmOM6TbzA8afAlXW7uq2Nqze+n6Xy5iz5F8AHDrijC6X5QWvxqBGquofgEYAVa3B/1XHGGO6yOdrjmv9KWG697pbIox3ec2rANUgIpm4D+2KyEig3qO6jDEHkKbmev7039NZuPZl6hur49IGkfAfnYP7TOi2NnT2d69vrOnwObc/PY2Z87v/eS+vAtQtwBvAEBF5Angb+KlHdRljDiD1jTXUN1Yzc/4f4hagIt3BDS70PkDtrdzMe8seJjujIGh7//yDAEhLyWLF5jlB+9767F7ufeV85q56ihc/vqVD9an6AFi49r+dbXKneTWL7y3gq8AVwJPAFFWd40VdxpgD1/MfxSc5anpqVtjtjc3edxQ9Nvv7vLf0QWobKoK2984dRGZaLxqaaoKuS11DJZ+sfprymh387/O/8sX2j1uV2dTcELG+lz/9bdD7ZZveprGprou/RXS8zGZ+PDADOAHLImGMiRGfxnf8yWmDL+z27vjgrqzdDcDKkFmESZKCSOuh/j++eFq7ZX6w/NGw26vq9rJkwxst71dv/YAXP76F3z//5Q60uPO8mmZ+H3AtsARYCnxbRP7mRV3GmAOLLwEyJVTXlYbdnpzU8aSxr837PU+//7Ogbc988HNeb2fMZ92OT0PqTqGmvqzD9cO+AFVTX8bvnj2RTbsXsXTjW9zzUnB+751lX3Sq/M7yapr5icA4daeZiMijwDKP6jLGdLPP1r7CqIFTyc0s7Pa6a+rLu73OUNnp+WG3N/saw25vy2frXgl6X1a9vWUK+WlTfhx1OclJXf84X79zPs2+BmYtvKflTi2QuotVZKf37nJd0fCqi+8LYGjA+yHutohEZIiIzBaR5SKyTERucLcXiMhbIrLG/X/3XBljTFgVNbt5bf7vefaDn8el/rmrWqfySerEh3Ozr4m6hspOtaFZ993FfWXqbWSl55OX1TcmkzZe/uSOTp0XelfX2FRPc3PHAqa//TvL1oS9G3tv6YMA5OcMpLqu1PO8f14FqFxghZuLbw6wHMgTkZdF5OUI5zQBP1LV8cDRwHdFZDxwE/C2qo7GmQ14k0dtNsZEYd6aZ4Huz97gV1q1tdU2jTAm1JbnPvxlVOMz4QTeKY0fcgI/PNfJQRCp668jNu3+vFPnFfYaHvT+3lfP46n3OzZ5OjU5I6rjfL4m7nn5HN5ceE+Hyu8orwLUr4DTcKab3wKc7m77k/vTiqpuV9WF7utKYAUwCDgH8I/gPQqc61GbjTFR2LBzQVzrDw2Mx467DFVfVA+u+nxNPPnuj9hSspQ12z7sdBvKqvatXOt/JipJUshMz23Z/s7if/LJquhz84Vr/0uf3M6KzbPbPO/oMV9z2hGyvaa+jPU750Vdf3NzI1npvaI6dnvpKlR9LPB46rknY1Cq+q6I9AeOxHlYd56qRp2LXkSKgcnAJ0A/VfX/bdgB9ItwzjXANQBDhw4Nd4gxJgYmFZ/G9tJVrbav2fYhQ4smR5yC7ZWU5HQAVJsRafsjbU/lZtbu+IS1Oz5p2ba3aisFOYM6VGdmel6rbQ1NNazZ9hE19WU8PvsGdpU7a7QeMfo8kpKS2y3Tp80kh7R/yYY3WLLhDW6+6IOI53WmezOcRRtep7wmMZYM8fNqFt/VwKc4z0KdD8wVkW9GeW4O8DzwA1UNmujvTroI+zVJVe9X1SmqOqWoqKhL7TfGRJaeltPy2p+wdG/lZp5+/2e8GvLMjBf65A5red2310iSxPnwjzT1O9C8Nc+12nbfaxd1uA3hZhL6x2zu+u+ZLcEJnDGzaLogm9t4FqktH614HIBte1dy5OgLwh4zpHBSq23FfQ8Pej9z/h/4cPm/O9UGr3jVxfcTYLKqXqGqlwOHAz9r5xxEJBUnOD2hqv5sjDtFZIC7fwDQfdkYjTGtzF7ceu2lBvf5n3AZvmNtT+VGAG6+6AOuOfVRNuxyuhzvfO5EAJ5878fc/vS0sOd2ZpZd+HKcAJWWktnuse8s/gevfPq7sPsCA93THzgfkf3yR0Usq61A59Mm+uQNC7tvc8liAHIznS/v/fMPom8vZ03ZI0af30br48urALUHCJweU+lui0icJ8weBFao6l0Bu14GLndfXw68FMN2GmM6qLK2pOW1fz2mtIBuvfKancxaeI8nCV037vq81bZte1e2vFZV1m6fG/F8ieIjb/3OBXy6+tk2j/EHqCtmRLdQ4uINr4fd3hDwYO/GXZ+hqpRUbGx1nH/yRVOYWXlTx14MOHkADx0eOSv5N096gMtO+AtXzPgHl0y/hxmHXMfFx9/d5fRMDZ3I7RctL6eZfyIit4rILcBcYLWI/FBEfhjhnGOBy4ATReRz9+d04E7gJBFZA3zZfW/MAau8egcLvvhvTMravndlh6ciByZK3Vu5BYAtJUtatv137q+Zt+Y51u38tNW5XfXY7Otbbfvq1NtaXlfU7Gy1f2fpGtbvnI+q8vn69lf8eWLODbz52Z/ZGzJbcNPuRdQ3VrN97ypq6kvJyehD3/yRUbdd1cfu8vVBU9v3Vm0JOmbDroVh7/Luf+MbADT7grsBp42/nMNGnsuoAccwZfR5JCdHflB4YMFYCnKHMLhwApnpeSQnpzKi/xEktTNu154PVzzWpfPb4tWDumvdHz//XU9umGMBUNUPiLwkx4wYtcuY/d69rzpdMv17H8SgPuM7XU5p1TYefOtqDht5LqdH+UBoU3N9UDeT/07i5U9ub9m2q8z5p//e0ocYNWAqXhvR/8iW16HrNNU31vCvN68E4Owjf9mhcu977aKWyQm7y9fx73e+27JvYME4akOeocrJ6ENVXeSOovKaXfzzjcsY0HsMV53sPE/00FtXBx3zxJwbAOiVPYDy6n0zBavrSymv3tEyIcTvkOGn0ztnIF877g8d+t0CaTupo3Iz+7a5zlVbefy6yqtksbe19eNFncb0dF9s+zhobOXVeV3rTKhzk41u27M86nMqaoKzC4S7o6lvrHLK7abnpALzz3288j8trytrS/i/F05ueV9avS1iGaHZv/38XZg19cGJWbftXUFeVt+gbVd+ue2l1v/qfrEINwMyVGBw8rv31fO5+6WzgraFm8F31UkPtFt+oCJ3LCqS6898huJ+h0fc/8lq71YR9moWX5GI/J+IzBSRd/w/XtRlTEfsLl/H4oDkl+1R9fHhiseiyjjg8zVz76sXsLN0TVeaGNEHK4JnWO0uX9fpsipqdvHW538FYEfZ6qiTnNa5wSdapVXbeHfpg516kBacLsh7XjqH+sYaakOCRHuWbnwz6P37yx6OeGykrOjV7sy8cFkVSkO655IDFjEc2f8ovnbc/0Ws767/nskjb3+HScWRHxQeNeCYiPta6gzTPTegYCyHjggOZAW5QyKWURTygG+rOpJS+OrUX3POUb/iwmndO8Li1RjUE8BKYDhwG7ABiP6JMWM88s83vhHUHeXX1NxAaVXrb9jrdy5g9uJ/RpyFFWjZprcpr97e0qUUS41N9UHjPOB08XVEVd1e6hqcAPPM+zcFZSx4P0I261Dh8rOFToYoyBnc8vo/797I+8seZmfZ2qDjt5QsjSrgPPjW1VTV7WHuqid5fUHk5KmDClp3db696L52y2+Pv43vLP57u8dmpu4bwTjjiJsY0HtsxGNr6svYUrIEVR9pKeGfG4um2y5SctrJI85seT2wYBynHR59Tr9wstJ7MbH4ZA4aNI1++aO7VFZHeBWg+qjqg0Cjqr6rqt/ESSBrTEJ687M/87fXLqSxKXg9n1S3z78jT+R74bX5v2+1bUfp6g6V8cCsK1umMu8oCz53b+XmqMoIl38vNHAEDvz70xI9EBC0F679L4+8fS1/+u/pbdZVVbe35fX7yx5m+eZ9nTCnTwlO4XPpCfdG0frWTj3sxjb3P/DmlTQ21YdNrxQqcIJCTkZBy9+dtuws+4JmX2OrB3G/caKz+EN6ak6401qEjkn5BZ73zZP+xfA2uugAjp8QPBZ28fF3A3DOUb9qdeyoAUe3WVYseRWg/NNQtovIGSIyGSho6wRj4umzdc7srt8/P4Pbn57WclfQ0Ox0faVG8bxLXta+B8RjvSREaHdVR63bMY+quj1s3r0o7P6VW+Zw+9PTeOGj1h9I4VwWEBD82bizImT4DvXGwrtbXgd2/X288j+8Om9fIN7ZRgCeHNKFlZrSfjAI57CR57S89k/lHtn/qKBjnpjzgw6Xm5SUHDT1PpJd5Wvpk+tkvgkMEkOLDgHge2c+x7dOeSTi+ZF+744u+zFt/DeCrsXwflO45pRHmTCs9bpPx0+4mt4Bd8kdvZPvCK8C1O0i0gv4EfBj4AGg7a8qxrSjvrGaFz++LexzIh01f83zvPTJ7WzavYi1Oz5tyUbg98LHt7Bi82yWbJgFELEbJrR9fh0dq+mcSJNeW4umixJg+eZ3okp4mpfVOuNYtIlGA81d9VRLDrq3F93H5wFLTzz5XuRuqXAL83XEtac9wSmH3Rg0yeDZD36Bqi8oDRLAlj1LQk+P6KIv/YFzj94X5M875nYumX5Pm+f4r2W4GY8ZaTlhH9wtyB3CuCEnRCwzJWA8LBoiSUGzIUWEvvkjgx4p8EtKSubKL/+D4yZcxYxDrmP0wGM7VFdHxHyauYgkA6NV9VWgHGdFXWO67NV5d7Ji82yWbXqrzdxk0fB/i18SYcLEyi1zglYsjWYqbeDSA/7Xzb4mkiQ57Adqs68pqjV8Ij3w2iurX9RlhGYI650zuNUgv99js7/Ht099rKXNPl+zkycu4Ft5dkZvTjr0+7z1+V9atg3vNyXic0Z9coeiqq2uw9uL7mPM4OPJz+q/r6XqC/vB6BeLb+yFecMoDMm6sGXPEpZt+l+Xyh09MHhiw7gh0wE45bAbmRVw5xgoxe0a7JMXfQ7Rrx/3J3rnDIy4PyM1l9zMIk6c9J2oyxxcOBGgzbEzv6z0fI47OPZjraFifgelzqT6r8e6XGP2VGyKW91tPQfi5wtYI2jF5ndQ9fG7Z6fzP3e2XKDVWz/gd89Oj2rG32+fPb7VtonDTqG8Zge/e3Z6VGNRoZMbmn2NTCo+jZsv+oCjDgrORVdSsYH3lj0UVP+dz53Y8ozPseMuIy0lk6PGXBh0Xm5WUcRccHsqN0Wc5NDYWBP0O97xzHEt07vDufrkh8Juj/TBGvplpq0AF00+P7/DR30l6mOPGH0eAwvGhd3n7+aMJm2SX1vBCZyuv++f9QITi09u87hAORkF3HzRB1x1csemqXvJqy6+D0XkryLyJRE5zP/jUV3mANGZ5bQDdXSacqh7Xw3/4auqvLnwz7yxYN835Dc/+0vLIH+450RWuSumfr7+taDtNfXlvPzJHTQ01qCqzAyz7PfVJz8cdD+0dONbbbbbP3MvsL0VNTtJTXG65HqHyeTtzLz7gsfdB0fBmfINkbs76xoq6ZU9oOX9jEOu49hxl7W8X7j2JdbtaD3ZZE9l6y8eoZNVonHJ9Ls568hfcN4xv+GyE+7l7CN/2SoV0TFjL+H8Y4MT2n7vrOdbXgeO9Q3u0zoF0DdO/BuD+hwMQHZGx4bVLz7+Lq466UGSk4K735qiyA943elPBXUdRqOr3aCJwKsAdShwMPBr9q0BFXmOqImrbXtXMm/N8zEf2I+17aUr2z+oDW8svKv9g9pQXr2diprgO6nNuxdTWrWFT9c8S21D8FLku8vXt7zeuOuzoOub4c6yCs2u/caCu1i84XU+Wf0MTc0NLAyz3k7/3qODuufCrTAbKDS564ZdC4F93ZYHD209EA7wr1lXBK399PoC5/oFpjAKvJuZt+Y5Dh91LgDnH3sHU8dezAmTvh1U5n/ebT0UvSTMBJAy96HagwaGT/oaTkZaLocMP51xQ05gWN/JTBp+Wqs8c4MLJ5Kf3T9oW6+sfi1rKq3bse93u+LLrfPsDS06pCVA5wcE42jbN6BgDDmZfYK2RzPbryB3MBOGncxph/+YUw+LlC2u5/EqQF2lqicE/gBXt3uWiYuH3rqaWQvvZl2Mp1KralSLyEUj3IOkHSm7uq60y+MLAH955astr32+Jh595zpmRVhVdPbifZkFHpv9vaBnjQLvqgK7s5Zvfhtwph83NtdGbEdg0tP2xgxCF5Xzp9Pp5+aRy0zPY2QUU4dr6ltPngjsLktJTiMlOY2bL/qAsYP3ddlNn3hNm+WGWzjwQTcF0Optwd1zXR17XL9zftjtc1c9FfQ+N9PJEjFt/BWtjp04zOk2K+7buU6hY9zkrv4HcVduebdl3+iBx0bsCgQ4fNS5TBn91Yj7exqvAlTrRVeg7fTAJu4Cg4Cqj9ufntbyD/f2p6dFXMIgnMraEu587kT+1om1dsIJTaD57Ac/545nvsTqrR/w0ie3c9/Mr/Pvd66POCW4oSm2GZe37lnOb5+dDtBq1pe/Wyv0js+/5EGoO5+b0eraigj1IVmibzr/HX5xwRwAxg/dN/fooEGR/1zCdan5pQZ01fmXXgh8yDaU/8+gKC98apyJw04Juz2wm88v9M4qkuSkNArzigH40bkzozqnLdE8LgDw/bOcj7DjJ1zFNaf4M3g4XWaThp/GT897q1Wqo2gdNvJcfn7BHPr3bv3A6wXH3tHyDJSJ8Sw+ERmL07XXS0QCw3we0PE5qIaVW94lLSWLEf2PCLt/0+5FbNr9OUMKJ/HyJ3dQWbubG87+L9kZvaMqP3CGmAaMbPi7Xf73+V/b/NCKpLx6B82+Rsqqt7U7Kysaof30/jGcZz64qWWb/2HTeaufY3j/I4JmaQVOVDjryF9SVr2tzdQ3APnZA1u6mgJV1pawpWRpxPMGFIS/o8kIyDQwpOiQVs8kBXYBrtg8O2is58RJ3wmaOjx5xNlU1Oxi7qqnWmXEBpi/5gWKeo1oM3v32MHHtbw+7uCr6NtrFKMHTmX55neYOT9ymp4jRp8X9P5bJz/MRyuf4OTJPwh7vIgwpHBSUIAeO+h4stLywz6AHOj6M59BJIlte5aHXcU2Wj84+yVe+uQ3nBDhbu6I0ee3dLeefdTNLX9fRYSsjHwgeBJDRyY0hBIRkiWFsYOn88HyR+kVMIMxKSnFs7uG/VGsr8UY4EwgHzgr4Ocw4FsxruuA8NyHv+Q/795IVd3elkSdPl9TS1qef7/zXeYs+RePzf4e5TU78GkzM+f/odXAeKjm5kZKKjYE9f/7z1mxeXZQOqDAILA2oI++rbK37d2XgDRwDZvK2hJKKja2OwheVr2D2oZ9kxoaAp4xas+sz+7hH69f0vK+vrG6JaABHDL8NI6fcFXQOUeMPp9xg6cDUNzvcC4+/m6uP/MZDh76ZWYccl3Qsf+dexuZaeET85906Pcoyguf22zlljkt6xkFfij5hS72t8idQHHa4T/mmHGXBO1LTcngy4c6iVqXbHijpbtzT+Um9lZu4Y2Fd/HY7OvJTt/3RWVo0aEtryePOJvMtLyA8tKZWHwyGWm5QQ9sAhw89KSg9+mp2UHv+/UezVem3trmw7KBdYHTHTh55FmtjgtcOgOcoJ6TUdDmXWI0cjL7cMn0eyJOHJg2/vKW15OKTw3al5WWR3HfwznjiJ+GntYlhXnDGFgwjrOPCp8H0MT4DkpVXwJeEpGpqvpxLMs+0D0x+wZqGyr4wTkv8eZnf2H+Fy9w/Znhe01XbX0f3ye/4aIvRf52OnPBH1s+AP12lK5i+95VPP/R/4t43pPv/pArZvyjzUXOQstu9jWQivPh9eeXzwWcJRIuPj7ypIX7Zn6NYUWTuWS6MzPu5U/uAJy8Yh3Nkv1KhGXIC/OKKanYwJlH/JxDR4Rf6O0rU28FYGT/o7l/lrMmz8Zdn7Fx12etjp1xyHUcNeaioMAa6rHZ13PBsb/F52tCJCkok8KLH98a4az2x9pWbX2PZl8TL358S9B2/13Bj7/yBhU1O7l/lvNBvLOs7entRx50IZ+ufgaAM474KQMLxrU88xQug3Z7xg4+Pmg8yT+DMPBO8uLj72ZE/yP4aMUTLamYUtpY3yiWsjN6M6ToEErKN7Tal5SUwqUn/DnmdaYkp/HNk/4V83J7Ek/Wg7Lg1HUNjTX8IWCpgN0VzoywwLGK/30eua86dOB50+5FLevZDC6c2CrxKDjTgDPayf0FsGXPUvrmj+QPz5/Ual92RgHVATnUwPlAHxPQnQTBs6Ug+Pe6+uSH8fmaWL9zHrc/PY3zjvkNW/Y4XWqHjjizQwHqrv+e2ZKJOjezKGhJhKtPfpAtJcsY1vfQdsvpmz+Cb53yCP+adUXEY/xjJZlpeVx3+pOUVm2lsnYPr84LzuLw7Ie/aDm+pGJDu3WHy9oQ6rkP217rKD01O2hxvdC1jEL1Cch+nZaS2RJQoHPT/ScWn8rLn97R8j4zrRcAl03/c8tYXi/397x8xn0sWj+TQX0O7nLXcEdcNO33bT5/ZbqfdXcmqMBlrCNZGdIlFOrFj29jk/vtNHCxtXDBye+jlU+E3X7d6U+1dBf97/O/8vyHEZYnCAlOAEs2zuKdxf/gryHPEfkfUg3N0vBASDbwNz/bl61g/JDo16585dPfBi2TcMn0u4MGtlOS0ynud1jUH4J9e7VePTUwzUvgczEFuUMYOeDoVtkKAmWl53PpCX/hmHGXBm0/9+jgu6C2knP6k3q2x9+1de1pj5OVns83Tmz98HCggwZ9Kej96IHHMKD3WEYOOJr0KHLMhav/utOfDHoPwXdj/mSrqSkZTBn9VQYUjOlwPV2RkZbTagq4iS8LUB4rq94RlAInWp195idwxtSyTW/x73e+2+ZaRmkpWQzvNyXsvtzMQvrkDuPoMV+jIHcw3z9r32qloTPXwvF/oK/c8i4frXicspBF2GYv+Req2uaEAyDoQz4jLYdT3MF4f0brK7/8T4YUHcKk4tOCslwvWr9v1ldaSmbLHU5n+Qf7A411x60ACnNbp6rx13nGETe12jey/1EU9z0s6M9s7ODjmTDsJG6+6IOWn7YC6Ij+R7Sb+ufGc/bltyvMK+aH575KbmZhm+eEJn7NzSzkqpMf4OvHdf5xxoLcIYzofyRjBh0Xdn9XH8Q2PY8nXXwikg6cBxQH1qGqv+5CmacCfwaSgQdUtXtXzuqEDTsX8vic7zNx2Cmcc3TkcZ1wPlzuTG296fy3+fvMSyiv2dHuOcdPuJovHXwFW/YsY6P7MCbAP16/tNWxE4tP5ZyAwdl/zbqy1bjE8H5HcvZRv2h5n5ycSnZ6b6rDPA8T6itTb+PgoTN45O3vhL1jy0rP54vtH7F4w+sRx4j8/M+u+O+ejjjofI44yFmd9LCRZwNwecDU3IbGav63KLj7M/QupbMun3FfUHfkwUNP5BW36ypc9uqMtJyWZ3dWbpnD2u1zW/YN6zsZcLrfpoz6KvO/eIHTp/ykw20qC7OOld95x/wm6hmdgfz5/dpa6K4zwo07Tio+jcUbXu9UslnTs3kSoICXcBLFLgC63KnrJqD9G3ASsAWYJyIvq2r0a1V7bOWWd/l4xRMM6zuZ6ROv4cW5t7YMpC/ZOIt++aM4emzrFIWrt37A+p3zycvqy4rNswEYOeBo6hqrGFI4iZTkdC494c80NNZQ21hJXmYRW/csp7xmJ7mZhQjC5+tfY9Puz1vGj7469TYWfPFiSz41fw61QKEfBhdM+x0bdy0kIzWHgX3Gs2TDLI4e0/oZpmtPf4I/vbhvHZ+TDv0+qs30yRtGRc1OXl/wJ4CWb+jhslOMH3Ii2RkFzFvzXFBwOn3KT1H1sXTTW+Rn9WfJxllB59U1tr+qLdCqm2bq2Itb5ZvrihvPeYXP1r3CmEFfirgeTzjnHHUzeyo3s7dyC6o+BvXZt8jeiZOuZcKwk6NesiJQTmZh2OzpMw65LugOr6OuPe2JTgW3jjrlsBuZPPJsMtLaH/80BxavAtRgVT21/cOidiTwhaquAxCRp4BzAE8C1JINs4KWTojunDfYunc5uyrWk5GW2xJs/D5d82zYDzN/+p3czL6oNiOSzMfuOJB/plxorrTQb7UHDZrGO4v/yaHuKprZGb2ZOvYSlm58M+gZmdzMIsYPOZGSyo2MHxK8fmR+dn/yh+8LPKHTmv0y0/I4ZfIP+GjlEzQ113PE6PNIStq3VEVdYxU7y75gQG9n/ODY8d9gyYY3OGT4GSzZMIvk5FROP/wnQU/PA0wYdgqTik8lJTmNw0edS3VdKau2vh/0gO2Jk64N26ZQI/ofRVZ6fsv407TxVwQN8ndVdkZvpo3/Rsv70w7/Mb2y25/IkJWeT1Z6PkPcrNGB0lKz2pwZ2ZZzjrq5JfMCOLnl5q58kqMOuqhL+djaGj+LpfTUrLDXxBiJVSqaoEJF7gfuVdXoF1Jpu7zzgVNV9Wr3/WXAUap6fcAx1wDXAAwdOvTwjRs7v2bQX1+9oNV4SWdlpOZwyPAzwiYMDXXs+G+QnpLdsrz0pdP/QnG/ruXYnb/m+ZalJb531vMtM6XiraJmV0vaoAnDTo6YCPPdpQ/y/rKHOWbcZZwYZfYBv5nz/8iabR9xw9kvtH/wfu5PL55BbUM5w/oexmUn/KX9E4xJICKyQFVbDYZ7FaCWA6OA9ThdfAKoqk5q88TI5bUboAJNmTJF588Pn3MrGjX1ZZ3KIZeZlktdYxWqSnJSCj71kZqcTkpyetBsskj83Ts19WUkJ6WQEeFh0I6qqS8jLSWrw4uYea2hqZbGpjoy0/KC7sJCNTXXk5yU1uG7AVWl2deYcL+3V/zdqZ15TsmYeIoUoLz6m3xajMvbCgT2aw12t3miM+MA7Z3bkb78WPf7d+X38VJaSmZUKWM6Ms4TSEQOmOAEFphMz+PJHVSsiUgKsBqYgROY5gEXq+qyCMfvBrq6LnghUNLFMnoCuw4Ouw772LVw2HVwxOI6DFPVotCN+8VXLlVtEpHrgVk408wfihSc3ONb/aIdJSLzw91yHmjsOjjsOuxj18Jh18Hh5XXYLwIUgKrOBLqeb98YY8x+wTJJGGOMSUgWoCK7P94NSBB2HRx2Hfaxa+Gw6+Dw7DrsF5MkjDHGHHjsDsoYY0xCsgBljDEmIVmAMsYYk5AsQBljjElIFqCMMcYkJAtQxhhjEpIFKGOMMQnJApQxxpiEZAHKGGNMQrIAZYwxJiFZgDLGGJOQLEAZY4xJSBagjDHGJCQLUMYYYxKSBShjjDEJyQKUMcaYhGQByhhjTEKyAGWMMSYhWYAyxhiTkCxAGWOMSUgWoIwxxiQkC1DGGGMSkgUoY4wxCckClDHGmIRkAcoYY0xCsgBljDEmIVmAMsYYk5AsQBljjElIFqCMMcYkJAtQxhhjEpIFKGOMMQkpJZaFichhbe1X1YWxrM8YY0zPJaoau8JEZrsvM4ApwCJAgEnAfFWdGrPKjDHG9Ggx7eJT1RNU9QRgO3CYqk5R1cOBycDWWNZljDGmZ4tpF1+AMaq6xP9GVZeKyDiP6mqlsLBQi4uLu6s6Y4wxXbBgwYISVS0K3e5VgFosIg8Aj7vvLwEWe1RXK8XFxcyfP7+7qjPGGNMFIrIx3HavAtSVwHeAG9z37wF/96guY4wxYWzYWcu371tKXYPPszrGDM7m/u9O8KRsTwKUqtaJyD+Amaq6yos6jDGmp6ipb2bR+gp8sZuzBsCi9ZWUVjVx1hFF5GV5cz/SNz/dk3LBowAlImcD/wekAcNF5FDg16p6thf1GWPM/uzf72zlof95M48sOQm+d9Yw8rNTPSnfS1518d0CHAnMAVDVz0VkeDQnisgGoBJoBppUdYqIFABPA8XABuBCVS2NeauNMcZDPp/yt5mb2FvZGLR9ycZKeuekcNdVY2NeZ3526n4ZnMC7ANWoquUiEritIzevJ6hqScD7m4C3VfVOEbnJff+zGLTTGGO6zZY9dTw2exv52SlkpiUH7TtxUh8OHpobp5YlJq8C1DIRuRhIFpHRwPeBj7pQ3jnAdPf1ozh3ZhagjDEJ4Q/Pr+OVebvbPc6fGOGWr4/i2HG9vW7Wfs+rAPU94JdAPfAfYBbwmyjPVeBNEVHgn6p6P9BPVbe7+3cA/UJPEpFrgGsAhg4d2rXWG2NMGxavr6S8tqnl/Ucry+jbK43jJxS0e25mWhKHjcjzsnk9hlcB6gxV/SVOkAJARC4Ano3i3GmqulVE+gJvicjKwJ2qqm7wImT7/cD9AFOmTInxXBhjjHFsLqnl6r8ubbX9gmP78/2zhsWhRT2XVwHq57QORuG2taKqW93/7xKRF3EmW+wUkQGqul1EBgC7Yt1gY4xpT7NPue3JtQD89LzhjB+S07JvZP+seDWrx4p1NvPTgNOBQSLyl4BdeUBT+LOCzs8GklS10n19MvBr4GXgcuBO9/8vxbLdxhgTjU27a1m8oRKAEyYW0Cc3Lc4t6tlifQe1DZgPnA0sCNheCdwYxfn9gBfd2X8pwH9U9Q0RmQc8IyJXARuBC2PaamNMj7BmWzXfuW8Z9Y3eZE7wP0j752+Ns+DUDWIaoFR1EbBIRP6jqo3tntD6/HXAIWG27wFmxKCJxpj9kKqyYG0FtfXNbR732boKKmqb+crRfcnJ9GYEIys9mckjbTp4d/BqDKpYRH4HjMdZGwoAVR3hUX3GmB5sycYqrvv78qiOTUkWvnfmMM8ClOk+Xv0JPoyTTeJu4ASc5LG2vLwxpkOWb6ri6Q+2s6usAYDbLx3NkMKMNs/pnZNqwamH8OpPMVNV3xYRUdWNwK0isgD4lUf1GWN6oFfm7WLWwhIGFKRz8NAcpo3vTVZ6cvsnmh7BqwBVLyJJwBoRuR5nNd2cds4xxhhKKhq49E+LqaxtosmnDCnM4LmbJse7WSYOvApQNwBZOCmOfoPTzXe5R3UZYxLYxt21bNhZG/XxG3bWsreqkVMmF9K/dxqHWtaFA1bMA5SIJAMXqeqPgSqc8SdjzAHqhw+sZHNJXYfPu/qUwQwryvSgRWZ/EfMAparNIjIt1uUaYxKTqnLfzE3sKG0Iu397aT2nHV7IxccNjLrMnMxkBvVpezKE6fm86uL7TERexkltVO3fqKoveFSfMSZO9lQ28ug72+idk0JORuuPlIEF6Zx0aCFjBmfHoXVmf+ZVgMoA9gAnBmxTwAKUMQnqL69s5Mn3trd/YCtOeoUfnzuckyYXxrZR5oDmSYBSVRt3MiaB1DU2M29NBU3NkVMAfbSylL75aZzSiSCTnprE1HH5XWihMa15EqBE5CDg7zjrOE0QkUnA2ap6uxf1GWPa9tq83fz++fXtHnfGlCKuO93WUzOJwasuvn8BPwH+CaCqi0XkP4AFKGO6yavzdjF3VRkA63Y407wfu3ES0kZOF5s1ZxKJVwEqS1U/dbOS+7W73IYxJnb+/c42dpXXt2TdnnFIH5uoYPYrXgWoEhEZiTt6KiLnA50ZfTXGtGHtjhqu/stS6hpbZ/lu9sFXp/bjpvMtR7PZP3kVoL6Ls/z6WBHZCqwHLvWoLmP2eyUVDSxxF8LriCUbK6mub+arU/vRKzv4n7MApx1eFKMWGtP9vJrFtw74cuAKuV7UY0xPcc/LG3jzsz2dOjc5SfjO6UPolZUa41YZE19ezeJLB84DioEU/1iUqv7ai/qMiaemZuXulzZQVt3hNTpbLFhbwdjB2fy/i0Z2+Nxe2SkWnEyP5FUX30tAOc6y7/Ue1WFMQti4u5ZnP9xBUV5qp5eCyM1I5pTJhYweaJMYjPHzKkANVtVTPSrbmA779VNf8Nr83Z6UrU4iBW75+iiOPCjfkzqMORB5FaA+EpGJqrrEo/LNAWztjpoOLd8AMG9NOcV9MzlxUoEnbcpMS7ZlIYyJMa8C1DTgChFZj9PFJ4Cq6iSP6jMHkB8+uJLtezvec3zJ8QP49qmWJcGY/YVXAeo0j8o1B7Dlm6p44t1t7Cpr4Kwjirj4+OiXb0BgWJEt32DM/sSraeYb3TWhRqvqwyJShC35brro9YW7eXvRHob3y+SkyYWMHJAV7yYZYzzk1TTzW4ApwBjgYSAVeBw41ov6TM/y37k7+d1z61omHwQa1CedJ39yaLe3yRjT/bzq4vsKMBlYCKCq20Qk16O6DLC5pJZVW2vi3YyYeHvRHjLTksJ24U0cZn+NjDlQeBWgGlRVRcSfi88e7vDYLU98wdJNVfFuRsyMH5LNNacMiXczjDFx5FWAekZE/gnki8i3gG/iLMFhYmD73nr+/vomGpr2LT63dkcNxx3cm+/0kLV8+uWnxbsJxpg482qSxB9F5CSgAmcc6leq+pYXdR0oNGBA5qOVpbyxsIShRRkkJzlppAYUpHPKYYWM7G8TB4wxPYNXd1C4AcmCUgxs3FXLZXcvpq4heLnux380iYzUzqXWMcaYROfVLL5K3LWgApQD84EfudnOTRirtlSzaXdwloQVW6qpa/Bx3jH9KMhxkoIOKcyw4GSM6dG8uoO6B9gC/Acni8TXgJE4s/oeAqZ7VO9+7/p/Lqe8pvXiw8lJ8K2Th1CQa1mrjTEHBq8C1NmqekjA+/tF5HNV/ZmI/MKjOvcbqsrfXtvE5pK6VvvKa5q4cFp/zjumX9D23MwUC07GmAOKVwGqRkQuBJ5z358P+D+Nwzx+2T4RORX4M5AMPKCqd3a5lTHS7OvYr1Rb38y/Z2+jT24q+SGroB40MIuTDu3D8H422cEYc2DzKkBdghNM7sMJSHOBS0UkE7i+o4WJSDLwN+AknK7DeSLysqouj12TO+fdpXv52SOr6GCMAuA7pw3l7KP6xr5RxhjTA3i55PtZEXZ/0IkijwS+8E+uEJGngHMATwLUe0v3UhsyYy6SOUv34lO45pTB+FcOjkZqsnCCR0s/GGNMT+DZNPMYGwRsDni/BTgq8AARuQa4BmDo0K49rHrXSxvY1oHlHPr3TuPqky3rgTHGxNL+EqDapar3A/cDTJkypVPjXH5/u3Y8Tc3RF2GTF4wxJvb2lwC1FQi8RRnsbvPEoD62bpAxxsSbaLg1DbpaqEg6cB5QTEAQVNVfd7K8FGA1MAMnMM0DLlbVZRGO3w1s7ExdAQqBki6W0RPYdXDYddjHroXDroMjFtdhmKoWhW706g7qJZzMEQtwlnzvElVtEpHrgVk408wfihSc3ONb/aIdJSLzVXVKV8vZ39l1cNh12MeuhcOug8PL6+BVgBqsqqfGskBVnQnMjGWZxhhjEleSR+V+JCITPSrbGGPMAcCrO6hpwBUish6ni08AVdVJHtXnhfvj3YAEYdfBYddhH7sWDrsODs+ug1eTJIaF266qXZ24YExCEpE+wNvu2/5AM7AbGAX8W1Wvi3F9jwDHA79X1X90saz/Ay4D/qiqf4xB84yJCa8ySVggMgcUVd0DHAogIrcCVd3wYf8TVX2u/cPapqo/EZHqWDTImFjyagzKGAOIyHQRedV9fauIPCoi74vIRhH5qoj8QUSWiMgbIpLqHne4iLwrIgtEZJaIDIiinkdE5O8iMldE1rn1PiQiK9y7LUQk2T1uqVvnjZ7+8sZ0kQUoY7rXSOBE4GzgcWC2qk4EaoEz3CB1L3C+qh6Os37aHVGW3RuYCtwIvAzcDRwMTBSRQ3Hu8Aap6gS3zodj9UsZ44X9JZOEMT3F66raKCJLcJ7pe8PdvgTnwfYxwATgLTf5cDKwPcqyX1FVdcveqapLAERkmVv2u8AIEbkXeA14Mya/kTEesQBlTPeqB1BVn4g06r5ZSj6cf48CLFPVqZ0t2y0r8AF5H5CiqqUicghwCnAtcCHwzU7UY0y3sC4+YxLLKqBIRKYCiEiqiBwci4JFpBBIUtXngZuBw2JRrjFesTsoYxKIqjaIyPnAX0SkF86/0XuAiKm9OmAQ8LCI+L+Y/jwGZRrjGU+egzLGeMudmfdqLKaZu+XdSvdMjTcmatbFZ8z+qRz4jYhc29WC3Ad1LwXsWSiTUOwOyhhjTEKyOyhjjDEJyQKUMcaYhGQByhhjTEKyAGWMMSYhWYAyxhiTkCxAGWOMSUgWoIwxxiQkC1DGGGMSkgUoY4wxCckClOlRRERFZFQCtGOOiFwdp7ozReQVESkXkWfj0YZYEpErROSDeLfDdD8LUCauRGSDiHw53u3oYc4H+gF9VPWC0J3u0vOPd3+zvCEi6SLyOxHZJCK1IrJGRH4s7oqP7jFzRKRORKpEpEREXhCRAfFst2mfBShjEpg4OvrvdBiwWlWburHOeHoWmAGcDuQClwHfBv4Uctz1qpoDHATkA3d3YxtNJ+xPfwlNAhORm0RkrYhUishyEflKyP5viciKgP2HichjwFDgFfeb7U9FZLqIbAk5t+UuS0SOFJGPRaRMRLaLyF9FJC3KNs4Rkd+IyIduO950F/EjinpvFZFnReRx99wlInKQiPxcRHaJyGYROTmkypEi8qmIVIjISyJSEFD20SLykft7LBKR6SHtvENEPgRqgBFhfpdx7nFlIrJMRM52t98G/Aq4yL2mV4Wcdyrwi4D9iyLVKSJXBvyZrRORbweUM11EtojIL9w7kg0icknA/kdE5B8i8pZ7/rsiMixg/1h3314RWSUiFwbs6yMiL7vX7VNgZBt/pjOAk4HzVHWpqjap6lyc7Ow3iEira6eqe4HngQluGT8Tka1uO1e5ZZpEoKr2Yz9d/gEuAAbifOm5CGfphgEB+7YCR+AsaT4KGObu2wB8OaCc6cCWkLJbjgEOB47GWcivGFgB/CDgWAVGRWjjHGAtzjfoTPf9nVHWeytQh7Ncegrwb2A98EsgFfgWsD6krq04H4LZOB+Ij7v7BgF7cL7xJwEnue+LAs7dBBzs1pUa0q5U4AucQJMGnAhUAmMC2vp4G39WrfaHqxM4Ayc4CHA8TuA6LOB6NQF3Aenu/uqANjzituk4d/+fgQ/cfdnAZuBKt67JQAkw3t3/FPCMe9wE9zp+EOF3uRN4N8K+jcC3An6/q93XhcA7wGPAGLctA919xcDIeP97sh/nx+6gTEyo6rOquk1Vfar6NLAGONLdfTXwB1Wdp44vVHVjJ+tZoKpz1fmmvAH4J86HY7QeVtXVqlqL8yF4aAfOfV9VZ6nTdfYsUIQT4BpxPlSLRSQ/4PjH1PlWXw38P+BCEUnG+XY/U1VnutfrLWA+TsDye0RVl7m/Z2NIO44Gcty6G1T1HeBV4Osd+F3CCapTVV9T1bXun9m7wJvAl0LO+X+qWu/ufw24MGDfa6r6nqrW4wTyqSIyBDgT2KCqD7t1fYYTwC9wr895wK9UtVpVlwKPttHmQmB7hH3bcf6M/P4iImXAInffD4FmnAA6XkRSVXWDqq5t5zqZbmIBysSEiHxDRD53u5zKcL75Frq7h+DcucSinoNE5FUR2SEiFcBvA+qJxo6A1zU4H/TR2hnwuhYoUdXmgPeElLc54PVGnLuSQpwxogv818q9XtOAARHODTUQ2KyqvpDyB0X7i0QQVKeInCYic91uuDKcABp4rUvd4BvYhoHhylPVKmCvu38YcFTI738J0B8noKTQ+tpFUkLwdQs0wN3v931VzVfVQap6iaruVtUvgB/g3FXuEpGnRGRgmLJMHFiAMl3mji38C7geZ+ZYPrAUp2sInA+bSOMIoStmVgNZAWUnE/wt+O/ASmC0qubhdHMJXddevZ0xJOD1UKAR5wNzM87dVX7AT7aq3hlwfFsriW4DhkjwRIahOF1h0YhUdst2EUnHuav5I9DP/TOdSfC17i0i2SFt2BbwvuX3F5EcoMDdvxmnWy7w989R1e8Au3G6DkOvXST/wwl2gccjIke5573bxrkAqOp/VHUaTuBU4PftnWO6hwUoEwvZOP+wdwOIyJW4A9CuB4Afi8jh4hgVMGC+k+BJAKuBDBE5Q0RSgZtxumD8coEKoEpExgLfidHv0F69nXGpiIwXkSzg18Bz7h3X48BZInKKiCSLSIY76WBwlOV+gnP391MRSXUnWJyF080YjZ043ZFt/ftPw/n9dwNNInIazmSEULeJSJqIfAmn6y7wuavTRWSaOJNYfgPMVdXNON2RB4nIZW77U0XkCBEZ516fF4BbRSRLRMYDl0dqpKr+D3gbeF5EDnav59E41/jfqrqqrQshImNE5EQ3INfh3An72jrHdB8LUKbLVHU5zpTej3E+/CYCHwbsfxa4A/gPzsD5f3G+TQP8DrjZ7er5saqWA9fhBLWtOHc2gbPrfgxc7JbzL+DpGP0O7dXbGY/hTBbYAWQA33fr2gycg3P3txvnjuInRPnvUVUbcALSaTh3ZPcB31DVlVG2yx9E9ojIwgh1VLrtfQYoxbnmL4cctsPdtw14Arg2pA3/AW7B6do7HGfszV/2ycDX3HN34Ny1+L8QXI/TVboD5/o93M7vcx4wG3gDJ8h87L6+pp3zcOu8E+c67gD6Aj+P4jzTDUS1rZ4EY4xpzb1re1xVw971icgjOLMib+7GZvnrfhRnrOsMN5ib/ZTdQRljepqrccamDot3Q0zXpMS7AcYYE0vutHyb6NADWBefMcaYhGRdfMYYYxKSBShjjDEJqUeOQRUWFmpxcXG8m2GMMSYKCxYsKFHVVg/GRwxQIvLDtgpU1bti0TAvFBcXM3/+/Hg3wxhjepxmn7J2ew2fr6/g7UV7yEpP5u6rx3WpTBEJm86qrTuoXPf/Y3CyUPsf0jsL+LRLrTHGGLPf8PmUhesq+GhFKXOW7GXLnnoAhhRmcMrkXp7VGzFAqeptACLyHk6K/Ur3/a04WYvb5ObG+jfOyp4K3K+qfxZnTZyncdLabwAuVNVSERGclPyn46RxuUJVF7plXY6TegbgdlVtK7uxMcaYGNhZWs+sz0p46ZNdbC6pIzlJOHR4LlfMGMwhw3MZXJhBclIsUmGGF80YVD8g8GnsBndbe5qAH6nqQhHJBRaIyFvAFcDbqnqniNwE3AT8DCdty2j35yicpKBHuQHtFmAKTqBbICIvq2ppNL+gMcaY6JRUNLB6azVvL97D/DUVbC917pRGDcjilq+PYvqEArIzkrutPdEEqH8Dn4rIi+77c2l7fRYAVHU77jotqlopIitwlgM4B2exM9xy5uAEqHNwkjsqMFdE8kVkgHvsW+qsgokb5E4Fnoyi7cYYYyJo9ilLNlQyd1UZC9ZWsGh9JQBZ6UkcPrIXXz2mH8cd3Jvh/bLaKckb7QYoVb1DRF5n30JlV7oLjEVNRIpxVs38BCd1v3+BsR3suxsbRPAaMFvcbZG2h9ZxDW5yyKFD28rOb4wxBy5VZcXmal6bv5v3l+9lR2kDyUkwsn8W3z51CBOH5TJxWA6Z6d13pxRJtNPMs4AKVX1YRIpEZLiqro/mRHcdmOdxluWucIaaHKqqIhKTVBaqej9wP8CUKVMsPYYxxriqapuYs3Qvc1eV8cmqcsprmkhPEY4ak881pwxh2rje5OekxruZrbQboETEP/4zBiftfSrOWivHRnFuKk5wekJVX3A37xSRAaq63e3C2+Vu30rwImWD3W1b2dcl6N8+p726jTHmQLWjtJ73l5WyfmcNSzdVsXprNT6F3jkpTB2bz2Ej8zju4AIKchMvKAWK5g7qKzjdcwsBVHWbO+mhTe6svAeBFSHPTL2MswDZne7/XwrYfr2IPIUzSaLcDWKzgN+KSG/3uJOx9VqMMSaIz6e89fkenn5/O0s3VQGQk5HM6IFZXDFjEEcelM+hw3NJ8nDWXaxFE6AaArviQpZ4bsuxwGXAEhH53N32C5zA9IyIXAVsBC50983EmWL+Bc408ysBVHWviPwGmOce92v/hAljjDnQlVU3MnP+bmbO383qbTUM75fJVScN4tTDixhWlBnv5nVJNAHqGRH5J5AvIt8CvomzkmmbVPUDIFKonhHmeAW+G6Gsh4CHomirMcb0eKrKmu01vLGghJc/2UlFbTPD+2Xy8/NHcNaRRaQk94w0q9HM4vujiJwEVOCMQ/1KVd/yvGXGGGNa7C5v4PP1FXy+roIPV5SxbW89KcnCEaN7cc0pgzl4aLsjL/udaCZJZAPvqOpbIjIGGCMiqe6iYMYYYzywq7yeT1eV8/GqMhatr2RXuZMvITMtiUnFuVwxY9B+MdGhK6Lp4nsP+JI7SeENYD5wEXCJlw0zxpgDRVVdE4vWV7JofSXrdtSwckt1S0Dqk5vKpOJcvl6cy8RhuYwfmkNK8v4z0aEroglQoqo17qSGv6vqHwImPRhjjOkAVWXb3nrmf1HOyi3VbNhVy+L1lTQ2K8lJMLQok0nFuRw8NIfJI/IYOzh7v5p5F0tRBSgRmYpzx3SVuy3+jxgbY0yCU1XKqptYurGSdTtqWbGliuWbq9hR6twd5WQkU9w3k3OO6sv0iQVMKs4lI80+Xv2iCVA34Dx39KKqLhOREcBsb5tljDH7n52l9SzfUsW2PfWs3lbNRyvKKK9patk/uE8644fkcNn0Xhw+Ko9hfTM9zQa+v4tmFt97OONQ/vfrgO972ShjjNlfNDT5mLNkLy/O3cmCLypatvftlcaRB/Xi4KE5jBmUzcj+WQmZTiiRRTOLrwj4KXAwkOHfrqonetguY4xJaGt31PDSJ7t4ff5uymua6JObytUnDWba+N4MKEintwWjLoumi+8JnAUGzwSuxUlPtNvLRhljTCIpqWhg7fYa1u2sZfGGSuavcRKuJifB9Il9OPOIIo46KP+AmV3XXaIJUH1U9UERuUFV3wXeFZF57Z5ljDH7GVWlpKKR1duq+XxdBSu3VLNuRw27K/Y99lmQk8qx43szbnA2J08utDslD0UToPx/MttF5AxgG1DgXZOMMcZ7dY3NLPiigtVbq1m/s5Zlm6rYUVpPY7OzWo8IjB6QxZTRvRgzKJvRA7Mp7ptJUa+0OLf8wBFNgLpdRHoBPwLuBfKAGz1tlTHGxFhpVSPz15SzZnsNSzY6D8U2ucGob680xg7O5vgJBfTLT2PUgCwOGpRNbma0S+YZL0Qzi+9V92U5cIK3zTHGmK5ravaxYks1C9dWsHl3HWt31LB8cxWqkJwEI/pnceG0/hx1UC8mFeeRnWHPHiWiaGbxHQT8HWep9gkiMgk4W1Vv97x1xhgTharaJhaurWDxhkpWbqlmycZKaht8gDNmNKQwg6tPGsyx43ozemAWqSk9I9t3TxfN/eu/gJ8A/wRQ1cUi8h/AApQxJm7Kqhp5e/Ee5q4q4/1lpfgUUpKF4r6ZnHlEEYcMz2PKqF49OplqTxdNgMpS1U+dBXJbNEU62BhjvFBV18SqLdUs3VTF3FVlfL6ugmYfFOWlcsG0/nxpfG8OHZFHmt0d9RjRBKgSERkJ+FfUPR/Y7mmrjDEHJFVlZ1kDW/fUUVLRSEllA5t217FofQUbdtbic+Y0MLJ/JpedMIgvH9KH0QOzCPkCbXqIaALUd4H7gbEishVYD1zqaauMMT1aaVUjyzZVsX5nDVv21LN9bx27yxvYureeOnfsyC8nI5kJw3KYPqGAQ4bnMWpAlk31PkBEM4tvHfBld+HCJFWt9L5Zxpj9mf9OaNveelZtrWZLSR2bdteyuaSO8pomquuaW47Ny0phYEE6gwszOGJ0L4b1zWRIYQaFeWkU5qWRm5lsd0gHqIgBSkR+GGE7AKp6l0dtMsbsJ3w+ZXtpPWu317B+Vy1LN1ayuaSOXWUNVAUEoeyMZAb0TmfCsBx6ZaUysCCdcUOch1/tWSMTSVt/M3reAvfGmE5p9imlVY3srWxke2k9yzZVMf+LctZsraa+SVuOG1KYwYj+mRw2Io/h/bIYXJjOqAHZ1iVnOiVigFLV27qzIcaY+PH5lE2769i8p46tJXVsK61nT0UDeysb2VlWz/bSBpp9+wJRchKMG5zDV4/pz7C+mYzqn8Wwfhn0yrIp3SZ27EFdYw4Q/qXGN+2upaq2mdLqRtZur2HZpio27qoNuhPKTEuiMC+N/OwUxg/J4cRJ6fTvnU5Bbir98tMY0S+LzHTLvmC8ZQ/qGtMDNDUru8rrKSl3pmbvLm+gpKKBmnof5TWN7CxzlosIHBcCyE5PZvzQHM4/thcj+mcxvF8mAwrSKchJtYkJJu7sQV1j9iNVdU2s3lrD4g2VrN1ew6aSWraU1FFZ29zq2OQkyM5IIS8zmT55aZw0uZDRA7MY3jeT3jmp5GWlUJCTSpItOW4SlD2oa0wC8E9CqG1oprqumZIKZ0JCWXUjJRUNLc8KbdhVS7P7mFC//DSGFWVyyuRC8nNS6dsrjX75afTOSaUwL40+uXYXZPZvnX1Q9xJPW2VMD9DUrFTXN7FxVx2lVU6w2V3eQFl1E+XVTVTXN1Na1Uh5dSO7yhtoCBgDCpSZlkT/3ukM7pPB9IkFjBucw6ThueRn24QE07O1GaBEJBm4TlXtQV1jXKpKdX0zZVVN7CpvYFdZPbsrGiivbmJPZSNfbK9hy566oIdRA+VmJtMrK8XpfstKYVCfdI7LS2NgQTo5GSlkpiXRNz+Ngpw0crOSycmw54TMganNv/mq2iwi09zX1d3TJGMSQ11jMyXljazfWcOKzdUs3VTJlhInJU99mLudlGShT24qQ4syOb24iN45KWSlJzO4TwZ989PIy0qhMC/NkpkaE6Vovpp9JiIvA88CLUFKVV/wrFXGdJPqumZKKhvYVdbAtr11bNhZy6bddazZXs2O0oagY0cNyGLckBymT3TGeXrnpFKUl0bf/DT69konKz3JxnyMiaFoAlQGsAc4MWCbAhagTEJqbPI5kwyqGqiqbaa2wUd1fTO19c2U1zSxaXctFTVNbN1Tz4ZdtUHnpqcIAwoymDgsl7OPzKRfvpMjbuygbHvux5huFk2y2Cu7oyHGtKXZp9TWN7OnspFNJXVs21PHnspGdpTWU1bdSFVdM3sqnIkItSHZsEP5Z7oNLszglMMK6d87nX75zgy4QQUZNu3amARho6/GE6rqBJUGH3UNPuobfdQ2NFNR00RZtZPNurq+mYZGH00+pbHJR1OzUt/ko8bd58x8a2JvZSOVtU34QoZ9kgT65ae3jPUcOiKXXtmp9HKf7ynslUZuRjKZaclkZSSRnZ5CVnoSGWl2J2TM/mC/CVAicirwZyAZeEBV74xzk3osn0+pqGmiorbJ7SJrprS6iT0VDS1dZdV1TtdZjfu6ur6ZytrgwBMaUNoiAqnJQmpKEtnpyWSmJVGQm8rQogwOG5lHXpYz461XZgpD+2YyqE86vbJSSUm2ux1jeqr9IkC5093/BpwEbAHmicjLqro8vi1LDD6fM+25qraZ6vom9lY2UV7TSH2Dj7omH5U1TdQ3+mhoUmobmimvbqLBvWNpaPJRVecEl6raZhqafNQ1+tA2gktykpCTkUxmehKZacnkZDg/AwvSyUpPJjsjmfTUJNJSkshMc45JS00iPTWJ/OwUemWlkJORQlZGEhmpyaQkC8nWrWaMCRFNsth04DygOPB4Vf21d81q5UjgC3fxRETkKeAcwJMAtXBtOXUNPhRQdVNoqLZ8aO/b7uwMOg6neyt4+773BBwb9jigsUlpbHa6vRqblfpGH+XVTneX/66mpr6Z+kZfyx1Le0QgLSWJtBQhPzuV9NQkUlOEtOQk+uSmMqwok9xMJ7A4gcRJhZOblUJWWhJ5WSkU5aWRnZFMqk2TNsZ0g2juoF4CyoEFQL23zYloELA54P0W4KjAA0TkGuAagKFDh3apstueWsv2vfH6VVsTgfzsFCdoZKZQmJdKdnoGGWnJZKUnkZOZQnZGMrkZKWRlJFOQk0qv7BQy3GCTk5lMeopNgTbG7F+iCVCDVfVUz1vSRap6P05KJqZMmdKB0Y/W/nD5GBqafQhOcBAE9z/8n/GCOK8DtvuPc/bv2xZ6XND5IccJkJIipKckkZIspCQnkZyEBRdjzAEnmgD1kYhMVNUlnrcmsq3AkID3g91tnhgzONuroo0xxkRJtK3RcEBElgOjcJLE1uN8yVdVneR981rakAKsBmbgBKZ5wMWquizC8buBjV2sthAo6WIZPYFdB4ddh33sWjjsOjhicR2GqWpR6MZo7qBO62LFXaaqTSJyPTALZ5r5Q5GCk3t8q1+0o0RkvqpO6Wo5+zu7Dg67DvvYtXDYdXB4eR2iySTR1TuRmFDVmcDMeLfDGGNM97D5wsYYYxKSBajI7o93AxKEXQeHXYd97Fo47Do4PLsO7U6SMMYYY+LB7qCMMcYkJAtQxhhjEpIFqBAicqqIrBKRL0Tkpni3J15EZIiIzBaR5SKyTERuiHeb4klEkkXkMxF5Nd5tiRcRyReR50RkpYisEJGp8W5TPIjIje6/iaUi8qSIZMS7Td1FRB4SkV0isjRgW4GIvCUia9z/945VfRagAgRkTT8NGA98XUTGx7dVcdME/EhVxwNHA989gK8FwA3Aing3Is7+DLyhqmOBQzgAr4eIDAK+D0xR1Qk4z2V+Lb6t6laPAKGp724C3lbV0cDb7vuYsAAVrCVruqo2AP6s6QccVd2uqgvd15U4H0aD4tuq+BCRwcAZwAPxbku8iEgv4DjgQQBVbVDVsrg2Kn5SgEw3w00WsC3O7ek2qvoesDdk8znAo+7rR4FzY1WfBahg4bKmH5AfyoFEpBiYDHwS56bEyz3AT4G215Lv2YYDu4GH3a7OB0TkgEtaqapbgT8Cm4DtQLmqvhnfVsVdP1Xd7r7eAfSLVcEWoEybRCQHeB74gapWxLs93U1EzgR2qeqCeLclzlKAw4C/q+pkoJoYduXsL9zxlXNwAvZAIFtELo1vqxKHOs8txezZJQtQwbo1a3qiE5FUnOD0hKq+EO/2xMmxwNkisgGny/dEEXk8vk2Kiy3AFlX130U/hxOwDjRfBtar6m5VbQReAI6Jc5vibaeIDABw/78rVgVbgAo2DxgtIsNFJA1n8PPlOLcpLsRZgOpBYIWq3hXv9sSLqv5cVQerajHO34d3VPWA+8asqjuAzSIyxt00A49WtE5wm4CjRSTL/TcygwNwskiIl4HL3deX4yxyGxPRZDM/YHQ0a3oPdyxwGbBERD53t/3CTdprDkzfA55wv7ytA66Mc3u6nap+IiLPAQtxZrp+xgGU8khEngSmA4UisgW4BbgTeEZErsJZ5ujCmNVnqY6MMcYkIuviM8YYk5AsQBljjElIFqCMMcYkJAtQxhhjEpIFKGOMMQnJApQxxpiEZAHKmBgQkT4i8rn7s0NEtrqvq0TkPg/qe0RE1ovItTEo6//cNv84Fm0zJlbsQV1jYkBV9wCHAojIrUCVqv7R42p/oqrPdbUQVf2JiFTHokHGxJLdQRnjIRGZ7l/kUERuFZFHReR9EdkoIl8VkT+IyBIRecPNfYiIHC4i74rIAhGZ5c9z1k49j4jI30Vkroisc+t9yF1Y8BH3mGT3uKVunTd6+ssb00UWoIzpXiOBE4GzgceB2ao6EagFznCD1L3A+ap6OPAQcEeUZfcGpgI34uRHuxs4GJgoIofi3OENUtUJbp0Px+qXMsYL1sVnTPd6XVUbRWQJTr7HN9ztS4BiYAwwAXjLyUVKMs66Q9F4RVXVLXunqi4BEJFlbtnvAiNE5F7gNeBAX8fIJDgLUMZ0r3oAVfWJSKPuS4bpw/n3KMAyVZ3a2bLdsuoDtvuAFFUtFZFDgFOAa3GSen6zE/UY0y2si8+YxLIKKBKRqeCsySUiB8eiYBEpBJJU9XngZg7M9ZzMfsTuoIxJIKraICLnA38RkV44/0bvAWKx7MsgnCXb/V9Mfx6DMo3xjC23Ycx+yJ2Z92osppm75d1K90yNNyZq1sVnzP6pHPhNrB7UBS4F7Fkok1DsDsoYY0xCsjsoY4wxCckClDHGmIRkAcoYY0xCsgBljDEmIf1/ZWxOKhKpOrgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "def make_timeseries_plots(N, sampleRate, test):\n",
    "    time = arange(N) / sampleRate\n",
    "    h, ax = plt.subplots(3, 1, sharex=True)\n",
    "    ax[0].plot(time * 1e3, test.nTrapped, '-g')\n",
    "    plt.title('actual number of trapped QPs')\n",
    "    ax[0].set_ylabel('n trapped')\n",
    "    ax[1].plot(time * 1e3, test.nGenerated, '-b')\n",
    "    ax[1].set_ylabel('n generated')\n",
    "    ax[1].set_xlabel('Time [ms]')\n",
    "    ax[2].plot(time * 1e3, test.releasePop, '-b')\n",
    "    ax[2].set_ylabel('n released')\n",
    "    ax[2].set_xlabel('Time [ms]')\n",
    "    plt.tight_layout()\n",
    "    #plt.savefig(\"qp_time_{}_{}.png\".format(sim_type, sim_time))\n",
    "    plt.show()\n",
    "\n",
    "make_timeseries_plots(qp_trapper_obj.N, qp_trapper_obj.sampleRate, qp_trapper_obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "dated-writer",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def createHisto_dev(df,val,title,plotname,bins=50,logy=False,logx=False):\n",
    "    df.hist(column=val,bins=bins)\n",
    "    plt.title(title)\n",
    "    if logy:\n",
    "        plt.yscale(\"log\")\n",
    "    if logx:\n",
    "        plt.xscale(\"log\")\n",
    "    #plt.savefig(self.tDir+plotname+\"_histo.png\")\n",
    "    plt.show()\n",
    "    plt.close()\n",
    "    \n",
    "createHisto_dev(df,\"n_trapped\",\"Number of QP Released\", \"qp_released\",logy=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "dedicated-stevens",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createHisto(self,df,val,title,plotname,bins=50,logy=False,logx=False):\n",
    "    df.hist(column=val)\n",
    "    plt.title(title)\n",
    "    if logy:\n",
    "        plt.yscale(\"log\")\n",
    "    if logx:\n",
    "        plt.xscale(\"log\")\n",
    "    plt.savefig(self.tDir+plotname+\"_histo.png\")\n",
    "    plt.close()\n",
    "\n",
    "def createQPModeHisto(self, df):\n",
    "    df.hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "    plt.suptitle(\"QP Occupation In Each Mode (log scale)\")\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(self.tDir+\"qp_all_mode_log_scale\"+\"_histo.png\")\n",
    "    plt.close()\n",
    "    \n",
    "    maxqp = df[\"n_trapped\"].max()\n",
    "    qp_range = np.arange(0,maxqp,8)\n",
    "\n",
    "    for i in range(len(qp_range)-1):\n",
    "        df[(qp_range[i]<=df[\"n_trapped\"])&(df[\"n_trapped\"]<=qp_range[i+1])].hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "        plt.suptitle(\"QP Occupation In Each Mode ({}-{})\".format(qp_range[i],qp_range[i+1]))\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(self.tDir+\"qp_mode_{}-{}\"+\"_histo.png\".format(qp_range[i],qp_range[i+1]))\n",
    "        plt.close()\n",
    "\n",
    "    new_qp_range = [i for i in range(qp_range[-1]+1,maxqp+1)]\n",
    "\n",
    "    df[(new_qp_range[0]<=df[\"n_trapped\"])&(df[\"n_trapped\"]<=new_qp_range[-1])].hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "    plt.suptitle(\"QP Occupation In Each Mode ({}-{})\".format(new_qp_range[0],new_qp_range[-1]))\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(self.tDir+\"qp_mode_{}-{}\"+\"_histo.png\".format(new_qp_range[0],new_qp_range[-1]))\n",
    "    plt.close()\n",
    "    \n",
    "def generateHistograms(self):\n",
    "    stime = (arange(self.N) / self.sampleRate) * 1e3 #ms\n",
    "    ltimes = [(i/ self.sampleRate)*1e3 for i in self.lifeTimes]\n",
    "    \n",
    "    df = pd.DataFrame(data={\"t\":stime, \"n_trapped\":self.nTrapped, \"n_rel\": self.releasePop})\n",
    "    dflt = pd.DataFrame(data={\"ltimes\":ltimes})\n",
    "    \n",
    "    self.createHisto(df,\"n_trapped\",\"Number of QP Trapped\",\"qp_trapped\",logy=False,bins=20)\n",
    "    self.createHisto(df,\"n_rel\",\"Number of QP Released\",\"qp_released\",logy=True)\n",
    "    \n",
    "    self.createHisto(dflt,\"ltimes\",\"Lifetime of Trapped QPs [ms]\",\"qp_trapped_lifetime\",logy=False,bins=None)\n",
    "    \n",
    "    self.createQPModeHisto(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "cordless-postage",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>t</th>\n",
       "      <th>n_trapped</th>\n",
       "      <th>n_rel</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.000003</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.000007</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.000010</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.000013</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2999995</th>\n",
       "      <td>9.999983</td>\n",
       "      <td>12</td>\n",
       "      <td>2193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2999996</th>\n",
       "      <td>9.999987</td>\n",
       "      <td>12</td>\n",
       "      <td>2193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2999997</th>\n",
       "      <td>9.999990</td>\n",
       "      <td>12</td>\n",
       "      <td>2193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2999998</th>\n",
       "      <td>9.999993</td>\n",
       "      <td>12</td>\n",
       "      <td>2193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2999999</th>\n",
       "      <td>9.999997</td>\n",
       "      <td>12</td>\n",
       "      <td>2193</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3000000 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                t  n_trapped  n_rel\n",
       "0        0.000000          0      0\n",
       "1        0.000003          0      0\n",
       "2        0.000007          0      0\n",
       "3        0.000010          0      0\n",
       "4        0.000013          0      0\n",
       "...           ...        ...    ...\n",
       "2999995  9.999983         12   2193\n",
       "2999996  9.999987         12   2193\n",
       "2999997  9.999990         12   2193\n",
       "2999998  9.999993         12   2193\n",
       "2999999  9.999997         12   2193\n",
       "\n",
       "[3000000 rows x 3 columns]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stime = (arange(qp_trapper_obj.N) / sampleRate)  * 1e3\n",
    "df = pd.DataFrame(data={\"t\":stime, \"n_trapped\":qp_trapper_obj.nTrapped, \"n_rel\": qp_trapper_obj.releasePop})\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "entire-deployment",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "piano-transfer",
   "metadata": {},
   "outputs": [],
   "source": [
    "def createQPModeHisto_dev(df):\n",
    "    df.hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "    plt.suptitle(\"QP Occupation In Each Mode (log scale)\")\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "    maxqp = df[\"n_trapped\"].max()\n",
    "    qp_range = np.arange(0,maxqp,8)\n",
    "\n",
    "    for i in range(len(qp_range)-1):\n",
    "        df[(qp_range[i]<=df[\"n_trapped\"])&(df[\"n_trapped\"]<=qp_range[i+1])].hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "        plt.suptitle(\"QP Occupation In Each Mode ({}-{})\".format(qp_range[i],qp_range[i+1]))\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "        plt.close()\n",
    "\n",
    "    new_qp_range = [i for i in range(qp_range[-1]+1,maxqp+1)]\n",
    "\n",
    "    df[(new_qp_range[0]<=df[\"n_trapped\"])&(df[\"n_trapped\"]<=new_qp_range[-1])].hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "    plt.suptitle(\"QP Occupation In Each Mode ({}-{})\".format(new_qp_range[0],new_qp_range[-1]))\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "fitting-holmes",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 36 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEdCAYAAABZtfMGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAg/0lEQVR4nO3de7hcdX3v8feHS0ALxGqAw0UIhyDlUksfIoiWltYooRixgkJsvVSBoieWPrUXbNFCtYo9tae2ohwkCCKCAdQDEoTSinjh2CQcRGNQIgYJggSRAKIg+jl/rLVlWO69M3vv2bN+2evzep79wKy1Zu3vrP3JfOe31m9mZJuIiIjSbNF2AREREaNJg4qIiCKlQUVERJHSoCIiokhpUBERUaQ0qIiIKFIaVGx2JJ0j6e1t1zEMkixpXss13CDpxCnc/0uSfnOQNQ2CpCskHdV2HTG2NKjCSXq9pK9JelTSvZI+KGl2z/ozJP1U0iOSHpT0ZUmHjbO//SVdKWmjpIclfU7SC4bzaCaufvxf7F1m+xTb75yG33WGpI9N4b4jf4eRnwcHXGI/NVjSqY3lp9bLzxhmPfXvXgQ8bPv/1bdfJ2mVpIckrZf0j5K2GuV++0j6yab+HnV+N9T7+6qkY3rWHS3pi/W/i3slnSdp+567vxd414AeakyDNKiCSXor1T+ivwRmA88H5gLXSdq6Z9NP2N4O2BH4IvBJSRplf3sDXwK+BuwF7Ap8qt7fmE0t+vYJ29v1/DyjhRq+Bby2sex19fI2nAJc1HP76cCfAXOAQ4EXAX8xyv3OBlb0sf9TgV1s7wCcDHxM0i71utlUDWhXYD9gN+B/jtzR9n8BO0iaP4HHE0OUBlUoSTsAZwJvsf1Z2z+1vQ54FfDfgVc372P7p8CFwH8DnjXKbs8AbrL9t7YfsP2w7X+legJ5b8/v/q16JPagpLskvb5e/jRJ75N0Zz0C+2K97AhJ6xv1r5O0oP7/MyRdLukT9ajtZkm/0bPtaZK+Xa/7hqQ/qJfvB5wDHNY7IpF0gaR39dz/JElrJT1Qjw537VlnSadIur1+PGeP1rzH+BtM+r6j7Ov99bF8qB5BHN6zbktJf9NzDFZJenbP3RdMoIYVwNMlHVDv+wBgWxpP9ps4Zi+WdFv9N/4AoMZ93yBpjaQfSrpW0p5jPOZZwO8Bnx9ZZvtDtr9g+3HbdwMXAy9s3O8E4EHgP8Z5nCP7u9X2EyM3ga2BZ9frPl7/23nU9g+BDzd/F3ADcPSmfk+0Iw2qXC+gemL5ZO9C248Ay4GXNO8gaRvg9cBdtu8fZZ8vBi4bZfky4IV1s9kTuAb4N6oR2UHALfV2/wQcXNf2TOCvgJ/3+XiOqX/3M4GPA5/uGQV+Gzic6hXvmdSvgm2voXoFftNYIxJJvwe8h6px7wLcCVza2OylwPOA59bbHdlnzVO9b68VVMdy5PFfJmnbet2fA4uB3wd2AN4APDqFGi7iyVHU63jqCGbcYyZpDlXmTqca5Xybnif1+hTa3wCvoMrHF4BLxqhjH+DnttePsR7gt4HVPfvfAfh7qmPSF0mfkfQT4CtUDWdlP7+rtgb4jVG2jQKkQZVrDnB/z6vDXvdQPTmMeFU9uriLqoH8wTj7vGeM/W1B9eT5auB625fUo7Yf2L5F0hZUT5yn2r7b9s9sf9n2Y30+nlW2L69Hef9M1XyfD2D7Mtvfs/1z258AbgcO6XO/fwicb/vmupa3UY245vZsc5btB21/F/gcVaPo10Tu+6p6lDPy87mRFbY/Vh/LJ2y/D9gG2LdefSJwuu1vuvJV2z+YQv0fAxbXLwBOqG/3Gu+Y/T6wuudv9S/AvT33PQV4j+01dTbfDRw0xijqGcDDYxUp6Q3AfKoXPiPeCSzdRFN7CtsvBbava7/O9i+9aJL0Yqpm/Y7GqofrOqNAaVDluh+Yo1EuIFO96u0dIS2z/QzbO9n+PdurxtnnLqMs34VqJPRDqtMj3x5lmzlUTWW0df24a+R/6ieQ9VTXBpD0Wkm3jDyxAwfWv68fu1KNAEb2/QjwA6rrDSN6n2AfBbabQN0Tue/I32Hk53dHVkj6i/q02Mb6Mc7mycc41jGfVP11I1tL1Txut31XY5PxjtmuPPVv5d7bwJ7A+3v+Vg9QnQLsPd4jfkjVOH6JpJdTjeKOGhntSzoIWAD8rzHus1pPTkA5vHdd/WLqGuAlkl7WuN/zqUatx9luXovbnup0YhQoDapcNwGPUZ1K+QVJ2wFHUZ3KmKjrgVeOsvxVVKfRHqV6Mtp7lG3uB34yxrofUV38HqlxS546woP6ukC9fgtgd+B79SvvDwNLgGfVp/G+zpPXPTb1cfvfo3rSHNn3r1Bdf7t7E/cbmvrJ9K+ojvOv1o9xI08+xrGO+VR8FHhr/d+m8Y7ZPTz1b6Xe23Wtf9JoxE+z/eVRfs/aehdPaV6SFlL9zRfZ/lrPqiOoJgF9V9K9VJMnjpV0M4DtA3omoHxhjMe9FT3HUtX09iuBN9ge7ZrWfsBXx9hXtCwNqlC2N1Jdj/k3SQslbV2fgllG1SwunsRuzwReIOkfJD1T0vaS3kJ1veKv620uproo/ypJW0l6lqSD6lHP+cA/S9q1vrB/WH3d61vAtqqm9W5Ndf1im8bvPljSK+oR4Z9RNd//C/wKVRPaACDpj6lGUCO+D+xeX3AfzSXAH0s6qK7l3cBX6gklpdgeeILqMW4l6R1U15pGnAe8U9XUakl6rqTRJrlMxCeorlMuG2XdeMfsauCAnr/Vn1JNuhlxDvC2nkkYsyWN9qIH249TvSj6nZFl9fWvi4Fj61l0vc6lai4H1T/n1PWMes1N0q9JOqq+drq1pD+ius70+Xr9gcBnqSYaXTXaPurarhljXbQsDapgtv+R6oL0P1GdK/8O1Uhlge0fTWJ/twO/RXVReB3Vq+VjgSNtf6ne5rtU5/LfSnX65haevIj8F1RT1FfU694LbFE30zdTPdHeTTWial5D+D/A8VSnfV4DvKI+LfMN4H1UI8bvA79ONRV+xH9SXdi+V9IvTfywfT3wduCK+vHsTXXdpQ3H66nvg3pE0k7AtVRPlN+iOrX2E5562uyfqRrJdcBDwFLgaVMpxPaPbV9v+8ejrBvzmNWn214JnEV12m8fev4etj9F9Xe/VNJDVKPd8d7s+r+p/t4j3k51enN5zzG6pt73o7bvHfkBHgF+YnvDGPsW1czU+6ia/6nA8bZvrte/lWokv7Tnd/VOyHge8MgojTIKIecLCzcb9eji74EX1o1ks6DqDaLzbP9R27XE8En6ErDE9Zt1SyHpCqoJGcvbriVGN9oF+CiU7Y9IeoJqmvdm06Ci22w333tUBNvHtl1DjC8NajNj+6JNbxURsfnLKb6IiChSJklERESR0qAiIqJIaVAREVGkNKiIiChSGlRERBQpDSoiIoqUBhUREUVKg4qIiCKlQUVERJHSoCIiokhpUBERUaQ0qIiIKFIaVEREFCkNKiIiipQGFRERRUqDioiIIqVBDZikbSQtlXSnpIcl3SLpqFG2e4ckS1rQRp0xPONlQtLcOgeP9Py8ve2aY3pt6nlC0tMlfVDS/ZI2SrqxzXrbkq98H7ytgLuA3wG+C/w+sEzSr9teByBpb+CVwD1tFRlDNWYmerZ5hu0n2iguWrGp54lz6232Ax4ADmqnzHblK9+HQNKtwJm2r6hvfxb4V+CDwIm2r2+zvhi+kUwAq4DvAFunQXVbTyZWA/8F7G77oXaraldO8U0zSTsDz6EKHZJeCTxme3mrhUVrmpmo3SlpvaSPSJrTUmnRkkYmDgHuBM6sT/F9TdKxrRbYkjSoaSRpa+Bi4ELbt0naHng3cGq7lUVbmpkA7geeB+wJHAxsX6+PjhglE7sDBwIbgV2BJcCFkvZrr8p2pEFNE0lbABcBj1MFDOAM4KKRa1HRLaNlwvYjtlfafsL29+vlL6lfzMQMN8bzxI+BnwLvsv247c8DnwNe0k6V7UmDmgaSBCwFdgaOtf3TetWLgD+VdK+ke4FnU10Y/euWSo0hGScTTSMXhfNvc4YbJxO3jrJ5JycLZJLENJB0DtWsmwW2H+lZ/ixg655NVwB/DlzTu13MPONk4lDgQeB24FepJs7sZPt3WygzhmicTGwNrAEuBN4DHAp8FnhefQqwM9KgBkzSnsA64DGgd1bWn9i+uLHtOjKLb8YbLxPAz6muS+4EPAT8O/BXtu8dcpkxRJt6npB0AHAe8FyqCRN/a/tTQy+0ZWlQERFRpJznjoiIIqVBRUREkdKgIiKiSGlQERFRpCI+LHbOnDmeO3du22XEAKxatep+2ztOdT/JxMyRTERTv5lotUFJWgQsmjdvHitXrmyzlBgQSXdO8f7JxAyTTERTv5koYgQVUbq5p13d13brzjp6miuJ6I5WG5Ttq4Cr5s+ff1KbdUQ5koloKjUTedEy/Yo5xRfTa3P5x5RMRFMy0V0ZQUVRkonp1e8LFWj/xcqIZKK7ih1Btf0PaXMZcQxa28c9r5ajKZmYXiU/17X6PijbV9k+efbs2W2WEQVJJqIpmeiuVhuUpEWSzt24cWObZURBkoloSia6KyOoKEoyEU3JRHflo44iIqJIOcUXRUkmoimZ6K5MM9+MTWTG3eYimZicmZiFEcnE5MyETOQUX0REFCkNKiIiipRrUFGUZCKakonuyjTzKEoyEU3JRHflFF9ERBQpDSoiIoo08AYlaT9J50i6XNKbBr3/iIjohr7eByXpfOClwH22D+xZvhB4P7AlcJ7ts2yvAU6RtAXwUeBDgy97ZpsJ71+YDiV/6nJEDF6/b9S9APgAVcMBQNKWwNnAi4H1wApJV9r+hqSXAW8CLhpsuRERT8qLlpmtr1N8tm8EHmgsPgRYa/sO248DlwLH1Ntfafso4A/H2qekkyWtlLRyw4YNk6s+ZpRkIpqSiW6bykcd7Qbc1XN7PXCopCOAVwDbAMvHurPtcyXdAyyaNWvWwVOoI2aIZCKakoluG/hn8dm+Abhh0PuNiOHK6bNo21Rm8d0NPLvn9u71sr7lDXjRlExEUzLRXVMZQa0A9pG0F1VjOgF49UR2IGkRsGjevHlTKCNmks09Exl1DN7mnomYvL5GUJIuAW4C9pW0XtIbbT8BLAGuBdYAy2yvnr5SIyKiS/qdxbfY9i62t7a9u+2l9fLltp9je2/b/zDRX56hezQlE9GUTHRXPs08ipJMRFMy0V35NPMoSjIRTclEd2UEFUVJJqIpmeiujKCiKMlENCUT3ZWv24iIiCLlFF8UJZmIpmSiu3KKL4qSTERTMtFdOcUXERFFSoOKiIgipUFFRESRMkkiipJMRFMy0V2ZJBFFSSaiKZnorpzii4iIIg38G3UlvRw4GtgBWGr7ukH/joiImPn6/T6o8yXdJ+nrjeULJX1T0lpJpwHY/rTtk4BTgOMHX3JERHRBv6f4LgAW9i6QtCVwNnAUsD+wWNL+PZucXq+PiIiYsH6/sPBG4IHG4kOAtbbvsP04cClwjCrvBa6xffNgy42IiK6YyiSJ3YC7em6vr5e9BVgAHCfplLHuLOlkSSslrdywYcMUyoiZIpmIpmSi22S7vw2lucBnbB9Y3z4OWGj7xPr2a4BDbS/p+5dLi4BFVNeqbp9Y6UM3B7i/7SIKNnJ89rS942R3kkzMKF3LRPKwaRPKxFQa1GHAGbaPrG+/DcD2eyZXd9kkrbQ9v+06StXF49PFxzwRXTs+XXu8kzHRYzSVU3wrgH0k7SVpFnACcOUU9hcREfEL/U4zvwS4CdhX0npJb7T9BLAEuBZYAyyzvXr6So2IiC7p6426thePsXw5sHygFZXr3LYLKFwXj08XH/NEdO34dO3xTsaEjlHf16AiIiKGKZ/FFxERRUqDioiIIqVBRUREkdKgIiKiSGlQERFRpDSoiIgoUhpUREQUKQ0qIiKKlAYVERFFSoOKiIgipUFFRESR0qAiIqJIaVAREVGkNKgBk7SNpKWS7pT0sKRbJB1Vr/tDSY/0/DwqyZIObrvumD7jZaJe/ypJa+p135D08hbLjSHoIxMnSlpbP098VtKubdbbljSowdsKuAv4HWA2cDqwTNJc2xfb3m7kB3gzcAdwc3vlxhCMmQlJuwEfA/4c2AH4S+DjknZqq9gYivEycQTwbuAY4JnAd4BL2imzXfk+qCGQdCtwpu0rGss/B9xg+8x2Kou2jGQCWA9cZXunnnUbgJfZvqmt+mL4ejJxGPA02/+jXr4rcDcwz/a3Wyxx6DKCmmaSdgaeA6xuLN8T+G3go23UFe1pZGIlsEbSyyRtWZ/eewy4tcUSY8hGeZ5Q7+r6vwcOtagC9PWV7zE5krYGLgYutH1bY/VrgS/Y/s7wK4u2jJYJSR8FPg5sCzwOvNL2j9qrMoapmQlJnwUulXQOcDvwDsDA01sssxUZQU0TSVsAF1E94SwZZZPXAhcOtaho1WiZkLQA+EfgCGAW1TWJ8yQd1E6VMUyjZcL29cDfAVcA6+qfh6lOB3dKGtQ0kCRgKbAzcKztnzbWvxDYFbi8hfKiBeNk4iDgRtsrbf/c9grgK8CCdiqNYRnvecL22bb3sb0zVaPaCvh6O5W2Jw1qenwI2A9YZPvHo6x/HXCF7YeHW1a0aKxMrAAOHxkxSfpN4HByDaoLRs2EpG0lHajKHsC5wPtt/7CtQtuSWXwDVk9+WEd1ofuJnlV/YvtiSdsC91K9YvqPFkqMIesjE0uAP6N6Jb0BONv2+4ZdZwzPeJkArgZuBPamOrX3EeB02z8bcpmtS4OKiIgi5RRfREQUKQ0qIiKKlAYVERFFSoOKiIgiFfFJEnPmzPHcuXPbLiMGYNWqVffb3nGq+0kmZo5kIpr6zUSrDUrSImDRvHnzWLlyZZulxIBIunOK908mZphkIpr6zURO8UVERJFaHUHZvgq4av78+Se1WUeUI5mIpmRi8uaedvW469eddfSQKpmcVkdQkhZJOnfjxo1tlhEFSSaiKZnorlYblO2rbJ88e/bsNsuIgiQT0ZRMdFcxkyQ2F5saMkP5w+aSbY6ZiOmVTHRXrkFtxmZis0wmpiaZiJkk16CiKMlENCUT3ZVrUFGUZCKakonuyvugIiKiSJkkEUXZHDMxE6/7lGRzzEQMRk7xRVGSiWhKJrorp/giIqJIRXyaeUTETJFTvoOTaeZRlGQimpKJ7tos3qibVyTdkTdlRlMy0V25BhUREUXKNaiGfkZrEREx/QY+gpK0n6RzJF0u6U2D3n9ERHRDXyMoSecDLwXus31gz/KFwPuBLYHzbJ9lew1wiqQtgI8CHxp82dGvmXr9bqY+roh4Ur8jqAuAhb0LJG0JnA0cBewPLJa0f73uZcDVwPKBVRoREZ3S1wjK9o2S5jYWHwKstX0HgKRLgWOAb9i+ErhS0tXAx0fbp6STgZMB9thjj8lVHzNKqZnIdcn2lJqJGI6pTJLYDbir5/Z64FBJRwCvALZhnBGU7XMl3QMsmjVr1sFTqCNmiGQimpKJ6VX6qfKBz+KzfQNww6D3GxER3TKVBnU38Oye27vXy/qWN+BFUzIx/Up/1dyUTHTXVKaZrwD2kbSXpFnACcCVE9lBPsIkmpKJaEomuqvfaeaXAEcAcyStB/7O9lJJS4BrqaaZn2979bRVGhExjs1tZBib1u8svsVjLF/OFKaSZ+g+tq7OHEsmoimZ6K58mnkUJZmIpmSiu/KNulGUZCKakonuavXDYiUtAhbNmzevzTKiIMnE2Lp62jeZ6K6MoKIoyUQ0JRPdle+DioiIImWSRBQlmYimZKK7coovipJMRFMy0V35Rt2IiAno6mSVNuQaVEREFCkNKiIiipRJElGUZCKakonuyiSJKEoyEU3JRHflFF9ERBRp4LP4JL0cOBrYAVhq+7pB/46IiJj5+hpBSTpf0n2Svt5YvlDSNyWtlXQagO1P2z4JOAU4fvAlR0REF/R7iu8CYGHvAklbAmcDRwH7A4sl7d+zyen1+oiIiAnrq0HZvhF4oLH4EGCt7TtsPw5cChyjynuBa2zfPNhyIyKiK6YySWI34K6e2+vrZW8BFgDHSTplrDtLOlnSSkkrN2zYMIUyYqZIJqIpmeg22e5vQ2ku8BnbB9a3jwMW2j6xvv0a4FDbS/r+5fX3vFBdq7p9YqUP3Rzg/raLKNjI8dnT9o6T3UkyMaN0LRPJw6ZNKBNTaVCHAWfYPrK+/TYA2++ZXN1lk7TS9vy26yhVF49PFx/zRHTt+HTt8U7GRI/RVE7xrQD2kbSXpFnACcCVU9hfRETEL/Q7zfwS4CZgX0nrJb3R9hPAEuBaYA2wzPbq6Ss1IiK6pK836tpePMby5cDygVZUrnPbLqBwXTw+XXzME9G149O1xzsZEzpGfV+DioiIGKZ8Fl9ERBQpDSoiIoqUBhUREUVKg4qIiCKlQUVERJHSoCIiokhpUBERUaQ0qIiIKFIaVEREFCkNKiIiipQGFRERRUqDioiIIqVBRUREkdKgpoGkj0m6R9JDkr4l6cSedS+SdJukRyV9TtKebdYawzFWJiTNknS5pHWSLOmIdiuNYRknE8+X9O+SHpC0QdJlknZpu9425Os2poGkA4C1th+T9GvADcDRwJ3At4ETgauAdwKH235+W7XGcIyTia8BbwZWApcBi23f0FadMTzjZGInYDuqL4N9AvgAsKvthW3V2pa+vrAwJqbxzcKuf/YGDgZW274MQNIZwP2Sfs32bUMvNIZmrEzYXgX8C4Ckn7VQWrRknEws691O0geAzw+ztlLkFN80kfRBSY8CtwH3UH3z8AHAV0e2sf0jqhHVAa0UGUM1Riaiw/rMxG8Dq0dZPuOlQU0T228GtgcOBz4JPEY1bN/Y2HRjvV3McGNkIjpsU5mQ9FzgHcBfDr+69qVBTSPbP7P9RWB34E3AI8AOjc12AB4edm3RjlEyER03ViYkzQOuAU61/YW26mtTGtRwbEV1DWo18BsjCyX9Ss/y6JaRTESM+EUm6tm91wPvtH1Rq1W1KA1qwCTtJOkESdtJ2lLSkcBi4D+ATwEHSjpW0rZUQ/dbM0FiZttEJpC0TZ0HgFmStpWk1gqOaTdeJiTtBvwn8AHb57RbabsyzXzAJO0IXE41UtqCamr5v9r+cL1+AdW00T2BrwCvt72unWpjGPrIxDqqPPTaK7mYucbLhKS/A84AftR7H9vbDbvOtqVBRUREkXKKLyIiipQGFRERRUqDioiIIqVBRUREkYr4LL45c+Z47ty5bZcRA7Bq1ar7be841f0kEzNHMhFN/Wai1QYlaRGwaN68eaxcubLNUmJAJN05xfsnEzNMMhFN/WYip/giIqJIrTYo21fZPnn27NltlhEFSSaiKZnorlYblKRFks7duLH5Ad/RVclENCUT3dXqNSjbVwFXzZ8//6Q269iczD3t6jHXrTvr6CFWMj2SiWhKJrorI6goSjIRTclEd+UaVBQlmYimZKK7MoKKoiQT0ZRMdFdGUFGUZGJq5p529VN+ZoJkorvyPqiIiChSTvFFUZKJaEomuiun+KIoyUQ0JRPdlVN8ERFRpDSoiIgoUq5BRVGSiWhKJror16CiKMlENCUT3VXEFxZGRMTgNd8Lt7l9XmeuQUVERJEG3qAk7SfpHEmXS3rToPcfERHd0NcpPknnAy8F7rN9YM/yhcD7gS2B82yfZXsNcIqkLYCPAh8afNkRZdjcT6FElKzfEdQFwMLeBZK2BM4GjgL2BxZL2r9e9zLgamD5wCqNiIhO6WsEZftGSXMbiw8B1tq+A0DSpcAxwDdsXwlcKelq4OOj7VPSycDJAHvsscfkqp9mM/3LAUuzOWQihiuZ6LapzOLbDbir5/Z64FBJRwCvALZhnBGU7XMl3QMsmjVr1sFTqCNmiGQimpKJbhv4NHPbNwA3DHq/ERHRLVOZxXc38Oye27vXy/qWN+BFUzIRTclEd02lQa0A9pG0l6RZwAnAlRPZQT7CJJqSiWhKJrqrrwYl6RLgJmBfSeslvdH2E8AS4FpgDbDM9urpKzUiIrqkrwZle7HtXWxvbXt320vr5cttP8f23rb/YaK/PEP3aEomoimZ6K58mnkUJZmIpmSiu/Jp5lGUZCKakonuyofFRkREkXKKL4qSTERTMtFdOcUXRUkmoimZ6K6MoKIoyUQ0JRPdlRFUFCWZiKZkorsySSIiIoqUBhUREUVKg4qIiCIN/Os2JkLSImDRvHnzxt1uvC8OhHx54EzSbyaiO5KJ7sokiShKMhFNyUR35RRfREQUaeCn+CS9HDga2AFYavu6Qf+OiIiY+fr9PqjzJd0n6euN5QslfVPSWkmnAdj+tO2TgFOA4wdfckREdEG/p/guABb2LpC0JXA2cBSwP7BY0v49m5xer4+IiJiwvk7x2b5R0tzG4kOAtbbvAJB0KXCMpDXAWcA1tm8eZLEREZuD3pnHmWU8eVOZJLEbcFfP7fX1srcAC4DjJJ0y1p0lnSxppaSVGzZsmEIZMVMkE9GUTHSbbPe3YTWC+oztA+vbxwELbZ9Y334NcKjtJX3/8vr9DVTXqm6fWOlDNwe4v+0iCjZyfPa0veNkd5JMzChdy0TysGkTysRUGtRhwBm2j6xvvw3A9nsmV3fZJK20Pb/tOkrVxePTxcc8EV07Pl17vJMx0WM0lVN8K4B9JO0laRZwAnDlFPYXERHxC/1OM78EuAnYV9J6SW+0/QSwBLgWWAMss716+kqNiIgu6XcW3+Ixli8Hlg+0onKd23YBhevi8eniY56Irh2frj3eyZjQMer7GlRERMQw5bP4IiKiSGlQERFRpDSoiIgoUqtfWFiininz37N9vaRXAy+gmql4ru2ftlpgDF0yEU3JxHBkkkSDpIupGvfTgQeB7YBPAi+iOl6va6+6aEMyEU3JxHCkQTVIutX2cyVtBdwN7Gr7Z5IEfNX2c1suMYYsmYimZGI4cg3ql21RD9+3p3p1NPI909sAW7dWVUEkzZZ0lqTbJD0g6QeS1tTLntF2fdMgmdiEZCKZaBpEJtKgftlS4DbgFuBvgcskfZjqo50ubbGukiwDfggcYfuZtp8F/G69bFmrlU2PZGLTkolkomnKmcgpvlFI2hXA9vfqTr8A+K7t/2q1sEJI+qbtfSe6bnOWTIwvmUgmmgaRiTSomDBJ1wHXAxfa/n69bGfg9cCLbS9osbxoQTIRTYPIRE7xxWQcDzwL+Hx9bvkB4AbgmcAr2ywsWpNMRNOUM5ERVAyUpD+2/ZG264hyJBPR1G8m0qBioCR91/YebdcR5UgmoqnfTOSTJGLCJN061ipg52HWEmVIJqJpEJlIg4rJ2Bk4kmq6aC8BXx5+OVGAZCKappyJNKiYjM8A29m+pblC0g1DryZKkExE05QzkWtQERFRpEwzj4iIIqVBRUREkdKgIiKiSGlQERFRpP8P7EjJogkSq0IAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "createQPModeHisto_dev(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tracked-jimmy",
   "metadata": {},
   "source": [
    "# Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "angry-patient",
   "metadata": {
    "code_folding": [
     50,
     238,
     336,
     426,
     434,
     524,
     532,
     621,
     629,
     638,
     641,
     653,
     656,
     735,
     743,
     824,
     832,
     936,
     944
    ]
   },
   "outputs": [],
   "source": [
    "from numpy import sin, cos, pi, exp, sqrt, zeros, ones, arange, mean, inf, cumsum, array, arctanh\n",
    "from numpy.random import random, choice, uniform\n",
    "from math import factorial\n",
    "from time import perf_counter\n",
    "from fitTools.Resonator import Resonator\n",
    "from scipy.signal import butter, lfilter\n",
    "from scipy.signal import windows, convolve\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "import dill\n",
    "import os\n",
    "import sys\n",
    "import random as rd\n",
    "\n",
    "\n",
    "def create_high_low_state_switch_process(N, sampleUnit=5, fraction=0.1,pFactor=2):\n",
    "    samples = np.ones(N)\n",
    "    freq = int(N / sampleUnit)\n",
    "    fraction = 0.2\n",
    "\n",
    "    samples = samples.reshape(sampleUnit, freq)\n",
    "\n",
    "    for sample in samples:\n",
    "        bound = int(fraction * len(sample))\n",
    "        sample[:bound] = pFactor\n",
    "\n",
    "    samples = samples.flatten()\n",
    "    return samples\n",
    "\n",
    "\n",
    "def create_high_low_state_switch_stochastic_process(N,\n",
    "                                                    sampleUnit=5,\n",
    "                                                    fraction=0.1,\n",
    "                                                    pFactor=2):\n",
    "    samples = np.ones(N)\n",
    "    freq = int(N / sampleUnit)\n",
    "\n",
    "    samples = samples.reshape(sampleUnit, freq)\n",
    "\n",
    "    for sample in samples:\n",
    "        bound = int(fraction * len(sample)) + int(\n",
    "            rd.uniform(0,\n",
    "                       rd.uniform(-fraction, fraction) * len(sample)))\n",
    "        sample[:bound] = pFactor\n",
    "\n",
    "    samples = samples.flatten()\n",
    "    return samples\n",
    "\n",
    "def createDir(sim_type):\n",
    "    date_run = datetime.now().strftime(\"%Y_%m_%d_%I_%M_%p\")\n",
    "    pwd = \"./data/{}/run_{}/\".format(sim_type,date_run)\n",
    "    try:\n",
    "        os.makedirs(pwd)\n",
    "    except OSError as error:\n",
    "        print(error)\n",
    "    return pwd\n",
    "    \n",
    "matplotlib.use('agg')\n",
    "\n",
    "\n",
    "class QPtrapper:\n",
    "    def __init__(self,\n",
    "                 N=1000,\n",
    "                 Lj=3.6e-11,\n",
    "                 tauTrap=1e-5,\n",
    "                 tauRelease=1e-5,\n",
    "                 tauCommon=1e-4,\n",
    "                 tauRare=1e-2,\n",
    "                 tauRecomb=1e-4,\n",
    "                 sampleRate=300e6,\n",
    "                 phi=0.4,\n",
    "                 Delta=2.72370016e-23,\n",
    "                 T=0.025,\n",
    "                 model=\"default\",\n",
    "                 targetDir = \"\"):\n",
    "\n",
    "        self.N = int(N)  #number of samples (i.e. duration*sample_rate)\n",
    "        \"\"\"\n",
    "        poisson paramaters\n",
    "        \"\"\"\n",
    "        # self.Lj = Lj/self.cosd\n",
    "        self.tauCommon = tauCommon  #poisson param for?\n",
    "        self.tauRare = tauRare  #poisson param for cosmic ray events\n",
    "        self.tauRecomb = tauRecomb  #poisson param for qp recombining\n",
    "        self.tau = tauTrap  #poisson param for qp traps\n",
    "        self.tauR = tauRelease  #poisson param for qp release\n",
    "        \"\"\"\n",
    "        physical input parameters\n",
    "        \"\"\"\n",
    "        self.sampleRate = sampleRate  #sample rate\n",
    "        self.dt = 1 / sampleRate  #timesteps\n",
    "        self.phi = phi  #flux bias\n",
    "        self.Delta = Delta  #?\n",
    "        self.T = T  #total time?\n",
    "        self.de = pi * phi  #?\n",
    "        #        if ((phi // 0.5) % 2):\n",
    "        #            self.de += pi\n",
    "        \"\"\"\n",
    "        trig calculations\n",
    "        \"\"\"\n",
    "        self.cosd = cos(self.de)\n",
    "        self.sind2 = sin(self.de)**2\n",
    "        self.sin4 = sin(self.de / 2)**4\n",
    "        self.sin2 = sin(self.de / 2)**2\n",
    "        \"\"\"\n",
    "        fundamental constants\n",
    "        \"\"\"\n",
    "        self.phi0 = 2.06783383 * 1e-15  #h/2e\n",
    "        self.kb = 1.38064852e-23\n",
    "        self.rphi0 = self.phi0 / (2 * pi)  #hbar/2e\n",
    "        \"\"\"\n",
    "        physical parameters related to output?\n",
    "        \"\"\"\n",
    "        self.Ne = 8 * (self.rphi0**2) / (self.Delta * Lj)  #?\n",
    "        self.Lj0 = Lj  #inductance initial?\n",
    "        self.Lj = Lj / (1 - sin(self.de / 2) * arctanh(sin(self.de / 2))\n",
    "                        )  #inductance?\n",
    "        # alpha = self.Delta/(4*(self.rphi0**2))\n",
    "        alpha = self.Delta / (2 * (self.rphi0**2))  #?\n",
    "        self.L1 = alpha * (self.cosd / sqrt(1 - self.sin2) + self.sind2 /\n",
    "                           (4 * sqrt(1 - self.sin2)**3))  #?\n",
    "        \"\"\"\n",
    "        simulation start command\n",
    "        \"\"\"\n",
    "        self.tDir = targetDir\n",
    "        self.model = model\n",
    "        if model == \"default\":\n",
    "            print(\"simulation with bulk material\")\n",
    "            self._getSwitchingEvents()\n",
    "            self.generatePlots()\n",
    "        elif model == \"con\":\n",
    "            print(\"simulation with constant pT\")\n",
    "            self._getSwitchingEvents_constant()\n",
    "            self.generatePlots()\n",
    "        elif model == \"p\":\n",
    "            print(\"simulation with periodic pT\")\n",
    "            self._getSwitchingEvents_periodic_pT()\n",
    "            self.generatePlots()\n",
    "        elif model == \"ps\":\n",
    "            print(\"simulation with periodic-stochastic pT\")\n",
    "            self._getSwitchingEvents_periodic_stochastic_pT()\n",
    "            self.generatePlots()\n",
    "        elif model == \"corcon\":\n",
    "            print(\"simulation with correlated-constant pT\")\n",
    "            self._getSwitchingEvents_periodic_correlated_constant_pT()\n",
    "            self.generatePlots()\n",
    "        elif model == \"corp\":\n",
    "            print(\"simulation with correlated-periodic pT\")\n",
    "            self._getSwitchingEvents_periodic_correlated_periodic_pT()\n",
    "            self.generatePlots()\n",
    "        elif model == \"corps\":\n",
    "            print(\"simulation with correlated-periodic_stochastic pT\")\n",
    "            self._getSwitchingEvents_periodic_correlated_periodic_stochastic_pT(\n",
    "            )\n",
    "            self.generatePlots()\n",
    "        elif model == \"anticorps\":\n",
    "            print(\"simulation with anti-correlated-periodic_stochastic pT\")\n",
    "            self._getSwitchingEvents_periodic_anticorrelated_periodic_stochastic_pT()\n",
    "            self.generatePlots()\n",
    "        else:\n",
    "            print(\"model parameter missing\")\n",
    "            pass\n",
    "            \n",
    "    def makeTimeSeriesPlot(self):\n",
    "        time = arange(self.N) / self.sampleRate\n",
    "        h, ax = plt.subplots(3, 1, sharex=True)\n",
    "        plt.suptitle('QP Trapping Dynamics ({})'.format(self.model))\n",
    "        ax[0].plot(time * 1e3, self.nTrapped, '-g')\n",
    "        ax[0].set_ylabel('N trapped')\n",
    "        ax[1].plot(time * 1e3, self.nGenerated, '-b')\n",
    "        ax[1].set_ylabel('N generated')\n",
    "        ax[1].set_xlabel('Time [ms]')\n",
    "        ax[2].plot(time * 1e3, self.releasePop, '-b')\n",
    "        ax[2].set_ylabel('N released')\n",
    "        ax[2].set_xlabel('Time [ms]')\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(\"{}qp_timeseries_{}.png\".format(self.tDir,self.model),facecolor='white', transparent=False)\n",
    "        plt.close()\n",
    "    \n",
    "    \n",
    "    def createHisto(self,df,val,title,plotname,bins=50,logy=False,logx=False):\n",
    "        df.hist(column=val)\n",
    "        plt.title(title)\n",
    "        if logy:\n",
    "            plt.yscale(\"log\")\n",
    "        if logx:\n",
    "            plt.xscale(\"log\")\n",
    "        plt.savefig(self.tDir+plotname+\"_histo.png\",facecolor='white', transparent=False)\n",
    "        plt.close()\n",
    "\n",
    "    def createQPModeHisto(self, df):\n",
    "        df.hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "        plt.suptitle(\"QP Occupation In Each Mode (log scale)\")\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(self.tDir+\"qp_all_mode_log_scale\"+\"_histo.png\",facecolor='white', transparent=False)\n",
    "        plt.close()\n",
    "\n",
    "        maxqp = df[\"n_trapped\"].max()\n",
    "        qp_range = np.arange(0,maxqp,8)\n",
    "\n",
    "        for i in range(len(qp_range)-1):\n",
    "            df[(qp_range[i]<=df[\"n_trapped\"])&(df[\"n_trapped\"]<=qp_range[i+1])].hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "            plt.suptitle(\"QP Occupation In Each Mode ({}-{})\".format(qp_range[i],qp_range[i+1]))\n",
    "            plt.tight_layout()\n",
    "            plt.savefig(self.tDir+\"qp_mode_{}_{}\".format(qp_range[i],qp_range[i+1])+\"_histo.png\",\n",
    "                       facecolor='white', transparent=False)\n",
    "            plt.close()\n",
    "\n",
    "        new_qp_range = [i for i in range(qp_range[-1]+1,maxqp+1)]\n",
    "\n",
    "        df[(new_qp_range[0]<=df[\"n_trapped\"])&(df[\"n_trapped\"]<=new_qp_range[-1])].hist(column=\"t\", by=\"n_trapped\", sharey=True, sharex=True,  log=True)\n",
    "        plt.suptitle(\"QP Occupation In Each Mode ({}-{})\".format(new_qp_range[0],new_qp_range[-1]))\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(self.tDir+\"qp_mode_{}_{}\".format(new_qp_range[0],new_qp_range[-1])+\"_histo.png\"\n",
    "                   ,facecolor='white', transparent=False)\n",
    "        plt.close()\n",
    "    \n",
    "    def generateHistograms(self):\n",
    "        stime = (arange(self.N) / self.sampleRate) * 1e3 #ms\n",
    "        ltimes = [(i/ self.sampleRate)*1e3 for i in self.lifeTimes]\n",
    "\n",
    "        df = pd.DataFrame(data={\"t\":stime, \"n_trapped\":self.nTrapped, \"n_rel\": self.releasePop})\n",
    "        dflt = pd.DataFrame(data={\"ltimes\":ltimes})\n",
    "\n",
    "        self.createHisto(df,\"n_trapped\",\"Number of QP Trapped\",\"qp_trapped\",logy=False,bins=20)\n",
    "        self.createHisto(df,\"n_rel\",\"Number of QP Released\",\"qp_released\",logy=True)\n",
    "\n",
    "        self.createHisto(dflt,\"ltimes\",\"Lifetime of Trapped QPs [ms]\",\"qp_trapped_lifetime\",logy=False,bins=None)\n",
    "\n",
    "        self.createQPModeHisto(df)\n",
    "    \n",
    "    \n",
    "    def generatePlots(self):\n",
    "        self.makeTimeSeriesPlot()\n",
    "        self.generateHistograms()\n",
    "    \n",
    "    def _getSwitchingEvents_periodic_anticorrelated_periodic_stochastic_pT(self, ):\n",
    "        \"\"\"\n",
    "            Constants Defining\n",
    "            \"\"\"\n",
    "        factor_increase = 0.5\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "            Creating Poisson Distribution for the various process\n",
    "            \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "            Data Structures for storing info from simulation\n",
    "            \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        \n",
    "        pT_coefficient = create_high_low_state_switch_stochastic_process(\n",
    "            N, sampleUnit=5, fraction=0.25)\n",
    "        self.trapped = False\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "                Produce common QP generation events\n",
    "                \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "                Produce trapping events\n",
    "                \"\"\"\n",
    "            if not self.trapped:\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * pT_coefficient[n]  #periodic_pT\n",
    "            elif self.trapped:\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * factor_increase  #factor * constant_pT\n",
    "\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "                self.trapped = True\n",
    "            if k == 0:\n",
    "                self.trapped = False\n",
    "            \"\"\"                    \n",
    "                Produce release events\n",
    "                \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "    #           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "    \n",
    "    def _getSwitchingEvents_periodic_correlated_periodic_pT(self, ):\n",
    "        \"\"\"\n",
    "            Constants Defining\n",
    "            \"\"\"\n",
    "        factor_increase = 2.0\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "            Creating Poisson Distribution for the various process\n",
    "            \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "            Data Structures for storing info from simulation\n",
    "            \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        pT_coefficient = create_high_low_state_switch_process(N,\n",
    "                                                              sampleUnit=5,\n",
    "                                                              fraction=0.25)\n",
    "        self.trapped = False\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "                Produce common QP generation events\n",
    "                \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "                Produce trapping events\n",
    "                \"\"\"\n",
    "            if not self.trapped:\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * pT_coefficient[n]  #periodic_pT\n",
    "            elif self.trapped:\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * factor_increase  #factor * constant_pT\n",
    "\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "                self.trapped = True\n",
    "            if k == 0:\n",
    "                self.trapped = False\n",
    "            \"\"\"                    \n",
    "                Produce release events\n",
    "                \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "    #           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n",
    "    def _getSwitchingEvents_periodic_correlated_periodic_stochastic_pT(self, ):\n",
    "        \"\"\"\n",
    "            Constants Defining\n",
    "            \"\"\"\n",
    "        factor_increase = 2.0\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "            Creating Poisson Distribution for the various process\n",
    "            \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "            Data Structures for storing info from simulation\n",
    "            \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        \n",
    "        pT_coefficient = create_high_low_state_switch_stochastic_process(\n",
    "            N, sampleUnit=5, fraction=0.25)\n",
    "        self.trapped = False\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "                Produce common QP generation events\n",
    "                \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "                Produce trapping events\n",
    "                \"\"\"\n",
    "            if not self.trapped:\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * pT_coefficient[n]  #periodic_pT\n",
    "            elif self.trapped:\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * factor_increase  #factor * constant_pT\n",
    "\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "                self.trapped = True\n",
    "            if k == 0:\n",
    "                self.trapped = False\n",
    "            \"\"\"                    \n",
    "                Produce release events\n",
    "                \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "    #           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n",
    "    def _getSwitchingEvents_periodic_correlated_constant_pT(self, ):\n",
    "        \"\"\"\n",
    "            Constants Defining\n",
    "            \"\"\"\n",
    "        factor_increase = 2.0\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "            Creating Poisson Distribution for the various process\n",
    "            \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "            Data Structures for storing info from simulation\n",
    "            \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        \n",
    "        # pT_coefficient = create_high_low_state_switch_stochastic_process(N,sampleUnit=10,fraction=0.1)\n",
    "        self.trapped = False\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "                Produce common QP generation events\n",
    "                \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "                Produce trapping events\n",
    "                \"\"\"\n",
    "            if not self.trapped:\n",
    "                trapmask = random() < len(self.nGen) * pT  #constant_pT\n",
    "            elif self.trapped:\n",
    "                # trapmask = random() < len(self.nGen)*pT*pT_coefficient[n], 1) #periodic_pT\n",
    "                trapmask = random() < len(\n",
    "                    self.nGen) * pT * factor_increase  #factor * constant_pT\n",
    "\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "                self.trapped = True\n",
    "            if k == 0:\n",
    "                self.trapped = False\n",
    "            \"\"\"                    \n",
    "                Produce release events\n",
    "                \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "    #           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n",
    "    def _dorokhov_boltz(self,\n",
    "                        tau,\n",
    "                        Ne=680,\n",
    "                        delta=2.72370016e-23,\n",
    "                        de=pi / 2,\n",
    "                        T=0.025):\n",
    "        return Ne / (tau * sqrt(1 - tau)) * exp(-self._Ea(tau, delta, de) /\n",
    "                                                (self.kb * T))\n",
    "\n",
    "    def _Ea(self, tau, delta=2.72370016e-23, de=pi / 2):\n",
    "        return delta * sqrt(1 - tau * sin(de / 2)**2)\n",
    "\n",
    "    def _MC_doro(self, Ne=680, delta=2.72370016e-23, de=pi / 2, T=0.025):\n",
    "        scale = self._dorokhov_boltz(0.999999999, Ne, delta, de, T)\n",
    "        while True:\n",
    "            x = uniform(low=0.0, high=1)\n",
    "            y = random() * scale\n",
    "            try:\n",
    "                if y < self._dorokhov_boltz(x, Ne, delta, de, T):\n",
    "                    return x\n",
    "                    break\n",
    "            except (ZeroDivisionError, RuntimeWarning):\n",
    "                pass\n",
    "\n",
    "    def _Poisson(self, tau):\n",
    "        return (self.dt / tau) * exp(-self.dt / tau)\n",
    "\n",
    "    def _getSwitchingEvents_periodic_stochastic_pT(self, ):\n",
    "        \"\"\"\n",
    "            Constants Defining\n",
    "            \"\"\"\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "            Creating Poisson Distribution for the various process\n",
    "            \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "            Data Structures for storing info from simulation\n",
    "            \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "        \n",
    "        pT_coefficient = create_high_low_state_switch_stochastic_process(\n",
    "            N, sampleUnit=5, fraction=0.25)\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "                Produce common QP generation events\n",
    "                \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "                Produce trapping events\n",
    "                \"\"\"\n",
    "            trapmask = random() < len(\n",
    "                self.nGen) * pT * pT_coefficient[n]  #periodic_pT\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "            \"\"\"                    \n",
    "                Produce release events\n",
    "                \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "    #           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n",
    "    def _getSwitchingEvents_periodic_pT(self, ):\n",
    "        \"\"\"\n",
    "        Constants Defining\n",
    "        \"\"\"\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "            Creating Poisson Distribution for the various process\n",
    "            \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "            Data Structures for storing info from simulation\n",
    "            \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        pT_coefficient = create_high_low_state_switch_process(N,\n",
    "                                                              sampleUnit=5,\n",
    "                                                              fraction=0.25)\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "                Produce common QP generation events\n",
    "                \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "                Produce trapping events\n",
    "                \"\"\"\n",
    "            trapmask = random() < len(\n",
    "                self.nGen) * pT * pT_coefficient[n]  #periodic_pT\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "\n",
    "            \"\"\"                    \n",
    "                Produce release events\n",
    "                \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "    #           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n",
    "    def _getSwitchingEvents(self, ):\n",
    "        #        phaseFactor = sin(abs(self.de))\n",
    "        #        pTrap = phaseFactor*self._Poisson(self.tau)\n",
    "        #        pTrap = self._Poisson(self.tau)\n",
    "        #        pRelease = self._Poisson(self.tauR)\n",
    "        #        pCommon = self._Poisson(self.tauCommon)\n",
    "        #        pRare = self._Poisson(self.tauRare)\n",
    "        \"\"\"\n",
    "        Constants Defining\n",
    "        \"\"\"\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "        Creating Poisson Distribution for the various process\n",
    "        \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRare = ((self.dt / self.tauRare)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRare) / factorials  #poisson distribution of cosmic\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "        Data Structures for storing info from simulation\n",
    "        \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nBulk = list(ones(3))  #3D vector for some reason?\n",
    "        self.bulkPop = []  #?\n",
    "        self.burstIndices = []  #?\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "            Produce common QP generation events\n",
    "            \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nBulk.append(1)\n",
    "                self.nBulk.append(1)\n",
    "            \"\"\"\n",
    "            Produce rare QP generation events -- such as cosmic ray bursts\n",
    "            \"\"\"\n",
    "            raremask = random() < pRare\n",
    "            k = cs[raremask][-1] if raremask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.burstIndices.append(n)\n",
    "                burst = int(random() * 50)\n",
    "                for i in range(burst):\n",
    "                    self.nBulk.append(1)\n",
    "                    self.nBulk.append(1)\n",
    "            \"\"\"\n",
    "            Produce pair recombination events\n",
    "            \"\"\"\n",
    "            recombmask = random() < len(self.nBulk) * pRecomb\n",
    "            k = cs[recombmask][-1] if recombmask.any() else 0\n",
    "            k = min((k, len(self.nBulk) // 2))\n",
    "            for _ in range(k):\n",
    "                self.nBulk.remove(1)\n",
    "                self.nBulk.remove(1)\n",
    "            \"\"\"        \n",
    "            Produce trapping events\n",
    "            \"\"\"\n",
    "            trapmask = random() < len(self.nBulk) * pT\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nBulk)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "                if self.nBulk:\n",
    "                    self.nBulk.remove(1)\n",
    "            \"\"\"                    \n",
    "            Produce release events\n",
    "            \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nBulk.append(1)\n",
    "\n",
    "#           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.bulkPop.append(len(self.nBulk))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n",
    "    def _getSwitchingEvents_constant(self, ):\n",
    "        \"\"\"\n",
    "        Constants Defining\n",
    "        \"\"\"\n",
    "        phi0 = self.phi0\n",
    "        rphi0 = phi0 / (2 * pi)\n",
    "        alpha = self.Delta / (2 * (rphi0**2))\n",
    "        \"\"\"\n",
    "        Creating Poisson Distribution for the various process\n",
    "        \"\"\"\n",
    "        cs = array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int)  #channels?\n",
    "        factorials = array([factorial(k) for k in cs],\n",
    "                           dtype=int)  #factorials of cs values\n",
    "        pR = ((self.dt / self.tauR)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauR) / factorials  #poisson distribution of release\n",
    "        pT = ((self.dt / self.tau)**cs) * exp(\n",
    "            -self.dt / self.tau) / factorials  #poisson distribution of trap\n",
    "        pCommon = ((self.dt / self.tauCommon)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauCommon) / factorials  #poisson distribution of common\n",
    "        pRecomb = ((self.dt / self.tauRecomb)**cs) * exp(\n",
    "            -self.dt /\n",
    "            self.tauRecomb) / factorials  #poisson distribution of recombine\n",
    "        \"\"\"\n",
    "        Data Structures for storing info from simulation\n",
    "        \"\"\"\n",
    "        trappedChannels = []  #?\n",
    "        self.nTrapped = []  #number of trapped QP\n",
    "        lFreqFactors = []  #?\n",
    "        # alpha = self.Delta/(4*(rphi0**2))\n",
    "        self.freqFactors = zeros(self.N)  #?\n",
    "        self.nGen = []\n",
    "        self.nRel = []\n",
    "        self.releasePop = []\n",
    "        self.nGenerated = []\n",
    "        self.lifeTimes = []\n",
    "\n",
    "        for n in range(self.N):\n",
    "            \"\"\"\n",
    "            Produce common QP generation events\n",
    "            \"\"\"\n",
    "            commask = random() < pCommon\n",
    "            k = cs[commask][-1] if commask.any() else 0\n",
    "            for _ in range(k):\n",
    "                self.nGen.append(1)\n",
    "                self.nGen.append(1)\n",
    "            \"\"\"        \n",
    "            Produce trapping events\n",
    "            \"\"\"\n",
    "            trapmask = random() < len(self.nGen) * pT  #this needs updating!!!\n",
    "            k = cs[trapmask][-1] if trapmask.any() else 0\n",
    "            k = min((k, len(self.nGen)))\n",
    "            for _ in range(k):\n",
    "                tau = self._MC_doro(self.Ne, self.Delta, self.de, self.T)\n",
    "                E = self._Ea(tau, self.Delta, self.de)\n",
    "                trappedChannels.append({'t': tau, 'E': E, 't_trapped': n})\n",
    "            \"\"\"                    \n",
    "            Produce release events\n",
    "            \"\"\"\n",
    "            relmask = random() < len(trappedChannels) * pR\n",
    "            k = cs[relmask][-1] if relmask.any() else 0\n",
    "            k = min((k, len(trappedChannels)))\n",
    "            for _ in range(k):\n",
    "                ch = choice(trappedChannels)\n",
    "                trappedChannels.remove(ch)\n",
    "                self.lifeTimes.append(n - ch[\"t_trapped\"])\n",
    "                self.nRel.append(1)\n",
    "\n",
    "#           Track changes\n",
    "            self.nTrapped.append(len(trappedChannels))\n",
    "            self.releasePop.append(len(self.nRel))\n",
    "            self.nGenerated.append(len(self.nGen))\n",
    "\n",
    "            #           Calculate frequency shift terms for each time point -- Sum_i 1/L_i\n",
    "            lFreqFactors.append([\n",
    "                alpha * c['t'] *\n",
    "                (self.cosd / sqrt(1 - c['t'] * self.sin2) +\n",
    "                 c['t'] * self.sind2 / (4 * sqrt(1 - c['t'] * self.sin2)**3))\n",
    "                for c in trappedChannels\n",
    "            ])\n",
    "            self.freqFactors[n] += sum(lFreqFactors[n])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "documentary-mobility",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class NBResonator():\n",
    "    def __init__(self,\n",
    "                 trapper,\n",
    "                 L=1e-9,\n",
    "                 C=0.7e-12,\n",
    "                 photonRO=1,\n",
    "                 photonNoise=0.5,\n",
    "                 Qi=5e4,\n",
    "                 Qe=5e4,\n",
    "                 sampleRate=300e6,\n",
    "                 delKappa=-0.5,\n",
    "                 fd=None):\n",
    "\n",
    "        self.port1 = Resonator('R')  #Resonator Object Instantiation\n",
    "        \"\"\"\n",
    "        info from QPTrapper Sim\n",
    "        \"\"\"\n",
    "        self.N = trapper.N\n",
    "        self.Lj0 = trapper.Lj0\n",
    "        self.Lj = trapper.Lj\n",
    "        \"\"\"\n",
    "        values calculated from QPTrapper Sim\n",
    "        \"\"\"\n",
    "        self.f0 = 1 / (2 * np.pi * np.sqrt((L + self.Lj) * C))\n",
    "        self.q0 = self.Lj / (L + self.Lj)\n",
    "        \"\"\"\n",
    "        input parameters\n",
    "        \"\"\"\n",
    "        self.photonRO = photonRO\n",
    "        self.Qi = Qi\n",
    "        self.Qe = Qe\n",
    "        self.Qt = Qi * Qe / (Qi + Qe)\n",
    "        self.sampleRate = sampleRate\n",
    "        \"\"\"\n",
    "        some physical parameters\n",
    "        \"\"\"\n",
    "        self.kappa = 2 * np.pi * self.f0 / self.Qt\n",
    "        self.kappa_e = 2 * np.pi * self.f0 / self.Qe\n",
    "        self.fwhm = self.f0 / self.Qt\n",
    "        self.diameter = 2 * self.Qt / self.Qe\n",
    "        self.f = self.f0 + delKappa * self.kappa / (\n",
    "            2 * np.pi)  # the resonator drive frequency for measurement\n",
    "\n",
    "        if fd != None:\n",
    "            self.f = fd\n",
    "        self.f_form = self.f0 - (self.q0 * self.f0 * self.Lj *\n",
    "                                 np.array(trapper.freqFactors) / 2)\n",
    "        self.f_shift = self.q0 * self.f0 * self.Lj * trapper.L1 / 2\n",
    "        #        self.SNR = photonRO*self.kappa/(4*sampleRate)*(1 - 4*self.Qt/self.Qe * (1-self.Qt/self.Qe))\n",
    "        \"\"\"\n",
    "        SNR Calculation\n",
    "        \"\"\"\n",
    "        self.pSNR = photonRO * self.kappa**2 / (4 * self.kappa_e *\n",
    "                                                (0.5 + photonNoise) *\n",
    "                                                sampleRate)\n",
    "        self.pSNRdB = max(20, 10 * np.log10(self.pSNR)) #updated SNR\n",
    "        print(self.pSNRdB)\n",
    "        #        self.sigma = self.diameter/(2*np.sqrt(2*self.SNR))\n",
    "        self.sigma = 1 / np.sqrt(self.pSNR)\n",
    "        self.complex_noise = np.empty(self.N, dtype=complex)\n",
    "        self.complex_noise.real = np.random.normal(scale=self.sigma, size=self.N) #default\n",
    "        self.complex_noise.imag = np.random.normal(scale=self.sigma,size=self.N) #default\n",
    "        #self.complex_noise.real = 0 #zero noise\n",
    "        #self.complex_noise.imag = 0 #zero noise\n",
    "        #get the response at given frequency\n",
    "        #        self._get_clean_response(self.w)\n",
    "        \"\"\"\n",
    "        passing resonator paramaters to Resonator object to generate signal\n",
    "        \"\"\"\n",
    "        kwargs = dict(fr=self.f_form,\n",
    "                      Ql=self.Qt,\n",
    "                      Qc=self.Qe,\n",
    "                      a=1.,\n",
    "                      alpha=0.,\n",
    "                      delay=0.)\n",
    "        signal = self.port1._S11_directrefl(self.f, **kwargs)\n",
    "        self.signal = self.butter_lowpass_filter(\n",
    "            signal - signal[0], self.kappa, self.sampleRate) + signal[0]\n",
    "        \"\"\"\n",
    "        adding noise to signal\n",
    "        \"\"\"\n",
    "        self.signal += self.complex_noise\n",
    "        #        self.signal = self.port1._S11_directrefl(self.f,**kwargs)\n",
    "        \"\"\"\n",
    "        dictionary of all parameters from NBResonator Analysis\n",
    "        \"\"\"\n",
    "        self.dParams = {\n",
    "            'fd': self.f,\n",
    "            'f0': self.f0,\n",
    "            'Qt': self.Qt,\n",
    "            'Qi': self.Qi,\n",
    "            'Qe': self.Qe,\n",
    "            'N': self.N,\n",
    "            'q': self.q0,\n",
    "            'photonRO': self.photonRO,\n",
    "            'sampleRate': self.sampleRate,\n",
    "            'kappa': self.kappa,\n",
    "            'fwhm': self.fwhm,\n",
    "            'diameter': self.diameter,\n",
    "            'freq_shift': self.f_shift,\n",
    "            'SNR': self.pSNR,\n",
    "            'SNRdB': self.pSNRdB,\n",
    "            'sigma': self.sigma\n",
    "        }\n",
    "\n",
    "    def butter_lowpass(self, cutoff, fs, order=1):\n",
    "        nyq = 0.5 * fs\n",
    "        normal_cutoff = cutoff / nyq\n",
    "        b, a = butter(order, normal_cutoff, btype='low', analog=False)\n",
    "        return b, a\n",
    "\n",
    "    def butter_lowpass_filter(self, data, cutoff, fs, order=1):\n",
    "        b, a = self.butter_lowpass(cutoff, fs, order=order)\n",
    "        y = lfilter(b, a, data)\n",
    "        return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "applicable-tenant",
   "metadata": {},
   "source": [
    "# Driver"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "congressional-incidence",
   "metadata": {},
   "source": [
    "## Only QPTrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "outstanding-insight",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation with periodic-stochastic pT\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "MAIN CODE\n",
    "\"\"\"\n",
    "if __name__ == '__main__':\n",
    "    \"\"\"\n",
    "    input paramaters\n",
    "    \"\"\"\n",
    "    sim_type = \"test\"\n",
    "    model = \"ps\"  #options: default,p,ps,con,cor\n",
    "    duration = 1e-3  # seconds to record data\n",
    "    sampleRate = 300e6\n",
    "    N = int(duration * sampleRate)\n",
    "    tauTrap = 140e-6\n",
    "    tauRelease = 40e-6\n",
    "    tauCommon = 4e-4\n",
    "    tauRare = 1e-2\n",
    "    tauRecomb = 2e-3\n",
    "    phi = 0.45\n",
    "    Lj = 21.2e-12\n",
    "    L = 1.89e-9\n",
    "    C = 0.2776e-12\n",
    "    Qi = 6000\n",
    "    Qe = 500\n",
    "    photonRO = 2\n",
    "    delKappa = -0.1\n",
    "    targetDir = createDir(sim_type)\n",
    "\n",
    "    args = {\n",
    "        'N': N,\n",
    "        'Lj': Lj,\n",
    "        'tauTrap': tauTrap,\n",
    "        'tauRelease': tauRelease,\n",
    "        'tauCommon': tauCommon,\n",
    "        'tauRare': tauRare,\n",
    "        'tauRecomb': tauRecomb,\n",
    "        'sampleRate': sampleRate,\n",
    "        'phi': phi,\n",
    "        'Delta': 2.72370016e-23,\n",
    "        'T': 0.025,\n",
    "        'model': model,\n",
    "        'targetDir':targetDir\n",
    "    }\n",
    "\n",
    "    now = perf_counter()\n",
    "    test = QPtrapper(**args)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "stylish-westminster",
   "metadata": {},
   "source": [
    "## All Driver Code (Needs Update Before Deployment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "touched-prescription",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.signal import windows, convolve\n",
    "\n",
    "def plot_IQ(rhann,ihann,tDir):\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(rhann,label=\"I\")\n",
    "    plt.plot(ihann,label=\"Q\")\n",
    "    plt.legend()\n",
    "\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(rhann,label=\"I\")\n",
    "    plt.plot(ihann,label=\"Q\")\n",
    "    plt.xscale(\"log\")\n",
    "    plt.legend()\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"{}iq_timeseries.png\".format(tDir),facecolor='white', transparent=False)\n",
    "    plt.close()\n",
    "    \n",
    "    plt.hist2d(rhann, ihann, bins=(50, 50))\n",
    "    plt.colorbar()\n",
    "    plt.xlabel(\"I\")\n",
    "    plt.ylabel(\"Q\")\n",
    "    plt.savefig(\"{}iq_color_2dhisto.png\".format(tDir),facecolor='white', transparent=False)\n",
    "    plt.close()\n",
    "\n",
    "    plt.figure(figsize=(10,8))\n",
    "    plt.subplot(2, 1, 1)\n",
    "    plt.hist2d(rhann, ihann, bins=(50, 50), cmap=matplotlib.cm.gray)\n",
    "    plt.colorbar()\n",
    "    plt.xlabel(\"I\")\n",
    "    plt.ylabel(\"Q\")\n",
    "\n",
    "    plt.subplot(2, 1, 2)\n",
    "    plt.hist2d(rhann, ihann, bins=(50, 50), norm=matplotlib.colors.LogNorm(), cmap=matplotlib.cm.gray)\n",
    "    plt.colorbar()\n",
    "    plt.xlabel(\"I\")\n",
    "    plt.ylabel(\"Q\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(\"{}iq_norm_2dhisto.png\".format(tDir),facecolor='white', transparent=False)\n",
    "    plt.close()\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "MAIN CODE\n",
    "\"\"\"\n",
    "if __name__ == '__main__':\n",
    "    \"\"\"\n",
    "    input paramaters\n",
    "    \"\"\"\n",
    "    sim_type = str(sys.argv[1])\n",
    "    model = str(sys.argv[2])  #options: default,p,ps,con,cor\n",
    "    duration = 1e-3  # seconds to record data\n",
    "    sampleRate = 300e6\n",
    "    N = int(duration * sampleRate)\n",
    "    tauTrap = 140e-6\n",
    "    tauRelease = 40e-6\n",
    "    tauCommon = 4e-4\n",
    "    tauRare = 1e-2\n",
    "    tauRecomb = 2e-3\n",
    "    phi = 0.45\n",
    "    Lj = 21.2e-12\n",
    "    L = 1.89e-9\n",
    "    C = 0.2776e-12\n",
    "    Qi = 6000\n",
    "    Qe = 500\n",
    "    photonRO = 2\n",
    "    delKappa = -0.1\n",
    "    targetDir = createDir()\n",
    "\n",
    "    args = {\n",
    "        'N': N,\n",
    "        'Lj': Lj,\n",
    "        'tauTrap': tauTrap,\n",
    "        'tauRelease': tauRelease,\n",
    "        'tauCommon': tauCommon,\n",
    "        'tauRare': tauRare,\n",
    "        'tauRecomb': tauRecomb,\n",
    "        'sampleRate': sampleRate,\n",
    "        'phi': phi,\n",
    "        'Delta': 2.72370016e-23,\n",
    "        'T': 0.025,\n",
    "        'model': model,\n",
    "        'targetDir'=targetDir\n",
    "    }\n",
    "\n",
    "    now = perf_counter()\n",
    "    test = QPtrapper(**args)\n",
    "\n",
    "    from datetime import datetime\n",
    "\n",
    "    sim_time = datetime.now().strftime(\"%Y_%m_%d-%I_%M_%S_%p\")\n",
    "    \"\"\"\n",
    "    pickle the QPtrapper object\n",
    "    \"\"\"\n",
    "    try:\n",
    "        dill.dump(test,\n",
    "                  file=open(\n",
    "                      \"qp_trapper_{}_{}.pickle\".format(sim_type, sim_time),\n",
    "                      \"wb\"))\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "    timer = perf_counter() - now\n",
    "    print('qptrapper runtime: {} seconds'.format(timer))\n",
    "    print('The average number of trapped QPs is {:.4}'.format(\n",
    "        np.mean(test.nTrapped)))\n",
    "    \"\"\"\n",
    "    save the qp trapping plot\n",
    "    \"\"\"\n",
    "    try:\n",
    "        makePlot(N, sampleRate, test, sim_type, sim_time)\n",
    "    except:\n",
    "        pass\n",
    "\n",
    "    now2 = perf_counter()\n",
    "    \"\"\"\n",
    "    calling NBResonator Object\n",
    "    \"\"\"\n",
    "    resArgs = {\n",
    "        'L': L,\n",
    "        'C': C,\n",
    "        'photonRO': photonRO,\n",
    "        'Qi': Qi,\n",
    "        'Qe': Qe,\n",
    "        'sampleRate': sampleRate,\n",
    "        'delKappa': delKappa\n",
    "    }\n",
    "    res = NBResonator(test, **resArgs)\n",
    "    \"\"\"\n",
    "    pickle the NBResonator object\n",
    "    \"\"\"\n",
    "    try:\n",
    "        dill.dump(res,\n",
    "                  file=open(\n",
    "                      \"nb_resonator_{}_{}.pickle\".format(sim_type, sim_time),\n",
    "                      \"wb\"))\n",
    "    except:\n",
    "        pass\n",
    "    duration2 = perf_counter() - now2\n",
    "    print('Resonator runtime: {}'.format(duration2))\n",
    "\n",
    "    avgTime = 4 * res.Qt * 50 / (photonRO * 2 * np.pi * res.f0)\n",
    "    nAvg = int(max(avgTime * sampleRate, 1))\n",
    "    window = windows.hann(nAvg)\n",
    "    rhann = convolve(res.signal.real, window, mode='same') / sum(window)\n",
    "    ihann = convolve(res.signal.imag, window, mode='same') / sum(window)\n",
    "    \"\"\"\n",
    "    save the plot\n",
    "    \"\"\"\n",
    "    plot_IQ(rhann,ihann,targetDir)\n"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.3"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "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
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}