qat.experimental.dialect.q1_sequence.ir.attrs module

Data tables and physical configuration attributes of the q1_sequence dialect.

The configuration attributes mirror the QCoDeS parameters exposed by the Qblox Instruments driver. See the Qblox Instruments API reference.

ModuleConfigAttr describes the analogue chain, keyed by physical lane: one OutputConfigAttr per used output and one InputConfigAttr per used input, alongside the module’s LocalOscillatorConfigAttr entries. SequencerConfigAttr describes the digital chain and carries the lossless connection that binds its sequencer to physical outputs, acquisition inputs and a local oscillator.

Every optional value is represented by NoneAttr so that an absent value stays distinguishable from a configured one.

class AcquireConfigAttr(auto_bin_incr_en=None, demod_en_acq=None)

Bases: AcquireConfigAttr

Acquisition path configuration of one sequencer.

Parameters:

auto_bin_incr_en¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether the bin index auto-increments across triggers.
demod_en_acq¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether demodulation is enabled on the acquisition path.

auto_bin_incr_en: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

demod_en_acq: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.acquire_config': The attribute name should be a static field in the attribute classes.

class AcquisitionAttr(*parameters)

Bases: AcquisitionAttr

An acquisition entry in a Qblox sequence’s acquisitions dictionary.

Parameters:

acquisition_name¶ – Acquisition name.
index¶ – Acquisition index. Range [0, 31].
num_bins¶ – Number of acquisition bins. Range [0, 7_000_000].

acquisition_name: StringAttr = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

index: AcqTableIndex = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.acquisition': The attribute name should be a static field in the attribute classes.

num_bins: BinCountImm = <xdsl.irdl.attributes._ParameterDef object>

class AcquisitionPathConnectionAttr(input_id, path)

Bases: AcquisitionPathConnectionAttr

Physical input connected to one Qblox acquisition path.

Parameters:

input_id¶ (IntAttr | int) – Physical input selected by the acquisition path.
path¶ (SignalPathAttr | SignalPath) – Acquisition path receiving the input.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

input_id: IntAttr = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.acquisition_path_connection': The attribute name should be a static field in the attribute classes.

path: SignalPathAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class AwgConfigAttr(gain_path0=None, gain_path1=None, offset_path0=None, offset_path1=None, mod_en=None)

Bases: AwgConfigAttr

Arbitrary waveform generator configuration of one sequencer.

Parameters:

gain_path0¶ (Union[FloatAttr[Float64Type], float, None]) – Gain applied to AWG path 0.
gain_path1¶ (Union[FloatAttr[Float64Type], float, None]) – Gain applied to AWG path 1.
offset_path0¶ (Union[FloatAttr[Float64Type], float, None]) – Offset applied to AWG path 0.
offset_path1¶ (Union[FloatAttr[Float64Type], float, None]) – Offset applied to AWG path 1.
mod_en¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether AWG modulation is enabled.

gain_path0: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

gain_path1: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

mod_en: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.awg_config': The attribute name should be a static field in the attribute classes.

offset_path0: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

offset_path1: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

class ConfigAttr(*parameters)

Bases: ParametrizedAttribute

Base for configuration attributes whose absent parameters are NoneAttr.

xDSL prints both NoneAttr and NoneType as none but always parses none back as a NoneType, so absent parameters are normalised on parse to keep the configuration round-trippable.

classmethod parse_parameters(parser)

Parse the attribute parameters.

Return type:: Sequence[Attribute]

class ConnectionAttr(direction, port_ids)

Bases: ConnectionAttr

One connection string accepted by the Qblox sequencer connection API.

A connection names one I/O port for real mode or an I and a Q port for complex mode, in every direction. Which combinations a module kind accepts is verified against the target description rather than here.

Parameters:

