quantify_scheduler.instrument_coordinator.components.qblox

Module containing Qblox InstrumentCoordinator Components.

Module Contents

Classes

_SequencerStateInfo
_StaticHardwareProperties	Dataclass that holds all the static differences between the different Qblox
QbloxInstrumentCoordinatorComponentBase	Qblox InstrumentCoordinator component base class.
QCMComponent	QCM specific InstrumentCoordinator component.
QRMComponent	QRM specific InstrumentCoordinator component.
QCMRFComponent	QCM-RF specific InstrumentCoordinator component.
QRMRFComponent	QRM-RF specific InstrumentCoordinator component.
PulsarQCMComponent	A component for a baseband Pulsar QCM.
PulsarQRMComponent	A component for a baseband Pulsar QRM.
_QRMAcquisitionManager	Utility class that handles the acquisitions performed with the QRM.
ClusterComponent	Class that represents an instrument coordinator component for a Qblox cluster.

Attributes

logger
_SEQUENCER_STATE_FLAG_INFO	Used to link all flags returned by the hardware to logging message and
_QCM_BASEBAND_PROPERTIES
_QRM_BASEBAND_PROPERTIES
_QCM_RF_PROPERTIES
_QRM_RF_PROPERTIES
AcquisitionIndexing	Named tuple to clarify how the indexing of acquisitions works inside the
ClusterModule	Type that combines all the possible modules for a cluster.

logger

class _SequencerStateInfo

message :str

The text to pass as the logging message.

logging_level :int

The logging level to use.

static get_logging_level(flag: qblox_instruments.SequencerStatusFlags) → int

Define the logging level per SequencerStatusFlags flag.

_SEQUENCER_STATE_FLAG_INFO :Dict[qblox_instruments.SequencerStatusFlags, _SequencerStateInfo]

Used to link all flags returned by the hardware to logging message and logging level.

class _StaticHardwareProperties

Dataclass that holds all the static differences between the different Qblox devices that are relevant for configuring them correctly.

settings_type :Type[quantify_scheduler.backends.types.qblox.BaseModuleSettings]

The settings dataclass to use that the hardware needs to configure to.

has_internal_lo :bool

Specifies if an internal lo source is available.

number_of_sequencers :int

The number of sequencers the hardware has available.

number_of_output_paths :int

The number of output paths that can be used.

_QCM_BASEBAND_PROPERTIES

_QRM_BASEBAND_PROPERTIES

_QCM_RF_PROPERTIES

_QRM_RF_PROPERTIES

class QbloxInstrumentCoordinatorComponentBase(instrument: Union[qcodes.instrument.base.Instrument, qcodes.instrument.channel.InstrumentChannel], **kwargs)

Bases: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase

Qblox InstrumentCoordinator component base class.

property instrument → Union[qcodes.instrument.base.Instrument, qcodes.instrument.channel.InstrumentChannel]

For Cluster modules we return a reference to its InstrumentChannel in the Cluster instrument; for Pulsar modules we return the instrument reference

_set_parameter(instrument: Union[qcodes.instrument.base.Instrument, qcodes.instrument.channel.InstrumentChannel], parameter_name: str, val: Any) → None

Sets the parameter directly or using the lazy set, depending on the value of force_set_parameters.

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

Finds if any of the sequencers is currently running.

Returns

True if any of the sequencers reports the SequencerStatus.RUNNING status.

wait_done(timeout_sec: int = 10) → None

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.

start() → None

Starts execution of the schedule.

stop() → None

Stops all execution.

abstract _configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings) → None

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

Configures all sequencer-specific settings.

Parameters

• seq_idx – Index of the sequencer to configure.

• settings – The settings to configure it to.

static _get_channel_map_parameter_name(output_index: int) → str

_arm_all_sequencers_in_program(program: Dict[str, Any])

Arms all the sequencers that are part of the program.

property _hardware_properties → _StaticHardwareProperties

Holds all the differences between the different modules.

Returns

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

class QCMComponent(instrument: qcodes.instrument.base.Instrument, **kwargs)

Bases: QbloxInstrumentCoordinatorComponentBase

QCM specific InstrumentCoordinator component.

_hardware_properties

retrieve_acquisition() → None

Retrieves the previous acquisition.

Returns

QCM returns None since the QCM has no acquisition.

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

Uploads the waveforms and programs to the sequencers and configures all the settings required. 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

options – Program to upload to the sequencers. The key is a sequencer, e.g., "seq0", or "settings", the value is the global settings dict or a sequencer-specific configuration.

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings)

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

Parameters

settings – The settings to configure it to.

class QRMComponent(instrument: qcodes.instrument.base.Instrument, **kwargs)

Bases: QbloxInstrumentCoordinatorComponentBase

QRM specific InstrumentCoordinator component.

_hardware_properties

_acquisition_manager :Optional[_QRMAcquisitionManager]

Holds all the acquisition related logic.

retrieve_acquisition() → Optional[Dict[AcquisitionIndexing, Any]]

Retrieves the latest acquisition results.

Returns

The acquired data.

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

Uploads the waveforms and programs to the sequencers and configures all the settings required. 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

options – Program to upload to the sequencers. The key is a sequencer, e.g., "seq0", or "settings", the value is the global settings dict or a sequencer-specific configuration.

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.BaseModuleSettings)

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

Configures all sequencer-specific settings.

Parameters

• seq_idx – Index of the sequencer to configure.

• settings – The settings to configure it to.

class QCMRFComponent(instrument: qcodes.instrument.base.Instrument, **kwargs)

Bases: QCMComponent

QCM-RF specific InstrumentCoordinator component.

_hardware_properties

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings)

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

Parameters

settings – The settings to configure it to.

class QRMRFComponent(instrument: qcodes.instrument.base.Instrument, **kwargs)

Bases: QRMComponent

QRM-RF specific InstrumentCoordinator component.

_hardware_properties

_configure_global_settings(settings: quantify_scheduler.backends.types.qblox.RFModuleSettings)

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

Parameters

settings – The settings to configure it to.

class PulsarQCMComponent(instrument: qcodes.instrument.base.Instrument, **kwargs)

Bases: QCMComponent

A component for a baseband Pulsar QCM.

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

Uploads the waveforms and programs to the sequencers and configures all the settings required. 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

options – Program to upload to the sequencers. The key is a sequencer, e.g., "seq0", or "settings", the value is the global settings dict or a sequencer-specific configuration.

class PulsarQRMComponent(instrument: qcodes.instrument.base.Instrument, **kwargs)

Bases: QRMComponent

A component for a baseband Pulsar QRM.

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

Uploads the waveforms and programs to the sequencers and configures all the settings required. 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

options – Program to upload to the sequencers. The key is a sequencer, e.g., "seq0", or "settings", the value is the global settings dict or a sequencer-specific configuration.

AcquisitionIndexing

Named tuple to clarify how the indexing of acquisitions works inside the _QRMAcquisitionManager.

class _QRMAcquisitionManager(parent: QRMComponent, number_of_sequencers: int, acquisition_mapping: Dict[Tuple[int, int], Tuple[str, str]], acquisition_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata)

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.

property instrument

Returns the QRM driver from the parent IC component.

retrieve_acquisition() → Dict[AcquisitionIndexing, Any]

Retrieves all the acquisition data in the correct format.

Returns

The acquisitions with the protocols specified in the acq_mapping as a dict with the (acq_channel, acq_index) as keys.

_store_scope_acquisition()

_get_protocol(acq_channel, acq_index) → str

Returns the acquisition protocol corresponding to acq_channel with acq_index.

_get_sequencer_index(acq_channel, acq_index) → int

Returns the seq idx corresponding to acq_channel with acq_index.

_get_scope_channel_and_index() → Optional[AcquisitionIndexing]

Returns the first (acq_channel, acq_index) pair that uses “trace” acquisition. Returns None if none of them do.

_get_scope_data(acquisitions: dict, acq_channel: int = 0) → Tuple[numpy.ndarray, numpy.ndarray]

Retrieves the scope mode acquisition associated with an acq_channel.

Parameters

acq_channel – The acq_channel to get the scope mode acquisition for.

Returns

• scope_data_i – The scope mode data for path0.

• scope_data_q – The scope mode data for path1.

_get_integration_data(acquisitions: dict, acq_channel: int = 0) → Tuple[numpy.ndarray, numpy.ndarray]

Retrieves the integrated acquisition data associated with an acq_channel.

Parameters

• acquisitions – The acquisitions dict as returned by the sequencer.

• acq_channel – The acq_channel from which to get the data.

Returns

• i_data – The integrated data for path0.

• q_data – The integrated data for path1.

_get_integration_amplitude_data(acquisitions: dict, acq_channel: int = 0) → Tuple[numpy.ndarray, numpy.ndarray]

Gets the integration data but normalized to the integration time (number of samples summed). 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

• acquisitions – The acquisitions dict as returned by the sequencer.

• acq_channel – The acq_channel from which to get the data.

Returns

• data_i – Array containing I-quadrature data.

• data_q – Array containing Q-quadrature data.

_get_threshold_data(acquisitions: dict, acq_channel: int = 0, acq_index: int = 0) → float

Retrieves the thresholded acquisition data associated with acq_channel and acq_index.

Parameters

• acquisitions – The acquisitions dict as returned by the sequencer.

• acq_channel – The acq_channel to get the thresholded acquisition data for.

• acq_index – The acq_index to get the thresholded acquisition data for.

Returns

The value of the thresholded acquisition for acq_channel and acq_index. Should always be 0.0 <= val <= 1.0.

static _channel_index_to_channel_name(acq_channel: int) → str

Returns the name of the acquisition from the acq_channel.

classmethod _get_bin_data(acquisitions: dict, acq_channel: int = 0) → dict

Returns the bin entry of the acquisition data dict.

ClusterModule

Type that combines all the possible modules for a cluster.

class ClusterComponent(instrument: qblox_instruments.Cluster, **kwargs)

Bases: quantify_scheduler.instrument_coordinator.components.base.InstrumentCoordinatorComponentBase

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

property is_running → bool

Returns true if any of the modules are currently running.

start() → None

Starts all the modules in the cluster.

stop() → None

Stops all the modules in the cluster.

_configure_cmm_settings(settings: Dict[str, Any])

Sets all the settings of the CMM (Cluster Management Module) that have been provided by the backend.

Parameters

settings – A dictionary containing all the settings to set.

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

Prepares the cluster component for execution of a schedule.

Parameters

options – The compiled instructions to configure the cluster to.

retrieve_acquisition() → Optional[Dict[Tuple[int, int], Any]]

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

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.