Previous Versions

Release 2.42.0

Release date 28.11.2024

Requires: LabOne 24.10

Includes: Applications Library 1.1.0

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 24.10 patch release. Please see the installation instructions for a link and explanation how to update your LabOne version. It is recommended to do a clean, new install of LabOne Q to ensure all your dependencies are properly updated. Additionally, a firmware upgrade of all your instruments from within the LabOne GUI will be required after updating to the latest patch release of LabOne 24.10.
• Introduces the new decorators @workflow_options and @task_options to define a custom class to inherit from the base option classes.
• Added better visual representations to
  QPU and QuantumPlatform when calling the class instance.
• Adds support for building qubit-based experiments without using an experiment context via @qubit_experiment(context=False). Note that quantum operations that modify the experiment calibration cannot be used without the experiment context.
• Made it possible to supply instrument options in arbitrary order when adding instruments to a device setup.

Applications Library

• Updated the options classes used in the how-to guides to use the new decorators @task_options and @workflow_options.
• Adds a new how-to guide on how to use LabOne Q in conjunction with a Time Tagger Ultra from Swabian Instruments in the context of NV center experiments.

Note

Since version 2.36.0, LabOne Q uses the asynchronous LabOne API by default when communicating with instruments. If any issues arise with the asynchronous LabOne API, there is currently still the fallback option to the legacy synchronous API, using session.connect(use_async_api=False). Please notify us immediately if this situation arises. The synchronous API is now deprecated and will be removed in a future release.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug when using markers on SHFSG instruments, that in some cases led to a vector transfer error at program execution.
• Fixed a bug when using active reset together with multiplexed readout and integration kernels of different length - in this case the timing between data acquisition and playback of feedback pulses may have been incorrect.

Documentation

• Fixes for broken links and typos in the manual.
• Fixes for broken links on the Readme page of the LabOne Q Github repository - many thanks to Github user bartandrews for spotting this!
• Corrected and expanded the description of instrument options in the manual.
• Added an explanation about minimal repetition periods for repeated measurements on SHFQA instruments to the manual.

Known Issues

• Using runtime checks of the sequencer playback through the disable_runtime_checks=False argument of session.connect(), is currently not possible when the experiment contains real-time feedback or is using the on-device PRNG. In the latter case, unintended error messages may be produced if the option is used.
• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.41.0

Release date 07.11.2024

Requires: LabOne 24.10

Includes: Applications Library 1.0.0

Notes & Important Changes

Functionality

• New functionality has been added to LabOne Q core, including: Workflows, Tasks, QPUs, and QuantumOperations. Tutorials demonstrating how these can be used can be found here, and users can see how to implement this functionality for their own experiments in the Applications Library documentation here.
• Updated ways to save and work with data in Workflows using a LogbookStore, available under workflow.logbook.
• Since version 2.40, LabOne Q added support for using the new QHub Quantum System Hub in your QCCS. Add a QHub instrument to your DeviceSetup in the same way as you have been using the PQSC before, to enable synchronisation of up to 56 instrument in one QCCS. Have a look at the QHub user manual to learn more about this new instrument. Note that real-time feedback experiments are not yet supported when using a QHub.

Applications Library

The Applications Library contains reference implementations of qubits, quantum operations, experiments, and analyses for various quantum computing applications using the Zurich Instruments LabOne Q software framework. Currently, the library content is focused on superconducting-qubit implementations, where we provide many examples showing how to construct experimental pulse sequences for common measurements. In addition, we also show how to use the new Workflows of LabOne Q to create qubit calibration routines for single parameters, that create the experiment sequence, compile it, run it, and then analyse the acquired data and update the relevant qubit parameters. See the Application How-to Guides and the Workflow tutorials to learn more.

You can get the Applications Library from the laboneq_applications repository, or by installing it as pip install laboneq-applications.

The Applications Library currently contains the following:

Qubit types

• A reference implementation of a tuneable transmon qubit object, designed to be used to control and read out flux-tuneable superconducting transmon qubits in the circuit QED architecture.

Quantum Operations

• A reference implementation of common quantum operations like measure, acquire, rx, ry, rz and others, written for use with the TuneableTransmon class.

Pre-Built Experiments and Analyses using Workflows

Single-qubit calibration experiments and analyses for superconducting qubits implemented using the new LabOne Q Workflows:

• Resonator Spectroscopy
• Qubit Spectroscopy
• Amplitude Rabi
• Ramsey Interferometry
• DRAG Quadrature-Scaling Calibration
• Lifetime Measurement
• Hahn echo
• Amplitude Fine
• Dispersive Shift
• IQ Blobs
• Raw Time Traces for Optimal Readout Weights

Note

Since version 2.36.0, LabOne Q uses the asynchronous LabOne API by default when communicating with instruments. If any issues arise with the asynchronous LabOne API, there is currently still the fallback option to the legacy synchronous API, using session.connect(use_async_api=False). Please notify us immediately if this situation arises. The synchronous API is now deprecated and will be removed in a future release.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where using the PRNG without reseeding resulted in incorrect seqC code for the randomised benchmarking experiment.
• Disallowed multiplexing of an RF signal by adding a check in the DeviceSetup that raises a LabOne Q Exception if two or more rf_signals share the same local port.

Documentation

• Added a new "Applications Library" section to the LabOne Q Manual. This section includes how-to guides and implementations of LabOne Q core functionality to get you up-and-running quickly. Many new examples showcasing the use of Workflows, Tasks, QPU, and qubit classes and modules are included.
• Moved and updated the content originally in the "How-to Guides" section into the Applications-Library section of the manual. These guides remain focused on pulse-level examples for users to get familiar with the structure of experimental sequences in LabOne Q.
• Added how-to guides for building experiments with Workflows to the Applications-Library section of the manual. These guides focus on the physics and start-to-end way of working for performing quantum experiments.
• Moved the content under "Learning Guides", now called "Tutorials", into the "Functionality & Concepts" section of the manual. These guides are standalone exectutable Python notebooks intended for users to learn LabOne Q software concepts.

Note

How-to guides in the LabOne Q manual are experiment and application-specific, whereas Tutorials are intended to help users learn about concepts associated with the LabOne Q software itself. While the entire documentation is included on our website, users who prefer to download directly from GitHub will fin the how-to guides in the Applications Library GitHub repository, while core documentation (Concepts, Tutorials, API Reference) is in the LabOne Q repository.

• Restructured the "Functionality & Concepts" section of the manual into eight sections, each describing a part of the LabOne Q framework. Within each of these sections, we explain the concepts underlying this part of the software and then provide tutorials teaching you how to use the functionality.

Known Issues

• Using runtime checks of the sequencer playback through the disable_runtime_checks=False argument of session.connect(), is currently not possible when the experiment contains real-time feedback or is using the on-device PRNG. In the latter case, unintended error messages may be produced if the option is used.
• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.40.0

Release date 31.10.2024

Requires: LabOne 24.10

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 24.10. Please see the installation instructions for a link and explanation how to update your LabOne version. It is recommended to do a clean, new install of LabOne Q to ensure all your dependencies are properly updated. Additionally, a firmware upgrade of all your instruments from within the LabOne GUI will be required after updating to LabOne 24.10.
• Starting with LabOne version 24.10, a new requirement on the local oscillator (LO) centre frequency on SHF instruments is enforced. When using a channel in RF mode, the LO frequency must now be an integer multiple of 200 MHz. In LabOne Q, this requirement is enforced at compile time. If your configuration specifies an LO frequency that is not an integer multiple of 200 MHz, an exception will be raised during compilation. Please adapt your configuration accordingly.
• Added the ability to specify a value for the connection timeout for communication to the instrument to better support situations where remote connections may be slow and unreliable. Use session.connect(timeout=timeout) to specify a timeout value in seconds. If not supplied, the default timeout is 10 seconds.

Note

Since version 2.36.0, LabOne Q uses the asynchronous LabOne API by default when communicating with instruments. If any issues arise with the asynchronous LabOne API, there is currently still the fallback option to the legacy synchronous API, using session.connect(use_async_api=False). Please notify us immediately if this situation arises. The synchronous API is now deprecated and will be removed in a future release.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed the information returned by DeviceSetup.list_calibratables() to display the correct path again.

Documentation

• Structural changes to the documentation to improve presentation. Previously saved links may no longer work, please update your links.
• Fix for the discrimination experiment used to verify correct state discrimination in our example notebooks, where previously the experiment calibration was not correctly applied.

Known Issues

• Using runtime checks of the sequencer playback through the disable_runtime_checks=False argument of session.connect(), is currently not possible when the experiment contains real-time feedback or is using the on-device PRNG. In the latter case, unintended error messages may be produced if the option is used.
• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.39.0

Release date 10.10.2024

Notes & Important Changes

Functionality

• Added support for marker waveforms in the play command, by passing a pulse functional when specifying markers via {"marker": {"waveform": pulse}}.

Note

Since version 2.36.0, LabOne Q uses the asynchronous LabOne API by default when communicating with instruments. If any issues arise with the asynchronous LabOne API, there is a fallback option to the legacy synchronous API to ensure continued functionality, using session.connect(use_async_api=False). The synchronous API is now deprecated and will be removed in a future release.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Documentation

• Fixed the LabOne version in the installation instructions.
• Added a new device setup tutorial that combines our "Functionality and Concepts" page with the example notebook on programmatic device setup construction.

Known Issues

• Using runtime checks of the sequencer playback through the disable_runtime_checks=False argument of session.connect(), is currently not possible when the experiment contains real-time feedback or is using the on-device PRNG. In the latter case, unintended error messages may be produced if the option is used.
• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.38.0

