3.3.1. qupulse.hardware.awgs

Functions

install_requirements(vendor)

class qupulse.hardware.awgs.TaborAWGRepresentation(instr_addr=None, paranoia_level=1, external_trigger=False, reset=False, mirror_addresses=())

Bases: object

Parameters

• instr_addr – Instrument address that is forwarded to tabor_control

• paranoia_level – Paranoia level that is forwarded to tabor_control

• external_trigger – Not supported yet

• reset –

• mirror_addresses –

__init__(instr_addr=None, paranoia_level=1, external_trigger=False, reset=False, mirror_addresses=())

Parameters

• instr_addr – Instrument address that is forwarded to tabor_control

• paranoia_level – Paranoia level that is forwarded to tabor_control

• external_trigger – Not supported yet

• reset –

• mirror_addresses –

abort() → None

property all_devices: Sequence[tabor_control.device.TEWXAwg]

amplitude(channel) → float

property channel_pair_AB: qupulse.hardware.awgs.tabor.TaborChannelPair

property channel_pair_CD: qupulse.hardware.awgs.tabor.TaborChannelPair

property dev_properties: dict

download_adv_seq_table(seq_table, pref=':ASEQ:DATA', paranoia_level=None)

download_segment_lengths(seg_len_list, pref=':SEGM:DATA', paranoia_level=None)

download_sequencer_table(seq_table, pref=':SEQ:DATA', paranoia_level=None)

enable() → None

get_readable_device(simulator=True) → tabor_control.device.TEWXAwg

get_status_table() → Dict[str, Union[str, float, int]]

Send a lot of queries to the AWG about its settings. A good way to visualize is using pandas.DataFrame

Returns

An ordered dictionary with the results

initialize() → None

is_coupled() → bool

property is_open: bool

property main_instrument: tabor_control.device.TEWXAwg

property mirrored_instruments: Sequence[tabor_control.device.TEWXAwg]

offset(channel: int) → float

property paranoia_level: int

reset() → None

sample_rate(channel) → int

select_channel(channel) → None

select_marker(marker: int) → None

Select marker 1 or 2 of the currently active channel pair.

send_binary_data(pref, bin_dat, paranoia_level=None)

send_cmd(cmd_str, paranoia_level=None)

send_query(query_str, query_mirrors=False) → Any

trigger() → None

class qupulse.hardware.awgs.TaborChannelPair(tabor_device: qupulse.hardware.awgs.tabor.TaborAWGRepresentation, channels: Tuple[int, int], identifier: str)

Bases: qupulse.hardware.awgs.base.AWG

CONFIG_MODE_PARANOIA_LEVEL = None

arm(name: str) → None

Implements arm().

change_armed_program(name: Optional[str]) → None

cleanup() → None

Discard all segments after the last which is still referenced

clear() → None

Delete all segments and clear memory

property device: qupulse.hardware.awgs.tabor.TaborAWGRepresentation

free_program(name: str) → qupulse.hardware.awgs.tabor.TaborProgramMemory

property internal_paranoia_level: Optional[int]

property logger

property num_channels: int

Implements num_channels.

property num_markers: int

Implements num_markers.

property programs: Set[str]

The set of program names that can currently be executed on the hardware AWG.

read_advanced_sequencer_table() → Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]

read_complete_program() → qupulse._program.tabor.PlottableProgram

read_sequence_tables() → List[Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]]

read_waveforms() → List[numpy.ndarray]

remove(name: str) → None

Remove a program from the AWG.

Also discards all waveforms referenced only by the program identified by name.

Parameters

name (str) – The name of the program to remove.

run_current_program() → None

property sample_rate: float

Implements sample_rate.

select() → None

set_channel_state(channel, active) → None

set_marker_state(marker: int, active: bool) → None

Sets the marker state of this channel pair. According to the manual one cannot turn them off/on separately.

set_program_advanced_sequence_table(name, new_advanced_sequence_table)

set_program_sequence_table(name, new_sequence_table)

set_volatile_parameters(program_name: str, parameters: Mapping[str, numbers.Number]) → None

Set the values of parameters which were marked as volatile on program creation. Sets volatile parameters in program memory and device’s (adv.) sequence tables if program is current program.

If set_volatile_parameters needs to run faster, set CONFIG_MODE_PARANOIA_LEVEL to 0 which causes the device to enter the configuration mode with paranoia level 0 (Note: paranoia level 0 does not work for the simulator) and set device._is_coupled.

Parameters

• program_name – Name of program which should be changed.

• parameters – Names of volatile parameters and respective values to which they should be set.

property total_capacity: int

