qblox_backend#

Compiler backend for Qblox hardware.

Module Contents#

Classes#

`OperationTimingInfo`	Timing information for an Operation.
`ConditionalAddress`	Container for conditional address data.
`QbloxHardwareCompilationConfig`	Datastructure containing the information needed to compile to the Qblox backend.
`_LocalOscillatorCompilationConfig`	Configuration values for a `quantify_scheduler.backends.qblox.instrument_compilers.LocalOscillatorCompiler`.
`_ClusterCompilationConfig`	Configuration values for a `ClusterCompiler`.
`_ClusterModuleCompilationConfig`	Configuration values for a `ClusterModuleCompiler`.
`_SequencerCompilationConfig`	Configuration values for a `SequencerCompiler`.

Functions#

`_replace_long_square_pulses_recursively`(...)	Generate a dict referring to long square pulses to replace in the schedule.
`_replace_long_square_pulses`(...)	Replace any square pulses indicated by pulse_idx_map by a `long_square_pulse`.
`_all_conditional_acqs_and_control_flows_and_latch_reset`(→ None)
`_set_conditional_address_map`(→ None)
`_insert_latch_reset`(→ None)
`compile_conditional_playback`(...)	Compiles conditional playback.
`compile_long_square_pulses_to_awg_offsets`(...)	Replace square pulses in the schedule with long square pulses.
`hardware_compile`(...)	Generate qblox hardware instructions for executing the schedule.
`find_qblox_instruments`(→ Dict[str, Any])	Find all inner dictionaries representing a qblox instrument of the given type.
`_all_abs_times_ops_with_voltage_offsets_pulses`(→ None)
`_add_clock_freqs_to_set_clock_frequency`(→ None)
`validate_non_overlapping_stitched_pulse`(→ None)	Raise an error when pulses overlap, if at least one contains a voltage offset.
`_exists_pulse_starting_before_current_end`(...)
`_raise_if_pulses_overlap_on_same_port_clock`(→ None)	Raise an error if any pulse operations overlap on the same port-clock.
`_get_pulse_start_ends`(→ dict[str, tuple[float, float]])
`_operation_end`(→ float)
`_check_nco_operations_on_nco_time_grid`(...)	Check whether NCO operations are on the 4ns time grid _and_ sub-schedules (including
`_check_nco_operations_on_nco_time_grid_recursively`(→ bool)	Check whether NCO operations, or Schedules/ControlFlowOperations containing NCO
`_check_nco_grid_timing`(→ None)	Assumes operation is a, or contains NCO operation(s), and checks the alignment
`_is_nco_operation`(→ bool)

_replace_long_square_pulses_recursively(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule) → quantify_scheduler.operations.operation.Operation | None[source]#

Generate a dict referring to long square pulses to replace in the schedule.

This function generates a mapping (dict) from the keys in the operations() dict to a list of indices, which refer to entries in the “pulse_info” list that describe a square pulse.

Parameters:: operation – An operation, possibly containing long square pulses.

_replace_long_square_pulses(operation: quantify_scheduler.operations.operation.Operation, square_pulse_idx_to_replace: list[int]) → quantify_scheduler.operations.operation.Operation | None[source]#

Replace any square pulses indicated by pulse_idx_map by a long_square_pulse.

Parameters:

operation – Operation to be replaced.
square_pulse_idx_to_replace – A list of indices in the pulse info to be replaced.

Returns:

operation – The operation to be replaced. If returns None, the operation does not need to be replaced in the schedule or control flow.
square_pulse_idx_to_replace – The pulse indices that need to be replaced in the operation.

_all_conditional_acqs_and_control_flows_and_latch_reset(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule, time_offset: float, accumulator: List[Tuple[float, quantify_scheduler.operations.operation.Operation]]) → None[source]#

class OperationTimingInfo[source]#

Timing information for an Operation.

start: float[source]#: start time of the operation.

end: float[source]#: end time of the operation.

classmethod from_operation_and_schedulable(operation: quantify_scheduler.operations.operation.Operation, schedulable: quantify_scheduler.schedules.schedule.Schedulable) → OperationTimingInfo[source]#: Create an OperationTimingInfo from an operation and a schedulable.

overlaps_with(operation_timing_info: OperationTimingInfo) → bool[source]#: Check if this operation timing info overlaps with another.

class ConditionalAddress[source]#

Container for conditional address data.

portclocks: set[tuple[str, str]][source]#

address: int[source]#

_set_conditional_address_map(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule, conditional_address_map: collections.defaultdict[str, ConditionalAddress]) → None[source]#

_insert_latch_reset(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule, abs_time_relative_to_schedule: float, schedule: quantify_scheduler.schedules.schedule.Schedule, conditional_address_map: collections.defaultdict[str, ConditionalAddress]) → None[source]#

compile_conditional_playback(schedule: quantify_scheduler.schedules.schedule.Schedule, **_: Any) → quantify_scheduler.schedules.schedule.Schedule[source]#

Compiles conditional playback.

This compiler pass will determine the mapping between trigger labels and trigger addresses that the hardware will use. The feedback trigger address is stored under the key feedback_trigger_address in pulse_info and in acquisition_info of the corresponding operation.

A valid conditional playback consists of two parts: (1) a conditional acquisition or measure, and (2) a conditional control flow. The first should always be followed by the second, else an error is raised. A conditional acquisition sends a trigger after the acquisition ends and if the acquisition crosses a certain threshold. Each sequencer that is subscribed to this trigger will increase their latch counters by one. To ensure the latch counters contain either 0 or 1 trigger counts, a LatchReset operation is inserted right after the start of a conditional acquisition, on all sequencers. If this is not possible (e.g. due to concurring operations), a RuntimeError is raised.

Parameters:

schedule – The schedule to compile.

Returns:

The returned schedule is a reference to the original schedule, but updated.

Return type:

Schedule

Raises:

RuntimeError –

If a conditional acquisitions/measures is not followed by a conditional control flow.
If a conditional control flow is not preceded by a conditional acquisition/measure.
If the compilation pass is unable to insert LatchReset on all sequencers.

compile_long_square_pulses_to_awg_offsets(schedule: quantify_scheduler.schedules.schedule.Schedule, **_: Any) → quantify_scheduler.schedules.schedule.Schedule[source]#

Replace square pulses in the schedule with long square pulses.

Introspects operations in the schedule to find square pulses with a duration longer than PULSE_STITCHING_DURATION. Any of these square pulses are converted to long_square_pulse(), which consist of AWG voltage offsets.

If any operations are to be replaced, a deepcopy will be made of the schedule, which is returned by this function. Otherwise the original unmodified schedule will be returned.

Parameters:: schedule (Schedule) – A Schedule, possibly containing long square pulses.
Returns:: schedule – The schedule with square pulses longer than PULSE_STITCHING_DURATION replaced by long_square_pulse(). If no replacements were done, this is the original unmodified schedule.
Return type:: Schedule

hardware_compile(schedule: quantify_scheduler.schedules.schedule.Schedule, config: quantify_scheduler.backends.graph_compilation.CompilationConfig) → quantify_scheduler.schedules.schedule.CompiledSchedule[source]#

Generate qblox hardware instructions for executing the schedule.

The principle behind the overall compilation is as follows:

For every instrument in the hardware configuration, we instantiate a compiler object. Then we assign all the pulses/acquisitions that need to be played by that instrument to the compiler, which then compiles for each instrument individually.

This function then returns all the compiled programs bundled together in a dictionary with the QCoDeS name of the instrument as key.

Parameters:

schedule – The schedule to compile. It is assumed the pulse and acquisition info is already added to the operation. Otherwise an exception is raised.
config – Compilation config for QuantifyCompiler.

Returns:

The compiled schedule.

find_qblox_instruments(hardware_config: Dict[str, Any], instrument_type: str) → Dict[str, Any][source]#: Find all inner dictionaries representing a qblox instrument of the given type.

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

Bases: quantify_scheduler.backends.types.common.HardwareCompilationConfig

Datastructure containing the information needed to compile to the Qblox backend.

This information is structured in the same way as in the generic HardwareCompilationConfig, but contains fields for hardware-specific settings.

config_type: Type[QbloxHardwareCompilationConfig][source]#: A reference to the HardwareCompilationConfig DataStructure for the Qblox backend.

hardware_description: Dict[str, quantify_scheduler.backends.types.qblox.QbloxHardwareDescription | quantify_scheduler.backends.types.common.HardwareDescription][source]#: Description of the instruments in the physical setup.

hardware_options: quantify_scheduler.backends.types.qblox.QbloxHardwareOptions[source]#: Options that are used in compiling the instructions for the hardware, such as LatencyCorrection or SequencerOptions.

allow_off_grid_nco_ops: bool | None = None[source]#: Flag to allow NCO operations to play at times that are not aligned with the NCO grid.

compilation_passes: List[quantify_scheduler.backends.graph_compilation.SimpleNodeConfig][source]#: The list of compilation nodes that should be called in succession to compile a schedule to instructions for the Qblox hardware.

_validate_connectivity_channel_names() → QbloxHardwareCompilationConfig[source]#

_warn_mix_lo_false() → QbloxHardwareCompilationConfig[source]#

classmethod from_old_style_hardware_config(data: Any) → Any[source]#: Convert old style hardware config dict to new style before validation.

_validate_connectivity_graph_structure() → QbloxHardwareCompilationConfig[source]#: Validate connectivity graph structure.

_extract_instrument_compilation_configs(portclocks_used: set[tuple]) → Dict[str, Any][source]#: Extract an instrument compiler config for each instrument mentioned in hardware_description. Each instrument config has a similar structure than QbloxHardwareCompilationConfig, but contains only the settings related to their related instrument. Each config must contain at least one portclock referenced in portclocks_used, otherwise the config is deleted.

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

Bases: quantify_scheduler.structure.model.DataStructure

Configuration values for a quantify_scheduler.backends.qblox.instrument_compilers.LocalOscillatorCompiler.

hardware_description: quantify_scheduler.backends.types.common.LocalOscillatorDescription[source]#: Description of the physical setup of this local oscillator.

frequency: float | None = None[source]#: The frequency of this local oscillator.

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

Bases: quantify_scheduler.structure.model.DataStructure

Configuration values for a ClusterCompiler.

hardware_description: quantify_scheduler.backends.types.qblox.ClusterDescription[source]#: Description of the physical setup of this cluster.

hardware_options: quantify_scheduler.backends.types.qblox.QbloxHardwareOptions[source]#: Options that are used in compiling the instructions for the hardware.

portclock_to_path: Dict[str, str][source]#: Mapping between portclocks and their associated channel name paths (e.g. cluster0.module1.complex_output_0).

lo_to_path: Dict[str, str][source]#: Mapping between lo names and their associated channel name paths (e.g. cluster0.module1.complex_output_0).

allow_off_grid_nco_ops: bool | None = None[source]#: Flag to allow NCO operations to play at times that are not aligned with the NCO grid.

_extract_module_compilation_configs() → Dict[int, _ClusterModuleCompilationConfig][source]#

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

Bases: quantify_scheduler.structure.model.DataStructure

Configuration values for a ClusterModuleCompiler.

hardware_description: quantify_scheduler.backends.types.qblox.ClusterModuleDescription[source]#: Description of the physical setup of this module.

hardware_options: quantify_scheduler.backends.types.qblox.QbloxHardwareOptions[source]#: Options that are used in compiling the instructions for the hardware.

portclock_to_path: Dict[str, str][source]#: Mapping between portclocks and their associated channel name paths (e.g. cluster0.module1.complex_output_0).

lo_to_path: Dict[str, str][source]#: Mapping between lo names and their associated channel name paths (e.g. cluster0.module1.complex_output_0).

allow_off_grid_nco_ops: bool | None = None[source]#: Flag to allow NCO operations to play at times that are not aligned with the NCO grid.

_extract_sequencer_compilation_configs() → Dict[int, _SequencerCompilationConfig][source]#

_validate_hardware_distortion_corrections_mode() → _ClusterModuleCompilationConfig[source]#

_validate_input_gain_mode() → _ClusterModuleCompilationConfig[source]#

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

Bases: quantify_scheduler.structure.model.DataStructure

Configuration values for a SequencerCompiler.

hardware_description: quantify_scheduler.backends.types.qblox.ComplexChannelDescription | quantify_scheduler.backends.types.qblox.RealChannelDescription | quantify_scheduler.backends.types.qblox.DigitalChannelDescription[source]#: Information needed to specify a complex/real/digital input/output.

sequencer_options: quantify_scheduler.backends.types.qblox.SequencerOptions[source]#: Configuration options for this sequencer.

portclock: str[source]#: Portclock associated to this sequencer.

channel_name: str[source]#: Channel name associated to this sequencer.

latency_correction: quantify_scheduler.backends.types.common.LatencyCorrection[source]#: Latency correction that should be applied to operations on this sequencer.

distortion_correction: quantify_scheduler.backends.types.common.SoftwareDistortionCorrection | None[source]#: Distortion corrections that should be applied to waveforms on this sequencer.

lo_name: str | None[source]#: Local oscilator associated to this sequencer.

modulation_frequencies: quantify_scheduler.backends.types.common.ModulationFrequencies[source]#: Modulation frequencies associated to this sequencer.

mixer_corrections: quantify_scheduler.backends.types.qblox.QbloxMixerCorrections | None[source]#: Mixer correction settings.

allow_off_grid_nco_ops: bool | None = None[source]#: Flag to allow NCO operations to play at times that are not aligned with the NCO grid.

_all_abs_times_ops_with_voltage_offsets_pulses(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule, time_offset: float, accumulator: List[Tuple[float, quantify_scheduler.operations.operation.Operation]]) → None[source]#

_add_clock_freqs_to_set_clock_frequency(schedule: quantify_scheduler.schedules.schedule.Schedule, operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule | None = None) → None[source]#

validate_non_overlapping_stitched_pulse(schedule: quantify_scheduler.schedules.schedule.Schedule, **_: Any) → None[source]#

Raise an error when pulses overlap, if at least one contains a voltage offset.

Since voltage offsets are sometimes used to construct pulses (see e.g. long_square_pulse()), overlapping these with regular pulses in time on the same port-clock can lead to undefined behaviour.

Note that for each schedulable, all pulse info entries with the same port and clock count as one pulse for that port and clock. This is because schedulables, starting before another schedulable has finished, could affect the waveforms or offsets in the remaining time of that other schedulable.

Parameters:: schedule (Schedule) – A Schedule, possibly containing long square pulses.
Returns:: schedule – A Schedule, possibly containing long square pulses.
Return type:: Schedule
Raises:: RuntimeError – If the schedule contains overlapping pulses (containing voltage offsets) on the same port and clock.

_exists_pulse_starting_before_current_end(abs_times_and_operations: list[Tuple[float, quantify_scheduler.operations.operation.Operation]], current_idx: int) → Tuple[float, quantify_scheduler.operations.operation.Operation] | Literal[False][source]#

_raise_if_pulses_overlap_on_same_port_clock(abs_time_a: float, op_a: quantify_scheduler.operations.operation.Operation, abs_time_b: float, op_b: quantify_scheduler.operations.operation.Operation) → None[source]#

Raise an error if any pulse operations overlap on the same port-clock.

A pulse here means a waveform or a voltage offset.

_get_pulse_start_ends(abs_time: float, operation: quantify_scheduler.operations.operation.Operation) → dict[str, tuple[float, float]][source]#

_operation_end(abs_time_and_operation: Tuple[float, quantify_scheduler.operations.operation.Operation]) → float[source]#

_check_nco_operations_on_nco_time_grid(schedule: quantify_scheduler.schedules.schedule.Schedule, **_: Any) → quantify_scheduler.schedules.schedule.Schedule[source]#: Check whether NCO operations are on the 4ns time grid _and_ sub-schedules (including control-flow) containing NCO operations start/end on the 4 ns time grid.

_check_nco_operations_on_nco_time_grid_recursively(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule, schedulable: quantify_scheduler.schedules.schedule.Schedulable | None = None, parent_control_flow_op: quantify_scheduler.operations.control_flow_library.ControlFlowOperation | None = None) → bool[source]#

Check whether NCO operations, or Schedules/ControlFlowOperations containing NCO operations, align with the NCO grid.

Parameters:

operation (Operation | Schedule) – The Operation or Schedule to be checked.
schedulable (Schedulable | None, optional) – The Schedulable the operation is a part of. None if it is the top-level Schedule.
parent_control_flow_op (ControlFlowOperation | None, optional) – The ControlFlowOperation that the operation is part of, if any. This is used to create the correct error message.

Returns:

True if the operation is a, or contains NCO operation(s), else False.

Return type:

bool

_check_nco_grid_timing(operation: quantify_scheduler.operations.operation.Operation | quantify_scheduler.schedules.schedule.Schedule, schedulable: quantify_scheduler.schedules.schedule.Schedulable | None, parent_control_flow_op: quantify_scheduler.operations.control_flow_library.ControlFlowOperation | None = None) → None[source]#: Assumes operation is a, or contains NCO operation(s), and checks the alignment of the operation with the NCO grid.

_is_nco_operation(operation: quantify_scheduler.operations.operation.Operation) → bool[source]#