Shuttling 9-ion rabi 20241205.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fit_signal', 'pmt_counts', 'pmt_counts_avg_thresholded', 'rabi_t']\n"
     ]
    }
   ],
   "source": [
    "from qutip import *\n",
    "from scipy.optimize import fsolve, leastsq, root, brentq, newton, 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",
    "import scipy as sc\n",
    "import scipy\n",
    "from scipy.integrate import dblquad, quad\n",
    "from scipy.special import laguerre\n",
    "from time import time\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",
    "    file_path = data_path + date + index + f\"/0000{number}-\" + exp + \".h5\"\n",
    "    file_path = data_path\n",
    "    with h5.File(file_path) as file:\n",
    "        datasets_keys = list(file['datasets'].keys())\n",
    "    print(datasets_keys)\n",
    "    with h5.File(file_path, \"r\") as file:\n",
    "        x_data = file['datasets'][x][:]\n",
    "        y_data = file['datasets'][y][:]\n",
    "    return x_data, y_data, np.linspace(np.min(x_data), np.max(x_data), 300)\n",
    "n_samples = 50\n",
    "\n",
    "# For shuttled data\n",
    "data_path = \"/Users/QUBIT/Library/CloudStorage/OneDrive-Personal/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240315/results/\"\n",
    "date = \"2024-10-27/\"\n",
    "index = \"20\"\n",
    "number = 30524\n",
    "\n",
    "# File loading\n",
    "path = \"C:/Users/bingr/OneDrive/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "# data_path = path + \"2024-10-27/19/000030462-RabiTimeScan.h5\"\n",
    "data_path = path + \"2024-10-27/20/000030524-RabiTimeScan.h5\"\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",
    "indices_to_remove = [9]\n",
    "keep_indices = np.ones(len(rabi_t), dtype=bool)  # Initially set all to keep\n",
    "keep_indices[indices_to_remove] = False  # Set indices to remove to 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.07 - 0.08    # / 0.58 - 0.28\n",
    "\n",
    "# Running simulation\n",
    "rabi = 0.031367640379929514*3.14/2\n",
    "n_ions = 9\n",
    "N = 200\n",
    "nbar = 11.8#23.73\n",
    "nalpha = 30\n",
    "\n",
    "# rabi =  0.10006110775107444\n",
    "# nbar =  8.300146520459053\n",
    "# nalpha =  14.014170204835581\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",
    "# 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, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\n",
    "\n",
    "data_saving_path = \"C:/Users/bingr/OneDrive/UCB STUDY/Research/Multiplexing/Simulation_Code/Multiplexing/data/\"\n",
    "\n",
    "import os\n",
    "# Create outputs directory if it doesn't exist\n",
    "os.makedirs(data_saving_path, exist_ok=True)\n",
    "\n",
    "np.save(data_saving_path + \"save_rabi_t_shuttling_static.npy\", rabi_t)\n",
    "np.save(data_saving_path + \"save_pmt_counts_avg_thresholded_shuttling_static.npy\", pmt_counts_avg_thresholded)\n",
    "np.save(data_saving_path + \"save_rabi_t_shuttling_static_simulation.npy\", time)\n",
    "np.save(data_saving_path + \"save_pmt_counts_avg_thresholded_shuttling_static_simulation.npy\", results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 283x283 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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('Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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.04686170532766234\n",
      "nbar =  54.818487726129014\n",
      "nalpha =  3.0361895110951953e-27\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 = \"C:/Users/bingr/OneDrive/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/\"\n",
    "date = \"2024-10-27/\"\n",
    "# index = \"19\"\n",
    "index = \"20\"\n",
    "# number = 30462\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)\n",
    "\n",
    "###########################################\n",
    "# Define the model and fit parameters\n",
    "###########################################\n",
    "\n",
    "n_ions = 9\n",
    "N = 200\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.031367640379929514 * 1.5, 23.73, 0.0]  # [rabi, nbar, nalpha]\n",
    "bounds = ((0, 0, 0), (np.inf, np.inf, np.inf))\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": [
      "/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": "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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 = 0.031367640379929514 * 10\n",
    "nbar =  fitted_nbar\n",
    "n_ions = 9\n",
    "N = 200\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, nbar_fit=nbar, nalpha_fit=nalpha)\n",
    "    results.append(D_population)\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('Rabi_9_ions_no_shuttling.pdf', format='pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/73/s1xpd2ts0712_vwy8r1jbjyc0000gn/T/ipykernel_14850/2879868478.py:63: UserWarning: No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n",
      "  plt.legend(fontsize=12)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "\n",
    "# Load the relevant datasets for analysis\n",
    "path = \"C:/Users/bingr/OneDrive/UCB STUDY/Research/Multiplexing/artiq_working_dir - 20240329/2024-10-27/\"\n",
    "file_path = path + \"20/000030524-RabiTimeScan.h5\"\n",
    "\n",
    "data_path_array = [\"20/000030524-RabiTimeScan.h5\", \"20/000030528-RabiTimeScan.h5\"]\n",
    "label_array = [\"\", \"\"]\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "for data_path, label in zip(data_path_array, label_array):\n",
    "    file_path = path + data_path\n",
    "    with h5py.File(file_path, 'r') as h5_file:\n",
    "        rabi_t = h5_file['datasets/rabi_t'][:]\n",
    "        pmt_counts = h5_file['datasets/pmt_counts'][:]\n",
    "        fit_signal = h5_file['datasets/fit_signal'][:]\n",
    "        pmt_counts_avg_thresholded = h5_file['datasets/pmt_counts_avg_thresholded'][:]\n",
    "        pmt_counts_avg_thresholded_copy = h5_file['datasets/pmt_counts_avg_thresholded'][:]\n",
    "\n",
    "        # Convert the datasets to numpy arrays\n",
    "        rabi_t = np.array(rabi_t)\n",
    "        pmt_counts = np.array(pmt_counts)\n",
    "        fit_signal = np.array(fit_signal)\n",
    "        pmt_counts_avg_thresholded = np.array(pmt_counts_avg_thresholded)\n",
    "        pmt_counts_avg_thresholded_copy = np.array(pmt_counts_avg_thresholded_copy)\n",
    "\n",
    "        # Re-scale it to the range [0, 1] and flip it to start from zero\n",
    "        pmt_counts_avg_thresholded = pmt_counts_avg_thresholded - np.min(pmt_counts_avg_thresholded)\n",
    "        pmt_counts_avg_thresholded = pmt_counts_avg_thresholded / np.max(pmt_counts_avg_thresholded)\n",
    "        pmt_counts_avg_thresholded = 1 - pmt_counts_avg_thresholded\n",
    "\n",
    "        # Re-scale the fit signal as the PMT counts\n",
    "        fit_signal = fit_signal - np.min(pmt_counts_avg_thresholded_copy)\n",
    "        fit_signal = fit_signal / np.max(pmt_counts_avg_thresholded_copy)\n",
    "        fit_signal = 1 - fit_signal\n",
    "\n",
    "        # Re-scale the PMT counts as the fit signal\n",
    "        pmt_counts_avg_thresholded = pmt_counts_avg_thresholded * 0.78\n",
    "        fit_signal = fit_signal * (0.5 / np.mean(fit_signal))\n",
    "\n",
    "    # Calculate the mean and standard deviation of PMT counts for visualization\n",
    "    pmt_counts_mean = np.mean(pmt_counts, axis=1)\n",
    "    pmt_counts_std = np.std(pmt_counts, axis=1)\n",
    "\n",
    "    # # Plot PMT counts (mean and standard deviation)\n",
    "    # plt.errorbar(rabi_t, pmt_counts_mean, yerr=pmt_counts_std, fmt='o', label='PMT Counts (Mean ± Std)', capsize=5)\n",
    "\n",
    "    # # Plot fit signal\n",
    "    # plt.plot(rabi_t, fit_signal, label='Fit Signal', linestyle='--', color='red')\n",
    "\n",
    "    # Plot thresholded average PMT counts\n",
    "    plt.plot(rabi_t, pmt_counts_avg_thresholded, label=label, linestyle='-', marker='o', markersize=5, linewidth=2, alpha=0.8)\n",
    "\n",
    "# Add labels, legend, and grid\n",
    "plt.ylim(-0.1, 1.0)\n",
    "plt.xlabel('Rabi Time (t)', fontsize=14)\n",
    "plt.ylabel('Counts', fontsize=14)\n",
    "plt.title('9-ion Rabi flop after shuttling', fontsize=16)\n",
    "plt.legend(fontsize=12)\n",
    "plt.grid(True)\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.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}