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.
`flatten_schedule`(...)	Recursively flatten subschedules based on the absolute timing.
`_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`(...)
`_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[source]#

handler[source]#

formatter[source]#

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

SUPPORTED_ACQ_PROTOCOLS[source]#

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

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

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

CLOCK_SAMPLE_FACTOR = 8[source]#

NUM_UHFQA_READOUT_CHANNELS = 10[source]#

MAX_QAS_INTEGRATION_LENGTH = 4096[source]#

ensure_no_operations_overlap(timing_table: pandas.DataFrame) → None[source]#

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][source]#

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][source]#: 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[source]#

_determine_sample_start(hardware_channel: str, abs_time: float, operation_name: str) → float[source]#

_add_channel_information(timing_table: pandas.DataFrame, port_clock_channelmapping: dict) → pandas.DataFrame | None[source]#

_apply_latency_corrections(timing_table: pandas.DataFrame, latency_dict: dict) → pandas.DataFrame[source]#: 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][source]#

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[source]#

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[source]#: Adds the sequence clock cycle start and sampling start of each operation for each channel.

_add_waveform_ids(timing_table: pandas.DataFrame) → pandas.DataFrame[source]#

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][source]#

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][source]#

_validate_schedule(schedule: quantify_scheduler.schedules.schedule.Schedule) → None[source]#

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][source]#

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][source]#: 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[source]#

Zurich Instruments acquisition configuration.

Parameters:: bin_mode

n_acquisitions: int[source]#: The number of distinct acquisitions in this experiment.

resolvers: dict[int, Callable][source]#

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