Previous Versions

Release 2.61.0

Release date 09.10.2025

Requires: LabOne 25.07

Includes: Applications Library 2.15.0

Notes & Important Changes

Functionality

• Added automated chunking support to the OpenQASM transpiler. The new "automated_chunking" parameter may be passed to exp_from_qasm_list or .batch_experiment. The "pipeliner" batch_mode was renamed to "chunking" to more accurately reflect what it does and to align with terminology used in the rest of LabOne Q.
• The update method of the QPU class has been extended to allow updating the edge parameters in the QPUTopology in addition to the parameters of the quantum elements. Have a look at this tutorial to learn how to use the qpu.update method for edge parameters.
• Modified the Experiment, Section, and DeviceSetup classes to prevent the accidental creation of new attributes (by making them slotted). Breaking change As a result of this, the __dict__ attribute is no longer accessible for these classes.
• Added the Workflow.replace_task method, which recursively replaces all occurrences of a task in a workflow with a different user-defined task. For more information, please see the Replacing the tasks section of the Workflows tutorial.

Applications Library

• Added the flux_range attribute to TunableTransmonQubitParameters, which controls the maximum output in the flux channel.
• Added the TunableCoupler and TunableCouplerParameters classes.

Deprecation notice

Note

The update_quantum_elements method in the QPU class has been deprecated and will be removed at the end of January 2026. Please use the more general update method instead, which can update the parameters for both quantum elements and topology edges.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated and will be removed at the end of January 2026. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• Fixed a hardware null-offset error on UHF and enhanced the emulator to validate input types, raising clear errors for unsupported values.
• Fixed phase-reset handling for hardware-modulated and multiplexed signals, enabling correct per-signal resets and timing. Previously, reset_oscillator_phase could be ignored or affect the wrong signals, and necessary timing gaps weren’t inserted, causing incorrect phases at pulse start. For more details, check out the section Explicit Phase Resets in DSL on the page Amplitude and Phase of Pulses and Phase Resets in the Section tutorial.
• When instantiating a QPU object with multiple quantum operations, the QPU is now attached to the resulting CombinedOperations object. This means that the QPU is now also an attribute of its combined quantum operations, which is particularly useful for accessing the QPU topology from within a new quantum operation definition.
• Fixed a bug in contrib/single_qubit_randomized_benchmarking.py which was causing the RB pulses to be added twice.

Documentation

• Added the Using the QPU topology with quantum operations section to the QPU topology tutorial.

Known Issues

• Using the reset_signal_oscillator_phase() on signals of type rf_signal is currently not supported.
• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.

Patch Release 2.60.1

Release date 26.09.2025

Requires: LabOne 25.07

Includes: Applications Library 2.14.0

Notes & Important Changes

This is a bug fix release which includes some changes that were accidentally left out of 2.60.0:

• The combine_results task can only be invoked from within a Workflow.
• Fixed accessing results via Results.data when handle prefixes overlapped.
• Removal of the warnings about the change of Operation.op to return a MultiMethod (the change itself is already in 2.60.0).

See the release notes for 2.60.0 below for the detailed descriptions.

Release 2.60.0

Release date 25.09.2025

Requires: LabOne 25.07

Includes: Applications Library 2.14.0

Notes & Important Changes

Functionality

• Breaking change The Operation.op property now returns a MultiMethod instead of a Callable. A MultiMethod is a function mapping that dispatches based on QuantumElement types. I.e., the MultiMethod mapping is keyed by "simplified type signatures", such that non-QuantumElement types are replaced by object. Replace self.op with self.op[simplified_type_signature]. For example, to call the operation with type signature (object, Transmon, int, float), you can write self.op[(object, Transmon, object, object)]. For operations without type hints, use self.op[()].
• Breaking change The Operation.BASE_OPS class attribute is now of type dict[str, MultiMethod] | None. To call a function directly, use self.BASE_OPS[op_name][simplified_type_signature], as explained above. For operations without type hints, use self.BASE_OPS[op_name][()].
• Breaking change The combine_results task can only be invoked from within a Workflow. Additionally, its input parameters are no longer saved by the FolderStore by default; the task output continues to be saved.
• Breaking change In the QPUTopology class, the neighbours method has been renamed to neighbors (American English).
• Modified QPUTopology.plot to return the Axes object.
• Added support for serializing common analysis workflow results to the folder store. Short tuples and lists with simple elements are now stored directly in the folder store log file. Dictionaries of QuantumParameters or QuantumElements are saved as JSON files using LabOneQ's DSL object serializer. ModelResults from the lmfit package are serialized to JSON using their .summary() method. Scikit Learn estimators have all their estimator parameters serialized to JSON. Variables from the uncertainties packaged have their value and standard-deviation saved as JSON files.
• Added an update_edge method to the QPUTopology class, which can update the parameters of a topology edge. This is analogous to the update method in the QuantumElement class, which can update the parameters of a quantum element.
• Added a general update method to the QPU class, which can update the parameters of both quantum elements and topology edges. The QPU.update_quantum_elements method has been deprecated.

Applications Library

• Breaking change Added a general update_qpu task, which can update the parameters of both quantum elements and topology edges. The update_qubits task has been removed. All the experiment-workflow modules and the rest of the codebase have been updated to use update_qpu instead of update_qubits.

Upcoming changes in the next release

• A Workflow.replace_task method will be added, which recursively replaces all occurrences of a task in a workflow with a different user-defined task.

Deprecation notice

Note

The update_quantum_elements method in the QPU class has been deprecated. Please use the more general update method instead, which can update the parameters for both quantum elements and topology edges.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• Fixed sessions getting stuck in InvalidStateError after SIGINT (Ctrl+C) interruptions.
• Fixed unnecessary hardware oscillator phase resets when resetting the phase of software-modulated signals.
• Fixed errors when resetting the phase of software-modulated signals off the sequencer grid.
• Fixed accessing results via Results.data when handle prefixes overlapped (for example, q1/measurement and q11/measurement), which previously raised an exception when printing Results.data["q1"].
• Fixed listing results via Results.data so that iterating over it (for example, list(results.data)) returns only data handles, not common handle prefixes; for a single handle q1/measurement, it now lists only q1/measurement.

Documentation

