{ "cells": [ { "cell_type": "markdown", "id": "4e7d4d76", "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": "7d431b55", "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 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": "9eae1395", "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": "377f0865", "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": "fb720816", "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": "87c43d20", "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": "6704632a", "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": "bd84283d", "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": "06528d51", "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": "8d875863", "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": "2825fa77", "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": "0ba01c91", "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": "32c3e505", "metadata": {}, "source": [ "Again, we define the gettable and run the experiment." ] }, { "cell_type": "code", "execution_count": 7, "id": "cfd78f1f", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:724: 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": "eb1c6819", "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": "767a94e0", "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": "f1143234", "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": "6a55f71c", "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": "8f4a32b10ed04e60bad107c1756626be", "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": "3278efed", "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": "a87eb129", "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:                             20250428-110352-881-5c7080\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: 20250428-110352-881-5c7080\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": "90b72c74", "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": "987a018f", "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": "fb034f66", "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": "1ea1233b", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "quantum_device.close()" ] }, { "cell_type": "code", "execution_count": 13, "id": "9f4c422c", "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": "b9c89410", "metadata": {}, "source": [ "(sec-schedulegettable-2dsweep-usage)=\n", "\n", "## 2D (and ND) measurement loops" ] }, { "cell_type": "code", "execution_count": 14, "id": "22d0915a", "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": "75880cde", "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": "76f5d0e4", "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": "cba2180c", "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": "dfed9aaf", "metadata": { "tags": [ "hide-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Starting iterative measurement...\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "0aa1bd06779a4b2cbb8910e1ad46f9ad", "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": "e3ec78f3", "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:                             20250428-110354-101-0b046e\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: 20250428-110354-101-0b046e\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": "704e9467", "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": "616a80b3", "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": "1dbdad7f", "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": "6f3115c4", "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": "4971615c", "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": "ba5de3d0b0a247b8a61a2540c70f322f", "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": "e5c5b0a4", "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:                             20250428-110359-306-d78502\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: 20250428-110359-306-d78502\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": "b2461e64", "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.22" }, "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": { "0aa1bd06779a4b2cbb8910e1ad46f9ad": { "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_eea7b14a57ca476e907f2801e77fa868", "IPY_MODEL_4ac8059252eb4b13b16eacac014bb9d9", "IPY_MODEL_610d3eccae3146a1904680cedf2a0113" ], "layout": "IPY_MODEL_f355493d621e4a989d34a8b3fafca408", "tabbable": null, "tooltip": null } }, "2c397e3c516548b6b888173840a41c48": { "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": "" } }, "2ee4e447dff14b98942f845ee738b36d": { "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 } }, "3321ce2032d74deda21b2cf95b64d158": { "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 } }, "3e80a1dd5b444dfab348d317d43d846c": { "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_6f5e5684859b4e3aaaa1940e375b2389", "placeholder": "​", "style": "IPY_MODEL_2ee4e447dff14b98942f845ee738b36d", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 10" } }, "459771eca1ac47a8bbf69710b462cde2": { "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_cc9180077e204f55a961aefec14ddbc9", "placeholder": "​", "style": "IPY_MODEL_a3fc2c824e564d0baa0ce9fe956c11ee", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "4ac8059252eb4b13b16eacac014bb9d9": { "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_cc1e3f3bf9df4b3bb1a3fae32ac0b757", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_8ce432340d06424e8e12f17bd79c82aa", "tabbable": null, "tooltip": null, "value": 100.0 } }, "54b512cd6e724da59ec47e19fb0c75f6": { "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_61c7366923eb46589846bee3f7b9e8bf", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_6a3da4f54f3d44a492f4c30d5c36c6ce", "tabbable": null, "tooltip": null, "value": 100.0 } }, "59b1e2598926482b80727763a18057be": { "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 } }, "59b58f6f3a8b428aa7c958820f2b0e25": { "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_bc6adb14e3c0440f8bcaa93fe91708a7", "placeholder": "​", "style": "IPY_MODEL_b96ffb76622a41229052e16486b51c19", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:00 | time left: 00:00 ]  last batch size: 125" } }, "610d3eccae3146a1904680cedf2a0113": { "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_c219eb8cfd324a2990f3fd68fcdba5dd", "placeholder": "​", "style": "IPY_MODEL_3321ce2032d74deda21b2cf95b64d158", "tabbable": null, "tooltip": null, "value": " [ elapsed time: 00:04 | time left: 00:00 ] " } }, "61c7366923eb46589846bee3f7b9e8bf": { "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 } }, "6a3da4f54f3d44a492f4c30d5c36c6ce": { "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": "" } }, "6f5e5684859b4e3aaaa1940e375b2389": { "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 } }, "6fcf613c8c3146b7a20a43350ef6c606": { "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 } }, "7977c303a65b4ae68998d21ae8dcb4b0": { "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 } }, "7aa3c00ce94a4ae18daf894aa35eb530": { "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 } }, "8ce432340d06424e8e12f17bd79c82aa": { "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": "" } }, "8f4a32b10ed04e60bad107c1756626be": { "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_459771eca1ac47a8bbf69710b462cde2", "IPY_MODEL_54b512cd6e724da59ec47e19fb0c75f6", "IPY_MODEL_59b58f6f3a8b428aa7c958820f2b0e25" ], "layout": "IPY_MODEL_59b1e2598926482b80727763a18057be", "tabbable": null, "tooltip": null } }, "9476694994794d7a8d0847110f97fc97": { "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_6fcf613c8c3146b7a20a43350ef6c606", "placeholder": "​", "style": "IPY_MODEL_7aa3c00ce94a4ae18daf894aa35eb530", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "9ccd86bf907b4697aa1fcb9ac131f992": { "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_b6ca8a9a586c4e69be2215e8449ed950", "max": 100.0, "min": 0.0, "orientation": "horizontal", "style": "IPY_MODEL_2c397e3c516548b6b888173840a41c48", "tabbable": null, "tooltip": null, "value": 100.0 } }, "a3fc2c824e564d0baa0ce9fe956c11ee": { "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 } }, "b6ca8a9a586c4e69be2215e8449ed950": { "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 } }, "b96ffb76622a41229052e16486b51c19": { "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 } }, "ba5de3d0b0a247b8a61a2540c70f322f": { "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_9476694994794d7a8d0847110f97fc97", "IPY_MODEL_9ccd86bf907b4697aa1fcb9ac131f992", "IPY_MODEL_3e80a1dd5b444dfab348d317d43d846c" ], "layout": "IPY_MODEL_f74b905dc2f74020b987b3a8f40c9db1", "tabbable": null, "tooltip": null } }, "bc6adb14e3c0440f8bcaa93fe91708a7": { "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 } }, "c219eb8cfd324a2990f3fd68fcdba5dd": { "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 } }, "cc1e3f3bf9df4b3bb1a3fae32ac0b757": { "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 } }, "cc9180077e204f55a961aefec14ddbc9": { "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 } }, "e41decbdca254d429c47bdaa153bed5e": { "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 } }, "eea7b14a57ca476e907f2801e77fa868": { "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_7977c303a65b4ae68998d21ae8dcb4b0", "placeholder": "​", "style": "IPY_MODEL_e41decbdca254d429c47bdaa153bed5e", "tabbable": null, "tooltip": null, "value": "Completed: 100%" } }, "f355493d621e4a989d34a8b3fafca408": { "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 } }, "f74b905dc2f74020b987b3a8f40c9db1": { "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 } } }, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }