qblox#

Module containing Qblox InstrumentCoordinator Components.

Module Contents#

Classes#

`_StaticHardwareProperties`	Dataclass for storing configuration differences across Qblox devices.
`_ModuleComponentBase`	Qblox InstrumentCoordinator component base class.
`_QCMComponent`	QCM specific InstrumentCoordinator component.
`_QRMComponent`	QRM specific InstrumentCoordinator component.
`_RFComponent`	Mix-in for RF-module-specific InstrumentCoordinatorComponent behaviour.
`_QCMRFComponent`	QCM-RF specific InstrumentCoordinator component.
`_QRMRFComponent`	QRM-RF specific InstrumentCoordinator component.
`_QRMAcquisitionManager`	Utility class that handles the acquisitions performed with the QRM.
`ClusterComponent`	Class that represents an instrument coordinator component for a Qblox cluster.

Functions#

`_get_instrument_ip`(→ str)
`_get_configuration_manager`(...)
`_download_log`(→ dict)

Attributes#

`logger`
`_QCM_BASEBAND_PROPERTIES`
`_QRM_BASEBAND_PROPERTIES`
`_QCM_RF_PROPERTIES`
`_QRM_RF_PROPERTIES`
`_ClusterModule`	Type that combines all the possible modules for a cluster.

logger[source]#

class _StaticHardwareProperties[source]#

Dataclass for storing configuration differences across Qblox devices.

settings_type: Type[quantify_scheduler.backends.types.qblox.BaseModuleSettings][source]#: The settings dataclass to use that the hardware needs to configure to.

has_internal_lo: bool[source]#: Specifies if an internal lo source is available.

number_of_sequencers: int[source]#: The number of sequencers the hardware has available.

number_of_output_channels: int[source]#: The number of physical output channels that can be used.

number_of_input_channels: int[source]#: “The number of physical input channels that can be used.

_QCM_BASEBAND_PROPERTIES[source]#

_QRM_BASEBAND_PROPERTIES[source]#

_QCM_RF_PROPERTIES[source]#

_QRM_RF_PROPERTIES[source]#

class _ModuleComponentBase(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm)[source]#

Bases: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase

Qblox InstrumentCoordinator component base class.

property instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm[source]#: Returns a reference to the module instrument.

property is_running: bool[source]#

Finds if any of the sequencers is currently running.

Returns:: True if any of the sequencers reports the SequencerStates.RUNNING status.

abstract property _hardware_properties: _StaticHardwareProperties[source]#

Holds all the differences between the different modules.

Returns:: A dataclass with all the hardware properties for this specific module.

_set_parameter(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm | qblox_instruments.qcodes_drivers.sequencer.Sequencer, parameter_name: str, val: Any) → None[source]#

Set the parameter directly or using the lazy set.

Parameters:

instrument – The instrument or instrument channel that holds the parameter to set, e.g. self.instrument or self.instrument[f”sequencer{idx}”].
parameter_name – The name of the parameter to set.
val – The new value of the parameter.

wait_done(timeout_sec: int = 10) → None[source]#

Blocks the instrument until all the sequencers are done running.

Parameters:: timeout_sec – The timeout in seconds. N.B. the instrument takes the timeout in minutes (int), therefore it is rounded down to whole minutes with a minimum of 1.

get_hardware_log(compiled_schedule: quantify_scheduler.schedules.schedule.CompiledSchedule) → dict | None[source]#

Retrieve the hardware log of the Qblox instrument associated to this component.

This log does not include the instrument serial number and firmware version.

Parameters:: compiled_schedule – Compiled schedule to check if this component is referenced in.
Returns:: A dict containing the hardware log of the Qblox instrument, in case the component was referenced; else None.

prepare(program: Dict[str, dict]) → None[source]#: Store program containing sequencer settings.

stop() → None[source]#: Stops all execution.

abstract _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings) → None[source]#

Configures all settings that are set globally for the whole instrument.

Parameters:: settings – The settings to configure it to.

_configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.SequencerSettings) → None[source]#

Configures all sequencer-specific settings.

Parameters:

seq_idx – Index of the sequencer to configure.
settings – The settings to configure it to.