• Added a new section to the QPU and QPU Topology tutorial describing how to use edge parameters.
• Updated the "Recording Experiment Workflow Results" tutorial with a description of how the FolderStore saves inputs and outputs. A more complete description of what is stored directly in log.jsonl and what is saved to disk as separate files was added, along with a description of what types are supported in each case. Examples were added showing how to control whether errors or warnings are raised for unsupported inputs and outputs, and how to turn off input and output saving entirely, using the new save_mode option of the FolderStore.

Known Issues

• Using the reset_signal_oscillator_phase() on signals of type rf_signal is currently not supported.
• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.59.0

Release date 11.09.2025

Requires: LabOne 25.07

Includes: Applications Library 2.13.0

Notes & Important Changes

Functionality

• When using baseband signals through rf_signal, LabOne Q now performs software modulation in full complex form. This means complex pulse envelopes such as DRAG can be used with such signals. Previously, the imaginary part of a complex pulse envelope was simply dropped before modulation. In hardware modulation mode, the behavior remains unchanged.
• Added QPU, QPUTopology, and QuantumPlatform to laboneq.simple.

Upcoming changes in the next release

• Breaking change Starting with LabOne Q 2.60.0 coming out on 25.09.2025, the .op property of the Operation class will return a MultiMethod instead of a Callable. A MultiMethod is a dictionary of functions that is keyed by their simplified type signatures. Following this change, please replace self.op with self.op[simplified_type_signature] to continue using existing code, where simplified_type_signature is the tuple of simplified types used for function dispatching. For example, for a quantum operation that was defined without type hints, you can replace self.op with self.op[()].

Similarly, the self.BASE_OPS class attribute will be of type dict[str, MultiMethod] | None starting from LabOne Q 2.60.0, which will be released on 25.09.2025. Following this change, to call a function directly, please replace self.BASE_OPS[op_name] with self.BASE_OPS[op_name][simplified_type_signature]. For example, for a quantum operation that was defined without type hints, you can replace self.BASE_OPS[op_name] with self.BASE_OPS[op_name][()].

• Breaking change Starting with LabOne Q 2.60.0 coming out on 25.09.2025, the combine_results task will no longer be callable outside a Workflow. In addition, the input parameters of this task will no longer be saved by the FolderStore be default. The output will continue to be saved.

Deprecation notice

Note

Support for LabOne 25.04 has been removed. Now the minimum supported LabOne version is 25.07.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• Fixed a bug where chunked experiment results were not arranged correctly when acquisition was inside nested real-time sweeps and an inner sweep was chunked.

Documentation

• Added a tutorial with a detailed explanation of the experiment chunking feature.

Known Issues

• Using the reset_signal_oscillator_phase() on signals of type rf_signal is currently not supported.
• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.58.0

Release date 28.08.2025

Requires: LabOne 25.07

Includes: Applications Library 2.12.0

Notes & Important Changes

Functionality

• Introduce a new DSL command reset_oscillator_phase() which allows to reset the signal of the oscillator at any point in the sequence. Its usage is detailed in the manual under Amplitude and Phase of Pulses. Note that introducing a phase reset when using hardware modulation introduces a deterministic delay on his signal line, which is the time it takes for the phase reset to take effect on hardware.
• The workflow FolderStore has been extended to allow saving dictionaries whose keys are strings and whose values are simple Python types or numpy arrays or lists or tuples of such values. These dictionaries may be nested.
• The FolderStore now accepts a save_mode argument that controls how task and workflow inputs and outputs are saved. The default mode is "warn" which logs a warning if an input or output is not supported for saving. The other modes are "raise", which raises an error for unsupported types, and "skip", which skips saving inputs and outputs. In the "skip" case, the FolderStore will still write its event log file.
• Improved convergence of auto chunking algorithm when using SHF instruments and hitting the waveform memory limitation.

Deprecation notice

Note

Support for LabOne 25.04 is deprecated and will be removed with version 2.59.0.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• Fixed a bug when accessing edges on the QPU.topology.
• Fixed two bugs affecting backwards compatibility of serialisation for DeviceSetup saved with any version before 2.53 and Experiment saved with version before 2.57.

Documentation

• Extended the Amplitude and Phase of Pulses section with an explanation of the new reset_oscillator_phase() DSL command.

Known Issues

• Using the reset_signal_oscillator_phase() on signals of type rf_signal is currently not supported.
• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.57.0

Release date 31.07.2025

Requires: LabOne 25.07

Includes: Applications Library 2.11.0

Notes & Important Changes

Functionality

• LabOne Q now supports LabOne 25.07. With this update, ZSync capable instruments are expected to take less time in establishing a connection. Issues with time-outs when connecting after booting-up an instrument should be resolved, as well as the corresponding ZSYNCLINKLOST firmware errors.
• Added the custom attribute to QuantumParameters, which is a dictionary of custom parameters with attribute-style access. This is convenient for fast prototyping and testing. For example, one can write q = QuantumElement("q0"); q.parameters.custom.x = 5.
• Changed the default layout of the QPUTopology.plot method from planar to spring. This improves the flexibility of the plot method, since not all graphs are possible to plot using the planar layout. The default value of the disconnected argument has been changed from True to False, to improve plot readability. Additionally, added optional arguments to the plot method to adjust the figure size (figsize), fix node positions (fixed_pos), set equal aspect ratio (equal_aspect), and show edge tags (show_tags). This provides increased control over the plot's appearance.
• The deprecation status of the attributes device_setup and experiment in CompiledExperiment was removed. The attributes will not be removed until further notice.
• Added a way to conveniently retrieve quantum elements from the QPU by user-defined group. The QPU class was previously initialized as QPU(quantum_elements, quantum_operations), where quantum_elements may be a single quantum element or a sequence of quantum elements. In addition, we now allow the quantum_elements argument to have the type dict[str, QuantumElement | Sequence[QuantumElement]], such that we group the quantum elements into a dictionary keyed by the group name. This provides users with an efficient method to retrieve all quantum elements of a specific kind, as attributes of qpu.groups. For example, one can write qpu = QPU({"qubits": [q0, q1, q2], "couplers": [c01, c02]}, qop); qpu.groups.qubits; qpu.groups.couplers.
• Improved the stability of the QPUTopology.add_edge method by raising an error if the source/target nodes do not exist in the QPU.
• When outputs of HDAWG instruments are used as individual signals (instead of pairing them into IQ signals), and the calibration of such signals sets the modulation mode to ModulationType.AUTO, then software modulation will be used. Previously, ModulationType.AUTO resolved to hardware modulation for such signals.