Release date 26.09.2024

Notes & Important Changes

Functionality

• Added the possibility to enable runtime checks for the sequencer playback on HDAWG, SHFSG and SHFQC drive channels. These will report an error message after experiment execution in case any unintended gaps were detected in the sequence playback. The option can be enabled by passing the argument disable_runtime_checks=False when calling session.connect(). It is currently disabled by default as in some edge cases false positives may be reported. In the future we plan to enable these checks by default.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug when using raw acquisition mode that in some cases led to NaN values being reported in the result vector.

Documentation

• Extended the VQE example notebook to a full end-to-end implementation using Qiskit, openQASM, and LabOne Q.
• Added an example on near-time gate fidelity optimization using near-time callback functions and an ask-and-tell optimizer interface.
• Added documentation for the calibration property voltage offset on HDAWG instruments.

Known Issues

• Using runtime checks of the sequencer playback through the disable_runtime_checks=False argument of session.connect(), is currently not possible when the experiment contains real-time feedback or is using the on-device PRNG. In the latter case, unintended error messages may be produced if the option is used.
• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.37.0

Release date 12.09.2024

Notes & Important Changes

Functionality

• Added a compatibility check between the AWG compiler and the running dataserver version when async API is used.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Added contracts to only acquire on acquire lines and vice versa.
• Fixed a long-standing bug that caused jitter on HDAWG+UHFQA setups.
• Fixed a bug that caused standalone HDAWG experiments to occasionally get stuck in their sequencer program.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.36.0

Release date 29.08.2024

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 24.07. Please see the installation instructions for a link and explanation how to update your LabOne version. It is recommended to do a clean, new install of LabOne Q to ensure all your dependencies are properly updated. Additionally, a firmware update of all your instruments from within the LabOne UI will be required after updating to LabOne 24.07.
• LabOne Q by default now uses the new asynchronous LabOne API when communicating with the instruments. This may lead to performance improvements in certain situations, especially where many settings are synchronised with the instruments. If you experience any issues, using session.connect(use_async_api=False) restores the old behavior, using the zhinst.core API.
• Added a warning on SHF instruments if the center frequency is not a multiple of 200MHz. This warning is relevant for experiments where the phase difference between output channels that do not share a synthesizer is important, i.e. channels on different instruments or within the same instrument but not part of a pair. If centre frequencies differ by odd multiples of 100 MHz, sometimes the phase difference between synthesizers may jump by 180 degrees when re-locking to the reference clock.
• Added functionality to retrieve pulse samplers and factories after using register_pulse_functional. Use pulse_library.pulse_sampler(name) and pulse_library.pulse_factory(name) to retrieve and use the samplers / functions of the pulse functionals that are defined.
• Added the ability to use subsections within match-case statements.
• Updated the device setup builder in contrib/example_helpers/generate_device_setup.py to be able to deal with more complex setups.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Ensured that spectroscopy mode is used when using a hardware oscillator on readout and acquire lines.
• Fixed a bug leading to a failure in compilation in some cases when multiplexing LogicalSignals with different oscillators.

Documentation

• Removed the old example notebook 99_basic_experiments.ipynb and replaced it with standalone examples covering previously missing functionality.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.35.0

Release date 15.08.2024

Notes & Important Changes

Functionality

• Added support for sweeping voltage_offset for signal lines of type rf_signal in a near-time sweep.
• Enabled use of the second trigger output line on SHFQA channels.
• Adapted the Qubit and Transmon classes to use a single shared oscillator for measure and acquire signal lines. That oscillators on all signal lines now also use ModulationType.AUTO by default for convenience.
• Added the argument add_measurement to the exp_from_qasm_list function. The setting add_measurement=False can now be used to disable automatically adding measurement operations for all qubits at the end of each QASM program.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug affecting the alignment of pulses on different output channels when using a single HDAWG instrument without any other instruments.
• Fixed a bug that prevented more than one SHFPPC instruments to be used together correctly in a setup.
• Fixed a bug in parameter comparisons when the compared parameters had different number of values.

Documentation

• Adapted example notebooks the use qubits to be compatible to using a shared oscillator in measure and acquire lines.
• Adapted Rabi example experiments to use right alignment of the sweep sections, to avoid potential gaps between excitation and readout pulse playback.
• Fixed some invalid links.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.34.0

Release date 19.07.2024

Notes & Important Changes

Functionality

• Improved the self-triggering mechanism for standalone HDAWGs to use the internal ready-check mechanism.
• Added support for openQASM branching statements of the type if (a) {...} and if (a) {...} else {...} for variables a that are known at compilation time.
• Added support for openQASM logical operators like logical AND (a && b), OR (a || b), negation (!a), comparison (a > b, a >= b, a < b, and a <= b), and equality (a == b, a != b) for variables a and b that are known at compilation time.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where the usage of multiple measure pulses on a single readout signal was silently ignored. This will lead to an explicit error at compile time now. Please use a single readout pulse per measure signal.
• Fixed a bug where a SweepParameter that was defined in a SignalCalibration but not actively swept in the Experiment was silently ignored. This situation will now lead to an error at compile time.
• Fixed a bug where an Experiment that did not contain an acquire_loop did compile into an empty CompiledExperiment. This situation will now lead to an error at compile time.
• Fixed a bug that interfered with the transfer of partial results to the user code when experiment execution was interrupted by an exception.
• Fixed a bug when using multiple SHFPPC in a single setup - in this situation it was previously not possible to use the instruments individually.
• Fixed a bug when using the pipeliner, where in some rare cases instrument settings were not being set in time to be effective for the next job.
• Fixed a bug in the Oscillator object that caused a deprecated field to be set by default, resulting in spurious FutureWarning during serialisation.
• Fixed a bug in emulation mode that in some cases led to a divide by zero warning when preparing the emulated results.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Patch Release 2.33.1

Release date 04.07.2024

Bug Fixes

• Updated zhinst-core dependency to the latest patch release 24.04.60606. Please make sure to update your LabOne installation to 24.04 (patch 2), which fixes a bug with SHFQA/SHFQC where, in pulsed spectroscopy mode, the envelope waveform gets played back repeatedly instead of only when triggered.

Release 2.33.0

Release date 27.06.2024

Notes & Important Changes

Functionality

• Updated LabOne Q's dependencies to the latest LabOne patch release version 24.04.59173. Please use our download center to always download the latest LabOne version. Have a look at the LabOne release notes for version 24.04 (patch 1) for the content of the patch release.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where calling the evaluate method on a pulse functional did not work as expected, if no pulse_parameters where supplied.
• Updated tooltip and equations for the Gaussian and super-Gaussian pulses to better reflect the parameter mapping to the [-1, 1] sampling interval.
• Fixed a bug in the sequencer code generation on UHFQA that in some rare cases led to unexpected timing of readout pulse playback and signal integration.
• Fixed a bug in the OutputSimulator that did not allow it to be used for experiments using the pipeliner or near-time sweeping. For these cases, currently only the first sequence step ban be simulated.
• Fixed a bug in the pulse sheet viewer when using it together with pipelined experiments. Currently, only the first pipelined chunk will be displayed in these cases.
• Fixed a bug where playing a trigger on a signal line of type rf_signal was not working correctly.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using OutputSimulator or pulse sheet viewer with an experiment using the pipeliner or near-time sweeping, currently only the first sequence step will be displayed.

• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.32.0

Release date 05.06.2024

Notes & Important Changes

Functionality

• Allow for more flexibility of acquire commands between pipelined chunks by reworking the checks ensuring the relative timings of readout and acquire operations match what is supported by the hardware. Due to this, some experiments involving the pipeliner or complex sequences of measurements are no longer rejected. For example, experiments using RepetitionMode.AUTO for a sweep of pulse delays are now accepted. In addition, overlapping readout pulses on the same QA unit must now always start at exactly the same time. Note, that a waveform can always be padded with zeros to achieve a pulse that effectively starts later.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug that led to empty oscillator settings when generating calibration objects from any qubit instance whenever the resonance frequency of the qubit exactly matches that of its associated local oscillator.
• Fixed resetting the oscillator phase (reset_oscillator_phase) for experiments in which all signal lines are software modulated.
• Fixed compilation issue for experiments that contained multiple operations on the same signal line within match-case statements.
• Fixed race condition that occasionally caused deadlocks during the hardware synchronization step of pipelined experiments.
• Fixed a bug that led to corrupted discrimination results when executing chunked experiments following session.connect(reset_devices=True).

Documentation

• Fixed alignment of pulses in randomized benchmarking example notebook.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.31.0

Release date 24.05.2024

Notes & Important Changes

Functionality

• LabOne Q now adds timestamps to Result objects that can be accessed as results.pipeline_jobs_timestamps[<handle>]. The resulting list contains a single timestamp per pipelined chunk of the experiment. Each timestamp measures the time passed from a global, instrument specific reference (the start of the QA result logger run, which is the same for all chunks) to the first data acquisition for each chunk, i.e the first startQA command executed for that specific chunk. This provides the possibility to precisely time the acquired results for pipelined experiments over long timescales and large experiments.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Improved error messaging when an incompatible version of LabOne Q is used.
• Fixed version requirement for zhinst-utils to avoid automatic downgrade of already installed versions.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays is thus typically not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.30.0

