T1_measurement_example.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Authors:** G. Ruggero Di Carlo (rdicarlo@tudelft.nl), Marios Samiotis (m.samiotis@tudelft.nl)\n",
    "\n",
    "**Date:** February 14, 2025"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# $T_1$ under repeated measurement using QI 2.0, with saving of raw data into .csv file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook we will perform a $T_1$ measurement using custom functions from utility_functions.py, and save the raw data in a .csv file in order to be processed after measurement.\n",
    "\n",
    "We use the mid-circuit measurement functionality for this purpose.\n",
    "\n",
    "For optimal performance, make sure that you are running this notebook within a customized Python 3.12 environment which includes the packages \"quantuminspire\" and \"qiskit-quantuminspire\".\n",
    "\n",
    "For detailed instructions on how to create such a Python environment, follow the instructions in the README file, [https://github.com/DiCarloLab-Delft/QuantumInspireUtilities/blob/main/README.md](https://github.com/DiCarloLab-Delft/QuantumInspireUtilities/blob/main/README.md).\n",
    "\n",
    "NOTE: in order to run the custom functions from utility_functions.py, you will need to clone the entire repository QuantumInspireUtilities from [https://github.com/DiCarloLab-Delft/QuantumInspireUtilities/tree/main](https://github.com/DiCarloLab-Delft/QuantumInspireUtilities/tree/main).\n",
    "\n",
    "Useful links:\n",
    "1. [Starmon-7 Fact Sheet](https://github.com/DiCarloLab-Delft/QuantumInspireUtilities/blob/main/Starmon7_FactSheet.pdf)\n",
    "2. [Starmon-7 Performance Metrics [live updated]](https://dicarlolab.tudelft.nl/Starmon7_performance.html)\n",
    "3. [Starmon-7 Fridge Parameters [live updated]](https://dicarlolab.tudelft.nl/Starmon7_fridge.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utility_functions import *\n",
    "from qiskit import QuantumCircuit\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "!qi login \"https://api.quantum-inspire.com\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment_backend = \"Starmon-7\"\n",
    "provider = QIProvider()\n",
    "backend = provider.get_backend(name=experiment_backend)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the function create_new_data_folder() will create a folder in the path specified in the utility_functions.py where we will save all our results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_directory = f\"[...]\"\n",
    "\n",
    "new_directory_path = create_new_data_folder(datadir=data_directory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create the quantum circuit to perform a single-qubit $T_1$ measurement using Qiskit,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "nr_qubits = 7 # Number of qubits of Starmon-7 processor\n",
    "nr_points = 15 # Number of points for the T1 experiment\n",
    "total_time = 150e-6 # Total time of the T1 experiment in [s]\n",
    "\n",
    "qubit_index = 0 # We choose qubit Q0\n",
    "\n",
    "cycle_time = 20e-9 # cycle time of the Central Controller (CC) instrument\n",
    "dt = total_time / nr_points # time interval between each measurement point\n",
    "measurement_times = np.linspace(start = 0.0, stop = total_time, num = nr_points)\n",
    "\n",
    "qc = QuantumCircuit(7, nr_points) # NOTE: we should put backend.num_qubits here\n",
    "qc.x(qubit_index) # qubit initialization to the |1> state\n",
    "qc.measure(qubit = qubit_index, cbit = 0) # initial measurement at time t=0\n",
    "for time_idx in range(1, nr_points):\n",
    "    qc.delay(duration = int((dt / cycle_time)), qarg = qubit_index) # delay in units of CC cycles\n",
    "    qc.measure(qubit = qubit_index, cbit = time_idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may visualize the circuit by running the cell below,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "qc.draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Choose the name of the files that we will create and save,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "basename = 'Example'\n",
    "suffix = 'T1_under_measurement'\n",
    "histname, circuit_name, rawname = prepare_file(basename, suffix, doraw=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we specify the number of shots and run the algorithm, (careful not to exceed the max_shots allowed by the backend!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "nr_shots = 2**14 # Careful not to exceed the max_shots of the backend!\n",
    "\n",
    "results = api_run_and_save(0, Qcircuit = qc, rawdata_filename = rawname, circuit_name=circuit_name,\n",
    "                           histname = histname, shots=nr_shots, backend_name=experiment_backend, get_results = True,\n",
    "                           get_hist_data=True, measurement_list=list((np.ones(nr_points, dtype=np.int8))), get_raw_data=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data are saved in a csv file in the format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(rawname+\"_0.csv\")\n",
    "measurement_outcomes_list = np.zeros((len(df[\"Raw data values\"]), (len(df[\"Raw data values\"][0])-1)), dtype = np.int8)\n",
    "\n",
    "for shot_index in range(len(df[\"Raw data values\"])):\n",
    "    for measurement_index in range(1, len(df[\"Raw data values\"][0])):\n",
    "        measurement_outcomes_list[shot_index][(measurement_index - 1)] = np.int8(df[\"Raw data values\"][shot_index][len(df[\"Raw data values\"][0]) - measurement_index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(4, 3), sharey = 'row', sharex = 'col')\n",
    "ax.plot(np.arange(len(np.sum(measurement_outcomes_list, 0))) * (dt * 1e6 + 1), np.sum(measurement_outcomes_list, 0) / nr_shots, '-o')\n",
    "\n",
    "ax.set_ylim(0, 1)\n",
    "ax.set_xlim(-1.5, max(np.arange(len(np.sum(measurement_outcomes_list, 0))) * (dt * 1e6 + 1)) + 1.5)\n",
    "\n",
    "ax.set_title('$T_1$ under repeated measurement')\n",
    "ax.set_ylabel('Fraction')\n",
    "ax.set_xlabel('Time (us)')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "quantuminspire",
   "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.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}