Note

LabOne Q has ended support and testing for Python version 3.9 with version 2.53. Please make sure to upgrade your Python environments to a supported version before upgrading.

Note

Including the instrument options when constructing the DeviceSetup is now a strict requirement since version 2.52.0. Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Applications Library

• Allowed cancellation_source in TWPAParameter to be specified by a string. This fixes deserialization of TWPAParameters.

Deprecation notice

Note

Support for LabOne 25.04 is deprecated and will be removed at 2.59.0.

Note

Removed DSL features and attributes which were deprecated in 2.29 or before (i.e. more than six months ago).

Note

The deprecated Results.compiled_experiment attribute has been removed.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• A bug causing DeviceSetup.reset_calibration() to clear only the physical channel calibration is fixed. Now it clears both logical signal calibrations and physical channel calibrations.
• Fixed a bug where sweeping the pulse parameters in near-time did not create the correct waveforms.
• Fixed a bug in the QPU.override_quantum_elements method, so that the quantum elements in the returned QPU, and the quantum elements in the returned QPU topology graph, are now the same objects.
• Fixed a bug where the sine generators used for hardware modulation on HDAWG instruments had a 90 degree phase difference between the two outputs of a single core, when they were configured as two independent signals (rf_signal). This does not affect IQ signals.
• Fixed deserialization of TWPAParameters from LabOne Q Applications by allowing cancellation_source be specified as a string.

Documentation

• Removed support for RF signal types on SHF device outputs, with only IQ signals now supported on SG channels.
• Removed the deprecated ZSync specification from device setups used in examples.
• Removed the specifying of repetition_time from multi-program QASM examples. The repetition_time argument became optional in LabOne Q 2.56.0.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.56.0

Release date 17.07.2025

Requires: LabOne 25.04

Includes: Applications Library 2.10.0

Notes & Important Changes

Functionality

• The get_edges method now supports retrieving all edges in the QPU topology by allowing the node parameter to be None.
• Improved error diagnostics by adding contextual information to compilation failures. When code generation fails for an AWG, error messages now include the specific signal UIDs that were being processed.
• The OpenQASM batch_experiment method and exp_from_qasm_list functions no longer pad each experiment to a fixed length by default. Previously the repetition_time option had to be set to a suitable time to ensure each chunk was the same length when using the experiment-chunking feature (batch_execution_mode="pipeline"). This is no longer required, so now repetition_time defaults to None, which adds no padding.

Note

LabOne Q has ended support and testing for Python version 3.9 with version 2.53. Please make sure to upgrade your Python environments to a supported version before upgrading.

Note

Including the instrument options when constructing the DeviceSetup is now a strict requirement since version 2.52.0. Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Applications Library

• Added support for temporary edge parameters in QPU parameter updating, allowing modification of topology edge parameters using tuple keys in addition to existing quantum element parameter updates.

Deprecation notice

Note

The deprecated Results.compiled_experiment attribute has been removed.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• Fixed a bug where explicitly specifying PortMode.RF prevented enabling auto-muting.
• Fixed the serialization of TWPAParamter by allowing TWPAParameter.cancellation_source to accept string values.
• Fixed a bug that had broken the temporary modification of quantum-element parameters in the experiment workflows in the Applications Library. The bug was caused by an incorrect QPU argument being passed to the temporary_quantum_elements_from_qpu task.

Documentation

• Removed repetition_time option from the examples in the VQE and Randomized Benchmarking Qiskit how-to guides, since it is no longer required.
• Fixed typo in documentation navigation and improved QPU topology tutorial formatting by removing numbered section headers and updating parameter names for better clarity.
• Updated the temporary parameters section of the Experiment Workflows tutorial to show that parameters for both quantum elements and topology edges can be temporarily modified.
• Removed deprecated zsync parameter from device setup configurations in tutorial notebooks.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.55.0

Release date 03.07.2025

Requires: LabOne 25.04

Includes: Applications Library 2.9.0

Notes & Important Changes

Functionality

• The auto-chunking system now intelligently handles program memory constraints by automatically detecting when compiled programs exceed instruction memory limits.
• Added a __getitem__ method to QPU as a way to efficiently return quantum elements by UID, slice, or type. You can now retrieve elements using intuitive bracket notation: by UID (qpu["q0"]), multiple UIDs (qpu[["q0", "q1"]]), slice indexing (qpu[:2]), or by type (qpu[Transmon]). The quantum_element_by_uid method has been deprecated in favor of this more flexible and user-friendly interface.
• Generalized the caching mechanism in the serialization system to support multiple object types beyond just pulses. The new ObjectCache framework now provides caching for both Pulse objects and Section objects, reducing serialized data size and improving performance by avoiding duplication of repeated objects.
• A new copy() method has been added to the QuantumOperations class, enabling users to create independent copies of quantum operations instances. The copied instance includes all registered operations but intentionally excludes the attached QPU, allowing the copy to be attached to a different QPU as needed. This enhancement provides greater flexibility when working with quantum operations across multiple quantum processing units.
• The add_quantum_elements method has been added to the dsl namespace, which can manually add logical signals and calibration of quantum elements to an Experiment. Learn how to use it in our tutorial!
• Added the QPUTopology class, which stores the topology information of the QPU as a multi-edged directed graph. The topology is an attribute of the QPU and may be accessed via qpu.topology. This feature facilitates operations involving multiple quantum elements, such as multi-qubit gates. Check out our new tutorial describing how to use this feature.

Note

LabOne Q has ended support and testing for Python version 3.9 with version 2.53. Please make sure to upgrade your Python environments to a supported version before upgrading.

Note

Including the instrument options when constructing the DeviceSetup is now a strict requirement since version 2.52.0. Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Applications Library