Release date 13.05.2024

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 24.04. Please see the installation instructions for a link and explanation how to update your LabOne version. It is recommended to do a clean new install of LabOne Q to ensure all your dependencies are properly updated. Additionally, a firmware update of all your instruments will be required. This can be done from within the LabOne UI after updating to LabOne 24.04.
• With the update to LabOne 24.04, LabOne Q now also supports the muting functionality of the new SHF+ instruments, which effectively reduces the noise on idle signal lines. Please see the corresponding notebook for a usage example.
• Adjusted inconsistency between pulse amplitudes in SPECTROSCOPY and INTEGRATION mode. The pulse amplitude in SPECTROSCOPY mode is now twice as large to match that of the INTEGRATION mode. Users are advised to check that the pulse amplitudes in experiments using SPECTROSCOPY mode are still calibrated within any eventual hardware limits.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• With the support for LabOne 24.04 also a prior issue where SHF instruments differed by up to 4 ns in their trigger-to-output latency was resolved. This difference is now corrected by the firmware and all SHF instruments have the same latency. As this fix affects the timing behavior of SHF instruments and users are therefore recommended to recalibrate any relevant signal lines.
• Fixed an integer overflow issue in the AWG compiler that prevented the compilation of very long waveforms.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays is thus typically not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.29.0

Release date 25.04.2024

Notes & Important Changes

Functionality

• Introduced the new PulseSampled pulse type, which unifies PulseSampledReal and PulseSampledComplex and can serve as a drop-in replacement for either of these two.
• Added support for sweeping all individual correction_matrix elements in the mixer_calibration setting in a near-time sweep. Note, that this matrix is normalised with the infinity norm (max norm) before being set to the instrument to avoid output overflows. This will affect the sweeping behavior of individual matrix elements.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug in the connection logic for a session which occasionally led to timeouts related to reference clock switching
• Added a missing minimal version to certain package dependencies to increase dependability when installing LabOne Q into an existing python environment.

Documentation

• Added API documentation for length, increment_oscillator_phase and set_oscillator_phase arguments of the play command.
• Clarified the behavior of delays on SHFQA input and output channels in the calibration property documentation.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.28.0

Release date 11.04.2024

Notes & Important Changes

Functionality

• Added support for sweeping voltage_offsets in the mixer_calibration setting in a near-time sweep.
• Added support for parametrized defcals when using the openQASM importer.
• Added the possibility to directly access and evaluate pulse functionals. Use PulseFunctional.evaluate() to evaluate the underlying function directly and PulseFunctional.generate_sampled_pulse() to return a pulse envelope in time. The pulse library example notebook demonstrates how to use this functionality.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug affecting plot_simulation if readout pulses or integration kernels of different lengths were used.

Documentation

• Added examples for calling pulse functionals directly to the pulse library example notebook.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.27.1

Release date 27.03.2024

Notes & Important Changes

Functionality

• Removed the create_measure_gate, create_x_gate and create_reset_gate implementations from the OpenQASM module. Their utility was very limited and we recommend to define your own gate implementations in a GateStore following the demonstration in these example notebooks.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug that prevented using the SHFQC together with a SHFPPC in a standalone setup without PQSC.

Documentation

• Fixed broken internal links in various parts of the user manual and the example notebooks.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.27.0

Release date 14.03.2024

Notes & Important Changes

Functionality

• Added the name attribute to Section objects. If no uid is specified, the automatically generated uid will contain the section name as a prefix to simplify identification in complex pulse sequences. name defaults to "unnamed".
• Added the name attribute to Experiment objects. Additionally, the uid of an Experiment is no longer autogenerated when it is not specified at its creation, but will remains None in this case.
• Improved logging of compilation progress by adding information on the code generation step and logging the time taken in each step.
• Improvements to plot_simulation: Added the signal_names_to_show parameter to allow easier selection of subsets of all signal lines involved in an experiment. Added the integration_kernels_to_plot parameter, which allows to select which integration kernels to plot for acquire lines using multistate discrimination. Improvements to plotting layout.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug when testing equality of SweepParameter and LinearSweepParameter.
• Fixed a bug where not all integration kernels were displayed when using plot_simulation for acquire signals with multi-state discrimination enabled.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.26.0

Release date 29.02.2024

Notes & Important Changes

Functionality

• Added the local argument to Experiment.match(). This argument gives explicit choice of local (within one SHFQC) or global (via PQSC) result routing for real-time feedback experiments.
• Added the reset_oscillator_phase argument to exp_from_qasm and exp_from_qasm_list. This allows resetting the oscillator phase at the start of each averaging shot of the QASM program to ensure that the absolute phase is identical for each shot.
• Changes to AcquiredResult.to_xarray(). The xarray output now uses sweep parameter uid / axis_name for coordinate names.
• Added the ability to also calculate and set ideal thresholds when using the automated calculation of integration kernels for qubit or qudit state discrimination. Use the new calculate_integration_kernels_thresholds function in laboneq.analysis to obtain integration weights and thresholds from measured raw signals for each qudit state. All examples notebooks are also adapted to the new functionality.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where, when using the pipeliner and changing device setups, the PQSC may wait indefinitely for an instrument that was no longer present. This led to timeouts when executing the experiment and fetching the results. The previously suggested workaround of using reset_devices=True when connecting to the instruments is no longer necessary.
• Fixed a bug that did not allow to use the output router functionality on the SHFQC instrument.
• Fixed a bug where xarray conversion did not work when parallel sweeps where used.

Documentation

• Significantly sped up the generation of large randomized benchmarking experiments in our helper functions.
• Added the threshold settings to all example notebooks that demonstrate state discrimination, i.e. readout weight calibration, active qubit reset with HDAWG and UHFQA, active qubit reset with SHFSG and SHFQA and active multistate reset.

Deprecation notice

• Deprecated the function calculate_integration_kernels in laboneq.analysis in favor of calculate_integration_kernels_thresholds which calculates the ideal integration weights as well as the correct thresholds for a given set of raw readout traces.
• Removed get_all_signals() from the set of DSL operations. The method did not behave correctly and is not actively used.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.25.0

Release date 15.02.2024

Notes & Important Changes

Functionality

• Added the ability to change the number of pipeliner chunks when loading and executing a list of QASM programs through the exp_from_qasm import feature in combination with batch_execution_mode='pipeline'. The number of individual chunks the experiments is split into is thereby set via the pipeline_chunk_count parameter. Currently, the number of QASM experiments in the imported list needs to be divisible by the specified count.
• The Sweep class now accepts also a single SweepParameter in addition to accepting a list of SweepParameters.
• Added optional compiler diagnostics output showing details on how the compiler maps pulses specified in the DSL to waveforms uploaded to the instruments. Use log_level=15 or DIAGNOSTIC to display the additional information in the log.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug which prevented running experiments on a setup containing a SHFQA together with a SHFPPC but without PQSC.
• Fixed an issue that led to multi-state acquisition to be always scheduled at the end of its parent section.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using the pipeliner, it is strongly recommended to reset all device nodes at session.connect() through the reset_device=True argument. If not, a timeout may occur occasionally when fetching the experimental results.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.24.0

Release date 09.02.2024

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 24.01. Please see the installation instructions for a link and explanation how to update your LabOne version. It is recommended to do a clean new install of LabOne Q to ensure all your dependencies are properly updated. Additionally, a firmware update of all your instruments from within the LabOne UI will be required after updating to LabOne 24.01.
• Added support for the pipeliner feature on SHFSG, SHFQA, SHFQC and HDAWG instruments. If your experiment is not properly executing due to resource limitations, e.g. too many sequencer instructions or too much waveform memory used, you can now add the chunk_count parameter to any single sweep in your experiment definition. The experiment will then be internally divided into a number of smaller subunits, which will be efficiently uploaded and executed on the instruments, bypassing many of the previous resource limitations. Using the pipeliner currently still comes with restrictions in the experiment definition, for details, see Known Issues.
• Added support for importing lists of QASM programs into a single LabOne Q experiment, and allowing the use of the pipeliner for the execution. See this example notebook for a demonstration.
• Added support for using the on-device pseudo random number generator of SHFSG and HDAWG sequencer cores. Have a look at the example notebook for how to use this feature.
• Adapted some names in the AmplifierPump calibration property, controlling the use of the SHFPPC Parametric Pump Controller.
• AmplifierPump.pump_freq is now AmplifierPump.pump_frequency
• AmplifierPump.pump_engaged is now AmplifierPump.pump_on
• AmplifierPump.alc_engaged is now AmplifierPump.alc_on
• AmplifierPump.use_probe is now AmplifierPump.probe_on
• Added the ability to modify and sweep the port_delay parameter of an acquire line also in RAW mode, addressing a previous Known Issue.
• We became aware of some instances where the automated calculation of pulse timing in real-time feedback may be incorrect and are currently working on a fix to this issue. In the meantime, the automated minimum timing delay of pulses based on real-time feedback of measurement results was increased by 20ns to ensure reliable and correct pulse playback in all situations.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where pulse replacement in a near-time sweep was not working as expected.
• Fixed a possible unintentional behavior where the presence of long waveforms in unused memory slots on the SHFQA could block or delay the intended playback.

Documentation

• Added a reference notebook demonstrating the use of the on-device pseudo random number generator.
• Added a reference notebook demonstrating the use of the match-case statement with sweep parameters.
• Adapted the Qiskit example notebook to use the list import of QASM programs.
• Adapted the randomized benchmarking example notebook to use a LabOne Q sweep over the sequence length instead of a Python loop, allowing the use of pipeliner for the sweep execution.

Known Issues

• When using the pipeliner in an experiment by specifying a chunk_count parameter in a sweep, the number of acquire commands in each chunk currently needs to be equal. Typically this means that the number of sweep steps within each chunk has to be the same.
• When using the pipeliner, it is strongly recommended to reset all device nodes at session.connect() through the reset_device=True argument. If not, a timeout may occur occasionally when fetching the experimental results.
• In an experiment that uses the pipeliner, the timing of all acquire statements in all chunks currently needs to be the same. Using RepetitionMode.AUTO together with a sweep of pulse delays thus typically is not supported.
• In an experiment that uses the pipeliner, the pulse sheet viewer or plot_simulation will not yet work correctly.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not display the correct waveforms for these pulses.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.

Release 2.23.0

Release date 18.01.2024

Notes & Important Changes

Functionality

• LabOne Q can now be used as backend for the quantify package allowing users to compile and execute quantify schedules on LabOne Q. See https://code.orangeqs.com/opensource/quantify-zurich-instruments for details.
• The output simulation when using plot_simulation now includes also integration weights on acquire lines.
• Clarified the naming convention for markers on the HDAWG. Any RF signal will now only accept marker1, which will always correspond to the marker output . For IQ signals both marker1 and marker2 can be specified individually.
• Changes to output plotting using the plot_simulation functionality. Now the output for each physical channel involved in the experiment will only be plotted once.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug that prevented any effect of SHFQA port_delay settings in RAW acquisition mode. Such port delays are now also effective in RAW mode.
• Fixed a bug that prevented using SGCHANNELS above index 1 when using an SHFSG instrument in standalone mode.
• Fixed a regression that required oscillator increments to only occur in combination with a subsequent play command. Oscillator increments are now fixed for overlapping waveforms without needing a playback interval.

Known Issues

• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not work.
• Sweeping the port_delay settings of acquire lines in RAW mode is currently not supported.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.22.0

Release date 21.12.2023

Notes & Important Changes

Functionality

• Updated zhinst-core dependency to the latest patch release 23.10.52579. Please make sure to update your LabOne installation to 23.10 (patch 2), which includes a critical fix affecting setups using a combination of HDAWG, PQSC, and SHF devices. When updating, please also upgrade the firmware of all instruments in your setup.
• Added OpenQASM support for extern functions to be used to define gates, i.e., LabOne Q sections, and in particular, to support OpenPulse measurement functions such as capture_v2.
• Added OpenQASM extern waveform and function call support.
• Added basic support for OpenQASM inputs.
• The real-time acquire loop of an experiment and its properties are now accessible via Experiment.get_acquire_loop_rt().
• An estimate of the total run time of a compiled experiment is now accessible through the estimated_runtime property of the CompiledExperiment object. Note that this is a best-case scenario estimate and disregards any communication overhead in the execution.
• The recipe in the compiled experiment now contains information about the LabOne Q the LabOne version used in the compilation.
• Serialized objects now contain the version number. A warning is issued when deserializing a JSON with incompatible version information.
• Added support for sweeping amplitude and intermediate frequency for integration weights in a near-time loop.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where it was not possible to play a marker on an rf_signal on the second channel of any sequencer core on an HDAWG.
• Fixed a bug where compilation of playback on multiplexed logical signals did not work if virtual z-gates were involved in the sequence.

Known Issues

• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not work.

• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.21.0

Release date 07.12.2023

Notes & Important Changes

Functionality

• Added the ability to sweep pulse amplitudes and frequencies in near-time for readout pulses.
• Added a check for installed instrument options to the device setup construction. If no options or incompatible options are given, a warning message will be logged, which indicates the correct options to add. Please add this information to your device descriptors, as this will become a requirement in the future.
• Added support for markers on rf_signals on the HDAWG. Currently restricted to the first channel on a sequencer, see Known Issues.
• Enhanced the pulse sheet viewer API: for interactive mode, you can now specify the max_simulation_length parameter. Simulated signals are shown up to this specified time in seconds; signals beyond this time are not shown. The default remains 10ms when the parameter is omitted.
• Added a warning in the compiler log if SG Channels amplitude overflows due to routed outputs with Output Router and Adder (RTR) option.
• Added functionality for programmatically defining a DeviceSetup to laboneq.simple.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed incorrect amplitude of pulses on SHFSG that use software modulation, but at 0 Hz. The fix changes the on-device gain of software modulated pulses on SHFSG. While this is transparent for experiments that were compiled with the new version, any experiments compiled with the previous version may produce incorrect amplitudes when executed by the new version. To ensure consistent output, please recompile existing experiments and do not use experiment compiled with a previous LabOne Q version.
• Fixed a bug that led to all pulses in the pulse sheet viewer to be tagged as containing a marker.

Documentation

• Removed the use of DataStore to save device setups and results in the parallel tuneup example.

Known Issues

• Markers on an rf_signal on the second channel of each HDAWG sequencer core is not working. Use the first channel instead.
• When sweeping pulse amplitude or frequency for readout pulses, OutputSimulator will not work.
• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Patch Release 2.20.1

Release date 01.12.2023

Bug Fixes

• Fixed a bug that may prevent the use of HDAWG instruments without installed precompensation (PC) option in LabOne Q 2.20.

Release 2.20.0

Release date 23.11.2023

Notes & Important Changes

Functionality

• Added support for LabOne 23.10. Please see the installation instructions for a link to update your LabOne version. Additionally, a firmware update of all your instruments from within the LabOne UI is required after updating to 23.10.
• Added support for SHFSG/SHFQC Output Router and Adder (RTR) instrument option. The feature can be enabled on logical signals pointing to SGCHANNELS/N/OUTPUT calibration SignalCalibration.added_outputs by adding a list of OutputRoutes. Also added near-time sweep support for the calibration items OutputRoute.amplitude_scaling and OutputRoute.phase_shift. Using this functionality requires SHFSG/SHFQC devices with Output Router and Adder (RTR) option enabled.
• Introduced a convenience method calculate_integration_kernels under laboneq.analysis. It can be used to calculate the integration kernels for optimal state discrimination. If this function is used for kernels, the discrimination will work out of the box without the additional need to set the thresholds.
• Trying to use sweep parameters of different lengths in parallel sweeps now results in a LabOneQException. This did not raise an exception in the earlier versions of LabOne Q, but instead the longer sweep(s) values were silently ignored.
• Added support for Python 3.12.
• Loops are now always scheduled on the system grid of the device setup, no longer on the shortest grid commensurate with all the sequencers explicitly involved in the loop.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed a bug where executing a phase increment on an HDAWG could lead to the code generator erroneously issuing an oscillator switching command.
• Fixed an issue where a Session object could not be reused after executing a first experiment, resulting in unknown system states for subsequent experiments.
• Fixed a bug where compilation failed in a device setup including UHFQA and HDAWG, when only signals on the HDAWG where involved in a loop.
• Fixed a bug in the serialisation that led to spurious warnings about missing support for NumpyArrayRepr being logged.

Documentation

• Added an example notebook on how to use the output router and adder option on SHFSG instruments.
• Added an example notebook on how to construct a DeviceSetup programmatically.
• Restructured the release notes in the manual. Only the most recent release will be shown on this first page, all previous releases can be found here.

Known Issues

• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround in these cases, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.19.0

Release date 09.11.2023

Notes & Important Changes

Functionality

• The device setup can now be constructed programmatically using calls to add_instruments to add instruments, add_connections to add mappings between instrument ports and logical signals, and add_dataserver() to specify the dataserver.
• Added native support for amplitude sweeps to the OpenQASM importer.
• Acquire signals on SHFQA input channels now compensate for internal trigger-to-acquisition delays, so the arriving readout pulses are automatically aligned to the beginning of acquisition. For a loopback configuration in integration mode, this starts the integration effectively at the first sample of the readout pulse. It is now also possible to use negative port_delay values on acquire signals on the SHFQA, up to a value of -212 ns in readout mode and -220 ns in spectroscopy mode.

Note

The change to the internal delay setting on SHFQA may require a recalibration of acquisition delays compared to previous versions of LabOne Q. In practice, a fixed offset of 212 ns was added to the port_delay setting in integration, discrimination and raw readout modes, and 220 ns in spectroscopy mode.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fixed potential failures of feedback experiments if the readout was assigned to a UHFQA through an overhaul of the feedback register assignment.
• Fixed utility function has_onboard_lo in laboneq.dsl.utils to correctly process logical signal lines of SHFQC instruments.
• Resolved a possible issues in the code compression module that could lead to a stack overflow by switching from a recursive to an iterative implementation.
• An error is triggered when different integration kernels are used on the same signal line. Additional logical signals can be defined on the same physical input and used to perform integrations with different kernels.
• Phase increments at the end of a pulse sequence are no longer ignored if no actual pulse is played afterwards.

Documentation

• User functions are now called as neartime callback functions to reflect their usecase more clearly.

Deprecation notice

• The register_user_function() method of the Experiment has beend deprecated in favor of register_neartime_callback().
• LabOne 23.02 is no longer supported in release 2.19. Please upgrade to LabOne 23.06 or newer.
• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.
• Use of near-time acquire loops through the acquire_loop_nt statement is deprecated. We recommend to use a near-time sweep instead.

Known Issues

• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.18.0

Release date 26.10.2023

Notes & Important Changes

Functionality

• Add support for loops in OpenQASM programs that sweep gate parameters.
• Extended the OpenQASM importer interface to support averaging and data acquisition options.
• Allow to define conditional phase increments within match-case statements when using hardware modulation.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Bug Fixes

• Fix: callback functions can now also use strings as arguments.
• Fixed a bug where a pulse sequence was not played correctly if some pulses contained a phase increment while others did not. Now also sequences consisting of pulses with and without phase increments are played correctly.

Documentation

• New section Phase and Amplitude of Pulses containing in-depth explanations on how to control these pulse parameters.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.
• Use of near-time acquire loops through the acquire_loop_nt statement is deprecated. We recommend to use a near-time sweep instead.

Known Issues

• Applying different integration kernels in successive acquire commands on the same logical signal line will only upload and use the first kernel provided. As a workaround, use multiple logical signal lines.
• Phase increments at the end of a pulse sequence are ignored if no actual pulse is played afterwards. As a workaround, add a dummy pulse with zero amplitude after the phase increment.
• To account for the internal delay introduced by the analog to digital conversion in the frontend of the SHFQA, a minimum port_delay setting of 224ns is necessary.
• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.17.0

Release date 12.10.2023

Notes & Important Changes

Functionality

• Adapted the way how integration kernels are treated to use the same conventions that are applied to multi-state discrimination also for the two-state qubit case. This change may require users to re-run threshold calibration for state-discrimination.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Bug Fixes

• Fixed a bug where an instrument setting was incorrect when using multiple oscillators on a single SG channel.
• Fixed a bug in the serialisation of Session objects and added clearer error messaging.

Documentation

• Adapted all example notebooks that use state discrimination to use the utilities functionality to calculate the matched filter weights for ideal state discrimination.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.
• Use of near-time acquire loops through the acquire_loop_nt statement is deprecated. We recommend to use a near-time sweep instead.

Known Issues

• To account for the internal delay introduced by the analog to digital conversion in the frontend of the SHFQA, a minimum port_delay setting of 224ns is necessary.
• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.16.0

Release date 28.09.2023

Notes & Important Changes

Functionality

• Added optional formatting of results data as xarray data objects. Calling Results.acquired_results.to_xarray() returns an xarray object containing the acquired results as well as the sweep values as data axes. The dependency of LabOne Q on xarray is optional, the conversion will only work if xarray is also installed in your Python environment.
• Changed the behavior of ModulationType.AUTO to depend on the type of signal it is applied to: In integration mode, measure and acquire signals (i.e. signals on QA instruments) will be software-modulated. In spectroscopy mode, measure and acquire signals will be hardware-modulated. All signals on other instruments will be hardware-modulated.
• It is now possible to exit a near-time loops before the associated sweep is completed by calling session.abort_execution(). See the user function learning guide for an example of how to use this. Addresses this feature request.
• Performance improvement: When sweeping amplitudes of signals in experiments, it is now easier and more efficient to interleave pulses with incremented amplitude and pulses with fixed amplitude.
• Performance improvement: Reduced communication overhead, which significantly reduces the total runtimes of small experiments.
• Added a check to verify that the compiled experiment does not use more command table entries than are available on the instrument, implementing this feature request.

Note

The recently added Qubit and Transmon are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Bug Fixes

• Fixed a bug in which LabOne Q crashed in situations where an SHFQA channel does not play a pulse on the measure line but still is supposed to acquire measurement data.
• Fixed settings when using multi-state discrimination on SHFQA and SHFQC readout units to ensure correct state discrimination and, additionally, when using multiple sets of integration kernels.

Known Issues

• When using multi-state discrimination applied to two-state qubit systems, a different kernel convention is expected than for multi-state discrimination for generic multi-state systems, leading to an apparent flipping in the reported results.
• To account for the internal delay introduced by the analog to digital conversion in the frontend of the SHFQA, a minimum port_delay setting of 224ns is necessary.
• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.15.0

Release date 18.09.2023

Notes & Important Changes

Functionality

• Added support for multi-state discrimination on SHFQA and SHFQC readout units. See the new example notebook for a demonstration of how to use this feature for real-time active reset of a ququad. For details on how the feature works internally, have a look at tutorial in the SHFQA documentation.
• Added support for the port_delay parameter for logical signal lines on SHFSG and SHFQC drive lines, which can be used to compensate for different signal runtimes.
• Added support for multi-dimensional sweeps when using sequential averaging.
• Added common functionality for analysis of experimental data, useful for analysis of data from simple tuneup experiments. This functionality was previously available through contrib.

Note

The recently added Qubit and Transmon are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Bug Fixes

• Fixed a bug where it was not possible to use different length of the acquire command for the signal acquisition on a multiplexed readout line. Fixes this issue.
• Fixed a bug in the parallel tuneup notebook where sweep parameters were not properly resolved when addressing multiple hardware oscillators.

Documentation

• Updated all example notebooks to use the new analysis library instead of the deprecated functions from contrib.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.
• Using a near-time acquire loop through the acquire_loop_nt statement has been deprecated. Use a near-time sweep instead.

Known Issues

• To account for the internal delay introduced by the analog to digital conversion in the frontend of the SHFQA, a minimum port_delay setting of 234ns is necessary.
• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.14.0

Release date 31.08.2023

Notes & Important Changes

• A patch has been released for LabOne 23.06 fixing a number of issues that also affected users of LabOne Q. Please download the new release from our Download center and ensure you update the firmware of all instruments through the LabOne user interface.

Functionality

• Implemented a new background architecture for LabOne Q, improving the way the internal components interact with and depend on each other.
• Added functionality to derive a new SweepParameter from an existing one using the array manipulation capabilities of numpy. Have a look at the API reference documentation here for details.
• To improve readability, the console log output no longer contains the component information for each log message. If you require this information, have a look at the file log for the full information.
• Improved the display of expected resource usage in the compiler log.
• Improved log message output when the pulse sheet viewer needs to trigger recompilation of the experiment, e.g. when the number of displayed events has changed.
• Added support for using the direct low-frequency path on SHFQA instruments. Use the calibration setting port_mode=PortMode.LF to use.

Note

The recently added Qubit and Transmon are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Bug Fixes

• Fixed a bug where the interactive pulse sheet viewer did not work with device setups containing SHFPPC instruments.
• Fixed a bug in the pulse inspector where specifying arguments may not have had the intended effect on the displayed pulse.
• Improved the printout formatting when displaying the contents of LogicalSignals.

Documentation

• Significant updates to the API reference documentation, the example notebooks and the general structure of the manual.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.
• Using a near-time acquire loop through the acquire_loop_nt statement has been deprecated. Use a near-time sweep instead.

Known Issues

• To account for the internal delay introduced by the analog to digital conversion in the frontend of the SHFQA, a minimum port_delay setting of 234ns is necessary.
• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• When running an experiment with feedback, gaps between consecutive feedback events cannot be longer than approximately 17 seconds (2^32 sequencer cycles).

Release 2.13.0

Release date 17.08.2023

Notes & Important Changes

Functionality

• Improved API for the pulse sheet viewer. Calling show_pulse_sheet now accepts the additional arguments interactive and max_events_to_publish. The interactive argument controls whether to run the pulse sheet viewer in interactive mode within the notebook itself, where then also the waveforms of individual pulses can be inspected. This argument defaults to False. max_events_to_publish controls the maximum number of events that are displayed in the pulse sheet viewer. For performance reasons, the default value here is set to 1000, for longer experiments, this may need to be adjusted. Additionally, the compiler by default not longer generates the event list for the pulse sheet viewer when compiling an experiment, this now only happens on demand. Adjusting the number of events may now trigger a recompilation of the experiment before the pulse sheet is shown.

Bug Fixes

• Adjusted the printout of LabOne Q data objects to avoid some unwanted side effects.

Documentation

• Updated the API reference documentation.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• Using multiple QA channels with global feedback currently has a bug in LabOne 23.06. We recommend using 23.02 if multiple QA channels on a single device are needed with global feedback.

Release 2.12.0

Release date 04.08.2023

Notes & Important Changes

Functionality

• Updated to LabOne 23.06. LabOne Q 2.12 requires LabOne 23.06. Please see the installation instructions for a link to update your LabOne version. Additionally, a firmware update with LabOne is required after updating to 23.06.
• Removed the laboneq.contrib Qubit and QubitParameters classes. These were superseded by the new Qubit class added in 2.11.
• Added a list of unfulfilled real-time start conditions to the warning printed by the LabOne Q controller when starting an experiment times out.

Note

The recently added Qubit and Transmon are not yet considered stable and their APIs might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Bug Fixes

• Fix serializing and deserializing of MixerType.
• Fix real-time frequency sweeps when combined with oscillator switching.

Documentation

• Added QASM examples to the manual.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.
• Using multiple QA channels with global feedback currently has a bug in LabOne 23.06. We recommend using 23.02 if multiple QA channels on a single device are needed with global feedback.

Release 2.11.0

Release date 20.07.2023

Notes & Important Changes

Functionality

• Added Qubit and Transmon objects. They represent a higher abstraction level on top of logical signals and are intended to represent actual physical qubits within LabOne Q. Qubit has been designed to represent a generic two-level system, while the Transmon implementation is more specific towards flux-tunable superconducting transmon qubits. Both inherit from the QuantumElement parent class, which can be used to derive your own type of qubit. Qubit and Transmon contain information about the logical signal lines as well as a dictionary of parameters used to control the respective qubits. The class methods Qubit.calibration() and Transmon.calibration() can be used to create Calibration objects derived from the qubit parameters and logical signals, which may directly be applied to a DeviceSetup or an Experiment. Have a look at this example notebook for an example how to use these new objects.

Note

Qubit and Transmon are not yet considered stable and their API might still change in future versions. Comments and feedback regarding the current implementation of these objects and their use in your experiments are welcome.

• Added an importer for OpenQASM 3.0 programs to translate them into LabOne Q experiments. Currently the importer supports the following OpenQASM language constructs: box, delay, measure, reset as well as playback of single- and multi-qubit gates. Playback of parametrized gates is also possible. See the example notebooks in this folder for some demonstrations on how to use LabOne Q with OpenQASM programs.

Note

The OpenQASM importer is not yet considered stable and the API will likely change in future versions. Comments and feedback regarding its use and what additional functionality may be required are especially welcome.

Bug Fixes

• Fixed a bug where specifying the LabOne dataserver port number as a string did not work as expected.
• Corrected the default value for the beta parameters of the DRAG pulse in the pulse library to a more sensible value.

Documentation

• Changed the documentation framework to make it more accessible and intuitive to use. GitHub example notebooks are now included in the How-to and Learning Guide sections, and the API Reference has been integrated in the main documentation. Feedback is welcome!
• Added example notebooks demonstrating import of OpenQASM programs for a single step of a VQE algorithm as well as two qubit randomized benchmarking using either Qiskit input or a circuit compiled from the pyGSTi module.
• Added an example notebook demonstrating design and execution of experiments on many Qubits in parallel. See this example notebook for a demonstration of a set of tune-up experiments for many qubits in parallel.
• Adapted the propagation delay example notebook to sweep the calibration property port_delay instead of directly setting the instrument node.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Directly setting an instrument node via the set_node() command if that setting is also controlled through LabOne Q, for example as a calibration setting, may lead to unintended system states. It is recommended to use the LabOne Q calibration settings in such cases.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.

Release 2.10.0

Release date 06.07.2023

Notes & Important Changes

Functionality

• Added support for resetting instruments to a known state at session connection. Use the reset_devices argument at session.connect() to execute a factory reset of all connected instruments of the device setup. This can be useful if other interfaces or API calls are used beside LabOne Q to manipulate the state of the instruments.
• Improved readability of the output generated for all LabOne Q data classes when using a print() statement.
• Added the ability to use the measure() function as a method on a Section directly, not just on the level of a full Experiment.

Bug Fixes

• When playing markers on logical signals that are mapped to QA channels, a warning will now be produced. QA channels do not have the ability to generate sample-precise marker outputs, use triggers instead.
• Fixed a spurious compilation error, leading to incorrect sequencer code when using global delays.
• Fixed a bug where nested frequency sweeps in real-time where not executed properly on SHFSG and SHFQC instruments.
• Fixed a bug where readout pulses failed to play back when using a subset of multiplexed readout signals.

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Waveform compression is not yet supported when playing pulses in parallel on two signal lines of type rf_signal if these signal lines share a sequencer core.
• Using both marker channels of a HDAWG sequencer core with two signal lines of type rf_signal will result in an error at runtime. As a workaround, we recommend to use markers with rf_signals on different sequencer cores.
• When using LabOne 23.02 with a version below 23.02.41959, playback on SHFSG and SHFQA channels may be misaligned by 4 ns. Please download the latest version of LabOne from our Download center.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.

Release 2.9.0

Release date 27.06.2023

Notes & Important Changes

Functionality

• When using .play(…​), markers may now be played without a pulse by specifying pulse=None.
• Added support for directly measuring the power spectral density when in spectroscopy mode on the SHFQA. Use AcquisitionMode.SPECTROSCOPY_PSD for this.
• Added support for OpenQASM delay instruction.
• Added support of qubit objects in OpenQASM parser.
• Added a key-value database for LabOne Q objects.
• Added laboneq.dsl.inspect to make execution metadata available to the user.
• Removed the need for an access token to run LabOne Q on real hardware.

Bug Fixes

• Fixed a bug where signals that were played on QA output channels where missing in the output simulator.
• Fixed a bug where the QA output channel was not switched off at the end of a CW spectroscopy experiment.
• Added a warning message when attempting to use waveform compression on the SHFQA or UHFQA - waveform compression is not supported on these instruments.
• Fixed a dependency issue when installing LabOne Q.
• Made markers usable in play command without pulse information.
• Fixed multiplexing on SHFQA instruments.

Documentation

• Added a new demonstration notebook for basic experiments with color centers.
• Added a new example notebook showing how to store and retrieve LabOne Q data objects like experiments in a database.

• Added a first OpenQASM support example showing how to build and execute a parameterized VQE circuit.

• Added a new demonstration notebook for basic experiments with color centers.

• Added a new example notebook showing how to store and retrieve LabOne Q data objects like experiments in a database.
• Added a first OpenQASM support example showing how to build and execute a parameterized VQE circuit.
• Added documentation of automatic generation of a zero amplitude pulse when playing markers without pulse

Deprecation notice

• Python 3.7 and 3.8 support was removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Waveform compression is not yet supported when playing pulses in parallel on two signal lines of type rf_signal if these signal lines share a sequencer core.
• Using both marker channels of a HDAWG sequencer core with two signal lines of type rf_signal will result in an error at runtime. As a workaround, we recommend to use markers with rf_signals on different sequencer cores.
• When using LabOne 23.02 with a version below 23.02.41959, playback on SHFSG and SHFQA channels may be misaligned by 4 ns. Please download the latest version of LabOne from our Download center.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same sequencer core must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.

Release 2.8.0

Release date 08.06.2023

Notes & Important Changes

Functionality

• Added support for displaying enabled markers in the simulated output.
• Added basic support for the native Python SQLite database to save and load any LabOne Q data objects.

Bug Fixes

• Improved support for waveform compression also in cases where compressible and incompressible waveforms are mixed by the compiler.
• Fixed an issue with serialization when using an SHFPPC in the device setup.
• Improved the logic of setting the reference clocks on SHF instruments to reduce communication overhead for each experiment.

Documentation

• Embedded the new YouTube channel of LabOne Q demos.

Deprecation notice

• Python 3.7 and 3.8 support is deprecated and has been removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Using both marker channels of a HDAWG sequencer core with two signal lines of type rf_signal will result in an error at runtime. As a workaround, we recommend to use markers with rf_signals on different sequencer cores.
• When using LabOne 23.02 with a version below 23.02.41959, playback on SHFSG and SHFQA channels may be misaligned by 4{nbsp}ns. Please download the latest version of LabOne from our Download center.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same AWG must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device's minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.

Release 2.7.0

Release date 25.05.2023

Notes & Important Changes

Functionality

• The playHold functionality introduced in Release 2.6.0 has been extended to improve performance for playback when using rf_signal.
• LabOne Q now supports sweeping the port_delay property on all logical signal lines and the amplitude setting of the SHFQA readout via setup and experiment calibrations.
• Added support for waveform compression also when playing pulses in parallel on two signal lines of type rf_signal with these signal lines sharing a sequencer core.

Bug Fixes

• Spurious error when using feedback on HDAWG channels has been fixed

Release 2.6.0

Release date 11.05.2023

Notes & Important Changes

Functionality

• Improved the efficiency of experiment playback and optimized the use of the waveform memory by implementing the use of the playHold functionality of the sequencer for SHFSG and HDAWG instruments. Using the playHold command in the sequencer enables the reduction of waveform memory usage for pulses where some parts of the waveform are constant. To use this functionality, supply the optional can_compress argument to a pulse functional defining a pulse.
• Integrated a detailed timing model for local and global feedback paths when using real-time feedback with the match - case statement. The compiler will now enforce a minimum timing between an acquire statement and the following match - case condition, based on the ideal timing constraints from hardware specifications.
• Added a check and an error message when local_oscillator frequencies are set to incompatible frequencies. The center frequencies on SHFSG, SHFQC and SHFQA channels can be set between 600 MHz and 8 GHz in steps of 100 MHz, when not using LF path.

Bug Fixes

• Fixed an issue where the logger would fail if Unicode characters were part of the logging file path.

Deprecation notice

• Python 3.7 and 3.8 support is deprecated and has been removed in release 2.3.0. Please upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• Waveform compression is not yet supported when playing pulses in parallel on two signal lines of type rf_signal if these signal lines share a sequencer core.
• Using both marker channels of a HDAWG sequencer core with two signal lines of type rf_signal will result in an error at runtime. As a workaround, we recommend to use markers with rf_signals on different sequencer cores.
• When using LabOne 23.02 with a version below 23.02.41959, playback on SHFSG and SHFQA channels may be misaligned by 4{nbsp}ns. Please download the latest version of LabOne from our Download center.
• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the cw resonator spectroscopy notebook for an example.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same AWG must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device's minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.

Release 2.5.0

Release date 27.04.2023

Notes & Important Changes

Functionality

• Added support for the SHFPPC parametric pump controller in LabOne Q.
• When using reset_oscillator_phase on an SHFSG or SHFQA, the overall timing of the shot and sweep repetition rate is now automatically enforced to be commensurate with the 100 MHz grid of the local oscillators in the SHF platform. This is to ensure better reproducibility of the phase reset in these cases.
• When using voltage_offset on a signal line of type rf_signal, this signal line is now enabled by default already when calling session.connect(). Previously, signal lines were only enabled when executing an experiment using that signal line.

Documentation

• Reorganized and expanded the example notebooks and added application specific examples for superconducting qubits and spin qubits.

Release 2.4.0

Release date 13.04.2023

Notes & Important Changes

Functionality

• Added a check for compatibility of device firmware and LabOne dataserver version to increase stability.
• Added support for switching off certain physical output channels through the session.disable_output() method. See the documentation for details on how to use - related to issue 22.

Bug Fixes

