pyglaze 0.1.0__py3-none-any.whl

pyglaze/device/configuration.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from dataclasses import asdict, dataclass, field
+from typing import TYPE_CHECKING, ClassVar, TypeVar
+
+from .delayunit import validate_delayunit
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+T = TypeVar("T", bound="DeviceConfiguration")
+
+
+@dataclass
+class Interval:
+    """An interval with a lower and upper bounds between 0 and 1 to scan."""
+
+    lower: float
+    upper: float
+
+    @property
+    def length(self: Interval) -> float:
+        """The length of the interval."""
+        return abs(self.upper - self.lower)
+
+    @classmethod
+    def from_dict(cls: type[Interval], d: dict) -> Interval:
+        """Create an instance of the Interval class from a dictionary.
+
+        Args:
+            d (dict): The dictionary containing the interval data.
+
+        Returns:
+            Interval: An instance of the Interval class.
+        """
+        return cls(**d)
+
+    def __post_init__(self: Interval) -> None:  # noqa: D105
+        if not 0.0 <= self.lower <= 1.0:
+            msg = "Interval: Bounds must be between 0 and 1"
+            raise ValueError(msg)
+        if not 0.0 <= self.upper <= 1.0:
+            msg = "Interval: Bounds must be between 0 and 1"
+            raise ValueError(msg)
+        if self.upper == self.lower:
+            msg = "Interval: Bounds cannot be equal"
+            raise ValueError(msg)
+
+
+class DeviceConfiguration(ABC):
+    """Base class for device configurations."""
+
+    amp_timeout_seconds: float
+    amp_port: str
+    amp_baudrate: ClassVar[int]
+
+    @property
+    @abstractmethod
+    def _sweep_length_ms(self: DeviceConfiguration) -> float:
+        """The length of the sweep in milliseconds."""
+
+    @abstractmethod
+    def save(self: DeviceConfiguration, path: Path) -> str:
+        """Save a DeviceConfiguration to a file."""
+
+    @classmethod
+    @abstractmethod
+    def from_dict(cls: type[T], amp_config: dict) -> T:
+        """Create a DeviceConfiguration from a dict."""
+
+    @classmethod
+    @abstractmethod
+    def load(cls: type[T], file_path: Path) -> T:
+        """Load a DeviceConfiguration from a file."""
+
+
+@dataclass
+class ForceDeviceConfiguration(DeviceConfiguration):
+    """Represents a configuration that can be sent to the lock-in amp for scans.
+
+    Args:
+        amp_port: The name of the serial port the amp is connected to.
+        sweep_length_ms: The length of the sweep in milliseconds.
+        delayunit: Name of the delay calculator.
+        scan_intervals: The intervals to scan.
+        integration_periods: The number of integration periods to use.
+        modulation_frequency: The frequency of the modulation in Hz.
+        dac_lower_bound: The lower bound of the modulation voltage in bits.
+        dac_upper_bound: The upper bound of the modulation voltage in bits.
+        min_modulation_voltage: The minimum modulation voltage in volts.
+        max_modulation_voltage: The maximum modulation voltage in volts.
+        modulation_waveform: The waveform to use for modulation.
+        amp_timeout_seconds: The timeout for the amp in seconds.
+    """
+
+    amp_port: str
+    sweep_length_ms: float
+    delayunit: str
+    scan_intervals: list[Interval] = field(default_factory=lambda: [Interval(0.0, 1.0)])
+    integration_periods: int = 100
+    modulation_frequency: int = 10000  # Hz
+    dac_lower_bound: int = 6400
+    dac_upper_bound: int = 59300
+    min_modulation_voltage: float = -1.0  # V
+    max_modulation_voltage: float = 0.5  # V
+    modulation_waveform: str = "square"
+    amp_timeout_seconds: float = 0.05
+
+    amp_baudrate: ClassVar[int] = 1200000  # bit/s
+
+    @property
+    def _sweep_length_ms(self: ForceDeviceConfiguration) -> float:
+        return self.sweep_length_ms
+
+    def __post_init__(self: ForceDeviceConfiguration) -> None:  # noqa: D105
+        validate_delayunit(self.delayunit)
+
+    def save(self: ForceDeviceConfiguration, path: Path) -> str:
+        """Save a DeviceConfiguration to a file.
+
+        Args:
+            path: The path to save the configuration to.
+
+        Returns:
+            str: Final path component of the saved file, without the extension.
+
+        """
+        with path.open("w") as f:
+            json.dump(asdict(self), f, indent=4, sort_keys=True)
+
+        return path.stem
+
+    @classmethod
+    def from_dict(
+        cls: type[ForceDeviceConfiguration], amp_config: dict
+    ) -> ForceDeviceConfiguration:
+        """Create a DeviceConfiguration from a dict.
+
+        Args:
+            amp_config: An amp configuration in dict form.
+
+        Raises:
+            ValueError: If the dictionary is empty.
+
+        Returns:
+            DeviceConfiguration: A DeviceConfiguration object.
+        """
+        return _config_w_intervals_from_dict(cls, amp_config)
+
+    @classmethod
+    def load(
+        cls: type[ForceDeviceConfiguration], file_path: Path
+    ) -> ForceDeviceConfiguration:
+        """Load a DeviceConfiguration from a file.
+
+        Args:
+            file_path: The path to the file to load.
+
+        Returns:
+            DeviceConfiguration: A DeviceConfiguration object.
+        """
+        with file_path.open() as f:
+            configuration_dict = json.load(f)
+        return cls.from_dict(configuration_dict)
+
+
+@dataclass
+class LeDeviceConfiguration(DeviceConfiguration):
+    """Represents a configuration that can be sent to a Le-type lock-in amp for scans.
+
+    Args:
+        amp_port: The name of the serial port the amp is connected to.
+        delayunit: Name of the delay calculator.
+        use_ema: Whether to use en exponentially moving average filter during lockin detection.
+        n_points: The number of points to scan.
+        scan_intervals: The intervals to scan.
+        integration_periods: The number of integration periods per datapoint to use.
+        amp_timeout_seconds: The timeout for the connection to the amp in seconds.
+    """
+
+    amp_port: str
+    delayunit: str
+    use_ema: bool = True
+    n_points: int = 1000
+    scan_intervals: list[Interval] = field(default_factory=lambda: [Interval(0.0, 1.0)])
+    integration_periods: int = 10
+    amp_timeout_seconds: float = 0.2
+
+    modulation_frequency: ClassVar[int] = 10000  # Hz
+    fs_dac_lower_bound: ClassVar[int] = 300
+    fs_dac_upper_bound: ClassVar[int] = 3700
+    amp_baudrate: ClassVar[int] = 1000000  # bit/s
+
+    def __post_init__(self: LeDeviceConfiguration) -> None:  # noqa: D105
+        validate_delayunit(self.delayunit)
+
+    @property
+    def _sweep_length_ms(self: LeDeviceConfiguration) -> float:
+        return self.n_points * self._time_constant_ms
+
+    @property
+    def _time_constant_ms(self: LeDeviceConfiguration) -> float:
+        return 1e3 * self.integration_periods / self.modulation_frequency
+
+    def save(self: LeDeviceConfiguration, path: Path) -> str:
+        """Save a LeDeviceConfiguration to a file.
+
+        Args:
+            path: The path to save the configuration to.
+
+        Returns:
+            str: Final path component of the saved file, without the extension.
+
+        """
+        with path.open("w") as f:
+            json.dump(asdict(self), f, indent=4, sort_keys=True)
+
+        return path.stem
+
+    @classmethod
+    def from_dict(
+        cls: type[LeDeviceConfiguration], amp_config: dict
+    ) -> LeDeviceConfiguration:
+        """Create a LeDeviceConfiguration from a dict.
+
+        Args:
+            amp_config: An amp configuration in dict form.
+
+        Raises:
+            ValueError: If the dictionary is empty.
+
+        Returns:
+            DeviceConfiguration: A DeviceConfiguration object.
+        """
+        return _config_w_intervals_from_dict(cls, amp_config)
+
+    @classmethod
+    def load(
+        cls: type[LeDeviceConfiguration], file_path: Path
+    ) -> LeDeviceConfiguration:
+        """Load a LeDeviceConfiguration from a file.
+
+        Args:
+            file_path: The path to the file to load.
+
+        Returns:
+            DeviceConfiguration: A DeviceConfiguration object.
+        """
+        with file_path.open() as f:
+            configuration_dict = json.load(f)
+        return cls.from_dict(configuration_dict)
+
+
+C = TypeVar("C", LeDeviceConfiguration, ForceDeviceConfiguration)
+
+
+def _config_w_intervals_from_dict(cls: type[C], amp_config: dict) -> C:
+    if amp_config:
+        config = cls(**amp_config)
+        config.scan_intervals = [Interval.from_dict(d) for d in config.scan_intervals]  # type: ignore[arg-type]
+        return config
+
+    msg = "'amp_config' is empty."
+    raise ValueError(msg)

pyglaze/device/delayunit.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import pickle
+from abc import ABC, abstractmethod
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Callable, cast
+from uuid import UUID, uuid4
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from pyglaze.helpers.types import FloatArray
+
+__all__ = ["UniformDelay", "NonuniformDelay", "list_delayunits", "load_delayunit"]
+
+_DELAYUNITS_PATH = Path(__file__).parent / "_delayunit_data"
+
+
+def validate_delayunit(name: str) -> None:
+    delayunits = list_delayunits()
+    if name not in delayunits:
+        msg = f"Unknown delayunit '{name}'. Valid options are: {', '.join(delayunits)}."
+        raise ValueError(msg)
+
+
+def list_delayunits() -> list[str]:
+    """List all available delayunits.
+
+    Returns:
+        A list of all available delayunits.
+
+    """
+    return [delayunit.stem for delayunit in _DELAYUNITS_PATH.iterdir()]
+
+
+def load_delayunit(name: str) -> Delay:
+    """Load a delayunit by name.
+
+    Args:
+        name: The name of the delayunit to load.
+
+    Returns:
+        The loaded delayunit.
+    """
+    try:
+        return _load_delayunit_from_path(_DELAYUNITS_PATH / f"{name}.pickle")
+    except FileNotFoundError as e:
+        msg = f"Unknown delayunit requested ('{name}'). Known units are: {list_delayunits()}"
+        raise NameError(msg) from e
+
+
+def _load_delayunit_from_path(path: Path) -> Delay:
+    with Path(path).open("rb") as f:
+        _dict: dict = pickle.load(f)
+    delay_type = _dict.pop("type")
+    return cast(Delay, globals()[delay_type](**_dict))
+
+
+@dataclass(frozen=True)
+class Delay(ABC):
+    friendly_name: str
+    unique_id: UUID
+    creation_time: datetime
+
+    def __call__(self: Delay, x: FloatArray) -> FloatArray:
+        if np.max(x) > 1.0 or np.min(x) < 0.0:
+            msg = "All values of 'x' must be between 0 and 1."
+            raise ValueError(msg)
+
+        return self._call(x)
+
+    @property
+    def filename(self: Delay) -> str:
+        return f"{self.friendly_name}-{self.creation_time.strftime('%Y-%m-%d')}.pickle"
+
+    @abstractmethod
+    def _call(self: Delay, x: FloatArray) -> FloatArray: ...
+
+    def save(self: Delay, path: Path) -> None:
+        with Path(path).open("wb") as f:
+            pickle.dump({"type": self.__class__.__name__, **asdict(self)}, f)
+
+
+@dataclass(frozen=True)
+class UniformDelay(Delay):
+    """A delay calculator that calculates equidisant delays."""
+
+    time_window: float
+
+    def _call(self: UniformDelay, x: FloatArray) -> FloatArray:
+        return x * self.time_window
+
+    @classmethod
+    def new(cls: type[UniformDelay], time_window: float, friendly_name: str) -> Delay:
+        """Create a new Delay object.
+
+        Args:
+            time_window: The time window for the delay.
+            friendly_name: The friendly name of the delay.
+
+        Returns:
+            Delay: The newly created Delay object.
+        """
+        return cls(
+            friendly_name=friendly_name,
+            unique_id=uuid4(),
+            creation_time=datetime.now(),  # noqa: DTZ005
+            time_window=time_window,
+        )
+
+
+@dataclass(frozen=True)
+class NonuniformDelay(Delay):
+    """A delay calculator that calculates non-equidistant delays."""
+
+    time_window: float
+    residual_interpolator: Callable[[FloatArray], FloatArray]
+
+    def _call(self: NonuniformDelay, x: FloatArray) -> FloatArray:
+        return (
+            x * self.time_window
+            + self.residual_interpolator(x)
+            - self.residual_interpolator(np.asarray(0.0))
+        )
+
+    @classmethod
+    def new(
+        cls: type[NonuniformDelay],
+        friendly_name: str,
+        time_window: float,
+        residual_interpolator: Callable[[FloatArray], FloatArray],
+    ) -> Delay:
+        """Create a new NonuniformDelay object.
+
+        Args:
+            friendly_name: The friendly name of the NonuniformDelay object.
+            time_window: The time window of the pulse.
+            residual_interpolator: a residual interpolator for calculating the nonuniform part of the delay.
+
+        Returns:
+            Delay: The newly created Delay object.
+        """
+        return cls(
+            friendly_name=friendly_name,
+            unique_id=uuid4(),
+            creation_time=datetime.now(),  # noqa: DTZ005
+            time_window=time_window,
+            residual_interpolator=residual_interpolator,
+        )