• All references to qpu.qubits in the documentation have been updated to qpu.quantum_elements. The attribute qpu.qubits was deprecated in LabOne Q 2.52.0.
• Implemented the temporary_qpu and temporary_quantum_elements_from_qpu tasks for experiments and experiment workflows. This enables the temporary modification of parameters in the QPU topology in the future. All experiments in the Applications Library have been updated to use temporary_qpu and temporary_quantum_elements_from_qpu instead of temporary_modify. The temporary_modify task has been deprecated.

Deprecation notice

Note

The deprecated Results.compiled_experiment attribute has been removed.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Note

The temporary_modify task from the Applications library has been deprecated. Please use temporary_qpu and, if needed, temporary_quantum_elements_from_qpu instead.

Bug Fixes

• Fixed serialization bug by correcting parameter type definitions to support both single parameters and parameter lists in sweep operations and pulse parameters in LabOne Q DSL.
• Fixed a bug in pipeliner emulation for SHFQC instrument causing controller timeouts and missing measurement results.
• Fixed a bug where trigger outputs were not being generated when a trigger signal was configured on a section but no pulses were played on that signal within the section.

Documentation

• Updated the "Writing an Experiment Workflow" tutorial with a section explaining how to manually add additional quantum elements to an experiment using dsl.add_quantum_elements.
• Updated the serialization tutorial to include benchmarks. The new serializer is in many cases ~2x faster than LabOne Q's old serializer.
• Added the QPU topology tutorial demonstrating how to create, modify, and visualize quantum processing unit topologies using the QPU class.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.54.0

Release date 19.06.2025

Requires: LabOne 25.04

Includes: Applications Library 2.8.0

Notes & Important Changes

Functionality

• Added support for capturing and forwarding data server logs, including device firmware logs, to the main LabOneQ logging system. This feature can be enabled by setting the server_log parameter to True when creating a Session.
• Improved automatic experiment chunking to handle waveform memory limitations.
• PQSC and QHUB connections are now deprecated and removed from all examples and documentation. Explicit ZSYNC connections will be ignored with deprecation warnings and will become hard errors in future releases. Users should remove these connection definitions from their device setup configurations.
• The deprecated save and load methods have been removed from DeviceSetup, Experiment, CompiledExperiment, Results, and Session classes, along with related methods like save_signal_map and load_signal_map.
• The default value of the parameter include_results_metadata of session.run() was changed from True to False. This means that the device_setup and the experiment are not part of the Results object by default. Set include_results_metadata=True to have these attributes in your Results.
• A new LabOne Q serialisation framework has been added with LabOne Q version 2.50.0 which ensures backwards compatibility. The old serialisation framework was removed. Please migrate your workflows and existing data to use the new serializers before then, following our tutorial.

Note

LabOne Q has ended support and testing for Python version 3.9 with version 2.53. Please make sure to upgrade your Python environments to a supported version before then.

Note

Including the instrument options when constructing the DeviceSetup is now a strict requirement since version 2.52.0. Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Applications Library

• Updated all notebooks to use the new serializer save and load methods.
• Corrected the type annotation for the temporary_parameters argument to workflows. Previously it was annotated as TunableTransmon but should have been annotated as QuantumElement.
• Added device options to the PQSC device in the TunableTransmon demo QPU.

Deprecation notice

Note

The attributes .experiment and .device_setup will be removed from the CompiledExperiment object in LabOne Q version 2.55.0 on July 3rd, 2025.

Note

The attribute .compiled_experiment will be removed from the Results object in LabOne Q version 2.55.0 on July 3rd, 2025.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a serialization issue where integer values were incorrectly converted to floats during roundtrip serialization when working with Union types containing float, ensuring that numeric types are now properly preserved throughout the serialization process.
• Fixed a timing issue in the output simulator where maximum simulation length checks were performed too late in the execution flow, causing unnecessary processing of events outside the simulation region.
• Fixed the device setup helper function to store qubits in a dictionary indexed by their unique identifiers instead of a list, improving code clarity and access patterns.
• Resolved a bug where the simulation would attempt to process signals that weren't present in the kernel samples.

Documentation

• Added a set of tutorials to the Getting Started page that show how to connect to our QCCS instruments and program a few simple experiments.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.53.0

Release date 05.06.2025

Requires: LabOne 25.04

Includes: Applications Library 2.7.0

Notes & Important Changes

Functionality

• Added the ability to autodetect Zsync connectivity. In setups that include PQSC or QHUB central controllers, specifying Zsync port information for each instrument is no longer required as it will now be automatically detected at runtime. Note that it is still require to define the internal connection between instrument and central controller, but now without the port parameter.

Note

LabOne Q has ended support and testing for Python version 3.9 with version 2.53. Please make sure to upgrade your Python environments to a supported version before then.

Note

Including the instrument options when constructing the DeviceSetup is now a strict requirement since version 2.52.0. Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Applications Library

• The user_defined parameter of TunableTransmonParameters was added back after it was accidentally removed in the previous release.
• The ramsey operation in TunableTransmonOperations has been upgraded to sweep the increment_oscillator_phase parameter in the second x90 gate instead of the phase to reduce waveform memory usage.
• Breaking change The phase parameter of the ramsey operation in TunableTransmonOperations was renamed to ramsey_phase.

Deprecation notice

Note

A new LabOne Q serialisation framework has been added with LabOne Q version 2.50.0 which ensures backwards compatibility. The old serialisation framework will be removed in LabOne Q version 2.54.0, planned for June 19th, 2025. Please migrate your workflows and existing data to use the new serialisers before then, following our tutorial.

Note

The attributes .experiment and .device_setup will be removed from the CompiledExperiment object in LabOne Q version 2.54.0 on June 19th, 2025.

Note

The attribute .compiled_experiment will be removed from the Results object in LabOne Q version 2.54.0 on June 19th, 2025. Moreover, the attributes .experiment and .device_setup will also be removed by default from the Results object, unless the user prevents this by passing include_results_metadata=True to session.run().

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a bug that led to an incorrect serialization of the phase used in the play command. The bug was causing a failure in the serialization of SweepParameter in the Ramsey experiment workflow.

Documentation

• The documentation for core LabOne Q functionality has been given a flatter structure and updated installation instructions have been added, with the goal of making the documentation more transparent and material easier to find. We've separated out some Advanced Topics while consolidating others. Further structural and content updates to both the core LabOne Q documentation and the Applications Library documentation will come soon.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.52.0

