Result Stream¶

qm.qua._dsl._ResultStream¶

`qm.qua._dsl._ResultStream` ¶

`add` ¶

Allows addition between streams. The addition is done element-wise. Can also be performed on buffers and other operators, but they must have the same dimensions.

Example

i = declare(int)
j = declare(int)
k = declare(int, value=5)
stream = declare_stream()
stream2 = declare_stream()
stream3 = declare_stream()
with for_(j, 0, j < 30, j + 1):
    with for_(i, 0, i < 10, i + 1):
        save(i, stream)
        save(j, stream2)
        save(k, stream3)

with stream_processing():
    (stream1 + stream2 + stream3).save_all("example1")
    (stream1.buffer(10) + stream2.buffer(10) + stream3.buffer(10)).save_all("example2")
    (stream1 + stream2 + stream3).buffer(10).average().save("example3")

`average` ¶

Perform a running average on a stream item. The Output of this operation is the running average of the values in the stream starting from the beginning of the QUA program.

`boolean_to_int` ¶

converts boolean to an integer number - 1 for true and 0 for false

`buffer` ¶

Gather items into vectors - creates an array of input stream items and outputs the array as one item. only outputs full buffers.

Note

The order of resulting dimensions is different when using a buffer with multiple inputs compared to using multiple buffers. The following two lines are equivalent:

stream.buffer(n, l, k)
stream.buffer(k).buffer(l).buffer(n)

PARAMETER	DESCRIPTION
`*args`	number of items to gather, can either be a single number, which gives the results as a 1d array or multiple numbers for a multidimensional array. DEFAULT: `()`

`buffer_and_skip` ¶

Gather items into vectors - creates an array of input stream items and outputs the array as one item. Skips the number of given elements. Note that length and skip start from the same index, so the buffer(n) command is equivalent to buffer_and_skip(n, n).

Only outputs full buffers.

Example

# The stream input is [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
with stream_processing():
    stream.buffer(3).save_all("example1")
    stream.buffer_and_skip(3, 3).save_all("example2")
    stream.buffer_and_skip(3, 2).save_all("example3")
    stream.buffer_and_skip(3, 5).save_all("example4")
# example1 -> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# example2 -> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# example3 -> [[1, 2, 3], [3, 4, 5], [5, 6, 7], [7, 8, 9]]
# example4 -> [[1, 2, 3], [6, 7, 8]]

Args: length: number of items to gather skip: number of items to skip for each buffer, starting from the same index as length

`convolution` ¶

Computes discrete, linear convolution of one-dimensional constant vector and one-dimensional vector item of the input stream.

PARAMETER	DESCRIPTION
`constant_vector`	vector of numbers TYPE: `PyNumberArrayType`
`mode`	"full", "same" or "valid" TYPE: `Optional[str]` DEFAULT: `None`

`divide` ¶

Allows division between streams. The division is done element-wise. Can also be performed on buffers and other operators, but they must have the same dimensions.

Example

i = declare(int)
j = declare(int)
k = declare(int, value=5)
stream = declare_stream()
stream2 = declare_stream()
stream3 = declare_stream()
with for_(j, 0, j < 30, j + 1):
    with for_(i, 0, i < 10, i + 1):
        save(i, stream)
        save(j, stream2)
        save(k, stream3)

with stream_processing():
    (stream1 / stream2 / stream3).save_all("example1")
    (stream1.buffer(10) / stream2.buffer(10) / stream3.buffer(10)).save_all("example2")
    (stream1 / stream2 / stream3).buffer(10).average().save("example3")

`dot_product` ¶

Computes dot product of the given vector and each item of the input stream

PARAMETER	DESCRIPTION
`vector`	constant vector of numbers TYPE: `PyNumberArrayType`

`fft` ¶

Computes one-dimensional discrete fourier transform for every item in the stream. Item can be a vector of numbers, in this case fft will assume all imaginary numbers are 0. Item can also be a vector of number pairs - in this case for each pair - the first will be real and second imaginary.

PARAMETER DESCRIPTION

output

supported from QOP 1.30 and QOP 2.0, options are "normal", "abs" and "angle":

"normal" - Same as default (none), returns a 2d array of size Nx2, where N is the length of the original vector. The first item in each pair is the real part, and the 2nd is the imaginary part.
"abs" - Returns a 1d array of size N with the abs of the fft.
"angle" - Returns the angle between the imaginary and real parts in radians.

TYPE: Optional[str] DEFAULT: None

RETURNS	DESCRIPTION
`_ResultStream`	stream object

`flatten` ¶

Deconstruct an array item - and send its elements one by one as items

`histogram` ¶

Compute the histogram of all items in stream

PARAMETER	DESCRIPTION
`bins`	vector or pairs. each pair indicates the edge of each bin. example: [[1,10],[11,20]] - two bins, one between 1 and 10, second between 11 and 20 TYPE: `List[List[PyNumberType]]`

`map` ¶

Transform the item by applying a function to it

PARAMETER	DESCRIPTION
`function`	a function to transform each item to a different item. For example, to compute an average between elements in a buffer you should write ".buffer(len).map(FUNCTIONS.average())" TYPE: `CommandsType`

`multiply` ¶

Allows multiplication between streams. The multiplication is done element-wise. Can also be performed on buffers and other operators, but they must have the same dimensions.

Example

i = declare(int)
j = declare(int)
k = declare(int, value=5)
stream = declare_stream()
stream2 = declare_stream()
stream3 = declare_stream()
with for_(j, 0, j < 30, j + 1):
    with for_(i, 0, i < 10, i + 1):
        save(i, stream)
        save(j, stream2)
        save(k, stream3)

with stream_processing():
    (stream1 * stream2 * stream3).save_all("example1")
    (stream1.buffer(10) * stream2.buffer(10) * stream3.buffer(10)).save_all("example2")
    (stream1 * stream2 * stream3).buffer(10).average().save("example3")

`multiply_by` ¶

Multiply the input stream item by a constant scalar or vector. The input item can be either scalar or vector.

PARAMETER	DESCRIPTION
`scalar_or_vector`	either a scalar number, or a vector of scalars. TYPE: `OneOrMore[PyNumberType]`

`save` ¶

Save only the last item received in stream

PARAMETER	DESCRIPTION
`tag`	result name TYPE: `str`

`save_all` ¶

Save all items received in stream.

PARAMETER	DESCRIPTION
`tag`	result name TYPE: `str`

`skip` ¶

Suppress the first n items of the stream

PARAMETER	DESCRIPTION
`length`	number of items to skip TYPE: `PyNumberType`

`skip_last` ¶

Suppress the last n items of the stream

PARAMETER	DESCRIPTION
`length`	number of items to skip TYPE: `PyNumberType`

`subtract` ¶

Allows subtraction between streams. The subtraction is done element-wise. Can also be performed on buffers and other operators, but they must have the same dimensions.

Example

i = declare(int)
j = declare(int)
k = declare(int, value=5)
stream = declare_stream()
stream2 = declare_stream()
stream3 = declare_stream()
with for_(j, 0, j < 30, j + 1):
    with for_(i, 0, i < 10, i + 1):
        save(i, stream)
        save(j, stream2)
        save(k, stream3)

with stream_processing():
    (stream1 - stream2 - stream3).save_all("example1")
    (stream1.buffer(10) - stream2.buffer(10) - stream3.buffer(10)).save_all("example2")
    (stream1 - stream2 - stream3).buffer(10).average().save("example3")

`take` ¶

Outputs only the first n items of the stream

PARAMETER	DESCRIPTION
`length`	number of items to take TYPE: `PyNumberType`

`tuple_convolution` ¶

Computes discrete, linear convolution of two one-dimensional vectors that received as the one item from the input stream

PARAMETER	DESCRIPTION
`mode`	"full", "same" or "valid" TYPE: `Optional[str]` DEFAULT: `None`

`tuple_dot_product` ¶

Computes dot product of the given item of the input stream - that should include two vectors

`tuple_multiply` ¶

Computes multiplication of the given item of the input stream - that can be any combination of scalar and vectors.

`zip` ¶

Combine the emissions of two streams to one item that is a tuple of items of input streams

PARAMETER	DESCRIPTION
`other`	second stream to combine with self TYPE: `_ResultStream`

qm.qua._dsl._Functions¶

`qm.qua._dsl._Functions` ¶

`average` `staticmethod` ¶

Perform a running average on a stream item. The Output of this operation is the running average of the values in the stream starting from the beginning of the QUA program.

PARAMETER	DESCRIPTION
`axis`	optional Axis or axes along which to average. TYPE: `OneOrMore[PyNumberType]` DEFAULT: `None`

RETURNS	DESCRIPTION
`CommandsType`	stream object

`boolean_to_int` `staticmethod` ¶

Converts boolean to integer number - 1 for true and 0 for false

RETURNS	DESCRIPTION
`CommandsType`	stream object

`convolution` `staticmethod` ¶

Computes discrete, linear convolution of one-dimensional constant vector and one-dimensional vector item of the input stream.

PARAMETER	DESCRIPTION
`constant_vector`	vector of numbers TYPE: `PyNumberArrayType`
`mode`	"full", "same" or "valid" TYPE: `Optional[str]` DEFAULT: `None`

RETURNS	DESCRIPTION
`CommandsType`	stream object

`demod` `staticmethod` ¶

Demodulates the acquired data from the indicated stream at the given frequency and integration weights. If operating on a stream of tuples, assumes that the 2nd item is the timestamps and uses them for the demodulation, reproducing the demodulation performed in real time. If operated on a single stream, assumes that the first item is at time zero and that the elements are separated by 1ns.

PARAMETER	DESCRIPTION
`frequency`	frequency for demodulation calculation TYPE: `PyNumberType`
`iw_cos`	cosine integration weight. Integration weight can be either a scalar for constant integration weight, or a python iterable for arbitrary integration weights. TYPE: `PyNumberType`
`iw_sin`	sine integration weight. Integration weight can be either a scalar for constant integration weight, or a python iterable for arbitrary integration weights. TYPE: `PyNumberType`
`integrate`	sum the demodulation result and returns a scalar if True (default), else the demodulated stream without summation is returned TYPE: `Optional[bool]` DEFAULT: `None`

RETURNS	DESCRIPTION
	stream object

Example

with stream_processing():
    adc_stream.input1().with_timestamps().map(FUNCTIONS.demod(freq, 1.0, 0.0, integrate=False)).average().save('cos_env')
    adc_stream.input1().with_timestamps().map(FUNCTIONS.demod(freq, 1.0, 0.0)).average().save('cos_result')  # Default is integrate=True

Note

The demodulation in the stream processing does not take in consideration any real-time modifications to the frame, phase or frequency of the element. If the program has any QUA command that changes them, the result of the stream processing demodulation will be invalid.

`dot_product` `staticmethod` ¶

Computes dot product of the given vector and an item of the input stream

PARAMETER	DESCRIPTION
`vector`	constant vector of numbers TYPE: `PyNumberArrayType`

RETURNS	DESCRIPTION
`CommandsType`	stream object

`fft` `staticmethod` ¶

Computes one-dimensional discrete fourier transform for every item in the stream. Item can be a vector of numbers, in this case fft will assume all imaginary numbers are 0. Item can also be a vector of number pairs - in this case for each pair - the first will be real and second imaginary.

PARAMETER DESCRIPTION

output

supported from QOP 1.30 and QOP 2.0, options are "normal", "abs" and "angle":

"normal" - Same as default (none), returns a 2d array of size Nx2, where N is the length of the original vector. The first item in each pair is the real part, and the 2nd is the imaginary part.
"abs" - Returns a 1d array of size N with the abs of the fft.
"angle" - Returns the angle between the imaginary and real parts in radians.

TYPE: Optional[str] DEFAULT: None

RETURNS	DESCRIPTION
`CommandsType`	stream object

`multiply_by` `staticmethod` ¶

Multiply the input stream item by a constant scalar or vector. the input item can be either scalar or vector.

PARAMETER	DESCRIPTION
`scalar_or_vector`	either a scalar number, or a vector of scalars. TYPE: `OneOrMore[PyNumberType]`

RETURNS	DESCRIPTION
`CommandsType`	stream object

`tuple_convolution` `staticmethod` ¶

