qibosoq.components package

Helper objects.

Submodules

qibosoq.components.base module

Various helper objects.

class qibosoq.components.base.Config(repetition_duration: int = 100, adc_trig_offset: int = 200, reps: int = 1000, soft_avgs: int = 1, average: bool = True)

Bases: object

General RFSoC Configuration.

repetition_duration: int = 100

Time to wait between shots (us).

adc_trig_offset: int = 200

Time to wait between readout pulse and acquisition (ADC clock ticks).

reps: int = 1000

Number of shots.

soft_avgs: int = 1

Number of software averages.

average: bool = True

Returns integrated results if true.

class qibosoq.components.base.OperationCode(value)

Bases: IntEnum

Available operations.

EXECUTE_PULSE_SEQUENCE = 1

EXECUTE_PULSE_SEQUENCE_RAW = 2

EXECUTE_SWEEPS = 3

class qibosoq.components.base.Qubit(bias: float | None = None, dac: int | None = None)

Bases: object

Qubit object, storing flux information.

bias: float | None = None

Amplitude factor, for sweetspot.

dac: int | None = None

DAC responsible for flux control.

class qibosoq.components.base.Parameter(value)

Bases: str, Enum

Available parameters for sweepers.

FREQUENCY = 'freq'

AMPLITUDE = 'gain'

RELATIVE_PHASE = 'phase'

DELAY = 't'

BIAS = 'bias'

DURATION = 'duration'

classmethod variants(parameters: str) → Parameter

classmethod variants(parameters: Iterable[str]) → Iterable[Parameter]

Convert from strings to Parameters.

class qibosoq.components.base.Sweeper(expts: int, parameters: List[Parameter], indexes: List[int], starts: ndarray[Any, dtype[float64]], stops: ndarray[Any, dtype[float64]])

Bases: object

Sweeper object.

expts: int

Number of points of the sweeper.

parameters: List[Parameter]

List of parameter to update.

indexes: List[int]

Index of the parameter to sweep relative to list of pulses or list of qubits.

starts: ndarray[Any, dtype[float64]]

Start value for each parameter to sweep.

stops: ndarray[Any, dtype[float64]]

Stop value for each parameter to sweep.

property serialized: dict

Convert a Sweeper object into a dictionary.

In particular, takes care of the convertion arrays -> lists.

qibosoq.components.pulses module

Pulses objects.

class qibosoq.components.pulses.Pulse(frequency: float, amplitude: float, relative_phase: int, start_delay: float, duration: float, name: str, type: str, dac: int, adc: int)

Bases: object

Abstract Pulse object.

frequency: float

Frequency of the pulse (MHz).

amplitude: float

Amplitude factor, multiplied by maximum gain of the DAC.

relative_phase: int

Relative phase (degrees).

start_delay: float

Delay before pulse is triggered (us).

duration: float

Duration of the pulse (us).

name: str

Name of the pulse, typically a serial.

type: str

Can be ‘readout’, ‘drive’, ‘flux’.

dac: int

DAC responsible for firing the pulse.

adc: int

ADC to acquire pulse back, for readout pulses.

class qibosoq.components.pulses.Rectangular(frequency: float, amplitude: float, relative_phase: int, start_delay: float, duration: float, name: str, type: str, dac: int, adc: int, shape: str = 'rectangular')

Bases: Pulse

Rectangular pulse.

shape: str = 'rectangular'

class qibosoq.components.pulses.Gaussian(frequency: float, amplitude: float, relative_phase: int, start_delay: float, duration: float, name: str, type: str, dac: int, adc: int, rel_sigma: float, shape: str = 'gaussian')

Bases: Pulse

Gaussian pulse.

rel_sigma: float

Sigma of the gaussian as a fraction of duration.

shape: str = 'gaussian'

class qibosoq.components.pulses.Drag(frequency: float, amplitude: float, relative_phase: int, start_delay: float, duration: float, name: str, type: str, dac: int, adc: int, rel_sigma: float, beta: float, shape: str = 'drag')

Bases: Pulse

Drag pulse.

rel_sigma: float

Sigma of the drag as a fraction of duration.

beta: float

Beta parameter for drag pulse.

shape: str = 'drag'

class qibosoq.components.pulses.FluxExponential(frequency: float, amplitude: float, relative_phase: int, start_delay: float, duration: float, name: str, type: str, dac: int, adc: int, tau: float, upsilon: float, weight: float, shape: str = 'fluxexponential')

Bases: Pulse

Flux pulse with exponential rising edge to correct distortions.

tau: float

upsilon: float

weight: float

shape: str = 'fluxexponential'

i_values(duration: int, max_gain: int)

Compute the waveform i values.

class qibosoq.components.pulses.Arbitrary(frequency: float, amplitude: float, relative_phase: int, start_delay: float, duration: float, name: str, type: str, dac: int, adc: int, i_values: List[float], q_values: List[float], shape: str = 'arbitrary')

Bases: Pulse

Custom pulse.

i_values: List[float]

q_values: List[float]

shape: str = 'arbitrary'

class qibosoq.components.pulses.Shape(value)

Bases: Enum

Map shape names to the corresponding objects.

RECTANGULAR = <class 'qibosoq.components.pulses.Rectangular'>

GAUSSIAN = <class 'qibosoq.components.pulses.Gaussian'>

DRAG = <class 'qibosoq.components.pulses.Drag'>

ARBITRARY = <class 'qibosoq.components.pulses.Arbitrary'>

FLUXEXPONENTIAL = <class 'qibosoq.components.pulses.FluxExponential'>