Release date 22.05.2025

Requires: LabOne 25.04

Includes: Applications Library 2.6.0

Notes & Important Changes

Functionality

• Implemented automated chunking of experiments, i.e. the possibility to determine the amount of chunks for the pipeliner automatically based on the experiment size and the available hardware resources.
  In the current implementation, the feature checks only for the number of command table entries that are required within an experiment. If the available hardware resources are exceeded, re-compilation is triggered with the number of chunks adapted to optimally use the hardware.
  Enable this feature by supplying the auto_chunking=True parameter to any single sweep within your experiments. When used together with the chunk_count parameter, the latter will be used as a starting point for the chunking.
• Breaking change Renamed QPU.qubits to QPU.quantum_elements. Instantiating the QPU with qubits as keyword arguments (QPU(qubits=qubits)) will raise an error. Instantiating the QPU with qubits passed as a positional argument (QPU(qubits)) is still supported but will raise a warning.
• Breaking change The default measurement handle added by OpenQASMTranspiler.batch_experiment when the option add_measurement==True changed from handle=qubit.uid to handle=f”{qubit.uid}/result”.
• Moved the AWG compilation step into the LabOne Q compiler to improve execution performance. This requires the correct instrument options to be specified at compile time. Mismatch between instrument options at compile and execution time will now lead to a hard failure.
• Improved support for using trigger output together with signal lines of type rf_signal. To avoid overlapping assignments, each rf signal line can now only be used to control a single trigger output.
• Added the add_measurement_handle option to the OpenQASM.batch_experiment to allow the handles of measurements added by add_measurement=True to be specified. Added add_measurement_handle as an input parameter to the legacy exp_from_qasm_list method as well.
• RunExperimentResults returned by the run_experiment task and Results returned by Session.run have been unified into one Result object that is backwards compatible with both of the previous two classes. Backwards compatibility will be dropped in LabOne Q version 2.54.0 on June 19th, 2025 (see the Deprecation-notice section below).
  The Session no longer creates an empty Results object when execution starts; it creates the full Results object when the experiment completes. The controller's intermediate results are still available to near-time callbacks via session.results and session.get_results(). The serializer allows saved json files of RunExperimentResults or the old Results to be loaded and returns the new unified Results object.
  The compiled_experiment will be excluded from the json file when saving the new Results object to ensure backwards compatible with older versions of LabOne Q.
  To learn more about the new Results class, have a look at the updated pages in the documentation.
• Session.run has a new input parameter include_results_metadata. Setting this parameter to True (False) will include (exclude) the following attributes from the returned Results object: experiment, compiled_experiment, device_setup. A new option field with the same name, include_results_metadata, implements the same functionality in the run_experiment task. include_results_metadata is by default True in both cases.

Note

Including the instrument options when constructing the DeviceSetup is now a strict requirement since version 2.52.0. Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Deprecation notice

Note

A new LabOne Q serialisation framework has been added with LabOne Q version 2.50.0 which ensures backwards compatibility. The old serialisation framework will be removed in LabOne Q version 2.54.0, planned for June 19th, 2025. Please migrate your workflows and existing data to use the new serialisers before then, following our tutorial.

Note

The attributes .experiment and .device_setup will be removed from the CompiledExperiment object in LabOne Q version 2.54.0 on June 19th, 2025.

Note

The attribute .compiled_experiment will be removed from the Results object in LabOne Q version 2.54.0 on June 19th, 2025. Moreover, the attributes .experiment and .device_setup will also be removed by default from the Results object, unless the user prevents this by passing include_results_metadata=True to session.run().

Note

LabOne Q will end support for Python version 3.9 at the end of May 2025. Please make sure to upgrade your Python environments to a supported version before then.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a bug where in some cases using markers led to increased resource usage on the instruments, limiting the size of experiments that could be successfully executed.
• Fixed a bug when using a standalone HDAWG without a PQSC, that could lead to incomplete experiment execution.
• Fixed a bug in the (new) serializer that prevented serializing Experiments that used PlayPulse operations where the pulse=None.
• Added the QHub instrument to the new serialization framework.
• Fixed a bug in the Results serialization that caused scalar result data (returned when performing an experiment that returned a single data point) to be converted to a numpy array.
• Fixed a bug in the Experiment serializer that caused each pulse to be saved to the experiment multiple times. If an Experiment plays the same pulse many times the result files are now much smaller and the serialization and deserialization faster.
• Fixed a bug in the Results serializer that failed to convert axis items back to numpy arrays.

Documentation

• Updated the pages on Accessing and Using Experimental Results to describe the new Results class.
• Fixed the headings in the tutorial on serialization to create a table of contents in the manual.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.51.0

Release date 29.04.2025

Requires: LabOne 25.04

Includes: Applications Library 2.5.0

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 25.04. Please see the installation instructions for a link and explanation how to update your LabOne version. We recommend 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 25.04.
• Removed the deprecated classes PulseSampledReal and PulseSampledComplex.

Applications Library

• Added the new experiment and analysis workflows measurement_qndness.py to the contrib folder. The new routine allows to characterise the performance of a QND measurement.

Deprecation notice

Note

Including the instrument options when constructing the DeviceSetup will become a strict requirement in the next release of LabOne Q, version 2.52.0 Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Note

A new LabOne Q serialisation framework has been added with LabOne Q version 2.50.0 which ensures backwards compatibility. The old serialisation framework will be removed in LabOne Q version 2.54.0, planned for June 19th, 2025. Please migrate your workflows and existing data to use the new serialisers before then, following our tutorial.

Note

The attributes .experiment and .device_setup will be removed from the CompiledExperiment object in LabOne Q version 2.54.0 on June 19th, 2025.

Note

The attribute .compiled_experiment will be removed from the Results object in LabOne Q version 2.54.0 on June 19th, 2025. Moreover, the attributes .experiment and .device_setup will also be removed by default from the Results object, unless the user prevents this by passing include_metadata=True to session.run().

Note

