{ "cells": [ { "cell_type": "markdown", "id": "69f2009b", "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": "29c880e2", "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", "/Users/user/quantify-data\n" ] } ], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "from quantify_core.data import handling as dh\n", "\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent, start_dummy_cluster_armed_sequencers\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", " \"version\": \"0.2\",\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}.module1.complex_input_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": "a268a867", "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": "36729fbd", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations 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": "6f0e0405", "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": "a2defb0c", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "from qcodes.instrument.parameter import ManualParameter\n", "\n", "from quantify_scheduler 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": "19447789", "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": "cbb49c02", "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": "c1cf1753", "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": "e5791dc2", "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": "8265eb84", "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": "793f11b5", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.operations 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": "4c6b28f9", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "d9eaf419", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/user/Documents/qblox/quantify-scheduler/quantify_scheduler/backends/qblox/compiler_abc.py:703: 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": "9f552910", "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": "cc5715fb", "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": "93f8d022", "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": "d3975a85", "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": "5a17a86cc5c546919b2c74b5d204b042", "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": "10871254", "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": "d029bba2", "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:                             20250408-154544-283-7a0b72\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: 20250408-154544-283-7a0b72\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": "6122655e", "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": "4fa00708", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import QuantumDevice, ScheduleGettable\n", "\n", "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", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "quantum_device.cfg_sched_repetitions(2)\n", "\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "bf1586d8", "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": "431b6819", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "61fb7abf", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import QuantumDevice, ScheduleGettable\n", "\n", "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", "quantum_device = QuantumDevice(name=\"quantum_sample\")\n", "\n", "schedule_gettable = ScheduleGettable(\n", " quantum_device=quantum_device,\n", " schedule_function=schedule_function,\n", " schedule_kwargs={\"q0\": \"q0\"},\n", ")" ] }, { "cell_type": "markdown", "id": "9427c6a4", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "10b72035", "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 import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.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", " \"version\": \"0.2\",\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}.module1.complex_input_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}.module3.complex_input_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": "308ae54c", "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": "eef2ee6f", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler import Schedule\n", "from quantify_scheduler.operations import Measure, Reset, SquarePulse, X, X90\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": "a0cf4a15", "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": "41d41cff", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b3442a586a884eef88876771c86b1609", "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": "5670c812", "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:                             20250408-154544-880-432284\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: 20250408-154544-880-432284\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": "dfcaa935", "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": "7569d23a", "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": "5b95a74a", "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": "0a5a13e0", "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": "e7a8c7f6", "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": "b2206dd55002446a84d404a917bf9715", "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": "7f79351a", "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:                             20250408-154552-230-679c6c\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: 20250408-154552-230-679c6c\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": "c6031482", "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.21" }, "source_map": [ 6, 34, 141, 149, 166, 170, 195, 199, 247, 251, 263, 273, 299, 303, 322, 332, 356, 364, 369, 373, 375, 401, 417, 423, 430, 445, 451, 588, 594, 617, 623, 660, 662, 672, 692, 714, 718, 754, 756 ], "widgets": { "application/vnd.jupyter.widget-state+json": { "state": { "318c0b4c309a43ec97b380febb3b585c": { "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_3d2e875bca0f40a1a6fb00d63f3def7c", "placeholder": "​", "style": "IPY_MODEL_6891e877cfed4515b7bc7b232d8963d5", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "3c1e8ed96a984e50a8023bb0cb31dd22": { "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 } }, "3d2e875bca0f40a1a6fb00d63f3def7c": { "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 } }, "4792ba7168c44408a961e217eee462f1": { "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": "" } }, "50371084623b43ea97b4aef7c1133d0b": { "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": "" } }, "5380e8b6f9ea4b1bbede7e06827d4a00": { "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 } }, "5a17a86cc5c546919b2c74b5d204b042": { "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_5f7b1204916d499095e1911c257e5b7c", "IPY_MODEL_b55b0f4f4fe14092939b3c7db247acc4", "IPY_MODEL_5ad15b394d3a4b42a3b6eeac5a9612e9" ], "layout": "IPY_MODEL_d5dd7799ecce40a8bdc5301961456ca7", "tabbable": null, "tooltip": null } }, "5ad15b394d3a4b42a3b6eeac5a9612e9": { "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_3c1e8ed96a984e50a8023bb0cb31dd22", "placeholder": "​", "style": "IPY_MODEL_bcdb36f7bf8942f794733cd25ee3c855", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "5f7b1204916d499095e1911c257e5b7c": { "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_e1e049366ee04746a9fbf43a3cdc3c03", "placeholder": "​", "style": "IPY_MODEL_e11dc837eadd49a891822a9da2180788", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "609b70128ed64403b9006b3f2f64068d": { "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_9b4ad8e6d47d42aeab3a7ccac734ca83", "placeholder": "​", "style": "IPY_MODEL_dfac924895c442338fdccddb049aab0e", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "615f5dabcff54dd59cb7edeb67855db1": { "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 } }, "6891e877cfed4515b7bc7b232d8963d5": { "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 } }, "6dda90f45bc94931ae0033c4258cd591": { "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 } }, "7377d4a8c06e4331a69379a2056f13ca": { "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 } }, "77893003fc8644f8ab62fb001b5fa9a5": { "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 } }, "78a6c04d65b54bc5bc40db034b265271": { "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 } }, "9b4ad8e6d47d42aeab3a7ccac734ca83": { "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 } }, "a45b6fb39c404f0ab5085af5c8610467": { "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_615f5dabcff54dd59cb7edeb67855db1", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_4792ba7168c44408a961e217eee462f1", "tabbable": null, "tooltip": null, "value": 100.0 } }, "b2206dd55002446a84d404a917bf9715": { "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_f6f68c766b2f47aabf2b73a6fe3da96d", "IPY_MODEL_e39a98490cce420a838b69f6af5ea9cd", "IPY_MODEL_318c0b4c309a43ec97b380febb3b585c" ], "layout": "IPY_MODEL_e7dd082fc4df4887b1e83e56b0d9ea13", "tabbable": null, "tooltip": null } }, "b3442a586a884eef88876771c86b1609": { "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_609b70128ed64403b9006b3f2f64068d", "IPY_MODEL_a45b6fb39c404f0ab5085af5c8610467", "IPY_MODEL_db5676fbe5624473a20062add5429edf" ], "layout": "IPY_MODEL_6dda90f45bc94931ae0033c4258cd591", "tabbable": null, "tooltip": null } }, "b3f05545d43245d88f654b822810395e": { "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 } }, "b55b0f4f4fe14092939b3c7db247acc4": { "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_b3f05545d43245d88f654b822810395e", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_f25bcb723ccd445eb2a897cc97f45705", "tabbable": null, "tooltip": null, "value": 100.0 } }, "bcdb36f7bf8942f794733cd25ee3c855": { "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 } }, "d5dd7799ecce40a8bdc5301961456ca7": { "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 } }, "d6ade1828f6a47348621ad1d4106709d": { "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 } }, "db5676fbe5624473a20062add5429edf": { "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_77893003fc8644f8ab62fb001b5fa9a5", "placeholder": "​", "style": "IPY_MODEL_d6ade1828f6a47348621ad1d4106709d", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:06 | time left: 00:00 ] " } }, "dfac924895c442338fdccddb049aab0e": { "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 } }, "e11dc837eadd49a891822a9da2180788": { "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 } }, "e1e049366ee04746a9fbf43a3cdc3c03": { "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 } }, "e39a98490cce420a838b69f6af5ea9cd": { "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_5380e8b6f9ea4b1bbede7e06827d4a00", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_50371084623b43ea97b4aef7c1133d0b", "tabbable": null, "tooltip": null, "value": 100.0 } }, "e7dd082fc4df4887b1e83e56b0d9ea13": { "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 } }, "f25bcb723ccd445eb2a897cc97f45705": { "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": "" } }, "f6f68c766b2f47aabf2b73a6fe3da96d": { "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_78a6c04d65b54bc5bc40db034b265271", "placeholder": "​", "style": "IPY_MODEL_7377d4a8c06e4331a69379a2056f13ca", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }