{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "2d030055", "metadata": {}, "source": [ "# Qblox basic sequencing" ] }, { "attachments": {}, "cell_type": "markdown", "id": "9b19dc28", "metadata": {}, "source": [ "This tutorial outputs the same waveforms as in the [Basic Sequencing](https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/tutorials/q1asm_tutorials/basic/baseband/basic_sequencing.html) tutorial, but using quantify instead.\n", "\n", "To run this tutorial please make sure you have installed and enabled ipywidgets:\n", "```\n", "pip install ipywidgets\n", "jupyter nbextension enable --py widgetsnbextension\n", "```" ] }, { "attachments": {}, "cell_type": "markdown", "id": "5d581a74", "metadata": {}, "source": [ "Quantify allows a either a gate or pulse to be played from a qblox instrument. Gates are performed on qubits (see [Operations and Qubits](https://quantify-os.org/docs/quantify-scheduler/latest/tutorials/Operations%20and%20Qubits.html)) and pulses are played on ports (see [Schedules and Pulses](https://quantify-os.org/docs/quantify-scheduler/latest/tutorials/Schedules%20and%20Pulses.html)).\n", "\n", "In this tutorial, we will play both gates and pulses." ] }, { "attachments": {}, "cell_type": "markdown", "id": "57d3a22d", "metadata": {}, "source": [ "First we set the data directory." ] }, { "cell_type": "code", "execution_count": null, "id": "5b1be671", "metadata": {}, "outputs": [], "source": [ "from quantify_core.data import handling as dh\n", "\n", "dh.set_datadir()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "aed2c88d", "metadata": {}, "source": [ "## Connections\n", "\n", "First, we define a quantum device with one transmon (qubit).\n", "\n", "The transmon here is a device element (typically a type of qubit) and is only necessary when using a gate operation, since the same gate can be implemented differently on different types of device elements. Take for example the `Measure` operation. The state of a transmon is determined by measuring a signal sent to a resonator coupled to it, but the state of a spin qubit is determined by measuring a current." ] }, { "cell_type": "code", "execution_count": 2, "id": "ec074da5", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "\n", "single_transmon_device = QuantumDevice(\"DUT\")\n", "transmon = BasicTransmonElement(\"transmon\")\n", "single_transmon_device.add_element(transmon)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "dfccd357", "metadata": {}, "source": [ "We will assume the transmon is already calibrated, and that we know the frequency of the qubit and the parameters for a $\\pi$-pulse. We can assign this known frequency and $\\pi$-pulse parameters to the transmon." ] }, { "cell_type": "code", "execution_count": 3, "id": "3864c7de", "metadata": {}, "outputs": [], "source": [ "transmon.clock_freqs.f01(5e9) # The |0> <=> |1> transition frequency is at 5 GHz.\n", "transmon.rxy.amp180(0.3) # The amplitude of a pi pulse is 0.3" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f0d0ec40", "metadata": {}, "source": [ "Next, we define the module(s) that are connected to the quantum device.\n", "\n", "In this case, one Qblox Cluster with a QCM (or QRM) in slot 1.\n", "\n", "We will use three outputs of the QCM for the tutorial to showcase both real and complex output signals. Please make appropriate modifications if using a QRM which only has two outputs." ] }, { "cell_type": "code", "execution_count": 5, "id": "521772db", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b384e776d0634c4e8cadc26f9badf18d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Select Device', options=(('Dummy Cluster', 'dummy'), ('pulsar-qcm @10.10.200.51', '00012…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import ipywidgets as widgets\n", "\n", "from qblox_instruments import Cluster, ClusterType, PlugAndPlay\n", "\n", "with PlugAndPlay() as p:\n", " # get info of all devices\n", " device_list = p.list_devices()\n", "\n", "# Scan for available devices and display\n", "names = {dev_id: dev_info[\"description\"][\"name\"] for dev_id, dev_info in device_list.items()}\n", "ip_addresses = {dev_id: dev_info[\"identity\"][\"ip\"] for dev_id, dev_info in device_list.items()}\n", "\n", "# create widget for names and ip addresses\n", "connect = widgets.Dropdown(\n", " options=[(\"Dummy Cluster\", \"dummy\")]\n", " + [(names[dev_id] + \" @\" + ip_addresses[dev_id], dev_id) for dev_id in device_list],\n", " description=\"Select Device\",\n", ")\n", "display(connect)" ] }, { "cell_type": "code", "execution_count": 6, "id": "be6391b1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dummy Cluster connected\n", "Status: CRITICAL, Flags: CARRIER_TEMPERATURE_OUT_OF_RANGE, FPGA_TEMPERATURE_OUT_OF_RANGE, Slot flags: SLOT4_CARRIER_TEMPERATURE_OUT_OF_RANGE, SLOT4_FPGA_TEMPERATURE_OUT_OF_RANGE\n" ] } ], "source": [ "import contextlib\n", "\n", "from qcodes import Instrument\n", "\n", "# Connect to device\n", "dev_id = connect.value\n", "# Close the chosen QCodes instrument as to prevent name clash.\n", "with contextlib.suppress(KeyError):\n", " Instrument.find_instrument(names[dev_id]).close()\n", "\n", "\n", "if dev_id == \"dummy\":\n", " module_type = \"QRM\" # 'QCM'\n", " slot_no = 4\n", "\n", " # Here we have the option to use a dummy device so that you can run your tests without a physical cluster\n", " cluster = Cluster(\n", " name=\"cluster0\", dummy_cfg={slot_no: ClusterType.CLUSTER_QRM} # ClusterType.CLUSTER_QCM\n", " )\n", "else:\n", " cluster = Cluster(name=\"cluster0\", identifier=ip_addresses[dev_id])\n", "\n", "print(f\"{connect.label} connected\")\n", "print(cluster.get_system_state())" ] }, { "cell_type": "code", "execution_count": 7, "id": "5ddff596", "metadata": {}, "outputs": [], "source": [ "def select_module_widget(device, select_qrm_type=None, select_rf_type=None):\n", " \"\"\"\n", " Create a widget to select modules of a certain type.\n", "\n", " default is to show only QRM baseband\n", "\n", " Args:\n", " ----\n", " devices: Cluster we are currently using\n", " select_qrm_type: filter QRM/QCM if true or false. ignored if None (default)\n", " select_rf_type: filter RF/baseband if true or false. ignored if None (default)\n", " \"\"\"\n", " options = [[None, None]]\n", "\n", " for module in device.modules:\n", " if module.present():\n", " if (select_qrm_type is None or module.is_qrm_type == select_qrm_type) and (\n", " select_rf_type is None or module.is_rf_type == select_rf_type\n", " ):\n", " options.append(\n", " [\n", " f\"{device.name} \"\n", " f\"{module.short_name} \"\n", " f\"({module.module_type}{'_RF' if module.is_rf_type else ''})\",\n", " module,\n", " ]\n", " )\n", " widget = widgets.Dropdown(options=options)\n", " display(widget)\n", "\n", " return widget" ] }, { "cell_type": "code", "execution_count": 8, "id": "ef136d77", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Select the readout module from the available modules:\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4caa5ac618d642d693949209590e0235", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(options=([None, None], ['cluster0 module4 (QRM)', ]), …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"Select the readout module from the available modules:\")\n", "select_module = select_module_widget(cluster, select_rf_type=False)" ] }, { "cell_type": "code", "execution_count": 9, "id": "32bd047e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " connected\n" ] } ], "source": [ "module = select_module.value\n", "print(f\"{module} connected\")" ] }, { "cell_type": "code", "execution_count": 10, "id": "6f04bd65", "metadata": {}, "outputs": [], "source": [ "slot_no = module.slot_idx\n", "if module.is_qcm_type:\n", " module_type = \"QCM\"\n", "if module.is_qrm_type:\n", " module_type = \"QRM\"" ] }, { "attachments": {}, "cell_type": "markdown", "id": "869a9d20", "metadata": {}, "source": [ "Create a dummy Local Oscillator with the same name as in the hardware config. This can be replaced with a microwave generator in an actual situation" ] }, { "cell_type": "code", "execution_count": 11, "id": "c17f7400", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.helpers.mock_instruments import MockLocalOscillator\n", "\n", "lo1 = MockLocalOscillator(name=\"lo1\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "7a90863b", "metadata": {}, "source": [ "Now we define the connections between the quantum device and the qblox instrument(s). For this we define a hardware config according to the [Qblox backend](https://quantify-os.org/docs/quantify-scheduler/latest/reference/qblox/index.html) tutorial." ] }, { "cell_type": "code", "execution_count": 12, "id": "17934456", "metadata": {}, "outputs": [], "source": [ "hardware_config = {\n", " \"backend\": \"quantify_scheduler.backends.qblox_backend.hardware_compile\", # Use the Qblox backend\n", " \"cluster0\": { # The first instrument is named \"cluster0\"\n", " \"instrument_type\": \"Cluster\", # The instrument is a Qblox Cluster\n", " \"ref\": \"internal\", # Use the internal reference clock\n", " f\"cluster0_module{slot_no}\": { # This is the module in slot of the cluster. (slot 0 has the CMM)\n", " \"instrument_type\": f\"{module_type}\", # The module is either a QCM or QRM module\n", " \"complex_output_0\": { # The module will output a real signal from output 0 (O1)\n", " \"lo_name\": \"lo1\", # output 0 and 1 (O1 and O2) are connected to the I and Q ports of an IQ mixer with a LocalOscillator by the name lo1\n", " \"portclock_configs\": [ # Each output can contain upto 6 portclocks. We will use only one for this tutorial\n", " {\n", " \"port\": \"transmon:mw\", # This output is connected to the microwave line of qubit 0\n", " \"clock\": \"transmon.01\", # This clock tracks the |0> <=> |1> transition of the transmon\n", " },\n", " ],\n", " },\n", " },\n", " },\n", " \"lo1\": {\n", " \"instrument_type\": \"LocalOscillator\",\n", " \"frequency\": 4.9e9,\n", " \"power\": 20,\n", " }, # lo1 has a frequency of 4.9 GHz and is set to a power level of 20 (can be dBm)\n", "}" ] }, { "cell_type": "code", "execution_count": 13, "id": "e2513a2e", "metadata": {}, "outputs": [], "source": [ "if module_type == \"QCM\":\n", " hardware_config[\"cluster0\"][f\"cluster0_module{slot_no}\"][\"real_output_2\"] = (\n", " { # The QCM will output a real signal from output 2\n", " \"portclock_configs\": [\n", " {\n", " \"port\": \"transmon:fl\", # This output is connected to the flux line of qubit 2\n", " \"clock\": \"cl0.baseband\", # This default value (clock with zero frequency) is used if a clock is not provided.\n", " },\n", " ]\n", " },\n", " )" ] }, { "cell_type": "code", "execution_count": 14, "id": "815b1414", "metadata": {}, "outputs": [], "source": [ "single_transmon_device.hardware_config(hardware_config)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "0a1e8701", "metadata": {}, "source": [ "## Schedule" ] }, { "attachments": {}, "cell_type": "markdown", "id": "259a1797", "metadata": {}, "source": [ "We can now create a `Schedule` of pulses or gates to play." ] }, { "cell_type": "code", "execution_count": 15, "id": "3d1edf28", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "\n", "sched = Schedule(\n", " \"Basic sequencing\", repetitions=2**27\n", ") # The schedule will be played repeatedly 2^27 times" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f5990ec4", "metadata": {}, "source": [ "Let's create the control portion of an experiment.\n", "\n", "First we specify an arbitrary numerical pulse to be played on the microwave port of the transmon.\n", "\n", "Here we play a gaussian pulse constructed from the scipy library." ] }, { "cell_type": "code", "execution_count": 16, "id": "75e2b89a", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from scipy.signal import gaussian\n", "\n", "from quantify_scheduler.operations.pulse_library import NumericalPulse\n", "\n", "t = np.arange(0, 48.5e-9, 1e-9)\n", "\n", "gaussian_pulse = sched.add(\n", " NumericalPulse(\n", " samples=0.2 * gaussian(len(t), std=0.12 * len(t))\n", " - 1j * gaussian(len(t), std=0.12 * len(t)), # Numerical pulses can be complex as well.\n", " t_samples=t,\n", " port=\"transmon:mw\",\n", " clock=\"transmon.01\",\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=0e-9,\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "2ad70ee4", "metadata": {}, "source": [ "Next, we apply a square pulse to the flux port of the transmon at the same time as the Gaussian Pulse" ] }, { "cell_type": "code", "execution_count": 17, "id": "15ba9e2f", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.pulse_library import SquarePulse\n", "\n", "if module_type == \"QCM\":\n", " square_pulse = sched.add(\n", " SquarePulse(amp=0.4, duration=32e-9, port=\"transmon:fl\", clock=\"cl0.baseband\"),\n", " ref_pt=\"start\", # Play at the start of\n", " ref_op=gaussian_pulse, # the gaussian pulse\n", " rel_time=0e-9, # Delay the pulse by 0 ns\n", " )" ] }, { "attachments": {}, "cell_type": "markdown", "id": "5df9a04d", "metadata": {}, "source": [ "Finally, we apply an X gate to the transmon. This uses the stored parameters in the `transmon` object." ] }, { "cell_type": "code", "execution_count": 18, "id": "84467ef0", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.gate_library import X\n", "from quantify_scheduler.resources import ClockResource\n", "\n", "pi_pulse = sched.add(X(qubit=transmon.name), ref_op=gaussian_pulse)\n", "\n", "sched.add_resource(\n", " ClockResource(name=\"transmon.01\", freq=transmon.clock_freqs.f01())\n", ") # A ClockResource is necessary for the schedule to know the frequency of the transmon." ] }, { "attachments": {}, "cell_type": "markdown", "id": "0828444c", "metadata": {}, "source": [ "## Compilation" ] }, { "attachments": {}, "cell_type": "markdown", "id": "9e5b04e8", "metadata": {}, "source": [ "We then compile the schedule to produce instructions for the instruments.\n", "\n", "We use the `SerialCompiler` here, which first converts all gates to pulses, then all pulses to instrument instructions." ] }, { "cell_type": "code", "execution_count": 19, "id": "93474c93", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(
,\n", " )" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from quantify_scheduler.backends.graph_compilation import SerialCompiler\n", "\n", "compiler = SerialCompiler(name=\"compiler\")\n", "compiled_sched = compiler.compile(\n", " schedule=sched, config=single_transmon_device.generate_compilation_config()\n", ")\n", "\n", "compiled_sched.plot_pulse_diagram()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3151b49c", "metadata": {}, "source": [ "We can view the compiled sequencer instructions sent to the QCM module. This may be compared to the program in the [Basic Sequencing](https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/tutorials/q1asm_tutorials/basic/baseband/basic_sequencing.html) tutorial. Notice the extra instructions here that set the gain for each waveform played and the automatically calculated wait times." ] }, { "cell_type": "code", "execution_count": 20, "id": "c97b4caa", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", " set_mrk 0 # set markers to 0 \n", " wait_sync 4 \n", " upd_param 4 \n", " wait 4 # latency correction of 4 + 0 ns \n", " move 134217728,R0 # iterator for loop with label start \n", " start: \n", " reset_ph \n", " upd_param 4 \n", " set_awg_gain 6553,32767 # setting gain for NumericalPulse \n", " play 0,1,4 # play NumericalPulse (48 ns) \n", " wait 44 # auto generated wait (44 ns) \n", " set_awg_gain 9821,0 # setting gain for X transmon \n", " play 2,2,4 # play X transmon (20 ns) \n", " wait 16 # auto generated wait (16 ns) \n", " loop R0,@start \n", " stop \n", "\n" ] } ], "source": [ "print(\n", " compiled_sched.compiled_instructions[\"cluster0\"][f\"cluster0_module{slot_no}\"][\"sequencers\"][\n", " \"seq0\"\n", " ][\"sequence\"][\"program\"]\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "e3d83e9d", "metadata": {}, "source": [ "## Instrument coordinator\n", "\n", "We create and instrument coordinator to prepare and run the schedule" ] }, { "cell_type": "code", "execution_count": 21, "id": "ab163bcc", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ClusterComponent(cluster))" ] }, { "cell_type": "code", "execution_count": 22, "id": "bd14b884", "metadata": {}, "outputs": [], "source": [ "# Set the qcodes parameters and upload the schedule program\n", "instrument_coordinator.prepare(compiled_sched)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "7222d5a2", "metadata": {}, "source": [ "We can now start the playback of the schedule. If you wish to view the signals on an oscilloscope, you can make the necessary connections and set up the oscilloscope accordingly." ] }, { "cell_type": "code", "execution_count": 23, "id": "f95c25df", "metadata": {}, "outputs": [], "source": [ "# Start the hardware execution\n", "instrument_coordinator.start()" ] }, { "cell_type": "code", "execution_count": 24, "id": "69c5d38b", "metadata": {}, "outputs": [], "source": [ "instrument_coordinator.stop()" ] } ], "metadata": { "jupytext": { "formats": "ipynb,py:percent" }, "kernelspec": { "display_name": "docs", "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.16" } }, "nbformat": 4, "nbformat_minor": 5 }