LabOne Q will end support for Python version 3.9 at the end of May 2025. Please make sure to upgrade your Python environments to a supported version before then.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a bug related to checking for Union type in workflow options, needed to support Python 3.9. The bug introduced some restrictions on the data types accepted by the options fields, which are now lifted with this bugfix.
• Fixed a bug when sweeping amplitudes from negative to positive values on rf_signals.
• Fixed a bug when using a HDAWG without any other instruments, which may lead to a timeout error during program execution.
• Fixed a bug in the generate device setup helper function which led to the clock source argument being ignored for PQSC and QHub instruments.

Documentation

• Added a new section to the advanced sweeping example notebook demonstrating how to use match-case statements to construct nested sweeps where sweep inner variables may depend on the value of the out sweep.
• Added a new how-to guide to describe the new measurement_qndness.py experiment workflow, which allows to characterize the performance of a QND measurement.

Known Issues

• Using OpenQASMTranspiler.batch_experiment with QASM programs that contain native measurement operations will lead to an unexpected shape of the returned data. To ensure the correct shape, measurement operations should be removed from the OpenQASM program, and .batch_experiment should be called with the option field add_measurement=True, which will add the measurement operations to the LabOne Q Experiment during the import step (see our tutorial for more details).
• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.50.0

Release date 10.04.2025

Requires: LabOne 25.01

Includes: Applications Library 2.4.0

Notes & Important Changes

Functionality

• Added the possibility to pass options to the compile_experiment task.
• Added a new serialisation framework which ensures backwards compatibility across LabOne Q versions. Learn what is new and how to migrate to the new framework in our tutorial. As the old serialisation framework will be removed in LabOne Q version 2.55.0 (planned for June 19th, 2025), we advise our users to migrate your workflows and data to use the new framework as soon as possible.

Deprecation notice

Note

Including the instrument options when constructing the DeviceSetup will become a strict requirement in an upcoming release of LabOne Q, version 2.52.0 Specify your instrument configuration through either the 'options' field in the 'instruments' list when using a device setup descriptor, or by specifying the device_options argument when constructing your setup programmatically. Alternatively, you can use the generate_device_setup helper function available under contrib, which has the option to query the instruments for installed options automatically. This function is already used in the majority of our publicly available examples.

Note

A new LabOne Q serialisation framework has been added with LabOne Q version 2.50.0 which ensures backwards compatibility. The old serialisation framework will be removed in LabOne Q version 2.54.0, planned for June 19th, 2025. Please migrate your workflows and existing data to use the new serialisers before then, following our tutorial.

Note

The attributes .experiment and .device_setup will be removed from the CompiledExperiment object in LabOne Q version 2.54.0 on June 19th, 2025.

Note

The attribute .compiled_experiment will be removed from the Results object in LabOne Q version 2.54.0 on June 19th, 2025. Moreover, the attributes .experiment and .device_setup will also be removed by default from the Results object, unless the user prevents this by passing include_metadata=True to session.run().

Note

LabOne Q will end support for Python version 3.9 at the end of May 2025. Please make sure to upgrade your Python environments to a supported version before then.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Known Issues

• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.49.0

Release date 27.03.2025

Requires: LabOne 25.01

Includes: Applications Library 2.3.0

Notes & Important Changes

Functionality

• Added a ready-check on HDAWG instrument when adjusting instrument settings like analog signal parameters that can take time to completely take effect.
• Continued work on the compiler performance. Notably compilation speed for experiments with a large number of nested sweeps or nested match-case statements has improved significantly.

Applications Library

• Added the parameters qubit_resonator_coupling_strength_g and ge_chi_shift to TunableTransmonQubitParameters.

Note

LabOne Q will end support for Python version 3.9 at the end of May 2025. Please make sure to upgrade your Python environments to a supported version before then.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a bug where using phase increments and phase resets in experiments with multiple sweeps on the same nesting level led to failure in compilation.

Documentation

• Fixed a typo in all the workflow-based how-to guides, where the option close_figures=False was incorrectly explained as closing all the figures.

Known Issues

• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.48.0

Release date 13.03.2025

Requires: LabOne 25.01

Includes: Applications Library 2.2.0

Notes & Important Changes

Functionality

• Added full support for Python 3.13.
• Added functionality to instrument LabOne Q using the OpenTelemetry framework to collect tracing information e.g., for benchmarks. Please note that LabOne Q will NEVER transmit telemetry data to Zurich Instruments or any other party on its own. The functionality purely serves to enable optional instrumentation of LabOne Q internals, so that user-supplied OpenTelemetry tracers can 'see inside' LabOne Q. If you are interested how to use the LabOneQInstrumentor, have a look at the API documentation or contact us directly for an example.

Applications Library

• Added two additional parameters to plotting_helpers.py/plot_data_2d: fit_y_values, fit_x_values. This allows a user to plot a fit line across the 2D colour plot.
• Added two new options to the qubit-spectroscopy analysis workflow: spectral_feature and frequency_filter.
• spectral_feature allows the user to choose whether to perform the fit assuming the Lorentzian is pointing upwards (spectral_feature=="peak") or downwards (spectral_feature=="dip"). By default, this parameter is set to "auto", in which case, the routine tries to work out the orientation of the Lorentzian feature (the behaviour before the introduction of the spectral_feature option). This option is useful when the automatic detection of the Lorentzian orientation fails.
• The frequency_filters option allows the user to specify information on how to filter the first-dimensional sweep points (the frequency) for each qubit before performing the Lorentzian fit; for example, to fit the data only in the range f < 6.8 GHz.

Note

LabOne Q will end support for Python version 3.9 at the end of May 2025. Please make sure to upgrade your Python environments to a supported version before then.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a bug that allowed baseband modulation of real-valued pulses on rf-signals using the phase keyword in the play command, leading to undefined behavior.
• Fixes a bug in signal_propagation_delay.py in laboneq-applications, where the name of the extracted qubit parameter was wrong.

Known Issues

• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.47.0

Release date 27.02.2025

Requires: LabOne 25.01

Includes: Applications Library 2.1.0

Notes & Important Changes

Applications Library

