UrukulChannel

Class Arguments

Argument	Type	Default Value
urukul	Urukul
device	TStr
ttl		None
default_attenuation		19.0
profile_arb	TInt32	0
use_drg	TBool	True
auto_sync_drg	TInt32	0
default_frequency	TFloat	100000000.0
default_amplitude	TFloat	0.0
default_phase	TFloat	0.0
freq_limit	tuple	(0.0, inf)
amp_limit	tuple	(0.0, 1.0)
blind	TBool	False
default_ramp_steps	TInt32	30

Bold arguments are mandatory. For more documentation on the listed arguments refer to the class definition below. If parameters appear in this list but not in the class definition below, please recursively check the linked base classes for the definition of the parameter.

Inheritance Diagram

Example Component Dictionary

   {
    "urukul_example": {
        "classname": "atomiq.components.sinara.urukul.UrukulChannel",
        "arguments": {
            "urukul": "<mandatory parameter (Urukul)>",
            "device": "<mandatory parameter (TStr)>",
            "ttl": null,
            "default_attenuation": 19.0,
            "profile_arb": 0,
            "use_drg": true,
            "auto_sync_drg": 0,
            "default_frequency": 100000000.0,
            "default_amplitude": 0.0,
            "default_phase": 0.0,
            "freq_limit": [
                0.0,
                1e999
            ],
            "amp_limit": [
                0.0,
                1.0
            ],
            "blind": false,
            "default_ramp_steps": 30
        }
    }
}

Class Description

class atomiq.components.sinara.urukul.UrukulChannel(urukul, device, ttl=None, default_attenuation=19.0, profile_arb=0, use_drg=True, auto_sync_drg=0, *args, **kwargs)

Bases: RFSource, Switchable

Single DDS Channel of a Sinara Urukul

Parameters:

• urukul (Urukul) -- The Urukul component this channel belongs to

• device (TStr) -- The ARTIQ device from the device_db representing the Urukul channel, e.g. @urukul0_ch0

• ttl -- The ARTIQ device from the device_db representing the Urukul fast RF switch, e.g. @ttl_urukul0_sw0

• default_attenuation -- Default attenuation to set for the channel on startup. (default -19dBm)

• profile_arb (TInt32) -- Profile on the DDS to use for arbitrary function generation. (default 0)

• use_drg (TBool) -- Use the DRG for amplitude or frequency ramps (recommended). (default True)

• auto_sync_drg (TInt32) -- Defined if the drg is synced to either frequency (1) or amplitude (2) in the prepare phase. Default is not synced (0). Syncing is recommended in combination with blind if continuous operation is required.

Tip

The ramp() method can be used in combination with the blind component argument. This allows for generating continous, jump-free ramps between experiments. This makes it possible to use the dds output to generate a lock signal for a laser cavity lock.

Attention

Setting parameters before the DRG is synced with the python object would break the continuity. Run sync_drg() before setting amplitude, frequency or phase parameters or use auto_sync_drg.

A Parametrizable is an entity that can be controlled by one or more continuous parameter(s)

init()

Initialize the urukul channel. Necessary only once after power on.

Warning

This function is not called automatically as it is slow and resets the device leading to a frequency/amplitude jump.

set(frequency=nan, amplitude=nan, phase=0.0, profile=-1)

Set the frequency and amplitude. Frequency/amplitude are set to the last known value if float("nan") is passed (default).

Parameters:

• frequency (artiq.compiler.types.TMono('float', OrderedDict())) -- Frequency in Hz (float("nan") to use previous value)

• amplitude (artiq.compiler.types.TMono('float', OrderedDict())) -- Amplitude in units of full scale (float("nan") to use previous value)

• phase (artiq.compiler.types.TMono('float', OrderedDict())) -- Phase tuning word in turns

• profile (artiq.compiler.types.TMono('int', OrderedDict([('width', artiq.compiler.types.TValue(32))]))) -- DDS Profile (-1 to keep current profile)

set_att(attenuation)

Set the hardware attenuation for this urukul channel via CPLD.

Parameters:

attenuation (artiq.compiler.types.TMono('float', OrderedDict())) -- channel attenuation (0. to 31.0 in 0.5 increments) [dB]

on()

Turn on via ttl.

:return

off()

Turn off via ttl.

:return

read64_32(addr)

Read two 32-bit values from 64-bit register. Advances time cursor by 8600ns

Parameters:

addr (artiq.compiler.types.TMono('int', OrderedDict([('width', artiq.compiler.types.TValue(32))]))) -- Register address

Returns:

Tuple of two 32-bit integer register values

sync_drg(target)

Synchronises the python object with the current register values of the DRG. Advances time cursor by 25us.

Parameters:

target (artiq.compiler.types.TMono('int', OrderedDict([('width', artiq.compiler.types.TValue(32))]))) -- Target to synchronise to. 1 for frequency, 2 for amplitude.

ramp(duration, frequency_start=nan, frequency_end=nan, amplitude_start=nan, amplitude_end=nan, ramp_timestep=nan, ramp_steps=-1)

Ramp frequency and amplitude over a given duration. Parameters default to -1 or nan to indicate no change. If the start frequency/amplitude is set to nan, the ramp starts from the last frequency/amplitude which was set. This method advances the timeline by ´duration´

Tip

This method can be used in combination with the blind component argument. This allows for generating continous, jump-free ramps between experiments. This makes it possible to use the dds output to generate a lock signal for a laser cavity lock. Note that in this mode using amplitude and frequency ramps leads to undefined behavior when switching between them. As the DRG can only address either amplitude or frequency, parallel ramps of both parameters are ramped in a simple step by step way. Usage of the DRG can be avoided by setting the component attribute use_drg to False.

Attention

When using the DRG, this method always advances the timeline by at least 10us, even if the ramp is shorter.

Parameters:

• duration (artiq.compiler.types.TMono('float', OrderedDict())) -- ramp duration [s]

• frequency_start (artiq.compiler.types.TMono('float', OrderedDict())) -- initial frequency [Hz]

• frequency_end (artiq.compiler.types.TMono('float', OrderedDict())) -- end frequency [Hz]

• amplitude_start (artiq.compiler.types.TMono('float', OrderedDict())) -- initial amplitude [0..1]

• amplitude_end (artiq.compiler.types.TMono('float', OrderedDict())) -- end amplitude [0..1]

• ramp_timesteps -- time between steps in the ramp [s]

• ramp_steps (artiq.compiler.types.TMono('int', OrderedDict([('width', artiq.compiler.types.TValue(32))]))) -- number of steps the whole ramp should have. This takes precedence over ramp_timesteps

• ramp_timestep (artiq.compiler.types.TMono('float', OrderedDict()))

append_to_dataset(key, value)

Append a value to a dataset.

The target dataset must be a list (i.e. support append()), and must have previously been set from this experiment.

The broadcast/persist/archive mode of the given key remains unchanged from when the dataset was last set. Appended values are transmitted efficiently as incremental modifications in broadcast mode.

arb(duration, samples_amp=[], samples_freq=[], samples_phase=[], repetitions=1, prepare_only=False, run_prepared=False, transform_amp=<function identity_float>, transform_freq=<function identity_float>, transform_phase=<function identity_float>)

Play Arbitrary Samples from a List

This method allows to set the output amplitude, frequency an phase according to the values specified in respective lists. The whole sequence is played in the specified duration. The pattern store in the sample list can also be repeated.

We supports a scheme to prepare the arb function before it is actually used. If that is needed, run this function with prepapre_only = True when the arb should be prepared and with run_only = True when the prepared arb should be played. In both calls the other parameters have to be passed.

Parameters:

• samples_amp (artiq.compiler.types.TMono('list', OrderedDict([('elt', artiq.compiler.types.TMono('float', OrderedDict()))]))) -- List of amplitude samples. If this list is empty (default), the amplitude is not modified.

• samples_freq (artiq.compiler.types.TMono('list', OrderedDict([('elt', artiq.compiler.types.TMono('float', OrderedDict()))]))) -- List of frequency samples. If this list is empty (default), the frequency is not modified.

• samples_phase (artiq.compiler.types.TMono('list', OrderedDict([('elt', artiq.compiler.types.TMono('float', OrderedDict()))]))) -- List of phase samples. If this list is empty (default), the phase is not modified.

• duration (artiq.compiler.types.TMono('float', OrderedDict())) -- The time in which the whole sequence of samples should be played back [s].

• repetitions (artiq.compiler.types.TMono('int', OrderedDict([('width', artiq.compiler.types.TValue(32))]))) -- Number of times the sequence of all samples should be played. (default 1)

• prepare_only (artiq.compiler.types.TMono('bool', OrderedDict()))

• run_prepared (artiq.compiler.types.TMono('bool', OrderedDict()))

build()

Should be implemented by the user to request arguments.

Other initialization steps such as requesting devices may also be performed here.

There are two situations where the requested devices are replaced by DummyDevice() and arguments are set to their defaults (or None) instead: when the repository is scanned to build the list of available experiments and when the dataset browser artiq_browser is used to open or run the analysis stage of an experiment. Do not rely on being able to operate on devices or arguments in build().

Datasets are read-only in this method.

Leftover positional and keyword arguments from the constructor are forwarded to this method. This is intended for experiments that are only meant to be executed programmatically (not from the GUI).

call_child_method(method, *args, **kwargs)

Calls the named method for each child, if it exists for that child, in the order of registration.

Parameters:

• method (str) -- Name of the method to call

• args -- Tuple of positional arguments to pass to all children

• kwargs -- Dict of keyword arguments to pass to all children

get_argument(key, processor, group=None, tooltip=None)

Retrieves and returns the value of an argument.

This function should only be called from build.

Parameters:

• key -- Name of the argument.

• processor -- A description of how to process the argument, such as instances of BooleanValue and NumberValue.

• group -- An optional string that defines what group the argument belongs to, for user interface purposes.

• tooltip -- An optional string to describe the argument in more detail, applied as a tooltip to the argument name in the user interface.

get_dataset(key, default=<class 'artiq.language.environment.NoDefault'>, archive=True)

Returns the contents of a dataset.

The local storage is searched first, followed by the master storage (which contains the broadcasted datasets from all experiments) if the key was not found initially.

If the dataset does not exist, returns the default value. If no default is provided, raises KeyError.

By default, datasets obtained by this method are archived into the output HDF5 file of the experiment. If an archived dataset is requested more than one time or is modified, only the value at the time of the first call is archived. This may impact reproducibility of experiments.

Parameters:

archive -- Set to False to prevent archival together with the run's results. Default is True.

get_dataset_metadata(key, default=<class 'artiq.language.environment.NoDefault'>)

Returns the metadata of a dataset.

Returns dictionary with items describing the dataset, including the units, scale and precision.

This function is used to get additional information for displaying the dataset.

See set_dataset() for documentation of metadata items.

get_device(key)

Creates and returns a device driver.

get_device_db()

Returns the full contents of the device database.

interactive(title='')

Request arguments from the user interactively.

This context manager returns a namespace object on which the method setattr_argument() should be called, with the usual semantics.

When the context manager terminates, the experiment is blocked and the user is presented with the requested argument widgets. After the user enters values, the experiment is resumed and the namespace contains the values of the arguments.

If the interactive arguments request is cancelled, raises CancelledArgsError.

mutate_dataset(key, index, value)

Mutate an existing dataset at the given index (e.g. set a value at a given position in a NumPy array)

If the dataset was created in broadcast mode, the modification is immediately transmitted.

If the index is a tuple of integers, it is interpreted as slice(*index). If the index is a tuple of tuples, each sub-tuple is interpreted as slice(*sub_tuple) (multi-dimensional slicing).

set_dataset(key, value, *, unit=None, scale=None, precision=None, broadcast=False, persist=False, archive=True)

Sets the contents and handling modes of a dataset.

Datasets must be scalars (bool, int, float or NumPy scalar) or NumPy arrays.

Parameters:

• unit -- A string representing the unit of the value.

• scale -- A numerical factor that is used to adjust the value of the dataset to match the scale or units of the experiment's reference frame when the value is displayed.

• precision -- The maximum number of digits to print after the decimal point. Set precision=None to print as many digits as necessary to uniquely specify the value. Uses IEEE unbiased rounding.

• broadcast -- the data is sent in real-time to the master, which dispatches it.

• persist -- the master should store the data on-disk. Implies broadcast.

• archive -- the data is saved into the local storage of the current run (archived as a HDF5 file).

set_default_scheduling(priority=None, pipeline_name=None, flush=None)

Sets the default scheduling options.

This function should only be called from build.

setattr_argument(key, processor=None, group=None, tooltip=None)

Sets an argument as attribute. The names of the argument and of the attribute are the same.

The key is added to the instance's kernel invariants.

setattr_dataset(key, default=<class 'artiq.language.environment.NoDefault'>, archive=True)

Sets the contents of a dataset as attribute. The names of the dataset and of the attribute are the same.

setattr_device(key)

Sets a device driver as attribute. The names of the device driver and of the attribute are the same.

The key is added to the instance's kernel invariants.