Shuttling 9-ion rabi 20250116.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data fitting test for no shuttling 9-ion rabi oscillation with 300us delay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.12736713455857543\n",
      "nbar =  0.9999999999999968\n",
      "nalpha =  53.24758187485582\n"
     ]
    }
   ],
   "source": [
    "from qutip import *\n",
    "from scipy.optimize import curve_fit\n",
    "import math\n",
    "import cmath\n",
    "import timeit\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits import mplot3d\n",
    "from time import time \n",
    "from pynverse import inversefunc\n",
    "from mpl_toolkits.axisartist.axislines import SubplotZero\n",
    "import matplotlib\n",
    "import h5py as h5\n",
    "from scipy.special import laguerre\n",
    "from scipy.integrate import dblquad, quad\n",
    "import scipy\n",
    "\n",
    "# Update matplotlib settings for consistent appearance in plots\n",
    "matplotlib.rcParams.update(\n",
    "    {\"font.family\": \"STIXGeneral\",\n",
    "     \"xtick.labelsize\": 12,\n",
    "     \"xtick.direction\": \"in\",\n",
    "     \"xtick.major.pad\": 3,\n",
    "     \"xtick.top\": True,\n",
    "     \"ytick.labelsize\": 12,\n",
    "     \"ytick.direction\": \"in\",\n",
    "     \"ytick.right\": True,\n",
    "     \"axes.labelsize\": 12,\n",
    "     \"axes.labelpad\": 3,\n",
    "     \"axes.grid\": True\n",
    "    }\n",
    ")\n",
    "\n",
    "# File loading function\n",
    "def file_loading(data_path, date, index, number, x='rabi_t', y='pmt_counts_avg_thresholded', exp='RabiTimeScan'):\n",
    "    # Construct full file path\n",
    "    file_path = data_path + date + index + f\"/0000{number}-\" + exp + \".h5\"\n",
    "    # For debugging or direct file usage, you can hardcode file_path if needed.\n",
    "    # file_path = data_path  # If you directly used a fixed path\n",
    "    \n",
    "    with h5.File(file_path, \"r\") as file:\n",
    "        datasets_keys = list(file['datasets'].keys())\n",
    "        print(\"Datasets available:\", datasets_keys)\n",
    "        x_data = file['datasets'][x][:]\n",
    "        y_data = file['datasets'][y][:]\n",
    "        \n",
    "    return x_data, y_data, np.linspace(np.min(x_data), np.max(x_data), 300)\n",
    "\n",
    "\n",
    "###########################################\n",
    "# Load and preprocess the data\n",
    "###########################################\n",
    "\n",
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"19\"\n",
    "number = 30462\n",
    "\n",
    "# data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "# date = \"2024-10-27/\"\n",
    "# number = 30462\n",
    "# file_path = data_path + date + f\"19/0000{number}-RabiTimeScan.h5\"\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded)\n",
    "\n",
    "###########################################\n",
    "# Define the model and fit parameters\n",
    "###########################################\n",
    "\n",
    "n_ions = 9\n",
    "N = 300\n",
    "\n",
    "def pe_model_optimized(time, rabi_0_fit, nbar_fit, nalpha_fit):\n",
    "    ndisplace_fit = complex(0, np.sqrt(nalpha_fit))\n",
    "    intensity_distribution = np.array([0.96912696, 0.9844114, 0.99344862, 0.99840835, 1., 0.99840835, 0.99344862, 0.9844114, 0.96912696])\n",
    "    pe_fit = np.zeros_like(time)\n",
    "    diagonal_elements_all = np.zeros(N)\n",
    "    for k in range(len(intensity_distribution)):\n",
    "        if(k < 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += 2 * diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += 2 * diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "        elif(k == 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "    return pe_fit / 9, diagonal_elements_all / 9\n",
    "\n",
    "def pe_model_optimized_fitting(time, rabi_0_fit, nbar_fit, nalpha_fit):\n",
    "    ndisplace_fit = complex(0, np.sqrt(nalpha_fit))\n",
    "    intensity_distribution = np.array([0.96912696, 0.9844114, 0.99344862, 0.99840835, 1., 0.99840835, 0.99344862, 0.9844114, 0.96912696])\n",
    "    pe_fit = 0\n",
    "    diagonal_elements_all = np.zeros(N)\n",
    "    for k in range(len(intensity_distribution)):\n",
    "        if(k < 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += 2 * diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += 2 * diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "        elif(k == 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "    return pe_fit / 9\n",
    "\n",
    "# Wrapper for curve_fit\n",
    "def fit_model(time, rabi_0_fit, nbar_fit, nalpha_fit):\n",
    "    return pe_model_optimized_fitting(time, rabi_0_fit, nbar_fit, nalpha_fit)\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.1, 30, 0.0]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.05, 0, 0), (0.15, 1, 300))\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR0AAAEWCAYAAABbrUO4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABREUlEQVR4nO2deXgUVdbG3+pOZ0+AbEAIS1hEDSLrsAgi+wAqQ0AWcRQZ3EY+QByFQQSVoIjDpkYdZUbizMgiBlFENAiyOIgsMiCIbEFDEEII2Ukn3X2/P26qU3Wruru6u3pJuL/nyQO1dNW93V1vn3vuuecIhBACDofD8ROGQDeAw+HcWHDR4XA4foWLDofD8StcdDgcjl/hosPhcPwKFx0Oh+NXuOhwOBy/wkWHw+H4lZBAN8CX2Gw2XLx4ETExMRAEIdDN4XAaLIQQlJWVITk5GQaDc1umQYvOxYsX0bJly0A3g8O5YcjLy0NKSorTcxq06MTExACgb0RsbKzL84uKipCamorc3FzExcX5unlBAe8z77MelJaWomXLlvZnzhkNWnTEIVVsbKwm0ampqQFAxUrL+Q0B3mfeZz3R4sbgjmQOh+NXgkZ09u7di4EDB7o87/Tp05g6dSr+9re/4f7778dnn33mh9ZxOBy9CPjwqry8HJ999hlefPFF/Pzzz07PvXLlCgYNGoQPP/wQ/fv3R1FRETp27IgtW7agV69eXrclLCwMEyZMQFhYmNfXUsVqBfbsAX77DWjeHOjfHzAafXMvjfi8z0EI73NgCbilEx0djUmTJuG+++5zee6yZcsQGhqK/v37AwDi4uIwatQozJs3T5e2hIWFYdKkSb75YLKzgTZtgIEDgfvvp/+2aUP3BxCf9jlI4X0OLAEXHRGjhl/87OxsdO/eXbavR48e+Oabb3DlyhVfNc17srOBceOACxfk+/Pz6f4ACw+H40+CRnRcUVVVhTNnzihiAFJSUmCz2XD06NEAtcwFViswcyaglqBR3DdrFj2Pw7kBCLhPRyvXrl0DIQRRUVGy/dHR0QCAgoICh68tKiqyTxkC1NRUMzPFc6TneouwaxdCWAtHCiFAXh4sO3eCDBig23214os+Bzu8z95jNpthNpvt22VlZZpfW29EJzQ0FIAyDkDcFo+rkZqaKtueMGECJk2a5PD8nJwcT5tJsVrR+b33EFpcDFNlJZI0vOTIF18gv6LCu/t6gdd9rofwPnvO2rVrsX79eo9eW29EJy4uDiEhIahgHkxxOzk52eFrc3NzZZGSziydnJwcDB06FCaTyaN2Cps2wTh7NoT8fLde12XECNweIEvH2z7XN3ifve/z4MGDkZmZad8uKytT/Lg7ot6IjiAI6Ny5M/KZhzk/Px8hISHo2LGjw9fGxcW5FYVpMpk8+2Cys4GJE9X9N44QBCAlBSEDBwZ0+tzjPtdjeJ+9u47o2hC3tVJvHMkAMHr0aBw+fFi27+DBgxg0aFDg19A4cxg7QhwqrlwZ8HgdDsdfBI3oiE4pm81m37d9+3Z06NABx48fBwA89thjKCwsxL59+wAAJSUl2Lx5M/7yl7/4v8Ese/Yop8RdkZICbNwIpKf7pk0cThAS8OFVTU0NNmzYgLVr1wIAFixYgIkTJ6JTp04oLS3FlStX7H6bpk2b4uuvv8Yrr7yC3bt349ixY3jrrbcwdOjQQHaB8ttv2s6LigL+/negRYugiEjmcPxNwEXHZDJh8uTJmDx5suJYeno60hkroGvXrtiwYYO/mqed5s21nVdRAdx+O9Cpk2/bw+EEKUEzvKr39O9Ph0taMhTu3u379nA4QQoXHb0wGoFVq7Q5krnocG5guOjoSXo6sGyZcn+jRvLtvXv90x4OJwjhoqM3jRvLt5s1A778Ur4vPx+4etVvTeJwggkuOnrDxBGhVy8gLQ1gl2nUhgFwODcaXHT0hl3t3rMnEB0N3HSTfD8XHc4NChcdvTl1Sr6dlib/V+THH/3THg4nyOCioyelpcDly/J94pqw226T7z92zD9t4nCCDC46enL6tHzbYADatqX/Z4MBWYuIw7lB4KKjJ6zotG4NiCk02reXH7t8mUYnczg3GFx09IS1XqTOY7VcI+fO+bY9HE4QEvC1Vw2KM2fk2x061P0/MpKuz5IuDD13TunrCRCGlSup5RUbC8yeHejmcBowXHT05Px5+bboz5Fus6ITJBhWraJBiy1acNHh+BQ+vNKTX3+Vb7duLd9u106+ffasb9vD4QQh3NLRC4tFmcSrVSv5Nmv51AfRWb6chgLwYRdHJ7jo6MVvvylrV7GWDis6rGUUjCxfzoddHF3hwyu9YAUkPBxISJDva9lSvp2X59s2acVqBcQaRmYzL/zH8SlcdPTil1/k261aKRN6MdVJUVYGlJT4tl0uEDZtwrBHH4VQWEh3FBYGRY11TsOFD6/0grV0WH8OoBQdgPqB2Hw7/iI7G8aJE2FkE4+JNdY3bgxMuzgNGm7p6AU7VFITnfBwIDHR+ev8haRkjiLBqihCM2cCVVX0/3zYxdEJLjp6cfGifLtFC/XzgsWvU1syx2FGZ0KoFSYmG+PDLo5OcNHRC1Z0HJU5DhbR0VoyR4o47OLCw/ECLjp6oVV0WL+OuwX69EJryRwp4rBr1iw+1OJ4DBcdPbDZlJaDVksnUKJTWzLHjSLIFEKodbZnjy9axbkB4KKjB1euKH/5HYkOa2GwSb/8hdGoXrlCK54MzzgccNHRB3ZoZTAASUnq5zZrJt++dMk3bdJCo0aOHcmu8GR4xuGAi44+sL/6SUlAiIMQqKZN5dtXrtB1W4FgyxblPlcVSgWBDhH79/dNmzgNnoAHBxJCsGLFCly+fBkmkwmXLl3CihUrEBMTo3r+unXrsH//fsTHx+PEiRN44IEHMHLkSD+3mkGrExlQWjqEUOEJhOWgVvQvIgKorFQ/XxSklSvp8IzD8YCAi86SJUuwfft2fP311wCABQsWYPLkyfj0008V5+bk5GDZsmX4/vvvIQgCSktL0bFjR+zbtw9t2rTxc8slsKLjTEASEujwy2ar23fpkv9Fp6xMWS4HoOlVHYlOSgoVnPR0nzaN07AJ6PCqqKgIGRkZmDJlin3f1KlT8dlnn2GPyuzIli1b0KpVKwi1v7ixsbFo3bo1Dh486K8mq1NQIN9mrRkpRqPS3xMIv85338mEzz6LJeZ0ZklIAHJzueBwvCagorNt2zZUVlaie/fu9n1t2rRBfHw8NmzYoDg/ISEBOTk5yM/PBwBUVVXh7NmzuC3QKT+vXJFvO3IiiwSDM3n/fvm2yUT/NRqVKTkAKkZ8SMXRgYAOr47V1n5KYQLmUlJScOTIEcX5jz76KN555x0MHDgQWVlZeOedd7Bs2TJ0FGtLOaCoqAg1NTX27bCwMISp/KKL50jP1YLx8mWZelvj42Fzcg1j06by8/PznZ7vC4xHjsjaYOvRAxg8GIiNhbBvHwzMqnkCwOLnNjrDsHKlPbmYbdYst17r6edcn9G7z2azGWYxHQqAsrIyza8NqOgUFRUBAKKiomT7o6OjUcAOWQA0bdoU27dvx9ChQ9G3b1/Mnj0bDz74oMv7pDKVGCZMmIBJkyY5PD8nJ0dL8+0MPHcOsZLtH/Lzkb91q8Pzu9bUQLoc9Pz+/fjRyfm+YNB330Hqqj/arRt+7dEDANDh6FHcypxfVVWFr/zcRmcMe/VVRFy9iuvx8fiKLdmsEXc/54aAXn1eu3Yt1q9f79FrAyo6oaGhAGD30YgIgmA/xvLrr79i8ODBOH/+PJYvX46ysjK8++67Tu+Tm5srmw1zZunk5ORg6NChMInDDQ2ETJsm2+4ydChuHzLE4fmGb78Fduywb6eGh6OVP2fgrl9HCDPNf8t996FT374AACE0FPj3v2XHw8PCAj9LKCEkPBwAEB4e7na7PP2c6zN693nw4MHIzMy0b5eVlSl+3B0RUNFJqvV9VFRUyEShoqICySrTzv/9738xe/ZsHD58GCaTCU899RRef/11DBgwAJMnT3Z4n7i4OMTGxjo8zmIymbR/MFZr3UrsWkKSk+t8JGowK9ANBQUw+PPLf+yY3IksCDB27lzX5549FS8RLJagfEAFwON2ufU5NxD06rPJZEJ0dLRsWysBdSR36dIFAOyOYZH8/Hx0YsvwAnjzzTcxfPhwhIWFwWAwYOXKlejTpw82bdrkj+aqc/Vq3UJIkWB3JDN11CuaNgUkXyAkJCj7EERWDqd+E1DRGTJkCCIjI3H48GH7vry8PBQUFGDcuHGK881mM6ySNU6CIKB///4wGALYDRXfkyI3MkugRYepRFrGLkIFgLQ0+TZbPofD8ZCAik5ERARmzZqFrKws+741a9agX79+6N27N7KyspCWlmZ3Ko8fPx5btmxBlZjNDsD333+vKlB+gxWduDjnQytAKTqlpY4D8nwBU3O9Qi2C+lbGlXz8uA8bxLmRCHhE8qJFi7BgwQLMmDEDTZo0QW5uLjZv3gxBEFBcXIyCggL71NyECRNQVlaG+++/H506dcLVq1cxadIkjB8/PnAdYGN02HSkaqgFD16+rF7v3Bcwlk65muiwls6JEz5skJuoVa/gMUT1hoCLjsFgQEZGhuqxmTNnYubMmbJ906ZNwzRmtiigsJaOK38OQAvXhYfX5R8G6BDLH6JDiKLmeoXaEgxWdH7+mTqfAzmUBWjWwpkzafpUoC6N6qpVwREtzYsTuoSvMvcWT0RHEALn1/ntN6CiQrarXE102reXb5vNyjVm/iY7m6ZLZROfBVMa1eXLgRdfpP9yVOGi4y2eiA4QONFh/DkkPBxV8fHK85o3pyvOpQSyDLKkeoUCnka1XsFFx1vcXXclEijROXdOvt2unfqQSRCUM1aBFJ3a6hUO4WlU6w1cdLyFtXS0OJIBpTix4uUrzp+XbRJnKUGCSXS0pkflaVSDHi463uLp8IoVJy46ztGab4inUQ16uOh4Sz0XHdU0FiKs6DCzXn6ltnqFw3SqPI1qvYGLjjdUVwMlJfJ9WkWHjVoWp4B9DWvpuCM6gbR0jEY6LQ4ohSdY0qiqxQ9xFHDR8QY16ySYLZ2aGoUz1q3hVXExUJuOJCCkpwMbNypLNqek0P3p6XSq+oUX/D9lnZ1N44XY+KFgmMYPMrjoeAM7tDIagSZNtL2WFZ3CQmDhQt8+LBcuyHMzA86HV61bKy2HQFo7ABWW8+frLEU2jWog4mTqQ/xQEBHwiOR6DSs6YtJ1LbDDK5sNeOkl+ivuq0hWJhsgoqOdi6TJBLRqRR9qkbNnVVNf+BWjsS6Xc6DSqIqRx9HRdNjnKH5IEGj80OjRAR36GVauRMdDh2A4dQp45pmAtQPgouMdrB9G63Q54Holui9gf4lbtnRd56pdO6XocKjo5OfTz9GZP04aP3TXXX5rHoth1SrcnJ8PsndvwEWHD6+8gfVvqEX2OiIiAmDStPocJm+RwjeiBrscgouOHK3OYh4/ZIdbOt7AZAxEXJx7r09MVKyD8imeiE4wzWAB9D3/+GOgvDyw7RDROmTi8UN2uKXjDd5YOoB7wzE98ER02JXvv/6qX3vcZfNm6mN67LG6UIXiYqVz3J+EhvL4ITfhouMN3lo6/vbrsKLDlP5RpVUr+faFC/6NPxGnwJ96is4EscnOKiqAV17xX3tYBCH444eCDC463sBaOp4Mr/wJ60iWWjpVVcD168rXsKJjsfg3vao4BZ6ZSe+txgsvAD/+6L82sWiJH+LY4aLjDb4YXvkqktVqVYqF9CERs++x905MVJYaZqfe/YGzInEWC7BoUWAjgl3FD3HscNHxBl8Mr3wVyXr5svIhbNGiznqIiqL+iaoq+RDGYKA+CSmB9OsAwM03A08/Ld/30Ue0P/6ICHYkbsEQP6RGkC3P4KLjDd5aOo4eXl9EsrL+nJAQumSDLQcbFUWHWdJgNzZq2Z+iozakmjsXeO45QFIrDYRQYZXii/exvi13qG2vUNteIQjay0XHU6xWOnMixR1Lx2oFNmxQP+aLTHis6DRvTmd91H6NmzSRO0VZv44/RYf1MzVpAowfT//905+cv1bv97G+LXcI0vbqLjrLb5TcsMXFytB3d0Rnzx7l8EyK3pnw1KbLQ0LkRfZEDAbg2rW67UCKjjR5PQCMHVuXRnXKFNev1+t91JouVe14IAji9K4eic7OnTvRrVs3REREwGg0yv6eCXCItd9QW23tjuj4OxOe2nR5cbHjtWIGQ93QJlCiU1hI04dI+cMf6v5/++3KtjnC2/dRa7pUtr2BIojTu3oUkfzggw+iR48eeOKJJxAaGmrfbzab8Z///Ee3xgU1rJUiCMpE5s7wdyY89guoVutKSmRk3S+iI9HxdbmVnTuVbRo8WL5v0CBgzRrX1/L2fdQqWsGSQyeI07t6vAxi48aNMKr4A4YMGeJVg+oNrKXjauEkS//+dIjDWiDS66Wk0PMsFup7cfceUtR8OpGRjs83mejQRlxpLuXaNeqAFhc9+mpl/I4d8u3+/Wm9MCnTpzsXHen76A1aRStYZqyCOL2rR8OruXPnYvfu3arHLga6NpK/YEXH3SJ0RiPw+uvqx0RxWb6cDoEqK6nVUVrqPF7FGazoJCfTKXJnVFXRX261Wud5eZ61QyvZ2cDq1fJ9332ndH526+Y4slvPiGCt6VLnzKF5kQJRaE+awCyI07t6ZOn8+uuvePfdd9G9e3fZfkII9u7di9NMbSVfUV1djQMHDqCiogLDhg3zyz3tqA2v3C1vm55OrQjWR5KSAvztb/S4INR9caKjqQjFxLiul87Cik7jxq5fI1YhjYqiQYLS7Ia+9OtkZ1OHMUtJCZ11kUb5CgJw993q1k5KChUcPQL0xHSp48bRe0odtFJxC2QwIGt5amlvACwzjyydc+fOgRCC3Nxc2d+ZM2dwxc20m4QQLF++HHPmzMH8+fMxbdo0lLGxIwxlZWV4+umncffdd8NsNmMwO873B99+K9+uqfEs/oFdxR0VRROgDx4sFxyAWlNNmtBZJ3cWOZaWKldlq1kvLGFhdUMwdojlq6hkcdbFGeysy6BBynPi4/WPCPZmuUMg0qgG6/IM4gHbtm0jVqvV4TF3ePnll8mgQYPs288//zy55557HJ5fUFBAunbtSqZNm0ZqamqcXrukpIQAICUlJZraUl1dTT755BNSXV3t/MSPPyaE/nbI/wSB/n38sab7EUIIue8++TViYggpKSHEWd8sFkIKC7Xf4+eflW2tfU9c9vnaNfrvmDHy18+bR0iLFvT/LVpob4srdu5Uf2/Zv507616Tl6c8npjo8BaaP2dHWCyEJCTQ+yQk0G1X+OK90noPi4XYattr09peN3HnWfPI0hk+fDgMBgPOnDmDjz76CJs3b8al2nU9w4cP13ydoqIiZGRkYIok3mLq1Kn47LPPsEdlKo8QgokTJ4IQgszMTISEBCAdkLNfYk/iH9goZpuNDp+c9c1opEMfdsW1I9hI3eho9fgcR/eqrvbftLknsy4pKcBNN8mPi2H/viBYlzs4Isja65Ho1NTU4IEHHkDHjh0xYcIEjBkzBq1atcJTTz3l1nW2bduGyspKmW+oTZs2iI+PxwaVaN1NmzZhx44dmD9/vmyq3q/oHf/AOkGtVm0BZlFR2qfoWdFJTNTu+BZni9jhmK8cyZ7OurBDLF+KDscrPBKd+fPnY9++fXj99dexd+9enDx5El9++SXKysqwePFizdc5duwYACCFyeuSkpKCI0eOKM7PysqCwWDAf//7XwwcOBBNmjTBpEmTUMwuR/Alesc/qCVo1yoI1dXaMuixoqO1TA5Q57D2l+j07w80ber4uKNZF9avV13t+Uwfx6d4ND75/vvv8b///Q/REhP9pptuwsCBA/GXv/xF83WKaqedo5hcwdHR0ShgKy3U3rdVq1aYO3cuEhMTcfr0afTv3x9//vOf8eGHHzq9T43kCxgWFoYwNl0DYD+nxsmXVUhM1PSmWRITQTR86YXGjWXXIzYbLFofFoOBJrEKDXUaw2O4eBFSg9rWrBmsTF+d9RnFxRCaNZO388IFICYGAgBiNsNSVaWb2W64/34YV6xQ7Ce1fbT+7W8gNpvcmd63L2TzeYSg5ocfgK5dFdfR1GcXhAC074Cmz8vd8/Vuk5EQeowQXe5vNpthlliTriZ/2Ha6Tb9+/WSCI8XmxqyKOEQSmAdGEATV4dPVq1cxffp0JNbmoenQoQMeeeQRLF68GJmZmWjioJxKKpNyc8KECZg0aZLDduXk5DhutNWKYfHxCL96FWqPOQFwPSEBOaWlwNatjq9TS2JuLvoy19+q4XXucPvBg2gj2f7FbMZR5h5O+wwgvLAQUm+dUF1tDxsQCgthSUnBsWnT8FufPl639+YLF9BRZf/1+Hj8+Kc/4bewMNX3dnByMqIlcWI//eMfyB050uF9XPXZGcOqqhABoKqqCl9p+LzcPV/vNg0zmxEBKhZ63H/t2rVYv369R6/1SHSuXLkCi8WicOSuXbsWBw4c0HydpFozv6KiAjGSNAUVFRVIVgnTb9y4sSIKunPnziCE4OzZs+jRo4fqfXJzc2XXd2bp5OTkYOjQoTA5iYMR3ngDwv33K/aLv8ShmZkYec89Dl8vo1kzmhnPfhGCkSNGuBd9XF7u1DFs/Mc/ZNutunVDSu3DqKnPtVYFeewxCA4c5OFFRei5dCms69aBjBmjve0s5eUwvvOOYjdJSIDp3Dl0BdCVjUquxThoEPDvf9u3O5WV4RYV0dH6OTsjpLYN4eHhGOlE2DSfLwZ/RkTIgzarq+kQt6KC+vEcfS+sVoTUHgsXBIwcPlxmeRprv+9hYWGa2uuKwYMHIzMz075dVlam+HF3hEei84c//AG33HILRowYgaioKOTl5WHfvn24cOGCW7/SXbp0AQDk5+fj5ptvtu/Pz8/HwIEDFee3b99eMexq1KgRAMhEhSUuLg6xsbGa22UymZx/GYcOVd0t1AajhbgT/8D4LwQApqoqup5JKyYTdUA7eBjZksXGFi1gZPrnss+lpTSK2YEvR6gtLBfyl7/QwD53h1pi9HVEBHDihPL6YWEwiZ9xSQmNH2Lbe8cdMtEx7N8Pg5M+ueyzBoTa6yi4eBE4dYr+GNx2m+PzCaHLSho1Uo+sFs+1WunSkyZNlD6/7Gw6oyrJmWPq0IEGB9Z+F8UfREEQvO4zavsgHe24c02PROf3v/89MjMzsWjRIhw6dAhGoxG9e/dGVlYW+vXrp/k6Q4YMQWRkJA4fPmwXnby8PBQUFGDcuHGK89PT0/EO8yt48eJFxMfHa1ZZXVBLSSEGo7n7sDnKHuiO6ERGOp8+Zx3JzZppv7aIxeK6Td4UlhOjaZs3d+2Ej4mhDyr7APbuLT/v3DlahdUdx7lWZs+uW+wq5eRJmkR+27a6fY0b160+FzP3id+T4mIqTK6+N6IFJAjyyQYxZw474ynmzAnGHM16Bwm5CthjmTdvHhk2bJh9+6WXXiL9+vUjNpuNrFmzhtx6663k8uXLhBBCCgsLSWJiIvnqq6/s5//+978nr732muq1fRYc+N//KoPRPA36stkICQuTX2v/fvevY7GoB33ZbIRERsqvv3ev/bDmPldUENKrl7bAvQ8/dL/tzZvXBdupXVMl4I3YbPRPpKaGkKgo+es++URxO6+DAx3x5ZeEREe7fn9SUmgAaXW1vP1aEANDrVb6/5QUx/cRBEJatiTEYiGWpUvJTxMmEMvSpfr2uRafBwc6w93UFosWLULPnj0xY8YMLFy4EKdPn8bmzZshCAKKi4tRUFBg95LHx8dj+/btWLlyJZ599lk8/vjj6N+/P55m8+X6GrVcOp4iCMo8PM7K1DrCalUv3FderrSCnE1JOyIyUnvuGndXLldX1/1yszMrjsx2o5FaDdKQgZAQ4He/k5+3b597bfGUQ4eAMWO0hTBcuFBnhbibOcBopNZVeblbMWO2WbPw86RJsM2a5d79fICm4dWYMWPQtWtXLFiwADabDX/4wx9QrvLmVldX4+jRo3jooYc0N8BgMCAjI0P12MyZMzGTif7t3LkzPv/8c83X9wnOMv55QlKSfEjhyfVDQ5X5jgHl0ArwTHQIAbp0oQnQHeFJGgmzWe44VRMdR1O84eE0nWlNTZ049ekjz8PjD9EpLwfuu097hDhA3885c2jqVXeH5CYT/dO6/i3IShprEh1CCKy1sxYGgwHx8fGoqKhAK+aXr6amBnm+TnkQDOhp6VRUUN+EFE8sHUB95TgrOpGR2pdASBEFxdlxwL2Vy4TQB1Zq6Wm1dEQaNZJbC+yU/YEDclHyBfPnU3+elAEDgF27nL/OG/9XaalzK0dKkJU01iQ6n3zyiWx72rRpuOmmm+zxMlK2bNmiS8OCGj0tHbNZ6ej0VHQMBjqzUzujB0ApOk2bep4MjF3fJMWTNBJms3IamK3+4Gp9ncFQl/cnKkrpTL5+HTh2jObd8QU//0wLAUrp25cmjXclOgC1QtzNwCg63ZOT6d9vv6kvnZFanoEsvczg0ezVtWvXVAXn8OHDqvEvDQ49LZ2wMOUMlqeiI+b0kc5uqImOpzjy6YiF5dwZJhBCBYUVFfbh+fOfaV+czZyFh9MfgogI2pb27Wl6EJF9+3wnOs8/LxfKsDAgK0u7FdK0KfDMM55lYBQEmghOS86cIBIdjxzJjrIGtmvXDv/3f//nVYPqBXqJjsVCHxi9RAegwyfpF0xP0WnaVH2Y4snK5fJyx2WCRaKiaODkCy+4fhil1h07xPKVX+fkSeoMlvLUU1T0XGXuEzl71rs2pKfT2CQ2mDbQOXOcoFl0zGYzpk2bhrZt2+K9995D27ZtZX+pqalo3rw5LK6+SA0Bdng1dKhn6SkrKuivk56iEx4uT6uhp+gYja4TumuBEDpjJQYzSitQSrnpJvrQVlXRP2e/1iEh1JFrsfhPdJYtk1sXsbHUOQzUZRoEnAvP3LneJ3O//37gyJF6U9JY8/AqLCwMq1evxty5c7Fnzx5FelBBEBAXF4cx3oTA1xdYS2fiRGDqVPevY7HQh4UVHW99RpWV1CIxGPQVHYBW+/Q2a6A0TICJppWRmkofapuN/ms20/fLYFC3rMLD6QweKzquggQ9qWpRUgKwi4ynT5c788XMfTNnOh5uFRVRi85bEhKCKmeOM9z26SxZsgTHjx9HWlqa4lhxcbHqVHqDgxUFd8sJi4izVuzrvbF0gLrcxpGR+ouOt5aOGPYfF+c4mlbEYKACJa1aYbHQKN7ISGU+oZAQ+sB16kQfZGnc0nffAffeq34fT6pa/Pvf8ilyoxF48knleenp9L7Nm9PPNSGBzmx9/HHdOWrxVZ4QLIX+XOCRTyctLQ1msxkXLlzAr7/+av87ceIExqol1G5osJaOO0X2RKqq6qaH1YZX3nyBwsPrHkhfWDreUFVFhcFZBUqRnTuVQ4+QECrSjpyjkZF06Nazp3z/d995124phABvvy3fN3q0uiCbzVScpFbIsmXq6+S8FQ0nwzhh+3Yk793r3fV1wiPR2bRpExITE9G6dWukpqba//r37+92YvZ6R00NNcWleGLpVFXVzdyoZQ8sKfGsfQD98pWV0YdSb9HRGpXsCIOBCoOraFqAWpSOMjCGhtIHWq28s8WiFB1P/DqOkql/+y1w/Lh83+OPq19DLQNA69Z0xoqFLaGsBxYL8NxzMI4aha5vvKG6mNbfeDRlvnr1amRlZSEyMhI7d+7EiBEjYLVasWnTJjzu6M1vKEhrfIt4YukYjXXjbkeLPrWUiXFEaCh9aNnhrreio6WKhCNqauoqXOiRgTEigl7r+nX5ECw6WjlFfuBAnQ9NK46GXf/6l/y8du2UmQtFGjVSzwQ5Zw7wz3/KSwOVlFAhdRZ2InW6s4tHRURHfUUFXfG/cycEACFmM8jkycD33zsvtOhjPLJ07r33XowZMwbDhw9HfHw87rzzTgwaNAhLly7FHNF731DxtoY5QC0Q6Yeu5p/w1q8TFqZIaQHAN6KjdVhQUVH3gOhVgTI8nL5/omUH0IecTY1SUQH8+KO2ezqjpkY5Tf6nPymFhRBqhTkSuago4NVX5fusVhpX44jsbFrmSPxuFBaqlz0SBNrXvn0VpZmF48ep2AUQjyydH3/8EevWrUPfvn0xbNgwPPLII3j66afx3XffYSdbf7qhwYpOdLTrSpksZjP9UkqFJyFBnqvG2xksQVC2NSzMvZQZaqiJzsMPa2+TKDpiHEt+vmPRcqcCZXi4PN1FUhJ9IM+frzvnu+/o+jF3IaTuvdy3T/m+jhhBLcrw8LryzxUVzi0Wsc2hoXVpLwDgr3+lifOnTpXPqrVp4zqFhYjFQp3XTIFFm9EI8sorMKo5vP2IR6Izfvx4jBkzBrNmzcL8+fPRtGlTpKWlQRAE9A9AmVK/woqBJ0Or6mrlOD8+Xi463lo6AE0kJcWbJRAicXHUKrt+vW6flrJDVqs8gM9ZxUwRd9ZxmUx167DEIUevXnLR2bfPse9FpDYZGYqK6tokneJnq5T06gV07lw3KVBVRd+b69epY/n6deV7brMBmzbRRaJsvwmhllNsLK3y+ttv9DqO3iOxvTNm1Dndr1xRONlJs2bYO3s2+syaBaO33wEv8Wh41b9/fxQWFmL+/PkAgMWLF+Pbb7/FRx99pHt+36BDj5mryEjlw6RngKAI21ZPknexiNUYpGhZ5Kvm8HVUgRKgD567wW0hIfQeJSV0xuiOO+THXc1gidP5hNDPlX04q6qoWEiZOJFaVmFh9P4REfT/olAYDPKyQqLV5Grmbvr0uvtXVyvLQrPtzs+nQ8qYGOWsXqdOsOzahWvO1s75EY9E54MPPlDs69OnD1JTU7GJ/VAaGt7G6IhOPhZfiA5bUcNbf46Iu6Ij5vlV+4W9917gf/9THhs/3rO2GQxUMGw2ZZDgqVPyz89mo8MXcdaoulq5al3KF1/I04cIArVWpFit9DriNcLC5ItaRX+LMxEB6Kyj6DDWGrHMtg+gDvVdu2igZZDgkej86MAhFxERgXnz5nnVoKDHW0unulr9F84XoqP3dLmIu6ITEuI4nUZ5ed1yECkd1epBuEF0NB32sA76J56AYckSAICwbh1w6611QuTIMSuybp18+847lVaa2UytDZbZs4GFC+m/WmfuxJlHrUNMtv5b9+7A9u30/0G04FOzT8dsNuOJJ55AVlYWAGDZsmWq53VVqTPUoGBFx11Lx2pVdzw3VNGx2aioOEqcHxZG1w1JiYjwbmpeJDQU6NFDHuvz0UcwfPstmv/xjzAuXarNMQvQPrBpWyZOlG9bLI6XIEin3L/5Rlv7RUsnNNS1052le3cgJ4c61qurvYv70hm31l7985//xO9+9zt89tlnGM+Yv+Laq0FsedeGhreOZDG2hIUVLz1y9gSD6Fy/7njauKKC+rd+/lm+/6abtFc5dUXfvqoBhretXu3cMTtzZt2wy2wGNm9WLntgo+9LS7XFVmmZuZNiNgPvvuvc6S6lZ0/gq6/q2hIaqs/6Lp1we/bq8ccfx7333qtalwpAw19l7u3wqqhI3TpqqJYOIeoh/6LvIypKKTreDq2k3HWXMh7GbEaEM1EnRB4tXVhIHdtShgyhU9si1dX04dYillpm7qRcvQocPQp88AGdUncWyd2rF61EwYqfLzMnuolHPyeOBAdwPzF7vcMbR7LV6vhXvz6LTmGhfApdxGJxbNmZzXV+npMn5cf0FJ1+/ZTDHbU0Gq5glyhMmFD3f0LoPdxJA+to5i4lBWAyOACgeYUeflj9fRa5807gyy+9i2T3AwFPzF7v8NbSYR2bImrpLaQZAN2lqkq5RkxtuYUnqPlbLlwAOnSQ73NUedRqlfs+fGnpREfT4YZ0utzb/DUmE638IFJeXjdd7g7p6XShaLNmdSvQz5+nIvbww7LCgQCoiDuy0KZOpYtQ3Q1UDQCavtFqidkFQUDr1q1lf23atHFYT7zB4I0j2VmCcFYQbDblbIQ7qFWB0CMBF0AD19jIZnaIJebBUbPsysvrZlPMZnkAHwBIqr3qApv43GLB9fh4e9VLt+nZs86asFrp5+qu4IgYjco8OJ9+qli+4JCEBJoedfXqeiE4AE/M7h7V1co4CHcsncpKx6V/1cSrsNCz4ENAKTqhofrmW2nZUr7SmhUdQVBWuQDsddHt4nvmjHI6V+8gtoEDgdppcgBATQ2OP/gguq9cqc2nwiJdTGowqPfTU1zlGJISHU2tRE+/IwHCI9v9jjvuUAjOpUuXAAB33323960KVrxZYe7qSxQRoVz5680MFis6SUl10bF6wA6x2GyCRUXqvhxBkPscWH9ObKzj6XVP6dtXZnEJAGpiYmBdt049GtoVI0fSfysr6Z9eywoIcR2pnJhY58Bu1KjeCQ7goeh8+eWXiI2NxceS7Gd5eXl44YUXYAuiICTdURMBrR+6o19+KXo6k9WcyGzSdm9gRUc6RKquVh9WWSzUzyR9SFl/Tvfu+rRPiujXkdD0++9B7r2Xtlt83+PjXSdTj4ykjl6rlfrN9JyKrq52nWPoypV6kyHQER6JzuLFizFt2jTcJRkr9+zZE02bNm3YEcmsPycmRvtUZGWl40qVIr4WndBQ31k6Fy7IHwa1h7G0VOlY9qUTWSQ7W5F0q81XX9GIZKlPJTzcdTL1p56iFqPBoP8skdbPRq/PMEB4JDqDBg3C8uXLEc/4IVq0aIE1a9bo0a7gxJuZK0e//lJ8KTriYs/qatfipwVWdGqH13afjVpUbkyMcj8rOno7kUUfCTOTZ7DZYHz4YWDtWvn5zhahxsbSTILFxfQ91CuAUUTrcocgTrquBY9SW1Q4SCS9bt06t4MDCSFYsWIFLl++DJPJhEuXLmHFihWI0TCunzdvHkJDQ/HCCy+4dU+P8SZGR6xi4Aw9RUcUARExRkdMS+FtsJhagGBxcd2KayniwkrWMiDEt5aOljzMzzyjHHKmpwN3303fK+mxKVPqaq/7YqbI1XIHsWLnjWjpDB8+HOPHj8c333yDU6dOIScnB2PHjsW6desw1c1SLEuWLMHnn3+OV199FRkZGUhOTsbkyZNdvu5///ufw/VfPsNTS8dRVC6Lr4dXABUbPRy1rOgUF9OHorBQ3lcxg55avE5BgTIsQE/RcZGHWQDoA6626v/LL5ViNG4c9en4akmBIDge3kkrdj79dN3i0XqIR5bOkCFDYDabMWPGDPuK84SEBLz88st49tlnNV+nqKgIGRkZeOedd+z7pk6ditTUVOzZs8dhQjCr1Yo33ngDPdnk277G0xgdi4U6HV097Hquv3IWjVxZSU10LULoiJQU5b78fCoaVivtMyH01zs2llp6bH0p1soJC/M+8bsUrau5RXGx2eoSgL3+uvyczp2pk9sXCbBmz657XxzVyvKkVnyQ4pHoAMCoUaMwatQolJaWoqamxu7fsVgsMGgc627btg2VlZXoLpmxaNOmDeLj47FhwwaHovPGG2/giSeewNNPP+1p8z3D08WezoICpfjD0gHosKG42DvRiYyk7ZW28ccfgVtuoWIjJmEH6nxZbKJzVnQ6dNDXX6E1D7N4T4OBPvwXL9alhBCZOdN3ycxZi0UtUtndWvFBjEeiU1BQgKTaaomxTGTqSy+9hJdeeknTdY4dOwYASGF+NVNSUnCETXdQy7lz51BUVCQTKlcUFRWhRuI8DQsLQ5hK/lrxnBoHjlZjYaFsPGpt1Ag2LU5ZsWici3OFxo1lHwi5cgUWT5y+ZjNMzLClJi5Ofv/QUKCmxmWfnWFMTYVBIjrW3FzYRH+D+P5arXYfRAjokIYAsNTUwHDiBKSPka1DB1j1cHKL9O6NkBYtgIsXITjw6xCDATCZ6toVHQ3jihWyz5kYDLDcd58+Dng3CAkLo+0KC4NFdNB7iDefsxpmsxlmyRq2MjZo1gkeic7LL7+MlUzW+qKiIjz99NP44IMPNItOUe1wJYoZI0dHR6OAzXpXyyuvvIJV4rhXI6lM1rQJEyZg0qRJDs/PyclR3d/31ClIQyJPFBTgnI7pWRPOnoU0wWb1b79hmwfXD79yBWzW4pyjR1HDLjeQHnfQZ2d0Dw+H9Ocid98+HHfS3mFVVYgAUFVVha+2bkXv3bshXYJ6OiQEJ3VOd9v8gQfQ89VXQVDrw2EQbDZUl5YitLZd365ejUHvvy87xxIWhq07dujaLi2w75ceePI5q7F27VqsX7/eo9d6JDq7du3C1KlT8eqrryIxMRHvvfce5s2bB4PBgL59+2q+TmjtDIDAjJMFQbAfk/L+++9j/PjxiHTTzM3NzZXNhjmzdHJycjB06FCYVIZDIQsXyrZv6dsXN4vRqY4QHalaQuVTUoAFC+yboeXlGDl8uNtmtXDokLwJISEYOn68cvasqAg10dHI2b7dYZ+dYfjuO1mumraEoLWT9yOkdjgXHh6OkSNHIuSpp2TH2919N9q6ej/dZeRIWLt1g3H2bIcpQk0hIbA+8wxCExIwKDsbBsaiCGnUCCP1bpcG2PfLG1x9t91l8ODByMzMtG+XlZUpftwd4ZHo5OTkoLS0FPfddx8qKipw5MgRPProo1i8eDGIG9GS4hCtoqJCJgoVFRWK9BmXL1/G0aNH8bDWcicS4uLiFMNAZ5hMJvUPhlkGEZKU5NpXY7VSH4qWD5pJnC4QAlNFhfvZCRnfk5CUBJNaOZTYWLvJ7rDPzmBWlRtyc2HQcA0BgMliUSz0DOnUyTd5X8aPpwm3an0kJDYWgiRuRygpgfH4ceprYn05AASjUZcH1VMEQLf7e/Q5O7hOtGRG0p1rejRlvmrVKmRkZGDPnj2Ii4vDyJEjMW3aNDRu3NitVeZdamsQ5TO/QPn5+ejUqZNs37Zt2/DOO+8gOjra/rdnzx68/PLL9v/7HE/idAwG7VPUjhZ9uovWPDoREd4FuLVtK98+d057iP6pU/rnRXaGNPI4OhpXOneWH9+6FXjvPfk+vYP/OAA8tHQWL16Mli1bYsOGDRg7diyqq6uxePFirFmzBrfeeisee+wxTdcZMmQIIiMjcfjwYdxcG4mal5eHgoICjBs3TnZueno67mBKikyePBm9evXCjBkz0MKThXvuUFVF02tK0SI6paU0rkNLOdvwcBrPIs1VVFjo/sPoTvIutRgVrbCiU1lJY2+0JAtjF3q2auW/lJqCgCNPPokhs2dDcBDoCkEApk2jM2DeFijkyPBIdEaNGoV169bZHcChoaF48cUXcfToUUyYMEGz6ERERGDWrFnIysrC/fffDwBYs2YN+vXrh969eyMrKwtLly7Fzp07kZSUpIhSjoiIQFxcHNq3b+9JN9xDLWZGi+g4yxaoRkKCUnTc5Ysv5NvORMDTPDAAHa6wFSrPnlW/H1uD+8QJ+XG9lz+4oLJpU1jXrUPIuHHqmQT//nfgkUf82qYbBY+HV+yM0wsvvIBNmzbh3XffdetaixYtQs+ePTFjxgwsXLgQp0+fxubNmyEIAoqLi1FQUCCbmgsYrOhoWTUOuP9Q6xGrc/CgfNtZkT3Rie/JymWzmZZskXLunPI8tRrcr70mP+eWW9y/v5eQ4cOpI3zQoLqhVK9ewNdfc8HxIZp+go1GI/r164fJkyfj0UcfRUJCAkoljrjY2Fi88MILWLJkCe666y57lkEtGAwGZGRkqB6bOXMmZs6c6fC132gt5aEHrOg0bux6VsldKwfQR3TY91/LcKekhFpuWv0YNTV0KNi2LfXPiLCi4ygpFZvr18+Wjp2ePanIVFXRNnpj+emNNFK5AaHpiWjVqhV27dpl3166dCleeeUVjB49GnfffTcefPBBhISEYO7cuXifiXFoMHjiRBaHHe7MFuixFIINItNSTjgyUnsJFXEBZ1wc0K6d/JhUdLQsuBQJgKUjw5vobF9RT9dWuUKT6KSlpcm2MzIysHHjRnz88ceKGBt21qnB4Ino1NS4HzrvC0tHy3IAd1ZOl5fTX19BUDqTz56t+7+LBZcyAmXpcPyOJltaLRgvNTVVITiAMrq4weCJ6ERH+394JQ4TpGixdABqkZWUOJ/RqqqigiNab2rT5iJaF1xGRtJ0qpwbAo8XfKoJDoDgcPr6Ak9Ep6yM5rF1B29FR60KhFbRAaigXLumzIpos1FBYoMMWdG5eJFOnUdGal9w2b69b1Zvs9T6SGwN9YexnqBJdE6cOIF//etfsmjj/Px8xT6z2Yzdu3fr38pgwF3R8TTREis6V66493o2eVdYmHvCJ52VKymhVlNISF0MEeufUgtXOHUK6NJFe/ncfv20t88ban0ktpoaGgzICQiaRWfKlCmyfYQQ1X2OLKB6j7uiY7MprQIteOtIvnhRvt2smftWhHh+o0ZUPMVV8mpERgKtW8urQZw8SUVHa/nc2sh0zo2BJtG59dZb8cQTT8jWWqhRUVGB1atX69KwoIN9+F1VyzQY3PfnAPL62AAd6mjNx5Odray5/dtvdL+nyZ+0LDa9+Wa56Pz0U93/HSWlknL77Z61jVMv0fRUPP/885ggrd3shKZ61csONty1dEpKPCvCpvb+FRS4rs/kKB6mupru37jRd1nnbr6ZpvcUYZc4sEmppAgCwMyOcho2mmavtAoOAIwdO9bjxgQ1njiSPRlqxscrrQvWT8OiJR5m1izfJfRmY2xY0QHkCy6ldOjgvzVXnKCAL6PVgs2mrO7pSnRcDEUdYjAop4/VZqSkuIqHIYRWa/DVSnw2xubECZoXaPly16/lQ6sbDi46WiguVkb5OhMdb1NCslPcrkRHazyM1vPchQ0ItViARYu46HBU4aKjBXdXmJvN3pV+Zf06rsRCazyM1vPcJT5eW01wtfeEzWvDafB4HBx4Q8GKTkSE84WBFot3lQNY0fniC+oQFku3sIjxMI6GWGKRNgfVNXTh9tsdpgO1o+ZT4pbODQe3dLTgrhO5cWPvss6xw6tDh4AXX3Q8XBHjYZyxcqVvS5hoEQ92eUViorJoH6fBw0VHC+w0rzPRIUTpdHYX1tLRMuuUnk6FhaVFC99Ol4uoiY7a9L2UPn38s/yBE1Tw4ZUW3LF0amo8CwqUwoqO1npH7CySINCgPX8UaevRQ7mPFUtWdHr39l17OEELt3S04I7oCIL3uVnY4ZXW+BrWp2I0+q8qZNu2yqn+ioq6tpeVKfvRp49/2sYJKrilowV3REes3+0NrKWjdSaMrbXuz2oGgkBTkkqLJJaX032rVtFlHFKLzWSiWfs4NxxcdLTgjuiUl2uvce4IT5eSsIs9/Vn7Ojsb+P575f78fLoMY8QI+f477uCRyDcofHilBa2i401sjpS4OHW/kNnseKglRh1L8ZfoiMsw1CCE/n31lXz/kCG+bxcnKOGiowU2p42jLHeC4H7SLjXUlkIAdBatTRtqVbBYLMogQn+Jjpa0pBaLfHvoUN+1hxPUcNHRgtRPATgWnaoq/RZVOnJGi8MVVnhMpsCJjrvLK1q1Up/t4twQcNFxhdWqjNNxJDpmsz7OW6tV6Z8REYdw7KrxkhKlteEv0XF3ecXEibxk7w0M/+RdUVSkjJNxNrzyNkYHoMOVqirHx9VWjV++rIyDefxx79uiBXEZhtZAvwce8G17OEENFx1XsEMrwHHWQE/TWbB4smqctcYMBppewh9Il2G4Ep4xY4DbbvN9mzhBCxcdV7CiExennjrUaqUBcHrg7qpxm03ZzubN9bG6tCKmJXW22jw8HHj5Zf+1iROUBFx0CCFYvnw55syZg/nz52PatGkoc/LwZmVl4ZZbbkFMTAzuuOMOfK8WG6InWp3IWvMYa6F/f+exPoJAF0qKq8bNZnmOYoAOd/xNejpw/nydJSi1emJigM2beVE9TuBFZ8mSJfj888/x6quvIiMjA8nJyZg8ebLquZs2bcKWLVuwaNEiLFy4ED/99BOGDx+OS67SeXqDVtFxlI7TE4xGxyVlxQdZumrcbFamNA2E6ADy96FZM2DLFuCDD2hZmmHDAtMmTlAR0IjkoqIiZGRk4J133rHvmzp1KlJTU7Fnzx70Z/K/7NixA+vXr4ehduajffv2GDNmDLZs2YJp06b5ppFaRcdicZ5jx13uvx+YP1+5PyWFCo501XhMjHK2K1CiI8VgAEaNCnQrOEFGQC2dbdu2obKyEt27d7fva9OmDeLj47FhwwbZuTU1NXjggQfsggMAQ2qjWktLS33XSDZVqCMncmWlvvdNTlbui42ltcKlgmO10pkudro8GESHw1EhoKJz7NgxAEAK84CkpKTgyJEjsn0mkwm9evWS7auqnVZm9+tGdjbwr3/J9/3nP8rAPKtVf6dtWJiyBlZIiDKyV4wN4qLDqScEfHgFAFHMwr/o6GgUqE1VM+zZswc9evTAHXfc4fI+NZJk6WFhYQhT8b+I59TU1EDYtAnGiRMBQiCdBCZlZcC4cbCuWwcyZkzdgYgI7xOyM4S0aAFBsgSD2GywCIL8PtXVQEQEQi5ckLXT0qwZiIb2SPusFyEABAAEgEXn90QPfNHnYEfvPpvNZpjNZvu2s8kfloCKTmhtCgi2FLEgCPZjzsjMzMTf//53l+elpqbKtidMmIBJkyY5PD9n2zYM+/OfYWQEB6h9mAhB9ZNPIickxKdRv71CQiDNrGMxm7FVWtSuFlN5OUYyw7sdp07hekmJ5nvl5OR42kwFw6qqEAFqiX4VxDXD9exzfUGvPq9duxbr16/36LUBFZ2kWqdsRUUFYmJi7PsrKiqQrObTkPDmm2/ij3/8I7p16+byPrm5ubLrO7N0cnJyMDwyEuFOaogLACILCzEqNhZkwACantSTap4uMGzdChw8aN8OEQSMHDyYDrGioujSh4gI4OefFa8dOHmyprw+Yp+HDh0Kk05T/oY5c2AtLUVobCxGjhypyzX1xBd9Dnb07vPgwYORmZlp3y4rK1P8uDsioKLTpUsXAEB+fj5ulsRv5OfnY+DAgQ5f980336C8vBzTp0/XdJ+4uDjExsZqblcIu6rc2XkmE6384IsvL5O0XLBaYYqOpkGIhNB7RkUpnd1Nm8LkZq4ak8mk3wP4zDP2//oxo4/b6NrneoJefTaZTIiWROC7c82AOpKHDBmCyMhIHD582L4vLy8PBQUFGDdunOprjh8/jq1bt2Lu3Ln2fZWVlTh//rx+DXMnIthm03eqXErr1vJtcYFnTAy1YsQ0GmzfeYUFThATUNGJiIjArFmzkJWVZd+3Zs0a9OvXD71790ZWVhbS0tLsTuWLFy/ikUceQffu3bFx40Zs3LgR//73v/HHP/4RiexMjxeQfv2cz/5II4LNZuVCS71o00a+bTCoJwrLzZVvt23rm/ZwODoQ8HSlixYtwoIFCzBjxgw0adIEubm52Lx5MwRBQHFxMQoKCmA2m1FVVYVRo0bhyJEj2Ldvn+waU6ZMUcyAeYW4gHHsWOUxNiK4utp3aTdZ0amupgnF2ADFc+fk21x0OEFMwEXHYDAgIyND9djMmTMxU5IG84cffvBXs2gA3vTpwJtvyvezEcFRUb5bWJmcrIzNOX/etehodOhxOIEg4GuvgppWreTbJhMdyoiCQ4jzvDfeYjQq28D6bwihUcpSuKXDCWK46DiDDVBk43IsFu2F8DyFHWKx/ptr1wB2GQgXHU4Qw0XHGezKbTbFptXqfY0rV7gSHXZoZTTy2StOUBNwn05Q46qOVGio73P9slbL6dPybTYwsHVr38QMcTg6wS0dZ6iV6ZVy7Zrv29Cxo3ybFZmffpJv8yRZnCCHi44znFk6Npt/qi2wopOfL0+LyorOLbf4vk0cjhdw0XFEWZky5/Ejj8i3IyN9344OHZTJzk+dqvv/yZPyY1x0OEEOFx1HqFVkeO65uv9XV/vHdxIernQmi0Msi0Xp4+GiwwlyuOg4gvXnNGokjzyurNRe58lb2CGWOKQ6c0aZw4f7dDhBDhcdR7D+HGmqDbX1T74kLU2+LUZmL1ok39+8ufMqEhxOEMBFxxGs6EjrOQmCfx9uSQ5pADTHDiG0pIuUnj391yYOx0O46DgiL0++LbV0ysp0T03qlB495NuXLwO//kpXuEvhosOpB3DRcQRbvE6a20bPwnpaaNeuLneOSLdu6knaOZwgh4uOI9iFlVLR0auonlYMBuUQqzapvYyMDGWlCg4nyOCi4whHlo7FQqex/c1dd7k+RxCAWbPqMgxyOEEIFx01SkronxQxVqay0v+zVwBw772uzyGE+qL27PF9ezgcD+GiowZr5QB1K7dranyXtMsZnTsD8fHazlULbORwggQuOioIv/4q39G8eZ0fxwelZjQhCIDWci5aE8tzOAGAi44KgiN/zvXryhkjf/LGG84XmUoTxnM4QQoXHTXY9Uzt2tF/r18PbK6aRo2Al19WP8YmjOdwghQuOioI0lXcQN3ap9BQ/623csSzzwIbNyqHUCkpdL+Yv5nDCVJ45kAVFKJz0010WOWPVBZaGDsW+MMfgGbNgMJCICGBpjHlFg6nHsAtHQaj2ax0JHfsqMytE2iMxjrndlgYFxxOvYGLDkMUu9ATANq3pzEwvs6HzOHcAPDhFUPMhQvyHS1bAtHRvi814wmzZ9PyM7GxgW4Jh6MZLjoMjdmZq06dgOJioHHjQDTHObNnB7oFHI7b8PECQ+MzZ+Q7uncP/IwVh9OACLilQwjBihUrcPnyZZhMJly6dAkrVqxATEyM6vkHDx7EW2+9hVtuuQUHDhzAU089hT59+ujTGIsFjdkSvd27y9OUcjgcrwi46CxZsgTbt2/H119/DQBYsGABJk+ejE8//VRx7s8//4zhw4fjwIEDaNu2LU6fPo3evXvj4MGDSE1N9a4hViuErCyEsDlpevQIzForDqeBEtDhVVFRETIyMjBlyhT7vqlTp+Kzzz7DHpWV0gsXLkSXLl3QtrbqZYcOHXDbbbchIyPDu4ZkZwNt2iDkiSfk+xMSaCwMh8PRjYCKzrZt21BZWYnukgRVbdq0QXx8PDZs2CA712Kx4NNPP5WdCwA9evTAxx9/DJuns0vZ2cC4cQA7awXQwDsVi4vD4XhOQEXn2LFjAICUlBTZ/pSUFBw5ckS27+zZs7h+/brquSUlJcjNzXW/AVYrMHOm8/w4PCkWh6MrAXVWFNWm3IxiHLXR0dEoKCjQfC4AFBQUoJ24MFPlPjWSROphYWEICwuDsGsXQtQsHCl5ebDs3AkyYIDrDtVDxPelxp+J5gMM77P3mM1mmCX+zzI3IvYDKjqhoaEAAIGZkhYEwX5My7nS42qwTuYJEyZg0qRJaLF7N3o4eI2UI198gfyKCg1n1l9ycnIC3QS/w/vsOWvXrsX69es9em1ARScpKQkAUFFRIZsir6ioQLK05AtzrhRxmz1fSm5uruz6dksnKgpYvtxlO7uMGIHbG7Clk5OTg6FDh8IUyLQdfoT32fs+Dx48GJmZmfbtsrIyzTPIARWdLl26AADy8/Nxs6Qcbn5+PgYOHCg7t0WLFkhISEA+U+43Pz8fCQkJaNq0qcP7xMXFIVZtqcDAgTQlRH6+ul9HEICUFIQMHNjgF1SaTKYb5gEU4X327jqia0Pc1kpAHclDhgxBZGQkDh8+bN+Xl5eHgoICjBs3TnauwWDAPffcIzsXoMGC6enpMHiyGNNoBFatov9no455UiwOxycEVHQiIiIwa9YsZGVl2fetWbMG/fr1Q+/evZGVlYW0tDS7U3n27NnYt28ffqlNJ3ru3Dns378fM2bM8LwR6ek0+ZW0bDDAk2JxOD4i4GuvFi1ahJ49e2LGjBlYuHAhTp8+jc2bN0MQBBQXF6OgoMDuJe/UqRM2bdqEOXPmYOnSpfjrX/+KTz/9FGlpad41Ij0dOH8e17duxeu9e+P61q00KdYNIDhmsxlr166VzUQ0dHifA4tASCCKOPmH0tJSNGrUCCUlJeo+HYarV68iISEBhYWFiNda7qWew/vM+6wH7jxrAbd0OBzOjQUXHQ6H41ca9PJpceRYWlqq6XwxqrKsrOyGmUrlfeZ91gPxGdPirWnQPp0LFy6gpVgOmMPh+Jy8vDzF+kiWBi06NpsNFy9eRExMjGL5BIfD0Q9CCMrKypCcnOwyZq5Biw6Hwwk+uCP5BqagoAAlJSWBbgbHj9hsNpw7dy6gbeCiA2oaLl++HHPmzMH8+fMxbdo0t5bq1xf+85//QBAE+1+fPn3sMRVffvklHn30USxZsgT33Xcffv755wC31nP27t2rWLsH0CUzU6dOxWuvvYbx48dj3759suOXLl3Co48+itdeew0PP/ww/vGPf/iryV7jqM8VFRVo0qSJ/TM3Go3Iy8uzHw9InwmHvPzyy2TQoEH27eeff57cc889AWyRbxg9ejR5//337X8HDhwghBCya9cukpSURIqLiwkhhHz99dekZcuW5Nq1awFsrfuUlZWRDz/8kHTs2JGwX+2TJ0+SuLg4cvbsWUIIIadOnSJxcXHk3LlzhBBCrl+/Tm6//XbywQcfEEIIMZvNpH379mTjxo3+7YSbOOszIYS89dZbZP78+fbPfN26dfZjgerzDS86V69eJZGRkfY3nhBCcnNzCQCye/fuALZMX7777jsyf/581WO9evUiU6dOle1r3bo1eemll/zRNN2ZP3++4gGcMGGC7IeFEEIGDBhg7/fbb79NIiMjSVVVlf34woULSbt27YjNZvN9o71Erc+EEDJixAhitVpVXxOoPt/wwyt38jTXZ15//XUsXrwYXbt2xdKlS1FVVQUAuHjxIvbv36+ae7q+9t/IZAXQkl87OzsbaWlpCBPrw9ceP3v2rCKzQTDC9hmgCbu++OILJCcnY9q0aTh58qTseKD6fMOLjjt5muszffv2xeOPP47CwkLMmTMH/fr1Q3l5udP+//TTT6iurg5Ec3VFS37tY8eOqR4HUG+/BxEREZg3bx46dOiAf/zjH+jWrZu91BOAgPX5hhcdd/I012eefPJJvPXWWzh37hwWLFiAQ4cO4fnnn3faf6vViqtXrwaiubqiJb92UVGR0+P1kX79+mHx4sXYs2cPvvnmGzRq1AgPPPCAfaV5oPp8w4uOO3maGwImkwkvvvgiHn30UWzcuNGr3NP1BS19DA0NbdDvwYABA5CdnY1Lly5h7969ABCwPt/wouMs97KzvMv1nYceeggFBQVO+x8WFtYgUj9oya+dlJTkUf7t+kSfPn3QoUMHuxUTqD7f8KIjzdMsJT8/H506dQpAi/xD48aNkZiYiLS0NISEhKj23+vkaEGClvzaXbp0UT0OoEF9D8TPHUDA+nzDi447eZobEocPH8aIESMQFxeH/v37q+aebij915Jfe/To0fjxxx9ldaEOHjyIjh074rbbbvN3k31CZWUlLl26hL59+wJA4Prss8n4esS8efPIsGHD7NsvvfQS6devX72Iz9DCjh07yLhx48ihQ4cIIYRcuXKFDB48mOTn5xNCCNm2bRtJTEwkJSUlhBBCdu/eTeLi4silS5cC1mZvmDt3LgEgi085duwYiY6OJufPnyeEEHL27FkSFRVFfvzxR0IIIZWVlaRdu3bkww8/JIQQUl1dTTp27Ejee+89/3fAA9g+V1VVkXHjxpE333zT/j2ePXu2LB4tUH3mCz5B16MsWLAApaWlaNKkCXJzc7Fy5UrExcUFumm6cOjQITz44IP45ZdfMHnyZCQnJ+Oxxx5Ds2bN7OesW7cOn3/+OTp16oSDBw/iueeesw896ws1NTXYsGEDnnvuOfzyyy947rnnMHHiRPtQYfv27Vi9ejW6deuGQ4cO4bHHHsOgQYPsr8/NzcXcuXNx++234+zZs+jatSumT58eqO5owlGfb7nlFkycOBFbt25Fr1698Lvf/Q7Dhw9XLJUIRJ+56HA4HL9yw/t0OByOf+Giw+Fw/AoXHQ6H41e46HA4HL/CRYfD4fgVLjocDsevcNHhcDh+hYsOR8GUKVNgNBrRtWtXDBkyxJ5jd8iQIejVqxciIyPtgYPLli1DSkoKysvLA9LWdevWeZXPury8HJs3b9axRRxXcNHhKBAEATt27MAPP/yA7du34/bbbwdAI3r379+PM2fOoHHjxgCA1NRU9O7dW5Z9zh8QQjBr1iwkJSUhJibG4+tER0cjKSkJGRkZOraO4wwuOhwFN998MwYMGODweHJyMkaNGgUASE9Px8aNG/1ennfRokVo1qyZbBmDp/Tp0wdRUVFYv369Di3juIIvg+AoqKmpkYnIXXfdhV27dsnqVEvPsVqtqjl6fcXJkydx11134fz58wgPD9flmlVVVbj11luxf/9+e+oHjm/glg5HgRarxWQy4ezZs5g7dy5atWpl37969WoMGzYMr7/+OubNm4fU1FQ0a9YMOTk5OHDgAEaOHIlGjRphxowZsut99NFHmD59OkaPHo0uXbpg165dDu+9atUq3HXXXTLBWbNmDQRBwPnz5+37pkyZgjZt2ti3P/jgA7z22mtYtmwZkpKSZHmAw8PD0bVrV7z11lsu+87xEp+uYec0CAYMGKBa3qSoqEhR+qSkpITExMSQO++8k5w8eZIQQsjEiRNJSkoKycrKIoQQ8tVXXxEA9uN79+4lzz77rP0aU6dOJY0bNyZlZWWq7UlJSSEvvviibN/7779PAJDc3Fz7voceeoi0bt2aEEJrPDVt2tR+bOPGjeSHH36QXeP5558nnTp1cvFucLyFWzocj2nSpAnatWsn2xcbG2tPDNaxY0cAdHh24cIFPPjggwCAO++8EwBw4sQJANQ/88svv2Du3LmYO3curFYr0tLSFFntAKCsrAwXLlywpyDVSk1NDa5evYo333wTAHDvvfeidevWsnOaNm2KEydO2MvzcHxDSKAbwGn4sDNb4nZpaSkA4IcffsC//vUvDBs2zOW1xNrr7iYOj4mJwYsvvoj/+7//w+eff463335bNvQCaMkWm82Gq1evokWLFm5dn6MdbulwAgapdUxXVlYiNzdXcVwslSJFLJniSVzQvHnzsHHjRhw7dgydO3fGt99+KztutVoBQDfnNEcdLjqcgCMWg7PZbPZ9Z86cwaeffqo4t0mTJkhMTERxcbHqtaTVDaTXu3z5Mo4ePYqxY8fip59+QufOnfHaa6/JXnvt2jU0atSoQVTACGa46HBcIkb8VlZWKo6JSb2llUBFi0FEfPgtFovsuGjpPPnkkzhw4AAmTJiAb775BuvWrcPTTz+Ne++9V7U9w4YNw/HjxxX7Q0NDsXLlSuTl5eGTTz7ByZMn7dZSeXk5/v73vwOgQ61x48Ypyqzk5uYq0nlyfECgPdmc4CUvL48sWbKEhISEEADkscceI/v377cfP3DgABk8eDABQObPn08uXLhA3n//fWI0Gskdd9xBDh8+TE6ePEnGjBlDAJAlS5aQa9eukaVLlxIA5O677yYnT54kNpuNPP/88yQxMZHExsaSsWPHkgsXLjhs1+7du0lycrIscX5mZiZZtGgRadOmDYmJiSHz5s0jhw8fJklJSWTJkiXkxIkTxGAwkOnTp5O3336bPPLII6SwsFB23bS0NPLFF1/o/0ZyZPDgQE695KGHHkJ6ejpGjx4NAJgzZw5atWqFJ5980qPr7dixA6tWreLrsPwAH15x6iWZmZl4++23ceXKFQDAL7/8gh9++MGja129ehWZmZn44IMP9GwixwFcdDj1kujoaKxfvx5vvfUWKioqcO3aNeTl5bl9nfLycmRmZuKf//wnGjVq5IOWclj48IpTryGEQBAE/PWvf4XFYlHMSGl9Pcd/cNHhcDh+hQ+vOByOX+Giw+Fw/AoXHQ6H41e46HA4HL/CRYfD4fgVLjocDsevcNHhcDh+hYsOh8PxK1x0OByOX/l/ebwQRu3Ypb8AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "n_ions = 9\n",
    "N = 300\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 6.00 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.09964254838798685\n",
      "nbar =  1.999999993934203\n",
      "nalpha =  122.34406667744291\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30524\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.2\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 80), (0.11, 2, 130))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\qutip\\core\\states.py:528: RuntimeWarning: overflow encountered in exp\n",
      "  diags = np.exp(-beta * i)\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\qutip\\core\\states.py:529: RuntimeWarning: invalid value encountered in divide\n",
      "  diags = diags / np.sum(diags)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "n_ions = 9\n",
    "N = 300\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 6.02 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.1199999999999988\n",
      "nbar =  2.999999999999962\n",
      "nalpha =  166.4967161342865\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30534\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [-12]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 80), (0.11, 3, 200))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\qutip\\core\\states.py:527: RuntimeWarning: invalid value encountered in log\n",
      "  beta = np.log(1.0 / n + 1.0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "n_ions = 9\n",
    "N = 300\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 6.01 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.10147100137496974\n",
      "nbar =  2.4999999999582383\n",
      "nalpha =  124.75619361877602\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30542\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.2\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 80), (0.11, 2.5, 200))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\qutip\\core\\states.py:527: RuntimeWarning: invalid value encountered in log\n",
      "  beta = np.log(1.0 / n + 1.0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "n_ions = 9\n",
    "N = 300\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 6.20 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.11999999999999193\n",
      "nbar =  0.24644548668288463\n",
      "nalpha =  182.60730811877895\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30522\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.1\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 100), (0.11, 1, 200))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "c:\\Users\\bingr\\.conda\\envs\\physics\\Lib\\site-packages\\scipy\\special\\_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR0AAAEWCAYAAABbrUO4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAQKBJREFUeJztnQm8DfX7x59z77Uv2ZX1SpJIRFm6EeKGpB1R4addl7RJlkSSstQvRVpos0QSSdklKpIS6mf9Zwlx7Rf3unf+r8/33O8xZ86cc2bmzFnneb9exzFz5s6Z75mZZ57vs7oURVGIYRgmQiRF6osYhmEACx2GYSIKCx2GYSIKCx2GYSIKCx2GYSIKCx2GYSIKCx2GYSIKCx2GYSJKCiUweXl5tH//fipRogS5XK5oHw7DJCyIMT558iRVqlSJkpKSnCt0IHCqVq0a7cNgGMewZ88eqlKlinOFDjQc+UOULFky6PaZmZlUo0YN2rVrF5UpU4acAI+Zx2wHJ06cEA94ec85VujIKRUEjhGhk5OTI97xwxnZPhHgMfOY7cSIGYMNyQzDRJSYETqrV6+mVq1aBd1u27Zt1Lt3b3r99dfp3nvvpfnz50fk+BiGsYeoT69OnTolBMfw4cPpr7/+Crjtv//+S61bt6bPPvuMbrjhBjFPrV27Ni1YsICaNGkS8rEUKlSIunTpIt6dAo/ZGRSKoTFHXdMpXrw4devWje6+++6g244dO5YKFiwoBA6AQaxjx440aNAgW44FJwTHEgsnJlLwmJ1BoRgac9SFjiQ5OTnoNl988QU1atTIa13jxo1pxYoVQgtiGCb2iRmhE4yzZ8/S9u3bfWIAsIwgwN9//z1qx8YwTBzZdIxy9OhREfVYrFgxn+kZOHTokN+/he1HugwBVEw9NVNuo9420eExO4Mcm8d87tw58ZIgGjnhhA5sOXpxAHJZfq4HgqLUwKCG+a0/Fi9eTE6Dx+wMFts05unTp9PMmTMt/W3cCB0YjVNSUuj06dNe6+Uycj78gShMdaRkIE0HJ6Vt27ZUoEABcgI8Zh6zFdq0aUMTJ0700nS0D/e4FzrQaOrXr0/79u3zWo9lCCO4zgMJLDNRmDgpTrkYJTxmZ1DApjFjH9K0IZcTzpAMOnfuTBs2bPBat379ehG745QcGoaJd2JG6EijFDxRkiVLllCtWrVo8+bNYvnhhx+mw4cP09q1a8Xy8ePHad68efT0009H6agZhjFLSizMNWfNmiUMU2Do0KHUtWtXqlevnshcRfyNtNtUrFiRli5dSq+88gqtWrWKNm3aRG+//baYpzIMEx9EXehgLti9e3fx0nLHHXeIl5qGDRsKIcUwTHwSM9MrhmGcAQsdhmEiCgsdhmGcZdNhHMS4cahriVKORAMGRPtomCjBQoeJrNBBcGflyix0HAxPrxiGiSgsdJjIkJuLCFD3//GOZcaRsNBhws8XXxClphIdPuxexjuWsZ5xHCx0mPACwXLXXUR793qvh20H61nwOA4WOkz4wBSqXz/0nPX9TK7r35+nWg6DvVdM+Pj+e18NRyt49uxxb4fqAexOdwQsdJjw8c8/xrdjd7pj4OkVEz4uucTe7ZiEgIUOEz7QnwzdO/z1t8b6qlXd2zGOgYUOEz7Qy+yNN9z/1woeuTxhgns7xjGw0GHCC+ohzZ7tttWogQaE9ficAwcdBQsdJvxAsOzeTVSunHsZ77t2uddz4KDjYKHDRAZMoWTbH7xjmQMHHQkLHSY6cOCgY+E4HSZyIP5GBgCaCRy88cZIHiUTZljoMJFDHfSX3/3DtgBDJm5gocNEp0IgBw46FhY6jH3k5BAdOEA0ejTRv/8SXXwx0ZNP6gcHysBBGI317Dr4G3zOgYMJBxuSmdCAi/v114natCFCb+tq1dwCB0AAIT7n3nuJ5sxxCyUJBw46FhY6jDWOHCHKyHALmWeeIVq2jCg7W98mA/sNXODVqxONH39hOyOBg4GmcC++6H5n4goWOox50GG1Th2i//6X6MwZ438HAQQbT926aFQfPHAwEBA2w4ez0IlDWOgwxjl/3q3ddOlyYQplhe3bidB//umn3WkPeoGDTMISdUOyoig0fvx4OnjwoOhrfuDAAbFcokQJ3e1nzJhBP/30E5UtW5a2bNlCPXr0oA4dOkT8uBONJNhPTp/29ThJTxSEwcqVRN9+q7+DHj3cU6gmTYjq1XNPv0qVIho1iuiTT4jWrPH9m7FjiX76iWju3PANjIk9lCgzatQopXXr1p7lIUOGKJ06ddLd9rvvvlMaN26s5OXlieXjx48rF198sbJr1y7d7fE5hoh3I2RnZytffvmleHcKcsx5lSvDh6QoeFcj1xcs6H7Xe1Ws6N52zhxFqVLF+zMsY/2aNYrStKn+39es6d6H3vf7w9/xmhizE89zdpjGbOZei+r0KjMzk0aOHEk9e/b0rOvduzfNnz+fvkckqoYFCxZQtWrVyJXv3ShZsiRVr16d1q9fH9HjdhTSna01EkPzKV3a/f+UlOB5VLDnQNuBx0pOpSQ7doQ2XWPiiqgKnUWLFlFWVhY1atTIsy41NVVMnWbBWKmhXLlytHjxYtqHC5mIzp49Szt27KCrrroqosftKI4f911XpgzR8uVERYteEExG8qjy8tw2oR9/dHuo1OAzuNzvuy8co2BiiKjadDZt2iTeq2guQCxv3LjRZ/uHHnqIJk2aRK1ataJp06aJ/48dO5Zq164dVKPKUcWIFCpUSLy0yG3U2yY6cqywrUF/hIg4n78uafJkSoadR4VSqhSd/+YbooYNxcUj/iY7m1yyNEWAPKrzy5eT0rKl23u1ejWl3HYbudTn+dQpUmbNovOPP05UsaL//eXmUsq5c+7vPneOzp89a8r47OTznGPTmM+dOydekpMnT8aH0IEwAMWKFfNaX7x4cTp06JDP9hUrVqQlS5ZQ27ZtqXnz5jRgwAC6//77g35PjRo1vJa7dOlC3bp187s9tCmngQuoSL72+N3ChXTR9u3U4rnnvLbJLViQfhg0iI5iqrR3L9188iRBdJ8/fZoKGPiOjd98Q/tUQqzA009Ts+HDqfS2bZ51rp076VSrVvTDyJGUW7iwzz4uWbuWrnrvPSoAQzW2P3yYzlepQpv69KF/mjUzNWYnnufFNo15+vTpNHPmTEt/G1WhU7BgQfEubTQSLMvPtPz999/Upk0b2r17N40bN05I2HfffTfg9+zatcvLGxZI08FJgVCDJ80JiDEvWiSEByjsclGHtDRKeeYZcmnKSihTplCzbt3INXcuJQ8YQC54tSA8DMbqNGjfnq6GpqMmPZ2Udu3I9euvnlWlt2+nDtOmUS7sRCoNRnzvmDE+07jCmZl07ZgxlDtjBim3325szE48z4vtGzPuwYkTJ3qWcR9qH+5+UaLISy+9JCzeJ06c8FrfsGFDpV27dj7b//DDD8qVV16pnD17VsnNzVUyMjLE33/yySe6+2fvVXByZs5UssqW9fYmFSum72WCJ+qZZxTF5fLvydJ7YfuqVRXl/Hn9g/jnH0VJTfX9u+efv7AN/lbrGTPzHQ4/z9nsvXLToEED8S4NwxIs10Osh4a33nqL0tPThZaSlJREEyZMoGbNmtFcjvOwxhdfUHLXrlQ4f6riQWPH8QDP1Guv6RuM/WEkjwqJoYsWuQ3Ual55hWjePPf/zdTfYWKaqAqdm266iYoWLUob0N0xnz179gh7zl1ws+rYHXJVKj+mYTfccIMQQIz1yn1+GsTYg5E8KgBnAAQM3O9qunZ1e7zee8/Y93H9nZgnqndrkSJFqH///sITJZk6dSqlpaVR06ZNxfq6det6jMr33HOPiNWBsVPy888/6wooRxBK0mO+5hAWgQPXt5k8Kklamu9YcK6R4wVNyAhcfyfmiXoaxIgRI2jo0KGUkZFBpUuXFkbfefPmCS3m2LFjQuBI1xy8TjBY3XvvvWL6deTIEeGFgjByJKG04g2nRgCv06lT1vKo+vYlWrvWt7IghA/X30kIoi50MDVCVLIe/fr1Ey81ffr0ES8mRMKhEcgbP5Ri6tjHlClEv/9OtHmzt53pqafwlHJvoxY8XH8nrmBjiFPJr9yn+Gv5G4xAhbes7lOCuK0ZM3zTJWDX+fBDa/V3mJiBhY5TUVXuM+yLgjDBC0W7wn3jw3v56qve6/bvJ1q40Fr9HSZmYKHjZO64g3KHDvU1Jl90kVuwaPOjpGBBgF4kbvwnnvDVdpCT99VXXH8njom6TYeJLklI3PRakeTWKJDMiTgZxNAgr0oKFnmDByq8pe5vFdLBJbkz2VFrWc1jj4U+hWOiBgsdJ7N8OSWtWuW9DukiMnvcakU/s540f8AgjWqFWiCE5DEycQdPr+IV3JAyyxfvZj1G8P4MG+a7XpN8GzWQd5Wa6tay9MjKivQRMTbBQice0d6QeMcy1htlxQr9lIFYmLb4KwimB+rwhAp3logoPL2KN+QNqQ2QkxX6jHqQkEOlQklO9skqj3Z6hiEuvzy6QZaMaVjoxBOBbkisg5aCCn2dOwe2v2zZQoRCXNrUBb0qgYGwy2CsJlhip5bVq4n++MPtYmfiAhY68YSZTOsbb/S/HRreqThXogQVhGHWitCxG7PpGRDE8GahU0UsTA2ZoLDQiSeM3pCBtjt4kOjjj71W7b75Zrrs2mvdpUm1Wks4tBm70zMgZDEmA1UkmejDQieeMHpDBtru7bcveL2gHBUsSLs6dKBLu3enZL2KcpG2ceSnZwRM7KxUCWUn3XFDEjTu69TpQocKJmZh71U8IW9If9MIrK9a1X+mNcqKQuioULp2pXOxdKOq0jP85ne9+ab7pQYtbF54IUIHyYQCC514wsgNGSjT+vPPfeJecjVZ/DEBvG/wwgXK77rlFrfBXM2kSUTcAy3mYaETbxi5If2Bm1JNmzZEsdozDOMIlt8FAVwEPSzywXTs0UfNBUqGGmTJmIaFTjxi5IbU8ttv7uJYauD1iWWCpWFUr040ZIj3Omg6779vaPfoLhFykCVjGhY68YrZvKjJk32NzTC8xjso7HXFFd7rnn+eSFtsXqd/ForS+22DzIInbLDQcQIoHfrJJ97rUH0xEXo+wYuFGspq0MQxkFE5N1c07AvaBpmnWmGBhY4TQL1hddtXlIxIpJKvN93k1k7UoAHjL7/obu5avZqKHDnivyg9t7MJKyx0nIDWgNyxI1G1apRQjB3rXe4CggM90fUSQu0IsmRiR+ig1S8TZdRZ0zAgq/qKCR55hBIOCFHtlOqnn9DTKDxBlkxkI5KXL19OTz31FG3dupWys7N9Ph/AmbrRRZ01rTWUwrWenk5xg5k0DBiVIWS2bbuwbuBAIvQ3VwVAKmlpdKZsWdEDXTRI1sLtbGJP6Nx///3UuHFjevTRR6kgDHn5oD/Vp59+aufxMaGAG0prQEZ+UjzVFDbzAIMXD5HK7dt7RyoPHeptbE5Opk19+tC1qPXM7WziJ/dq9uzZlKxzUtAqmIkRLQAN6uDJUfPAA5TQoGwHWhT/9deFdUj9+M9/iBo08Kz6p1kzyp0xg1KgHam1QWg4EDjcXSK2hM7AgQNp1apV1KpVK5/P9u/fT5deeqkdx8aEqgVoS3o2b25P0at4mFqqgTEZnUPhjVKljyiYdt15p//i80zsCJ2///6b3n33XWrUqJHXekVRaPXq1bRNPacOI7AnrVu3jk6fPk3t2rWLyHfGFaqe74KePckxoMC8Okzghx/cU8377vPezmrxeSayQmfnzp1CwKDvuJrz58/Tv5hDmwD7GT9+PB08eJAKFChABw4cEMslcNH4Af3MX3zxRdq0aZPQutogh4gJ3l/cST3fcf2UL4+L9cI6uNA3b6aksmUTX+NLNKGDXuJt27YVfci1fPvtt6b2NXr0aFqyZAktXbpULA8dOpS6d+9OX6Ghmg4Qaunp6ULLWrhwIaWkcEkgQ8BGgSZ6TgHTKNhmbr31wjpoPq++Sknw6k2cGM2jczSW4nRw00PgbN++nT7//HOaN2+e0FDkZ0bJzMykkSNHUk+V2t+7d2+aP38+fa8TDQqtqGvXruJ94sSJLHD8odcryolV9ZBbhkBILTk50TgaJhShk5OTQz169KDatWtTly5d6Pbbb6dq1arRk08+aWo/ixYtoqysLC/bUGpqKpUtW5ZmoX2shrlz59KyZcto8ODBXq56RgXyhdS2DFChgruMhRNB+QvttXLsmPFuE9F4YBw54vY64v8ovBarxxpJoYObfu3atfTmm28Kw/Gff/4pplWwtbz88suG9wObDKii6ZmN5Y0bN/psP23aNKFhrVmzRnjOSpcuTd26daNjuIgYd2Y0yj1ovVbXXEPkVK2wZk2iZ5/1WuXKzqbK6CIRa5w+7TZklynjfuGcwYQBAZRAyaeWrsSff/6ZfvvtNyqOtiX5XH755UIQPI1atSamV6CYpqsk9nvo0CHd74VGBeNx+fLlhZfshhtuoMcee4w+++yzgN8D7UxSqFAh8dIit1FvGy+gNowo1aAoPomMyqJFlDtrlttFnEBj9ndBY/zQDc7LMT39NKV8/DG5/u//PNvV/fBDynnmGXFz6/4NnsiwCeXHQeUh6zzcAkdvagyhg/sDBcZCqApg93lGIDBeEigcYRU6aWlpXgJHTZ6JjotyiuTSlN7Est706ciRI9S3b18hcECtWrXowQcfFNoVbDzQfPSoUaOG1zKmhNCQ/LF48WKKK3Jzqd1jj1GyjsCRZD/+OC3Gk9OPSzjuxqxHbi7dfPIk4XGSffIkLZo/3zPeS7p1o+tGj/ZsWiQzk7Y98ght6dmTarZrRylZWXS+aFHasXChZ5t2r74qstGRMvFdgni7Ftt0nqdPn04zZ8609LeWhA48SHCPaw25OBDEzRilAmwNQsif9nKRY7kSKv5rKFWqlE8UdP369YVheceOHSI1Qw+49tX7D6Tp4KTAMwf3fbzgWrmSUgIUrYIgKnr4MHUsWZKUli29PsvJzqbFS5ZQ2+bNqQBsB/hdUAJUPhHxe+NBgpgfPIXhAcMTDuc+hn4joekNGEAuaCY4xydO0K0ZGZQ7bpxbw2vfnpTx48mlejpftmABpQ4ffsHuk5NDtfEbYMwuF6UgzEBEGxSmDh06hOfAFcU9HTbSQ15Om9XZ9Aax+9pGmAoe9GpNR/twt1Xo3HbbbVSnTh1q3769mBrt2bNH2Hj27t0r3NhGaZAflr5v3z66QlX9Dct60c6XXXaZz7Tronw3cKC4njJlylBJE32bcFLiSeiI/CIDpGA79big0qPAF8ZcqpT3mLWapvpCh2YKAyeEEQQUlnXCJyJqy8qfWqpx7d9PKViP2tEo4o4xqISO6/x5KoBp05dfuoWt+kEE4ZW/PwjtsF0PJ064Y6iM7B/XOh4GIRyLXdc29qGe7ZjZp6Ur5eabbxZS7tdff6U33nhDuMyR+oBYGzOBesjTKlq0KG1QlV6AAINguUtblEmEmtxBPyCyVJN2AW+XUSmbkJgt1QCNBTcUBAUMlmaBQMINgIsO+0Fn0KNHo+NlCdZqGTz0kLv2MY5Ry/LlRN9957s+Us0FXS630DEKNExtPl2cYfnxhLQDxNLA5Q3VCqobbD2YdhmlSJEi1L9/f+GVkkydOlXsp2nTpmJ93bp1PdpNr1696MSJE17zUswrYVh2tAsdJRi03SH89cOCip4/BfHqpGAV3ASwpcmbFDeENv0i2q2WMfUMtA1y2KQhV02gNsXqmkVWOXPGHTltBhwTNDK9440TbNeJzZa2GDFiBF177bWUkZFBw4YNEx4paE4wJsMVDoEjreTQaBC9PGHCBHr22WfpkUceEd4r1PZxNLBBIItaD3WpBmg2mBJBu7G773e+HYRKlXJrUpFq52JHdT+UJg0U6qGnRUHYwB5kVehkZ7tfVoD9J45DIAwdOYL/GjZsKFIU4J2CTedUvi1Am4D5+++/0wMmyicg7gZRyXr069dPvLSG46+//trw/h2DToiBV6kGTHthD/DjdbQNCDb5HdCq8DSHLcUOrSqc1f1ee81tF6pfX/9zCFA7k0HPnAntXECzx7Q2DlNbDAkdeIdy859aEBLQOOBhQsyM1kIOmwwTYaC9zJvnu16WasDND2EQ6SmoFDbQfPBUh9DDOrWWhc+wbPWGDtb73Cg4jt69iX780VeLwPHhN8ZvaIeGmJvrno6Gsi9pvMdU1oxNKF6Ezpew7msSPhEMKONl1CxYsMC+o2OMgVrAetMM6Y2BOh4t7xJuDng2IBBwY8OYCxsQBBDW4SVtQJiaWW21DMeDtgqgWdA9Yvx4IgQNajt/ylcw7QTTLVlYzV+9o2PH3L9BqAIMx6LyxsULlq7Eo0eP6goceKH04l+YMKN5KHg9qREpGk13tgQ3GLQc2JMgcBAdjBsG1wuEDaYJ0IasCI1ArZZRxsLPzS2+SavVoLTpW2/5dv6sU4dozhz97hJmbD1nz7rHbMc5kUZlHVNHLGNp5KgaqEfNmjXpiSeeCPWYGDPgJkV7XDXSfoIbJBbn/Dhm5ERhuieNzlLYWM2j02u1jGX0vwIawaPIdS+95P0ZhAKuYb3On716hd75s1AhY4GARsGxy+lrogkdeJAwrUI8zpQpU8S7+oU4mUsuucSUy9wx4IYKlydn61bv7gdAzvHtskHYCVy9MpFRHRQHYYMbB8tW84P0qgD60YLOlCsnaiSLFsQZGcH3re78CSOwFWBbO3vW/nOCqVwc3XeG/W6YNr333nsiJgbxOdryoHBxI/IXni5GBeb3iMWApwFPOLunn1otB1OKWM1IhuYFrUb7pJfRwLixIXgQ6wN7hdbobBUIHkQkI+0mM5OUcuVo8eTJ1EH2coe7HEXjNJUwfcDxQePRCyY00gzw4EGiihXdrXLsRApwCDULKRKRxrSzH5X+Nm/eLIL2tCCuRs+V7ljwRMRNgxcMh3ia2y10tPYc3FyhTgHCRTCXvbRRYEqI3wo3kEwTCNXzhhtTTju1tZAhBKdMcbcnNgKOSW1kNuJOh4Fa9iJ7KgxxZRgfjkWt7SWSTQcCB9Mt5FqhSLt8bdmyhe5EdX3mwpNR3mRS8NipBiM8Yf1673W33ebfSInjkUWhtDV3wg2+E7+BEeEhhQz+RuZL4XghtKzaLoJF8CKOyei1C6GhNjLD6BxI0EMoRSJFpFR+YGaMYymsERX8EACIWB0t1VFEinHfILhxtNMDPCVxcdjhvdBqORBqKNilBy56uKvl0x7L0CbsNGoGQsYKGQVeLkzHYP+RqQK4ebEfaNMYK+wj+I2DaRn4OyN2InQHRbxTsBtXm2ALDQYue9iO9MDUOhK2NZfLfT7xG0FQQ2Dj98HvFUOudUtCB7Yd5EUhWRMthpFtjuBBCCOkJjD5T1a9vBrc9LhZ7Jh7a4UO7Gy4GfWa8OEGVtuUZGGoSCVpYsxmk0txs+I3lG5tCBftb4qQABifcXP5u7H07Eh6QCt99VXz0x+pxcHIrP09ZSZ+JCmaL2wgaOWUNYYCCC0JnVtvvdVjMEbaQ4sWLYQhuVmzZnT33XdzgKC82PSewDj5dtzoSGJcudJ7HVrM4CLTBqXhyY0LUHvx42LUy7wOB1byvSBg8JT2FzSI8ag1N/zm8rfFOwzSEEjYxmhxOfx2KJX78cfe63ETB5ra4fsw3ZWCHoJOTmWjYdxNSbkgrKUAihEs6fh//PEHzZgxQ9hx4MVC9b6tW7eKddB8mPybTA/ceFB/Q/UwIf9MvQ/cWDffrL+t1Ab0iMQTENM4ExUlPeCmMZqfJJ/oUrBJG5r0iKkDD+U7BC6OS9YVkkJi0iSiFi2892/UliQz+GHruewyIhP1pZyCJU3nnnvuEZoOylKgSHvFihWFcRnaDrK+HQ9u8kCFmXAzYboRij1F6ypv21b/iYqbCMfhLys53NnKMkbJam4V/s5MYqN6agnBgyc8NCbpRQTyXdrWcK7UAhzHDG8WopCtCEsJUlOgfapKtxD2h4cOfnfp6cWx4nqAYJPCUtbMgSDF+ZPbYizYDpqU3FbWMoJGg+1lvWIIbIw/huw5wNIVB8FyWFrvRZjDy3TLLbfQP//8Iwp8OR5cFIHqpODCCMV7hL/VNjVELIoeRjPL8ZQPR3U8tQfPCjKfClNEIwJSO7WEYPE3rZPrIdi0LnTURMYNHaAMrGFbzwsvXNCukpIuPBzU2rD2N9JqyuplnCf1A0vWBtfL+4IgwrbxPr366KOPfNbBnoOoZBiTHU8ww6GcCli17SA4TR0Vixvmllt8t8P+jVbpx5M2lKd6oP2GGjeCG9LKdBTTOrXHDDfisGGUpymX4hc7pp7S1iM1lXNhrDMUao2fWLfp+KsEOGjQIHI0uKCMxKLIrGUraAU77A9IbNTTuIze8Hga2l3xT0Yghwo0HJljZBQ5VVFrORA6L75ovp2MHcF2altPapC4ngTHVO4VWv6iG8PYsWPFu/YFu45e9rmjgAZi5EmGC9lKoBtuPLRWUeMv9USq1kbAtnZ51iQQOHa5i6HNmeitFPK0Tju1gX1HD7PlRtVxPVYFjx2lUuMl9+qDDz6g6667TvQahzFZL/eqdevW5GgwdzZyo+PpbcWVigx/rZsbUchaZMF0MzVqIDBxc9vl0cJ+7AqKk3YXWUzLiJZjV6U/fB8E/XXX6RdFN1tETFHF9SBtxexxQtjIlAp/NXtiGNOGZAT/IU5Hry8VcHyWObwsRm80aAK4oIPdRGoDIco1qEEfeBRd17vxzHqmoJXADmKH0MF1ECjGxgoYP8YVbPoKjchP40XLoBQH6unAS6i+xvFdaNwIb5eZImJKvq0HheXRDSVY4a8EwpJNx5/AsVKYPaGQMR9GwUVqxOYhDYTIVNZGIQfK6jcrPCD8rEwX/GlN4YjExdQ10DRLBkGGo3DZjTe6UyW0QOA8+mjgjhyB3Orj4sMAnDCF2RMKWe/XKLDrmDHe4obavz/41CqUGBzcrBCcoeZkyZgRu4FAwbRRL/ZHao52RQDrpZN07+6eYqlr8EBrefttojffdBcFg7EYfyONx5EoLB9HcGF2O5EBWkYxaz/RCqhatYiuvNJ3O5wraBpWbnocU6iBi+GeYmMKizFCOMqaOxgvXnZOq/xNdVBZELE3Wo0LgkgKKBix8X9/th6Xy20LsiuYVlvT2e7uFTbChdntBJqF2RONCxdTGiN/p61YBy1HT7OStYetIjs4WI1WRvBiuJMcZZ8tGNUhhKDh2FHs3Cg4Z3rTPLV2469gvEvVi8wOwQAvGGKPtOU28P3+gkajiKWJ7/XXX+8jcA4cOCDeEZnsWKD2m8WM61yrQfiz50B7CsUYDO0hlEBB/G0kesHLQu+ycFUkS7PK7/JnA8ONDxuQv4Lxs2fbIxAgcCDY9Go6h+KWjzWh8+2331LJkiVpDqz5+WBa9SICr8IR1ZrIyNwas1x8MVGTJvqf4Qkc6g2IqYuVyFmcfzs9VrEOplAw8GvBg6RBgwsF4tUF43ftskfgQHsK1scdbvkYK19rSegg1wpTrBshyfNBa2Akfjo2ItlqMJosM2kWxHfoeWhwsdvhuYEWYSU/DNMLJ4RN5KdUiHe8Zs701S5h38Q9grY20tZXSFMqNRTbDZw5wfq457vlkyZMoNqffSbeo42lqxMBgOPGjRMGZTWVK1emqXouRSdg1nOl9UoFehrpfeZvagVNw444GyutUvDdstpfopOfUuExNiNYFoGbWoGPG3/UKHdRdqMGYH9gqqTux2XEOwY2b6akkSPpilmzKOn11ynaWLo69MqUAtTTMRscCM/Y+PHj6eDBg1SgQAFhG8JyCQPxItCqChYsKKZ1UQcXjNXi4bjBIXj0noB6cSlQ6Vu10t8X9mGXPQVeLDOFviF01e5lp3Htte6OE/n2TS+kMDl8mGjNGqLmzc0ZgKXtxkqaSkYGuaTZI9K1se3SdNLT00UaxIoVK+h///sfLV68WBRkh9BBfpbZ7hJff/01vfrqqzRy5EgReNgdsRBB+O2330QOWMwAoWH1CQ9Pj96NLZ9sWiFfv76+gMOFZWc3DrMlOPDdTtByAiEfHBC+er/FuXPwxKC7gbsQvBEDMASWP9uNEdR2VjsKyIWIpSvkpptuEgmgGRkZnozzcuXK0ahRo+jZZ581vJ/MzEwhaCahUls+EFookYHeWv4KgiFm6L///a+wI8UMocaHwPWrrpkS6Mm2erX7c+3TMFRXuRYzWo7VlsCJhjqgENroY48R/fij73ZbtgTPy9q50y3IDx0KbLsxgdB4UN3TaLudcKCEyPHjx5XDhw97lnNycgz/7aeffoqrVNm8ebPX+rJlyyp9+/b1+3fjx49X1q9fr7Rs2VIZNmxYwGPD/vFuhOzsbOXLL78U76bJzFRC4uhRRTl/3v1/vFepgsvP/6tq1QvbS7Ccm2vqa4OOOS9PUbKygu/o1Cnf44lRQjrPZsH5+PBDRUlKCnw+SedVuLD3ewivPJfL/V6unPuc2oyZe82SpnPo0CGqgLmr0CK95/AvvfSSeBlh06ZN4r0K4hZUYHkjimPrsHPnTqEhNUKio0GwPaKl1RnzeGmR26i3NQSeHkbbnPhDttPNyyPXypWUEuzJtmcPnV++nJSWLS+sw1PRZMErQ2OGTSlQYirseDIDPA5CJiyfZ6t0704pgwaR659/SElOJpfR8yMj0C3WOVIKFiQlPZ3y7rqLkp57jlwHDoh1diRlY6aDl+SkibIjloQOplETNK433NhPPfWUqCpoVOjgb0AxjZekePHiQrDp8corr9AbMLSZANM1NV26dKFuyAz2A2xU0aTyqlXU2MB2G7/5hvaZSTANQLTHHA0iOeZ22dmEGO2zF11Ee268kS4PY9BebsGCtPGxx+jAtdfS+fx7q11Ojvh+CIrvbCgWP336dJqJMAELWBI6K1euFLYXGH8RmTxlyhThSUJeVnNY5Q0Cz5OsxaMGy/IzNR9++KEwYKPflhl27drl5Q0LpOngQmzbtq3wpBkGTy6MIdT4GAjhMmXIhQvFQMZxg/bt6Wqp6chC3SY9aIbHLOsUa7eBLcdoDaEYwfJ5DgFoGrknTlDBkiWpxhNPkIJOEfv2Uagx1NKKlte1KyUtXUquf/+lpPLlqf6YMVRfbpSbS9Iviqu+Q3p6yOkXbdq0oYkTJ3ppOtqHu61CByfsxIkToscV3OeYCj300EMiaBAucKPIKRr2oRYKWNaWz4BLHRnsvXr1Mn28KC6mnQYGAheiqYsROVEQhKF6bmTgGAyQmHL6m2LlJwumYDt58UDghXAhBR2zrLeMbeR2EDjwvMWRwAnpPIfCM894/puMf5CRDkcB0LtnOnUiWrr0Qh5b167uWB/U31FNZVyopTRhAiXDqZBvpoAg84xLuuXzC8wnHTlCSUgUDjEvC/vHjES9bBgrRqPBgwcrvXr1UpKSkpR27dopt956q7JhwwbT+/nqq6+E8Wnr1q1e6ytUqKAMGDDAa93UqVOVwoULK8WKFfO88P0FChQQ/1+1alX0DMlHjthjnFPvY9YsfaMgDIJ4zZnjbay0aMg2NWZ8D35L+X0wfofBKJlQhuRAzJnj6zCAg0Ce28qV3evwLoGxHsZgrMe72niv3R77yTcgB72GQsTMvWZJ6LhcLqVatWrK7NmzxfK5c+eUoUOHKhkZGcqkSZMM7ycrK0spWrSo8GJJ/v77b3Hwa9as8dr2xIkTyrZt27xe1113nfLEE0+I/2NfURM6dl288qYGEKL+vFbai+XMGbf3yAKWxgxBEyeeqpgWOmaFiJn1wTygEDp6HlCLmLnXLBkhOnbsSFu2bBEBgQD2l+HDh9N//vMfHwNzINA9Ag370BddgjSKtLQ0atq0qViPYu8wKmP6ddlll3m98PeYOsn/Rw0rBdb1wBRJelS0FQIDJQtiWhfJ8dtZf9jpJKtiodR5WWbSI/TANMxgXlaksWSEgPdI63FCKgIMwO+++66pfY0YMUJUJESgYenSpYXRd968eWJfx44dEwJH7ZqLOXAx2JHgKOsgI2/quefc9Xi1+EsWhEvVrs4HTPT5wob6OCiDaud2dmJEdYLtpEWLFsrkyZM9qpT6JXnllVfEtrFCRKZX585Zntr4VY3Xr9dXibXqtPz+EycSY6oRIWJuzJVV596IHcbI9Gr5cmOBg9guFqdXKEsKNzk8VGDMmDFCK+nZsyfNnj3bE2w0cOBAMdVxFGZ6Sxnl88+9lwNNZTAds6tlDBNdFIP1cfx5iNXlNpBCBG9WoJbK8HzZVS7V7ukV7CpqkC8FYYMiXtoYm3r16pGjwJTIDne5Gm0zPQgVf0GA4ep8wETHNng4f0oVyA4jC4IFq+kcqXKpJjF0teoF4yEQSCtwgNbWk/DIFAA796dNBvRnJMa2ZrpeMrFNbq6928H+E+5yqRaw/HjWEzggpo2+4cDOLpZ6eTZ4qvmLMkZQIk+tEodkgw8vMw85CJbOnUm5+GJyHT5MSrly5IIHNIreR0NCB+7xjz/+2CvaeN++fT7rIHBWoXqak7C7foy248Ott6Iotf628GZZLRzGxB4FCwZuUSzb1qDVDZJ7jUbZ+3PLx7rQgdFYDYSN3jp/GlBCgoxqhKnbeeNrY37QZgY2NW3Tt/yMdCbBavCkpga3w8RgWxnbhc6VV15Jjz76qFeuhR7ImXrvvffIMdjV0EwdCKYG9jH0zkYejhYYlu1qAcxElwEaAzDsLfBiqYP7oOEkgMAxLHSGDBkiykEYAR0hHDW1CrWFrTYQTE2bNv61qBATPJkY5g63HUa0GcJ1ISPRE+R8GxI6RgUOkKkRjgBG31CylIMV20bbZr25O6ZgTi6A7gSSY8sOYycOr6IdhQ4QMt0BU1XEUQQqBTJ3LtH48d7TOHwnjM1sQGbiFBY6oWL2CQShA+8EVOZAgWAA2yEhD90fYN+R3Rmc1EGTSTg4lDUULrrI+t8aDfBCDyV0iUAgILQidJ1wkoeQSThY07GzbUw4NKRLLnELGc4iZ0Igr18/2vbLL1SrUSNP6dJowUInWu5yo4FgUUjIYxKPvP796a+FC6lmhw5RFzo8vQqFUFIQIFSCGZKjlJDHMOGEhY5VICxCTYFAPMbzz+tPqaKYkMcw4YSnV1aRyZZmNBG9EpSYXqmBIEP5AtZwmAGq9IgEgoVOpEpa6JWgrF7dfVGpQYQzCxxGLz0iQWChYxU8fYwWz/IXeazVckA0C8wzTARgm45VEKRnBEyh/JWgjESpDIaJMVjoWEG22LWjFQjDOAwWOlZAHRujiZ7RaPHBMDEMCx0rwJZjtBY03N9GYOMx4xBY6Fi15xjt6hmsFYiEDciMQ2CrpRVgz5G1ToxoMP5agah5+GF3flWCxWQwjBYWOlYwW1RJtgLRlqCU1KlD9NprnD3OOIKoT69QzH3cuHH03HPP0eDBg6lPnz50MkAvp2nTplGdOnWoRIkSdP3119PPP/9MUcGsgIDg2b2bqGxZ38+6dmWBwziGqAud0aNH09dff02vvvqq6BxaqVIl6t69u+62c+fOpQULFtCIESNo2LBhtHXrVkpPT6cDqDkTizE6WvxpRxA6DOMQojq9yszMFIJm0qRJnnW9e/cW3UO///57ukFT1mHZsmU0c+ZMSsqPBEbf9Ntvv10IImhIEQHBfqG08dX2tbrmGqLLLw/5sBgmXoiqprNo0SLKysqiRo0aedalpqZS2bJladasWV7b5uTkUI8ePTwCB9x0003i/YQ2fymcQFuxauxFkXWt0GEth3EYURU6mzZtEu9V4FJWgeWNGzd6rStQoAA1adLEa93Z/Ba82vVhBd+JRndWmD/f13tlotMGwyQCUZ9egWKaQDs09Tt06FDQv8cUrHHjxsKgHOx7oClJChUqJF5a5DbqbX2ApoK/tSB4kufM8ZLyec2bUy6CB60KMRswNOYEg8ccOmghjpckkPMnpoROwfw2KtpWxFiWnwVi4sSJNHny5KDbwUak7ePVrVs3v9svXryY7Cb53Dm6+euvvYTOH/Xq0a6FCykWCMeYYx0es3WmT58u7KtWiKrQqVChgqcdMVzgEizDixWIt956i+677z66BobYIOzatctr/4E0HZyUtm3biumcnbWRXR98QCn500GASVadIUOoTpQ7ohoac4LBYy4Q8v7atGkjHvpqTUf7cI9JodOgQQPxvm/fPrriiis867HcqlUrv3+3YsUKOnXqFPXt29fQ95QpU4ZKmjD+4qT4PTFQI812gIAdR/NUcF1+ORXQ2LKiScAxJyg8ZutgHzCDqJfjwpAM71PRokVpw4YNnnV79uwR9py7kDagw+bNm2nhwoU0cOBAzzp4wHYj8C7cQHhYCeJDsa6VK73XDR1q22ExTDwRVaFTpEgR6t+/v4gylkydOpXS0tKoadOmYn3dunU9RuX9+/fTgw8+KFzss2fPFq9PPvlETLPKly8fmYM2ml2u5v333eUwJJjq3X67rYfFMPFC1HOvEF08dOhQysjIoNKlSwv7y7x584Qx+dixY0LgwEoO93jHjh2FK33t2rVe++jZs6ePByxsiZ5mNR3YgD791NdNjlrIDONAoi50EOyHqGQ9+vXrJ16SX3/9laIKylmYLSe6Zg3Rtm3e6x54wNbDYph4Iuq5VwndAQJ88on3cs2aREHiihgmkYm6phNXwANmdHo1bhwRbFEffeSr5XBGOeNgWOiYATleF11kXOjotZi5/37bD4th4gmeXpk1CodCerq7wR7DOBgWOkaBy9toiVKgV0P5kUdsPSSGiUdY6JjBaPF0aETachuVKxPdcktYDoth4gkWOkZBdrmRDF20EK5WDWm43uvT0rh7J8Ow0DHpLg8mNGTP8v37fT9D7hU+ZxiHw0LHzNQqUIxOsJ7lcJP37x+6MZph4hwWOkYJNrUK1rMcwmjPHvd2DONgWOgYAQIjWEdPoz3Lubc543BY6NhlzzHas9zodgyToLA7xQgoUBSsSBHa5RQu7C7c7s+mg6JdmrY6DOM0WNNRkTRhAtWePl28+1QLhLYTCNhrtG5yicy1wn4tlDplmESChY6KpDfeoCvQzO+NN8xnl48a5d9zBQ0HvczRWphhHA5PryRwZUtNBe/qAuzoTBEoMxylUqdO9V4np1rlyqEyPGs4DJMPazoAQXupqeQ6fFgsivfUVPd6aC/B2uGMGOHtUkeOVqlSF/7PAodhPLDQkVHE2hgblKXA+s8/920FrGb7diJVjWfBo4+yoGEYPzhb6ASKIpbrnnoKNVX97+Ppp72jjBG5/NxzYThYhkkMnG3TMRJFjM9//pmodWvfz1esIJo3z3sdenFdfDHRgAHuTHMT/bYYxgk4W+gYjQ4+eNB3HbSbJ5/0Xgej8aBB7v9D6DAM44Ozp1ehRBG/+SbRxo3e61566YIBmWEYXZwtdBAdjBgaf+5wrEfxLW0U8c6dRC+84L2ubl2iBx8M37EyTILgbKEDD5MMBNQKHrkMjUbticK0qk8fX4/WpElcpIthDOBsoQMQJYxoYWg0aqABwRXeubP3ejQGXL7ce93jj7srAzIMExQWOlLw7N5NCgzBcFrJKOIOHby1nKVLiYYP9/7bqlWJXnklwgfMMPELCx0JhIvs9iCjiIsXv/D5b78R3Xmnd0wPtnnmGaIFC9zuc64KyDBBiboRQlEUGj9+PB08eJAKFChABw4cEMslSpTQ3X79+vX09ttvU506dWjdunX05JNPUrNmzWw5lrx+/WjbL79QrUaNKBn5V9JG89dfRDffTHT8uPcfFCtGlJHhPSWDjYgTOxkmdoXO6NGjacmSJbQUUxciGjp0KHXv3p2++uorn23/+usvSk9PF8Lm0ksvpW3btlHTpk2FIKpRo0bIx5LXvz/9tXAh1ezQgZJRzqJ0abf9BnYdLGvRtpmRqROcUc4wsTm9yszMpJEjR1LPnj0963r37k3z58+n73VqCQ8bNowaNGggBA6oVasWXXXVVWIftjfWy8pyCw5EImsFjj8vlZx6cQF2holNobNo0SLKysqiRo0aedalpqZS2bJladasWV7bnj9/Xmg/6m1B48aNac6cOZQHQWEVaCxLlpBrzhyq/u23lIxOnLVrE335pf72gQp6cQF2hond6dWmTZvEexXYQlRgeaMm2nfHjh105swZ3W2PHz9Ou3btopo1a1o7EAT7tW0rfowGZBNcgJ1hYk/oYHoFisEgq6J48eJ06NAhw9sCbO9P6OBvc1T1bgoVKiReHooVoyAVkE1zvnx5Uox0BI0y8ndR/z6JDo85dM6dOydekpN6Ns9YFDoF84tjuTTRwFiWnxnZVv25Hlojc5cuXahbt26e5ZRTp6gj2QOsOmfKlaPFmLItXEjxwuLFi8lp8JitM336dJqJrrUWiKrQqVChgng/ffq0l4scy5UqVfK7rRq5rN1eDaZe6v37aDp5eaQ8/TQpJUoQnOIly5en5DVrDAkYtQhUpACcOJE6dOpE8QCefLgQ27ZtK0IWnACPuUDI+2vTpg1NnDjRS9Mx6kGOqtCBJwrs27ePrrjiCs96LLdq1cpr28qVK1O5cuXEZ2qwjPUVK1b0+z1lypShksHq2vzzD53PyaFVCxdSh/R0Sq5Vy+0C1yvwBeFSpgy5ULBLVY/HBXvThAmUEofuclyITrkBJTxm62Af0rQhl+PCe3XTTTdR0aJFacOGDZ51e/bsEfaZuxDvoiIpKYk6derktS1AjM4dd9whPo9oIui777oLsiOO57PP3O9InYhDgcMwkSSqQqdIkSLUv39/mqaqMTx16lRKS0sTQX9YX7duXY9RecCAAbR27Vr6v//7P7G8c+dO+umnnyhDHRUciURQGfwH4XTjjUSwD+Gd6yIzTOznXo0YMYKuvfZaITgQ/Ico43nz5gkD8bFjx4TAkVbyevXq0dy5c+m5556jMWPG0PPPPy9idyCY7ADfAwOZxyqfnwiayNqMz5gdAI85urgUJD8lKCdOnKCLLrpIxPEEtekQ0ZEjR4R96PDhwyJA0QnwmHnMkb7Xoq7pMAzjLFjoMAzjrCzzcCJnjlD9jCCjKvHuFFcqj5nHbAfyHjNirUlom87evXupKir7MQwTERDyos2PdJTQQeb5/v37RTSyNn2CYRj7gBiBFoXMgGAxcwktdBiGiT3YkOxgEAMFFyfjHPLy8kRQbTRhoZOvGo4bN04EHQ4ePJj69OljKlU/Xvj000/FNFO+UFtaxlR8++239NBDD4nysXfffbcoDRuvrF692id3T6bMoDLla6+9Rvfcc4+IbleD+tz4DfB5r1696P3336d4H/Pp06epdOnSnnOenJws7C5RHTOmV05n1KhRSuvWrT3LQ4YMUTp16qQkGp07d1Y+/PBDz2vdunVi/cqVK5UKFSoox44dE8tLly5Vqlatqhw9elSJJ06ePKl89tlnSu3atWEy8Prszz//VMqUKaPs2LFDLP/vf/8Tyzt37hTLZ86cUa6++mrlo48+Esvnzp1TLrvsMmX27NlKvI4ZvP3228rgwYM953zGjBmKJFpjdrzQOXLkiFK0aFHPDw927dolTuCqVauUROHHH38UF58eTZo0UXr37u21rnr16spLL72kxCMYp/YG7NKli9eDBbRs2dIz7nfeeUdcB2fPnvV8PmzYMKVmzZpKXl6eEo9jBu3bt1dyc3MVPaI1ZsdPr8zUaY5n3nzzTXr55ZepYcOGIm/t7NmzYj28e0ia1as9Ha/jxxTCbH3tL774QuTwqess4XOUydVWNoiHMQPUz/nmm2+ERwkmgz///JPURGvMjhc6Zuo0xzPNmzenRx55ROTewHaFTP5Tp04FHP/WrVspOzub4h0j9bXxO+h9DuL1OihSpAgNGjRIdE2Breaaa67xtHoC0Rqz44WOmTrN8czjjz8umhTCc4HeYr/88gsNGTIk4Phzc3NFomC8Y6S+NrYJ9Hk8kpaWJrRbtHNasWKFSMjs0aOHJ9M8WmN2vNAxU6c5EUAI/PDhw4XHYvbs2SHVno4XjIwRr0T+DVq2bCmmU/BWwdMFojVmxwudQLWXA9VdjnceeOAB8TQLNH7M9ROh9IOR+trYxkr97XiiWbNmYqoltZhojdnxQkddp1kNllE0LFEpVaoUlS9fXhgSU1JSdMdvV3G0aGOkvjauA73PQSJdB6XyzzuI1pgdL3TM1GlOJDDe9u3bi6L1N9xwg27t6UQZv5H62p07d6Y//vjDqy8UPq9du7ZoXZ0IZGVliekVnAogamMOmzM+jhg0aJDSrl07zzLiU9LS0uIiPsMIy5YtU+666y7ll19+Ecv//vuv0qZNG2Xfvn1iedGiRUr58uWV48ePi2XEJyFw7sCBA0o8MnDgQBGzoo5P2bRpk1K8eHFl9+7dYhlBgsWKFVP++OMPsZyVlSXiUxBoB7Kzs0XA3ZQpU5R4HPPZs2fFOX/rrbc81/GAAQO84tGiNWZO+MzPR4FHBzVBEDIOF+qECROEFpAIwFN1//33i4L23bt3F/P1hx9+mC6++GLPNjNmzKCvv/5aqNV42r3wwgueqWe8gCc2Yotw7Bgr3rt27eqZKixZsoTee+894TrGb4LfoHXr1p6/x3kfOHAgXX311cLNjpimvn37UjyOuU6dOuJ94cKF1KRJE7ruuusoPT3dJ1UiGmNmocMwTERxvE2HYZjIwkKHYZiIwkKHYZiIwkKHYZiIwkKHYZiIwkKHYZiIwkKHYZiIwkKH8aFnz56iKBQCxZAmImvs4v8INEPaiAwcHDt2rKjBgto80QBBjaHUs8Zxz5s3z9ZjYgLDQofxAQJm2bJl9Ouvv4ooXkSrAvwfVQa3b98uEgdBjRo1qGnTpl7V5yIBYlr79+8vMqXR18wqqB+DfYwcOdLW42P8w0KH8eGKK64Q9Vf8gTSKjh07iv8jYRJ1eSLdnnfEiBEijUOdxhBKyQcUs5o5c6Ytx8YEhtMgGN18HrUQufHGG2nlypVefarV26DCoF6N3nCBWr84pt27d1PhwoVt2SdqRl955ZVCk5OlH5jwwJoO44MRrQXbIEEQyYLVqlXzrEdCZbt27UQheNTnxfQLGgmKhK9bt446dOggymZmZGR47e/zzz8XiYYotwB7EYScP9544w0hdNQCZ+rUqWJaCEGktk2hyL7ko48+Ev2dYIfClEpdBxj7gg0LJV2ZMBPWHHYmIUCrFr1LJTMz06f1CcpjlChRQmnRooXoNQW6du2qVKlSRZk2bZpY/u6778TfyM9Xr16tPPvss559oC1MqVKlRE8nPbCv4cOHe61DTyfsE+2DJA888IBopSN7PFWsWNHzGXo7/frrr177QL+zevXqmfx1GLOwpsNYBl6tmjVreq1Dx1BZGAzFoAC0kr1794ryGqBFixbifcuWLR77DMoyQGvCC9M1VC3UVrUD8FRhX7IEqVEwHUSR+bfeekss33rrrVS9enWvbVBBEMck2/Mw4SElTPtlGA9az5ZcRv0iAC/Zxx9/LKZlwZC9180WDoeHCwXpn3jiCVE36J133vGaesmWLaitBOGEEqdMeGBNh4ka0jCNMpooJqVFtkpRI1umWIkLgo0Jnjb0e6pfvz798MMPXp9DwwJ2GacZfVjoMFFHNoODliFBLBC6cupN6eBdOnbsmO6+1N0N1Ps7ePAg/f7773TnnXeKJoIQOjAqqzl69KgwcidCB4xYhoUOExQZ8QuNRIss6q3uBCo1Bu3Nj/a+6s+lpoNGgPBsdenSRTSFQ5TxU089JewuemAatnnzZp/1mHKhzCwK63/55ZfCtS61JWhGkydP9ky1UHRe22YF2pa2nCcTBkybnhnHsGfPHmX06NFKSkqK8Aw9/PDDyk8//eT5fN26daLAOz6DF2vv3r3Ci5ScnKxcf/31yoYNG4SH6vbbbxfbYF9Hjx5VxowZI5ZvueUW8TkKh8NzhOLwJUuWVO68806xL3+gcHylSpW8CudPnDhRGTFihJKamiq8Zyi2j++vUKGC+N4tW7YoSUlJSt++fZV33nlHefDBB5XDhw977bdu3brKN998E6Zfk5FwcCATt80CEQ2NuB6A/uyIF4LWZAWkfSD+h/Owwg9Pr5i4ZOLEicID9e+//4pluNzhBbMCvFXYH4IHmfDDQoeJS5CoiVwpRBDDeAwjMGw5ZoGtBwLngw8+EEZkJvzw9IqJa3D5Iv3h+eefF4ZqrUfK6N8zkYOFDsMwEYWnVwzDRBQWOgzDRBQWOgzDRBQWOgzDRBQWOgzDRBQWOgzDRBQWOgzDRBQWOgzDRBQWOgzDUCT5f/KKLWw/avjgAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "n_ions = 9\n",
    "N = 300\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 6.38 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_ions = 9\n",
    "N = 400\n",
    "\n",
    "def pe_model_optimized(time, rabi_0_fit = rabi, nbar_fit = nbar, nalpha_fit = nalpha):\n",
    "    ndisplace_fit = complex(0, np.sqrt(nalpha_fit))\n",
    "    intensity_distribution = np.array([0.96912696, 0.9844114, 0.99344862, 0.99840835, 1., 0.99840835, 0.99344862, 0.9844114, 0.96912696])\n",
    "    pe_fit = np.zeros_like(time)\n",
    "    diagonal_elements_all = np.zeros(N)\n",
    "    for k in range(len(intensity_distribution)):\n",
    "        if(k < 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += 2 * diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += 2 * diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "        elif(k == 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "    return pe_fit / 9, diagonal_elements_all / 9\n",
    "\n",
    "def pe_model_optimized_fitting(time, rabi_0_fit, nbar_fit, nalpha_fit):\n",
    "    ndisplace_fit = complex(0, np.sqrt(nalpha_fit))\n",
    "    intensity_distribution = np.array([0.96912696, 0.9844114, 0.99344862, 0.99840835, 1., 0.99840835, 0.99344862, 0.9844114, 0.96912696])\n",
    "    pe_fit = 0\n",
    "    diagonal_elements_all = np.zeros(N)\n",
    "    for k in range(len(intensity_distribution)):\n",
    "        if(k < 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += 2 * diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += 2 * diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "        elif(k == 4):\n",
    "            eta = 0.23/np.sqrt(n_ions)    # LD parameter\n",
    "            eta_squared_laguerre_values = [laguerre(i)(eta**2) for i in range(N)]\n",
    "            inputstate_fit = displace(N, ndisplace_fit) * thermal_dm(N, nbar_fit) * displace(N, ndisplace_fit).dag()\n",
    "            diagonal_elements = np.abs(inputstate_fit.full().diagonal())\n",
    "            diagonal_elements_all += diagonal_elements\n",
    "            for i in range(N):\n",
    "                pe_fit += diagonal_elements[i] * np.sin(intensity_distribution[k] * rabi_0_fit * eta_squared_laguerre_values[i] * time)**2\n",
    "    return pe_fit / 9\n",
    "\n",
    "# Wrapper for curve_fit\n",
    "def fit_model(time, rabi_0_fit, nbar_fit, nalpha_fit):\n",
    "    return pe_model_optimized_fitting(time, rabi_0_fit, nbar_fit, nalpha_fit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.19579199998431665\n",
      "nbar =  1.893232511519885e-10\n",
      "nalpha =  277.12627343641685\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30516\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 200), (0.11, 2, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 5.90 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.14057883220983147\n",
      "nbar =  7.135256133998461e-11\n",
      "nalpha =  213.9525154036317\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30528\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 100), (0.11, 2, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 4.80 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.10999999999459224\n",
      "nbar =  1.4931904886376721\n",
      "nalpha =  175.6580421450941\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30574\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = []  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 10), (0.11, 30, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 4.763 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.09000000000000001\n",
      "nbar =  3.358927415040481\n",
      "nalpha =  122.03011096610992\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"19\"\n",
    "number = 30424\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [9]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 10), (0.11, 30, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 4.762 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.09000000000000001\n",
      "nbar =  2.2785340035464827\n",
      "nalpha =  123.65452969534654\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"19\"\n",
    "number = 30412\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = [-7, -8, -9]  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 10), (0.11, 30, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/qutip/core/states.py:486: RuntimeWarning: invalid value encountered in log\n",
      "  beta = np.log(1.0 / n + 1.0)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 4.759 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.09000000000000001\n",
      "nbar =  5.947489358047152\n",
      "nalpha =  142.41350044870174\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"19\"\n",
    "number = 30444\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = []  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 10), (0.11, 30, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 4.5 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.09000000000377846\n",
      "nbar =  1.770662802041944\n",
      "nalpha =  230.85008212327182\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30576\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = []  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.3\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 10), (0.11, 30, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 3.846 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:571: RuntimeWarning: overflow encountered in multiply\n",
      "  - (n + alpha) * _ufuncs.eval_genlaguerre(n - 1, alpha, x)) / x\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:192: RuntimeWarning: invalid value encountered in divide\n",
      "  dy /= np.exp((log_dy.max() + log_dy.min()) / 2.)\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:193: RuntimeWarning: divide by zero encountered in divide\n",
      "  w = 1.0 / (fm * dy)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitted parameters:\n",
      "rabi =  0.10999999999901375\n",
      "nbar =  1.6752530279901539\n",
      "nalpha =  152.67749696743826\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"19\"\n",
    "number = 30466\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = []  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.1\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.09, 0, 10), (0.11, 2, 300))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR0AAAEWCAYAAABbrUO4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/GU6VOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABFCUlEQVR4nO2deXgT1frHv5M0TXfowmIpS1kuagFBQBZbkV1ARApSEa8gF8EVEP1dKkIRKYpwWbWIyr1SvEpBLIugaBGFolwECoIiilCwFKHQUpqmbZrl/P44nTQz2SaTNGna83mePjBnJpNzsnxzznvehSOEEDAYDIaXUPi6AwwGo3HBRIfBYHgVJjoMBsOrMNFhMBhehYkOg8HwKkx0GAyGV2Giw2AwvAoTHQaD4VUCfN2BusRkMuHKlSsIDw8Hx3G+7g6D0WAhhECj0SA2NhYKheO5TIMWnStXrqB169a+7gaD0WgoKChAXFycw2satOiEh4cDoC9ERESE0+tLSkoQHx+P/Px8REVF1XX36gVszGzMnqCsrAytW7c2f+cc0aBFh19SRURESBIdvV4PgIqVlOsbAmzMbMyeRIoZgxmSGQyGV6k3onPo0CEMHDjQ6XXnzp3D1KlT8a9//QuPPfYYPv/8cy/0jsFgeAqfL6/Ky8vx+eefY9GiRfjtt98cXnv9+nUMGjQIn3zyCZKSklBSUoLOnTtj9+7d6NOnj9t9UavVSElJgVqtdvte/gIbc+OgPo3Z5zOdsLAwTJw4EY888ojTa1esWIHAwEAkJSUBAKKiojBq1CjMmzfPI31Rq9WYOHFivXhjvAUbc+OgPo3Z56LDo1QqnV6TnZ2Nnj17Ctp69eqF7777DtevX6+rrjEYDA9Sb0THGVVVVfjjjz+sfADi4uJgMplw6tQpH/WMwWC4gs9tOlK5efMmCCEIDQ0VtIeFhQEAioqK7D62pKTEvGUI0KmmrWkmf43ltQ0dNubGgafHrNPpoNPpzMcajUbyY/1GdAIDAwFY+wHwx/x5W8THxwuOU1JSMHHiRLvX5+TkyO2m38LG3Djw1Jg3b96MLVu2yHqs34hOVFQUAgICoNVqBe38cWxsrN3H5ufnCzwlHc10cnJyMHToUKhUKg/1vH7DxszGLIfBgwcjIyPDfKzRaKx+3O3hN6LDcRy6deuGwsJCQXthYSECAgLQuXNnu4+NiopyyQtTpVI1mg8jDxtz48BTY1apVGbTBn8sFb8xJAPAmDFjkJeXJ2g7duwYBg0a1GhiaBgMf6feiA5vlDKZTOa2ffv2oVOnTvjll18AADNmzMCNGzdw+PBhAMCtW7ewc+dOvPzyy97vMIPBkIXPl1d6vR5bt27F5s2bAQBpaWl49NFH0aVLF5SVleH69etmu02LFi3wzTff4M0338TBgwdx+vRprFu3DkOHDvXlEBgMhgv4XHRUKhUmTZqESZMmWZ1LTk5GcnKyoK1Hjx7YunWrt7rHYDA8TL1ZXjEYjMYBEx0Gg+FVmOgwGAyv4nObDsMNVq4EysqAiAhgzhxf94bBkAQTHX9m5UqgsBBo1YqJDsNvYMsrBoPhVZjo+CtGI8BH+ep09JjB8AOY6Pgj2dlAu3bAjRv0+MYNepyd7cteMRiSYKLjb2RnA+PHA5cvC9sLC2k7Ex5GPYeJjj9hNAKzZgGEWJ/j22bPZkstRr2GiY4/kZtrPcOxhBCgoIBex2DUU5jo+BN//eXZ6xgMH8BEx5+47TbPXsdg+AAmOv5EUhIQFwfYqxfNcUDr1vQ6BqOewkTHn1AqgTVr6P/FwsMfr15Nr2Mw6ilMdPyN5GRg2zYa+mBJXBxtF+UfYjDqGyz2yh9JTgbGjAFatqSOgTExQH4+m+Ew/AI20/FXlEqAL6OjVjPBYfgNTHQYDIZXYcsrf2bOnNp8OgyGn8BEx59hOXQYfghbXjEYDK/CRIfBYHgVJjoMBsOrMNFhMBhehYkOg8HwKmz3qiHCStMw6jE+Fx1CCFatWoVr165BpVLh6tWrWLVqFcLDw21en5WVhSNHjiA6OhpnzpzB448/jpEjR3q51/UcVpqGUY/xuegsXboU+/btwzfffAMASEtLw6RJk7Br1y6ra3NycrBixQr8+OOP4DgOZWVl6Ny5Mw4fPox27dp5ued+RFkZsGsXcPQoUFICNG0K9OgBjB5N/89geBGfik5JSQnS09Oxfv16c9vUqVMRHx+P3NxcJInywuzevRtt2rQBV5PGISIiAm3btsWxY8eY6NiCECAtjc58tFrr84GBUEyZgsDERO/3jdFo8akhee/evaioqEDPnj3Nbe3atUN0dDS2bt1qdX1MTAxycnJQWFgIAKiqqsL58+fRtWtXr/XZrygqAhYvti04AFBdDeX772PQCy+AO3jQu31jNFp8OtM5ffo0ACAuLk7QHhcXh5MnT1pdP336dKxfvx4DBw5EZmYm1q9fjxUrVqBz584On6ekpAR6vd58rFaroeYjtC3gr7G81h8J0OvBAYDBIOl69a1bICNGwPDuuyBPPFGnfasPNJT32RU8PWadTgcdX+wRgEajkfxYny+vACA0NFTQHhYWhqKiIqvrW7RogX379mHo0KHo378/5syZgyckfEni4+MFxykpKZg4caLd63NycqR0v16i0mjwwI0bECc0JQoFrvXoAU3r1gi9ehUtjh+H0uIDyOn1CJg2DXk//YSCwYO922kf4c/vs1w8NebNmzdjy5Ytsh7rU9EJDAwEALONhofjOPM5MX/++ScGDx6MixcvYuXKldBoNHj//fcdPk9+fr5gN8zRTCcnJwdDhw6FSqVydTi+R6+HcuRIKEwmQTO5804YPvoI0V27IrqmzXT5Mrhnn4Vi717BtT3WrUO3oUNBHnjAS532Pn7/PsvA02MePHgwMjIyzMcajcbqx90ePhWd5s2bAwC0Wq1AFLRaLWJjY62u/+GHHzBnzhzk5eVBpVLhxRdfxNq1azFgwABMmjTJ7vNERUUhwoX0DyqVyj8/jJMnAwcOCNtUKnCpqVDdfbewPT4e2L0bxpdegpLPuwyAMxoRMHEi3em64w4vdNp3+O377AaeGrNKpUJYWJjgWCo+NSR3794dAMyGYZ7CwkJ06dLF6vp33nkHw4cPh1qthkKhwOrVq9GvXz9s377dG92t37z9NrB5s3W7Xk/FyFa5YaUSpuXLce7hh4XtWi2QkgJUVtZJVxmNG5+KzpAhQxASEoK8vDxzW0FBAYqKijB+/Hir63U6HYwWJXM5jkNSUhIUikYezWEwAC+/7PgaB+WGzzzxBExiG9fp08yxkFEn+PTbGhwcjNmzZyMzM9PctnHjRiQmJqJv377IzMxEQkKC2ag8YcIE7N69G1VVVebrf/zxR5sC1ahITweqq+2fd1ZuWKGAcf16QOx6sH49UOO0yWB4Cp97JC9evBhpaWmYOXMmIiMjkZ+fj507d4LjOJSWlqKoqMi8NZeSkgKNRoPHHnsMXbp0QXFxMSZOnIgJEyb4eBQ+xGgENmyQdq2jcsPBwcCWLUCvXkBFRW37jBnAqVNASIh7/WQwavC56CgUCqSnp9s8N2vWLMyaNUvQNm3aNEybNs0bXfMPsrJonJUUnJUbvuMOYPly4LnnatvOnwcWLQLeekt+HxkMCxq5McTPMRiA115zfp0r5Yaffhq4915h28qVwLlz1teuXEmff+VKKb1lMAAw0fFvdu0C/vjD8TWulhtWKIAPPgAs/aQMBmDuXOtrV66ksyAmOgwXYKLjz6xdKzzu0MEz5YbvuIPudlmyfbu1DxCDIQMmOv7KyZPWIrBoEXDpEi0zDNSWG5ZT33zevNr78MyZA4i8nRkMV2Gi46+8/bbwuGVL4JFHPFduuEkTKmKW5OUB//2vvPsxGDUw0fFHbt0CPvlE2PbMM0I7jCeYPt06FGLhQsc+QQyGE5jo+CNbtwIWDpJQqag/jacJCAD69xe2XbwIWDhzMhiuwkTHH9m4UXj84INAixZ181xffmnd5swDmsFwABMdf+P334EffhC2TZlSd8/HiTPzAPjzT+oFzSdx0unsxnUxGGJ87pHMcJFNm4THzZoBI0a4fVvF6tU0utxe2ZrAQOHsZubMWqG5cQNo1w5Ys0beThmjUcFEx58gBPj4Y2HbpEnUpmPJnDm1da8kolizxnHZmogIKi484plNYSEwfrzrPkGMRgcTHX/i+HFqyLXEVrrWukhJoVYD990H2EvgTghdis2eDYwZI3+rntHgYaLjD/AVO8Vf+I4dgZpEaF5hzBj7ogMIU2jcf7/XusXwL5jo+AN8xU7x7OGRR2wbep3dS27J4ZYtpV3nKIUGo9HDRMefENtRHnnE9Xu4U3LYRt5qmzhLocFo1LAtc3+lQ4e6X1oZjcJt8f79rQNKLXElhQbDqyhWr0bnzZvpLqWv++LrDjBkMn68/aUVX8+qooJug0ssuicgO5tug/M7VjduUKF77DHHj5OaQoPhVRRr1uD2LVvoLqWv++LrDjAkYEs0xBUc+OuKi2kVB0Kob41SSUVIr7dfXlhMdjYVtcuXhe2FhcC//kWXZWJhCQpi2+UMSTDR8Qcs46wAmnKid29hW0UFFYKoKGok5jgaOxUURPMfq1Q0QZet1BSWy6iqKmDWLCpaYvi2Tz8Fli617mPHjvLGx2hUMEOyPyAWnREjhDON0lIqKs52soKDqfAAZgHhtm/HsGefBVdcTNv5f+3Bb4snJNDnsxSnZctY6gtv4M4OZD3A4zOdlSx1pWfRamtnITyjRtX+32SisxlRPXhJfPQRlI8+iiBnQmOL0lLAosIjAJokPj/f/mNYTmXP4OdpYmWJzrfffou7774bwcHBUCqVgr//+7//83QfGzfigvdKJTB8OP1/ZSWNhwoKknfvefMAQuCipw/lttushc5oBFassP8YP/+yMDyDrOXVE088gV69euGZZ55BoEXiKJ1Oh4/FsUEM+WRnW4c5KJXA/v3AQw9R0YmKkn4/S9tNeTlQVua64HAczbuclGR7l+rf/wbS0oCaOvUMhhjZNp1t27ZBaeNDN2TIELc6xKghOxsYN866vbqa7ixt2eLaTlF2NjUQ81vgZWWu90lKZYmqKpow3k4tMwZD1vIqNTUVB+3E4Fy5csWtDjFAZySiIoNWuGJAtLcF7ir2KkuIq39mZMgTNUbdIHby9HHuI1kznT///BPvv/8+evbsKWgnhODQoUM4Z6swWx1QXV2No0ePQqvVYtiwYV55Tq+Qm+tYIAih56UEVvICZmsLHAABbC+xOI56H1dW0h0tvrKErRlOWJiwFHFpKfD++8DLLzvuG6PuqZnhcjUzXK4e5D6SJToXLlwAIQT5op0Kg8GA69evu3QvQghWrVqFa9euQaVS4erVq1i1ahXCw8PtPkaj0eC1117D6dOnkZqaisGDB8sZRv2DFwapAZNSrnMiYHYFB6AfzJkz6f9tVZawzNuTmwvs2FF7btEiKnhz5ljn+2F4B36GK/7B8XXuIyKDvXv3EqPRaPecK7zxxhtk0KBB5uMFCxaQ0aNH272+qKiI9OjRg0ybNo3o9XqH97516xYBQG7duiWpL9XV1WTHjh2kurpaWuc9hclE/27eJKS4mJAvvySEflQc/337rfN7f/KJtHtZ/sXFEZKVRR/fqhVta9XK8fMcPmx9n6ZNCSktpeMymaTfq47x2fvsCQwGQmJi6OsYE0OP7V0XF2f/PeY4Qlq3tv94F3HluyZLdHjOnTtHtm7dSnbs2EH++usvlx9fXFxMQkJCyKZNm8xt+fn5BAA5ePCg1fUmk4kMGjSIdO/eneh0Oqf39xvRKS4mxFJALT9Y7n5gvv1WktCYIiJqP8h6PSE3btB/XRGKAQOE9w0IoH3U6ZjoeILPPrMWkrg42i5G4vsu6YdLAq5812QZkvV6PR5//HF07twZKSkpGDt2LNq0aYMXX3zRpfvs3bsXFRUVAttQu3btEB0dja1bt1pdv337duzfvx/z588XbNX7NVot9bMJsFjpKpVAYqLt612tTZ6URA3AdryVCcehIiam1tFPraZ9iYy0aweySUVF7VKMx2CgS67AQGrA5D2r64Ex0+9wFA83fjw9b4knl+geRpbozJ8/H4cPH8batWtx6NAhnD17Fl999RU0Gg2WLFki+T6nT58GAMTFxQna4+LicPLkSavrMzMzoVAo8MMPP2DgwIGIjIzExIkTUVpaKmcY9YPgYOvdHwC4ds329a7WJlcqqW0GsBaemuOf//EP63MKBX2slDLChFAhGTsWuOsu4bmlS4HPPgM6daoNseCNmeIvCsM2jjYD+LbZs2kwLu/xLTWnkQ9yH8kyJP/444/46aefEGbhBv+3v/0NAwcOxMsu7FiUlJQAAEJFnq1hYWEoKiqy+bxt2rRBamoqmjVrhnPnziEpKQnPPvssPhFXvBQ9j55P9wBArVZDzZfetYC/xvLaOkWjobMcsaG1rAwBP/5oZeQlMTEw/P57beS4VEaPBpeVBeWcOeAKC2vv16oVqpctw18hISAffQQOdDfLYHHvAI6z2S5Ar6czJYMB3MsvI+Dvf689d+wYyPjxAIRGa1LzC23MygIZO1b6WDyA199nN+EOHECAs93MggKQt94Cd+MGSKtWMPzxBwJatQKuXAFnQ6xIze6koW9f1z5LNeh0OugswnM0Go3kx8oSncTERIHgWGKS8stYA79E4kS/shzH2Vw+FRcX4/nnn0ezZs0AAJ06dcJTTz2FJUuWICMjA5GRkTafJz4+XnCckpKCiRMn2u1Xjjj0wMu0OHoUfS2WH/y2dhUh+Pqrr+TdVK0G1q7FA08+CXVZGXQREdi7Zo15iabT6RAMoKqqCl9/8YX5YcPstNuDCwnBgwoFFKLPgVhAOUJAAFQ/9xxyAgJ8koPH1++zVFodPIheEq7TV1UhEDXv1Vdf4bbHH0fvt96ycosgAEAIjk6ahL9kfp42b96MLVu2yHqsLNG5fv06DAYDAgKED9+8eTOOHj0q+T7Na1zltVqtYItcq9Ui1kZqzKZNm1p5QXfr1g2EEJw/fx69etl+a/Lz8wX3dzTTycnJwdChQ6Gq621ek4naPGyIq+Lbb4UNNTWngoKCMHLkSLeeNiA8HCgrQ2B4OEaOHm0eM/96iJ9DMXcujGVlCFSrMXLQIOs4r5s3gSZNaqPXAXAREdRXhz+20xcOQMiNGxgVEQEyYIBb43IFr77PElCsXm12PTDNnm11ngsNlRSvpgoKAsrLa9/DkSNhvPtuKOfMobYfnrg4GFesQI+xY9FDZp8HDx6MjIwM87FGo7H6cbeHLNF5+OGHcccdd2DEiBEIDQ1FQUEBDh8+jMuXL+MLCb+GPN1r0m0WFhbi9ttvN7cXFhZi4MCBVtd37NjRatnVpEkTAHDo1xMVFYUIF2pAqVSquv8wVlTYjwwXiQ6nVgPV1eBq+uYJxPfiZ5tWz2ERwKu8ebPW1gPQaX2zZtb2oJAQgeg4I+D6dZ/48njlfZaCRc0xpa2A6YEDqS2vsNC2XacmHo6rmR0L3sMJE4Bx40BatqRLr5gYcBcvIsDNmaVKpRKsdlx5HWUZkh944AFkZGTgxIkTWLNmDXbu3In27dvjm2++cclRb8iQIQgJCUFeXp65raCgAEVFRRhfYwewJDk5Gd9//72g7cqVK4iOjpassvUCo9F+LfDr14FTp4Rt9WWnjl++8pkMS0utvwSOxmYPlsjdMRI2A7B6tf18SkolXV4Dtp08vYzsfDrDhg1Dbm4uKioqoNFokJOTg8TERBhcyMcbHByM2bNnIzMz09y2ceNGJCYmom/fvsjMzERCQoJ5dvPkk0+irKxMsBbfsmULUlNT/WsLXaezn45CHNMWFlb7galDTLNmAQsXSovpunWLCgvHCZZVVnmVncESuUsnOZnuWooT47u6m1kP8HjmwI8//hiTJ0+WfP3ixYuRlpaGmTNnIjIyEvn5+di5cyc4jkNpaSmKiorMVvLo6Gjs27cPr7zyCnJyclBWVoakpCS89NJLnh5G3RIcbP9XKTdXeNyvH3DmTJ13yTR7NpRSpshKJbXhlJcLk3jZc7m3h6v+Rr6Gr2DqTcQZApOTacHDli2psDuKhxPjis9VHSNJdMaOHYsePXogLS0NJpMJDz/8MMrLy62uq66uxqlTp1wSHYVCgXQ7aRBmzZqFWaJo627dumHPnj2S71/vIIQuS+zstFmJTv/+taJTXz44SiW1wVRVUbuUyeQwqNQmcXHAqlXAgw/WXT/dpbqaiivvR6XVUsdJPgd1XWOrRpmcpZJWW38+O5AoOoQQGGuMVAqFAtHR0dBqtWjTpo3gOr1ej4KCAs/3siGh09m30ZSVAWKnyIED6Ye8rIx+4H3xiyumsrI28fvNm8BPP7mWNqNJk9pf6OJimojM3ph8mQ9YpwOaNq1dQgYFUXuWyURtV/VpSW8rfQXv3Gk0CpfBPkaS6OywjB4GMG3aNPztb38z+8tYsnv3bo90rMHCzxJscfiw0ANYpQLuuQfgt5MrK6kjlzsfdsvIcLkYDEB4OBUKjgNczaFUWVn7Cx0U5NjG5U5FUrmUldFZhK0dUV74b92iy8v6IDziBG28x/eKFbRUkTvvdR0gy6Zz8+ZNm4KTl5dn0/+FYYHBQG06thAvrXr1El4bHOx+zJK7X1yTiX7Z+JlJYKD0Guc81dXA3r3AAw/YDgHxJVotHZujzzHH0eVxRYXvRcdR+opHH6XlgmxloPQhsuZc9rIGdujQAS+88IJbHWrQGAyOt5PFomNrV6esTFo8VF1hq2Lo/ffTmYijZZ/Y9vDyy/Q+HEfDQZYv932lCJOJCrsDny8zHEftWRqNe/YSd7L6EeI8JuvFFwGjEaZZs3A2JYXuUvoYyaKj0+kwbdo0tG/fHh988AHat28v+IuPj8dtt93m0pZ5o6O62v4vqE4HHDkibLvvPuvrgoKs62B5k+pq6193pZLmRQZs+5FwHPD008L2X36hSdwBOttZvdq3lSIIofYpV+1lajVdajnDVvkdW6WbXQmEra52nmGyoADIzYVp9mz8NnGiTY9nbyN5eaVWq7FhwwakpqYiNzfXKj0ox3GIiorCWC8H7/kVjpYSx44J61txHHDvvdbXBQX5Ni1EjQe4FbwfyaxZwi9CXBwVlIcfpilMLYML09KAiRPrh82hrKzWTuUKgYH0/XBm4BfbpqRk9XOG1M+BD9JXOMJlm87SpUvxyy+/ICEhwepcaWmpza10Rg0lJfZLxoiXVl270p0TMRxHxUmp9P4uluX2sS1s+ZFcuFCbK6hJE6HjYFER8Oab9M+XO3KEUMGRu8MTHExfm9BQaeNwlqqC42iqCmfLNqn+TfXM41uWITkhIQE6nQ7Xr18XRJVfvnwZL774Io6IlwkM59uWUuw5PBxHl1j2DNJ1hU5nXdVTjNiPhN/lUattLy1XrLCu7eVtHP0YSEWlovYdKbM2KYn3Cwpq72W5BQ7U7kCGhdXGbTmIyUJSkm/tgCJkic727dsxefJkaLVaq3Nt27Z1u1MNEkLsi4TRCIhiyhyKTlAQNeh6E6NRXiXRqChqe3CUi2fGDN85r1VU0HG5O9NSq6XnpZG63OHL+IgrOFjuQLZvT5dj4rryYo9vfxedDRs2IDMzEyEhIfj2228xYsQIGI1GbN++HU+LDYYMislkf3v155+tjZGOREehoFN5bzoKEiKvXjq//WwwUGNyeTnw44/CSPrcXNtLSXsOb55EpfJchDtfiseZG4Cc5c7ly3Tre+FCoE8fKnB6PX1dX3wR2LiRzth4YmKAZ5+l/x45AigUCCsoAC5dAjp2dP35PYmcJMzr1683/3/ZsmXEZDIRQgipqKggo0aNknPLOqFeJWYvLrZ/7u23hcmy27d3fr/yckIqK93uluQx37gh/aaOErAbjYRoNIS0bWudbB4g5Lbb6DWuJCF3EfOYS0sJ8fR7XVZm+32xfE2cVWqowz9Tu3aeHW8NdZ6Y/eeff0ZWVhb+/PNPDBs2DE899RR+/fVXZGVl4VtxAiqG86WDK/YcnqAg6tnrDXQ6z0W6KxR0RvDuu8J2y9coK8u1JORyqaryfB6fsDDhLiQPv7zRaOhOnrfeOzG+dmaEzOXVhAkTMHbsWMyePRvz589HixYtkJCQAI7jkMTSFFjDcfa3mgkBDh0Stkl5DZVK50ZdT+HJJQjPiBF0u3zzZmF7WRl1HHS2szNmjO2lFv84jqNfdP7LHhBAbUuECNt4m051da2zoqXTX2AgfR6+gmloKL2WT+3RpEltwrLAQPo6GY00NOTcOep5nZNTa8cpKwN8GSpUDyIGZIlOUlISblhsfS5ZsgQPPvgg/vrrLzzwwAMe61yDobLS/pe2oMA6dsle+RkxhNh21vMkhFA7TF340qxaBezZI6x7rtU6NpLzOztffgmMGkUd+gBqpFcoasMYIiLoTIbfNeTFwtLgGhhYu6PIuyDwNjLeaK5Q1M7O+OOgIKFRnX9t9Hrgq6+ArVuBXbukOQ3KoVkz2h+VqjYWzGgEzp+vtXu1aEFFVK8HdDqQ6mpwBgNIYKDd9LHeQpbobNq0CU+Itjn79euHEydOYPv27Zg0aZJHOtdgqKqy/wtz+LDwOCoK+NvfpN1XqaS/yHUpOrxPUF3w/fdCwXEFjYYKhHir2/J1Fhu+eeHgDa6WlTjE7gziHwnL10BsvD9xAli3jpbacVVoeLEzGKgBOiDA/mvCb4HzEfriNCl8StOWLa2Wpga9Hl98/jlGDhsmP3Ofh5Bt07FFcHAw5s2b51aHGiRKpX0fHbHo9O0rfUfKGw6CcrbK58xxnoWQd5CTi1yHN96k6i46HfDxxzTJWq9ewH/+47rgrFxJZ2YtWtDjyEjgww+FMy4eW0nPystd89Wy9KHyIS7FXk2dOhVKpRIrVqyAUqm0+ktISLAZfd6oIcSx7UUsOv36uXb/iIi688EgRF5O3TlzaJyRI9Fx5iBnD3dTnBoM7i0VCwuBBQuANm2Axx8H/vc/effhOLq8FFVUcSktaWCgPN8pH+NS7NV//vMf3HPPPfj8888xYcIEwXk+9mrQoEEe76RfU7Omthm5XFVFp+aWuCo6RiP9tbRnqHYH3jdG/MXwBHLigdxNcWowWKdZdQSfQCw8HOjdG3jnHbpz5izm6d57ge7dAYsSLVZYBGNaISUtqbOQlHqMy5+mp59+Gg899JDNulQAWJS5GL3evhH5+HGhFyvH0Q+3KwQEWKea8BSVlXUjZoC85REfPCo3CXl5ORUQqcurf/2LiqOU1zgujjo/Tp5M/795s2PR4bEnvo7SkhqN9HNTj7IBuoKsnzB7ggO4npi9wcNvudpCvLTq0kXe1D8iom68kyMi6u6DnZTkuJaTmNBQYfCoqxBCBZTjnIcrnD9PDcNXr9JjR4IzcCDw/PPAQw8J+1aXtcT1etszZ09khfQCPk/M3uBxNNNx157Dw/uRyAlTsAefUrSudq74Wk624oZsodUCzz0HvP22vN26mzdpqIU9YTaZgK+/pkuoL75w3J+QEBqk+txz9IfCFs5E1TIY0xWqq6m42RJfb+eQlomknzFiIzE7x3Fo27at4K9du3Z264k3Sgixn3CLEM+JjkLh+cRejnyLPIUjo6mtFJvvv0/jjsTFCJ3Bex7bmrVdvUpTa3TqRB0W9+yxLzgdO1Ljb2Eh9ai2JziA9AJ5rog6IdRVwB9K9jiAJWavSwwG+8uBP/+0Xs/LFR2Arvs9FRDJe+J6I5jUltH04kU6jjfeAF59VXj9yZNAz55UfPr2BWJjnf/CBwQIt4q1WsR+/z2UH35IRcaZvUatBnbsAIYNc2256SyxGW+bkrosqq6msyxfVwNxE1kL5HttZLS7evUqWrZsiQfrcx0jb+MofMAdp0BbhIV5LqOgweDZpZoz7BlN582jxlze69iyf99/T/+Cg+nrdv/9tnelNBr6Hvz6K/Ddd8D+/Qj4+mv05sMa7NGkCX09y8upEMr1tBeLalSU9U6UlGWRXk/F089nOYBM58CvvvoKERER+Oyzz8xtBQUFeO211wRJvRo9Go39X1F3nALtwccAuUtZWf35NeW3he3NGCsrgdGjqWPdnXfS4n2TJgGPPUbDJHr1ogLSrRswcyawYwc4R4LTtSvw3nt0CeWpnTtLUZWbu6c+vSduImums2TJEkybNg3333+/ua137944duwY5s2bh6VLl3qqf/6NXm/fJ8RT9hxL1Gr3I8IdGb59SfPmVEzWrrUdxW0w0NnMr7+6fm/ekN2sGS0c6M6X21lxQI6rjQGT+j7xDqZ+ukUuRtYoBg0ahJUrVyI6OlrQ3qpVK2zcuNET/WoY2LOLVFa67xRoCz52xx1UKmklWLwNxwHLltHX7ckn3b6dSaGAafBgOqvh63ZZvl9yS8OsXOm8qoVaTZdtzrbu58wBXnmF/lsPwhc8haxPqK00pQCQlZXlsnMgIQSrVq3CtWvXoFKpcPXqVaxatQrhEj748+bNQ2BgIF577TWXntMrEGLfRT0vT7jsUihoJU93UShqPVXl/CqaTPRX2lYWv/pCfDzdQfryS7rzFBhI+y3lc6dUAkYjSNOm+GrtWgx59FEoVCrg9deF19mrmMmnC3UXvlgfX6LY1ntFCPCPf3g3hYmXkDXTGT58OCZMmIDvvvsOv//+O3JycjBu3DhkZWVh6tSpLt1r6dKl2LNnD9566y2kp6cjNjZWUpT6Tz/9hBUrVsjpvncwGOwnarLlFOip2QWfI0YOlZX17xdVHDwaFCR0uGzWjEaN//ADsGFD7Q5QWBiweDGtrZWbSwWKn9GEhqLa3k4RXxrGWQIxW3WsXEGhoOPQaGigKD+TIqR2hqVWNzjBAWTOdIYMGQKdToeZM2eaI85jYmLwxhtv4J///Kfk+5SUlCA9PR3r1683t02dOhXx8fHIzc21mxDMaDTi7bffRm9XQwa8Cb/bYIu6sOfwBAXRD7Ic+Fwx9QlbdhHLyGre3tG9O93FSkujs7UmTYD58117LmcVMy0TiHmqxnqTJtTGw4c28KWK/TSYUwqyLVOjRo3CqVOnUFpaiuvXr6OoqAipqaku7V7t3bsXFRUV6Nmzp7mtXbt2iI6OxtatW+0+7u2338YzzzyDgLoIRPQU9kqueNIp0B6hodIrE/BUV1N7jj/ukBBCBT4qyr3+u1Ax06NYikxUlLBWfANE1re2qKgIzZs3BwBEiKapr7/+Ol4Xr5HtcPr0aQBAXFycoD0uLg4nT560+ZgLFy6gpKREIFTOKCkpgd7iS6hWq6G2IQj8NXpXv7C20Grpl19sgLx0CSqRU6C+Vy8oli8373q4XfrVZKJTdgne4eYxl5bSpYonxi4DxaxZteN31gejEQE6HTgApLoahupqutwyGBAA0HbQxFWWmM/VzGT0er3wXjX/OsNQUAClneex9/yO+uUNPPrZBk11o7PYRdS4MLuWJTpvvPEGVq9eLWgrKSnBSy+9hE2bNkkWnZKaDG6hIke0sLAwFBUV2XzMm2++iTW8e7lE4uPjBccpKSmYOHGi3etzcnJcur8rtMrNRS+LY114OPaeO4dhb72F4OJiVEZH42t3nARlknPsmNefU4DlmL/4wu5ltx0+jK4bNkBVXAwA4G7cgCEuDqenTcNf/fphWFUVggFUVVXha9F9+HP8l+Xn118X3kviF+d/ly6hp53nsff8HYYNQ0BFBQwhITjvYHx1jac+25s3b8aWLVtkPVaW6Bw4cABTp07FW2+9hWbNmuGDDz7AvHnzoFAo0L9/f8n3CawJ3ONEU0mO48znLPnwww8xYcIEhLiYRyQ/P1+wG+ZoppOTk4OhQ4dC5Y6vCiG1dgURyuXLBceqpCSMHDUKATXr96CgIIwcOVL+c1v2AXA6TffYmL0At307lMuWWdlcgkpK0HvZMhizsqB08Dryr7FarcZthw+jt4178Ue2XjXCcUCrVujz8ssIqLFDCp7HaERAzesdxHEYOXx4rcHboi+dXR24B/D0+zx48GBkWKTu0Gg0Vj/u9pAlOjk5OSgrK8MjjzwCrVaLkydPYvr06ViyZIl56ioFfomm1WoFoqDVaq3SZ1y7dg2nTp3CkzJ8NKKioqyWgY5QqVTuvzGbNtl2EvvxR8Fliv796bZtDVzN83sEPkm5I5GucX/wyJjrEqMReOklm0ZersbIG/DSS+bAV06ng0qhsBk2wAHoumEDQIiVuNiVaI6j59asgcrCwGt+v0Tb7NyNG1B16uS5bXYP4an3WaVSIcxiZ82Ve8oyJK9Zswbp6enIzc1FVFQURo4ciWnTpqFp06YuRZl3794dAFBYWChoLywsRBdRBO/evXuxfv16hIWFmf9yc3PxxhtvmP9fb6iooDW6xU5ilZXWNhNPG5EtCQmhz2nPsc1kosZTf0BK/e/Ll4GapZLZt4bf4rZ09isvR3BxsWtVEWylC+WRus3OAOBGGETr1q2xdetWjBs3DtXV1ViyZAk2btyIO++8EzNmzJB0nyFDhiAkJAR5eXm4/fbbAdAYrqKiIowfP15wbXJyslWg6aRJk9CnTx/MnDkTrcTpEXwJXz9JzPHjwmNPOQXag3dC42tAWTqh8ULkL6lI5KQ35b/0L79MM/nxsxCpFSjCwmoDPi2DNC0FrKpK+jZ7AwjW9ASyZjqjRo3CmTNnMK4m50lgYCAWLVqEf/zjH1YGZkcEBwdj9uzZyMzMNLdt3LgRiYmJ6Nu3LzIzM5GQkICioiKEh4ejY8eOgr/g4GBERUWZ/19vkBpZ3rVr3Tt/KRT0S3LzZq3ToFbrueBQbyEnwx5f+WH5cnlJ4PlllGXke3Y2nUHx3srFxb7ZZvdjZM101qxZY7Xj9Nprr4HjOLz//vsu3Wvx4sVIS0vDzJkzERkZifz8fOzcuRMcx6G0tBRFRUWCrTm/QGq5mbpcWlnC+7DwHtKWPi3+khXA1fSmEiCwY8Phs/qJl6X8MkrO88uZqTVUpBRHVygU5L777iPvvfeeuVi65R/Pm2++SRQKhYzy63WDK0XdCSGkurqa7Nixg1RXV8t/UpOJkJISQlq1or+zrVrVtrdsKSxon5lJzxkMhMTE0LaYGHrsJTwyZm/x2WeEcBz9s3wdPfnH3/+zz4TvocFASFyc/Pt++61PX7q6fp9d+a5JWl61adMGBw4cwPTp0wEAy5YtQ2RkJKZMmYJt27aZgzxTU1PRsWPHutJH/8Be+MPFi7WJvnn69bOerosNoIxa7KU39ST2DMa+qtPVAJG0vEpISBAcp6enY9u2bfjss8+sfGzEu06NDr6+tBjx0kqhoLl+H3nEerrOG0Dt7ZY0ZsSZ+KKjaSyWO8uuiAjq3mCrvhSPL+p0NVAkzXRsOePFx8dbCQ5g7V3c6KiooLtX4lwsYtFRKumuhr1dD4Ce91QK0oaEOBOfvQToTiD8LIQ35juqZiq3Thf74bBCdsCnLcEB4H9GX0+zbRvQoYP1cunTT4XX6fVs18NT2Ft2tW4N/N//2awNbpb61auliRVvyLZ3LW985hPb8bMmJjhWSFpenTlzBh999JHA27iwsNCqTafT4eDBg57vpb+QnU2z2olnL3JsATxs10Majkrx9u1rVZGhMiYGgRkZCEhOprmTneGoThcvRGvW1N5LTg34RoJk0ZkyZYqgjRBis83eDKjBYzTadxJzBznT+saKvaoSIkEiMTHIee89jBw92vH9xKVhpJSUkSJgjRxJonPnnXfimWeeEcRa2EKr1WLDhg0e6ZjfIXd3wx5yK0AybOOoNrg9bCXncjSjYkhCkugsWLAAKSkpkm7YokULtzrkt3hyGcR2Peo3cgSMYUaSIVmq4AAwh0Y0Ojy5DGK7HowGTD3O9+lnJCXR3ZMrV1yz69TkaEFlJY3jYdN1RgOHiY6nUCqBJUvo7pV4d8MebNdDPlLrf3v7XgynMNHxFIQADz1ke3fDHmzXQz7uVGCoy3sxnMJEx1NwHC1SJ97dqCnwZiYkhHots2VUw4TNmpzCRMdTVFbSeCp+ecTvbojDGHjRYcuousHRl77mnKkuQ3XYrMkpTHQ8hV7vOBcxQEWmPuchbgg4+tLXnDPp9Q4rTjDqFiY6nkKhsF/Rk+euu4Br17zTH0bdwpZRsmGi4ymklIDt1w/YsaPOu8LwAmwZJRvZUeYMC0wm6/rhtrbMvZWelMGox7CZjicwGKyXVjXZFAU4Eh02XWc0EpjoeIKAAOudKHE9qdhYwFEFRDZdZzQSmOh4gqoqa5tOx46AZX3wpCTqy8NmNIxGDhMdT1BVZb1dXlIiPE5MpP+yGQ2jkcMMyZ5AnLjsyhXgwgVhG8uLw2AAYKLjGcSleQ8dEh5HRACNvUoGg1EDEx13qa6m9a4tESdTv/deFvLAYNTARMddbG2Xi2c6vD2HwWD4XnQIIVi5ciXmzp2L+fPnY9q0adCIHe0syMzMxB133IHw8HDce++9+PHHH73YWxuI46lu3aJF9Cxh9hwGw4zPRWfp0qXYs2cP3nrrLaSnpyM2NhaTJk2yee327duxe/duLF68GAsXLsSvv/6K4cOH46q4XK+3sVw6HT5MPZR5AgOB3r293ycGo57i0y3zkpISpKenY/369ea2qVOnIj4+Hrm5uUgSzRD279+PLVu2QKGgWtmxY0eMHTsWu3fvxrRp07zadzNabW0aC8B6adW7t7S4LAajkeDTmc7evXtRUVGBnj17mtvatWuH6OhobN26VXCtXq/H448/bhYcABgyZAgAoKyszDsdFmMy0ehySw4cEB4zew6DIcCnonP69GkAQFxcnKA9Li4OJ0+eFLSpVCr06dNH0FZVVQUAVu1eg+OA8PDaY60WOHJEeM1993m3TwxGPcfnyysACBVlcgsLC0NRUZHTx+fm5qJXr1649957nT6PXq83H6vVaqgtl0Q18NdYXuuQqiq6c1Wze8UdOIAAi8cSpRKGvn1pgq96istjbgCwMbuPTqeDTqczHzva/BHjU9EJDAwEAKtSxBzHmc85IiMjA++9957T6+JFgZYpKSmYOHGi3etzcnKc3tMWd27ahE4Wxzc7dkSu2GenniJ3zP4MG7N8Nm/ejC1btsh6rE9Fp3nz5gBoOeJwi2WKVqtFbGysw8e+8847+Pvf/467777b6fPk5+cL7u9oppOTk4OhQ4dCJSWtqChwU7lkieB0k7FjMXLkSOf38SEuj7kBwMbs/pgHDx6MjIwM87FGo7H6cbeHT0Wne/fuAIDCwkLcfvvt5vbCwkIMHDjQ7uO+++47lJeX4/nnn5f0PFFRUYhwIapbpVJJe2MiI2sNybduAcePC04rhwyB0k8+1JLH3IBgY3bvPmFhYYJjqfjUkDxkyBCEhIQgLy/P3FZQUICioiKMHz/e5mN++eUXfPHFF0hNTTW3VVRU4OLFi3XdXSEGgzBb4MGD1v45/ft7t08Mhh/gU9EJDg7G7NmzkZmZaW7buHEjEhMT0bdvX2RmZiIhIcFsVL5y5Qqeeuop9OzZE9u2bcO2bdvw3//+F3//+9/RrFkz73beYBB6In/7rfB8//5AcLB3+8Rg+AE+z6ezePFipKWlYebMmYiMjER+fj527twJjuNQWlqKoqIi6HQ6VFVVYdSoUTh58iQOHz4suMeUKVOsdsDqHHH4w/79wvODBnm3PwyGn+Bz0VEoFEhPT7d5btasWZg1a5b5+MSJE97qlnMMhtqZzI0bwE8/Cc87sEkxGI0Zn8de+S2VlbX/F3shh4QA99zj3f4wGH4CEx05iMvLfP218DgxkRqSGQyGFUx05MBxtdkCCQH27hWeHzbM+31iMPwEJjpyqKysLTFz9izw55/C8w884P0+MRh+AhMdOVRX12YL/PJL4bm4OODOO73fJwbDT2CiIwelsjZxlzj264EHrKtDMBgMM0x0XIWQ2qRcWi3w++/C82xpxWA4hImOqxgMQEUF/b/YC1mpBAYP9n6fGAw/gomOq+j1tdvhO3YIz/XtCzRt6u0eMRh+BRMdVwkMpH+ffgp8+KHw3M8/A9nZvukXg+EnMNFxlaoqOsOZMEEYVQ7Q9BbjxzPhYTAcwETHFQihPjoW8WA2mT0bMBq90iUGw99gouMKRiNw9Chw+bL9awgBCgqsSwszGAwATHRcQ6mkSygp/PVX3faFwfBTmOi4Qmkp0LKltGtvu61Ou8Jg+CtMdFzBZKIR5JZlhMVwHNC6NatfzmDYgYmOVAgBQkNprXJ7RmI+/GH1asfCxGA0YpjoSEWvp+lJP/nE/jVxccC2bUBysvf6xWD4GT5PV+o3VFTQyHJRjXWEhNBzMTFAfj6b4TAYTmCi4wyjEXjhBboNrtUCN28Kz4eHU9FRq5ngMBgSYKLjiOxs6ghozy9n+HAa+sBgMCTDbDr2yM6mIQ2OHAGffdZ7/WEwGghspmMLo5HOcMQJ2C1RKmnunDlzrGqaMxgM+zDRsQF36JDjGQ5AhemHH6joMBgMybDllS2khjCwUAcGw2WY6NhCaggDC3VgMFyGiY4NSGIidfRzlGCdhTowGLLwuU2HEIJVq1bh2rVrUKlUuHr1KlatWoXw8HCb1x87dgzr1q3DHXfcgaNHj+LFF19Ev379PNsppRJYswYYN872eY5joQ4Mhkx8LjpLly7Fvn378M033wAA0tLSMGnSJOzatcvq2t9++w3Dhw/H0aNH0b59e5w7dw59+/bFsWPHEB8f715HjEZwBw6g1cGD4EJDgS5dar2NLWnVCli7loU6MBgy8enyqqSkBOnp6ZgyZYq5berUqfj888+RayMJ1sKFC9G9e3e0b98eANCpUyd07doV6enp7nUkOxto1w4BQ4ei18qVCBg6lBbMEwtOWBhw6RITHAbDDXwqOnv37kVFRQV69uxpbmvXrh2io6OxVRTjZDAYsGvXLsG1ANCrVy989tlnMInzFUslO5suo8Rb5OJI8i5dgNdeY0sqBsNNfLq8On36NAAgLi5O0B4XF4eTJ08K2s6fP4/Kykqb1966dQv5+fno0KGDax3gnQCd0a0bTT/KHAAZDLfxqeiUlJQAAEJDQwXtYWFhKCoqknwtABQVFdkVnZKSEuj1evOxWq2GWq0Gd+AAApw5AQIwvPIKSHAwTW/RwOBfF30DHJs92JjdR6fTQafTmY81Go3kx/pUdAJritZxoq1pjuPM56Rca3neFmIjc0pKCiZOnIhWBw+il4R+njx6FIXBwRKu9F9ycnJ83QWvw8Ysn82bN2PLli2yHutT0WnevDkAQKvVCrbItVotYmNj7V5rCX8svt6S/Px8wf3NM53QUGDlSqf97D5iBO4aMMDpdf6IXq9HTk4Ohg4dCpVK5evueAU2ZvfHPHjwYGRkZJiPNRqN5B1kn4pO9+7dAQCFhYW4/fbbze2FhYUYOHCg4NpWrVohJiYGhYWFgvbCwkLExMSgRYsWdp8nKioKEbbsMQMHUifAwkLbwZ0cB8TFIWDgwAZvQFapVI3mC8jDxuzefXjTBn8sFZ/uXg0ZMgQhISHIy8sztxUUFKCoqAjjx48XXKtQKDB69GjBtQB1FkxOToZCIWMovBMgYO19zPIdMxh1gk9FJzg4GLNnz0ZmZqa5bePGjUhMTETfvn2RmZmJhIQEs1F5zpw5OHz4MC5dugQAuHDhAo4cOYKZM2fK70RyMs1r3KqVsJ3lO2Yw6gSfx14tXrwYvXv3xsyZM7Fw4UKcO3cOO3fuBMdxKC0tRVFRkdlK3qVLF2zfvh1z587FsmXL8Morr2DXrl1ISEhwrxPJycDFi6j84gus7dsXlV98QfMdNwLB0el02Lx5s2AnoqHDxuxbOEIcZaryb8rKytCkSRPcunXLtk1HRHFxMWJiYnDjxg1ER0d7oYe+h42ZjdkTuPJd8/lMh8FgNC6Y6DAYDK/i8yjzuoRfOZaVlUm6nveq1Gg0jWYrlY2ZjdkT8N8xKdaaBm3TuXz5Mlq3bu3rbjAYjYaCggKr+EgxDVp0TCYTrly5gvDwcKvwCQaD4TkIIdBoNIiNjXXqM9egRYfBYNQ/mCG5EVNUVIRbt275uhsML2IymXDhwgWf9oGJDujUcOXKlZg7dy7mz5+PadOmuRSq7y98/PHH4DjO/NevXz+zT8VXX32F6dOnY+nSpXjkkUfw22+/+bi38jl06JBV7B5AQ2amTp2K5cuXY8KECTh8+LDg/NWrVzF9+nQsX74cTz75JP797397q8tuY2/MWq0WkZGR5vdcqVSioKDAfN4nYyYM8sYbb5BBgwaZjxcsWEBGjx7twx7VDWPGjCEffvih+e/o0aOEEEIOHDhAmjdvTkpLSwkhhHzzzTekdevW5ObNmz7sretoNBryySefkM6dOxPxR/vs2bMkKiqKnD9/nhBCyO+//06ioqLIhQsXCCGEVFZWkrvuuots2rSJEEKITqcjHTt2JNu2bfPuIFzE0ZgJIWTdunVk/vz55vc8KyvLfM5XY270olNcXExCQkLMLzwhhOTn5xMA5ODBgz7smWf53//+R+bPn2/zXJ8+fcjUqVMFbW3btiWvv/66N7rmcebPn2/1BUxJSRH8sBBCyIABA8zjfvfdd0lISAipqqoyn1+4cCHp0KEDMZlMdd9pN7E1ZkIIGTFiBDEajTYf46sxN/rllSt5mv2ZtWvXYsmSJejRoweWLVuGqqoqAMCVK1dw5MgRm7mn/XX8SlFWACn5tbOzs5GQkAC1Wi04f/78eavMBvUR8ZgBmrDryy+/RGxsLKZNm4azZ88KzvtqzI1edFzJ0+zP9O/fH08//TRu3LiBuXPnIjExEeXl5Q7H/+uvv6K6utoX3fUoUvJrnz592uZ5AH77OQgODsa8efPQqVMn/Pvf/8bdd99tLvUEwGdjbvSi40qeZn/mueeew7p163DhwgWkpaXh+PHjWLBggcPxG41GFBcX+6K7HkVKfu2SkhKH5/2RxMRELFmyBLm5ufjuu+/QpEkTPP744+ZIc1+NudGLjit5mhsCKpUKixYtwvTp07Ft2za3ck/7C1LGGBgY2KBfgwEDBiA7OxtXr17FoUOHAMBnY270ouMo97KjvMv+zuTJk1FUVORw/Gq1ukGkfpCSX7t58+ay8m/7E/369UOnTp3MsxhfjbnRi45lnmZLCgsL0aVLFx/0yDs0bdoUzZo1Q0JCAgICAmyO3+3kaPUEKfm1u3fvbvM8gAb1OeDfdwA+G3OjFx1X8jQ3JPLy8jBixAhERUUhKSnJZu7phjJ+Kfm1x4wZg59//llQF+rYsWPo3Lkzunbt6u0u1wkVFRW4evUq+vfvDwC+G3Odbcb7EfPmzSPDhg0zH7/++uskMTHRL/wzpLB//34yfvx4cvz4cUIIIdevXyeDBw8mhYWFhBBC9u7dS5o1a0Zu3bpFCCHk4MGDJCoqily9etVnfXaH1NRUAkDgn3L69GkSFhZGLl68SAgh5Pz58yQ0NJT8/PPPhBBCKioqSIcOHcgnn3xCCCGkurqadO7cmXzwwQfeH4AMxGOuqqoi48ePJ++88475czxnzhyBP5qvxswCPkHjUdLS0lBWVobIyEjk5+dj9erViIqK8nXXPMLx48fxxBNP4NKlS5g0aRJiY2MxY8YMtGzZ0nxNVlYW9uzZgy5duuDYsWN49dVXzUtPf0Gv12Pr1q149dVXcenSJbz66qt49NFHzUuFffv2YcOGDbj77rtx/PhxzJgxA4MGDTI/Pj8/H6mpqbjrrrtw/vx59OjRA88//7yvhiMJe2O+44478Oijj+KLL75Anz59cM8992D48OFWoRK+GDMTHQaD4VUavU2HwWB4FyY6DAbDqzDRYTAYXoWJDoPB8CpMdBgMhldhosNgMLwKEx0Gg+FVmOgwrJgyZQqUSiV69OiBIUOGmHPsDhkyBH369EFISIjZcXDFihWIi4tDeXm5T/qalZXlVj7r8vJy7Ny504M9YjiDiQ7DCo7jsH//fpw4cQL79u3DXXfdBYB69B45cgR//PEHmjZtCgCIj49H3759BdnnvAEhBLNnz0bz5s0RHh4u+z5hYWFo3rw50tPTPdg7hiOY6DCsuP322zFgwAC752NjYzFq1CgAQHJyMrZt2+b18ryLFy9Gy5YtBWEMcunXrx9CQ0OxZcsWD/SM4QwWBsGwQq/XC0Tk/vvvx4EDBwR1qi2vMRqNNnP01hVnz57F/fffj4sXLyIoKMgj96yqqsKdd96JI0eOmFM/MOoGNtNhWCFl1qJSqXD+/HmkpqaiTZs25vYNGzZg2LBhWLt2LebNm4f4+Hi0bNkSOTk5OHr0KEaOHIkmTZpg5syZgvt9+umneP755zFmzBh0794dBw4csPvca9aswf333y8QnI0bN4LjOFy8eNHcNmXKFLRr1858vGnTJixfvhwrVqxA8+bNBXmAg4KC0KNHD6xbt87p2BluUqcx7IwGwYABA2yWNykpKbEqfXLr1i0SHh5O7rvvPnL27FlCCCGPPvooiYuLI5mZmYQQQr7++msCwHz+0KFD5J///Kf5HlOnTiVNmzYlGo3GZn/i4uLIokWLBG0ffvghAUDy8/PNbZMnTyZt27YlhNAaTy1atDCf27ZtGzlx4oTgHgsWLCBdunRx8mow3IXNdBiyiYyMRIcOHQRtERER5sRgnTt3BkCXZ5cvX8YTTzwBALjvvvsAAGfOnAFA7TOXLl1CamoqUlNTYTQakZCQYJXVDgA0Gg0uX75sTkEqFb1ej+LiYrzzzjsAgIceeght27YVXNOiRQucOXPGXJ6HUTcE+LoDjIaPeGeLPy4rKwMAnDhxAh999BGGDRvm9F587XVXE4eHh4dj0aJFeOGFF7Bnzx68++67gqUXQEu2mEwmFBcXo1WrVi7dnyEdNtNh+AxSY5iuqKhAfn6+1Xm+VIolfMkUOX5B8+bNw7Zt23D69Gl069YN33//veC80WgEAI8Zpxm2YaLD8Dl8MTiTyWRu++OPP7Br1y6rayMjI9GsWTOUlpbavJdldQPL+127dg2nTp3CuHHj8Ouvv6Jbt25Yvny54LE3b95EkyZNGkQFjPoMEx2GU3iP34qKCqtzfFJvy0qg/IyBh//yGwwGwXl+pvPcc8/h6NGjSElJwXfffYesrCy89NJLeOihh2z2Z9iwYfjll1+s2gMDA7F69WoUFBRgx44dOHv2rHm2VF5ejvfeew8AXWqNHz/eqsxKfn6+VTpPRh3ga0s2o/5SUFBAli5dSgICAggAMmPGDHLkyBHz+aNHj5LBgwcTAGT+/Pnk8uXL5MMPPyRKpZLce++9JC8vj5w9e5aMHTuWACBLly4lN2/eJMuWLSMAyIMPPkjOnj1LTCYTWbBgAWnWrBmJiIgg48aNI5cvX7bbr4MHD5LY2FhB4vyMjAyyePFi0q5dOxIeHk7mzZtH8vLySPPmzcnSpUvJmTNniEKhIM8//zx59913yVNPPUVu3LghuG9CQgL58ssvPf9CMgQw50CGXzJ58mQkJydjzJgxAIC5c+eiTZs2eO6552Tdb//+/VizZg2Lw/ICbHnF8EsyMjLw7rvv4vr16wCAS5cu4cSJE7LuVVxcjIyMDGzatMmTXWTYgYkOwy8JCwvDli1bsG7dOmi1Wty8eRMFBQUu36e8vBwZGRn4z3/+gyZNmtRBTxli2PKK4dcQQsBxHF555RUYDAarHSmpj2d4DyY6DAbDq7DlFYPB8CpMdBgMhldhosNgMLwKEx0Gg+FVmOgwGAyvwkSHwWB4FSY6DAbDqzDRYTAYXoWJDoPB8Cr/D34LW4J+cQHMAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Shuttling data with 5.0 kHz shuttling speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Datasets available: ['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:133: RuntimeWarning: invalid value encountered in multiply\n",
      "  np.poly1d.__init__(self, poly.coeffs * float(kn))\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n",
      "/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/multiplexing/lib/python3.9/site-packages/scipy/special/_orthogonal.py:119: RuntimeWarning: invalid value encountered in scalar divide\n",
      "  equiv_weights = [weights[k] / wfunc(roots[k]) for\n"
     ]
    }
   ],
   "source": [
    "n_samples = 50\n",
    "\n",
    "# Specify the data path and file details\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"19\"\n",
    "number = 30408\n",
    "\n",
    "rabi_t, pmt_counts_avg_thresholded, times = file_loading(data_path, date, index, number)\n",
    "rabi_t = np.array(rabi_t)  # Convert list to numpy array if not already\n",
    "pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "\n",
    "# Remove unwanted indices if needed\n",
    "indices_to_remove = []  # Added 12 to the list\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to True\n",
    "keep_indices[indices_to_remove] = False\n",
    "rabi_t = rabi_t[keep_indices]\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded[keep_indices]\n",
    "\n",
    "# Data re-scaling\n",
    "errorbar = (np.sqrt(pmt_counts_avg_thresholded) / np.sqrt(n_samples)) / np.max(pmt_counts_avg_thresholded)\n",
    "pmt_counts_avg_thresholded = np.max(pmt_counts_avg_thresholded) - pmt_counts_avg_thresholded\n",
    "pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded) / 1.1\n",
    "\n",
    "# Initial guesses\n",
    "# initial_guess = [0.09832203238100552, 0, 100]  # [rabi, nbar, nalpha]\n",
    "# bounds = ((0.05, 0, 0), (0.15, 30, 1))  # Modified upper bound for nalpha to 5\n",
    "bounds = ((0.0, 0, 10), (1, 400, 400))\n",
    "# bounds = ((0.0, 0, 0), (0.15, np.inf, np.inf))\n",
    "# Initial guess is the center of the bounds\n",
    "initial_guess = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2, (bounds[0][2] + bounds[1][2]) / 2]\n",
    "\n",
    "# Perform the curve fitting\n",
    "popt, pcov = curve_fit(fit_model, rabi_t, pmt_counts_avg_thresholded, p0=initial_guess, bounds=bounds)\n",
    "fitted_rabi, fitted_nbar, fitted_nalpha = popt\n",
    "\n",
    "print(\"Fitted parameters:\")\n",
    "print(\"rabi = \", fitted_rabi)\n",
    "print(\"nbar = \", fitted_nbar)\n",
    "print(\"nalpha = \", fitted_nalpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Running simulation\n",
    "# rabi =  fitted_rabi\n",
    "rabi = fitted_rabi\n",
    "nbar =  fitted_nbar\n",
    "# n_ions = 9\n",
    "# N = 400\n",
    "nalpha = fitted_nalpha\n",
    "\n",
    "# You already have these lines in your code\n",
    "time = np.linspace(np.min(times), np.max(times), 200)\n",
    "\n",
    "# Running simulation for different nalpha values\n",
    "nbars = [nbar - 3, nbar, nbar + 3]\n",
    "results = []\n",
    "\n",
    "for nbar in nbars:\n",
    "    D_population, _ = pe_model_optimized(time, rabi_0_fit=rabi, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(\"./outputs/shuttling/\", exist_ok=True)\n",
    "\n",
    "np.save(\"./data/save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(\"./data/save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)\n",
    "\n",
    "rabi_t = np.load(\"./data/save_rabi_t_shuttling_static.npy\")\n",
    "pmt_counts_avg_thresholded = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static.npy\")\n",
    "time = np.load(\"./data/save_rabi_t_shuttling_static_simulation.npy\")\n",
    "results = np.load(\"./data/save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\")\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(2.83, 2.83))\n",
    "errorbar = np.sqrt(pmt_counts_avg_thresholded * (1 - pmt_counts_avg_thresholded)) / np.sqrt(n_samples)\n",
    "plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='red', lw=2, zorder=2, label='Data')\n",
    "# plt.scatter(rabi_t[:], pmt_counts_avg_thresholded[:], c='red', s=30, zorder=2, label='Data')\n",
    "# plt.errorbar(rabi_t[:], pmt_counts_avg_thresholded[:], yerr=errorbar[:], fmt='o', c='C0', lw=1, zorder=2, label='Data')\n",
    "plt.plot(time, results[1], c='red', lw=3, zorder=3, label=f'$\\\\bar{{n}}_{{th}} = {np.average(nbars):.1f} \\\\pm {(np.average(nbars) - nbars[0]):.1f}$')\n",
    "plt.plot(time, results[0], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "plt.plot(time, results[2], '--', c='red', lw=0.5, zorder=1, alpha=0.1)\n",
    "# plt.fill_between(time, results[0], results[2], color='red', alpha=0.3)\n",
    "# plt.title('9-ion rabi oscillation after half speed shuttling', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.xlabel(r'Time (µs)', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylabel(r'Excitation', fontdict={'family': 'STIXGeneral', 'size': 12})\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlim(-10, 170)\n",
    "# plt.legend(loc='lower right')\n",
    "# plt.legend()\n",
    "plt.grid(True)\n",
    "plt.savefig('./outputs/shuttling/Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "multiplexing",
   "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}