Skip to content

qoolqit.devices

devices

Modules:

  • device –
  • unit_converter –

Classes:

  • AnalogDevice –

    A realistic device for analog sequence execution.

  • AnalogDeviceWithDMM –

    A realistic device with DMM for analog sequence execution.

  • Device –

    QoolQit Device wrapper around a Pulser BaseDevice.

  • DigitalAnalogDevice –

    A device with digital and analog capabilities.

  • MockDevice –

    A virtual device for unconstrained prototyping.

Functions:

AnalogDevice()

A realistic device for analog sequence execution.

Methods:

  • from_connection –

    Return the specified device from the selected device from a connection.

  • info –

    Show the device short description and constraints.

  • reset_converter –

    Resets the unit converter to the default one.

  • set_distance_unit –

    Changes the unit converter according to a reference distance unit.

  • set_energy_unit –

    Changes the unit converter according to a reference energy unit.

Attributes:

  • specs (dict[str, float | None]) –

    Return the device specification constraints.

Source code in qoolqit/devices/device.py 
233
234
def __init__(self) -> None:
    super().__init__(pulser_device=pulser.AnalogDevice)

specs: dict[str, float | None] property

Return the device specification constraints.

from_connection(connection: RemoteConnection, name: str) -> Device classmethod

Return the specified device from the selected device from a connection.

Available devices through the provided connection are can be seen with the connection.fetch_available_devices() method.

Parameters:

  • connection
    (RemoteConnection) –

    connection object to fetch the available devices.

  • name
    (str) –

    The name of the desired device.

Returns:

  • Device ( Device ) –

    The requested device.

Raises:

  • ValueError –

    If the requested device is not available through the provided connection.

Example: 

from pulser_pasqal import PasqalCloud
fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")

Source code in qoolqit/devices/device.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@classmethod
def from_connection(cls, connection: RemoteConnection, name: str) -> Device:
    """Return the specified device from the selected device from a connection.

    Available devices through the provided connection are can be seen with
    the `connection.fetch_available_devices()` method.

    Args:
        connection (RemoteConnection): connection object to fetch the available devices.
        name (str): The name of the desired device.

    Returns:
        Device: The requested device.

    Raises:
        ValueError: If the requested device is not available through the provided connection.

    Example:
    ```python
    from pulser_pasqal import PasqalCloud
    fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")
    ```
    """
    available_remote_devices = connection.fetch_available_devices()
    if name not in available_remote_devices:
        raise ValueError(f"Device {name} is not available through the provided connection.")
    pulser_device = available_remote_devices[name]
    return cls(pulser_device=pulser_device)

info() -> None

Show the device short description and constraints.

Source code in qoolqit/devices/device.py 
189
190
191
def info(self) -> None:
    """Show the device short description and constraints."""
    print(self)

reset_converter() -> None

Resets the unit converter to the default one.

Source code in qoolqit/devices/device.py 
120
121
122
123
def reset_converter(self) -> None:
    """Resets the unit converter to the default one."""
    # Create a NEW converter so mutations don't persist.
    self._converter = self._default_converter

set_distance_unit(distance: float) -> None

Changes the unit converter according to a reference distance unit.

Source code in qoolqit/devices/device.py 
129
130
131
def set_distance_unit(self, distance: float) -> None:
    """Changes the unit converter according to a reference distance unit."""
    self.converter.factors = self.converter.factors_from_distance(distance)

set_energy_unit(energy: float) -> None

Changes the unit converter according to a reference energy unit.

Source code in qoolqit/devices/device.py 
125
126
127
def set_energy_unit(self, energy: float) -> None:
    """Changes the unit converter according to a reference energy unit."""
    self.converter.factors = self.converter.factors_from_energy(energy)

AnalogDeviceWithDMM()

A realistic device with DMM for analog sequence execution.

Methods:

  • from_connection –

    Return the specified device from the selected device from a connection.

  • info –

    Show the device short description and constraints.

  • reset_converter –

    Resets the unit converter to the default one.

  • set_distance_unit –

    Changes the unit converter according to a reference distance unit.

  • set_energy_unit –

    Changes the unit converter according to a reference energy unit.