_determine_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.SequencerSettings) → Dict[str, str][source]#: Returns a dictionary with the channel map parameters for this module.

_determine_output_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.SequencerSettings, channel_map_parameters: Dict[str, str]) → Dict[str, str][source]#: Adds the outputs to the channel map parameters dict.

_arm_all_sequencers_in_program(program: Dict[str, Any])[source]#: Arm all the sequencers that are part of the program.

_start_armed_sequencers()[source]#: Start execution of the schedule: start armed sequencers.

class _QCMComponent(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm)[source]#

Bases: _ModuleComponentBase

QCM specific InstrumentCoordinator component.

_hardware_properties[source]#

retrieve_acquisition() → None[source]#

Retrieves the previous acquisition.

Returns:: QCM returns None since the QCM has no acquisition.

prepare(program: Dict[str, dict]) → None[source]#

Uploads the waveforms and programs to the sequencers.

All the settings that are required are configured. Keep in mind that values set directly through the driver may be overridden (e.g. the offsets will be set according to the specified mixer calibration parameters).

Parameters:: program – Program to upload to the sequencers. Under the key "sequencer" you specify the sequencer specific options for each sequencer, e.g. "seq0". For global settings, the options are under different keys, e.g. "settings".

start() → None[source]#: Arm sequencers and start sequencers.

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings)[source]#

Configures all settings that are set globally for the whole instrument.

Parameters:: settings – The settings to configure it to.

class _QRMComponent(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm)[source]#

Bases: _ModuleComponentBase

QRM specific InstrumentCoordinator component.

_hardware_properties[source]#

_acquisition_manager: _QRMAcquisitionManager | None[source]#: Holds all the acquisition related logic.

retrieve_acquisition() → xarray.Dataset | None[source]#

Retrieves the latest acquisition results.

Returns:: The acquired data.

prepare(program: Dict[str, dict]) → None[source]#

Uploads the waveforms and programs to the sequencers.

Parameters:: program – Program to upload to the sequencers. Under the key "sequencer" you specify the sequencer specific options for each sequencer, e.g. "seq0". For global settings, the options are under different keys, e.g. "settings".

start() → None[source]#: Clear acquisition data, arm sequencers and start sequencers.

_clear_sequencer_acquisition_data()[source]#: Clear all acquisition data.

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings)[source]#

Configures all settings that are set globally for the whole instrument.

Parameters:: settings – The settings to configure it to.

_configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.SequencerSettings) → None[source]#

Configures all sequencer-specific settings.

Parameters:

seq_idx – Index of the sequencer to configure.
settings – The settings to configure it to.

_determine_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.SequencerSettings) → Dict[str, str][source]#: Returns a dictionary with the channel map parameters for this module.

_determine_input_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.SequencerSettings, channel_map_parameters: Dict[str, str]) → Dict[str, str][source]#: Adds the inputs to the channel map parameters dict.

_determine_scope_mode_acquisition_sequencer_and_qblox_acq_index(acquisition_metadata: Dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata]) → Tuple[int, int] | None[source]#

Finds the sequencer and qblox_acq_index that performs the raw trace acquisition.

Raises an error if multiple scope mode acquisitions are present per sequencer. Note, that compiler ensures there is at most one scope mode acquisition, however the user is able to freely modify the compiler program, so we make sure this requirement is still satisfied. See _ensure_single_scope_mode_acquisition_sequencer().

Parameters:: acquisition_metadata – The acquisition metadata for each sequencer.
Returns:: The sequencer and qblox_acq_channel for the trace acquisition, if there is any, otherwise None, None.

class _RFComponent(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm)[source]#

Bases: _ModuleComponentBase

Mix-in for RF-module-specific InstrumentCoordinatorComponent behaviour.

_configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.SequencerSettings) → None[source]#

Configures all sequencer-specific settings.

Parameters:

seq_idx – Index of the sequencer to configure.
settings – The settings to configure it to.

_determine_output_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.SequencerSettings, channel_map_parameters: Dict[str, str]) → Dict[str, str][source]#: Adds the outputs to the channel map parameters dict.

class _QCMRFComponent(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm)[source]#

Bases: _RFComponent, _QCMComponent

