qasm_program

QASM program class for Qblox backend.

Module Contents

Classes

QASMProgram

Class that holds the compiled Q1ASM program that is to be executed by the sequencer.

class QASMProgram(static_hw_properties: quantify_scheduler.backends.types.qblox.StaticHardwareProperties, register_manager: quantify_scheduler.backends.qblox.register_manager.RegisterManager, align_fields: bool, acq_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata | None)

Class that holds the compiled Q1ASM program that is to be executed by the sequencer.

Apart from this the class holds some convenience functions that auto generate certain instructions with parameters, as well as update the elapsed time.

Parameters:

• static_hw_properties – Dataclass holding the properties of the hardware that this program is to be played on.

• register_manager – The register manager that keeps track of the occupied/available registers.

• align_fields – If True, make QASM program more human-readable by aligning its fields.

register_manager: quantify_scheduler.backends.qblox.register_manager.RegisterManager

The register manager that keeps track of the occupied/available registers.

static_hw_properties: quantify_scheduler.backends.types.qblox.StaticHardwareProperties

Dataclass holding the properties of the hardware that this program is to be played on.

elapsed_time: int = 0

The time elapsed after finishing the program in its current form. This is used to keep track of the overall timing and necessary waits.

integration_length_acq: int | None

Integration length to use for the square acquisition.

time_last_acquisition_triggered: int | None

Time on which the last acquisition was triggered. Is None if no previous acquisition was triggered.

instructions: List[list]

A list containing the instructions added to the program. The instructions added are in turn a list of the instruction string with arguments.

align_fields: bool

If true, all labels, instructions, arguments and comments in the string representation of the program are printed on the same indention level. This worsens performance.

conditional_manager: quantify_scheduler.backends.qblox.conditional.ConditionalManager

The conditional manager that keeps track of the conditionals.

acq_metadata: quantify_scheduler.schedules.schedule.AcquisitionMetadata | None

Acquisition metadata.

_lock_conditional: bool = False

A lock to prevent nested conditionals.

_find_qblox_acq_index(acq_channel: Hashable) → int

Finds the Qblox acq_index corresponding to acq_channel in the acq_metadata.

static get_instruction_as_list(instruction: str, *args: int | str, label: str | None = None, comment: str | None = None) → List[str | int]

Takes an instruction with arguments, label and comment and turns it into the list required by the class.

Parameters:

• instruction – The instruction to use. This should be one specified in q1asm_instructions or the assembler will raise an exception.

• args – Arguments to be passed.

• label – Adds a label to the line. Used for jumps and loops.

• comment – Optionally add a comment to the instruction.

Returns:

List that contains all the passed information in the valid format for the program.

Raises:

SyntaxError – More arguments passed than the sequencer allows.

emit(*args, **kwargs) → list[str, int]

Wrapper around the get_instruction_as_list which adds it to this program.

Parameters:

• args – All arguments to pass to get_instruction_as_list.

• **kwargs – All keyword arguments to pass to get_instruction_as_list.

Returns:

A list containing instructions.

set_marker(marker_setting: str | int = '0000') → None

Sets the marker from a string representing a binary number. Each digit corresponds to a marker e.g. ‘0010’ sets the second marker to True.

Parameters:

marker_setting – The string representing a binary number.

set_latch(pulses: Sequence[quantify_scheduler.backends.qblox.operation_handling.base.IOperationStrategy]) → None

Set the latch that is needed for conditional playback.

This assumes that the latch address is present inside the pulses’ operation_info. If no latch address is found, nothing is emitted.

Parameters:

pulses – The pulses to search the latch address in.

auto_wait(wait_time: int, count_as_elapsed_time: bool = True, comment: str | None = None) → None

Automatically emits a correct wait command. If the wait time is longer than allowed by the sequencer it correctly breaks it up into multiple wait instructions. If the number of wait instructions is too high (>4), a loop will be used.

Parameters:

• wait_time – Time to wait in ns.

• count_as_elapsed_time – If true, this wait time is taken into account when keeping track of timing. Otherwise, the wait instructions are added but this wait time is ignored in the timing calculations in the rest of the program.

• comment – Allows to override the default comment.

Raises:

ValueError – If wait_time <= 0.

wait_till_start_operation(operation: quantify_scheduler.backends.types.qblox.OpInfo) → None

Waits until the start of a pulse or acquisition.

Parameters:

operation – The pulse or acquisition that we want to wait for.

Raises:

ValueError – If wait time < 0.

verify_square_acquisition_duration(acquisition: quantify_scheduler.backends.types.qblox.OpInfo, duration: float)

Verifies if the square acquisition is valid by checking constraints on the duration.

Parameters:

• acquisition – The operation info of the acquisition to process.

• duration – The duration to verify.

Raises:

• ValueError – When attempting to perform an acquisition of a duration that is not a multiple of 4 ns.

• ValueError – When using a different duration than previous acquisitions.

_acquire_looped(acquisition: quantify_scheduler.backends.types.qblox.OpInfo, bin_idx: int | str) → None

set_gain_from_amplitude(amplitude_path_I: float, amplitude_path_Q: float, operation: quantify_scheduler.backends.types.qblox.OpInfo | None) → None

Sets the gain such that a 1.0 in waveform memory corresponds to the full awg gain.

Parameters:

• amplitude_path_I – Voltage to set on path_I.

• amplitude_path_Q – Voltage to set on path_Q.

• operation – The operation for which this is done. Used for the exception messages.

static expand_awg_from_normalised_range(val: float, immediate_size: int, param: str | None = None, operation: quantify_scheduler.backends.types.qblox.OpInfo | None = None)

Takes the value of an awg gain or offset parameter in normalized form (abs(param) <= 1.0), and expands it to an integer in the appropriate range required by the sequencer.

Parameters:

• val – The value of the parameter to expand.

• immediate_size – The size of the immediate. Used to find the max int value.

• param – The name of the parameter, to make a possible exception message more descriptive.

• operation – The operation this value is expanded for, to make a possible exception message more descriptive.

Returns:

The expanded value of the parameter.

Raises:

ValueError – Parameter is not in the normalized range.

conditional(operation: quantify_scheduler.backends.qblox.operation_handling.virtual.ConditionalStrategy) → None

Defines a conditional block in the QASM program.

When this context manager is entered/exited it will insert additional set_cond QASM instructions in the program that specify the conditionality of a set of instructions.

For example, a conditional X gate would correspond to the QASM program:

set_cond 1, 0, 0, 20
play 1, 20
set_cond 0, 0, 0, 4

The exact values that need to be passed to the first set_cond instruction are determined while the qasm program is generated with the help of FeedbackTriggerCondition and ConditionalManager.

Parameters:

operation (ConditionalStrategy) – The conditional strategy that defines the start of a conditional block.

loop(label: str, repetitions: int = 1)

Defines a context manager that can be used to generate a loop in the QASM program.

Parameters:

• label – The label to use for the jump.

• repetitions – The amount of iterations to perform.

Yields:

The register used as loop counter.

Examples

This adds a loop to the program that loops 10 times over a wait of 100 ns.

from quantify_scheduler.backends.qblox.qasm_program import QASMProgram
from quantify_scheduler.backends.qblox.instrument_compilers import QcmModule
from quantify_scheduler.backends.qblox import register_manager, constants
from quantify_scheduler.backends.types.qblox import (
    StaticHardwareProperties,
    BoundedParameter
)

qasm = QASMProgram(
    static_hw_properties=QcmModule.static_hw_properties,
    register_manager=register_manager.RegisterManager(),
    align_fields=True,
    acq_metadata=None,
)

with qasm.loop(label="repeat", repetitions=10):
    qasm.auto_wait(100)

qasm.instructions

[['', 'move', '10,R0', '# iterator for loop with label repeat'],
 ['repeat:', '', '', ''],
 ['', 'wait', '100', '# auto generated wait (100 ns)'],
 ['', 'loop', 'R0,@repeat', '']]

temp_registers(amount: int = 1) → Iterator[List[str]]

Context manager for using a register temporarily. Frees up the register afterwards.

Parameters:

amount – The amount of registers to temporarily use.

Yields:

Either a single register or a list of registers.