QM driver for 0.2

.envrc

@@ -2,8 +2,8 @@ if ! has nix_direnv_version || ! nix_direnv_version 2.2.1; then
   source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/2.2.1/direnvrc" "sha256-zelF0vLbEl5uaqrfIzbgNzJWGmLzCmYAkInj/LNxvKs="
 fi
 
-nix_direnv_watch_file flake.nix
-nix_direnv_watch_file flake.lock
+watch_file flake.nix
+watch_file flake.lock
 if ! use flake . --impure; then
   echo "devenv could not be built. The devenv environment was not loaded. Make the necessary changes to devenv.nix and hit enter to try again." >&2
 fi

.github/workflows/deploy.yml

@@ -11,8 +11,8 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-13, windows-latest]
-        python-version: [3.9, '3.10', '3.11']
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: [3.9, "3.10", "3.11"]
     uses: qiboteam/workflows/.github/workflows/deploy-pip-poetry.yml@main
     with:
       os: ${{ matrix.os }}

.github/workflows/rules.yml

@@ -11,8 +11,8 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-13, windows-latest]
-        python-version: [3.9, '3.10', '3.11']
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: [3.9, "3.10", "3.11"]
     uses: qiboteam/workflows/.github/workflows/rules-poetry.yml@main
     with:
       os: ${{ matrix.os }}

.github/workflows/rustapi.yml

@@ -9,7 +9,7 @@ jobs:
   tests:
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-13]
+        os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
 
     steps:

README.md

@@ -27,31 +27,36 @@ A simple example on how to connect to a platform and use it execute a pulse sequ
 
 ```python
 from qibolab import create_platform, ExecutionParameters
-from qibolab.pulses import DrivePulse, ReadoutPulse, PulseSequence
+from qibolab.pulses import Pulse, Delay, PulseType
 
 # Define PulseSequence
 sequence = PulseSequence()
 # Add some pulses to the pulse sequence
-sequence.add(
-    DrivePulse(
-        start=0,
+sequence.append(
+    Pulse(
         amplitude=0.3,
         duration=4000,
         frequency=200_000_000,
         relative_phase=0,
         shape="Gaussian(5)",  # Gaussian shape with std = duration / 5
+        type=PulseType.DRIVE,
         channel=1,
     )
 )
-
-sequence.add(
+sequence.append(
+    Delay(
+        duration=4000,
+        channel=2,
+    )
+)
+sequence.append(
     ReadoutPulse(
-        start=4004,
         amplitude=0.9,
         duration=2000,
         frequency=20_000_000,
         relative_phase=0,
         shape="Rectangular",
+        type=PulseType.READOUT,
         channel=2,
     )
 )

doc/source/getting-started/experiment.rst

@@ -102,17 +102,13 @@ And the we can define the runcard ``my_platform/parameters.json``:
                     "frequency": 5500000000,
                     "shape": "Gaussian(3)",
                     "type": "qd",
-                    "start": 0,
-                    "phase": 0
                 },
                 "MZ": {
                     "duration": 2000,
                     "amplitude": 0.02,
                     "frequency": 7370000000,
                     "shape": "Rectangular()",
                     "type": "ro",
-                    "start": 0,
-                    "phase": 0
                 }
             }
         },
@@ -193,8 +189,8 @@ We leave to the dedicated tutorial a full explanation of the experiment, but her
 
     # define the pulse sequence
     sequence = PulseSequence()
-    ro_pulse = platform.create_MZ_pulse(qubit=0, start=0)
-    sequence.add(ro_pulse)
+    ro_pulse = platform.create_MZ_pulse(qubit=0)
+    sequence.append(ro_pulse)
 
     # define a sweeper for a frequency scan
     sweeper = Sweeper(
@@ -215,7 +211,7 @@ We leave to the dedicated tutorial a full explanation of the experiment, but her
     results = platform.sweep(sequence, options, sweeper)
 
     # plot the results
-    amplitudes = results[ro_pulse.serial].magnitude
+    amplitudes = results[ro_pulse.id].magnitude
     frequencies = np.arange(-2e8, +2e8, 1e6) + ro_pulse.frequency
 
     plt.title("Resonator Spectroscopy")

doc/source/main-documentation/qibolab.rst

@@ -61,12 +61,13 @@ Now we can create a simple sequence (again, without explicitly giving any qubit
 
 .. testcode::  python
 
-   from qibolab.pulses import PulseSequence
+   from qibolab.pulses import PulseSequence, Delay
 
    ps = PulseSequence()
-   ps.add(platform.create_RX_pulse(qubit=0, start=0))  # start time is in ns
-   ps.add(platform.create_RX_pulse(qubit=0, start=100))
-   ps.add(platform.create_MZ_pulse(qubit=0, start=200))
+   ps.append(platform.create_RX_pulse(qubit=0))
+   ps.append(platform.create_RX_pulse(qubit=0))
+   ps.append(Delay(duration=200, channel=platform.qubits[0].readout.name))
+   ps.append(platform.create_MZ_pulse(qubit=0))
 
 Now we can execute the sequence on hardware:
 
@@ -126,9 +127,9 @@ will create a dummy platform that also has coupler qubits.
 Emulator platform
 ^^^^^^^^^^^^^^^^^
 
-QiboLab supports the use of emulators to simulate the behavior of quantum devices. It uses :class:`qibolab.instruments.emulator.pulse_simulator.PulseSimulator`, which is a controller that utilizes a simulation engine to numerically solve the dynamics of the device in the presence of control pulse sequences specified by :class:`qibolab.pulses.PulseSequence`. The emulator platform for a specific device requires its own platform folder and can be initialized in the same way as any other real platforms:
+QiboLab supports the use of emulators to simulate the behavior of quantum devices. It uses :class:`qibolab.instruments.emulator.pulse_simulator.PulseSimulator`, which is a controller that utilizes a simulation engine to numerically solve the dynamics of the device in the presence of control pulse sequences specified by :class:`qibolab.pulses.PulseSequence`. The emulator platform for a specific device requires its own platform folder and can be initialized in the same way as any other real platforms::
 
-.. testcode:: python_emulator
+    # .. testcode:: python_emulator
 
     import os
     from pathlib import Path
@@ -275,12 +276,6 @@ Pulses
 In Qibolab, an extensive API is available for working with pulses and pulse sequences, a fundamental aspect of quantum experiments.
 At the heart of this API is the :class:`qibolab.pulses.Pulse` object, which empowers users to define and customize pulses with specific parameters.
 
-The API provides specialized subclasses tailored to the main types of pulses typically used in quantum experiments:
-
-- Readout Pulses (:class:`qibolab.pulses.ReadoutPulse`)
-- Drive Pulses (:class:`qibolab.pulses.DrivePulse`)
-- Flux Pulses (:class:`qibolab.pulses.FluxPulse`)
-
 Each pulse is associated with a channel and a qubit.
 Additionally, pulses are defined by a shape, represented by a subclass of :class:`qibolab.pulses.PulseShape`.
 Qibolab offers a range of pre-defined pulse shapes:
@@ -301,31 +296,29 @@ To illustrate, here are some examples of single pulses using the Qibolab API:
     from qibolab.pulses import Pulse, Rectangular
 
     pulse = Pulse(
-        start=0,  # Timing, always in nanoseconds (ns)
         duration=40,  # Pulse duration in ns
         amplitude=0.5,  # Amplitude relative to instrument range
         frequency=1e8,  # Frequency in Hz
         relative_phase=0,  # Phase in radians
-        shape=Rectangular(),
+        envelope=Rectangular(),
         channel="channel",
         type="qd",  # Enum type: :class:`qibolab.pulses.PulseType`
         qubit=0,
     )
 
 In this way, we defined a rectangular drive pulse using the generic Pulse object.
-Alternatively, you can achieve the same result using the dedicated :class:`qibolab.pulses.DrivePulse` object:
+Alternatively, you can achieve the same result using the dedicated :class:`qibolab.pulses.Pulse` object:
 
 .. testcode:: python
 
-    from qibolab.pulses import DrivePulse, Rectangular
+    from qibolab.pulses import Pulse, Rectangular
 
-    pulse = DrivePulse(
-        start=0,  # timing, in all qibolab, is expressed in ns
-        duration=40,
+    pulse = Pulse(
+        duration=40,  # timing, in all qibolab, is expressed in ns
         amplitude=0.5,  # this amplitude is relative to the range of the instrument
         frequency=1e8,  # frequency are in Hz
         relative_phase=0,  # phases are in radians
-        shape=Rectangular(),
+        envelope=Rectangular(),
         channel="channel",
         qubit=0,
     )
@@ -340,65 +333,58 @@ To organize pulses into sequences, Qibolab provides the :class:`qibolab.pulses.P
 
     sequence = PulseSequence()
 
-    pulse1 = DrivePulse(
-        start=0,  # timing, in all qibolab, is expressed in ns
-        duration=40,
+    pulse1 = Pulse(
+        duration=40,  # timing, in all qibolab, is expressed in ns
         amplitude=0.5,  # this amplitude is relative to the range of the instrument
         frequency=1e8,  # frequency are in Hz
         relative_phase=0,  # phases are in radians
-        shape=Rectangular(),
+        envelope=Rectangular(),
         channel="channel",
         qubit=0,
     )
-    pulse2 = DrivePulse(
-        start=0,  # timing, in all qibolab, is expressed in ns
-        duration=40,
+    pulse2 = Pulse(
+        duration=40,  # timing, in all qibolab, is expressed in ns
         amplitude=0.5,  # this amplitude is relative to the range of the instrument
         frequency=1e8,  # frequency are in Hz
         relative_phase=0,  # phases are in radians
-        shape=Rectangular(),
+        envelope=Rectangular(),
         channel="channel",
         qubit=0,
     )
-    pulse3 = DrivePulse(
-        start=0,  # timing, in all qibolab, is expressed in ns
-        duration=40,
+    pulse3 = Pulse(
+        duration=40,  # timing, in all qibolab, is expressed in ns
         amplitude=0.5,  # this amplitude is relative to the range of the instrument
         frequency=1e8,  # frequency are in Hz
         relative_phase=0,  # phases are in radians
-        shape=Rectangular(),
+        envelope=Rectangular(),
         channel="channel",
         qubit=0,
     )
-    pulse4 = DrivePulse(
-        start=0,  # timing, in all qibolab, is expressed in ns
-        duration=40,
+    pulse4 = Pulse(
+        duration=40,  # timing, in all qibolab, is expressed in ns
         amplitude=0.5,  # this amplitude is relative to the range of the instrument
         frequency=1e8,  # frequency are in Hz
         relative_phase=0,  # phases are in radians
-        shape=Rectangular(),
+        envelope=Rectangular(),
         channel="channel",
         qubit=0,
     )
-    sequence.add(pulse1)
-    sequence.add(pulse2)
-    sequence.add(pulse3)
-    sequence.add(pulse4)
+    sequence.append(pulse1)
+    sequence.append(pulse2)
+    sequence.append(pulse3)
+    sequence.append(pulse4)
 
     print(f"Total duration: {sequence.duration}")
 
     sequence_ch1 = sequence.get_channel_pulses("channel1")  # Selecting pulses on channel 1
-    print(f"We have {sequence_ch1.count} pulses on channel 1.")
+    print(f"We have {len(sequence_ch1)} pulses on channel 1.")
 
 .. testoutput:: python
     :hide:
 
-    Total duration: 40
+    Total duration: 160.0
     We have 0 pulses on channel 1.
 
-.. warning::
-
-    Pulses in PulseSequences are ordered automatically following the start time (and the channel if needed). Not by the definition order.
 
 When conducting experiments on quantum hardware, pulse sequences are vital. Assuming you have already initialized a platform, executing an experiment is as simple as:
 
@@ -416,19 +402,18 @@ Typical experiments may include both pre-defined pulses and new ones:
     from qibolab.pulses import Rectangular
 
     sequence = PulseSequence()
-    sequence.add(platform.create_RX_pulse(0))
-    sequence.add(
-        DrivePulse(
-            start=0,
+    sequence.append(platform.create_RX_pulse(0))
+    sequence.append(
+        Pulse(
             duration=10,
             amplitude=0.5,
             frequency=2500000000,
             relative_phase=0,
-            shape=Rectangular(),
+            envelope=Rectangular(),
             channel="0",
         )
     )
-    sequence.add(platform.create_MZ_pulse(0, start=0))
+    sequence.append(platform.create_MZ_pulse(0))
 
     results = platform.execute_pulse_sequence(sequence, options=options)
 
@@ -500,9 +485,9 @@ A tipical resonator spectroscopy experiment could be defined with:
     from qibolab.sweeper import Parameter, Sweeper, SweeperType
 
     sequence = PulseSequence()
-    sequence.add(platform.create_MZ_pulse(0, start=0))  # readout pulse for qubit 0 at 4 GHz
-    sequence.add(platform.create_MZ_pulse(1, start=0))  # readout pulse for qubit 1 at 5 GHz
-    sequence.add(platform.create_MZ_pulse(2, start=0))  # readout pulse for qubit 2 at 6 GHz
+    sequence.append(platform.create_MZ_pulse(0))  # readout pulse for qubit 0 at 4 GHz
+    sequence.append(platform.create_MZ_pulse(1))  # readout pulse for qubit 1 at 5 GHz
+    sequence.append(platform.create_MZ_pulse(2))  # readout pulse for qubit 2 at 6 GHz
 
     sweeper = Sweeper(
         parameter=Parameter.frequency,
@@ -535,10 +520,15 @@ For example:
 
 .. testcode:: python
 
+    from qibolab.pulses import PulseSequence, Delay
+
     sequence = PulseSequence()
 
-    sequence.add(platform.create_RX_pulse(0))
-    sequence.add(platform.create_MZ_pulse(0, start=sequence[0].finish))
+    sequence.append(platform.create_RX_pulse(0))
+    sequence.append(
+        Delay(duration=sequence.duration, channel=platform.qubits[0].readout.name)
+    )
+    sequence.append(platform.create_MZ_pulse(0))
 
     sweeper_freq = Sweeper(
         parameter=Parameter.frequency,
@@ -631,12 +621,12 @@ Let's now delve into a typical use case for result objects within the qibolab fr
 
 .. testcode:: python
 
-    drive_pulse_1 = platform.create_MZ_pulse(0, start=0)
-    measurement_pulse = platform.create_qubit_readout_pulse(0, start=0)
+    drive_pulse_1 = platform.create_RX_pulse(0)
+    measurement_pulse = platform.create_MZ_pulse(0)
 
     sequence = PulseSequence()
-    sequence.add(drive_pulse_1)
-    sequence.add(measurement_pulse)
+    sequence.append(drive_pulse_1)
+    sequence.append(measurement_pulse)
 
     options = ExecutionParameters(
         nshots=1000,
@@ -709,7 +699,7 @@ If this set is universal any circuit can be transpiled and compiled to a pulse s
 Every :class:`qibolab.qubits.Qubit` object contains a :class:`qibolab.native.SingleQubitNatives` object which holds the parameters of its native single-qubit gates,
 while each :class:`qibolab.qubits.QubitPair` objects contains a :class:`qibolab.native.TwoQubitNatives` object which holds the parameters of the native two-qubit gates acting on the pair.
 
-Each native gate is represented by a :class:`qibolab.native.NativePulse` or :class:`qibolab.native.NativeSequence` which contain all the calibrated parameters and can be converted to an actual :class:`qibolab.pulses.PulseSequence` that is then executed in the platform.
+Each native gate is represented by a :class:`qibolab.pulses.Pulse` or :class:`qibolab.pulses.PulseSequence` which contain all the calibrated parameters.
 Typical single-qubit native gates are the Pauli-X gate, implemented via a pi-pulse which is calibrated using Rabi oscillations and the measurement gate, implemented via a pulse sent in the readout line followed by an acquisition.
 For a universal set of single-qubit gates, the RX90 (pi/2-pulse) gate is required, which is implemented by halving the amplitude of the calibrated pi-pulse.
 U3, the most general single-qubit gate can be implemented using two RX90 pi-pulses and some virtual Z-phases which are included in the phase of later pulses.
@@ -766,7 +756,6 @@ The most important instruments are the controller, the following is a table of t
     "RTS frequency",                "yes","yes","yes","yes"
     "RTS amplitude",                "yes","yes","yes","yes"
     "RTS duration",                 "yes","yes","yes","yes"
-    "RTS start",                    "yes","yes","yes","yes"
     "RTS relative phase",           "yes","yes","yes","yes"
     "RTS 2D any combination",       "yes","yes","yes","yes"
     "Sequence unrolling",           "dev","dev","dev","dev"