• Added support for calculating the qubit population from calibration traces or principal-component analysis for 2D data. Added the function calculate_population_2d and the task calculate_qubit_population_2d to analysis/calibration_traces_rotation.py.
• Added the task plot_raw_complex_data_2d for plotting raw results from 2D measurements.
• Added a small analysis workflow in spectroscopy_two_dimensional_plotting.py for plotting the raw-data and the signal magnitude and phase from a spectroscopy experiment. Added this analysis workflow to the experiment workflows in resonator_spectroscopy_amplitude.py and qubit_spectroscopy_amplitude.py;
• Added analysis/resonator_spectroscopy_dc_bias.py containing an analysis workflow for a resonator-spectroscopy experiment with a DC voltage sweep.
• Extended the plot_raw_complex_data_1d task to work with instances of both Results and ExperimentResults.

Note

LabOne Q will end support for Python version 3.9 at the end of May 2025. Please make sure to upgrade your Python environments to a supported version before then.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed bugs in plot_raw_complex_data_1d to correctly detect when to plot the calibration traces.

Documentation

• Documented the restrictions on the object types that can be serialised by the FolderStore.
• Extended the how-to guide Resonator Spectroscopy with DC Bias with a call to the analysis workflow in analysis/resonator_spectroscopy_dc_bias.py.

Known Issues

• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.46.0

Release date 13.02.2025

Requires: LabOne 25.01

Includes: Applications Library 2.0.0

Notes & Important Changes

Functionality

• Added the ability to use the internal scope in segmented mode on SHFQA and SHFQC instruments.
• Allowed barriers in OpenQASM programs to be broadcast in the case where they were applied to multiple qubits.
• Added support for multiple inheritance of quantum operation classes.
• Added a parameters argument to QuantumElement.from_device_setup that allows qubit parameters to be specified when creating qubits from a DeviceSetup.

Applications Library

• Upgraded the Applications Library to version 2.0.0 due to a major clean-up of the task and workflow options classes:
• removed TuneupAnalysisOptions and QubitSpectroscopyAnalysisOptions;
• added the new options classes DoFittingOption, FitDataOptions, ExtractQubitParametersTransitionOptions, BasePlottingOptions, PlotPopulationOptions, CalculateQubitPopulationOptions;
• moved the options classes related to the analysis routines into a new module laboneq_applications.analysis.options;
• moved QubitSpectroscopyAnalysisWorkflowOptions into laboneq_applications.experiments.qubit_spectroscopy;
• modified all the analysis workflows to use the new options classes instead of TuneupAnalysisOptions;
• Fixed the task temporary_modify to work for all children of QuantumElement;

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Adapted the priority and order in which phase increments are emitted in the sequencer code, which in rare cases led to gaps in playback of sequences containing many consecutive virtual z-gates without waveform playback at the same time.
• Added a fix to prevent adding an instrument with the same id to a device setup twice, which led to undefined behavior in emulation mode.
• Fixes the time-traces analysis workflow in laboneq_applications to work with one qubit state and to catch the exception when the kernel extraction fails.

Documentation

• Adapted the feedback and readout kernel optimisation examples to use the segmented scope functionality, which speeds up execution of these experiments.
• Fixed various typos in examples notebooks.

Known Issues

• Using the internal scope to acquire raw traces on multiple channels of an SHFQA in a single experiment is only possible if the timing of all acquisitions is equal between instrument channels.
• 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.45.0

Release date 30.01.2025

Requires: LabOne 25.01

Includes: Applications Library 1.4.0

Notes & Important Changes

Functionality

• Updated dependencies to the newest LabOne 25.01. Please see the installation instructions for a link and explanation how to update your LabOne version. We recommend 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 25.01.
• Removed the legacy synchronous API for communication with the instruments in the controller.
• Added support for the new long readout time option on SHFQA and SHFQC readout channels. See the new tutorial on how to enable playback and integration of readout pulses longer than the default 2us.
• Added a new method .copy() to QuantumElement and QuantumParameters.
• Updated the generate_descriptor helper function to query the instruments for their options.
• Updated the generate_device_setup helper function to query the instruments for their options and to query the PQSC for the ZSync ports to which the other instruments are connected.
• Significantly improved the performance of the LabOne Q compiler for large experiments involving many signal lines.

Applications Library

• Added an implementation for a TWPA object and TWPA quantum operations.
• Added implementations for TWPA calibration experiments: calibrate_cancellation, measure_gain_curve, scan_pump_parameters, twpa_spectroscopy, which all use the fast sweeping functionality of the SHFPPC together with our quantum analysers.
• Added analysis routines for the TWPA calibration experiments: calibrate_cancellation, measure_gain_curve, scan_pump_parameters, twpa_spectroscopy.

Note

Since version 2.36.0, LabOne Q uses the asynchronous LabOne API by default when communicating with instruments. The synchronous API has been removed with version 2.45.

Note

The Qubit and Transmon classes are not yet considered stable and their APIs might still change in future versions. Their parent QuantumElement class has been updated with version 2.44, making it much simpler to create your own implementation of a qubit object.

Bug Fixes

• Fixed a bug where holdoff errors on readout channels persisted for continued runs of an experiment.
• Fixed a bug when using the pipeliner on an instrument with only readout channels, where the automated ready-check in some cases did not work correctly.

Documentation

• Added a new tutorial on how to use the long readout time option on quantum analyser channels.
• Added a new how-to guide for basic TWPA calibration.
• Extended the quantum element tutorial to cover writing your own quantum element and how to copy qubits or qubit parameters.
• Added a new tutorial for the context-based DSL defined in laboneq.simple.dsl.
• Added a new tutorial for serialization.

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.44.0

Release date 16.01.2025

Requires: LabOne 24.10

Includes: Applications Library 1.3.0

Notes & Important Changes

Functionality

