zhinst_backend

Backend for Zurich Instruments.

Module Contents

Classes

ZIAcquisitionConfig	Zurich Instruments acquisition configuration.
ZIDeviceConfig	Zurich Instruments device configuration.
ZIHardwareCompilationConfig	Datastructure containing the information needed to compile to the Zurich Instruments backend.

Functions

ensure_no_operations_overlap(→ None)	Iterates over all hardware_channels in a schedule to determine if any of the pulses
_extract_port_clock_channelmapping(→ dict[str, str])	Take the hardware configuration file and return a dictionary that maps port-clock
_determine_clock_sample_start(→ tuple[int, float])	depending on the output channel, select the right clock cycle time and sample rate
_determine_clock_start(→ float)
_determine_sample_start(→ float)
_add_channel_information(→ pandas.DataFrame | None)
_apply_latency_corrections(→ pandas.DataFrame)	Changes the "abs_time" of a timing table depending on the specified latency
_determine_measurement_fixpoint_correction(...)	Calculates by how much time to shift all operations to ensure a measurement starts
_apply_measurement_fixpoint_correction(→ pandas.DataFrame)	Updates the abs_time of all operations based on the measurement fixpoint correction.
_add_clock_sample_starts(→ pandas.DataFrame)	Adds the sequence clock cycle start and sampling start of each operation for each
_add_waveform_ids(→ pandas.DataFrame)	Multiple (numerical) waveforms might be needed to represent a single operation.
_parse_local_oscillators(→ dict[str, ...)	Returns the LocalOscillator domain models parsed from the data dictionary.
_parse_devices(...)
_validate_schedule(→ None)	Validates the CompiledSchedule required values for creating the backend.
apply_waveform_corrections(→ tuple[int, int, ...)	Add waveform corrections such as modulation, changing the
_get_instruction_list(...)	Iterates over a timing table for a specific output for which clock_cycle_start and
_generate_legacy_hardware_config(→ dict)	Extract the old-style Zhinst hardware config from the CompilationConfig.
_generate_new_style_hardware_compilation_config(→ dict)	Generate a new-style ZIHardwareCompilationConfig from an old-style hardware config.
_get_operations_by_repr(→ dict[str, ...)
compile_backend(...)	Compiles zhinst hardware instructions for a schedule.
_add_lo_config(→ None)	Adds configuration for a local oscillator required for a specific output channel to
_add_wave_nodes(...)
_compile_for_hdawg(...)	param device:
_assemble_hdawg_sequence(→ tuple[str, str])
_compile_for_uhfqa(...)	Initialize programming the UHFQA ZI Instrument.
_assemble_uhfqa_sequence(→ str)
construct_waveform_table(→ dict[str, numpy.ndarray])	Iterates over all unique waveforms in a timing_table dataframe to calculate the

Attributes

logger
handler
formatter
SUPPORTED_DEVICE_TYPES
SUPPORTED_ACQ_PROTOCOLS
WAVEFORM_GRANULARITY
HDAWG_DEVICE_TYPE_CHANNEL_GROUPS
DEVICE_SAMPLING_RATES
CLOCK_SAMPLE_FACTOR
NUM_UHFQA_READOUT_CHANNELS
MAX_QAS_INTEGRATION_LENGTH

logger

handler

formatter

SUPPORTED_DEVICE_TYPES: list[str] = ['HDAWG', 'UHFQA']

SUPPORTED_ACQ_PROTOCOLS

WAVEFORM_GRANULARITY: dict[quantify_scheduler.backends.types.zhinst.DeviceType, int]

HDAWG_DEVICE_TYPE_CHANNEL_GROUPS: dict[str, dict[int, int]]

DEVICE_SAMPLING_RATES: dict[quantify_scheduler.backends.types.zhinst.DeviceType, dict[int, int]]

CLOCK_SAMPLE_FACTOR = 8

NUM_UHFQA_READOUT_CHANNELS = 10

MAX_QAS_INTEGRATION_LENGTH = 4096

ensure_no_operations_overlap(timing_table: pandas.DataFrame) → None

Iterates over all hardware_channels in a schedule to determine if any of the pulses have overlap.

Parameters:

timing_table – a timing table containing the absolute time and duration as well as the hardware channels on which these pulses are to be applied.

Raises:

ValueError – If there is overlap between operations.

_extract_port_clock_channelmapping(hardware_cfg: dict[str, Any]) → dict[str, str]

Take the hardware configuration file and return a dictionary that maps port-clock pairs to instrument output channels.

e.g.: {‘q0:mw-q0.01’: ‘ic_hdawg0.channel_0’,

‘q0:res-q0.ro’: ‘ic_uhfqa0.channel_0’}

_determine_clock_sample_start(hardware_channel: str, abs_time: float, operation_name: str = '') → tuple[int, float]

depending on the output channel, select the right clock cycle time and sample rate from the channel descriptor for ZI channels. the sample is returned as a float to preserve information of incorrect rounding to full samples if present.

_determine_clock_start(hardware_channel: str, abs_time: float, operation_name: str) → float

_determine_sample_start(hardware_channel: str, abs_time: float, operation_name: str) → float

_add_channel_information(timing_table: pandas.DataFrame, port_clock_channelmapping: dict) → pandas.DataFrame | None

_apply_latency_corrections(timing_table: pandas.DataFrame, latency_dict: dict) → pandas.DataFrame

Changes the “abs_time” of a timing table depending on the specified latency corrections for each port-clock combination as specified in the latency dict. The corrections are added to the abs_time elements fulfilling the specific port-clock combination.

_determine_measurement_fixpoint_correction(measurement_start_sample: int, common_frequency: float = 600000000.0) → tuple[float, int]

Calculates by how much time to shift all operations to ensure a measurement starts at sample 0.

Parameters:

• measurement_start_sample – the sample at which the measurement starts

• common_frequency – The shift needs to be such that it occurs at a multiple of the common frequency. A larger common frequency results in a smaller time correction. This largest common frequency is the common frequency of the HDAWG and UHFQA and is 600 MHz.

Returns:

The time correction to be applied in seconds. The correction in the number of samples.

Return type:

Tuple[float, int]

_apply_measurement_fixpoint_correction(timing_table: pandas.DataFrame, common_frequency: float = 600000000.0) → pandas.DataFrame

Updates the abs_time of all operations based on the measurement fixpoint correction.

The abs_time is applied to all operations between two acquisitions. After that the samples and clocks are re-calculated to reflect this change in time.

Parameters:

• timing_table – A timing table that has the samples already determined.

• common_frequency – The shift needs to be such that it occurs at a multiple of the common frequency. A larger common frequency results in a smaller time correction. This largest common frequency is the common frequency of the HDAWG and UHFQA and is 600 MHz.

_add_clock_sample_starts(timing_table: pandas.DataFrame) → pandas.DataFrame

Adds the sequence clock cycle start and sampling start of each operation for each channel.

_add_waveform_ids(timing_table: pandas.DataFrame) → pandas.DataFrame

Multiple (numerical) waveforms might be needed to represent a single operation.

This waveform_id consists of a concatenation of the waveform_op_id with the sample_start and modulation phase added to it.

_parse_local_oscillators(data: dict[str, Any]) → dict[str, quantify_scheduler.backends.types.zhinst.LocalOscillator]

Returns the LocalOscillator domain models parsed from the data dictionary.

Parameters:

data – The hardware map “local_oscillators” entry.

Returns:

A dictionary of unique LocalOscillator instances.

Raises:

RuntimeError – If duplicate LocalOscillators have been found.

_parse_devices(data: dict[str, Any]) → list[quantify_scheduler.backends.types.zhinst.Device]

_validate_schedule(schedule: quantify_scheduler.schedules.schedule.Schedule) → None

Validates the CompiledSchedule required values for creating the backend.

Parameters:

schedule –

Raises:

ValueError – The validation error.

apply_waveform_corrections(output: quantify_scheduler.backends.types.zhinst.Output, waveform: numpy.ndarray, start_and_duration_in_seconds: tuple[float, float], instrument_info: quantify_scheduler.backends.types.zhinst.InstrumentInfo, is_pulse: bool) → tuple[int, int, numpy.ndarray]

Add waveform corrections such as modulation, changing the waveform starting time by shifting it and resizing it based on the Instruments granularity.

Parameters:

• output –

• waveform –

• start_and_duration_in_seconds –

• instrument_info –

• is_pulse – True if it is a pulse to be up converted, False if it is an integration weight.

_get_instruction_list(output_timing_table: pandas.DataFrame) → list[quantify_scheduler.backends.types.zhinst.Instruction]

Iterates over a timing table for a specific output for which clock_cycle_start and waveform_id have been determined to return a list of all instructions to be played on a Zurich Instruments device.

class ZIAcquisitionConfig

Zurich Instruments acquisition configuration.

Parameters:

bin_mode –

n_acquisitions: int

The number of distinct acquisitions in this experiment.

resolvers: dict[int, Callable]

Resolvers used to retrieve the results from the right UHFQA nodes.

See also resolvers

bin_mode: quantify_scheduler.enums.BinMode

The bin mode of the acquisitions.

acq_protocols: dict[int, SUPPORTED_ACQ_PROTOCOLS]

Acquisition protocols for each acquisition channel.

class ZIDeviceConfig

Zurich Instruments device configuration.

name: str

The name of the schedule the config is for.

settings_builder: quantify_scheduler.backends.zhinst.settings.ZISettingsBuilder

The builder to configure the ZI settings.

The builder typically includes DAQ and AWG settings.

acq_config: ZIAcquisitionConfig | None

Acquisition config for the schedule.

The acquisition config contains the number of acquisitions and a dictionary of resolvers used to retrieve the results from the right UHFQA nodes. Note that this part of the config is not needed during prepare, but only during the retrieve acquisitions step.

_generate_legacy_hardware_config(schedule: quantify_scheduler.schedules.schedule.Schedule, compilation_config: quantify_scheduler.backends.graph_compilation.CompilationConfig) → dict

Extract the old-style Zhinst hardware config from the CompilationConfig.

Only the port-clok combinations that are used in the schedule are included in the old-style hardware config.

Parameters:

• schedule (Schedule) – Schedule from which the port-clock combinations are extracted.

• config (CompilationConfig) – CompilationConfig from which hardware config is extracted.

Returns:

hardware_config – Zhinst hardware configuration.

Return type:

dict

Raises:

• KeyError – If the CompilationConfig.connectivity does not contain a hardware config.

• KeyError – If the ‘frequency_param’ is not specified for in a LO config.

• ValueError – If a value is specified in both the hardware options and the hardware config.

• RuntimeError – If no external local oscillator is found in the generated zhinst hardware configuration.

_generate_new_style_hardware_compilation_config(old_style_config: dict) → dict

Generate a new-style ZIHardwareCompilationConfig from an old-style hardware config.

Parameters:

old_style_config – Old-style hardware config.

Returns:

New-style hardware compilation config dictionary.

Return type:

dict

_get_operations_by_repr(schedule: quantify_scheduler.schedules.schedule.Schedule) → dict[str, quantify_scheduler.operations.operation.Operation]

compile_backend(schedule: quantify_scheduler.schedules.schedule.Schedule, config: quantify_scheduler.backends.graph_compilation.CompilationConfig | dict[str, Any] | None = None, *, hardware_cfg: dict[str, Any] | None = None) → quantify_scheduler.schedules.schedule.CompiledSchedule

Compiles zhinst hardware instructions for a schedule.

This method generates sequencer programs, waveforms and configurations required for the instruments defined in the hardware configuration.

Parameters:

• schedule – The schedule to be compiled.

• config – Compilation config for QuantifyCompiler.

• hardware_cfg – (deprecated) The hardware configuration of the setup. Pass a full compilation config instead using config argument.

Returns:

A collection containing the compiled backend configuration for each device.

Raises:

• NotImplementedError – Thrown when using unsupported ZI Instruments.

• ValueError – When both config and hardware_cfg are supplied.

class ZIHardwareCompilationConfig(/, **data: Any)

Bases: quantify_scheduler.backends.types.common.HardwareCompilationConfig

Datastructure containing the information needed to compile to the Zurich Instruments backend.

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

config_type: Type[ZIHardwareCompilationConfig]

A reference to the HardwareCompilationConfig DataStructure for the Zurich Instruments backend.

hardware_description: Dict[str, quantify_scheduler.backends.types.zhinst.ZIHardwareDescription | quantify_scheduler.backends.types.common.HardwareDescription]

Description of the instruments in the physical setup.

hardware_options: quantify_scheduler.backends.types.zhinst.ZIHardwareOptions

Options that are used in compiling the instructions for the hardware, such as LatencyCorrection or OutputGain.

compilation_passes: List[quantify_scheduler.backends.graph_compilation.SimpleNodeConfig]

The list of compilation nodes that should be called in succession to compile a schedule to instructions for the Zurich Instruments hardware.

classmethod from_old_style_hardware_config(data: Any) → Any

Convert old style hardware config dict to new style before validation.

_add_lo_config(channel: quantify_scheduler.backends.types.zhinst.Output, local_oscillators: dict[str, quantify_scheduler.backends.types.zhinst.LocalOscillator], resources: dict[str, quantify_scheduler.resources.Resource], device_configs: dict[str, ZIDeviceConfig | float]) → None

Adds configuration for a local oscillator required for a specific output channel to the device configs.

_add_wave_nodes(device_type: quantify_scheduler.backends.types.zhinst.DeviceType, awg_index: int, wf_id_mapping: dict[str, int], numerical_wf_dict: dict[str, numpy.ndarray], settings_builder: quantify_scheduler.backends.zhinst.settings.ZISettingsBuilder) → quantify_scheduler.backends.zhinst.settings.ZISettingsBuilder

_compile_for_hdawg(device: quantify_scheduler.backends.types.zhinst.Device, timing_table: pandas.DataFrame, numerical_wf_dict: dict[str, numpy.ndarray], repetitions: int) → quantify_scheduler.backends.zhinst.settings.ZISettingsBuilder

Parameters:

• device –

• timing_table –

• numerical_wf_dict –

• repetitions –

Raises:

ValueError –

_assemble_hdawg_sequence(instructions: list[quantify_scheduler.backends.types.zhinst.Instruction], wf_id_mapping: dict[str, int], numerical_wf_dict: dict[str, numpy.ndarray], repetitions: int, schedule_duration: float, markers: str | int | None = None, trigger: int = None) → tuple[str, str]

_compile_for_uhfqa(device: quantify_scheduler.backends.types.zhinst.Device, timing_table: pandas.DataFrame, numerical_wf_dict: dict[str, numpy.ndarray], repetitions: int, operations: dict[str, quantify_scheduler.operations.operation.Operation], bin_mode: quantify_scheduler.enums.BinMode) → tuple[quantify_scheduler.backends.zhinst.settings.ZISettingsBuilder, ZIAcquisitionConfig]

Initialize programming the UHFQA ZI Instrument.

Creates a sequence program and converts schedule pulses to waveforms for the UHFQA.

Parameters:

• device –

• timing_table –

• numerical_wf_dict –

• repetitions –

• operations –

_assemble_uhfqa_sequence(instructions: list[quantify_scheduler.backends.types.zhinst.Instruction], wf_id_mapping: dict[str, int], repetitions: int, device_name: str, trigger: int = 2) → str

construct_waveform_table(timing_table: pandas.DataFrame, operations_dict: dict[str, quantify_scheduler.operations.operation.Operation], device_dict: dict[str, quantify_scheduler.backends.types.zhinst.Device]) → dict[str, numpy.ndarray]

Iterates over all unique waveforms in a timing_table dataframe to calculate the numerical waveforms.

Parameters:

• timing_table – A timing table for which the waveform_id has been determined

• operations_dict – The Operations contained in a Schedule.

• device_dict – A dictionary containing the Device objects describing the devicesin the hardware configuration.

Returns:

numerical_waveform dict, a dictionary containing the complex valued waveforms that will be uploaded to the control hardware.