quantify_scheduler.operations.pulse_library

Standard pulses for use with the quantify_scheduler.

Module Contents

Classes

ShiftClockPhase	An operation that shifts the phase of a clock by a specified amount.
IdlePulse	The IdlePulse Operation is a placeholder for a specified duration of time.
RampPulse	The RampPulse Operation is a real-valued pulse that ramps from the specified offset
StaircasePulse	A real valued staircase pulse, which reaches it's final amplitude in discrete
SquarePulse	The SquarePulse Operation is a real-valued pulse with the specified
SuddenNetZeroPulse	The sudden net-zero (SNZ) pulse from Neg\^ırneac et al. [2021].
SoftSquarePulse	The SoftSquarePulse Operation is a real valued square pulse convolved with
ChirpPulse	A linear chirp signal. A sinusoidal signal that ramps up in frequency.
DRAGPulse	DRAG pulse intended for single qubit gates in transmon based systems.
WindowOperation	The WindowOperation is an operation for visualization purposes.
NumericalPulse	Defines a pulse where the shape is determined by specifying an array of (complex)

Functions

decompose_long_square_pulse(→ list)	Generates a list of square pulses equivalent to a (very) long square pulse.
create_dc_compensation_pulse(→ SquarePulse)	Calculates a SquarePulse to counteract charging effects based on a list of pulses.
_extract_pulses(→ List[Dict[str, Any]])

class ShiftClockPhase(phase: float, clock: str, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

An operation that shifts the phase of a clock by a specified amount.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class IdlePulse(duration: float, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

The IdlePulse Operation is a placeholder for a specified duration of time.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class RampPulse(amp: float, duration: float, port: str, offset: float = 0, clock: str = BasebandClockResource.IDENTITY, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

The RampPulse Operation is a real-valued pulse that ramps from the specified offset to the specified amplitude + offset during the duration of the pulse.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class StaircasePulse(start_amp: float, final_amp: float, num_steps: int, duration: float, port: str, clock: str = BasebandClockResource.IDENTITY, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

A real valued staircase pulse, which reaches it’s final amplitude in discrete steps. In between it will maintain a plateau.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class SquarePulse(amp: float, duration: float, port: str, clock: str = BasebandClockResource.IDENTITY, phase: float = 0, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

The SquarePulse Operation is a real-valued pulse with the specified amplitude during the pulse.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class SuddenNetZeroPulse(amp_A: float, amp_B: float, net_zero_A_scale: float, t_pulse: float, t_phi: float, t_integral_correction: float, port: str, clock: str = BasebandClockResource.IDENTITY, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

The sudden net-zero (SNZ) pulse from Neg\^ırneac et al. [2021].

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

decompose_long_square_pulse(duration: float, duration_max: float, single_duration: bool = False, **kwargs) → list

Generates a list of square pulses equivalent to a (very) long square pulse.

Intended to be used for waveform-memory-limited devices. Effectively, only two square pulses, at most, will be needed: a main one of duration duration_max and a second one for potential mismatch between N duration_max and overall duration.

Parameters

• duration – Duration of the long pulse in seconds.

• duration_max – Maximum duration of square pulses to be generated in seconds.

• single_duration – If True, only square pulses of duration duration_max will be generated. If False, a square pulse of duration < duration_max might be generated if necessary.

• **kwargs – Other keyword arguments to be passed to the SquarePulse.

Returns

A list of :class`SquarePulse` s equivalent to the desired long pulse.

class SoftSquarePulse(amp: float, duration: float, port: str, clock: str, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

The SoftSquarePulse Operation is a real valued square pulse convolved with a Hann window for smoothing.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class ChirpPulse(amp: float, duration: float, port: str, clock: str, start_freq: float, end_freq: float, t0: float = 0)

Bases: quantify_scheduler.Operation

A linear chirp signal. A sinusoidal signal that ramps up in frequency.

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class DRAGPulse(G_amp: float, D_amp: float, phase: float, clock: str, duration: float, port: str, t0: float = 0, data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

DRAG pulse intended for single qubit gates in transmon based systems.

A DRAG pulse is a gaussian pulse with a derivative component added to the out-of-phase channel to reduce unwanted excitations of the \(|1\rangle - |2\rangle\) transition (Motzoi et al. [2009] and Gambetta et al. [2011]).

The waveform is generated using waveforms.drag() .

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

create_dc_compensation_pulse(pulses: List[quantify_scheduler.Operation], sampling_rate: float, port: str, t0: float = 0, amp: Optional[float] = None, duration: Optional[float] = None, data: Optional[Dict[str, Any]] = None) → SquarePulse

Calculates a SquarePulse to counteract charging effects based on a list of pulses.

The compensation is calculated by summing the area of all pulses on the specified port. This gives a first order approximation for the pulse required to compensate the charging. All modulated pulses ignored in the calculation.

Parameters

• pulses – List of pulses to compensate

• sampling_rate – Resolution to calculate the enclosure of the pulses to calculate the area to compensate.

• amp – Desired amplitude of the DCCompensationPulse. Leave to None to calculate the value for compensation, in this case you must assign a value to duration. The sign of the amplitude is ignored and adjusted automatically to perform the compensation.

• duration – Desired pulse duration in seconds. Leave to None to calculate the value for compensation, in this case you must assign a value to amp. The sign of the value of amp given in the previous step is adjusted to perform the compensation.

• port – Port to perform the compensation. Any pulse that does not belong to the specified port is ignored.

• clock – Clock used to modulate the pulse.

• phase – Phase of the pulse in degrees.

• t0 – Time in seconds when to start the pulses relative to the start time of the Operation in the Schedule.

• data – The operation’s dictionary, by default None Note: if the data parameter is not None all other parameters are overwritten using the contents of data.

Returns

Returns a SquarePulse object that compensates all pulses passed as argument.

_extract_pulses(pulses: List[quantify_scheduler.Operation], port: str) → List[Dict[str, Any]]

class WindowOperation(window_name: str, duration: float, t0: float = 0.0, data: Optional[Dict[str, Any]] = None)

Bases: quantify_scheduler.Operation

The WindowOperation is an operation for visualization purposes.

The WindowOperation has a starting time and duration.

property window_name → str

Return the window name of this operation

__str__() → str

Returns a concise string representation which can be evaluated into a new instance using eval(str(operation)) only when the data dictionary has not been modified.

This representation is guaranteed to be unique.

class NumericalPulse(samples: Union[numpy.ndarray, list], t_samples: Union[numpy.ndarray, list], port: str, clock: str, t0: float = 0, interpolation: str = 'linear', data: Optional[dict] = None)

Bases: quantify_scheduler.Operation

Defines a pulse where the shape is determined by specifying an array of (complex) points. If points are required between the specified samples (such as could be required by the sampling rate of the hardware), meaning \(t[n] < t' < t[n+1]\), scipy.interpolate.interp1d will be used to interpolate between the two points and determine the value.

__str__() → str

Provides a string representation of the Pulse.