qat.experimental.system_data.hardware.qblox.target module

Dependency-neutral target description for Qblox hardware.

The records in this module model the Q1 sequencer and module architecture documented by Qblox. They describe a compilation target, not the installed hardware or its calibrated configuration.

See:

class ModuleSpec(kind, sequencers, output_count, input_count, output_channel_map, input_channel_map=<factory>, marker_count=0, acquisition_memory_bins=None, supports_mixer_correction=True, is_rf=False)

Bases: object

Physical sequencer bank and channel map of one Qblox module kind.

acquisition_memory_bins: int | None

input_channel_map: frozendict[int, tuple[int, ...]]

input_count: int

is_rf: bool

Whether the module carries an RF front end.

An RF module exposes one logical I/O port per RF chain and derives its I and Q lanes internally, so a connection may name only one port index. Mirrors qblox_instruments.types.TypeHandle.is_rf_type, which covers QCM-RF, QRM-RF, and QRC. The driver’s Module property delegates to that classification.

kind: QbloxModuleKind

marker_count: int

output_channel_map: frozendict[int, tuple[int, ...]]

output_count: int

property sequencer_count: int: Return the number of physical Q1 sequencers.

sequencer_indices(type_=None)

Return all sequencer indices, optionally filtered by Q1 sequencer type.

Return type:: tuple[int, ...]

sequencers: tuple[Q1SequencerType, ...]

supports_mixer_correction: bool

class Q1AsmSpec(min_gain=-32768, max_gain=32767, min_offset=-32768, max_offset=32767, max_wait_time_ns=65532, register_size=4294967295, loop_unroll_threshold=4)

Bases: object

Immediate and register limits of the Q1ASM instruction set.

loop_unroll_threshold: int

max_gain: int

max_offset: int

max_wait_time_ns: int

min_gain: int

min_offset: int

register_size: int

class Q1SequencerFeature(value)

Bases: str, Enum

Feature predicates exposed by a Q1 sequencer type.

acquisition = 'acquisition'

awg = 'awg'

class Q1SequencerSpec(type, instruction_capacity, clock_period_ns=4, sample_rate_hz=1000000000, nco_min_frequency_hz=-500000000.0, nco_max_frequency_hz=500000000.0, nco_phase_steps=1000000000, nco_phase_steps_per_degree=2777777.777777778, nco_frequency_steps_per_hz=4, nco_frequency_limit_steps=2000000000, register_count=64, waveform_sample_capacity=16384, readout=None)

Bases: object

Static limits and features of one Q1 sequencer type.

clock_period_ns: int

property features: frozenset[Q1SequencerFeature]: Return the feature predicates implied by this sequencer type.

instruction_capacity: int

nco_frequency_limit_steps: int

nco_frequency_steps_per_hz: int

nco_max_frequency_hz: float

nco_min_frequency_hz: float

nco_phase_steps: int

nco_phase_steps_per_degree: float

readout: ReadoutSpec | None

register_count: int

sample_rate_hz: int

supports(feature)

Return whether this sequencer type provides feature.

Return type:: bool

type: Q1SequencerType

waveform_sample_capacity: int

class Q1SequencerType(value)

Bases: str, Enum

Q1 sequencer types defined by Qblox.

control = 'control'

readout = 'readout'

class QbloxTargetDescription(q1asm, sequencer_specs, module_specs, min_module_slot=1, max_module_slot=20)

Bases: object

Immutable Qblox target specification and typed query boundary.

input_sequencers(kind, input_)

Return sequencers routable from a physical input channel.

Return type:: tuple[int, ...]

max_module_slot: int

min_module_slot: int

module_spec(kind)

Return the target specification for kind.

Return type:: ModuleSpec

module_specs: frozendict[QbloxModuleKind, ModuleSpec]

output_sequencers(kind, output)

Return sequencers routable to a physical output channel.

Return type:: tuple[int, ...]

q1asm: Q1AsmSpec

sequencer(kind, index)

Return the module-bound target view of a physical sequencer.

Return type:: SequencerTarget

sequencer_spec(type_)

Return the shared target specification for a Q1 sequencer type.

Return type:: Q1SequencerSpec

sequencer_specs: frozendict[Q1SequencerType, Q1SequencerSpec]

supports(kind, index, feature)

Return whether a physical sequencer provides feature.

Return type:: bool

validate_module_location(location)

Validate that a module location is representable by this target.

Parameters:: location¶ (QbloxModuleLocation) – Physical instrument and slot occupied by a module.
Raises:: ValueError – If the slot falls outside the target’s Cluster chassis.
Return type:: None

class ReadoutSpec(min_integration_length_samples=4, max_integration_length_samples=16777212, min_acquisition_threshold=-16777212, max_acquisition_threshold=16777212, weight_sample_capacity=16384)

Bases: object

Limits of the acquisition path added by a readout sequencer.

max_acquisition_threshold: int

max_integration_length_samples: int

min_acquisition_threshold: int

min_integration_length_samples: int

weight_sample_capacity: int

class SequencerTarget(index, sequencer_spec, output_channels, input_channels)

Bases: object

Module-bound view of one physical Q1 sequencer.

index: int

input_channels: tuple[int, ...]

output_channels: tuple[int, ...]

sequencer_spec: Q1SequencerSpec