QUA Statements Reference¶
qm.qua._dsl.program
¶
Create a QUA program.
Used within a context manager, the program is defined in the code block
below with
statement.
Statements in the code block below are played as soon as possible, meaning that an instruction
will be played immediately unless it is dependent on a previous instruction.
Additionally, commands output to the same elements will be played sequentially,
and to different elements will be played in parallel.
An exception is that pulses will be implicitly aligned at the end of each for_
loop iteration.
The generated program_name
object is used as an input to the execute function of a
qm.QuantumMachine object.
Example
where qm
is an instance of a qm.QuantumMachine
qm.qua._dsl.play
¶
Play a pulse
based on an 'operation' defined in element
.
The pulse will be modified according to the properties of the element (see detailed explanation about pulse modifications below), and then played to the OPX output(s) defined to be connected to the input(s) of the element in the configuration.
PARAMETER | DESCRIPTION |
---|---|
pulse |
The name of an
TYPE:
|
element |
The name of the element, as defined in the quantum machine configuration.
TYPE:
|
duration |
The time to play this pulse in units of the clock cycle (4ns). If not provided, the default pulse duration will be used. It is possible to dynamically change the duration of both constant and arbitrary pulses. Arbitrary pulses can only be stretched, not compressed.
TYPE:
|
chirp |
Allows to perform piecewise linear sweep of the element’s intermediate frequency in time. Input should be a tuple, with the 1st element being a list of rates and the second should be a string with the units. The units can be either: ‘Hz/nsec’, ’mHz/nsec’, ’uHz/nsec’, ’pHz/nsec’ or ‘GHz/sec’, ’MHz/sec’, ’KHz/sec’, ’Hz/sec’, ’mHz/sec’.
TYPE:
|
truncate |
Allows playing only part of the pulse, truncating the end. If provided, will play only up to the given time in units of the clock cycle (4ns).
TYPE:
|
condition |
Will play the operation only if the condition is true.
TYPE:
|
timestamp_stream |
(Supported from
QOP 2.2) Adding a
TYPE:
|
Note
Arbitrary waveforms cannot be compressed and can only be expanded up to \(2^{24}-1\) clock cycles (67ms). Unexpected output will occur if a duration outside the range is given. See Dynamic pulse duration in the documentation for further information.
Note
When using chrip, it is possible to add a flag "continue_chirp=True" to the play command. When this flag is set, the internal oscillator will continue the chirp even after the play command had ended. See the `chirp documentation chirp documentation for more information.
Example
with program() as prog:
v1 = declare(fixed)
assign(v1, 0.3)
play('pulse1', 'element1')
play('pulse1' * amp(0.5), 'element1')
play('pulse1' * amp(v1), 'element1')
play('pulse1' * amp(0.9, v1, -v1, 0.9), 'element_iq_pair')
time_stream = declare_stream()
# Supported on QOP2.2+
play('pulse1', f'element1', duration=16, timestamp_stream='t1')
play('pulse1', f'element1', duration=16, timestamp_stream=time_stream)
with stream_processing():
stream.buffer(10).save_all('t2')
qm.qua._dsl.pause
¶
Pause the execution of the job until qm.jobs.running_qm_job.RunningQmJob.resume is called.
The quantum machines freezes on its current output state.
qm.qua._dsl.update_frequency
¶
Dynamically update the frequency of the oscillator associated with a given element
.
This changes the frequency from the value defined in the quantum machine configuration.
The behavior of the phase (continuous vs. coherent) is controlled by the keep_phase
parameter and
is discussed in the documentation.
PARAMETER | DESCRIPTION |
---|---|
element |
The element associated with the oscillator whose frequency will be changed
TYPE:
|
new_frequency |
The new frequency value to set in units set
by
TYPE:
|
units |
units of new frequency. Useful when sub-Hz precision is required. Allowed units are "Hz", "mHz", "uHz", "nHz", "pHz"
TYPE:
|
keep_phase |
Determine whether phase will be continuous
through the change (if
TYPE:
|
qm.qua._dsl.update_correction
¶
Updates the correction matrix used to overcome IQ imbalances of the IQ mixer for the next pulses played on the element
Note
Make sure to update the correction after you called update_frequency
Note
Calling update_correction
will also reset the frame of the oscillator associated with the element.
PARAMETER | DESCRIPTION |
---|---|
element |
The element associated with the oscillator whose correction matrix will change
TYPE:
|
c00 |
The top left matrix element
TYPE:
|
c01 |
The top right matrix element
TYPE:
|
c10 |
The bottom left matrix element
TYPE:
|
c11 |
The bottom right matrix element
TYPE:
|
qm.qua._dsl.set_dc_offset
¶
Set the DC offset of an element's input to the given value. This value will remain the DC offset until changed or until the Quantum Machine is closed. The offset value remains until it is changed or the Quantum Machine is closed.
-- Available from QOP 2.0 --
PARAMETER | DESCRIPTION |
---|---|
element |
The element to update its DC offset
TYPE:
|
element_input |
The desired input of the element, can be 'single' for a 'singleInput' element or 'I' or 'Q' for a 'mixInputs' element
TYPE:
|
offset |
The offset to set
TYPE:
|
qm.qua._dsl.measure
¶
Perform a measurement of element
using pulse
based on 'operation' as defined in the 'element'.
An element for which a measurement is applied must have outputs defined in the configuration.
A measurement consists of:
-
playing an operation to the element (identical to a :func:
play
statement) -
waiting for a duration of time defined as the
time_of_flight
in the configuration of the element, and then sampling the returning pulse. The OPX input to be sampled is defined in the configuration of the element. -
Processing the aqcuired data according to a parameter defined in the measure command, including Demodulation, Integration and Time Tagging.
For a more detailed description of the measurement operation, see Measure Statement Features
PARAMETER | DESCRIPTION |
---|---|
pulse |
The name of an
TYPE:
|
element |
name of the element, as defined in the quantum machine configuration. The element must have outputs.
TYPE:
|
stream |
The stream variable which
the raw ADC data will be saved and will appear in result
analysis scope. You can receive the results with
qm.QmJob.result_handles.get("name"). A string name
can also be used. In this case, the name of the result
handle should be suffixed by If !!! Warning:
TYPE:
|
*outputs |
A parameter specifying the processing to be done on the ADC data, there are multiple options available, including demod(), integration() & time_tagging().
TYPE:
|
timestamp_stream |
(Supported from
QOP 2.2) Adding a
TYPE:
|
Example
with program() as prog:
I = declare(fixed)
Q = declare(fixed)
adc_st = declare_stream(adc_trace=True)
# measure by playing 'meas_pulse' to element 'resonator', do not save raw results.
# demodulate data from "out1" port of 'resonator' using 'cos_weights' and store result in I, and also
# demodulate data from "out1" port of 'resonator' using 'sin_weights' and store result in Q
measure('meas_pulse', 'resonator', None, demod.full("cos_weights", I, "out1"), demod.full("sin_weights", Q, "out1"))
# measure by playing 'meas_pulse' to element 'resonator', save raw results to `adc_st`
# demodulate data from 'out1' port of 'resonator' using 'optimized_weights' and store result in I
measure('meas_pulse', 'resonator', adc_st, demod.full("optimized_weights", I, "out1"))
with stream_processing():
adc_st.input1().save_all("raw_adc_stream")
from qm import QuantumMachinesManager
qm = QuantumMachinesManager().open_qm(config)
job = qm.execute(prog)
# ... we wait for the results to be ready...
job.result_handles.wait_for_all_values()
# raw results can be retrieved as follows (here job is a QmJob object:
raw_I_handle = job.result_handles.get("raw_adc_stream")
qm.qua._dsl.align
¶
Align several elements together.
All the elements referenced in elements
will wait for all the others to
finish their currently running statement.
If no arguments are given, the statement will align all the elements used in the program.
PARAMETER | DESCRIPTION |
---|---|
*elements |
a single element, multiple elements, or none
TYPE:
|
qm.qua._dsl.reset_phase
¶
Resets the phase of the oscillator associated with element
, setting the phase of the next pulse to absolute zero.
This sets the phase of the currently playing intermediate frequency to the value it had at the beginning of the program (t=0).
Note
- The phase will only be set to zero when the next play or align command is executed on the element.
- Reset phase will only reset the phase of the intermediate frequency (:math:
\\omega_{IF}
) currently in use.
PARAMETER | DESCRIPTION |
---|---|
element |
an element
TYPE:
|
qm.qua._dsl.ramp_to_zero
¶
Starting from the last DC value, gradually lowers the DC to zero for duration
*4nsec
If duration
is None, the duration is taken from the element's config
Warning
This feature does not protect from voltage jumps. Those can still occur, i.e. when the data sent to the analog output is outside the range -0.5 to \(0.5 - 2^{16}\) and thus will have an overflow.
PARAMETER | DESCRIPTION |
---|---|
element |
element for ramp to zero
TYPE:
|
duration |
time ,
TYPE:
|
qm.qua._dsl.wait
¶
Wait for the given duration on all provided elements without outputting anything. Duration is in units of the clock cycle (4ns)
PARAMETER | DESCRIPTION |
---|---|
duration |
time to wait in units of the clock cycle (4ns). Range: [4, \(2^{31}-1\)] in steps of 1.
TYPE:
|
*elements |
elements to wait on
TYPE:
|
Warning
In case the value of this is outside the range above, unexpected results may occur.
Note
The purpose of the wait
operation is to add latency. In most cases, the
latency added will be exactly the same as that specified by the QUA variable or
the literal used. However, in some cases an additional computational latency may
be added. If the actual wait time has significance, such as in characterization
experiments, the actual wait time should always be verified with a simulator.
qm.qua._dsl.wait_for_trigger
¶
Wait for an external trigger on the provided element.
During the command the OPX will play the pulse supplied by the pulse_to_play
parameter
PARAMETER | DESCRIPTION |
---|---|
element |
element to wait on
TYPE:
|
pulse_to_play |
the name of the pulse to play on the element while waiting for the external trigger. Must be a constant pulse. Default None, no pulse will be played.
TYPE:
|
trigger_element |
Available only with the OPD. The triggered element. See further details in the note.
TYPE:
|
time_tag_target |
Available only with the OPD. The time at which the trigger arrived relative to the waiting start time. In ns.
TYPE:
|
Warning
In the OPX - The maximum allowed voltage value for the digital trigger is 1.8V. A voltage higher than this can damage the controller.
In the OPX+ and with the OPD - The maximum allowed voltage is 3.3V.
Note
Read more about triggering with the OPD here
qm.qua._dsl.save
¶
Stream a QUA variable, a QUA array cell, or a constant scalar.
the variable is streamed and not immediately saved (see Stream processing).
In case result_or_tag
is a string, the data will be immediately saved to a result handle under the same name.
If result variable is used, it can be used in results analysis scope see stream_processing if string tag is used, it will let you receive result with qm.QmJob.result_handles. The type of the variable determines the stream datatype, according to the following rule:
- int -> int64
- fixed -> float64
- bool -> bool
Note
Saving arrays as arrays is not currently supported. Please use a QUA for loop to save an array.
Example
# basic save
a = declare(int, value=2)
save(a, "a")
# fetching the results from python (job is a QmJob object):
a_handle = job.result_handles.get("a")
a_data = a_handle.fetch_all()
# save the third array cell
vec = declare(fixed, value=[0.2, 0.3, 0.4, 0.5])
save(vec[2], "ArrayCellSave")
# array iteration
i = declare(int)
array = declare(fixed, value=[x / 10 for x in range(30)])
with for_(i, 0, i < 30, i + 1):
save(array[i], "array")
# save a constant
save(3, "a")
PARAMETER | DESCRIPTION |
---|---|
var |
A QUA variable or a QUA array cell to save
TYPE:
|
stream_or_tag |
A stream variable or string tag name to save the value under
TYPE:
|
qm.qua._dsl.frame_rotation
¶
Shift the phase of the oscillator associated with an element by the given angle.
This is typically used for virtual z-rotations.
Note
The fixed point format of QUA variables of type fixed is 4.28, meaning the phase
must be between \(-8\) and \(8-2^{28}\). Otherwise the phase value will be invalid.
It is therefore better to use frame_rotation_2pi()
which avoids this issue.
Note
The phase is accumulated with a resolution of 16 bit.
Therefore, N changes to the phase can result in a phase (and amplitude) inaccuracy of about :math:N \cdot 2^{-16}
.
To null out this accumulated error, it is recommended to use reset_frame(el)
from time to time.
PARAMETER | DESCRIPTION |
---|---|
angle |
The angle to add to the current phase (in radians)
TYPE:
|
*elements |
a single element whose oscillator's phase will be shifted. multiple elements can be given, in which case all of their oscillators' phases will be shifted
TYPE:
|
qm.qua._dsl.frame_rotation_2pi
¶
Shift the phase of the oscillator associated with an element by the given angle in units of 2pi radians.
This is typically used for virtual z-rotations.
Note
Unlike the case of frame_rotation(), this method performs the 2-pi radian wrap around of the angle automatically.
Note
The phase is accumulated with a resolution of 16 bit.
Therefore, N changes to the phase can result in a phase inaccuracy of about :math:N \cdot 2^{-16}
.
To null out this accumulated error, it is recommended to use reset_frame(el)
from time to time.
PARAMETER | DESCRIPTION |
---|---|
angle |
The angle to add to the current phase (in \(2\pi\) radians)
TYPE:
|
*elements |
a single element whose oscillator's phase will be shifted. multiple elements can be given, in which case all of their oscillators' phases will be shifted
TYPE:
|
qm.qua._dsl.fast_frame_rotation
¶
Shift the phase of the oscillator associated with an element by applying the rotation matrix [[cosine, -sine],[sin, cosine]].
This is typically used for virtual z-rotations.
-- Available from QOP 2.2 --
Note
The phase is accumulated with a resolution of 16 bit.
Therefore, N changes to the phase can result in a phase (and amplitude) inaccuracy of about :math:N \cdot 2^{-16}
.
To null out this accumulated error, it is recommended to use reset_frame(el)
from time to time.
PARAMETER | DESCRIPTION |
---|---|
cosine |
The main diagonal values of the rotation matrix
TYPE:
|
sine |
The bottom left rotation matrix element and minus the top right rotation matrix element value
TYPE:
|
*elements |
A single element whose oscillator's phase will be shifted. multiple elements can be given, in which case all of their oscillators' phases will be shifted
TYPE:
|
qm.qua._dsl.reset_frame
¶
Resets the frame of the oscillator associated with an element to 0.
Used to reset all of the frame updated made up to this statement.
PARAMETER | DESCRIPTION |
---|---|
*elements |
a single element whose oscillator's phase will be reset. multiple elements can be given, in which case all of their oscillators' phases will be reset
TYPE:
|
qm.qua._dsl.assign
¶
Set the value of a given QUA variable, or of a QUA array cell
PARAMETER | DESCRIPTION |
---|---|
var |
A QUA variable or a QUA array cell for which to assign
TYPE:
|
_exp |
An expression for which to set the variable
TYPE:
|
Example::
qm.qua._dsl.switch_
¶
Part of the switch-case flow control statement in QUA.
To be used with a context manager.
The code block inside should be composed of only case_()
and default_()
statements, and there should be at least one of them.
The expression given in the switch_()
statement will be evaluated and compared
to each of the values in the case_()
statements. The QUA code block following
the case_()
statement which evaluated to true will be executed. If none of the
statements evaluated to true, the QUA code block following the default_()
statement (if given) will be executed.
PARAMETER | DESCRIPTION |
---|---|
expression |
An expression to evaluate
TYPE:
|
unsafe |
If set to True, then switch-case would be more efficient
and would produce less gaps. However, if an input which does
not match a case is given, unexpected behavior will occur.
Cannot be used with the
TYPE:
|
qm.qua._dsl.case_
¶
Part of the switch-case flow control statement in QUA.
To be used with a context manager.
Must be inside a switch_()
statement.
The expression given in the switch_()
statement will be evaluated and compared
to each of the values in the case_()
statements. The QUA code block following
the case_()
statement which evaluated to true will be executed. If none of the
statements evaluated to true, the QUA code block following the default_()
statement (if given) will be executed.
PARAMETER | DESCRIPTION |
---|---|
case_exp |
A value (or expression) to compare to the expression
in the
TYPE:
|
qm.qua._dsl.default_
¶
Part of the switch-case flow control statement in QUA.
To be used with a context manager.
Must be inside a switch_()
statement, and there can only be one default_()
statement.
The expression given in the switch_()
statement will be evaluated and compared
to each of the values in the case_()
statements. The QUA code block following
the case_()
statement which evaulated to true will be executed. If none of the
statements evaluated to true, the QUA code block following the default_()
statement (if given) will be executed.
qm.qua._dsl.if_
¶
If flow control statement in QUA.
To be used with a context manager.
The QUA code block following the statement will be executed only if the expression given evaluates to true.
PARAMETER | DESCRIPTION |
---|---|
expression |
A boolean expression to evaluate
TYPE:
|
qm.qua._dsl.elif_
¶
Else-If flow control statement in QUA.
To be used with a context manager.
Must appear after an if_()
statement.
The QUA code block following the statement will be executed only if the expressions
in the preceding if_()
and elif_()
statements evaluates to false and if the
expression given in this elif_()
evaluates to true.
PARAMETER | DESCRIPTION |
---|---|
expression |
A boolean expression to evaluate
TYPE:
|
qm.qua._dsl.else_
¶
Else flow control statement in QUA.
To be used with a context manager.
Must appear after an if_()
statement.
The QUA code block following the statement will be executed only if the expressions
in the preceding if_()
and elif_()
statements evaluates to false.
qm.qua._dsl.for_each_
¶
Flow control: Iterate over array elements in QUA.
It is possible to either loop over one variable, or over a tuple of variables,
similar to the zip
style iteration in python.
To be used with a context manager.
PARAMETER | DESCRIPTION |
---|---|
var |
The iteration variable
TYPE:
|
values |
A list of values to iterate over or a QUA array.
TYPE:
|
Example
Warning
This behavior is not exactly consistent with python zip
.
Instead of sending a list of tuple as values, the function expects a tuple of
lists.
The first list containing the values for the first variable, and so on.
qm.qua._dsl.while_
¶
While loop flow control statement in QUA.
To be used with a context manager.
PARAMETER | DESCRIPTION |
---|---|
cond |
an expression which evaluates to a boolean variable, determines if to continue to next loop iteration
TYPE:
|
qm.qua._dsl.for_
¶
For loop flow control statement in QUA.
To be used with a context manager.
PARAMETER | DESCRIPTION |
---|---|
var |
QUA variable used as iteration variable
TYPE:
|
init |
an expression which sets the initial value of the iteration variable
TYPE:
|
cond |
an expression which evaluates to a boolean variable, determines if to continue to next loop iteration
TYPE:
|
update |
an expression to add to
TYPE:
|
qm.qua._dsl.infinite_loop_
¶
Infinite loop flow control statement in QUA.
To be used with a context manager.
Optimized for zero latency between iterations, provided that no more than a single element appears in the loop.
Note
In case multiple elements need to be used in an infinite loop, it is possible to add several loops in parallel (see example). Two infinite loops cannot share an element nor can they share variables.
qm.qua._dsl.L
¶
Creates an expression with a literal value
PARAMETER | DESCRIPTION |
---|---|
value |
int, float or bool to wrap in a literal expression
|
qm.qua._dsl.DeclarationType
¶
qm.qua._dsl.declare
¶
Declare a single QUA variable or QUA vector to be used in subsequent expressions and assignments.
Declaration is performed by declaring a python variable with the return value of this function.
PARAMETER | DESCRIPTION |
---|---|
t |
The type of QUA variable. Possible values:
TYPE:
|
value |
An initial value for the variable or a list of initial values for a vector
TYPE:
|
size |
If declaring a vector without explicitly specifying a value, this parameter is used to specify the length of the array
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
QuaVariableType
|
The variable or vector |
Warning
some QUA statements accept a variable with a valid range smaller than the full size of the generic
QUA variable. For example, amp()
accepts numbers between -2 and 2.
In case the value stored in the variable is larger than the valid input range, unexpected results
may occur.
qm.qua._dsl.declare_input_stream
¶
Declare a QUA variable or a QUA vector to be used as an input stream from the job to the QUA program.
Declaration is performed by declaring a python variable with the return value of this function.
Declaration is similar to the normal QUA variable declaration. See declare for available parameters.
See Input streams for more information.
-- Available from QOP 2.0 --
qm.qua._dsl.advance_input_stream
¶
Advances the input stream pointer to the next available variable/vector.
If there is no new data waiting in the stream, this command will wait until it is available.
The variable/vector can then be used as a normal QUA variable.
See Input streams for more information.
-- Available from QOP 2.0 --
qm.qua._dsl.declare_stream
¶
Declare a QUA output stream to be used in subsequent statements To retrieve the result - it must be saved in the stream processing block.
Declaration is performed by declaring a python variable with the return value of this function.
Note
if the stream is an ADC trace, declaring it with the syntax declare_stream(adc_trace=True)
will add a buffer of length corresponding to the pulse length.
RETURNS | DESCRIPTION |
---|---|
A
|
class:
TYPE:
|
_ResultSource
|
qm.qua._dsl.amp
¶
To be used only within a play or measure command, as a multiplication to
the operation
.
It is possible to scale the pulse's amplitude dynamically by using the following syntax:
play('pulse_name' * amp(v), 'element')
where v
is QUA variable of type fixed. Range of v: -2 to \(2 - 2^{-16}\) in steps of \(2^{-16}\).
Moreover, if the pulse is intended to a mixedInputs element and thus is defined with two waveforms, the two waveforms, described as a column vector, can be multiplied by a matrix:
play('pulse_name' * amp(v_00, v_01, v_10, v_11), 'element'),
where v_ij
, i,j={0,1}, are QUA variables of type fixed.
Note that v_ij
should satisfy -2 <= v_ij
<= \(2 - 2{-16}\).
Note that scaling in this manner, rather than in the configuration, might result in a computational overhead. See QUA Best Practice Guide for more information.
PARAMETER | DESCRIPTION |
---|---|
v1 |
If only this variable is given, it is the scaler amplitude
factor which multiples the
TYPE:
|
v2 |
The second element in the amplitude matrix which multiples
the
TYPE:
|
v3 |
The third element in the amplitude matrix which multiples
the
TYPE:
|
v4 |
The forth element in the amplitude matrix which multiples
the
TYPE:
|
qm.qua._dsl.ramp
¶
To be used only within a play
command, instead of the operation
.
It’s possible to generate a voltage ramp by using the ramp(slope)
command.
The slope argument is specified in units of V/ns
. Usage of this feature is as follows:
play(ramp(0.0001),'qe1',duration=1000)
.. note: The pulse duration must be specified if the ramp feature is used.
PARAMETER | DESCRIPTION |
---|---|
v |
The slope in units of
|
qm.qua._dsl.strict_timing_
¶
Any QUA command written within the strict timing block will be required to to play without gaps.
See the documentation for further information and examples.
To be used with a context manager.
-- Available from QOP 2.0 --
qm.qua._dsl.RealAccumulationMethod
¶
A base class for specifying the integration and demodulation processes in the measure
statement.
These are the options which can be used inside the measure command as part of the demod
and integration
processes.
accumulated
¶
Same as sliced()
, however the accumulated result of the demodulation/integration
is saved in each array cell. See Accumulated demodulation.
PARAMETER | DESCRIPTION |
---|---|
iw |
integration weights
TYPE:
|
target |
variable to which demod result is saved
TYPE:
|
samples_per_chunk |
The number of ADC samples to be used for each chunk is this number times 4.
TYPE:
|
element_output |
(optional) the output of an element from which to get ADC results
TYPE:
|
full
¶
Perform an ordinary demodulation/integration. See Full demodulation.
PARAMETER | DESCRIPTION |
---|---|
iw |
integration weights
TYPE:
|
target |
variable to which demod result is saved
TYPE:
|
element_output |
(optional) the output of an element from which to get ADC results
TYPE:
|
moving_window
¶
Same as sliced()
, however the several chunks are accumulated and saved to each array cell.
See Moving window demodulation.
PARAMETER | DESCRIPTION |
---|---|
iw |
integration weights
TYPE:
|
target |
variable to which demod result is saved
TYPE:
|
samples_per_chunk |
The number of ADC samples to be used for each chunk is this number times 4.
TYPE:
|
chunks_per_window |
The number of chunks to use in the moving window
TYPE:
|
element_output |
(optional) the output of an element from which to get ADC results
TYPE:
|
sliced
¶
Perform a demodulation/integration in which the demodulation/integration process is split into chunks and the value of each chunk is saved in an array cell. See Sliced demodulation.
PARAMETER | DESCRIPTION |
---|---|
iw |
integration weights
TYPE:
|
target |
variable to which demod result is saved
TYPE:
|
samples_per_chunk |
The number of ADC samples to be used for each chunk is this number times 4.
TYPE:
|
element_output |
(optional) the output of an element from which to get ADC results
TYPE:
|
qm.qua._dsl.DualAccumulationMethod
¶
A base class for specifying the dual integration and demodulation processes in the :func:measure
statement.
These are the options which can be used inside the measure command as part of the dual_demod
and
dual_integration
processes.
accumulated
¶
This feature is currently not supported in QUA
full
¶
Perform an ordinary dual demodulation/integration. See Dual demodulation.
PARAMETER | DESCRIPTION |
---|---|
iw1 |
integration weights to be applied to element_output1
TYPE:
|
element_output1 |
the output of an element from which to get ADC results
TYPE:
|
iw2 |
integration weights to be applied to element_output2
TYPE:
|
element_output2 |
the output of an element from which to get ADC results
TYPE:
|
target |
variable to which demod result is saved
TYPE:
|
moving_window
¶
This feature is currently not supported in QUA
sliced
¶
This feature is currently not supported in QUA
qm.qua._dsl.TimeTagging
¶
A base class for specifying the time tagging process in the measure statement.
These are the options which can be used inside the measure command as part of the time_tagging
process.
analog
¶
Performs time tagging. See Time tagging.
PARAMETER | DESCRIPTION |
---|---|
target |
The QUA array into which the times of the detected pulses are saved (in ns)
TYPE:
|
max_time |
The time in which pulses are detected (Must be larger than the pulse duration)
TYPE:
|
targetLen |
A QUA int which will get the number of pulses detected
TYPE:
|
element_output |
the output of an element from which to get the pulses
TYPE:
|
digital
¶
Performs time tagging from the attached OPD. See Time tagging.
-- Available with the OPD addon --
PARAMETER | DESCRIPTION |
---|---|
target |
The QUA array into which the times of the detected pulses are saved (in ns)
TYPE:
|
max_time |
The time in which pulses are detected (Must be larger than the pulse duration)
TYPE:
|
targetLen |
A QUA int which will get the number of pulses detected
TYPE:
|
element_output |
the output of an element from which to get the pulses
TYPE:
|
high_res
¶
Performs high resolution time tagging. See Time tagging.
-- Available from QOP 2.0 --
PARAMETER | DESCRIPTION |
---|---|
target |
The QUA array into which the times of the detected pulses are saved (in ps)
TYPE:
|
max_time |
The time in which pulses are detected (Must be larger than the pulse duration)
TYPE:
|
targetLen |
A QUA int which will get the number of pulses detected
TYPE:
|
element_output |
the output of an element from which to get the pulses
TYPE:
|
qm.qua._dsl.Counting
¶
A base class for specifying the counting process in the measure statement.
These are the options which can be used inside the measure command as part of the counting
process.
-- Available with the OPD addon --
digital
¶
Performs counting from the attached OPD. See Time tagging.
-- Available with the OPD addon --
PARAMETER | DESCRIPTION |
---|---|
target |
A QUA int which will get the number of pulses detected
TYPE:
|
max_time |
The time in which pulses are detected (Must be larger than the pulse duration)
TYPE:
|
element_outputs |
the outputs of an element from which to get ADC results
TYPE:
|
qm.qua._dsl.stream_processing
¶
A context manager for the creation of Stream processing pipelines
Each pipeline defines an analysis process that is applied to every stream item. A pipeline must be terminated with a save/save_all terminal, and then can be retrieved with QmJob.result_handles.
There are two save options: save_all
will save every stream item, save
will save only last item.
A pipeline can be assigned to python variable, and then reused on other pipelines. It is ensured that the common part of the pipeline is processed only once.