QCM-RF specific InstrumentCoordinator component.

_hardware_properties[source]#

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings)[source]#

Configures all settings that are set globally for the whole instrument.

Parameters:: settings – The settings to configure it to.

class _QRMRFComponent(instrument: qblox_instruments.qcodes_drivers.qcm_qrm.QcmQrm)[source]#

Bases: _RFComponent, _QRMComponent

QRM-RF specific InstrumentCoordinator component.

_hardware_properties[source]#

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings)[source]#

Configures all settings that are set globally for the whole instrument.

Parameters:: settings – The settings to configure it to.

_determine_input_channel_map_parameters(settings: quantify_scheduler.backends.types.qblox.SequencerSettings, channel_map_parameters: Dict[str, str]) → Dict[str, str][source]#: Adds the inputs to the channel map parameters dict.

class _QRMAcquisitionManager(parent: _QRMComponent, acquisition_metadata: Dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata], scope_mode_sequencer_and_qblox_acq_index: Tuple[int, int] | None, acquisition_duration: Dict[int, int], seq_name_to_idx_map: Dict[str, int])[source]#

Utility class that handles the acquisitions performed with the QRM.

An instance of this class is meant to exist only for a single prepare-start- retrieve_acquisition cycle to prevent stateful behavior.

Parameters:

parent – Reference to the parent QRM IC component.
acquisition_metadata – Provides a summary of the used acquisition protocol, bin mode, acquisition channels, acquisition indices per channel, and repetitions, for each sequencer.
scope_mode_sequencer_and_qblox_acq_index – The sequencer and qblox acq_index of the scope mode acquisition if there’s any.
acquisition_duration – The duration of each acquisition for each sequencer.
seq_name_to_idx_map – All available sequencer names to their ids in a dict.

property instrument[source]#: Returns the QRM driver from the parent IC component.

retrieve_acquisition() → xarray.Dataset[source]#

Retrieves all the acquisition data in the correct format.

Returns:: The acquisitions with the protocols specified in the acquisition_metadata. Each xarray.DataArray in the xarray.Dataset corresponds to one acq_channel. The acq_channel is the name of each xarray.DataArray in the xarray.Dataset. Each xarray.DataArray is a two-dimensional array, with acq_index and repetition as dimensions.

_store_scope_acquisition()[source]#

Calls store_scope_acquisition function on the Qblox instrument.

This will ensure that the correct sequencer will store the scope acquisition data on the hardware, so it will be filled out when we call get_acquisitions on the Qblox instrument’s sequencer corresponding to the scope acquisition.

static _acq_channel_attrs(protocol: str) → dict[source]#

_get_scope_data(acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) → xarray.DataArray[source]#

Retrieves the scope mode acquisition associated with an acq_channel.

Parameters:

acq_indices – Acquisition indices.
hardware_retrieved_acquisitions – The acquisitions dict as returned by the sequencer.
acquisition_metadata – Acquisition metadata.
acq_duration – Desired maximum number of samples for the scope acquisition.
qblox_acq_index – The Qblox acquisition index from which to get the data.
acq_channel – The acquisition channel.

Returns:

The scope mode data.

_get_integration_data(acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable, multiplier: float = 1, separated: bool = True) → xarray.DataArray[source]#

Retrieves the integrated acquisition data associated with an acq_channel.

Parameters:

acq_indices – Acquisition indices.
hardware_retrieved_acquisitions – The acquisitions dict as returned by the sequencer.
acquisition_metadata – Acquisition metadata.
acq_duration – Desired maximum number of samples for the scope acquisition.
qblox_acq_index – The Qblox acquisition index from which to get the data.
acq_channel – The acquisition channel.
multiplier – Multiplies the data with this number.
separated – True: return I and Q data separately False: return I+Q in the real part and 0 in the imaginary part

Returns:

The integrated data.

_get_integration_amplitude_data(acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) → xarray.DataArray[source]#

Gets the integration data but normalized to the integration time.

The return value is thus the amplitude of the demodulated signal directly and has volt units (i.e. same units as a single sample of the integrated signal).

Parameters:

