examples/01_qubit_characterization/01_cw_resonator_spec_shfsg_shfqa_shfqc.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Resonator Spectroscopy with SHFQA or SHFQC\n",
    "\n",
    "This notebook shows you how to perform CW resonator spectroscopy in LabOne Q with a SHFQA or the quantum analyzer channels of a SHFQC. Here, you'll find the resonance frequency of the qubit readout resonator by looking at the transmission or reflection of a probe signal applied through the readout line.\n",
    "\n",
    "A demonstration of this notebook, starting from the basics of installing LabOne Q, is also available on our Youtube channel [here](https://www.youtube.com/watch?v=aRaGHNZeVkI&list=PLjxUCNDRYw8k1_HTzXDohUHKhYKYFQrbn&index=1&ab_channel=ZurichInstruments)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. LabOne Q Imports\n",
    "\n",
    "You'll begin by importing `laboneq.simple` and some extra helper functions to run the examples. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LabOne Q:\n",
    "from laboneq.simple import *\n",
    "\n",
    "# Helpers:\n",
    "from laboneq.contrib.example_helpers.plotting.plot_helpers import plot_results\n",
    "from laboneq.contrib.example_helpers.generate_example_datastore import (\n",
    "    generate_example_datastore,\n",
    "    get_first_named_entry,\n",
    ")\n",
    "\n",
    "from pathlib import Path\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build an in-memory data store with device setup and qubit parameters for the\n",
    "# example notebooks\n",
    "setup_db = generate_example_datastore(in_memory=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Device Setup\n",
    "\n",
    "Below, you'll create a device setup and specify to run in an emulated mode or on hardware, `emulate = True/False` respectively.\n",
    "\n",
    "If you run on your hardware, the [descriptor](https://docs.zhinst.com/labone_q_user_manual/concepts/set_up_equipment/) called by `create_device_setup` should be replaced by one of your own, generally stored as a [YAML file](https://docs.zhinst.com/labone_q_user_manual/concepts/set_up_equipment#labone_q.func_concepts.setting_up.set_up_equipment.descriptor). Once you have this descriptor, it can be reused for all your experiments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load a calibrated device setup from the dummy database\n",
    "device_setup = get_first_named_entry(\n",
    "    db=setup_db, name=\"6_tuneable_qubit_setup_shfsg_shfqa_hdawg_pqsc_calibrated\"\n",
    ")\n",
    "\n",
    "emulate = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create and connect to a session\n",
    "session = Session(device_setup=device_setup)\n",
    "session.connect(do_emulation=emulate)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Experiment Parameters\n",
    "\n",
    "Now you'll define the frequency sweep parameters to use in your experiment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# frequency range of spectroscopy scan - around expected centre frequency as defined in qubit parameters\n",
    "start_freq = -200.0e6\n",
    "stop_freq = 200.0e6\n",
    "num_points = 101\n",
    "integration_time = 1e-3\n",
    "\n",
    "# define number of averages\n",
    "# used for 2^num_averages, maximum: num_averages = 17\n",
    "num_averages = 4\n",
    "\n",
    "\n",
    "# define sweep parameter\n",
    "def create_readout_freq_sweep(qubit, start_freq, stop_freq, num_points):\n",
    "    return LinearSweepParameter(\n",
    "        uid=f\"{qubit}_res_freq\",\n",
    "        start=start_freq,\n",
    "        stop=stop_freq,\n",
    "        count=num_points,\n",
    "        axis_name=\"Frequency [Hz]\",\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Experiment Definition\n",
    "\n",
    "You'll now create a function which generates you CW spectroscopy [experiment](https://docs.zhinst.com/labone_q_user_manual/concepts/experiment/). In this experiment, you'll pass the `LinearSweepParameter` defined previously as an argument to the [sweep section](https://docs.zhinst.com/labone_q_user_manual/concepts/averaging_sweeping/#labone_q.func_concepts.experiment.averaging_sweeping.parameters_sweeps). Within the section, you'll create a [section](https://docs.zhinst.com/labone_q_user_manual/concepts/sections_and_pulses/) containing an `acquire` command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function that defines a resonator spectroscopy experiment, and takes the frequency sweep as a parameter\n",
    "\n",
    "\n",
    "def res_spectroscopy_CW(freq_sweep, exp_settings):\n",
    "    # Create resonator spectroscopy experiment - uses only readout drive and signal acquisition\n",
    "    exp_spec = Experiment(\n",
    "        uid=\"Resonator Spectroscopy\",\n",
    "        signals=[\n",
    "            ExperimentSignal(\"measure\"),\n",
    "            ExperimentSignal(\"acquire\"),\n",
    "        ],\n",
    "    )\n",
    "\n",
    "    ## define experimental sequence\n",
    "    # loop - average multiple measurements for each frequency - measurement in spectroscopy mode\n",
    "    with exp_spec.acquire_loop_rt(\n",
    "        uid=\"shots\",\n",
    "        count=pow(2, exp_settings[\"num_averages\"]),\n",
    "        acquisition_type=AcquisitionType.SPECTROSCOPY,\n",
    "    ):\n",
    "        with exp_spec.sweep(uid=\"res_freq\", parameter=freq_sweep):\n",
    "            # readout pulse and data acquisition\n",
    "            with exp_spec.section(uid=\"spectroscopy\"):\n",
    "                # resonator signal readout\n",
    "                exp_spec.acquire(\n",
    "                    signal=\"acquire\",\n",
    "                    handle=\"res_spec\",\n",
    "                    length=exp_settings[\"integration_time\"],\n",
    "                )\n",
    "            # relax time after readout - for signal processing and qubit relaxation to ground state\n",
    "            with exp_spec.section(uid=\"relax\", length=1e-6):\n",
    "                exp_spec.reserve(signal=\"measure\")\n",
    "                exp_spec.reserve(signal=\"acquire\")\n",
    "\n",
    "    return exp_spec"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Experiment Calibration and Signal Map\n",
    "\n",
    "Before running the experiment, you'll need to set an [experiment calibration](https://docs.zhinst.com/labone_q_user_manual/concepts/experiment_calibration/). The sweep parameter is assigned to the hardware oscillator modulating the readout resonator drive line. You'll also define and set the mapping between the experimental and logical lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function that returns the calibration of the readout line oscillator for the experimental signals\n",
    "\n",
    "\n",
    "def res_spec_calib(freq_sweep):\n",
    "    exp_calibration = Calibration()\n",
    "    # sets the oscillator of the experimental measure signal\n",
    "    exp_calibration[\"measure\"] = SignalCalibration(\n",
    "        # for spectroscopy, use the hardware oscillator of the QA, and set the sweep parameter as frequency\n",
    "        oscillator=Oscillator(\n",
    "            \"readout_osc\",\n",
    "            frequency=freq_sweep,\n",
    "            modulation_type=ModulationType.HARDWARE,\n",
    "        )\n",
    "    )\n",
    "    return exp_calibration\n",
    "\n",
    "\n",
    "# signal maps for the two different qubits - maps the logical signal of the device setup to the experimental signals of the experiment\n",
    "\n",
    "\n",
    "def res_spec_map(qubit):\n",
    "    signal_map = {\n",
    "        \"measure\": device_setup.logical_signal_groups[f\"{qubit}\"].logical_signals[\n",
    "            \"measure_line\"\n",
    "        ],\n",
    "        \"acquire\": device_setup.logical_signal_groups[f\"{qubit}\"].logical_signals[\n",
    "            \"acquire_line\"\n",
    "        ],\n",
    "    }\n",
    "    return signal_map\n",
    "\n",
    "\n",
    "# define the experiment with the frequency sweep relevant for qubit 0\n",
    "freq_sweep = create_readout_freq_sweep(\"q0\", start_freq, stop_freq, num_points)\n",
    "exp_settings = {\"integration_time\": integration_time, \"num_averages\": num_averages}\n",
    "exp_spec = res_spectroscopy_CW(freq_sweep, exp_settings)\n",
    "\n",
    "# set signal calibration and signal map for experiment to qubit 0\n",
    "exp_spec.set_calibration(res_spec_calib(freq_sweep))\n",
    "exp_spec.set_signal_map(res_spec_map(\"q0\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Compile and Generate Pulse Sheet\n",
    "\n",
    "Now you'll compile the experiment and generate a pulse sheet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile the experiment on the open instrument session\n",
    "compiled_res_spec = session.compile(exp_spec)\n",
    "\n",
    "Path(\"Pulse_Sheets\").mkdir(parents=True, exist_ok=True)\n",
    "# generate a pulse sheet to inspect experiment before runtime\n",
    "show_pulse_sheet(\"Pulse_Sheets/Resonator_Spectroscopy_Pulse_Sheet\", compiled_res_spec)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Run, Save, and Plot Results\n",
    "\n",
    "Finally, you'll run the experiment, save, and plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# run the compiled experiemnt\n",
    "res_spec_results = session.run(compiled_res_spec)\n",
    "timestamp = time.strftime(\"%Y%m%dT%H%M%S\")\n",
    "Path(\"Results\").mkdir(parents=True, exist_ok=True)\n",
    "session.save_results(f\"Results/{timestamp}_results.json\")\n",
    "print(f\"File saved as Results/{timestamp}_results.json\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plot the results\n",
    "plot_results(res_spec_results, phase=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "repo",
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}