pyglaze/device/identifiers.py

@@ -0,0 +1,41 @@
+from typing import Literal, get_args
+from uuid import UUID
+
+from typing_extensions import TypeAlias
+
+DeviceName: TypeAlias = Literal["glaze1", "glaze2", "carmen"]
+
+
+def _device_ids() -> dict[DeviceName, UUID]:
+    return {
+        "glaze1": UUID("5042dbda-e9bc-4216-a614-ac56d0a32023"),
+        "glaze2": UUID("66fa482a-1ef4-4076-a883-72d7bf43e151"),
+        "carmen": UUID("6a54db26-fa88-4146-b04f-b84b945bfea8"),
+    }
+
+
+def list_devices() -> list[DeviceName]:
+    """List all available devices.
+
+    Returns:
+        A list of all available devices.
+    """
+    return list(_device_ids().keys())
+
+
+def get_device_id(name: DeviceName) -> UUID:
+    """Get the UUID of a device by its name.
+
+    Args:
+        name: The name of the device.
+
+    Returns:
+        Unique identifier of a device.
+    """
+    try:
+        return _device_ids()[name]
+    except KeyError as e:
+        msg = (
+            f"Device {name} does not exist. Possible values are {get_args(DeviceName)}"
+        )
+        raise ValueError(msg) from e

pyglaze/devtools/__init__.py

@@ -0,0 +1,3 @@
+from .thz_pulse import gaussian_derivative_pulse
+
+__all__ = ["gaussian_derivative_pulse"]