direction¶ (DirectionKindAttr | DirectionKind) – Whether the connection carries output, input, or bidirectional data.
port_ids¶ (ArrayAttr[IntAttr] | Iterable[IntAttr | int]) – Ordered I/O ports connected to the sequencer I/Q paths.

property connection: str: Return the connection string accepted by connect_sequencer.

direction: DirectionKindAttr = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

property input_ids: tuple[int, ...]

Return the physical inputs this connection acquires from.

An ioX_Y connection acquires on every listed lane; see connection_input_ids().

name: ClassVar[str] = 'q1_sequence.connection': The attribute name should be a static field in the attribute classes.

property output_ids: tuple[int, ...]

Return the physical outputs this connection drives.

An ioX_Y connection drives every listed lane; see connection_output_ids().

port_ids: ArrayAttr[IntAttr] = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class DirectionKindAttr(data)

Bases: EnumAttribute[DirectionKind], SpacedOpaqueSyntaxAttribute

Direction prefix accepted by the Qblox sequencer connection API.

data: DataElement

enum_type: alias of DirectionKind

name: ClassVar[str] = 'q1_sequence.direction_kind': The attribute name should be a static field in the attribute classes.

class InputConfigAttr(input_id, input_signal=None, scope_acquire=None)

Bases: InputConfigAttr

Analogue configuration of one physical module input.

Parameters:

input_id¶ (IntAttr | int) – Zero-based physical input. For example, 0 denotes in0.
input_signal¶ (Optional[InputSignalConfigAttr]) – Signal conditioning applied to the input.
scope_acquire¶ (Optional[ScopeAcquireConfigAttr]) – Scope acquisition configuration of the input.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

input_id: IntAttr = <xdsl.irdl.attributes._ParameterDef object>

input_signal: InputSignalConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.input_config': The attribute name should be a static field in the attribute classes.

scope_acquire: ScopeAcquireConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class InputSignalConfigAttr(attenuation=None, gain=None, offset=None, offset_path_0=None, offset_path_1=None)

Bases: InputSignalConfigAttr

Signal conditioning applied to one physical input.

Parameters:

attenuation¶ (Union[FloatAttr[Float64Type], float, None]) – Input attenuation in dB.
gain¶ (Union[FloatAttr[Float64Type], float, None]) – Input gain in dB.
offset¶ (Union[FloatAttr[Float64Type], float, None]) – Baseband input offset in V.
offset_path_0¶ (Union[FloatAttr[Float64Type], float, None]) – Offset in V applied to input path 0, the I component.
offset_path_1¶ (Union[FloatAttr[Float64Type], float, None]) – Offset in V applied to input path 1, the Q component.

attenuation: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

gain: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.input_signal_config': The attribute name should be a static field in the attribute classes.

offset: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

offset_path_0: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

offset_path_1: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

class LocalOscillatorConfigAttr(oscillator_id, frequency, enable=None)

Bases: LocalOscillatorConfigAttr

A local oscillator owned by one physical module.

Parameters:

oscillator_id¶ (StringAttr | str) – Identifier the module’s lanes reference the oscillator by.
frequency¶ (IntAttr | int) – Oscillator frequency in Hz.
enable¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether the oscillator is enabled.

enable: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

frequency: IntAttr = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.local_oscillator_config': The attribute name should be a static field in the attribute classes.

oscillator_id: StringAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class MarkerOverrideConfigAttr(marker_ovr_en=None, marker_ovr_value=None)

Bases: MarkerOverrideConfigAttr

Marker override configuration of one sequencer.

When enabled, the override takes priority over the set_mrk instruction. It drives the marker outputs and the RF switches, which must be enabled for RF operation.

Parameters:

marker_ovr_en¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether marker overriding is enabled.
marker_ovr_value¶ (Union[IntAttr, int, None]) – Marker override value, one bit per marker channel.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

marker_ovr_en: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

marker_ovr_value: OptionalInt = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.marker_override_config': The attribute name should be a static field in the attribute classes.

