AOM

Class Arguments

Argument	Type	Default Value
center_freq	TFloat
rfsource	RFSource
freq_limit	tuple	None
bandwidth	TFloat	None
switch	Switchable	None
switching_delay	TFloat	0
passes	TInt32	1
order	TInt32	1
am_calibration	Calibration	None
amp_limit	tuple	(0.0, 1.0)

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

   {
    "lightmodulator_example": {
        "classname": "atomiq.components.optoelectronics.lightmodulator.AOM",
        "arguments": {
            "center_freq": "<mandatory parameter (TFloat)>",
            "rfsource": "<mandatory parameter (RFSource)>",
            "freq_limit": null,
            "bandwidth": null,
            "switch": null,
            "switching_delay": 0,
            "passes": 1,
            "order": 1,
            "am_calibration": null,
            "amp_limit": [
                0.0,
                1.0
            ]
        }
    }
}

Class Description

class atomiq.components.optoelectronics.lightmodulator.AOM(center_freq, freq_limit=None, bandwidth=None, switch=None, switching_delay=0, passes=1, order=1, am_calibration=None, *args, **kwargs)

Bases: RFLightModulator, Switchable

An acousto-optical modulator to alter amplitude, frequency and phase of the light.

A component to represent an AOM to attenuate, switch and frequency-shift light. It is controlled by an RFSource and a Switchable to rapidly switch the light on and off. As such, the AOM works also as a (non-perfect) shutter.

Parameters:

• rfsource -- The rf source that drives the AOM

• center_freq (TFloat) -- RF center frequency of the AOM in Hz.

• freq_limit (tuple) -- Tuple (freq_min, freq_max) giving the minimum/maximum RF frequency that the AOM can handle in Hz. Either freq_limit xor bandwidth must be given

• bandwidth (TFloat) -- RF bandwidth of the AOM around the center frequency in Hz. Either bandwidth xor freq_limit must be given.

• switch (Switchable) -- An optional switch to rapidly switch on and off the AOM. If none is given the rfsource is used to switch.

• switching_delay (TFloat) -- the switching delay of the AOM, i.e. the time it takes from the arrival of the TTL to having full optical power. (default 0)

• passes (TInt32) -- How often does the beam pass the AOM? Singlepass -> 1, Doublepass -> 2 (default 1)

• order (TInt32) -- The diffraction order the AOM is aligned to. -2, -1, 1, 2 ... (default 1)

• am_calibration (Calibration) -- Calibration of RF power vs output power. Typically an inverse sigmoid. (default none)

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

set_frequency(frequency)

Set the frequency shift of the light coming out of the AOM

Parameters:

frequency (artiq.compiler.types.TMono('float', OrderedDict()))

set_detuning(detuning)

Set the frequency shift of the light coming out of the AOM relative to the center frequency

Parameters:

detuning (artiq.compiler.types.TMono('float', OrderedDict())) -- Detuning from the AOM center frequency in Hz

detune(detuning)

Alias for set_detuning()

Parameters:

detuning (artiq.compiler.types.TMono('float', OrderedDict()))

set_amplitude(amplitude)

Set the amplitude of the light after the modulator

Parameters:

amplitude (artiq.compiler.types.TMono('float', OrderedDict())) -- Relative amplitude [0 .. 1] of the light after the modulator

arb(duration, samples_amp=[], samples_freq=[], samples_det=[], 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_det (artiq.compiler.types.TMono('list', OrderedDict([('elt', artiq.compiler.types.TMono('float', OrderedDict()))]))) -- List of frequency samples relative to the center frequency. If this list is empty (default), the frequency is not modified. This overwrites samples_frequency

• 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()))

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´.

Note

The amplitude calibration is only applied at the start and end point of the ramp to reduce calculation overhead. This relies on the calibration being sufficiently linear in the ramp range.

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

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

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

• ramp_steps (artiq.compiler.types.TMono('int', OrderedDict([('width', artiq.compiler.types.TValue(32))])))

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.

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).

on()

Turns on the AOM. The time cursor is moved back in time to accommodate the switching_delay of the AOM. After executing the on method of the defined switch the time cursor is then forwarded by switching_delay again. The time cursor advancement is therefore given by the switch.on() method.

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.

set_phase(value)

Set the phase shift of the light imposed by the modulator

Parameters:

• phase -- Phase shift in radians

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

set_polarisation(angle)

Set the polarization rotation imposed by the modulator

Parameters:

angle (artiq.compiler.types.TMono('float', OrderedDict())) -- Rotation angle in radians

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.

off()

Turns off the AOM. The time cursor is moved back in time to accommodate the switching_delay of the AOM. After executing the off method of the defined switch the time cursor is then forwarded by switching_delay again. The time cursor advancement is therefore given by the switch.off() method.