Attributes:

  • specs (dict[str, float | None]) –

    Return the device specification constraints.

Source code in qoolqit/devices/device.py 
240
241
242
243
244
245
246
247
248
249
250
def __init__(self) -> None:
    dmm_channel = pulser.channels.dmm.DMM(
        clock_period=4,
        min_duration=16,
        max_duration=6000,
        mod_bandwidth=8,
        bottom_detuning=-2 * math.pi * 20,
        total_bottom_detuning=-2 * math.pi * 20,
    )
    pulser_device = replace(pulser.AnalogDevice.to_virtual(), dmm_objects=(dmm_channel,))
    super().__init__(pulser_device=pulser_device)

specs: dict[str, float | None] property

Return the device specification constraints.

from_connection(connection: RemoteConnection, name: str) -> Device classmethod

Return the specified device from the selected device from a connection.

Available devices through the provided connection are can be seen with the connection.fetch_available_devices() method.

Parameters:

  • connection
    (RemoteConnection) –

    connection object to fetch the available devices.

  • name
    (str) –

    The name of the desired device.

Returns:

  • Device ( Device ) –

    The requested device.

Raises:

  • ValueError –

    If the requested device is not available through the provided connection.

Example: 

from pulser_pasqal import PasqalCloud
fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")

Source code in qoolqit/devices/device.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@classmethod
def from_connection(cls, connection: RemoteConnection, name: str) -> Device:
    """Return the specified device from the selected device from a connection.

    Available devices through the provided connection are can be seen with
    the `connection.fetch_available_devices()` method.

    Args:
        connection (RemoteConnection): connection object to fetch the available devices.
        name (str): The name of the desired device.

    Returns:
        Device: The requested device.

    Raises:
        ValueError: If the requested device is not available through the provided connection.

    Example:
    ```python
    from pulser_pasqal import PasqalCloud
    fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")
    ```
    """
    available_remote_devices = connection.fetch_available_devices()
    if name not in available_remote_devices:
        raise ValueError(f"Device {name} is not available through the provided connection.")
    pulser_device = available_remote_devices[name]
    return cls(pulser_device=pulser_device)

info() -> None

Show the device short description and constraints.

Source code in qoolqit/devices/device.py 
189
190
191
def info(self) -> None:
    """Show the device short description and constraints."""
    print(self)

reset_converter() -> None

Resets the unit converter to the default one.

Source code in qoolqit/devices/device.py 
120
121
122
123
def reset_converter(self) -> None:
    """Resets the unit converter to the default one."""
    # Create a NEW converter so mutations don't persist.
    self._converter = self._default_converter

set_distance_unit(distance: float) -> None

Changes the unit converter according to a reference distance unit.

Source code in qoolqit/devices/device.py 
129
130
131
def set_distance_unit(self, distance: float) -> None:
    """Changes the unit converter according to a reference distance unit."""
    self.converter.factors = self.converter.factors_from_distance(distance)

set_energy_unit(energy: float) -> None

Changes the unit converter according to a reference energy unit.

Source code in qoolqit/devices/device.py 
125
126
127
def set_energy_unit(self, energy: float) -> None:
    """Changes the unit converter according to a reference energy unit."""
    self.converter.factors = self.converter.factors_from_energy(energy)

Device(pulser_device: BaseDevice, default_converter: Optional[UnitConverter] = None)

QoolQit Device wrapper around a Pulser BaseDevice.

Parameters:

  • pulser_device

    (BaseDevice) –

    a BaseDevice to build the QoolQit device from.

  • default_converter

    (Optional[UnitConverter], default: None ) –

    optional unit converter to handle unit conversion.

Examples:

From Pulser device: 

qoolqit_device = Device(pulser_device=pulser_device)

From remote Pulser device: 

from pulser_pasqal import PasqalCloud
from qoolqit import Device

# Fetch the remote device from the connection
connection = PasqalCloud()
pulser_fresnel_device = connection.fetch_available_devices()["FRESNEL"]

# Wrap a Pulser device object into a QoolQit Device
fresnel_device = Device(pulser_device=PulserFresnelDevice)

From custom Pulser device: 

from dataclasses import replace
from pulser import AnalogDevice
from qoolqit import Device

# Converting the pulser Device object in a VirtualDevice object
VirtualAnalog = AnalogDevice.to_virtual()
# Replacing desired values
ModdedAnalogDevice = replace(
    VirtualAnalog,
    max_radial_distance=100,
    max_sequence_duration=7000
    )

# Wrap a Pulser device object into a QoolQit Device
mod_analog_device = Device(pulser_device=ModdedAnalogDevice)

Returned by: Used by:

Methods:

  • from_connection –

    Return the specified device from the selected device from a connection.

  • info –

    Show the device short description and constraints.

  • reset_converter –

    Resets the unit converter to the default one.

  • set_distance_unit –

    Changes the unit converter according to a reference distance unit.

  • set_energy_unit –

    Changes the unit converter according to a reference energy unit.

Attributes:

  • specs (dict[str, float | None]) –

    Return the device specification constraints.

Source code in qoolqit/devices/device.py 
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
def __init__(
    self,
    pulser_device: BaseDevice,
    default_converter: Optional[UnitConverter] = None,
) -> None:

    if not isinstance(pulser_device, BaseDevice):
        raise TypeError("`pulser_device` must be an instance of Pulser BaseDevice class.")

    # Store it for all subsequent lookups
    self._pulser_device: BaseDevice = pulser_device
    self._name: str = self._pulser_device.name

    # Physical constants / channel & limit lookups (assumes 'rydberg_global' channel)
    self._C6 = self._pulser_device.interaction_coeff
    self._clock_period = self._pulser_device.channels["rydberg_global"].clock_period
    # Relevant limits from the underlying device (float or None)
    self._max_duration = self._pulser_device.max_sequence_duration
    self._max_amp = self._pulser_device.channels["rydberg_global"].max_amp
    self._upper_amp = self._max_amp or 4 * math.pi
    self._max_abs_det = self._pulser_device.channels["rydberg_global"].max_abs_detuning
    self._min_distance = self._pulser_device.min_atom_distance
    self._lower_distance = self._min_distance or 5.0
    self._max_radial_distance = self._pulser_device.max_radial_distance

    # ratio between maximum amplitude and maximum interaction energy J_max = C6/r_min^6
    self._energy_ratio: float = (self._upper_amp * self._lower_distance**6) / self._C6

    # layouts
    self._requires_layout = self._pulser_device.requires_layout

    if default_converter is not None:
        # Snapshot the caller-provided factors so reset() reproduces them exactly.
        t0, e0, d0 = default_converter.factors
        self._default_factory: Callable[[], UnitConverter] = lambda: UnitConverter(
            self._C6, t0, e0, d0
        )
    else:
        self._default_factory = lambda: UnitConverter.from_distance(
            self._C6, self._lower_distance
        )

    self.reset_converter()

specs: dict[str, float | None] property

Return the device specification constraints.

from_connection(connection: RemoteConnection, name: str) -> Device classmethod

Return the specified device from the selected device from a connection.

Available devices through the provided connection are can be seen with the connection.fetch_available_devices() method.

Parameters:

  • connection
    (RemoteConnection) –

    connection object to fetch the available devices.

  • name
    (str) –

    The name of the desired device.

Returns:

  • Device ( Device ) –

    The requested device.

Raises:

  • ValueError –

    If the requested device is not available through the provided connection.

Example: 

from pulser_pasqal import PasqalCloud
fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")

Source code in qoolqit/devices/device.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@classmethod
def from_connection(cls, connection: RemoteConnection, name: str) -> Device:
    """Return the specified device from the selected device from a connection.

    Available devices through the provided connection are can be seen with
    the `connection.fetch_available_devices()` method.

    Args:
        connection (RemoteConnection): connection object to fetch the available devices.
        name (str): The name of the desired device.

    Returns:
        Device: The requested device.

    Raises:
        ValueError: If the requested device is not available through the provided connection.

    Example:
    ```python
    from pulser_pasqal import PasqalCloud
    fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")
    ```
    """
    available_remote_devices = connection.fetch_available_devices()
    if name not in available_remote_devices:
        raise ValueError(f"Device {name} is not available through the provided connection.")
    pulser_device = available_remote_devices[name]
    return cls(pulser_device=pulser_device)

info() -> None

Show the device short description and constraints.

Source code in qoolqit/devices/device.py 
189
190
191
def info(self) -> None:
    """Show the device short description and constraints."""
    print(self)

reset_converter() -> None

Resets the unit converter to the default one.

Source code in qoolqit/devices/device.py 
120
121
122
123
def reset_converter(self) -> None:
    """Resets the unit converter to the default one."""
    # Create a NEW converter so mutations don't persist.
    self._converter = self._default_converter

set_distance_unit(distance: float) -> None

Changes the unit converter according to a reference distance unit.

Source code in qoolqit/devices/device.py 
129
130
131
def set_distance_unit(self, distance: float) -> None:
    """Changes the unit converter according to a reference distance unit."""
    self.converter.factors = self.converter.factors_from_distance(distance)

set_energy_unit(energy: float) -> None

Changes the unit converter according to a reference energy unit.

Source code in qoolqit/devices/device.py 
125
126
127
def set_energy_unit(self, energy: float) -> None:
    """Changes the unit converter according to a reference energy unit."""
    self.converter.factors = self.converter.factors_from_energy(energy)

DigitalAnalogDevice()

A device with digital and analog capabilities.

Methods:

  • from_connection –

    Return the specified device from the selected device from a connection.

  • info –

    Show the device short description and constraints.

  • reset_converter –

    Resets the unit converter to the default one.

  • set_distance_unit –

    Changes the unit converter according to a reference distance unit.

  • set_energy_unit –

    Changes the unit converter according to a reference energy unit.

Attributes:

  • specs (dict[str, float | None]) –

    Return the device specification constraints.

Source code in qoolqit/devices/device.py 
256
257
def __init__(self) -> None:
    super().__init__(pulser_device=pulser.DigitalAnalogDevice)

specs: dict[str, float | None] property

Return the device specification constraints.

from_connection(connection: RemoteConnection, name: str) -> Device classmethod

Return the specified device from the selected device from a connection.

Available devices through the provided connection are can be seen with the connection.fetch_available_devices() method.

Parameters:

  • connection
    (RemoteConnection) –

    connection object to fetch the available devices.

  • name
    (str) –

    The name of the desired device.

Returns:

  • Device ( Device ) –

    The requested device.

Raises:

  • ValueError –

    If the requested device is not available through the provided connection.

Example: 

from pulser_pasqal import PasqalCloud
fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")

Source code in qoolqit/devices/device.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@classmethod
def from_connection(cls, connection: RemoteConnection, name: str) -> Device:
    """Return the specified device from the selected device from a connection.

    Available devices through the provided connection are can be seen with
    the `connection.fetch_available_devices()` method.

    Args:
        connection (RemoteConnection): connection object to fetch the available devices.
        name (str): The name of the desired device.

    Returns:
        Device: The requested device.

    Raises:
        ValueError: If the requested device is not available through the provided connection.

    Example:
    ```python
    from pulser_pasqal import PasqalCloud
    fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")
    ```
    """
    available_remote_devices = connection.fetch_available_devices()
    if name not in available_remote_devices:
        raise ValueError(f"Device {name} is not available through the provided connection.")
    pulser_device = available_remote_devices[name]
    return cls(pulser_device=pulser_device)

info() -> None

Show the device short description and constraints.

Source code in qoolqit/devices/device.py 
189
190
191
def info(self) -> None:
    """Show the device short description and constraints."""
    print(self)

reset_converter() -> None

Resets the unit converter to the default one.

Source code in qoolqit/devices/device.py 
120
121
122
123
def reset_converter(self) -> None:
    """Resets the unit converter to the default one."""
    # Create a NEW converter so mutations don't persist.
    self._converter = self._default_converter

set_distance_unit(distance: float) -> None

Changes the unit converter according to a reference distance unit.

Source code in qoolqit/devices/device.py 
129
130
131
def set_distance_unit(self, distance: float) -> None:
    """Changes the unit converter according to a reference distance unit."""
    self.converter.factors = self.converter.factors_from_distance(distance)

set_energy_unit(energy: float) -> None

Changes the unit converter according to a reference energy unit.

Source code in qoolqit/devices/device.py 
125
126
127
def set_energy_unit(self, energy: float) -> None:
    """Changes the unit converter according to a reference energy unit."""
    self.converter.factors = self.converter.factors_from_energy(energy)

MockDevice()

A virtual device for unconstrained prototyping.

Methods:

  • from_connection –

    Return the specified device from the selected device from a connection.

  • info –

    Show the device short description and constraints.

  • reset_converter –

    Resets the unit converter to the default one.

  • set_distance_unit –

    Changes the unit converter according to a reference distance unit.

  • set_energy_unit –

    Changes the unit converter according to a reference energy unit.

Attributes:

  • specs (dict[str, float | None]) –

    Return the device specification constraints.

Source code in qoolqit/devices/device.py 
226
227
def __init__(self) -> None:
    super().__init__(pulser_device=pulser.MockDevice)

specs: dict[str, float | None] property

Return the device specification constraints.

from_connection(connection: RemoteConnection, name: str) -> Device classmethod

Return the specified device from the selected device from a connection.

Available devices through the provided connection are can be seen with the connection.fetch_available_devices() method.

Parameters:

  • connection
    (RemoteConnection) –

    connection object to fetch the available devices.

  • name
    (str) –

    The name of the desired device.

Returns:

  • Device ( Device ) –

    The requested device.

Raises:

  • ValueError –

    If the requested device is not available through the provided connection.

Example: 

from pulser_pasqal import PasqalCloud
fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")

Source code in qoolqit/devices/device.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
@classmethod
def from_connection(cls, connection: RemoteConnection, name: str) -> Device:
    """Return the specified device from the selected device from a connection.

    Available devices through the provided connection are can be seen with
    the `connection.fetch_available_devices()` method.

    Args:
        connection (RemoteConnection): connection object to fetch the available devices.
        name (str): The name of the desired device.

    Returns:
        Device: The requested device.

    Raises:
        ValueError: If the requested device is not available through the provided connection.

    Example:
    ```python
    from pulser_pasqal import PasqalCloud
    fresnel_device = Device.from_connection(connection=PasqalCloud(), name="FRESNEL")
    ```
    """
    available_remote_devices = connection.fetch_available_devices()
    if name not in available_remote_devices:
        raise ValueError(f"Device {name} is not available through the provided connection.")
    pulser_device = available_remote_devices[name]
    return cls(pulser_device=pulser_device)

info() -> None

Show the device short description and constraints.

Source code in qoolqit/devices/device.py 
189
190
191
def info(self) -> None:
    """Show the device short description and constraints."""
    print(self)

reset_converter() -> None

Resets the unit converter to the default one.

Source code in qoolqit/devices/device.py 
120
121
122
123
def reset_converter(self) -> None:
    """Resets the unit converter to the default one."""
    # Create a NEW converter so mutations don't persist.
    self._converter = self._default_converter

set_distance_unit(distance: float) -> None

Changes the unit converter according to a reference distance unit.

Source code in qoolqit/devices/device.py 
129
130
131
def set_distance_unit(self, distance: float) -> None:
    """Changes the unit converter according to a reference distance unit."""
    self.converter.factors = self.converter.factors_from_distance(distance)

set_energy_unit(energy: float) -> None

Changes the unit converter according to a reference energy unit.

Source code in qoolqit/devices/device.py 
125
126
127
def set_energy_unit(self, energy: float) -> None:
    """Changes the unit converter according to a reference energy unit."""
    self.converter.factors = self.converter.factors_from_energy(energy)

available_default_devices() -> None

Show the default available devices in QooQit.

Source code in qoolqit/devices/device.py 
260
261
262
263
def available_default_devices() -> None:
    """Show the default available devices in QooQit."""
    for dev in (AnalogDevice(), AnalogDeviceWithDMM(), DigitalAnalogDevice(), MockDevice()):
        dev.info()