{ "cells": [ { "cell_type": "markdown", "id": "ea64cea5", "metadata": {}, "source": [ "(sec-timetagging)=\n", "\n", "# Tutorial: Timetagging\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`Timetagging.ipynb`\n", "```\n", "\n", "## Introduction\n", "\n", "```{admonition} Note\n", "The Timetag and TimetagTrace protocols are currently only implemented for the Qblox backend, and they are available on the **QTM**. Please also see {ref}`sec-qblox-acquisition-details` for more information on Qblox module-specific behavior of these operations.\n", "```\n", "\n", "The timetag acquisitions return the time at which the input voltage crossed a set threshold. This tutorial explores various ways to perform timetag acquisitions, using a Qblox cluster with a QCM and a QTM module. Note that only a subset of the features of these acquisitions are shown here, see the {ref}`reference guide ` for more info.\n", "\n", "## Initial setup\n", "\n", "First, we import the required classes and set up the data directory." ] }, { "cell_type": "code", "execution_count": 1, "id": "70ea4617", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Data will be saved in:\n", "/root/quantify-data\n" ] } ], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "\n", "from quantify_core.data import handling as dh\n", "from quantify_scheduler.backends.graph_compilation import SerialCompiler\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.enums import BinMode, TimeRef, TimeSource\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "from quantify_scheduler.instrument_coordinator.instrument_coordinator import (\n", " InstrumentCoordinator,\n", ")\n", "from quantify_scheduler.operations.acquisition_library import (\n", " Timetag,\n", " TimetagTrace,\n", " Trace,\n", ")\n", "from quantify_scheduler.operations.pulse_library import SquarePulse\n", "from quantify_scheduler.schedules.schedule import Schedule\n", "\n", "dh.set_datadir(dh.default_datadir())" ] }, { "cell_type": "markdown", "id": "57b9c98d", "metadata": {}, "source": [ "Next, we write the {ref}`hardware configuration `: \n", "\n", "- In the `\"hardware_description\"` we define a QCM and a QTM module (when using physical hardware, we also connect port 1 of the QCM with port 1 of the QTM).\n", "\n", "- In the `\"connectivity\"` we assign the QCM port 1 (`\"cluster0.module{QCM_SLOT}.real_output_0\"`) to a mock device port `\"qcm:out\"`, and assign the QTM port 1 (`\"cluster0.module{QTM_SLOT}.digital_output_0\"`) to the mock device port `\"qtm:in\"`.\n", "\n", "- In the {ref}`sec-qblox-digitization-thresholds` of `\"hardware_options\"` we set the value of `in_threshold_primary` field, which is the value of the voltage threshold that needs to be crossed to register a timetag in QTM modules. Note the `\"qtm:in-digital\"` key that is used here; `digital` is the default clock assigned to digital channels." ] }, { "cell_type": "code", "execution_count": 2, "id": "c9ba3296", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "QCM_SLOT = 7\n", "QTM_SLOT = 10\n", "\n", "hw_cfg = {\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " \"cluster0\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"ref\": \"internal\",\n", " \"modules\": {\n", " f\"{QCM_SLOT}\": {\"instrument_type\": \"QCM\"},\n", " f\"{QTM_SLOT}\": {\"instrument_type\": \"QTM\"},\n", " },\n", " },\n", " },\n", " \"hardware_options\": {\n", " \"digitization_thresholds\": {\"qtm:in-digital\": {\"in_threshold_primary\": 0.5}},\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " [f\"cluster0.module{QCM_SLOT}.real_output_0\", \"qcm:out\"],\n", " [f\"cluster0.module{QTM_SLOT}.digital_input_0\", \"qtm:in\"],\n", " ]\n", " },\n", "}" ] }, { "cell_type": "markdown", "id": "6f54b245", "metadata": {}, "source": [ "We create an {class}`~quantify_scheduler.instrument_coordinator.instrument_coordinator.InstrumentCoordinator` instance with a cluster, where we also provide a `dummy_cfg` dummy configuration so that this notebook can run without physical hardware (when using a real cluster, provide `identifier` instead of `dummy_cfg`)." ] }, { "cell_type": "code", "execution_count": 3, "id": "41fccf44", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "instrument_coordinator = InstrumentCoordinator(name=\"ic\")\n", "cluster = Cluster(\n", " name=\"cluster0\",\n", " # identifier=\"10.10.10.10\",\n", " dummy_cfg={\n", " QCM_SLOT: ClusterType.CLUSTER_QCM,\n", " QTM_SLOT: ClusterType.CLUSTER_QTM,\n", " },\n", ")\n", "\n", "cluster_component = ClusterComponent(cluster)\n", "instrument_coordinator.add_component(cluster_component)" ] }, { "cell_type": "markdown", "id": "5bcd1d4d", "metadata": {}, "source": [ "Finally, we define a {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` (since we do not have a \"real\" quantum device, this object serves simply to generate the compilation configuration later on)." ] }, { "cell_type": "code", "execution_count": 4, "id": "a2b568ae", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "quantum_device = QuantumDevice(name=\"quantum_device\")\n", "quantum_device.hardware_config(hw_cfg)" ] }, { "cell_type": "markdown", "id": "1a8cd16a", "metadata": {}, "source": [ "## Timetag acquisition\n", "\n", "In all examples in this tutorial, except the gate-level example, the QCM will send four pulses with increasing time between the pulses.\n", "\n", "In the first example, we'll record a single timetag using the {class}`~quantify_scheduler.operations.acquisition_library.Timetag` acquisition protocol. The event that triggers this timetag is defined by the {class}`time_source ` parameter, which we set to the first detected rising edge (`TimeSource.FIRST`). The timetag represents the time elapsed since the moment specified by the {class}`time_ref ` parameter, which we set to the start of the acquisition (`TimeRef.START`). We will simply do one repetition of the schedule.\n", "\n", "```{note}\n", "With the `bin_mode` parameter it is possible to change the behaviour of the acquisition for multiple repetitions. Please see the {ref}`reference guide ` for more information.\n", "```" ] }, { "cell_type": "code", "execution_count": 5, "id": "1b195cb5", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "sched = Schedule(\"Timetag\")\n", "\n", "sched.add(\n", " Timetag(\n", " duration=10e-6,\n", " port=\"qtm:in\",\n", " clock=\"digital\",\n", " time_source=TimeSource.FIRST,\n", " time_ref=TimeRef.START,\n", " )\n", ")\n", "\n", "square_pulse = SquarePulse(amp=1.0, duration=200e-9, port=\"qcm:out\")\n", "sched.add(square_pulse, rel_time=100e-9, ref_pt=\"start\")\n", "for rel_time in (1e-6, 2e-6, 3e-6):\n", " sched.add(square_pulse, rel_time=rel_time, ref_pt=\"start\")" ] }, { "cell_type": "markdown", "id": "2feb7dc0", "metadata": {}, "source": [ "Let's compile the schedule." ] }, { "cell_type": "code", "execution_count": 6, "id": "fb890a3b", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "compiler = SerialCompiler(name=\"compiler\")\n", "compiled_schedule = compiler.compile(\n", " schedule=sched,\n", " config=quantum_device.generate_compilation_config(),\n", ")" ] }, { "cell_type": "markdown", "id": "b943b379", "metadata": {}, "source": [ "And send it to the hardware, and execute it." ] }, { "cell_type": "code", "execution_count": null, "id": "2f487a8e", "metadata": { "tags": [ "skip-execution" ] }, "outputs": [], "source": [ "instrument_coordinator.prepare(compiled_schedule)\n", "instrument_coordinator.start()\n", "instrument_coordinator.wait_done(timeout_sec=10)\n", "acquisition = instrument_coordinator.retrieve_acquisition()" ] }, { "cell_type": "markdown", "id": "bfd0e5fc", "metadata": {}, "source": [ "The acquisition data shows one timetag, in this case around 73 ns. This value can differ depending on cable length." ] }, { "cell_type": "code", "execution_count": 7, "id": "8e628c10", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "import numpy as np\n", "import xarray as xr\n", "\n", "data_array = xr.DataArray(\n", " np.array([72.97265625]).reshape((1, 1)),\n", " dims=[\"repetition\", \"acq_index_0\"],\n", " coords={\"acq_index_0\": [0]},\n", " attrs={\"acq_protocol\": \"Timetag\"},\n", " )\n", "acquisition = xr.Dataset({0: data_array})" ] }, { "cell_type": "code", "execution_count": 8, "id": "8f3f0c8c", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 16B\n",
       "Dimensions:      (acq_index_0: 1)\n",
       "Coordinates:\n",
       "  * acq_index_0  (acq_index_0) int64 8B 0\n",
       "Data variables:\n",
       "    0            (acq_index_0) float64 8B 72.97
" ], "text/plain": [ " Size: 16B\n", "Dimensions: (acq_index_0: 1)\n", "Coordinates:\n", " * acq_index_0 (acq_index_0) int64 8B 0\n", "Data variables:\n", " 0 (acq_index_0) float64 8B 72.97" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "acquisition.isel(repetition=0)" ] }, { "cell_type": "markdown", "id": "c52c7821", "metadata": {}, "source": [ "Next up, we will show you how to record multiple timetags in an acquisition window.\n", "\n", "## TimetagTrace acquisition\n", "\n", "The {class}`~quantify_scheduler.operations.acquisition_library.TimetagTrace` acquisition can record a stream of timetags. Every time that a rising edge is detected, a timetag is recorded. Therefore, this time we expect to see 4 timetags from the 4 pulses sent by the QCM.\n", "\n", "The timetag values are equal to the time difference between the recorded rising edges and the `time_ref` ({class}`~quantify_scheduler.enums.TimeRef`), which we set to the start of the acquisition (`TimeRef.START`)." ] }, { "cell_type": "code", "execution_count": 9, "id": "649601d9", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "sched = Schedule(\"TimetagTrace\")\n", "\n", "sched.add(\n", " TimetagTrace(duration=10e-6, port=\"qtm:in\", clock=\"digital\", time_ref=TimeRef.START)\n", ")\n", "\n", "square_pulse = SquarePulse(amp=1.0, duration=200e-9, port=\"qcm:out\")\n", "sched.add(square_pulse, rel_time=100e-9, ref_pt=\"start\")\n", "for rel_time in (1e-6, 2e-6, 3e-6):\n", " sched.add(square_pulse, rel_time=rel_time, ref_pt=\"start\")" ] }, { "cell_type": "markdown", "id": "606a04e2", "metadata": {}, "source": [ "We compile the schedule." ] }, { "cell_type": "code", "execution_count": 10, "id": "f47899ad", "metadata": {}, "outputs": [], "source": [ "compiler = SerialCompiler(name=\"compiler\")\n", "compiled_schedule = compiler.compile(\n", " schedule=sched,\n", " config=quantum_device.generate_compilation_config(),\n", ")" ] }, { "cell_type": "markdown", "id": "d9d8feec", "metadata": {}, "source": [ "And we execute it on the hardware." ] }, { "cell_type": "code", "execution_count": null, "id": "267b4920", "metadata": { "tags": [ "skip-execution" ] }, "outputs": [], "source": [ "instrument_coordinator.prepare(compiled_schedule)\n", "instrument_coordinator.start()\n", "instrument_coordinator.wait_done(timeout_sec=10)\n", "\n", "acquisition = instrument_coordinator.retrieve_acquisition()" ] }, { "cell_type": "markdown", "id": "7aaa971c", "metadata": {}, "source": [ "As expected, we record 4 timetags. The first one is roughly around the same value as the single timetag recorded above, and the other ones are 1000, 3000, and 6000 ns later, respectively." ] }, { "cell_type": "code", "execution_count": 11, "id": "befdda70", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "import xarray as xr\n", "\n", "data_array = xr.DataArray(\n", " np.array([72.99365234, 1072.96435547, 3072.94970703, 6072.97314453]).reshape((1, 1, 4)),\n", " dims=[\"repetition\", \"acq_index_0\", \"trace_index_0\"],\n", " coords={\"acq_index_0\": [0], \"trace_index_0\": list(range(4))},\n", " attrs={\"acq_protocol\": \"Timetag\"},\n", " )\n", "acquisition = xr.Dataset({0: data_array})" ] }, { "cell_type": "code", "execution_count": 12, "id": "3eb76ae4", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 72B\n",
       "Dimensions:        (trace_index_0: 4)\n",
       "Coordinates:\n",
       "    acq_index_0    int64 8B 0\n",
       "  * trace_index_0  (trace_index_0) int64 32B 0 1 2 3\n",
       "Data variables:\n",
       "    0              (trace_index_0) float64 32B 72.99 1.073e+03 ... 6.073e+03
" ], "text/plain": [ " Size: 72B\n", "Dimensions: (trace_index_0: 4)\n", "Coordinates:\n", " acq_index_0 int64 8B 0\n", " * trace_index_0 (trace_index_0) int64 32B 0 1 2 3\n", "Data variables:\n", " 0 (trace_index_0) float64 32B 72.99 1.073e+03 ... 6.073e+03" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "acquisition.isel(acq_index_0=0, repetition=0)" ] }, { "cell_type": "markdown", "id": "d6a14934", "metadata": {}, "source": [ "## Trace acquisition\n", "\n", "Finally, we can measure a trace of the input signal. The QTM digitizes this signal and will return `0` whenever the voltage is below the digitization threshold, and `1` when the voltage is above. The trace has a 1 ns time resolution.\n", "\n", "We use the same schedule again, but with the {class}`~quantify_scheduler.operations.acquisition_library.Trace` protocol. Note the `bin_mode`, which must be set to `BinMode.FIRST` when using `Trace` acquisition on a QTM module." ] }, { "cell_type": "code", "execution_count": 13, "id": "8d3894a8", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "sched = Schedule(\"Trace\")\n", "\n", "sched.add(Trace(duration=10e-6, port=\"qtm:in\", clock=\"digital\", bin_mode=BinMode.FIRST))\n", "\n", "square_pulse = SquarePulse(amp=1.0, duration=200e-9, port=\"qcm:out\")\n", "sched.add(square_pulse, rel_time=100e-9, ref_pt=\"start\")\n", "for rel_time in (1e-6, 2e-6, 3e-6):\n", " sched.add(square_pulse, rel_time=rel_time, ref_pt=\"start\")" ] }, { "cell_type": "markdown", "id": "9fa6ec3d", "metadata": {}, "source": [ "We compile the schedule." ] }, { "cell_type": "code", "execution_count": 14, "id": "512ee26b", "metadata": {}, "outputs": [], "source": [ "compiler = SerialCompiler(name=\"compiler\")\n", "compiled_schedule = compiler.compile(\n", " schedule=sched,\n", " config=quantum_device.generate_compilation_config(),\n", ")" ] }, { "cell_type": "markdown", "id": "f0a505e6", "metadata": {}, "source": [ "And execute it on the hardware again." ] }, { "cell_type": "code", "execution_count": null, "id": "f08ea281", "metadata": { "tags": [ "skip-execution" ] }, "outputs": [], "source": [ "instrument_coordinator.prepare(compiled_schedule)\n", "instrument_coordinator.start()\n", "instrument_coordinator.wait_done(timeout_sec=10)\n", "\n", "acquisition = instrument_coordinator.retrieve_acquisition()" ] }, { "cell_type": "markdown", "id": "477e4513", "metadata": {}, "source": [ "The result is a trace of the pulses sent by the QCM, digitized by the QTM." ] }, { "cell_type": "code", "execution_count": 15, "id": "7d0129d7", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "import xarray as xr\n", "\n", "dummy_data = np.zeros((10000,))\n", "\n", "dummy_data[140:340] = 1\n", "dummy_data[1140:1340] = 1\n", "dummy_data[3140:3340] = 1\n", "dummy_data[6140:6340] = 1\n", "\n", "data_array = xr.DataArray(\n", " np.array(dummy_data, dtype=int).reshape(1, -1),\n", " dims=[\"acq_index_0\", \"trace_index_0\"],\n", " coords={\"acq_index_0\": [0], \"trace_index_0\": list(range(10000))},\n", " attrs={\"acq_protocol\": \"Timetag\"},\n", " )\n", "acquisition = xr.Dataset({0: data_array})" ] }, { "cell_type": "code", "execution_count": 16, "id": "f854ee7b", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "acquisition.to_dataarray().plot()" ] }, { "cell_type": "markdown", "id": "edcdabaf", "metadata": {}, "source": [ "## Gate-level: NV center example\n", "\n", "To finish the tutorial, we show how to use the timetag acquisition protocol with an NV center defined in the quantum device.\n", "\n", "To keep the tutorial focused, we only include the readout laser in the hardware configuration (and leave re-ionization and spin-pump lasers out). Again, we use port 1 of the QCM, this time connected to an optical modulator, and port 1 of the QTM, connected to a single-photon detector:" ] }, { "cell_type": "code", "execution_count": 17, "id": "365c380e", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "QCM_SLOT = 7\n", "QTM_SLOT = 10\n", "\n", "hw_cfg = {\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " \"cluster0\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"ref\": \"internal\",\n", " \"modules\": {\n", " f\"{QCM_SLOT}\": {\"instrument_type\": \"QCM\"},\n", " f\"{QTM_SLOT}\": {\"instrument_type\": \"QTM\"},\n", " },\n", " },\n", " \"red_laser\": {\"instrument_type\": \"LocalOscillator\", \"power\": 1},\n", " \"optical_mod_red_laser\": {\"instrument_type\": \"OpticalModulator\"},\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"qe0:optical_control-qe0.ge0\": {\"interm_freq\": 0.0, \"lo_freq\": None},\n", " \"qe0:optical_readout-qe0.ge0\": {\"interm_freq\": 0.0, \"lo_freq\": None},\n", " },\n", " \"digitization_thresholds\": {\n", " \"qe0:optical_readout-qe0.ge0\": {\"in_threshold_primary\": 0.5}\n", " },\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " [f\"cluster0.module{QCM_SLOT}.real_output_0\", \"optical_mod_red_laser.if\"],\n", " [\"red_laser.output\", \"optical_mod_red_laser.lo\"],\n", " [\"optical_mod_red_laser.out\", \"qe0:optical_control\"],\n", " [f\"cluster0.module{QTM_SLOT}.digital_input_0\", \"qe0:optical_readout\"],\n", " ]\n", " },\n", "}" ] }, { "cell_type": "markdown", "id": "d128f177", "metadata": {}, "source": [ "We now add a mock laser to our instrument coordinator so that the example compiles." ] }, { "cell_type": "code", "execution_count": 18, "id": "1bad0213", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "from quantify_scheduler.helpers.mock_instruments import MockLocalOscillator\n", "from quantify_scheduler.instrument_coordinator.components.generic import (\n", " GenericInstrumentCoordinatorComponent,\n", ")\n", "\n", "red_laser = MockLocalOscillator(name=\"red_laser\")\n", "instrument_coordinator.add_component(GenericInstrumentCoordinatorComponent(red_laser))" ] }, { "cell_type": "markdown", "id": "9a8fa805", "metadata": {}, "source": [ "Then we add a {class}`~quantify_scheduler.device_under_test.nv_element.BasicElectronicNVElement` (our NV center) to the quantum device. Note that measurement parameters such as `time_source` and `time_ref` are now defined on the quantum device element." ] }, { "cell_type": "code", "execution_count": 19, "id": "a03d87e2", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [], "source": [ "from quantify_scheduler.device_under_test.nv_element import BasicElectronicNVElement\n", "\n", "quantum_device.hardware_config(hw_cfg)\n", "\n", "qe0 = BasicElectronicNVElement(\"qe0\")\n", "qe0.measure.pulse_amplitude(1.0)\n", "qe0.measure.time_source(TimeSource.FIRST)\n", "qe0.measure.time_ref(TimeRef.START)\n", "qe0.clock_freqs.ge0.set(470.4e12)\n", "quantum_device.add_element(qe0)" ] }, { "cell_type": "markdown", "id": "5369d087", "metadata": {}, "source": [ "The schedule consists simply of a `Measure` operation, which includes a readout pulse (sent from the QCM to the optical modulator) and a timetag acquisition." ] }, { "cell_type": "code", "execution_count": 20, "id": "27d08b5d", "metadata": { "mystnb": { "remove_code_outputs": true } }, "outputs": [ { "data": { "text/plain": [ "{'name': 'da2bb02a-fc6c-41d1-a6c4-ac36662043e7', 'operation_id': '6045403973784129302', 'timing_constraints': [{'rel_time': 0, 'ref_schedulable': None, 'ref_pt_new': None, 'ref_pt': None}], 'label': 'da2bb02a-fc6c-41d1-a6c4-ac36662043e7'}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from quantify_scheduler.operations.gate_library import Measure\n", "\n", "sched = Schedule(\"NV Timetag\")\n", "\n", "sched.add(Measure(\"qe0\", acq_protocol=\"Timetag\", bin_mode=BinMode.APPEND))" ] }, { "cell_type": "markdown", "id": "90578020", "metadata": {}, "source": [ "Finally, we compile the schedule and show the pulse and the acquisition operation in a pulse diagram." ] }, { "cell_type": "code", "execution_count": 21, "id": "5556e4bc", "metadata": {}, "outputs": [ { "data": { "text/html": [ "