class MixerCorrectionConfigAttr(phase_offset=None, gain_ratio=None)

Bases: MixerCorrectionConfigAttr

Mixer imbalance correction applied to one sequencer’s AWG path.

Parameters:

phase_offset¶ (Union[FloatAttr[Float64Type], float, None]) – Mixer phase imbalance correction in degrees.
gain_ratio¶ (Union[FloatAttr[Float64Type], float, None]) – Mixer gain imbalance correction.

gain_ratio: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.mixer_correction_config': The attribute name should be a static field in the attribute classes.

phase_offset: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

class ModuleConfigAttr(slot_idx, instrument_id, kind, outputs=(), inputs=(), local_oscillators=())

Bases: ModuleConfigAttr

Authoritative analogue configuration of one physical Qblox module.

Parameters:

slot_idx¶ (SlotIndexAttr | int) – Cluster slot the module occupies.
instrument_id¶ (StringAttr | str) – Cluster instrument containing the module.
kind¶ (QbloxModuleKindAttr | QbloxModuleKind) – Module kind.
outputs¶ (ArrayAttr[OutputConfigAttr] | Iterable[OutputConfigAttr]) – Configuration of every physical output in use.
inputs¶ (ArrayAttr[InputConfigAttr] | Iterable[InputConfigAttr]) – Configuration of every physical input in use.
local_oscillators¶ (ArrayAttr[LocalOscillatorConfigAttr] | Iterable[LocalOscillatorConfigAttr]) – Local oscillators the module’s lanes reference.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

inputs: ArrayAttr[InputConfigAttr] = <xdsl.irdl.attributes._ParameterDef object>

instrument_id: StringAttr = <xdsl.irdl.attributes._ParameterDef object>

kind: QbloxModuleKindAttr = <xdsl.irdl.attributes._ParameterDef object>

local_oscillators: ArrayAttr[LocalOscillatorConfigAttr] = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.module_config': The attribute name should be a static field in the attribute classes.

outputs: ArrayAttr[OutputConfigAttr] = <xdsl.irdl.attributes._ParameterDef object>

slot_idx: SlotIndexAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class NcoConfigAttr(frequency=None, phase_offs=None, prop_delay_comp=None, prop_delay_comp_en=None)

Bases: NcoConfigAttr

Numerically controlled oscillator configuration of one sequencer.

Parameters:

frequency¶ (Union[FloatAttr[Float64Type], float, None]) – NCO frequency in Hz. The selected target validates its range.
phase_offs¶ (Union[FloatAttr[Float64Type], float, None]) – NCO phase offset in degrees.
prop_delay_comp¶ (Union[IntAttr, int, None]) – Propagation delay compensation in nanoseconds.
prop_delay_comp_en¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether propagation delay compensation is enabled.

frequency: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.nco_config': The attribute name should be a static field in the attribute classes.

phase_offs: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

prop_delay_comp: OptionalInt = <xdsl.irdl.attributes._ParameterDef object>

prop_delay_comp_en: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

class OutputConfigAttr(output_id, pulse_shaping=None, output_signal=None)

Bases: OutputConfigAttr

Analogue configuration of one physical module output.

Parameters:

output_id¶ (IntAttr | int) – Zero-based physical output. For example, 0 denotes out0.
pulse_shaping¶ (Optional[RealTimePredistortionConfigAttr]) – Pulse-shaping filters applied to the output.
output_signal¶ (Optional[OutputSignalConfigAttr]) – Signal conditioning applied to the output.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.output_config': The attribute name should be a static field in the attribute classes.

output_id: IntAttr = <xdsl.irdl.attributes._ParameterDef object>

output_signal: OutputSignalConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

pulse_shaping: RealTimePredistortionConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class OutputPathConnectionAttr(output_id, path=None)

Bases: OutputPathConnectionAttr

One physical output connected to a sequencer output path.

Parameters:

output_id¶ (IntAttr | int) – Physical output configured by the outN field.
path¶ (Union[SignalPathAttr, SignalPath, None]) – Qblox sequencer path carried by the connection.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.output_path_connection': The attribute name should be a static field in the attribute classes.

output_id: IntAttr = <xdsl.irdl.attributes._ParameterDef object>

path: SignalPathAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

class OutputSignalConfigAttr(attenuation=None, offset=None, offset_path_0=None, offset_path_1=None)

Bases: OutputSignalConfigAttr

Signal conditioning applied to one physical output.

Parameters:

attenuation¶ (Union[FloatAttr[Float64Type], float, None]) – Output attenuation in dB.
offset¶ (Union[FloatAttr[Float64Type], float, None]) – Baseband output offset in V.
offset_path_0¶ (Union[FloatAttr[Float64Type], float, None]) – Offset in mV applied to output path 0, the I component.
offset_path_1¶ (Union[FloatAttr[Float64Type], float, None]) – Offset in mV applied to output path 1, the Q component.

attenuation: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.output_signal_config': The attribute name should be a static field in the attribute classes.

offset: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

offset_path_0: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

offset_path_1: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

class QbloxModuleKindAttr(data)

Bases: EnumAttribute[QbloxModuleKind], SpacedOpaqueSyntaxAttribute

Attribute carrying a QbloxModuleKind.

enum_type: alias of QbloxModuleKind

name: ClassVar[str] = 'q1_sequence.module_kind': The attribute name should be a static field in the attribute classes.

class RealTimePredistortionConfigAttr(fir_out=None, exp_overshoot_0_out=None, exp_overshoot_1_out=None, exp_overshoot_2_out=None, exp_overshoot_3_out=None)

Bases: RealTimePredistortionConfigAttr

Real-time predistortion filters applied to one physical output.

Each filter accepts 'bypassed' to disable it, or 'delay_comp' to bypass it while delaying the output as if it were applied.

Parameters:

fir_out¶ (Union[str, StringAttr, None]) – Finite-impulse-response filter configuration.
exp_overshoot_0_out¶ (Union[str, StringAttr, None]) – Exponential-overshoot filter 0 configuration.
exp_overshoot_1_out¶ (Union[str, StringAttr, None]) – Exponential-overshoot filter 1 configuration.
exp_overshoot_2_out¶ (Union[str, StringAttr, None]) – Exponential-overshoot filter 2 configuration.
exp_overshoot_3_out¶ (Union[str, StringAttr, None]) – Exponential-overshoot filter 3 configuration.

exp_overshoot_0_out: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

exp_overshoot_1_out: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

exp_overshoot_2_out: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

exp_overshoot_3_out: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

fir_out: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.real_time_predistortion_config': The attribute name should be a static field in the attribute classes.

class ScopeAcquireConfigAttr(sequencer_select=None, enable_average_mode=None)

Bases: ScopeAcquireConfigAttr

Trace acquisition configuration of one physical input.

Parameters:

sequencer_select¶ (Union[int, SequencerIndexAttr, None]) – Index of the sequencer whose acquisitions the module writes into its scope memory when using sequencer trigger mode. Qblox exposes this as a sequencer id rather than a per-sequencer flag, so the identity of the selection is preserved here instead of being reduced to a boolean.
enable_average_mode¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether scope acquisition averaging is enabled.

enable_average_mode: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.scope_acquire_config': The attribute name should be a static field in the attribute classes.

sequencer_select: SequencerIndexAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

class SequencerConfigAttr(port_id=None, carrier_frequency=None, connections=None, output_path_connections=None, acquisition_path_connections=None, acquisition_enabled=None, disabled_outputs=None, disabled_acquisition_paths=None, acquisition_disabled=None, local_oscillator_id=None, enable_sync=None, nco=None, awg=None, mixer=None, marker_switch=None, unweighted_acquire=None, acquire=None, thresholded_acquire=None)

Bases: SequencerConfigAttr

Configuration and physical connections of one sequencer.

The connections bind the sequencer to the analogue lanes configured by the attached ModuleConfigAttr. Output connections retain fan-out and Qblox signal-path selection. Acquisition connections retain each acq_I/acq_Q input selection.

Parameters:

port_id¶ (Union[str, StringAttr, None]) – Canonical port the sequencer drives.
carrier_frequency¶ (Union[FloatAttr[Float64Type], float, None]) – Carrier frequency in Hz produced by the local oscillator and the NCO together.
connections¶ (Union[ArrayAttr[ConnectionAttr], Iterable[ConnectionAttr], None]) – Exact ordered entries in the supplied bulk_value.
output_path_connections¶ (Union[ArrayAttr[OutputPathConnectionAttr], Iterable[OutputPathConnectionAttr], None]) – Output selection for each output path.
acquisition_path_connections¶ (Union[ArrayAttr[AcquisitionPathConnectionAttr], Iterable[AcquisitionPathConnectionAttr], None]) – Input selection for each acquisition path.
acquisition_enabled¶ (Union[IntegerAttr[IntegerType], bool, None]) – Explicit acquisition enable state.
disabled_outputs¶ (Union[ArrayAttr[IntAttr], Iterable[IntAttr | int], None]) – Outputs explicitly configured as off.
disabled_acquisition_paths¶ (Union[ArrayAttr[SignalPathAttr], Iterable[SignalPathAttr | SignalPath], None]) – Acquisition paths configured as off.
acquisition_disabled¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether the combined acquisition path is configured as off.
local_oscillator_id¶ (Union[str, StringAttr, None]) – Local oscillator mixed with the NCO, absent for baseband.
enable_sync¶ (Union[IntegerAttr[IntegerType], bool, None]) – Whether the sequencer joins party-line synchronisation.
nco¶ (Optional[NcoConfigAttr]) – Numerically controlled oscillator configuration.
awg¶ (Optional[AwgConfigAttr]) – Arbitrary waveform generator configuration.
mixer¶ (Optional[MixerCorrectionConfigAttr]) – Mixer imbalance correction applied to the AWG path.
marker_switch¶ (Optional[MarkerOverrideConfigAttr]) – Marker override configuration.
unweighted_acquire¶ (Optional[UnweightedAcquireConfigAttr]) – Unweighted acquisition configuration.
acquire¶ (Optional[AcquireConfigAttr]) – Acquisition path configuration.
thresholded_acquire¶ (Optional[ThresholdedAcquireConfigAttr]) – Thresholded acquisition configuration.

acquire: AcquireConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

acquisition_disabled: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

acquisition_enabled: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

acquisition_path_connections: ArrayAttr[AcquisitionPathConnectionAttr] | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

awg: AwgConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

carrier_frequency: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

connections: ArrayAttr[ConnectionAttr] | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

disabled_acquisition_paths: ArrayAttr[SignalPathAttr] | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

disabled_outputs: ArrayAttr[IntAttr] | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

enable_sync: OptionalBool = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

property has_acquisition_config: bool: Whether any acquisition-only configuration is present.

property integration_length: IntegrationLengthImm | None: Configured unweighted integration length, if any.

local_oscillator_id: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

marker_switch: MarkerOverrideConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

merge_bound(bound)

Merge resolved values while retaining program-owned acquisition data.

Parameters:: bound¶ (SequencerConfigAttr) – Configuration resolved from the hardware description.
Return type:: SequencerConfigAttr
Returns:: The merged sequencer configuration.

mixer: MixerCorrectionConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.sequencer_config': The attribute name should be a static field in the attribute classes.

nco: NcoConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

output_path_connections: ArrayAttr[OutputPathConnectionAttr] | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

port_id: OptionalString = <xdsl.irdl.attributes._ParameterDef object>

thresholded_acquire: ThresholdedAcquireConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

unweighted_acquire: UnweightedAcquireConfigAttr | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

with_unweighted_acquire(unweighted_acquire)

Return a copy with a new unweighted acquisition configuration.

Parameters:: unweighted_acquire¶ (UnweightedAcquireConfigAttr) – The unweighted acquisition configuration to apply.
Return type:: SequencerConfigAttr
Returns:: The updated sequencer configuration.

class SignalPathAttr(data)

Bases: EnumAttribute[SignalPath], SpacedOpaqueSyntaxAttribute

Sequencer I/Q signal path selected by a connection.

data: DataElement

enum_type: alias of SignalPath

name: ClassVar[str] = 'q1_sequence.sequencer_path': The attribute name should be a static field in the attribute classes.

class ThresholdedAcquireConfigAttr(rotation=None, threshold=None)

Bases: ThresholdedAcquireConfigAttr

Thresholded acquisition configuration of one sequencer.

Parameters:

rotation¶ (Union[FloatAttr[Float64Type], float, None]) – Phase rotation applied to the integration result, in degrees.
threshold¶ (Union[FloatAttr[Float64Type], float, None]) – Threshold discretizing the phase-rotated integration result.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

name: ClassVar[str] = 'q1_sequence.thresholded_acq_config': The attribute name should be a static field in the attribute classes.

rotation: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

threshold: OptionalFloat = <xdsl.irdl.attributes._ParameterDef object>

class UnweightedAcquireConfigAttr(integration_length=None)

Bases: UnweightedAcquireConfigAttr

Unweighted acquisition configuration of one sequencer.

Parameters:: integration_length¶ (Union[IntegrationLengthImm, int, None]) – Integration length in samples, a multiple of 4.

classmethod get_irdl_definition(): Get the IRDL attribute definition.

integration_length: IntegrationLengthImm | NoneAttr = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.unweighted_acquisition_config': The attribute name should be a static field in the attribute classes.

class WaveformAttr(*parameters)

Bases: WaveformAttr

A waveform entry in a Qblox sequence’s waveforms dictionary.

Parameters:

waveform_name¶ – Waveform name.
index¶ – Index referenced by play operations. Range [0, 1023].
data¶ – Float32 samples, each sample in [-1.0, 1.0] represents DAC range.

data: DenseIntOrFPElementsAttr[Float32Type] = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

index: WaveformTableIndex = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.waveform': The attribute name should be a static field in the attribute classes.

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

waveform_name: StringAttr = <xdsl.irdl.attributes._ParameterDef object>

class WeightAttr(*parameters)

Bases: WeightAttr

A weight entry in a Qblox sequence’s weights dictionary.

Each coefficient multiplies one demodulated ADC sample before summation. A sequencer accepts at most 32 weight arrays and 16 384 samples.

Parameters:

weight_name¶ – Weight name.
index¶ – Index referenced by acquire_weighted. Range [0, 31].
data¶ – Float32 coefficients, each in [-1.0, 1.0].

data: DenseIntOrFPElementsAttr[Float32Type] = <xdsl.irdl.attributes._ParameterDef object>

classmethod get_irdl_definition(): Get the IRDL attribute definition.

index: WeightTableIndex = <xdsl.irdl.attributes._ParameterDef object>

name: ClassVar[str] = 'q1_sequence.weight': The attribute name should be a static field in the attribute classes.

verify()

Check that the attribute parameters satisfy the expected invariants. Raise a VerifyException otherwise.

Return type:: None

weight_name: StringAttr = <xdsl.irdl.attributes._ParameterDef object>

make_acquisition(name, index, num_bins)

Creates an AcquisitionAttr from Python primitives.

Parameters:

name¶ (str) – Acquisition name.
index¶ (int) – Table index in [0, 31].
num_bins¶ (int) – Number of acquisition bins in [0, 7_000_000].

Return type:

AcquisitionAttr