acq_indices – Acquisition indices.
hardware_retrieved_acquisitions – The acquisitions dict as returned by the sequencer.
acquisition_metadata – Acquisition metadata.
acq_duration – Desired maximum number of samples for the scope acquisition.
qblox_acq_index – The Qblox acquisition index from which to get the data.
acq_channel – The acquisition channel.

Returns:

Array containing binned, normalized acquisition data.

_get_threshold_data(acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) → xarray.DataArray[source]#

Retrieve the thresholded acquisition data associated with acq_channel and acq_index.

Parameters:

acq_indices – Acquisition indices.
hardware_retrieved_acquisitions – The acquisitions dict as returned by the sequencer.
acquisition_metadata – Acquisition metadata.
acq_duration – Desired maximum number of samples for the scope acquisition.
qblox_acq_index – The Qblox acquisition index from which to get the data.
acq_channel – The acquisition channel.

Returns:

DataArray containing thresholded acquisition data.

_get_trigger_count_data(acq_indices: list, hardware_retrieved_acquisitions: dict, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata, acq_duration: int, qblox_acq_index: int, acq_channel: Hashable) → xarray.DataArray[source]#

Retrieves the trigger count acquisition data associated with acq_channel.

Parameters:

acq_indices – Acquisition indices.
hardware_retrieved_acquisitions – The acquisitions dict as returned by the sequencer.
acquisition_metadata – Acquisition metadata.
acq_duration – Desired maximum number of samples for the scope acquisition.
qblox_acq_index – The Qblox acquisition index from which to get the data.
acq_channel – The acquisition channel.

Returns:

data – The acquired trigger count data.

Return type:

xarray.DataArray

Notes

For BinMode.AVERAGE, data contains the distribution of counts.
For BinMode.APPEND, data contains the raw trigger counts.

static _qblox_acq_index_to_qblox_acq_name(qblox_acq_index: int) → str[source]#: Returns the name of the acquisition from the qblox_acq_index.

classmethod _get_bin_data(hardware_retrieved_acquisitions: dict, qblox_acq_index: int = 0) → dict[source]#: Returns the bin entry of the acquisition data dict.

_ClusterModule[source]#: Type that combines all the possible modules for a cluster.

class ClusterComponent(instrument: qblox_instruments.Cluster)[source]#

Bases: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase

Class that represents an instrument coordinator component for a Qblox cluster.

New instances of the ClusterComponent will automatically add installed modules using name “<cluster_name>_module<slot>”.

Parameters:: instrument – Reference to the cluster driver object.

property is_running: bool[source]#: Returns true if any of the modules are currently running.

start() → None[source]#: Starts all the modules in the cluster.

stop() → None[source]#: Stops all the modules in the cluster.

_configure_cmm_settings(settings: Dict[str, Any])[source]#

Set all the settings of the Cluster Management Module.

These setting have been provided by the backend.

Parameters:: settings – A dictionary containing all the settings to set.

prepare(options: Dict[str, dict]) → None[source]#

Prepares the cluster component for execution of a schedule.

Parameters:: options – The compiled instructions to configure the cluster to.

retrieve_acquisition() → Dict[Tuple[int, int], Any] | None[source]#

Retrieves all the data from the instruments.

Returns:: The acquired data or None if no acquisitions have been performed.

wait_done(timeout_sec: int = 10) → None[source]#

Blocks until all the components are done executing their programs.

Parameters:: timeout_sec – The time in seconds until the instrument is considered to have timed out.

get_hardware_log(compiled_schedule: quantify_scheduler.schedules.schedule.CompiledSchedule) → dict | None[source]#

Retrieve the hardware log of the Cluster Management Module and associated modules.

This log includes the module serial numbers and firmware version.

Parameters:: compiled_schedule – Compiled schedule to check if this cluster is referenced in (and if so, which specific modules are referenced in).
Returns:: A dict containing the hardware log of the cluster, in case the component was referenced; else None.

_get_instrument_ip(component: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase) → str[source]#

_get_configuration_manager(instrument_ip: str) → qblox_instruments.ConfigurationManager[source]#

_download_log(config_manager: qblox_instruments.ConfigurationManager, is_cluster: bool | None = False) → dict[source]#