• The QuantumElement, Qubit and Transmon classes have been extensively modified:
• Most of the functionality of Qubit and Transmon has been moved to their parent QuantumElement base class.
• Users defining new qubit classes should now inherit directly from QuantumElement, specifying only the required signals and parameters and implementing a .calibration() method. All other methods are now included on the base class QuantumElement.
• The Transmon class inherits directly from QuantumElement.
• The Qubit class is now an alias for Transmon.
• Both Qubit and Transmon are intended for demonstration purposes for now, as more changes are planned for these classes and will come soon.
• QuantumElement is now an attrs class rather than a dataclass.
• Some of the new QuantumElement methods that may be useful include: from_logical_signal_group, from_device_setup, experiment_signals, replace, update.
• The .load and .save methods are deprecated and users are encourage to use laboneq.serializers.load and laboneq.serializers.save instead.
• Where possible all three classes remain largely backwards compatible but there are many small changes. Get in touch with us if you need help!
• If you have saved existing qubits you should be able to load them into LabOne Q 2.44 by first loading the qubits in LabOne Q 2.43, saving them with laboneq.serializers.save, and then loading them with laboneq.serializers.load in LabOne Q 2.44. The saving and loading procedure for users of laboneq-applications remains unchanged. See our documentation for details.
• Removed the /logical_signal_groups/ prefix from the signal names of QuantumElements. When using DeviceSetup.set_calibration, logical signal calibration may be passed without the /logical_signal_groups/ prefix.
• The OpenQASM experiment() method now automatically adds the qubit calibration to the experiment calibration.
• Added support for passing qubit registers to OpenQASM instructions, enabling broadcasting of these operations onto multiple qubits in parallel. See the OpenQASM tutorial in the LabOne Q manual for details.

Applications Library

• Updates TunableTransmonQubit to use the refactored QuantumElement class.

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 now considered stable and the API will not undergo major changes in future versions. Comments and feedback on the new API are appreciated.

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 controller that could lead to erroneous AWG timeout errors.
• Using Openpulse ports that are not declared within the program now raises an exception.
• OpenQASM program cal blocks no longer produce empty Experiment sections when they do not include any operations.
• Openpulse waveform variable type can now be used as an input argument for functions.
• Added missing dependencies on qiskit and qiskit_experiments to laboneq-applications.
• Fixed various bugs in the single-qubit randomized benchmarking experiment in laboneq-applications.

Documentation

• Updated all the Workflow-based how-to guides for superconducting qubits to give more detailed instructions for defining the experimental setup in practice.
• Updated OpenQASM tutorial with the new qubit-broadcasting feature.
• Added a new tutorial about quantum elements.
• Added Experiment built-in functions to the API Reference documentation.
• Fixed broken links on several pages.

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.43.0

Release date 19.12.2024

Requires: LabOne 24.10

Includes: Applications Library 1.2.0

Notes & Important Changes

Functionality

• Removed experimental flag from OpenQASM support and upgraded the API. Check out the new tutorial to see how the new API works. Below, we summarise the major changes:
• Added laboneq.openqasm3.OpenQASMTranspiler to transpile OpenQASM programs into LabOne Q objects by using QuantumOperations. The new tutorial shows how to use the QuantumOperations and OpenQASMTranspiler to transpile QASM programs into a LabOne Q Experiment.
• The following objects are deprecated in favor of newly added laboneq.openqasm3.OpenQASMTranspiler
  • laboneq.openqasm3.GateStore supplemented by QuantumOperations
  • laboneq.openqasm3.exp_from_qasm supplemented by OpenQASMTranspiler.experiment
  • laboneq.openqasm3.exp_from_qasm_list supplemented by OpenQASMTranspiler.batch_experiment
• Added the possibility to transpile a QASM program into a LabOne Q Section using OpenQASMTranspiler.section().
• Added two options classes SingleProgramOptions and MultiProgramOptions to be used with the new OpenQASMTranspiler.experiment and OpenQASMTranspiler.batch_experiment.
• OpenQASM wavefroms can now be specified either as a list of samples or as an instance of laboneq Pulse. The former was not supported in the old API.
• In the new API, OpenPulse implicit input waveforms are passed via the inputs argument compared to exp_from_qasm where they were passed in as input arguments: exp_from_qasm(waveforms={"wf0": Pulse()}) --> .transpile(inputs={"wf0": Pulse()})
• In the new API, ports are passed in via the externs argument compared to exp_from_qasm where they were passed in as input arguments: exp_from_qasm(ports={"port": "port"}) --> .transpile(externs={"port": "port"})
• Improved input validation when importing QASM programs.
• Added tracking of overrange indicators on SHF instruments. If an overrange condition is detected during the execution of your experiment, a warning will be logged by LabOne Q indicating the channel on which the overrange condition was present. Overrange can be indicative of an incompatible power range setting on signal inputs or be caused by overshoots from very steep pulse edges on output channels.

Applications Library

• Updated the TunableTransmonOperations set_frequency and set_amplitude that access the experiment calibration to work without an experiment context.
• Removed the restriction to one qubit for the active_reset operation.
• Upgrades contrib/single_qubit_randomized_benchmarking.py to the new OpenQASMTranspiler API.

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 now considered stable and the API will not undergo major changes in future versions. Comments and feedback on the new API are appreciated.

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 automuting did not engage for very long delay periods.
• Fixed a bug where opts.spectroscopy_reset_delay was not passed to the call to the passive_reset operation in qubit_spectroscopy_amplitude.py/create_experiment, like it is done in qubit_spectroscopy.py.
• Fixed a bug where the multiple-QASM-program Experiment generation function exp_from_qasm_list (now OpenQASMTranspiler.batch_experiment) wrongly applied an ExperimentCalibration.

Documentation

• Expands the page Phase and Amplitude of Pulses with more detailed explanations.
• Fixes the failing code in Sweeping parameters with QCoDeS in LabOne Q and Color Centers: Using Time Tagger with neartime callback functions by enabling emulation of the missing resources.
• Adds more tutorials and how-to guides related to the new Workflow and QuantumOperations features of LabOne Q and the Applications Library:
• Two tune-up guides for superconducting transmon qubits, qubit tune-up and active reset tune-up.
• How to write experiment workflows with quantum operations.
• New tutorial describing in details the TunableTransmonOperations and how they use the TunableTransmonParameter of TunableTransmonQubits.
• More details in Defining your Experimental Setup about how to create your experimental setup before using the experiments in the Applications Library.
• More description about Tasks, options, and QuantumOperations.
• Tutorial on the new OpenQASM API.

Deprecation notice

• Deprecated the internal DataStore and replaced its usage in all public examples.
• Deprecated GateStore in favour of QuantumOperations. The GateStore API is till available. The gates are converted internally into QuantumOperations, which will result in additional reserve operations within the generated Experiment compared to previous behaviour.

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.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