• Improved the quality of compression for the sequencer code generated by the compiler to avoid issues with SHFQA and UHFQA running out of free registers. Related to issue 30 and issue 13.
• Fixed the logic for switching off HDAWG output channels to ensure this only happens when strictly necessary - fixes issue 23.
• Fixed an issue where signals on different AWG cores were not aligned in the output simulator for a standalone HDAWG setup.

Documentation

• Added a new manual chapter detailing how to use triggers and markers in LabOne Q.
• Moved commonly used convenience functionality for the example notebooks to contrib to enable simplified import from anywhere. See the example notebooks on how to use.

Release 2.3.0

Release date 30.03.2023

Notes & Important Changes

Functionality

• Further increased performance of the compiler, especially for experiments involving a very large number of sections.
• Added support for real-time feedback on setups including a PQSC. Use the Experiment.match_global statement to enable real-time feedback based on readout results on any quantum analyzer channel connected to any drive channel through a PQSC. Supported combinations of instruments are currently any combination of SHFQA, SHFSG and SHFQC.
• Added a Experiment.match statement, that chooses automatically between global or local feedback paths. See this notebook on an example how to use.
• Added support for marker output on logical signals of type rf_signal on HDAWG.
• Added support for the keywords start and length when enabling markers. The marker high will be delayed by the value of start relative to the start of the pulse playback and the total duration of the marker output will be given by its length argument.
• Enable more argument types for pulse functionals. It is now possible to use strings, integers, floats and booleans, as well as lists, dictionaries and numpy arrays of these base types as arguments for pulse functionals.
• Introduced a check for duplicate ids when creating a device setup. DeviceSetup now raises a LabOneQException if instruments have no unique UIDs.
• Enabled the command table by default also on the HDAWG, to reduce waveform memory usage and increase sequencer code efficiency.

Bug Fixes

• Fixed a bug where the delay node of markers and triggers was not correctly reset when calling session.connect(), if changes where made in the LabOne GUI.
• Fixed a bug where logical signals of type rf_signal where not supported in the Output Simulator when using the command table.

Documentation

• Adapted the real-time feedback example to also support feedback through a PQSC.
• Due to changes in the timing calculation in LabOne 23.02., adapted the necessary delay time for a standalone SHFQC when using real-time feedback.
• Moved commonly used helper functions from the example folder into laboneq.contrib, see the example notebooks for usage.

Release 2.2.0

Release date 21.03.2023

Notes & Important Changes

• LabOne Q release 2.2 requires version 23.02 of LabOne. Please download the latest release of LabOne from the Zurich Instruments Download center and make sure to update the firmware of all your instruments through the GUI before using them together with this release. Since also the core Python API has been updated with this release, we recommend to use a fresh Python environment when installing LabOne Q 2.2. For instructions, see the section on installation.

Functionality

• Enabled the new scheduler by default. If required, it is still possible to use the legacy scheduler, by using the compiler_settings={"USE_EXPERIMENTAL_SCHEDULER": False} argument at session.compile().
• Added a new Experiment.measure() method, unifying the readout pulse playback and acquire command for more streamlined experiment design.
• Enable the use of markers for signal lines of type iq_signal on SHFSG and HDAWG. Use the marker argument of the play command to enable specific marker channels during the playback of that pulse.
• Enable phase increments with the command table on HDAWG and SHFSG, significantly reducing the amount of waveforms required when changing pulse phases.
• Increased efficiency when accessing the internal data structures used in the compiler, see also https://github.com/zhinst/laboneq/issues/19. This will speed up compilation times especially for experiments using a large number of sections.
• Added methods to display pulse functionals directly in your notebook and analyze the expected response of a qubit as a function of its frequency. Have a look at this example notebook for how to use them.

Bug Fixes

• Fixed an issue with the pulse sheet viewer not displaying any data, related to https://github.com/zhinst/laboneq/issues/28.
• Fixed an issue with the generation of pulse sheets for some experiments, related to https://github.com/zhinst/laboneq/issues/29.
• Fixed a rare failure in the event scheduler for certain experiments.

Release 2.1.0

Release date 02.03.2023

Notes & Important Changes

Functionality

• Added a new scheduler for experiments. Currently this is not yet enabled by default, to enable use compiler_settings={"USE_EXPERIMENTAL_SCHEDULER": True} within session.compile().
• Added the option to fix a section to the signal grid of the used device setup. Use the parameter section(on_system_grid=True) to force the section to start and end on the system grid. This can be useful in special cases where sequencer commands need to align to section boundaries.
• When compiler setting <device>_MIN_PLAYWAVE_HINT is not multiple of device samples, it is now rounded up to the closest matching value instead of raising AssertionError.
• Introduced a check and meaningful error message to catch unsupported use of sweep parameters at an early stage. As an example trying to sweep an amplitude in a near-time loop will trigger the exception.

Bug Fixes

• Fixed a bug where putting a match / case statement within a sweep loop failed.
• Fixed a bug where using a SweepParameter as a pulse_parameter of a pulse functional led to a compiler exception when running the experiment more than once.
• Fixed a bug where unnecessary oscillator switching events where issued when multiple hardware oscillators on the same physical channel where used.
• Fixed a bug that did not allow to set an experimental calibration when the underlying logical signal calibration was not defined.

Deprecation notice

• Python 3.7 and 3.8 support is deprecated and will be removed in a future major release. It is recommended to upgrade to Python 3.9 or newer.
• The descriptor keyword "instrument_list" has been replaced by "instruments" for consistency.

Known Issues

• When running CW resonator spectroscopy with an SHFQA or SHFQC, it is necessary to set the port_delay calibration of the used acquire line to 250 ns. Have a look at the basic_experiments notebook for an example.
• To avoid potential issues with synchronization in LabOne 22.08, it is advised not to use the reference clock out of the PQSC to distribute a clock signal to the UHFQA. Instead, use an external reference clock as a common clock source.
• When delaying logical signal lines of type rf_signal via the delay_signal calibration property, all rf_signals on the same AWG must be set to the same delay.
• When delaying logical signal lines on the SHFQA via the delay_signal calibration property, the delays for the measure and acquire line must be the same; the measure pulse delay is not added to the acquire pulse delay as on the UHFQA. We recommend to use port_delay for now.
• When creating a section with very short content (below the device’s minimum waveform length), the compiler may fail to map the experiment to valid SeqC, and will generate an error. As a workaround, manually add delays to the sequence.

Release 2.0.0

Release date 17.02.2023

Notes & Important Changes

Functionality

• Added support for adding instruments to the setup descriptor without any signal lines specified. For such instruments, a data server connection will be established when calling session.connnect() such that they are available to use with toolkit from within LabOne Q.
• Added support for specifying one or multiple data servers in the setup descriptor.
• Added direct support for virtual z-gates without playing a pulse at the same time. Use Experiment.play(pulse=None, increment_oscillator_phase=z_gate_phase) to increment the phase by a given value or Experiment.play(pulse=None, set_oscillator_phase=new_phase) to set the absolute oscillator phase.
• Increased the number of sweep steps that are supported for a real-time frequency sweep on the HDAWG to 512.
• Changed the compiler settings for the SHFSG to use command table by default and shorten the minimal waveform length from 1024 to 64. This should allow more efficient use of the waveform and instruction memory of the instrument. Refer to Tips & Tricks for more information on how to modify these settings.

Bug Fixes

• Fixed a bug where real-time frequency sweeps failed when using a software oscillator.
• Fixed a bug where a trigger node address on the SHFQA was incorrect.

API changes

• Removed deprecated Session.run_all(), use Session.run() instead.
• Removed deprecated Session.set() and Session.get().
• Removed deprecated offset argument from laboneq.dsl.experiment.Experiment.section() method.
• Removed deprecated pass_v3_to_compiler argument from Session. The argument had no functionality.
• Renamed Experiment.set() to Experiment.set_node() & removed the key argument.
• Removed do_simulation argument from Session.run(). The functionality is replace with laboneq.simulator.output_simulator.OutputSimulator.
• Removed max_simulation_time instance variable from Session.

Release 1.7.0

Release date 02.02.2023

Notes & Important Changes

Functionality

• Enabled real-time frequency sweeps on HDAWG. Due to technical limitations on this instrument, the number of real-time sweep steps is currently limited to a maximum of 401.
• Introduced an error message if a duplicate section id is used in the experiment.

Bug Fixes

• Fixed a bug where waveform replacement with pulse functionals that use the same parameter names did not work as expected.
• Fixed a bug where waveforms were scaled incorrectly for playback in branching sections, leading to clipped output.
• Fixed a bug where using pass in one arm of a match-case statement could have triggered a mixed-signals compiler error.

Documentation

• Added a demonstration of real-time feedback on SHFQC. This notebook emulates active qubit reset and uses two different readout pulses to simulate the different qubit states. In the example code, the state discrimination parameters are first calibrated using optimal integration weights and the result is then used to demonstrate real-time feedback based on an arbitrary pattern of simulated qubit states.

Deprecation notice

• The next upcoming release will remove some API functionality:
  • session.run_all(experiment) - use session.run(experiment) instead
  • the offset argument of section - use either constant length for the section or RepetitionMode.CONSTANT in the outer acquisition loop
  • session.set() and session.get() - in user functions, use the toolkit functionality to read out and set node values instead
  • experiment.set() will be renamed to experiment.set_node() and its key parameter will be removed
  • simulation of the output signals via the do_simulation parameter of session.run() as well as the output_signals property of the compiled experiment - use the new OutputSimulator class instead, as demonstrated in this example notebook

Release 1.6.0

Release date 12.01.2023

Notes & Important Changes

Functionality

