{ "cells": [ { "cell_type": "markdown", "id": "105f64cc", "metadata": {}, "source": [ "(sec-tutorial-schedulegettable)=\n", "\n", "# Tutorial: ScheduleGettable\n", "\n", "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`ScheduleGettable.ipynb`\n", "```\n", "\n", "This tutorial covers the {class}`~quantify_scheduler.gettables.ScheduleGettable` in-depth. If you're looking for more information on how to set up an experiment in general, please see {ref}`sec-tutorial-experiment`.\n", "\n", "The {class}`~quantify_scheduler.gettables.ScheduleGettable` forms the top-level interface to {mod}`quantify_scheduler`. Under the hood, it uses `quantify-scheduler` modules to compile {ref}`Schedules `, run them on your hardware and retrieve measurement data from the hardware. As the {class}`~quantify_scheduler.gettables.ScheduleGettable` uses functions that return {class}`~quantify_scheduler.schedules.schedule.Schedule`s, you can dynamically set function parameters during experiments.\n", "\n", "For those familiar with [quantify-core](https://quantify-os.org/docs/quantify-core), the interface of the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also designed to be used as a [gettable](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#settables-and-gettables) for [MeasurementControl](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control). This is convenient for large, possibly multi-dimensional measurement loops, as is demonstrated in {ref}`2D (and ND) measurement loops`.\n", "\n", "Two things are always required when using a {class}`~quantify_scheduler.gettables.ScheduleGettable`: a {ref}`QuantumDevice ` and a function that returns a {class}`~quantify_scheduler.schedules.schedule.Schedule`. We will set these up in a few example scenarios below and show how to use the {class}`~quantify_scheduler.gettables.ScheduleGettable`. More commonly used schedule functions are also included in `quantify-scheduler` out of the box. You can find them in {mod}`~.quantify_scheduler.schedules.spectroscopy_schedules`, {mod}`~.quantify_scheduler.schedules.timedomain_schedules` and {mod}`~.quantify_scheduler.schedules.trace_schedules`.\n", "\n", "(sec-schedulegettable-1dsweep-usage)=\n", "\n", "## 1D iterative measurement loop\n", "\n", "\n", "```{admonition} Setup and hardware configuration\n", "The device setup and hardware configuration for this tutorial can be viewed in the collapsed code cells. In places where you would communicate with actual hardware, dummy objects have been used. If you want to learn more about how to set up the {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` and hardware configuration, please see our other tutorials, in particular {ref}`sec-tutorial-experiment` and {ref}`sec-tutorial-compiling`.\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "id": "0d4690fb", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "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", "from quantify_core.data import handling as dh\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "from quantify_scheduler.helpers.qblox_dummy_instrument import start_dummy_cluster_armed_sequencers\n", "\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir() # change me!\n", "\n", "# We define a single transmon qubit as an element (BasicTransmonElement) of the\n", "# QuantumDevice, and populate the parameters with some reasonable values.\n", "\n", "# Device parameters\n", "ACQ_DELAY = 100e-9\n", "FREQ_01 = 4e9\n", "READOUT_AMP = 0.1\n", "READOUT_FREQ = 4.3e9\n", "PI_PULSE_AMP = 0.15\n", "LO_FREQ_QUBIT = 3.9e9\n", "LO_FREQ_READOUT = 4.5e9\n", "\n", "single_qubit_device = QuantumDevice(\"single_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "single_qubit_device.add_element(q0)\n", "\n", "# Assign device parameters to transmon element\n", "q0.measure.pulse_amp(READOUT_AMP)\n", "q0.clock_freqs.readout(READOUT_FREQ)\n", "q0.clock_freqs.f01(FREQ_01)\n", "q0.measure.acq_delay(ACQ_DELAY)\n", "q0.rxy.amp180(PI_PULSE_AMP)\n", "\n", "# For this example, we will set up a Qblox cluster hardware setup with two modules: a\n", "# QRM-RF and a QCM-RF.\n", "\n", "# Note: if you are connecting to an actual cluster, you would provide the\n", "# 'identifier' argument (the ip address, device name or serial number) instead\n", "# of the 'dummy_cfg' argument.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "# We create an InstrumentCoordinator to control the cluster and add it to the\n", "# QuantumDevice.\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "# A basic hardware configuration will be used for the two cluster modules.\n", "\n", "hardware_cfg = {\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " \"1\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"2\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " }\n", " },\n", " \"ref\": \"internal\"\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\n", " \"lo_freq\": LO_FREQ_READOUT\n", " },\n", " \"q0:mw-q0.01\": {\n", " \"lo_freq\": LO_FREQ_QUBIT\n", " }\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " [f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"],\n", " [f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"]\n", " ]\n", " }\n", "}\n", "\n", "\n", "# This hardware configuration should also be added to the quantum device.\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "1c3b1d6e", "metadata": {}, "source": [ "For this experiment, we have set up a basic {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` called `single_qubit_device`, representing a single transmon qubit.\n", "\n", "We'll now define the schedule function. A valid schedule function must contain a `repetitions` (integer) parameter (see {ref}`Repetitions`), and can contain any number of additional parameters. It must return a {class}`~quantify_scheduler.schedules.schedule.Schedule` object.\n", "\n", "The schedule function can be parameterized to loop over different values. The parameters can be scalars or arrays. For example, the schedule function defined below takes an array of values for the parameter `times`. This is called a _batched_ measurement, as will be explained further in this tutorial." ] }, { "cell_type": "code", "execution_count": 2, "id": "a27cb70f", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset, X\n", "\n", "def t1_sched(times, repetitions=1):\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(\"q0\"), label=f\"Reset {i}\")\n", " schedule.add(X(\"q0\"), label=f\"pi {i}\")\n", " # Measure tau seconds after the start of the X gate\n", " schedule.add(\n", " Measure(\"q0\", acq_index=i),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "f5dbc82d", "metadata": {}, "source": [ "Now, let's create the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_scheduler.gettables.ScheduleGettable` provides a convenient way to compile and execute schedules in just a few lines of code. The parameters can be set directly, with arrays and scalars, or through QCoDeS parameters, as shown below." ] }, { "cell_type": "code", "execution_count": 3, "id": "9b04071f", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "\n", "# The points we want to measure.\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# As QCoDeS parameter:\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "# Set the parameter. This can be done even after defining the gettable!\n", "time(times)\n", "\n", "# Or as array:\n", "time = times\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")" ] }, { "cell_type": "markdown", "id": "3e377d75", "metadata": {}, "source": [ "Note that `batched=True` here. This means we are doing a _batched_ measurement, which simply means that we tell the {class}`~quantify_scheduler.gettables.ScheduleGettable` to expect an array of values in the acquisition result. In this case, our schedule function creates one schedule for an array of times, and it includes an acquisition (the {class}`~quantify_scheduler.operations.gate_library.Measure` operation) for each point." ] }, { "cell_type": "code", "execution_count": 4, "id": "e4f2f339", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "import xarray\n", "\n", "from quantify_scheduler.waveforms import soft_square\n", "\n", "from qblox_instruments import DummyScopeAcquisitionData, DummyBinnedAcquisitionData\n", "\n", "\n", "soft_sq_samples = round(q0.measure.integration_time() * 1e9)\n", "soft_sq_times = np.arange(soft_sq_samples)\n", "soft_sq = soft_square(t=soft_sq_times, amp=0.5)\n", "scope_data_real = np.zeros(16384) # Scope trace acquires 16384 points\n", "scope_data_real[:soft_sq_samples] = soft_sq\n", "scope_data_real += np.random.randn(16384) / 500 # add some \"noise\"\n", "\n", "# Create dummy scope data with the soft square pulse on the I path and noise on\n", "# the Q path\n", "scope_data = list(zip(scope_data_real, np.random.randn(16384) / 500))\n", "\n", "dummy_scope_acquisition_data = DummyScopeAcquisitionData(\n", " data=scope_data, out_of_range=(False, False), avg_cnt=(0, 0)\n", " )\n", "\n", "ic_cluster.instrument.set_dummy_scope_acquisition_data(\n", " slot_idx=1, sequencer=None, data=dummy_scope_acquisition_data\n", ")\n", "\n", "\n", "# Dataset with T1 experiment data\n", "example_dataset = xarray.open_dataset(\"../examples/dataset.hdf5\")\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re) * 1024, float(im) * 1024)\n", " for re, im in zip(example_dataset[\"y0\"], example_dataset[\"y1\"])\n", " ],\n", ")" ] }, { "cell_type": "markdown", "id": "e228a082", "metadata": {}, "source": [ "Let's now run the experiment and retrieve the acquisitions using the {meth}`~quantify_scheduler.gettables.ScheduleGettable.get` method." ] }, { "cell_type": "code", "execution_count": 5, "id": "06069bf1", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(times, data[0], '.', label=\"real\")\n", "plt.plot(times, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Idle time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "7b37f107", "metadata": {}, "source": [ "Note that the data used here is the same as in {ref}`sec-tutorial-experiment`. The example dataset can be downloaded {download}`here <../examples/dataset.hdf5>`.\n", "\n", "As we defined 125 points in our `times` array which were measured in 125 different `acq_index`es, the acquisition result also contains 125 _I_ values (in `data[0][:]`) and 125 _Q_ values (in `data[1][:]`). The general format of the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable` is also explained in the {ref}`user guide `.\n", "\n", "## Trace measurement\n", "\n", "The previous experiment's acquisition results had one data point for each acquisition in the schedule. For a trace measurement, the data format is slightly different. To illustrate this, let us set up an experiment with a trace measurement." ] }, { "cell_type": "code", "execution_count": 6, "id": "2ae15b4e", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations.pulse_library import IdlePulse, SoftSquarePulse\n", "\n", "\n", "def trace_schedule(pulse_amp, acq_delay, port=\"q0:res\", clock=\"q0.ro\", repetitions=1):\n", " schedule = Schedule(\"Trace a pulse\", repetitions=repetitions)\n", "\n", " schedule.add(\n", " SoftSquarePulse(\n", " duration=q0.measure.integration_time(),\n", " amp=pulse_amp,\n", " port=port,\n", " clock=clock,\n", " ),\n", " label=\"trace_pulse\",\n", " )\n", "\n", " # Add acq_delay to compensate for time-of-flight of the pulse\n", " schedule.add(\n", " Measure(q0.name, acq_protocol=\"Trace\"),\n", " ref_pt=\"start\",\n", " rel_time=acq_delay,\n", " label=\"acquisition\"\n", " )\n", "\n", " return schedule" ] }, { "cell_type": "markdown", "id": "e456c1fb", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "6a544979", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:640: RuntimeWarning: Operation is interrupting previous Pulse because it starts before the previous ends, offending operation: Pulse \"SquarePulse\" (t0=1.0000000000000001e-07, duration=3e-07)\n", " warnings.warn(\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=trace_schedule,\n", " schedule_kwargs={\n", " \"pulse_amp\": 0.5,\n", " \"acq_delay\": 100e-9,\n", " },\n", " batched=True,\n", ")\n", "\n", "data = gettable.get()\n", "\n", "plt.plot(np.arange(1000)/1e9, data[0], '.', label=\"real\")\n", "plt.plot(np.arange(1000)/1e9, data[1], '.', label=\"imaginary\")\n", "plt.legend()\n", "plt.xlabel(\"Time (s)\")\n", "plt.ylabel(\"Voltage (V)\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "c7cfed74", "metadata": {}, "source": [ "This time, there is only one acquisition operation in the schedule. The measurement result contains two arrays: one for the _I_ values (`data[0][:]`), and one for the _Q_ values (`data[1][:]`) of the acquired trace.\n", "\n", "## MeasurementControl\n", "\n", "Iterating through different parameters can be done with some help from `quantify-core` as well, through the {class}`~quantify_core.measurement.control.MeasurementControl` class. The {class}`~quantify_core.measurement.control.MeasurementControl` uses settables (parameters to vary in an experiment) and gettables (in this case, our {class}`~quantify_scheduler.gettables.ScheduleGettable`). The settable must be a class that implements `set()`, such as a QCoDeS {class}`~qcodes.parameters.ManualParameter`.\n", "\n", "In this example, the settable is the `time` object, and the setpoints are a numpy array of values (`times`). These are added to the {class}`~quantify_core.measurement.control.MeasurementControl` as shown, together with the {class}`~quantify_scheduler.gettables.ScheduleGettable`. The {class}`~quantify_core.measurement.control.MeasurementControl` object will be in charge of setting the setpoints, and retrieving the measurement results through the gettable." ] }, { "cell_type": "code", "execution_count": 8, "id": "b9dcf37e", "metadata": {}, "outputs": [], "source": [ "from quantify_core.measurement.control import MeasurementControl\n", "\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = np.linspace(start=1.6e-7, stop=4.976e-5, num=125)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"times\": time},\n", " batched=True\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)" ] }, { "cell_type": "markdown", "id": "55b12804", "metadata": {}, "source": [ "The experiment is set to run fully in _batched_ mode. When using {class}`~quantify_core.measurement.control.MeasurementControl`, settables and gettables can be either batched (an array of points is set for each measurement iteration) or iterative (only one point is set per iteration). Combinations of batched and iterative settables are possible, as explained in detail in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#mixing-iterative-and-batched-settables).\n", "\n", "Settables and gettables are batched if they have the attribute `batched=True`. In {class}`~quantify_scheduler.gettables.ScheduleGettable`, this can be controlled through the `batched` argument when creating the class. For other classes, the attribute can be added dynamically if needed, as shown above for the `time` parameter.\n", "\n", "With both the gettable and the settable having `batched=True`, the {class}`~quantify_core.measurement.control.MeasurementControl` knows that it should set the entire `times` array as the settable's value (instead of repeating the experiment for each value in the array). All data points are measured without interruption and all measurement results are returned in one go. Now, let's run the experiment and retrieve the data." ] }, { "cell_type": "code", "execution_count": 9, "id": "9b766262", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t --- (None) --- \n", "Batched settable(s):\n", "\t sample \n", "Batch size limit: 125\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "68b2b90f497d4687bbdb6229d29820d7", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "dataset = measurement_control.run()" ] }, { "cell_type": "markdown", "id": "30eff0b1", "metadata": {}, "source": [ "The {class}`~quantify_core.measurement.control.MeasurementControl` class processes the data returned by the {class}`~quantify_scheduler.gettables.ScheduleGettable`, and turns it into a {class}`~xarray.Dataset`. More information on the format of this dataset can be found in the [quantify-core documentation](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#dataset)." ] }, { "cell_type": "code", "execution_count": 10, "id": "8767a90c", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 3kB\n",
       "Dimensions:  (dim_0: 125)\n",
       "Coordinates:\n",
       "    x0       (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n",
       "    y1       (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n",
       "Attributes:\n",
       "    tuid:                             20240727-041212-292-38ca5e\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 3kB\n", "Dimensions: (dim_0: 125)\n", "Coordinates:\n", " x0 (dim_0) float64 1kB 1.6e-07 5.6e-07 9.6e-07 ... 4.936e-05 4.976e-05\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 1kB -1.166 -1.141 -1.109 ... -0.737 -0.7305 -1.164\n", " y1 (dim_0) float64 1kB 0.2569 0.2138 0.2035 ... -0.2533 -0.247 0.2671\n", "Attributes:\n", " tuid: 20240727-041212-292-38ca5e\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dataset" ] }, { "cell_type": "markdown", "id": "628f5683", "metadata": {}, "source": [ "The dataset coordinates and data variables are named as generic `x` and `y` parameters. You can click on the 'Show/Hide attributes' button next to the coordinates and variables to see what they refer to.\n", "\n", "(sec-tutorial-schedulegettable-repetitions)=\n", "## Repetitions\n", "\n", "Repetition defines how many times the defined schedule will run on the hardware. Running the schedule multiple times can be useful for example if the user would like to reduce errors of acquisitions by averaging the result of multiple measurements.\n", "\n", "There are multiple ways the repetitions can be set. They are not completely independent of each other, and which setting will be taken into account depends on how you create and use the schedule.\n", "\n", "1. {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`: via `cfg_sched_repetitions` (by default it is `1024`),\n", "2. schedule function: via the `repetitions` function argument,\n", "3. {class}`~quantify_scheduler.schedules.schedule.Schedule` object: via the `repetitions` function argument of its constructor, or via its `repetitions` attribute directly,\n", "4. ({class}`~quantify_scheduler.gettables.ScheduleGettable`: currently, it is not possible to supply `repetitions` via `schedule_kwargs`).\n", "\n", "Ultimately, the {class}`~quantify_scheduler.schedules.schedule.Schedule` object is what governs the repetitions, via its `repetitions` attribute.\n", "\n", "When using a schedule function, the `repetitions` function argument sets the repetitions, provided that the schedule function passes it to the `Schedule` object. This is true for the pre-defined schedules, see {mod}`!quantify_scheduler.schedules`.\n", "\n", "However, if the experiment is run using `ScheduleGettable`, this `repetitions` function argument is set to `QuantumDevice.cfg_sched_repetitions`. Hence, typically, the schedule will run `QuantumDevice.cfg_sched_repetitions` times.\n", "\n", "### Possible mistake: ignoring `repetitions` argument\n", "\n", "Keep in mind that the schedule function should pass the `repetitions` argument to the `Schedule` initializer, otherwise both `QuantumDevice.cfg_sched_repetitions` and the `repetitions` argument of the schedule function will be ignored. For example, in the following setup, the `repetitions` will always be `1` (default for the `Schedule` object), even if `cfg_sched_repetitions` is set to `2`." ] }, { "cell_type": "code", "execution_count": 11, "id": "a550131c", "metadata": {}, "outputs": [], "source": [ "def schedule_function(q0: str, repetitions: int):\n", " schedule = Schedule(\"Example schedule\")\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "9baaae46", "metadata": {}, "source": [ "### Possible mistake: ignoring `cfg_sched_repetitions` default value\n", "\n", "Also note, that the default value of the `repetitions` argument of the schedule function will be ignored if `ScheduleGettable` is used, and it will be set to `QuantumDevice.cfg_sched_repetitions`. For example, in the following setup, `repetitions` will be `1024` (default for `QuantumDevice`), even if the default argument for `repetitions` is `2`." ] }, { "cell_type": "code", "execution_count": 12, "id": "86d9fc93", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "f7a91030", "metadata": {}, "outputs": [], "source": [ "def schedule_function(q0: str, repetitions: int = 2):\n", " schedule = Schedule(\"Example schedule\", repetitions=repetitions)\n", " schedule.add(Measure(q0, acq_index=0))\n", " return schedule\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "from quantify_scheduler.gettables import ScheduleGettable\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "836fe5ad", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "6c096791", "metadata": { "mystnb": { "code_prompt_show": "Set up the quantum device, dummy hardware and hardware configuration" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType, DummyBinnedAcquisitionData\n", "\n", "from quantify_scheduler.device_under_test.quantum_device import QuantumDevice\n", "from quantify_scheduler.device_under_test.transmon_element import BasicTransmonElement\n", "from quantify_scheduler.instrument_coordinator import InstrumentCoordinator\n", "from quantify_scheduler.instrument_coordinator.components.qblox import ClusterComponent\n", "\n", "\n", "single_qubit_device.close_all()\n", "\n", "# Device parameters\n", "Q0_ACQ_DELAY = 100e-9\n", "Q0_FREQ_01 = 4e9\n", "Q0_READOUT_AMP = 0.1\n", "Q0_READOUT_FREQ = 4.3e9\n", "Q0_PI_PULSE_AMP = 0.15\n", "Q0_LO_FREQ_QUBIT = 3.9e9\n", "Q0_LO_FREQ_READOUT = 4.5e9\n", "\n", "Q1_ACQ_DELAY = 120e-9\n", "Q1_FREQ_01 = 4.1e9\n", "Q1_READOUT_AMP = 0.1\n", "Q1_READOUT_FREQ = 3.8e9\n", "Q1_PI_PULSE_AMP = 0.15\n", "Q1_LO_FREQ_QUBIT = 4.1e9\n", "Q1_LO_FREQ_READOUT = 3.8e9\n", "\n", "two_qubit_device = QuantumDevice(\"two_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "q0.measure.acq_channel(0)\n", "q0.measure.pulse_amp(Q0_READOUT_AMP)\n", "q0.clock_freqs.readout(Q0_READOUT_FREQ)\n", "q0.clock_freqs.f01(Q0_FREQ_01)\n", "q0.measure.acq_delay(Q0_ACQ_DELAY)\n", "q0.rxy.amp180(Q0_PI_PULSE_AMP)\n", "\n", "q1 = BasicTransmonElement(\"q1\")\n", "q1.measure.acq_channel(1) # Note that we're specifying that measurements on q1 should use a different measurement channel\n", "q1.measure.pulse_amp(Q1_READOUT_AMP)\n", "q1.clock_freqs.readout(Q1_READOUT_FREQ)\n", "q1.clock_freqs.f01(Q1_FREQ_01)\n", "q1.measure.acq_delay(Q1_ACQ_DELAY)\n", "q1.rxy.amp180(Q1_PI_PULSE_AMP)\n", "\n", "two_qubit_device.add_element(q0)\n", "two_qubit_device.add_element(q1)\n", "\n", "# We will need to adjust the hardware configuration.\n", "\n", "# Note: if you are connecting to an actual cluster, you would provide the\n", "# 'identifier' argument (the ip address, device name or serial number) instead\n", "# of the 'dummy_cfg' argument.\n", "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " 3: ClusterType.CLUSTER_QRM_RF,\n", " 4: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "# Temporarily fixing dummy cluster's deficiency.\n", "cluster.start_sequencer = lambda : start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "two_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)\n", "\n", "hardware_cfg = {\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " \"1\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"2\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " },\n", " \"3\": {\n", " \"instrument_type\": \"QRM_RF\"\n", " },\n", " \"4\": {\n", " \"instrument_type\": \"QCM_RF\"\n", " }\n", " },\n", " \"ref\": \"internal\"\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\n", " \"lo_freq\": Q0_LO_FREQ_READOUT\n", " },\n", " \"q0:mw-q0.01\": {\n", " \"lo_freq\": Q0_LO_FREQ_QUBIT\n", " },\n", " \"q1:res-q1.ro\": {\n", " \"lo_freq\": Q1_LO_FREQ_READOUT\n", " },\n", " \"q1:mw-q1.01\": {\n", " \"lo_freq\": Q1_LO_FREQ_QUBIT\n", " }\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " [f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"],\n", " [f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"],\n", " [f\"{cluster.name}.module3.complex_output_0\", \"q1:res\"],\n", " [f\"{cluster.name}.module4.complex_output_0\", \"q1:mw\"]\n", " ]\n", " }\n", "}\n", "\n", "\n", "two_qubit_device.hardware_config(hardware_cfg)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[DummyBinnedAcquisitionData(data=(0.0, 0.0), thres=0, avg_cnt=0)]\n", ")" ] }, { "cell_type": "markdown", "id": "403f3cfc", "metadata": {}, "source": [ "2D and higher-dimensional measurement loops are easy to realize. Below we show an example Chevron experiment, which is a type of two-qubit experiment often performed on transmon qubits. The experiment includes a square pulse, and we want to vary both its amplitude and duration in a 2D grid. We have already set up a two-qubit {class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice` under the variable name `two_qubit_device`.\n", "\n", "We define simple schedule below with a parameterized amplitude and duration of the square pulse. `duration` and `amp` are scalars, so for each measurement point the schedule will be recompiled." ] }, { "cell_type": "code", "execution_count": 15, "id": "46bb87e1", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations.gate_library import Measure, Reset, X, X90\n", "from quantify_scheduler.operations.pulse_library import SquarePulse\n", "\n", "def chevron_schedule_not_batched(duration, amp, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\") # Start at the end of the reset\n", " # We specify a clock for tutorial purposes, Chevron experiments do not necessarily use modulated square pulses\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square) # Start at the end of the square pulse\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\", # Start at the same time as the other measure\n", " )\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "43c0b59b", "metadata": {}, "source": [ "We set up a non-batched measurement with {class}`~quantify_core.measurement.control.MeasurementControl` and a {class}`~quantify_scheduler.gettables.ScheduleGettable`. For this {class}`~quantify_scheduler.gettables.ScheduleGettable`, notice the keyword argument `num_channels=2`, which is needed since we specified in the quantum device elements that the measurements on `\"q0\"` and `\"q1\"` should end up in two different channels.\n", "\n", "In addition, we used another new argument in the {class}`~quantify_scheduler.gettables.ScheduleGettable`: `real_imag=False`. `real_imag` can be used to transform the acquisition data. If it is `True` (the default), the I and Q values will be returned, and if it is `False`, the data will be transformed to the absolute value and the phase (in degrees, in the interval `(-180, 180]`)." ] }, { "cell_type": "code", "execution_count": 16, "id": "d689ba83", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "c3322f3ebb8b4256aee7dd6ade250883", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "measurement_control = MeasurementControl(\"measurement_control\")\n", "\n", "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = False\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_not_batched,\n", " schedule_kwargs={\"duration\": duration, \"amp\": amplitude},\n", " batched=False,\n", " real_imag=False,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes]) # note: setpoints_grid instead of setpoints\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 17, "id": "d27986d4", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y1       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y2       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "    y3       (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
       "Attributes:\n",
       "    tuid:                             20240727-041213-807-9fc70d\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y1 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y2 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", " y3 (x0, x1) float64 480B 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", "Attributes:\n", " tuid: 20240727-041213-807-9fc70d\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "79592e06", "metadata": {}, "source": [ "As expected, this dataset contains double the amount of coordinates and data variables (note that the actual data has been mocked and set to 0.0). The two coordinates refer to the settables, `duration` and `amplitude`. With `real_imag` now set to `False`, the data variables contain the magnitude and phase (as opposed to the I and Q voltages) for measurements on `\"q0\"` and `\"q1\"`.\n", "\n", "### Batched 2D experiment\n", "\n", "Since this measurement is not batched, it's rather slow. Let's make this faster with (partial) batching.\n", "\n", "We will batch the amplitudes together, so we change the amplitudes parameter in the schedule function to an array." ] }, { "cell_type": "code", "execution_count": 18, "id": "a40fc47d", "metadata": { "mystnb": { "code_prompt_show": "Provide the dummy hardware with acquisition data" }, "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import DummyBinnedAcquisitionData\n", "\n", "\n", "def get_dummy_binned_acquisition_data(real: float, imag: float):\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=0, avg_cnt=0)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=3, sequencer=0, acq_index_name=\"0\", data=[get_dummy_binned_acquisition_data(re * 10, im * 10) for re, im in zip(range(-5, 5), range(5, -5, -1))]\n", ")" ] }, { "cell_type": "code", "execution_count": 19, "id": "12760abe", "metadata": {}, "outputs": [], "source": [ "def chevron_schedule_batched(duration, amps, repetitions=1):\n", " sched = Schedule(\"Chevron Experiment\", repetitions=repetitions)\n", "\n", " acq_idx = 0\n", "\n", " for amp in amps:\n", " reset = sched.add(Reset(\"q0\", \"q1\"))\n", " sched.add(X(\"q0\"), ref_op=reset, ref_pt=\"end\")\n", " square = sched.add(SquarePulse(amp=amp, duration=duration, port=\"q0:mw\", clock=\"q0.01\"))\n", " sched.add(X90(\"q0\"), ref_op=square)\n", " sched.add(X90(\"q1\"), ref_op=square)\n", " sched.add(Measure(\"q0\", acq_index=acq_idx), label=f\"M q0 {acq_idx}\")\n", " sched.add(\n", " Measure(\"q1\", acq_index=acq_idx),\n", " label=f\"M q1 {acq_idx}\",\n", " ref_pt=\"start\",\n", " )\n", "\n", " acq_idx += 1\n", "\n", " return sched" ] }, { "cell_type": "markdown", "id": "4b2c37c0", "metadata": {}, "source": [ "We specify that we want to batch the amplitudes by setting ``amplitude.batched = True`` and ``batched=True``as keyword argument for the gettable. Finally, we run this experiment just as before." ] }, { "cell_type": "code", "execution_count": 20, "id": "710fbc1e", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting batched measurement...\n", "Iterative settable(s) [outer loop(s)]:\n", "\t duration \n", "Batched settable(s):\n", "\t amplitude \n", "Batch size limit: 60\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "a071980198f24e4e9a7b67fe8441454c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Completed: 0%| [ elapsed time: 00:00 | time left: ? ] it" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Configure the settables\n", "duration = ManualParameter(\"duration\", label=\"Duration\", unit=\"s\")\n", "duration.batched = False\n", "\n", "durations = np.linspace(start=20e-9, stop=60e-9, num=6)\n", "\n", "amplitude = ManualParameter(\"amplitude\", label=\"Amplitude\", unit=\"V\")\n", "amplitude.batched = True\n", "\n", "amplitudes = np.linspace(start=0.1, stop=1.0, num=10)\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=two_qubit_device,\n", " schedule_function=chevron_schedule_batched,\n", " schedule_kwargs={\"duration\": duration, \"amps\": amplitude},\n", " batched=True,\n", " real_imag=False,\n", " data_labels=[\"Magnitude Q0\", \"Phase Q0\", \"Magnitude Q1\", \"Phase Q1\"],\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables([duration, amplitude])\n", "measurement_control.setpoints_grid([durations, amplitudes])\n", "measurement_control.gettables(gettable)\n", "\n", "# Run!\n", "dataset = measurement_control.run()\n", "dset_grid = dh.to_gridded_dataset(dataset)" ] }, { "cell_type": "code", "execution_count": 21, "id": "e6786c24", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 2kB\n",
       "Dimensions:  (x0: 6, x1: 10)\n",
       "Coordinates:\n",
       "  * x0       (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n",
       "  * x1       (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n",
       "Data variables:\n",
       "    y0       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y1       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "    y2       (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n",
       "    y3       (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n",
       "Attributes:\n",
       "    tuid:                             20240727-041222-848-35ea9a\n",
       "    name:                             \n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         True\n",
       "    1d_2_settables_uniformly_spaced:  False\n",
       "    xlen:                             6\n",
       "    ylen:                             10
" ], "text/plain": [ " Size: 2kB\n", "Dimensions: (x0: 6, x1: 10)\n", "Coordinates:\n", " * x0 (x0) float64 48B 2e-08 2.8e-08 3.6e-08 4.4e-08 5.2e-08 6e-08\n", " * x1 (x1) float64 80B 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0\n", "Data variables:\n", " y0 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y1 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", " y2 (x0, x1) float64 480B 0.07071 0.05657 0.04243 ... 0.04243 0.05657\n", " y3 (x0, x1) float64 480B 135.0 135.0 135.0 135.0 ... -45.0 -45.0 -45.0\n", "Attributes:\n", " tuid: 20240727-041222-848-35ea9a\n", " name: \n", " grid_2d: False\n", " grid_2d_uniformly_spaced: True\n", " 1d_2_settables_uniformly_spaced: False\n", " xlen: 6\n", " ylen: 10" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dset_grid" ] }, { "cell_type": "markdown", "id": "d600ec34", "metadata": {}, "source": [ "The shape of the dataset is no different from the previous (non-batched) experiment, but the metadata is a little different. Some coordinates and data variables now have the `batched=True` attribute. We also introduced another keyword argument: the `data_labels`. These `data_labels` are picked up by the {class}`~quantify_core.measurement.control.MeasurementControl`and end up in the {class}`xarray.Dataset` as the \"long_name\" of attributes. For example, `\"y0\"`s label can be accessed through `dataset[\"y0\"].attrs[\"long_name\"]`. The various plotting features of `quantify-core` will use this name to get labels for the figure axes." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "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.19" }, "source_map": [ 6, 34, 143, 151, 168, 172, 197, 201, 249, 253, 265, 275, 301, 305, 324, 334, 358, 366, 371, 375, 377, 403, 419, 425, 432, 447, 453, 589, 595, 619, 625, 662, 664, 674, 694, 716, 720, 756, 758 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "02ba67b51bfa43ffb4039c92f2fdfda1": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_b53ed88043ec463cae56b41fdbe0eb95", "placeholder": "​", "style": "IPY_MODEL_e763add058bc4934bfd42d0ab3d82cc5", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "11978bf7b8d64fc0b9433b5e2a6616f4": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "1a73209ef31e40279bdaa9d9c6852c89": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "24baae579f0a42e7b340b1bd11dc9996": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "27be7e5819fb4f29b6dfae33df9e0d8f": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "2f79b28b741345cb9a5380eea21a4d0e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "30a0ab5426be4173a06faeb259b70f68": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "31240ba25d8248c395dfd129030f5cf1": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "38192bc6779742f8bc2c7e46ab744f24": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_8bd85dae2ac04c4b81670479c52b6f55", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_40fca2a47bfa4ff3a8b826df103e061f", "tabbable": null, "tooltip": null, "value": 100.0 } }, "40fca2a47bfa4ff3a8b826df103e061f": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "566539829ba64d51b2eaac83036e9c40": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_27be7e5819fb4f29b6dfae33df9e0d8f", "placeholder": "​", "style": "IPY_MODEL_cd8430950d6245f68205e0bd10f5f7f3", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "57890f89954a4afab46e6331a6a9b3fa": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "5f233e80125a4552a280bffdd58f8e19": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_67b5f9646e2447f5b315afd357e9084b", "placeholder": "​", "style": "IPY_MODEL_57890f89954a4afab46e6331a6a9b3fa", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "67b5f9646e2447f5b315afd357e9084b": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "68b2b90f497d4687bbdb6229d29820d7": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_566539829ba64d51b2eaac83036e9c40", "IPY_MODEL_38192bc6779742f8bc2c7e46ab744f24", "IPY_MODEL_02ba67b51bfa43ffb4039c92f2fdfda1" ], "layout": "IPY_MODEL_b17bee9c052543ca8f80f0964e8c27a3", "tabbable": null, "tooltip": null } }, "80da3a43192448a7a0b45cb7360bb4b8": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "ProgressStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "ProgressStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "bar_color": null, "description_width": "" } }, "860cd58ffef0492394d85d1e7a3989b6": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "8bd85dae2ac04c4b81670479c52b6f55": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "98845a5c504049b38e6869b2538c00a0": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "a071980198f24e4e9a7b67fe8441454c": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_d8354112b7fd439481567ad1493c1f2a", "IPY_MODEL_c2c771c5121f4d47a97d3d8e2b897bae", "IPY_MODEL_5f233e80125a4552a280bffdd58f8e19" ], "layout": "IPY_MODEL_c84a8f41d5d249c58b030524721a3dd8", "tabbable": null, "tooltip": null } }, "b17bee9c052543ca8f80f0964e8c27a3": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "b53ed88043ec463cae56b41fdbe0eb95": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "b76da28e33764dbcbba8804c36e9e406": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "bc5b4b97d2664c5d81214b6f0068040e": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_11978bf7b8d64fc0b9433b5e2a6616f4", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_30a0ab5426be4173a06faeb259b70f68", "tabbable": null, "tooltip": null, "value": 100.0 } }, "bf0cb1af8bf947748e49b3a23caf1c5d": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "bf8325d68d4a4ea48da7a883c644f75a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_31240ba25d8248c395dfd129030f5cf1", "placeholder": "​", "style": "IPY_MODEL_98845a5c504049b38e6869b2538c00a0", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "c2c771c5121f4d47a97d3d8e2b897bae": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "FloatProgressModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "FloatProgressModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "ProgressView", "bar_style": "success", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_860cd58ffef0492394d85d1e7a3989b6", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_80da3a43192448a7a0b45cb7360bb4b8", "tabbable": null, "tooltip": null, "value": 100.0 } }, "c3322f3ebb8b4256aee7dd6ade250883": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HBoxModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HBoxModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HBoxView", "box_style": "", "children": [ "IPY_MODEL_bf8325d68d4a4ea48da7a883c644f75a", "IPY_MODEL_bc5b4b97d2664c5d81214b6f0068040e", "IPY_MODEL_ddb136789f474323a6ca6d953f126547" ], "layout": "IPY_MODEL_b76da28e33764dbcbba8804c36e9e406", "tabbable": null, "tooltip": null } }, "c84a8f41d5d249c58b030524721a3dd8": { "model_module": "@jupyter-widgets/base", "model_module_version": "2.0.0", "model_name": "LayoutModel", "state": { "_model_module": "@jupyter-widgets/base", "_model_module_version": "2.0.0", "_model_name": "LayoutModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "LayoutView", "align_content": null, "align_items": null, "align_self": null, "border_bottom": null, "border_left": null, "border_right": null, "border_top": null, "bottom": null, "display": null, "flex": null, "flex_flow": null, "grid_area": null, "grid_auto_columns": null, "grid_auto_flow": null, "grid_auto_rows": null, "grid_column": null, "grid_gap": null, "grid_row": null, "grid_template_areas": null, "grid_template_columns": null, "grid_template_rows": null, "height": null, "justify_content": null, "justify_items": null, "left": null, "margin": null, "max_height": null, "max_width": null, "min_height": null, "min_width": null, "object_fit": null, "object_position": null, "order": null, "overflow": null, "padding": null, "right": null, "top": null, "visibility": null, "width": null } }, "cd8430950d6245f68205e0bd10f5f7f3": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } }, "d8354112b7fd439481567ad1493c1f2a": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_bf0cb1af8bf947748e49b3a23caf1c5d", "placeholder": "​", "style": "IPY_MODEL_24baae579f0a42e7b340b1bd11dc9996", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "ddb136789f474323a6ca6d953f126547": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLModel", "state": { "_dom_classes": [], "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLModel", "_view_count": null, "_view_module": "@jupyter-widgets/controls", "_view_module_version": "2.0.0", "_view_name": "HTMLView", "description": "", "description_allow_html": false, "layout": "IPY_MODEL_1a73209ef31e40279bdaa9d9c6852c89", "placeholder": "​", "style": "IPY_MODEL_2f79b28b741345cb9a5380eea21a4d0e", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:08 | time left: 00:00 ] " } }, "e763add058bc4934bfd42d0ab3d82cc5": { "model_module": "@jupyter-widgets/controls", "model_module_version": "2.0.0", "model_name": "HTMLStyleModel", "state": { "_model_module": "@jupyter-widgets/controls", "_model_module_version": "2.0.0", "_model_name": "HTMLStyleModel", "_view_count": null, "_view_module": "@jupyter-widgets/base", "_view_module_version": "2.0.0", "_view_name": "StyleView", "background": null, "description_width": "", "font_size": null, "text_color": null } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }