qblox#

Python dataclasses for compilation to Qblox hardware.

Module Contents#

Classes#

`BoundedParameter`	Specifies a certain parameter with a fixed max and min in a certain unit.
`StaticHardwareProperties`	Specifies the fixed hardware properties needed in the backend.
`StaticAnalogModuleProperties`	Specifies the fixed hardware properties needed in the backend for QRM/QCM modules.
`StaticTimetagModuleProperties`	Specifies the fixed hardware properties needed in the backend for QTM modules.
`OpInfo`	Data structure describing a pulse or acquisition and containing all the information
`LOSettings`	Dataclass containing all the settings for a generic LO instrument.
`QbloxRealTimeFilter`	An individual real time filter on Qblox hardware.
`DistortionSettings`	Distortion correction settings for all Qblox modules.
`ExternalTriggerSyncSettings`	Settings for synchronizing a cluster on an external trigger.
`ClusterSettings`	Shared settings between all the Qblox modules.
`BaseModuleSettings`	Shared settings between all the Qblox modules.
`AnalogModuleSettings`	Shared settings between all QCM/QRM modules.
`BasebandModuleSettings`	Settings for a baseband module.
`RFModuleSettings`	Global settings for the module to be set in the InstrumentCoordinator component.
`TimetagModuleSettings`	Global settings for the module to be set in the InstrumentCoordinator component.
`ThresholdedAcqTriggerReadSettings`	Settings for reading from a trigger address.
`SequencerSettings`	Sequencer level settings.
`AnalogSequencerSettings`	Sequencer level settings.
`TimetagSequencerSettings`	Sequencer level settings.
`QbloxBaseDescription`	Base class for a Qblox hardware description.
`ComplexChannelDescription`	Information needed to specify an complex input/output in the
`RealChannelDescription`	Information needed to specify a real input/output in the
`DigitalChannelDescription`	Information needed to specify a digital (marker) output
`DescriptionAnnotationsGettersMixin`	Provide the functionality of retrieving valid channel names by inheriting this class.
`QRMDescription`	Information needed to specify a QRM in the
`QCMDescription`	Information needed to specify a QCM in the
`RFDescription`	User settings for radio frequency (RF) modules.
`QRMRFDescription`	Information needed to specify a QRM-RF in the
`QCMRFDescription`	Information needed to specify a QCM-RF in the
`QTMDescription`	Information needed to specify a QTM in the
`ClusterDescription`	Information needed to specify a Cluster in the `CompilationConfig`.
`ComplexInputGain`	Input gain settings for a complex input connected to a port-clock combination.
`QbloxMixerCorrections`	Mixer correction settings with defaults set to None, and extra mixer correction
`SequencerOptions`	Configuration options for a sequencer.
`QbloxHardwareDistortionCorrection`	A hardware distortion correction specific to the Qblox backend.
`DigitizationThresholds`	The settings that determine when an analog voltage is counted as a pulse.
`QbloxHardwareOptions`	Datastructure containing the hardware options for each port-clock combination.

Attributes#

`_ModuleSettingsT`	Custom type to allow correct type inference from `extract_settings_from_mapping` for
`ClusterModuleDescription`	Specifies a Cluster module and its instrument-specific settings.
`QbloxHardwareDescription`	Specifies a piece of Qblox hardware and its instrument-specific settings.
`RealInputGain`	Input gain settings for a real input connected to a port-clock combination.
`OutputAttenuation`	Output attenuation setting for a port-clock combination.
`InputAttenuation`	Input attenuation setting for a port-clock combination.

exception ValidationWarning[source]#

Bases: UserWarning

Warning type for dubious arguments passed to pydantic models.

class BoundedParameter[source]#

Specifies a certain parameter with a fixed max and min in a certain unit.

min_val: float[source]#: Min value allowed.

max_val: float[source]#: Max value allowed.

units: str[source]#: Units in which the parameter is specified.

class StaticHardwareProperties[source]#

Specifies the fixed hardware properties needed in the backend.

instrument_type: str[source]#: The type of instrument.

max_sequencers: int[source]#: The amount of sequencers available.

_get_connected_io_indices(mode: str, channel_idx: str) → tuple[int, Ellipsis][source]#: Return the connected input/output indices associated to this channel name.

_get_connected_output_indices(channel_name: str) → tuple[int, Ellipsis][source]#: Return the connected output indices associated to this channel name.

_get_connected_input_indices(channel_name: str, channel_name_measure: list[str] | None) → tuple[int, Ellipsis][source]#: Return the connected input indices associated to this channel name.

class StaticAnalogModuleProperties[source]#

Bases: StaticHardwareProperties

Specifies the fixed hardware properties needed in the backend for QRM/QCM modules.

max_awg_output_voltage: float | None[source]#: Maximum output voltage of the awg.

mixer_dc_offset_range: BoundedParameter[source]#: Specifies the range over which the dc offsets can be set that are used for mixer calibration.

channel_name_to_digital_marker: dict[str, int][source]#: A mapping from channel_name to digital marker setting. Specifies which marker bit needs to be set at start if the output (as a string ex. complex_output_0) contains a pulse.

default_markers: dict[str, int] | None = None[source]#: The default markers value to set at the beginning of programs and reset marker pulses to. A mapping from channel name to marker. Important for RF instruments that use the set_mrk command to enable/disable the RF output.

class StaticTimetagModuleProperties[source]#

Bases: StaticHardwareProperties

Specifies the fixed hardware properties needed in the backend for QTM modules.

class OpInfo[source]#

Bases: dataclasses_json.DataClassJsonMixin

Data structure describing a pulse or acquisition and containing all the information required to play it.

name: str[source]#: Name of the operation that this pulse/acquisition is part of.

data: dict[source]#: The pulse/acquisition info taken from the data property of the pulse/acquisition in the schedule.

timing: float[source]#: The start time of this pulse/acquisition. Note that this is a combination of the start time “t_abs” of the schedule operation, and the t0 of the pulse/acquisition which specifies a time relative to “t_abs”.

property duration: float[source]#: The duration of the pulse/acquisition.

property is_acquisition: bool[source]#: Returns True if this is an acquisition, False otherwise.

property is_real_time_io_operation: bool[source]#: Returns True if the operation is a non-idle pulse (i.e., it has a waveform), False otherwise.

property is_offset_instruction: bool[source]#: Returns True if the operation describes a DC offset operation, corresponding to the Q1ASM instruction set_awg_offset.

property is_parameter_instruction: bool[source]#

Return True if the instruction is a parameter, like a voltage offset.

From the Qblox documentation: “parameter operation instructions” are latched and only updated when the upd_param, play, acquire, acquire_weighed or acquire_ttl instructions are executed.

Please refer to https://docs.qblox.com/en/main/cluster/q1_sequence_processor.html#q1-instructions for the full list of these instructions.

property is_parameter_update: bool[source]#: Return True if the operation is a parameter update, corresponding to the Q1ASM instruction upd_param.

property is_loop: bool[source]#: Return True if the operation is a loop, corresponding to the Q1ASM instruction loop.

property is_control_flow_end: bool[source]#: Return True if the operation is a control flow end.

class LOSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Dataclass containing all the settings for a generic LO instrument.

power: dict[str, float][source]#: Power of the LO source.

frequency: dict[str, float | None][source]#: The frequency to set the LO to.

_ModuleSettingsT[source]#: Custom type to allow correct type inference from extract_settings_from_mapping for child classes.

class QbloxRealTimeFilter[source]#

Bases: dataclasses_json.DataClassJsonMixin

An individual real time filter on Qblox hardware.

coeffs: float | list[float] | None = None[source]#: Coefficient(s) of the filter. Can be None if there is no filter or if it is inactive.

config: quantify_scheduler.backends.qblox.enums.QbloxFilterConfig[source]#: Configuration of the filter. One of ‘BYPASSED’, ‘ENABLED’, or ‘DELAY_COMP’.

marker_delay: quantify_scheduler.backends.qblox.enums.QbloxFilterMarkerDelay[source]#: State of the marker delay. One of ‘BYPASSED’ or ‘ENABLED’.

get(item: str) → object[source]#

class DistortionSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Distortion correction settings for all Qblox modules.

bt: QbloxRealTimeFilter[source]#: The bias tee correction filter.

exp0: QbloxRealTimeFilter[source]#: The exponential overshoot correction 1 filter.

exp1: QbloxRealTimeFilter[source]#: The exponential overshoot correction 2 filter.

exp2: QbloxRealTimeFilter[source]#: The exponential overshoot correction 3 filter.

exp3: QbloxRealTimeFilter[source]#: The exponential overshoot correction 4 filter.

fir: QbloxRealTimeFilter[source]#: The FIR filter.

get(item: str) → object[source]#

class ExternalTriggerSyncSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Settings for synchronizing a cluster on an external trigger.

slot: int[source]#: Slot of the module receiving the incoming trigger (can be the CMM).

channel: int[source]#

Channel that receives the incoming trigger.

Note that this is the channel number on the front panel. When using a CMM, this should be 1.

input_threshold: float | None = None[source]#

If a QTM module is used, this setting specifies the input threshold.

If a CMM is used instead, this setting is ignored and the trigger signal must be TTL (>2.4 V).

trigger_timestamp: float = 0[source]#: What time the cluster should be set to upon receiving the trigger.

timeout: float = 1[source]#: The time the cluster will wait for the trigger to arrive.

format: str = 's'[source]#: The time unit for the trigger_timestamp and timeout parameters.

edge_polarity: qblox_instruments.qcodes_drivers.time.Polarity[source]#: The edge polarity to trigger on.

sync_to_ref_clock: bool = False[source]#: If True, synchronizes to the next internal 10 MHz reference clock tick, by default False.

class ClusterSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Shared settings between all the Qblox modules.

reference_source: Literal['internal', 'external'][source]#

sync_on_external_trigger: ExternalTriggerSyncSettings | None = None[source]#

classmethod extract_settings_from_mapping(mapping: quantify_scheduler.backends.qblox_backend._ClusterCompilationConfig) → ClusterSettings[source]#

Factory method that takes all the settings defined in the mapping and generates an instance of this class.

Parameters:

mapping – The mapping dict to extract the settings from
**kwargs – Additional keyword arguments passed to the constructor. Can be used to override parts of the mapping dict.

class BaseModuleSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Shared settings between all the Qblox modules.

offset_ch0_path_I: float | None = None[source]#: The DC offset on the path_I of channel 0.

offset_ch0_path_Q: float | None = None[source]#: The DC offset on the path_Q of channel 0.

offset_ch1_path_I: float | None = None[source]#: The DC offset on path_I of channel 1.

offset_ch1_path_Q: float | None = None[source]#: The DC offset on path_Q of channel 1.

in0_gain: int | None = None[source]#: The gain of input 0.

in1_gain: int | None = None[source]#: The gain of input 1.

distortion_corrections: list[DistortionSettings][source]#: distortion correction settings

get(item: str) → object[source]#

classmethod extract_settings_from_mapping(mapping: quantify_scheduler.backends.qblox_backend._ClusterModuleCompilationConfig, **kwargs) → _ModuleSettingsT[source]#

Factory method that takes all the settings defined in the mapping and generates an instance of this class.

Parameters:

mapping – The mapping dict to extract the settings from
**kwargs – Additional keyword arguments passed to the constructor. Can be used to override parts of the mapping dict.

class AnalogModuleSettings[source]#

Bases: BaseModuleSettings

Shared settings between all QCM/QRM modules.

offset_ch0_path_I: float | None = None[source]#: The DC offset on the path_I of channel 0.

offset_ch0_path_Q: float | None = None[source]#: The DC offset on the path_Q of channel 0.

offset_ch1_path_I: float | None = None[source]#: The DC offset on path_I of channel 1.

offset_ch1_path_Q: float | None = None[source]#: The DC offset on path_Q of channel 1.

out0_lo_freq_cal_type_default: quantify_scheduler.backends.qblox.enums.LoCalEnum[source]#: Setting that controls whether the mixer of channel 0 is calibrated upon changing the LO and/or intermodulation frequency.

out1_lo_freq_cal_type_default: quantify_scheduler.backends.qblox.enums.LoCalEnum[source]#: Setting that controls whether the mixer of channel 1 is calibrated upon changing the LO and/or intermodulation frequency.

in0_gain: int | None = None[source]#: The gain of input 0.

in1_gain: int | None = None[source]#: The gain of input 1.

class BasebandModuleSettings[source]#

Bases: AnalogModuleSettings

Settings for a baseband module.

Class exists to ensure that the cluster baseband modules don’t need special treatment in the rest of the code.

class RFModuleSettings[source]#

Bases: AnalogModuleSettings

Global settings for the module to be set in the InstrumentCoordinator component. This is kept separate from the settings that can be set on a per sequencer basis, which are specified in AnalogSequencerSettings.

lo0_freq: float | None = None[source]#: The frequency of Output 0 (O0) LO. If left None, the parameter will not be set.

lo1_freq: float | None = None[source]#: The frequency of Output 1 (O1) LO. If left None, the parameter will not be set.

out0_att: int | None = None[source]#: The attenuation of Output 0.

out1_att: int | None = None[source]#: The attenuation of Output 1.

in0_att: int | None = None[source]#: The attenuation of Input 0.

classmethod extract_settings_from_mapping(mapping: quantify_scheduler.backends.qblox_backend._ClusterModuleCompilationConfig, **kwargs: dict | None) → RFModuleSettings[source]#

Factory method that takes all the settings defined in the mapping and generates an RFModuleSettings object from it.

Parameters:

mapping – The compiler config to extract the settings from
**kwargs – Additional keyword arguments passed to the constructor. Can be used to override parts of the mapping dict.

class TimetagModuleSettings[source]#

Bases: BaseModuleSettings

Global settings for the module to be set in the InstrumentCoordinator component. This is kept separate from the settings that can be set on a per sequencer basis, which are specified in TimetagSequencerSettings.

class ThresholdedAcqTriggerReadSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Settings for reading from a trigger address.

thresholded_acq_trigger_invert: bool = False[source]#: If true, inverts the comparison result that is read from the trigger network address counter.

thresholded_acq_trigger_count: int | None = None[source]#: Sets the threshold for the counter on the specified trigger address.

class SequencerSettings[source]#

Bases: dataclasses_json.DataClassJsonMixin

Sequencer level settings.

In the Qblox driver these settings are typically recognized by parameter names of the form "{module}.sequencer{index}.{setting}" (for allowed values see Cluster QCoDeS parameters). These settings are set once and will remain unchanged after, meaning that these correspond to the “slow” QCoDeS parameters and not settings that are changed dynamically by the sequencer.

These settings are mostly defined in the hardware configuration under each port-clock key combination or in some cases through the device configuration (e.g. parameters related to thresholded acquisition).

sync_en: bool[source]#: Enables party-line synchronization.

channel_name: str[source]#: Specifies the channel identifier of the hardware config (e.g. complex_output_0).

channel_name_measure: list[str] | None[source]#: Extra channel name necessary to define a Measure operation.

connected_output_indices: tuple[int, Ellipsis][source]#: Specifies the indices of the outputs this sequencer produces waveforms for.

connected_input_indices: tuple[int, Ellipsis][source]#: Specifies the indices of the inputs this sequencer collects data for.

sequence: dict[str, Any] | None = None[source]#: JSON compatible dictionary holding the waveforms and program for the sequencer.

seq_fn: str | None = None[source]#: Filename of JSON file containing a dump of the waveforms and program.

thresholded_acq_trigger_write_en: bool | None = None[source]#: Enables mapping of thresholded acquisition results to the trigger network.

thresholded_acq_trigger_write_address: int | None = None[source]#: The trigger address that thresholded acquisition results are written to.

thresholded_acq_trigger_write_invert: bool = False[source]#: If True, inverts the trigger before writing to the trigger network.

thresholded_acq_trigger_read_settings: dict[int, ThresholdedAcqTriggerReadSettings][source]#: Settings for reading from a trigger address.

classmethod initialize_from_compilation_config(sequencer_cfg: quantify_scheduler.backends.qblox_backend._SequencerCompilationConfig, connected_output_indices: tuple[int, Ellipsis], connected_input_indices: tuple[int, Ellipsis]) → SequencerSettings[source]#

Instantiates an instance of this class, with initial parameters determined from the sequencer compilation config.

Parameters:

sequencer_cfg – The sequencer compilation_config.
connected_output_indices – Specifies the indices of the outputs this sequencer produces waveforms for.
connected_input_indices – Specifies the indices of the inputs this sequencer collects data for.

Returns:

: SequencerSettings A SequencerSettings instance with initial values.

get(item: str) → object[source]#

class AnalogSequencerSettings[source]#

Bases: SequencerSettings

Sequencer level settings.

In the Qblox driver these settings are typically recognized by parameter names of the form "{module}.sequencer{index}.{setting}" (for allowed values see Cluster QCoDeS parameters). These settings are set once and will remain unchanged after, meaning that these correspond to the “slow” QCoDeS parameters and not settings that are changed dynamically by the sequencer.

These settings are mostly defined in the hardware configuration under each port-clock key combination or in some cases through the device configuration (e.g. parameters related to thresholded acquisition).

nco_en: bool = False[source]#: Specifies whether the NCO will be used or not.

init_offset_awg_path_I: float = 0.0[source]#: Specifies what value the sequencer offset for AWG path_I will be reset to before the start of the experiment.

init_offset_awg_path_Q: float = 0.0[source]#: Specifies what value the sequencer offset for AWG path_Q will be reset to before the start of the experiment.

init_gain_awg_path_I: float = 1.0[source]#: Specifies what value the sequencer gain for AWG path_I will be reset to before the start of the experiment.

init_gain_awg_path_Q: float = 1.0[source]#: Specifies what value the sequencer gain for AWG path_Q will be reset to before the start of the experiment.

modulation_freq: float | None = None[source]#: Specifies the frequency of the modulation.

mixer_corr_phase_offset_degree: float | None = None[source]#: The phase shift to apply between the I and Q channels, to correct for quadrature errors.

mixer_corr_gain_ratio: float | None = None[source]#: The gain ratio to apply in order to correct for imbalances between the I and Q paths of the mixer.

auto_sideband_cal: quantify_scheduler.backends.qblox.enums.SidebandCalEnum[source]#: Setting that controls whether the mixer is calibrated upon changing the intermodulation frequency.

integration_length_acq: int | None = None[source]#: Integration length for acquisitions. Must be a multiple of 4 ns.

thresholded_acq_threshold: float | None = None[source]#: The sequencer discretization threshold for discretizing the phase rotation result.

thresholded_acq_rotation: float | None = None[source]#: The sequencer integration result phase rotation in degrees.

ttl_acq_input_select: int | None = None[source]#: Selects the input used to compare against the threshold value in the TTL trigger acquisition path.

ttl_acq_threshold: float | None = None[source]#: For QRM modules only, sets the threshold value with which to compare the input ADC values of the selected input path.

ttl_acq_auto_bin_incr_en: bool | None = None[source]#: Selects if the bin index is automatically incremented when acquiring multiple triggers.

classmethod initialize_from_compilation_config(sequencer_cfg: quantify_scheduler.backends.qblox_backend._SequencerCompilationConfig, connected_output_indices: tuple[int, Ellipsis], connected_input_indices: tuple[int, Ellipsis]) → AnalogSequencerSettings[source]#

Instantiates an instance of this class, with initial parameters determined from the sequencer compilation config.

Parameters:

sequencer_cfg – The sequencer compilation_config.
connected_output_indices – Specifies the indices of the outputs this sequencer produces waveforms for.
connected_input_indices – Specifies the indices of the inputs this sequencer collects data for.

Returns:

: AnalogSequencerSettings A AnalogSequencerSettings instance with initial values.

class TimetagSequencerSettings[source]#

Bases: SequencerSettings

Sequencer level settings.

In the Qblox driver these settings are typically recognized by parameter names of the form "{module}.sequencer{index}.{setting}" (for allowed values see Cluster QCoDeS parameters). These settings are set once and will remain unchanged after, meaning that these correspond to the “slow” QCoDeS parameters and not settings that are changed dynamically by the sequencer.

These settings are mostly defined in the hardware configuration under each port-clock key combination or in some cases through the device configuration (e.g. parameters related to thresholded acquisition).

in_threshold_primary: float | None = None[source]#: The settings that determine when an analog voltage is counted as a pulse.

time_source: quantify_scheduler.enums.TimeSource | None = None[source]#: Selects the timetag data source for timetag acquisitions.

time_ref: quantify_scheduler.enums.TimeRef | None = None[source]#: Selects the time reference that the timetag is recorded in relation to.

time_ref_channel: int | None = None[source]#: If using TimeRef.PORT, this setting specifies the channel index (on the same module) belonging to that port.

scope_trace_type: quantify_scheduler.backends.qblox.enums.TimetagTraceType | None = None[source]#: Set to True if the program on this sequencer contains a scope/trace acquisition.

trace_acq_duration: int | None = None[source]#: Duration of the trace acquisition (if any) done with this sequencer.

thresholded_acq_trigger_write_address_low: int = 0[source]#

thresholded_acq_trigger_write_address_mid: int = 0[source]#

thresholded_acq_trigger_write_address_high: int = 0[source]#

thresholded_acq_trigger_write_address_invalid: int = 0[source]#

thresholded_acq_trigger_write_threshold_low: int | None = None[source]#: Optional threshold value used for the upd_thres Q1ASM instruction if ThresholdedTriggerCount is scheduled.

thresholded_acq_trigger_write_threshold_high: int | None = None[source]#: Optional threshold value used for the upd_thres Q1ASM instruction if ThresholdedTriggerCount is scheduled.

_validate_io_indices_no_channel_map() → None[source]#: There is no channel map in the QTM yet, so there can be only one connected index: either input or output.

classmethod initialize_from_compilation_config(sequencer_cfg: quantify_scheduler.backends.qblox_backend._SequencerCompilationConfig, connected_output_indices: tuple[int, Ellipsis], connected_input_indices: tuple[int, Ellipsis]) → TimetagSequencerSettings[source]#

Instantiates an instance of this class, with initial parameters determined from the sequencer compilation config.

Parameters:

sequencer_cfg – The sequencer compilation config.
connected_output_indices – Specifies the indices of the outputs this sequencer produces waveforms for.
connected_input_indices – Specifies the indices of the inputs this sequencer collects data for.

Returns:

: SequencerSettings A SequencerSettings instance with initial values.

class QbloxBaseDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.backends.types.common.HardwareDescription

Base class for a Qblox hardware description.

ref: Literal['internal'] | Literal['external'][source]#: The reference source for the instrument.

sequence_to_file: bool = False[source]#: Write sequencer programs to files for (all modules in this) instrument.

class ComplexChannelDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure

Information needed to specify an complex input/output in the QbloxHardwareCompilationConfig.

marker_debug_mode_enable: bool = False[source]#: Setting to send 4 ns trigger pulse on the marker located next to the I/O port along with each operation. The marker will be pulled high at the same time as the module starts playing or acquiring.

mix_lo: bool = True[source]#: Whether IQ mixing with a local oscillator is enabled for this channel. Effectively always True for RF modules.

downconverter_freq: float | None = None[source]#: Downconverter frequency that should be taken into account w hen determining the modulation frequencies for this channel. Only relevant for users with custom Qblox downconverter hardware.

distortion_correction_latency_compensation: int[source]#: Delay compensation setting that either delays the signal by the amount chosen by the settings or not.

class RealChannelDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure

Information needed to specify a real input/output in the QbloxHardwareCompilationConfig.

marker_debug_mode_enable: bool = False[source]#: Setting to send 4 ns trigger pulse on the marker located next to the I/O port along with each operation. The marker will be pulled high at the same time as the module starts playing or acquiring.

mix_lo: bool = True[source]#: Whether IQ mixing with a local oscillator is enabled for this channel. Effectively always True for RF modules.

distortion_correction_latency_compensation: int[source]#: Delay compensation setting that either delays the signal by the amount chosen by the settings or not.

class DigitalChannelDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure

Information needed to specify a digital (marker) output (for MarkerPulse) in the QbloxHardwareCompilationConfig.

distortion_correction_latency_compensation: int[source]#: Delay compensation setting that either delays the signal by the amount chosen by the settings or not.

class DescriptionAnnotationsGettersMixin[source]#

Provide the functionality of retrieving valid channel names by inheriting this class.

classmethod get_valid_channels() → list[str][source]#: Return all the valid channel names for this hardware description.

classmethod get_instrument_type() → str[source]#: Return the instrument type indicated in this hardware description.

classmethod validate_channel_names(channel_names: collections.abc.Iterable[str]) → None[source]#: Validate channel names specified in the Connectivity.

class QRMDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure, DescriptionAnnotationsGettersMixin

Information needed to specify a QRM in the QbloxHardwareCompilationConfig.

instrument_type: Literal['QRM'] = 'QRM'[source]#: The instrument type of this module.

sequence_to_file: bool = False[source]#: Write sequencer programs to files, for this module.

complex_output_0: ComplexChannelDescription | None = None[source]#: Description of the complex output channel on this QRM, corresponding to ports O1 and O2.

complex_input_0: ComplexChannelDescription | None = None[source]#: Description of the complex input channel on this QRM, corresponding to ports I1 and I2.

real_output_0: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port O1.

real_output_1: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port O2.

real_input_0: RealChannelDescription | None = None[source]#: Description of the real input channel on this QRM, corresponding to port I1.

real_input_1: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port I2.

digital_output_0: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M1.

digital_output_1: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M2.

digital_output_2: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M3.

digital_output_3: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M4.

class QCMDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure, DescriptionAnnotationsGettersMixin

Information needed to specify a QCM in the QbloxHardwareCompilationConfig.

instrument_type: Literal['QCM'] = 'QCM'[source]#: The instrument type of this module.

sequence_to_file: bool = False[source]#: Write sequencer programs to files, for this module.

complex_output_0: ComplexChannelDescription | None = None[source]#: Description of the complex output channel on this QRM, corresponding to ports O1 and O2.

complex_output_1: ComplexChannelDescription | None = None[source]#: Description of the complex output channel on this QRM, corresponding to ports O3 and O4.

real_output_0: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port O1.

real_output_1: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port O2.

real_output_2: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port O3.

real_output_3: RealChannelDescription | None = None[source]#: Description of the real output channel on this QRM, corresponding to port O4.

digital_output_0: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M1.

digital_output_1: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M2.

digital_output_2: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M3.

digital_output_3: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M4.

class RFDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure, DescriptionAnnotationsGettersMixin

User settings for radio frequency (RF) modules.

sequence_to_file: bool = False[source]#: Write sequencer programs to files, for this module.

rf_output_on: bool = True[source]#

Whether the RF outputs of this module are always on by default.

If set to False they can be turned on by using the RFSwitchToggle operation.

class QRMRFDescription(/, **data: Any)[source]#

Bases: RFDescription

Information needed to specify a QRM-RF in the QbloxHardwareCompilationConfig.

instrument_type: Literal['QRM_RF'] = 'QRM_RF'[source]#: The instrument type of this module.

complex_output_0: ComplexChannelDescription | None = None[source]#: Description of the complex output channel on this QRM, corresponding to port O1.

complex_input_0: ComplexChannelDescription | None = None[source]#: Description of the complex input channel on this QRM, corresponding to port I1.

digital_output_0: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M1.

digital_output_1: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M2.

class QCMRFDescription(/, **data: Any)[source]#

Bases: RFDescription

Information needed to specify a QCM-RF in the QbloxHardwareCompilationConfig.

instrument_type: Literal['QCM_RF'] = 'QCM_RF'[source]#: The instrument type of this module.

complex_output_0: ComplexChannelDescription | None = None[source]#: Description of the complex output channel on this QRM, corresponding to port O1.

complex_output_1: ComplexChannelDescription | None = None[source]#: Description of the complex output channel on this QRM, corresponding to port O2.

digital_output_0: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M1.

digital_output_1: DigitalChannelDescription | None = None[source]#: Description of the digital (marker) output channel on this QRM, corresponding to port M2.

class QTMDescription(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure, DescriptionAnnotationsGettersMixin

Information needed to specify a QTM in the QbloxHardwareCompilationConfig.

instrument_type: Literal['QTM'] = 'QTM'[source]#: The instrument type of this module.

sequence_to_file: bool = False[source]#: Write sequencer programs to files, for this module.

digital_input_0: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 1, specified as input.

digital_input_1: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 2, specified as input.

digital_input_2: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 3, specified as input.

digital_input_3: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 4, specified as input.

digital_input_4: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 5, specified as input.

digital_input_5: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 6, specified as input.

digital_input_6: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 7, specified as input.

digital_input_7: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 8, specified as input.

digital_output_0: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 1, specified as output.

digital_output_1: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 2, specified as output.

digital_output_2: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 3, specified as output.

digital_output_3: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 4, specified as output.

digital_output_4: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 5, specified as output.

digital_output_5: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 6, specified as output.

digital_output_6: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 7, specified as output.

digital_output_7: DigitalChannelDescription | None = None[source]#: Description of the digital channel corresponding to port 8, specified as output.

classmethod validate_channel_names(channel_names: collections.abc.Iterable[str]) → None[source]#: Validate channel names specified in the Connectivity.

ClusterModuleDescription[source]#

Specifies a Cluster module and its instrument-specific settings.

The supported instrument types are: QRMDescription, QCMDescription, QRMRFDescription, QCMRFDescription, QTMDescription,

class ClusterDescription(/, **data: Any)[source]#

Bases: QbloxBaseDescription

Information needed to specify a Cluster in the CompilationConfig.

instrument_type: Literal['Cluster'][source]#: The instrument type, used to select this datastructure when parsing a CompilationConfig.

modules: dict[int, ClusterModuleDescription][source]#: Description of the modules of this Cluster, using slot index as key.

ip: str | None = None[source]#: Unique identifier (typically the ip address) used to connect to the cluster

sync_on_external_trigger: ExternalTriggerSyncSettings | None = None[source]#: Settings for synchronizing the cluster on an external trigger.

QbloxHardwareDescription[source]#: Specifies a piece of Qblox hardware and its instrument-specific settings.

RealInputGain[source]#

Input gain settings for a real input connected to a port-clock combination.

This gain value will be set on the QRM input ports that are connected to this port-clock combination.

Example

hardware_compilation_config.hardware_options.input_gain = {
    "q0:res-q0.ro": RealInputGain(2),
}

class ComplexInputGain(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure

Input gain settings for a complex input connected to a port-clock combination.

This gain value will be set on the QRM input ports that are connected to this port-clock combination.

Example

hardware_compilation_config.hardware_options.input_gain = {
    "q0:res-q0.ro": ComplexInputGain(
        gain_I=2,
        gain_Q=3
    ),
}

gain_I: int[source]#: Gain setting on the input receiving the I-component data for this port-clock combination.

gain_Q: int[source]#: Gain setting on the input receiving the Q-component data for this port-clock combination.

OutputAttenuation[source]#

Output attenuation setting for a port-clock combination.

This attenuation value will be set on each control-hardware output port that is connected to this port-clock combination.

Example

hardware_compilation_config.hardware_options.output_att = {
    "q0:res-q0.ro": OutputAttenuation(10),
}

InputAttenuation[source]#

Input attenuation setting for a port-clock combination.

This attenuation value will be set on each control-hardware output port that is connected to this port-clock combination.

Example

hardware_compilation_config.hardware_options.input_att = {
    "q0:res-q0.ro": InputAttenuation(10),
}

class QbloxMixerCorrections(/, **data: Any)[source]#

Bases: quantify_scheduler.backends.types.common.MixerCorrections

Mixer correction settings with defaults set to None, and extra mixer correction settings for _automated_ mixer correction.

These settings will be set on each control-hardware output port that is connected to this port-clock combination.

Example

hardware_compilation_config.hardware_options.mixer_corrections = {
    "q0:res-q0.ro": {
        auto_lo_cal="on_lo_interm_freq_change",
        auto_sideband_cal="on_interm_freq_change"
    },
}

dc_offset_i: float | None = None[source]#: The DC offset on the I channel used for this port-clock combination.

dc_offset_q: float | None = None[source]#: The DC offset on the Q channel used for this port-clock combination.

amp_ratio: float = None[source]#: The mixer gain ratio used for this port-clock combination.

phase_error: float = None[source]#: The mixer phase error used for this port-clock combination.

auto_lo_cal: quantify_scheduler.backends.qblox.enums.LoCalEnum[source]#: Setting that controls whether the mixer is calibrated upon changing the LO and/or intermodulation frequency.

auto_sideband_cal: quantify_scheduler.backends.qblox.enums.SidebandCalEnum[source]#: Setting that controls whether the mixer is calibrated upon changing the intermodulation frequency.

classmethod warn_if_mixed_auto_and_manual_calibration(data: dict[str, Any]) → dict[str, Any][source]#: Warn if there is mixed usage of automatic mixer calibration (the auto_* settings) and manual mixer correction settings.

class SequencerOptions(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure

Configuration options for a sequencer.

For allowed values, also see Cluster QCoDeS parameters.

Example

hardware_compilation_config.hardware_options.sequencer_options = {
    "q0:res-q0.ro": {
        "init_offset_awg_path_I": 0.1,
        "init_offset_awg_path_Q": -0.1,
        "init_gain_awg_path_I": 0.9,
        "init_gain_awg_path_Q": 1.0,
        "ttl_acq_threshold": 0.5
        "qasm_hook_func": foo
    }
}

init_offset_awg_path_I: float = None[source]#: Specifies what value the sequencer offset for AWG path_I will be reset to before the start of the experiment.

init_offset_awg_path_Q: float = None[source]#: Specifies what value the sequencer offset for AWG path_Q will be reset to before the start of the experiment.

init_gain_awg_path_I: float = None[source]#: Specifies what value the sequencer gain for AWG path_I will be reset to before the start of the experiment.

init_gain_awg_path_Q: float = None[source]#: Specifies what value the sequencer gain for AWG path_Q will be reset to before the start of the experiment.

ttl_acq_threshold: float | None = None[source]#: For QRM modules only, the threshold value with which to compare the input ADC values of the selected input path.

qasm_hook_func: collections.abc.Callable | None = None[source]#: Function to inject custom qasm instructions after the compiler inserts the footer and the stop instruction in the generated qasm program.

classmethod _init_setting_limits(init_setting) → float[source]#

class QbloxHardwareDistortionCorrection(/, **data: Any)[source]#

Bases: quantify_scheduler.backends.types.common.HardwareDistortionCorrection

A hardware distortion correction specific to the Qblox backend.

bt_coeffs: list[float] | None = None[source]#: Coefficient of the bias tee correction.

exp0_coeffs: list[float] | None = None[source]#: Coefficients of the exponential overshoot/undershoot correction 1.

exp1_coeffs: list[float] | None = None[source]#: Coefficients of the exponential overshoot/undershoot correction 2.

exp2_coeffs: list[float] | None = None[source]#: Coefficients of the exponential overshoot/undershoot correction 3.

exp3_coeffs: list[float] | None = None[source]#: Coefficients of the exponential overshoot/undershoot correction 4.

fir_coeffs: list[float] | None = None[source]#: Coefficients for the FIR filter.

class DigitizationThresholds(/, **data: Any)[source]#

Bases: quantify_scheduler.structure.model.DataStructure

The settings that determine when an analog voltage is counted as a pulse.

in_threshold_primary: float | None = None[source]#: For QTM modules only, this is the voltage threshold above which an input signal is registered as high.

class QbloxHardwareOptions(/, **data: Any)[source]#

Bases: quantify_scheduler.backends.types.common.HardwareOptions

Datastructure containing the hardware options for each port-clock combination.

Example

Here, the HardwareOptions datastructure is created by parsing a dictionary containing the relevant information.

import pprint
from quantify_scheduler.schemas.examples.utils import (
    load_json_example_scheme
)

from quantify_scheduler.backends.types.qblox import (
    QbloxHardwareOptions
)
qblox_hw_options_dict = load_json_example_scheme(
    "qblox_hardware_config_transmon.json")["hardware_options"]
pprint.pprint(qblox_hw_options_dict)

{'distortion_corrections': {'q0:fl-cl0.baseband': {'clipping_values': [-2.5,
                                                                       2.5],
                                                   'filter_func': 'scipy.signal.lfilter',
                                                   'input_var_name': 'x',
                                                   'kwargs': {'a': [1],
                                                              'b': [0,
                                                                    0.25,
                                                                    0.5]}}},
 'input_att': {'q0:res-q0.ro': 4, 'q5:res-q5.ro': 10},
 'input_gain': {'q4:res-q4.ro': {'gain_I': 2, 'gain_Q': 3}},
 'latency_corrections': {'q4:mw-q4.01': 8e-09, 'q5:mw-q5.01': 4e-09},
 'mixer_corrections': {'q4:mw-q4.01': {'amp_ratio': 0.9999,
                                       'phase_error': -4.2},
                       'q4:res-q4.ro': {'amp_ratio': 0.9997,
                                        'dc_offset_i': -0.054,
                                        'dc_offset_q': -0.034,
                                        'phase_error': -4.0}},
 'modulation_frequencies': {'q0:mw-q0.01': {'interm_freq': 50000000.0,
                                            'lo_freq': None},
                            'q0:res-q0.ro': {'interm_freq': None,
                                             'lo_freq': 7800000000.0},
                            'q4:mw-q4.01': {'interm_freq': 200000000.0,
                                            'lo_freq': None},
                            'q4:res-q4.ro': {'interm_freq': None,
                                             'lo_freq': 7200000000.0},
                            'q5:mw-q5.01': {'interm_freq': 50000000.0,
                                            'lo_freq': None},
                            'q5:res-q5.ro': {'interm_freq': 50000000.0},
                            'q6:mw-q6.01': {'lo_freq': 5000000000.0},
                            'q7:mw-q7.01': {'lo_freq': 5000000000.0}},
 'output_att': {'q0:mw-q0.01': 4,
                'q0:res-q0.ro': 12,
                'q5:mw-q5.01': 4,
                'q6:mw-q6.01': 6},
 'sequencer_options': {'qe0:optical_readout-qe0.ge0': {'ttl_acq_threshold': 0.5}}}

The dictionary can be parsed using the model_validate method.

qblox_hw_options = QbloxHardwareOptions.model_validate(qblox_hw_options_dict)
qblox_hw_options

QbloxHardwareOptions(crosstalk=None, latency_corrections={'q4:mw-q4.01': 8e-09, 'q5:mw-q5.01': 4e-09}, distortion_corrections={'q0:fl-cl0.baseband': SoftwareDistortionCorrection(filter_func='scipy.signal.lfilter', input_var_name='x', kwargs={'b': [0, 0.25, 0.5], 'a': [1]}, clipping_values=[-2.5, 2.5], sampling_rate=1000000000.0)}, modulation_frequencies={'q0:res-q0.ro': ModulationFrequencies(interm_freq=None, lo_freq=7800000000.0), 'q0:mw-q0.01': ModulationFrequencies(interm_freq=50000000.0, lo_freq=None), 'q4:mw-q4.01': ModulationFrequencies(interm_freq=200000000.0, lo_freq=None), 'q4:res-q4.ro': ModulationFrequencies(interm_freq=None, lo_freq=7200000000.0), 'q5:mw-q5.01': ModulationFrequencies(interm_freq=50000000.0, lo_freq=None), 'q5:res-q5.ro': ModulationFrequencies(interm_freq=50000000.0, lo_freq=None), 'q6:mw-q6.01': ModulationFrequencies(interm_freq=None, lo_freq=5000000000.0), 'q7:mw-q7.01': ModulationFrequencies(interm_freq=None, lo_freq=5000000000.0)}, mixer_corrections={'q4:mw-q4.01': QbloxMixerCorrections(dc_offset_i=None, dc_offset_q=None, amp_ratio=0.9999, phase_error=-4.2, auto_lo_cal=<LoCalEnum.OFF: 'off'>, auto_sideband_cal=<SidebandCalEnum.OFF: 'off'>), 'q4:res-q4.ro': QbloxMixerCorrections(dc_offset_i=-0.054, dc_offset_q=-0.034, amp_ratio=0.9997, phase_error=-4.0, auto_lo_cal=<LoCalEnum.OFF: 'off'>, auto_sideband_cal=<SidebandCalEnum.OFF: 'off'>)}, input_gain={'q4:res-q4.ro': ComplexInputGain(gain_I=2, gain_Q=3)}, output_att={'q0:mw-q0.01': 4, 'q0:res-q0.ro': 12, 'q5:mw-q5.01': 4, 'q6:mw-q6.01': 6}, input_att={'q0:res-q0.ro': 4, 'q5:res-q5.ro': 10}, sequencer_options={'qe0:optical_readout-qe0.ge0': SequencerOptions(init_offset_awg_path_I=0.0, init_offset_awg_path_Q=0.0, init_gain_awg_path_I=1.0, init_gain_awg_path_Q=1.0, ttl_acq_threshold=0.5, qasm_hook_func=None)}, digitization_thresholds=None)

input_gain: dict[str, RealInputGain | ComplexInputGain] | None = None[source]#: Dictionary containing the input gain settings (values) that should be applied to the inputs that are connected to a certain port-clock combination (keys).

output_att: dict[str, OutputAttenuation] | None = None[source]#: Dictionary containing the attenuation settings (values) that should be applied to the outputs that are connected to a certain port-clock combination (keys).

input_att: dict[str, InputAttenuation] | None = None[source]#: Dictionary containing the attenuation settings (values) that should be applied to the inputs that are connected to a certain port-clock combination (keys).

mixer_corrections: dict[str, QbloxMixerCorrections] | None = None[source]#: Dictionary containing the qblox-specific mixer corrections (values) that should be used for signals on a certain port-clock combination (keys).

sequencer_options: dict[str, SequencerOptions] | None = None[source]#: Dictionary containing the options (values) that should be set on the sequencer that is used for a certain port-clock combination (keys).

distortion_corrections: dict[str, quantify_scheduler.backends.types.common.SoftwareDistortionCorrection | QbloxHardwareDistortionCorrection | list[QbloxHardwareDistortionCorrection]] | None = None[source]#: Dictionary containing the distortion corrections (values) that should be applied to waveforms on a certain port-clock combination (keys).

digitization_thresholds: dict[str, DigitizationThresholds] | None = None[source]#: Dictionary containing the digitization threshold settings for QTM modules. These are the settings that determine the voltage thresholds above which input signals are registered as high.

qblox#

Module Contents#

Classes#

Attributes#

This Page