• Added support for waveform replacement on single rf_lines on HDAWG, see Issue 12.
• Added a user-accessible compiler setting to change the resolution of phase setting when software modulation is used. Use compiler_settings={"PHASE_RESOLUTION_BITS": number_of_bits}, default is 12 bits of resolution.

Bug Fixes

• Fix for bug "SHFQC: Number of measurements executed do not match defined", where the number of measurements executed on a SHFQC was not as expected.
• Fixed a bug where the length setting in a play command was silently ignored if it was not a SweepParameter.
• Fixed a bug where delays at the end of loops were silently ignored.
• Fixed a bug where raw readout on the SHFQA did not give reproducible results.

Release 1.5.0

Release date 15.12.2022

Notes & Important Changes

• Introduced a voltage_offset calibration property for logical signals of type rf_signal - use this to apply offsets to your single channel signals on the HDAWG.

Bug Fixes

• Fixed an issue when deserializing pulse functionals without a mixer_type argument specified. When not specified, the mixer_type now defaults to IQ.
• Fixed a bug where, when using software modulation, not all uploaded waveforms were properly modulated.
• Fixed a bug where the raw readout results on the SHFQA depended on previous signals and did not always reflect the current state of the measurements.
• Fixed a bug with phase increments of software modulated signals - the resolution of allowed increments was chosen too small, this will be a user accessible setting in the future.
• Fixed a problem with the new output simulation not working properly for signals on SHFSG and SHFQA.

Release 1.4.0

Release date 01.12.2022

Notes & Important Changes

Functionality

• Implemented a new, faster and more versatile output simulator. For examples on how to use it, see this example notebook.
• Added the possibility to change output and input range settings on all channels of HDAWG and UHFQA instruments. Use the range calibration property of any logical signal or physical channel to set these values.
• Implemented a new, more responsive pulse sheet viewer. As before use show_pulse_sheet("my_experiment", my_compiled_experiment) to generate an overview of events on all logical signals in a compiled experiment.
• Further improved the speed of saving and loading any LabOne Q data objects.

Bug fixes

• Fixed the issue that the SHFQC was only working with the six channel option.

Release 1.3.0

Release date 17.11.2022

Notes & Important Changes

Functionality

• Added initial support for using trigger outputs, through the trigger argument of section - feedback welcome!
• Replaced awg_module by the new LabOne standalone compiler, increasing the speed of session connection, sequencer code compilation and upload.
• Because of the switch to the standalone compiler, LabOne 22.08 or later is required to run LabOne Q 1.3.0
• Changed the way software modulation is applied to pulses on the UHFQA for consistency between UHFQA and SHFQA - this change may require recalibration of integration weights and thresholds on UHFQA setups after upgrading LabOne Q

Documentation

• Added example notebook demonstrating playback of consecutive signals with different hardware modulation frequencies on SHFSG channels with the command table

Bug fixes

• Fix to improve compilation speed for sequential averaging - https://github.com/zhinst/laboneq/issues/6

Release 1.2.0

Release date 03.11.2022

Notes & Important Changes

• Added support for multiplexing of HW modulated signals on SHFSG. If your application would benefit from this feature, please contact us so that we can help you implement it.
• Improved pulse library. Users can now easily extend the range of available pulse types by creating their own library. Our own standard library has been expanded as well, and will continue to grow in the future. A tutorial on our GitHub repository explains the most important features.
• Pre-compensation is now configured via signal calibration. Delays are adapted accordingly.

Release 1.1.0

Release date 20.10.2022

Notes & Important Changes

• Improved serialization and deserialization performance. Long arrays (e.g. waveforms) are now stored as binary blobs, reducing the size of generated JSON files.
• The gaussian_q pulse shape has been removed. For generating a Gaussian pulse on the Q channel, use gaussian(amplitude=1j) instead.

Patch Release 1.0.3

Release date 10.10.2022

Notes & Important Changes

• Pinned required retworkx version to 0.11 after breaking changes had been introduced with 0.12.

Patch Release 1.0.2

Release date 03.10.2022

Notes & Important Changes

• Introduced an access token required for running LabOne Q during an initial managed beta phase. Please visit https://www.zhinst.com/ch/en/install-labone-q-today to get your access token today!
• Fixed an issue with the assignment of center frequencies for the signal generator channels on an SHFQC

Release 1.0.0

Release date 27.09.2022

Notes & Important Changes

• QCCS Software has been renamed to LabOne Q
• LabOne Q now depends on LabOne release 22.08. We strongly recommend to perform a fresh install into a clean Python environment to ensure no clash of dependencies. Please also update the firmware of all devices to use to the newest version.
• It is no longer possible to specify a too short repetition length when using RepetitionMode.CONSTANT, an exception will be raised in this case.
• Hardware oscillator phase reset commands can now be issued for every iteration of sweep and averaging loops through the new parameter reset_oscillator_phase to make phases reproducible within each sweep step and averaging iteration. This new behavior is disabled by default.
• The pulse length can now be swept as parameter of the Experiment.play command.
• The parameters phase, set_oscillator_phase and increment_oscillator_phase of the Experiment.play command can now be swept.

Release 0.68

Release date 08.09.2022

Notes & Important Changes

• The device setup now offers a new physical_channel_groups attribute. This new API complements logical_signal_groups, and allows more straightforward access to parameters of physical ports on each device, including when they are shared across multiple logical signals.
• The CompiledExperiment class now has a publicly exposed API for serialization to JSON.
• Setting do_simulation=True in session.run() no longer leads to an error.

Release 0.67

Release date 25.08.2022

Notes & Important Changes

• The SHFQC can now be used as a standalone instrument, without the need for a PQSC.
• State discrimination can be used on the SHFQA. To use, set the new threshold property on the logical signal used for data acquisition and set AcquisitionType.DISCRIMINATION within the acquire loop.
• Using session.set(node_address, value) and session.get(node_address), it is now possible to set and read out the values of any instrument node from within a connected session directly.
• Using session.devices[device_id] in a connected session returns a toolkit device object that enables to address the device directly using the same functionality know from the toolkit python package. For details on how to use the device object, please refer to the toolkit documentation at https://docs.zhinst.com/zhinst-toolkit/en/latest/
• It is now possible to specify negative amplitudes in a sweep parameter
• There are now two different ways to access the results object generated when running an experiment. The property session.results delivers a reference to the results object within the session and can be used e.g. from within user functions when reading out partial results. Calling session.get_results() returns a deep copy of the results object from within the session, to be used for saving the results. session.run(experiment) by default returns the reference via session.results.
• In a near-time loop if any sweep steps exits with an error, it is now retried once and subsequently skipped at repeated error. The rest of the experiment may be executed normally.
• For experiments that generate a lot of waveforms on the HDAWG it was possible in rare cases that waveform playback was not possible seamlessly due to memory restrictions on the instrument. This behavior is now detected by QCCS SW and reported as an error to the user, so the experiment can be redesigned.

Release 0.66

Release date 11.08.2022

Notes & Important Changes

• When an error is encountered during a near-time loop, the affected step is repeated and the experiment does not fail.
• Unintended gaps in the playback of pulses on the HDAWG are now detected and signaled to the user.

Release 0.65

Release date 28.07.2022

Notes & Important Changes

• Waveform replacements of pulses works on all devices
• SW modulation and HW modulation yield the same output on all devices
• Mandatory first argument to the Experiment.call(…​) / Section.call(…​) was renamed from func to func_name - this need to be adjusted in user code, if passed as named and not positional argument

Release 0.64

Release date 14.07.2022

Notes & Important Changes

• Session.run() now accepts both compiled and raw experiments. Session.run_all() has been deprecated and will be removed in a future version.
• The output simulator does no longer run automatically when an experiment is executed. Trigger it manually by supplying do_simulation=True to Session.compile() or Session.run().
• The output simulation can also be started without a session, by calling the CompiledExperiment.simulate_outputs() method.
• The simulated output signals are now stored as part of the compiled experiment, and no longer directly as part of the results object. Find them in CompiledExperiment.output_signals with the same internal structure as previously.
• The built-in result plotter (qccs.simple.Plotter) has been removed. For examples of how to access and plot the simulated output signals, see the example notebooks.
• Mixer calibration on the HDAWG has been reworked and stabilized. This has not yet been extensively tested, feedback is welcome.

Release 0.63

Release date: 01.07.2022

Notes & Important Changes

• Improved reliability of real-time frequency sweeps on SHFQA
• Added support for real-time frequency sweeps on SHFSG
• Logging contains number of sequencer code lines and number of waveform samples that will be uploaded to instruments
• Logging levels are now adjustable

Release 0.62

Release date: 17.06.2022

Notes & Important Changes

• Real-time frequency sweeps for resonator spectroscopy are now possible on SHFQA. Limitations apply, see below.
• Small system support: A single HDAWG or SHFSG device can be used without a PQSC as a standalone device.
• Waveforms in real-time loops can be exchanged to another one with the same length via a user function.
• Integration kernels on SHFQA had inverted frequency compared to the readout pulse before, this has been corrected in this release - might require changes to user code
• It is no longer possible to mix UHFQA and SHF instruments in the same experiment
• Each near time execution step now has an automatic timeout implemented, based in the calculated real-time execution time of the step - this is to catch and prevent rare interrupts in execution

Release 0.61

Release date: 03.06.2022

Notes & Important Changes

• Support for standalone SHFSG operation
• In a setup with an SHF instrument (SHFSG, SHFQA,…​), the HDAWG sampling rate is switched to 2.0 GSa/s, allowing for a tighter combined section grid
• Consecutive Sections with signals on only one instrument can have arbitrary lengths now and are not bound to the common section grid