upload(name: str, program: qupulse._program._loop.Loop, channels: Tuple[Optional[Union[str, int]], Optional[Union[str, int]]], markers: Tuple[Optional[Union[str, int]], Optional[Union[str, int]]], voltage_transformation: Tuple[Callable, Callable], force: bool = False) → None

Upload a program to the AWG.

The policy is to prefer amending the unknown waveforms to overwriting old ones.

class qupulse.hardware.awgs.TektronixAWG(device: tek_awg.TekAwg, synchronize: str, identifier='Tektronix', logger=None, default_program_repetition_mode='once', idle_waveform_length=250)

Bases: qupulse.hardware.awgs.base.AWG

Driver for Tektronix AWG object (5000/7000 series).

Special characteristics:

• Changing the run mode to ‘running’ takes a lot of time (depending on the sequence)

• To keep the “arm” time low each program is uploaded to the sequence table! This reduces the number of programs drastically but allows very fast switching with arm IF the awg runs.

• Arm starts the awg if it does not run. The first call to arm after uploading new programs is therefore slow. This guarantees that subsequent calls to arm and run_current_program are always fast.

• Uploading while the awg runs is VERY slow. The private properties _allow_upload_while_running and _auto_stop_on_upload control the behaviour in this case (stopping the awg or raising an exception). These properties are currently not a stable interface to that functionality hence the privateness.

This driver implements an interface for changing the program repetition mode consisting of:

• the property default_program_repetition_mode

• set_program_repetition_mode(program_name, mode)

• get_program_repetition_mode(program_name)

Synchronization: The driver relies on the fact that internal variables correspond to the device state: _sequence_entries and _waveforms We do not aim to detect user manipulation but want to make sure invalidate the internal state on upload errors. To do this the attribute _synchronized is set to False. Methods that rely on the synchronization state to correctly modify the awg check that attribute.

All private functions assume that the error queue is empty when called.

TODO: Move logger and repetition mode functionality to AWG interface

Parameters

• device – Instance of the underlying driver from tek_awg package

• synchronize – Either ‘read’ or ‘clear’.

• identifier – Some identifier

• logger – Logging will happen here (defaults to ‘qupulse.tektronix’ otherwise)

• default_program_repetition_mode – ‘once’ or ‘infinite’

• idle_waveform_length – length of the idle_waveform in samples

__init__(device: tek_awg.TekAwg, synchronize: str, identifier='Tektronix', logger=None, default_program_repetition_mode='once', idle_waveform_length=250)

Parameters

• device – Instance of the underlying driver from tek_awg package

• synchronize – Either ‘read’ or ‘clear’.

• identifier – Some identifier

• logger – Logging will happen here (defaults to ‘qupulse.tektronix’ otherwise)

• default_program_repetition_mode – ‘once’ or ‘infinite’

• idle_waveform_length – length of the idle_waveform in samples

arm(name: Optional[str])

Arming starts the awg

property armed_program: Optional[str]

assert_synchronized()

cleanup()

Delete all waveforms not used anymore and rewrite sequence entries if they are fragmented

clear()

Clear all waveforms, the sequence table and program registry and initialize the idle program.

property default_program_repetition_mode: str

repetition mode for newly uploaded programs. Valid values are ‘once’ and ‘infinite’. You can use set_program_repetition_mode to change the repetition mode of an existing program

property device: tek_awg.TekAwg

get_program_information() → Dict[str, dict]

get_program_repetition_mode(program_name: str) → str

This function uses cached data and does not talk to the awg

static idle_pulse_name(idle_length: int) → str

initialize_idle_program()

Make sure we can arm the idle program which plays the idle waveform(default 0V) on all channels.

make_idle_waveform(length) → tek_awg.Waveform

property num_channels: int

Implements num_channels.

property num_markers: int

Implements num_markers.

property programs: Set[str]

Implements programs.

read_waveforms()

Read all waveform data from the device (including binary data).

remove(name: str)

Implements remove().

run_current_program(channel_states: Optional[Tuple[bool, bool, bool, bool]] = None)

Runs the currentlz armed program

Parameters

channel_states – If given the channel states are set to these values

Returns:

property sample_rate: float

Implements sample_rate.

set_program_repetition_mode(program_name: str, mode: str)

set_volatile_parameters(program_name: str, parameters)

Implements set_volatile_parameters().

synchronize()

Read waveforms from device and re-upload all programs

property synchronized: bool

upload(*args, **kwargs)

Implements upload().

warn_if_errors_are_present()

Emit a warning with present errors.

qupulse.hardware.awgs.install_requirements(vendor: str)

Modules

qupulse.hardware.awgs.base	This module defines the common interface for arbitrary waveform generators.
qupulse.hardware.awgs.tabor
qupulse.hardware.awgs.tektronix
qupulse.hardware.awgs.zihdawg