Returns:

An AcquisitionAttr.

make_dense_floats(values)

Return type:: DenseIntOrFPElementsAttr

make_module_config(slot_idx, instrument_id, kind, outputs=(), inputs=(), local_oscillators=())

Create a module configuration from Python primitives.

Parameters:

slot_idx¶ (int) – Cluster slot the module occupies.
instrument_id¶ (str) – Cluster instrument containing the module.
kind¶ (QbloxModuleKind) – Module kind.
outputs¶ (Iterable[OutputConfigAttr]) – Physical output configurations.
inputs¶ (Iterable[InputConfigAttr]) – Physical input configurations.
local_oscillators¶ (Iterable[LocalOscillatorConfigAttr]) – Local oscillators referenced by the module.

Return type:

ModuleConfigAttr

Returns:

A ModuleConfigAttr.

make_sequencer_config(integration_length=None, port_id=None, carrier_frequency=None, connections=None, output_path_connections=None, acquisition_path_connections=None, acquisition_enabled=None, disabled_outputs=None, disabled_acquisition_paths=None, acquisition_disabled=None, local_oscillator_id=None, enable_sync=None, nco=None, awg=None, mixer=None, marker_switch=None, acquire=None, thresholded_acquire=None)

Create a sequencer configuration from Python values and nested attributes.

Parameters:

integration_length¶ (Optional[int]) – Unweighted acquisition integration length in samples.
port_id¶ (Optional[str]) – Canonical port the sequencer drives.
carrier_frequency¶ (Optional[float]) – Carrier frequency in Hz.
connections¶ (Optional[Iterable[ConnectionAttr]]) – Connections accepted by connect_sequencer.
output_path_connections¶ (Optional[Iterable[OutputPathConnectionAttr]]) – Physical outputs selected for output signal paths.
acquisition_path_connections¶ (Optional[Iterable[AcquisitionPathConnectionAttr]]) – Physical inputs selected for acquisition paths.
acquisition_enabled¶ (Optional[bool]) – Explicit acquisition enable state.
disabled_outputs¶ (Optional[Iterable[int]]) – Physical outputs explicitly configured as off.
disabled_acquisition_paths¶ (Optional[Iterable[SignalPath]]) – Acquisition paths explicitly configured as off.
acquisition_disabled¶ (Optional[bool]) – Whether the combined acquisition path is off.
local_oscillator_id¶ (Optional[str]) – Local oscillator mixed with the sequencer NCO.
enable_sync¶ (Optional[bool]) – Whether the sequencer joins party-line synchronisation.
nco¶ (Optional[NcoConfigAttr]) – Numerically controlled oscillator configuration.
awg¶ (Optional[AwgConfigAttr]) – Arbitrary waveform generator configuration.
mixer¶ (Optional[MixerCorrectionConfigAttr]) – Mixer correction configuration.
marker_switch¶ (Optional[MarkerOverrideConfigAttr]) – Marker override configuration.
acquire¶ (Optional[AcquireConfigAttr]) – Acquisition path configuration.
thresholded_acquire¶ (Optional[ThresholdedAcquireConfigAttr]) – Thresholded acquisition configuration.

Return type:

SequencerConfigAttr

Returns:

A SequencerConfigAttr.

make_waveform(name, index, samples)

Creates a WaveformAttr from Python primitives.

Parameters:

name¶ (str) – Waveform name.
index¶ (int) – Table index in [0, 1023].
samples¶ (list[float]) – Float samples in [-1.0, 1.0].

Return type:

WaveformAttr

Returns:

A verified WaveformAttr.

make_weight(name, index, coeffs)

Creates a WeightAttr from Python primitives.

Parameters:

name¶ (str) – Weight name.
index¶ (int) – Table index in [0, 31].
coeffs¶ (list[float]) – Float coefficients in [-1.0, 1.0].

Return type:

WeightAttr

Returns:

A verified WeightAttr.