qblox#

Module containing Qblox InstrumentCoordinator Components.

Module Contents#

Classes#

`_StaticHardwareProperties`	Dataclass for storing configuration differences across Qblox devices.
`_StaticAnalogModuleProperties`	Dataclass for storing configuration differences across Qblox devices.
`_StaticTimetagModuleProperties`	Dataclass for storing configuration differences across Qblox devices.
`_ModuleComponentBase`	Qblox InstrumentCoordinator component base class.
`_AnalogModuleComponent`	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.
`_QTMComponent`	QTM specific InstrumentCoordinator component.
`_AcquisitionManagerBase`	Utility class that handles the acquisitions performed with a module.
`_QRMAcquisitionManager`	Utility class that handles the acquisitions performed with the QRM.
`_QTMAcquisitionManager`	Utility class that handles the acquisitions performed with the QTM.
`ClusterComponent`	Class that represents an instrument coordinator component for a Qblox cluster.

Functions#

`_supported_bin_modes`(→ Callable[[F], F])
`_get_instrument_ip`(→ str)
`_get_configuration_manager`(...)
`_download_log`(→ dict)

Attributes#

`logger`
`_QCM_BASEBAND_PROPERTIES`
`_QRM_BASEBAND_PROPERTIES`
`_QCM_RF_PROPERTIES`
`_QRM_RF_PROPERTIES`
`_QTM_PROPERTIES`
`_ReadoutModuleComponentT`
`F`
`_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.

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.

class _StaticAnalogModuleProperties[source]#

Bases: _StaticHardwareProperties

Dataclass for storing configuration differences across Qblox devices.

settings_type: type[quantify_scheduler.backends.types.qblox.AnalogModuleSettings][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.

class _StaticTimetagModuleProperties[source]#

Bases: _StaticHardwareProperties

Dataclass for storing configuration differences across Qblox devices.

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

_QCM_BASEBAND_PROPERTIES[source]#

_QRM_BASEBAND_PROPERTIES[source]#

_QCM_RF_PROPERTIES[source]#

_QRM_RF_PROPERTIES[source]#

_QTM_PROPERTIES[source]#

class _ModuleComponentBase(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase

Qblox InstrumentCoordinator component base class.

_instrument_module[source]#

_seq_name_to_idx_map[source]#

_program[source]#

_nco_frequency_changed: dict[int, bool][source]#: Private attribute for automatic mixer calibration. The keys are sequencer indices. The prepare method resets this to an empty dictionary.

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

_set_parameter(instrument: qblox_instruments.qcodes_drivers.module.Module | 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.

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.

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.

disable_sync() → None[source]#: Disable sync for all sequencers.

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.

arm_all_sequencers_in_program() → None[source]#: Arm all the sequencers that are part of the program.

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

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

clear_data() → None[source]#: Clears remaining data on the module. Module type specific function.

property _hardware_properties: _StaticHardwareProperties[source]#

Abstractmethod:

Holds all the differences between the different modules.

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

class _AnalogModuleComponent(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: _ModuleComponentBase

Qblox InstrumentCoordinator component base class.

abstract _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.AnalogModuleSettings) → 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.AnalogSequencerSettings) → 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.AnalogSequencerSettings) → 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.AnalogSequencerSettings, channel_map_parameters: dict[str, str]) → dict[str, str][source]#: Adds the outputs to the channel map parameters dict.

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

property _hardware_properties: _StaticAnalogModuleProperties[source]#

Abstractmethod:

Holds all the differences between the different modules.

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

class _QCMComponent(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: _AnalogModuleComponent

QCM specific InstrumentCoordinator component.

_hardware_properties[source]#

Holds all the differences between the different modules.

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

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

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.AnalogModuleSettings) → None[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.module.Module)[source]#

Bases: _AnalogModuleComponent

QRM specific InstrumentCoordinator component.

_hardware_properties[source]#

Holds all the differences between the different modules.

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

_acquisition_manager: _QRMAcquisitionManager | None = 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.

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

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.AnalogModuleSettings) → 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.AnalogSequencerSettings) → 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.AnalogSequencerSettings) → 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.AnalogSequencerSettings, 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.

clear_data() → None[source]#: Clears remaining data on the module. Module type specific function.

class _RFComponent(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: _AnalogModuleComponent

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

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

Uploads the waveforms and programs to the sequencers.

Overrides the parent method to additionally set LO settings for automatic mixer calibration. This must be done _after_ all NCO frequencies have been set.

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

_configure_sequencer_settings(seq_idx: int, settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) → 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.AnalogSequencerSettings, channel_map_parameters: dict[str, str]) → dict[str, str][source]#: Adds the outputs to the channel map parameters dict.

_get_connected_lo_idx_for_sequencer(sequencer_settings: quantify_scheduler.backends.types.qblox.AnalogSequencerSettings) → list[int][source]#: Looks at the connected _output_ ports of the sequencer (if any) to determine which LO this sequencer’s output is coupled to.

abstract _configure_lo_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings, lo_idx_to_connected_seq_idx: dict[int, list[int]]) → None[source]#: Configure the settings for LO frequency and automatic mixer calibration.

class _QCMRFComponent(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: _RFComponent, _QCMComponent

QCM-RF specific InstrumentCoordinator component.

_hardware_properties[source]#

Holds all the differences between the different modules.

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

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

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

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

_configure_lo_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings, lo_idx_to_connected_seq_idx: dict[int, list[int]]) → None[source]#: Configure the settings for LO frequency and automatic mixer calibration.

class _QRMRFComponent(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: _RFComponent, _QRMComponent

QRM-RF specific InstrumentCoordinator component.

_hardware_properties[source]#

Holds all the differences between the different modules.

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

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

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

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

_configure_lo_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings, lo_idx_to_connected_seq_idx: dict[int, list[int]]) → None[source]#: Configure the settings for LO frequency and automatic mixer calibration.

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

class _QTMComponent(instrument: qblox_instruments.qcodes_drivers.module.Module)[source]#

Bases: _ModuleComponentBase

QTM specific InstrumentCoordinator component.

_hardware_properties[source]#

Holds all the differences between the different modules.

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

_acquisition_manager: _QTMAcquisitionManager | None = 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.

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

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.TimetagModuleSettings) → 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.TimetagSequencerSettings) → None[source]#

Configures all sequencer-specific settings.

Parameters:

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

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

Configures all io_channel-specific settings.

Parameters:

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

clear_data() → None[source]#: Clears remaining data on the module. Module type specific function.

_ReadoutModuleComponentT[source]#

class _AcquisitionManagerBase(parent: _ReadoutModuleComponentT, acquisition_metadata: dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata], acquisition_duration: dict[str, int], seq_name_to_idx_map: dict[str, int])[source]#

Bases: abc.ABC

Utility class that handles the acquisitions performed with a module.

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

parent[source]#

_acquisition_metadata[source]#

_acq_duration[source]#

_seq_name_to_idx_map[source]#

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

property _protocol_to_acq_function_map: dict[str, Callable][source]#

Abstractmethod:

Mapping from acquisition protocol name to the function that processes the raw acquisition data.

The acquisition processing function signature should be the following (for brevity, it’s not listed in the typehint):

def acq_processing_function(
    self,
    acq_indices: list,
    hardware_retrieved_acquisitions: dict,
    acquisition_metadata: AcquisitionMetadata,
    acq_duration: int,
    qblox_acq_index: int,
    acq_channel: Hashable,
) -> DataArray:

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 Each xarray.DataArray is a two-dimensional array, with acq_index and repetition as dimensions.

_assert_acquisition_data_exists(hardware_retrieved_acquisitions: dict, qblox_acq_index: int, acq_channel: Hashable) → None[source]#: Assert that the qblox_acq_index is in the acquisition data.

_get_acquisitions_from_instrument(seq_idx: int, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata) → dict[source]#

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

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

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.

F[source]#

_supported_bin_modes(bin_modes: Sequence[quantify_scheduler.enums.BinMode | str]) → Callable[[F], F][source]#

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

Bases: _AcquisitionManagerBase

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.
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.
scope_mode_sequencer_and_qblox_acq_index – The sequencer and qblox acq_index of the scope mode acquisition if there’s any.

_scope_mode_sequencer_and_qblox_acq_index[source]#

property _protocol_to_acq_function_map: dict[str, Callable][source]#

Mapping from acquisition protocol name to the function that processes the raw acquisition data.

The acquisition processing function signature should be the following (for brevity, it’s not listed in the typehint):

def acq_processing_function(
    self,
    acq_indices: list,
    hardware_retrieved_acquisitions: dict,
    acquisition_metadata: AcquisitionMetadata,
    acq_duration: int,
    qblox_acq_index: int,
    acq_channel: Hashable,
) -> DataArray:

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() → None[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.

_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.DISTRIBUTION, data contains the distribution of counts.
For BinMode.APPEND, data contains the raw trigger counts.

class _QTMAcquisitionManager(parent: _ReadoutModuleComponentT, acquisition_metadata: dict[str, quantify_scheduler.schedules.schedule.AcquisitionMetadata], acquisition_duration: dict[str, int], seq_name_to_idx_map: dict[str, int])[source]#

Bases: _AcquisitionManagerBase

Utility class that handles the acquisitions performed with the QTM.

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.
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 _protocol_to_acq_function_map: dict[str, Callable][source]#

Mapping from acquisition protocol name to the function that processes the raw acquisition data.

The acquisition processing function signature should be the following (for brevity, it’s not listed in the typehint):

def acq_processing_function(
    self,
    acq_indices: list,
    hardware_retrieved_acquisitions: dict,
    acquisition_metadata: AcquisitionMetadata,
    acq_duration: int,
    qblox_acq_index: int,
    acq_channel: Hashable,
) -> DataArray:

_get_acquisitions_from_instrument(seq_idx: int, acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata) → dict[source]#

_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

BinMode.AVERAGE is not implemented for the QTM.
For BinMode.APPEND, data contains the raw trigger counts.

_get_digital_trace_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]#

_get_timetag_trace_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]#

_split_timetag_trace_data_per_window(timetags: list[int], scope_data: list[tuple[str, int]]) → list[list[float]][source]#

Split the long array of scope_data on acquisition windows.

The scope_data is formatted like [[TYPE, TIME],[TYPE,TIME],…], where TYPE is one of “OPEN”, “RISE”, “CLOSE”. The TIME is absolute (cluster system time).

Each acquisition window starts with “OPEN” and ends with “CLOSE”. This method uses that information to divide the long scope_data array up into smaller arrays for each acquisition window.

Furthermore, the timetags list contains the relative timetags of the first pulse recorded in each window. This data is used to calculate the relative timetags for all timetags in the trace.

_get_timetag_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]#

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

_cluster_modules: dict[str, _ClusterModule][source]#

_program[source]#

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]) → None[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() → xarray.Dataset | 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]#