Computes discrete, linear convolution of two one-dimensional vectors of the input stream

PARAMETER	DESCRIPTION
`mode`	"full", "same" or "valid" TYPE: `Optional[str]` DEFAULT: `None`

RETURNS	DESCRIPTION
`CommandsType`	stream object

`tuple_dot_product` `staticmethod` ¶

Computes dot product between the two vectors of the input stream

RETURNS	DESCRIPTION
`CommandsType`	stream object

`tuple_multiply` `staticmethod` ¶

Computes multiplication between the two elements of the input stream. Can be any combination of scalar and vectors.

RETURNS	DESCRIPTION
`CommandsType`	stream object

qm.qua._dsl._ResultSource¶

`qm.qua._dsl._ResultSource` ¶

A python object representing a source of values that can be processed in a stream_processing() pipeline

This interface is chainable, which means that calling most methods on this object will create a new streaming source

See the base class _ResultStream for operations

`auto_reshape` ¶

Creates a buffer with dimensions according to the program structure in QUA.

For example, when running the following program the result "reshaped" will have shape of (30,10):

Example

i = declare(int)
j = declare(int)
stream = declare_stream()
with for_(i, 0, i < 30, i + 1):
    with for_(j, 0, j < 10, j + 1):
        save(i, stream)

with stream_processing():
    stream.auto_reshape().save_all("reshaped")

`input1` ¶

A stream of raw ADC data from input 1. Only relevant when saving data from measure statement.

`input2` ¶

A stream of raw ADC data from input 2. Only relevant when saving data from measure statement.

`timestamps` ¶

Get a stream with only the timestamps of the stream-items

`with_timestamps` ¶

Get a stream with the relevant timestamp for each stream-item

Result Stream¶

qm.qua._dsl._ResultStream¶

qm.qua._dsl._ResultStream ¶

add ¶

average ¶

boolean_to_int ¶

buffer ¶

buffer_and_skip ¶

convolution ¶

divide ¶

dot_product ¶

fft ¶

flatten ¶

histogram ¶

map ¶

multiply ¶

multiply_by ¶

save ¶

save_all ¶

skip ¶

skip_last ¶

subtract ¶

take ¶

tuple_convolution ¶

tuple_dot_product ¶

tuple_multiply ¶

zip ¶

qm.qua._dsl._Functions¶

qm.qua._dsl._Functions ¶

average staticmethod ¶

boolean_to_int staticmethod ¶

convolution staticmethod ¶

demod staticmethod ¶

dot_product staticmethod ¶

fft staticmethod ¶

multiply_by staticmethod ¶

tuple_convolution staticmethod ¶

tuple_dot_product staticmethod ¶

tuple_multiply staticmethod ¶

qm.qua._dsl._ResultSource¶

qm.qua._dsl._ResultSource ¶

auto_reshape ¶

input1 ¶

input2 ¶

timestamps ¶

with_timestamps ¶

`qm.qua._dsl._ResultStream` ¶

`add` ¶

`average` ¶

`boolean_to_int` ¶

`buffer` ¶

`buffer_and_skip` ¶

`convolution` ¶

`divide` ¶

`dot_product` ¶

`fft` ¶

`flatten` ¶

`histogram` ¶

`map` ¶

`multiply` ¶

`multiply_by` ¶

`save` ¶

`save_all` ¶

`skip` ¶

`skip_last` ¶

`subtract` ¶

`take` ¶

`tuple_convolution` ¶

`tuple_dot_product` ¶

`tuple_multiply` ¶

`zip` ¶

`qm.qua._dsl._Functions` ¶

`average` `staticmethod` ¶

`boolean_to_int` `staticmethod` ¶

`convolution` `staticmethod` ¶

`demod` `staticmethod` ¶

`dot_product` `staticmethod` ¶

`fft` `staticmethod` ¶

`multiply_by` `staticmethod` ¶

`tuple_convolution` `staticmethod` ¶

`tuple_dot_product` `staticmethod` ¶

`tuple_multiply` `staticmethod` ¶

`qm.qua._dsl._ResultSource` ¶

`auto_reshape` ¶

`input1` ¶

`input2` ¶

`timestamps` ¶

`with_timestamps` ¶