pyglaze 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyglaze/interpolation/interpolation.py

@@ -1,6 +1,9 @@
+from typing import cast
+
 import numpy as np
+from scipy.interpolate import CubicSpline
 
-from pyglaze.helpers.types import FloatArray
+from pyglaze.helpers._types import FloatArray
 
 
 def ws_interpolate(
@@ -21,4 +24,21 @@ def ws_interpolate(
     # times must be zero-centered for formula to work
     sinc = np.sinc((interp_times[:, np.newaxis] - times[0] - dt * _range) / dt)
 
-    return np.asarray(np.sum(pulse * sinc, axis=1))
+    return cast("FloatArray", np.sum(pulse * sinc, axis=1))
+
+
+def cubic_spline_interpolate(
+    times: FloatArray, pulse: FloatArray, interp_times: FloatArray
+) -> FloatArray:
+    """Performs cubic spline interpolation at the supplied times given a pulse.
+
+    Args:
+        times: Sampling times
+        pulse: A sampled pulse satisfying the Nyquist criterion
+        interp_times: Array of times at which to interpolate
+
+    Returns:
+        FloatArray: Interpolated values
+    """
+    spline = CubicSpline(times, pulse, bc_type="natural")
+    return cast("FloatArray", spline(interp_times))

pyglaze/scanning/_asyncscanner.py

@@ -6,7 +6,7 @@ from multiprocessing import Event, Pipe, Process, Queue, synchronize
 from queue import Empty, Full
 from typing import TYPE_CHECKING
 
-from serial import serialutil
+from serial import SerialException, serialutil
 
 from pyglaze.datamodels.waveform import UnprocessedWaveform, _TimestampedWaveform
 from pyglaze.scanning.scanner import Scanner
@@ -25,6 +25,12 @@ class _ScannerHealth:
     error: Exception | None
 
 
+@dataclass
+class _ScannerMetadata:
+    serial_number: str
+    firmware_version: str
+
+
 @dataclass
 class _AsyncScanner:
     """Used by GlazeClient to starts a scanner in a new process and read scans from shared memory."""
@@ -34,6 +40,7 @@ class _AsyncScanner:
     logger: logging.Logger | None = None
     is_scanning: bool = False
     _child_process: Process = field(init=False)
+    _metadata: _ScannerMetadata = field(init=False)
     _shared_mem: Queue[_TimestampedWaveform] = field(init=False)
     _SCAN_TIMEOUT: float = field(init=False)
     _stop_signal: synchronize.Event = field(init=False)
@@ -72,6 +79,10 @@ class _AsyncScanner:
                 self.logger.error(str(msg.error))
             raise msg.error
 
+        # As part of startup, metadata is sent from scanner
+        metadata: _ScannerMetadata = self._scanner_conn.recv()
+        self._metadata = metadata
+
     def stop_scan(self: _AsyncScanner) -> None:
         self._stop_signal.set()
         self._child_process.join()
@@ -87,10 +98,21 @@ class _AsyncScanner:
 
         return [self._get_scan().waveform for _ in range(n_pulses)]
 
-    def get_next(self: _AsyncScanner, averaged_over_n: int = 1) -> UnprocessedWaveform:
-        return UnprocessedWaveform.average(
-            [self._get_scan().waveform for _ in range(averaged_over_n)]
-        )
+    def get_next(self: _AsyncScanner) -> UnprocessedWaveform:
+        return self._get_scan().waveform
+
+    def get_serial_number(self: _AsyncScanner) -> str:
+        if not self.is_scanning:
+            msg = "Scanner not connected"
+            raise SerialException(msg)
+        return self._metadata.serial_number
+
+    def get_firmware_version(self: _AsyncScanner) -> str:
+        if not self.is_scanning:
+            msg = "Scanner not connected"
+            raise SerialException(msg)
+
+        return self._metadata.firmware_version
 
     def _get_scan(self: _AsyncScanner) -> _TimestampedWaveform:
         try:
@@ -115,7 +137,12 @@ class _AsyncScanner:
     ) -> None:
         try:
             scanner = Scanner(config=config)
+            device_metadata = _ScannerMetadata(
+                serial_number=scanner.get_serial_number(),
+                firmware_version=scanner.get_firmware_version(),
+            )
             parent_conn.send(_ScannerHealth(is_alive=True, is_healthy=True, error=None))
+            parent_conn.send(device_metadata)
         except (serialutil.SerialException, TimeoutError) as e:
             parent_conn.send(_ScannerHealth(is_alive=False, is_healthy=False, error=e))
             return

pyglaze/scanning/client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
-from serial import serialutil
+from serial import SerialException, serialutil
 from typing_extensions import Self
 
 from ._asyncscanner import _AsyncScanner
@@ -57,3 +57,19 @@ class GlazeClient:
             n_pulses: The number of terahertz pulses to read from the CCS server.
         """
         return self._scanner.get_scans(n_pulses)
+
+    def get_serial_number(self: GlazeClient) -> str:
+        """Get the serial number of the connected device."""
+        try:
+            return self._scanner.get_serial_number()
+        except AttributeError as e:
+            msg = "No connection to device."
+            raise SerialException(msg) from e
+
+    def get_firmware_version(self: GlazeClient) -> str:
+        """Get the firmware version of the connected device."""
+        try:
+            return self._scanner.get_firmware_version()
+        except AttributeError as e:
+            msg = "No connection to device."
+            raise SerialException(msg) from e

pyglaze/scanning/scanner.py

@@ -4,19 +4,14 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Generic, TypeVar
 
 import numpy as np
-from serial import SerialException
 
 from pyglaze.datamodels import UnprocessedWaveform
-from pyglaze.device.ampcom import _ForceAmpCom, _LeAmpCom
-from pyglaze.device.configuration import (
-    DeviceConfiguration,
-    ForceDeviceConfiguration,
-    LeDeviceConfiguration,
-)
+from pyglaze.device.ampcom import _LeAmpCom
+from pyglaze.device.configuration import DeviceConfiguration, LeDeviceConfiguration
 from pyglaze.scanning._exceptions import ScanError
 
 if TYPE_CHECKING:
-    from pyglaze.helpers.types import FloatArray
+    from pyglaze.helpers._types import FloatArray
 
 TConfig = TypeVar("TConfig", bound=DeviceConfiguration)
 
@@ -48,6 +43,14 @@ class _ScannerImplementation(ABC, Generic[TConfig]):
     def disconnect(self: _ScannerImplementation) -> None:
         pass
 
+    @abstractmethod
+    def get_serial_number(self: _ScannerImplementation) -> str:
+        pass
+
+    @abstractmethod
+    def get_firmware_version(self: _ScannerImplementation) -> str:
+        pass
+
 
 class Scanner:
     """A synchronous scanner for Glaze terahertz devices."""
@@ -86,92 +89,21 @@ class Scanner:
         """Close serial connection."""
         self._scanner_impl.disconnect()
 
-
-class ForceScanner(_ScannerImplementation[ForceDeviceConfiguration]):
-    """Perform synchronous terahertz scanning using a given DeviceConfiguration.
-
-    Args:
-        config: A DeviceConfiguration to use for the scan.
-
-    """
-
-    def __init__(self: ForceScanner, config: ForceDeviceConfiguration) -> None:
-        self._config: ForceDeviceConfiguration
-        self._ampcom: _ForceAmpCom | None = None
-        self.config = config
-        self._phase_estimator = _LockinPhaseEstimator()
-
-    @property
-    def config(self: ForceScanner) -> ForceDeviceConfiguration:
-        """The device configuration to use for the scan.
+    def get_serial_number(self: Scanner) -> str:
+        """Get the serial number of the connected device.
 
         Returns:
-            DeviceConfiguration: a DeviceConfiguration.
+            str: The serial number of the connected device.
         """
-        return self._config
+        return self._scanner_impl.get_serial_number()
 
-    @config.setter
-    def config(self: ForceScanner, new_config: ForceDeviceConfiguration) -> None:
-        amp = _ForceAmpCom(new_config)
-        if getattr(self, "_config", None):
-            if (
-                self._config.integration_periods != new_config.integration_periods
-                or self._config.modulation_frequency != new_config.modulation_frequency
-            ):
-                amp.write_period_and_frequency()
-            if self._config.sweep_length_ms != new_config.sweep_length_ms:
-                amp.write_sweep_length()
-            if self._config.modulation_waveform != new_config.modulation_waveform:
-                amp.write_waveform()
-            if (
-                self._config.min_modulation_voltage != new_config.min_modulation_voltage
-                or self._config.max_modulation_voltage
-                != new_config.max_modulation_voltage
-            ):
-                amp.write_modulation_voltage()
-            if self._config.scan_intervals != new_config.scan_intervals:
-                amp.write_list()
-        else:
-            amp.write_all()
-
-        self._config = new_config
-        self._ampcom = amp
-
-    def scan(self: ForceScanner) -> UnprocessedWaveform:
-        """Perform a scan.
+    def get_firmware_version(self: Scanner) -> str:
+        """Get the firmware version of the connected device.
 
         Returns:
-            Unprocessed scan.
+            str: The firmware version of the connected device.
         """
-        if self._ampcom is None:
-            msg = "Scanner not configured"
-            raise ScanError(msg)
-        _, responses = self._ampcom.start_scan()
-
-        time = responses[:, 0]
-        radius = responses[:, 1]
-        theta = responses[:, 2]
-        self._phase_estimator.update_estimate(radius=radius, theta=theta)
-
-        return UnprocessedWaveform.from_polar_coords(
-            time, radius, theta, self._phase_estimator.phase_estimate
-        )
-
-    def update_config(self: ForceScanner, new_config: ForceDeviceConfiguration) -> None:
-        """Update the DeviceConfiguration used in the scan.
-
-        Args:
-            new_config: A DeviceConfiguration to use for the scan.
-        """
-        self.config = new_config
-
-    def disconnect(self: ForceScanner) -> None:
-        """Close serial connection."""
-        if self._ampcom is None:
-            msg = "Scanner not connected"
-            raise SerialException(msg)
-        self._ampcom.disconnect()
-        self._ampcom = None
+        return self._scanner_impl.get_firmware_version()
 
 
 class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
@@ -245,10 +177,30 @@ class LeScanner(_ScannerImplementation[LeDeviceConfiguration]):
         self._ampcom.disconnect()
         self._ampcom = None
 
+    def get_serial_number(self: LeScanner) -> str:
+        """Get the serial number of the connected device.
+
+        Returns:
+            str: The serial number of the connected device.
+        """
+        if self._ampcom is None:
+            msg = "Scanner not connected"
+            raise ScanError(msg)
+        return self._ampcom.get_serial_number()
+
+    def get_firmware_version(self: LeScanner) -> str:
+        """Get the firmware version of the connected device.
+
+        Returns:
+            str: The firmware version of the connected device.
+        """
+        if self._ampcom is None:
+            msg = "Scanner not connected"
+            raise ScanError(msg)
+        return self._ampcom.get_firmware_version()
+
 
 def _scanner_factory(config: DeviceConfiguration) -> _ScannerImplementation:
-    if isinstance(config, ForceDeviceConfiguration):
-        return ForceScanner(config)
     if isinstance(config, LeDeviceConfiguration):
         return LeScanner(config)
 
@@ -258,10 +210,13 @@ def _scanner_factory(config: DeviceConfiguration) -> _ScannerImplementation:
 
 class _LockinPhaseEstimator:
     def __init__(
-        self: _LockinPhaseEstimator, r_threshold_for_update: float = 2.0
+        self: _LockinPhaseEstimator,
+        r_threshold_for_update: float = 2.0,
+        theta_threshold_for_adjustment: float = 1.0,
     ) -> None:
-        self.phase_estimate: float | None = None
         self.r_threshold_for_update = r_threshold_for_update
+        self.theta_threshold_for_adjustment = theta_threshold_for_adjustment
+        self.phase_estimate: float | None = None
         self._radius_of_est: float | None = None
 
     def update_estimate(
@@ -274,7 +229,11 @@ class _LockinPhaseEstimator:
             self._set_estimates(theta_at_max, r_max)
             return
 
-        if r_max > self.r_threshold_for_update * self._radius_of_est:
+        if r_max > self.r_threshold_for_update * self._radius_of_est or (
+            r_max > self._radius_of_est
+            and abs(theta_at_max - self.phase_estimate)
+            < self.theta_threshold_for_adjustment
+        ):
             self._set_estimates(theta_at_max, r_max)
 
     def _set_estimates(

{pyglaze-0.2.2.dist-info → pyglaze-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pyglaze
-Version: 0.2.2
+Version: 0.4.0
 Summary: Pyglaze is a library used to operate the devices of Glaze Technologies
 Author: GLAZE Technologies ApS
 License: BSD 3-Clause License
@@ -38,11 +38,12 @@ Project-URL: Issues, https://github.com/GlazeTech/pyglaze/issues
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy <2.0.0,>=1.26.4
-Requires-Dist: pyserial >=3.5
-Requires-Dist: scipy >=1.7.3
-Requires-Dist: bitstring >=4.1.2
-Requires-Dist: typing-extensions >=4.12.2
+Requires-Dist: numpy<2.0.0,>=1.26.4
+Requires-Dist: pyserial>=3.5
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: bitstring>=4.1.2
+Requires-Dist: typing_extensions>=4.12.2
+Dynamic: license-file
 
 # Pyglaze
 Pyglaze is a python library used to operate the devices of [Glaze Technologies](https://www.glazetech.dk/).

pyglaze-0.4.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+pyglaze/__init__.py,sha256=42STGor_9nKYXumfeV5tiyD_M8VdcddX7CEexmibPBk,22
+pyglaze/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyglaze/datamodels/__init__.py,sha256=DJLByl2C7pC4RM4Uh6PW-McM5RIGBjcopzGywCKhSlI,111
+pyglaze/datamodels/pulse.py,sha256=ygC9Vfdn7ULzu-JndtODuEwmD8cDXnlOoEcliwJPsxg,22565
+pyglaze/datamodels/waveform.py,sha256=T0wV7saJNPowwQs518VLypul-p1bg_1REPTflw8UNzM,5810
+pyglaze/device/__init__.py,sha256=rxF1h54dHTwq5JVvLjxDeirY4njMfr8c9qs0yJ5GRhE,119
+pyglaze/device/ampcom.py,sha256=ecnkrMI1wFatTvPQjlZ5LTG2xkrTLIVkOw1hU_Hojso,10714
+pyglaze/device/configuration.py,sha256=YmIOWY-K1ixSWZgrpEElE7zBVr4EbFWtPIZ0sRn4RpU,4899
+pyglaze/devtools/__init__.py,sha256=9EW20idoaZv_5GuSgDmfpTPjfCZ-Rl27EV3oJebmwnQ,90
+pyglaze/devtools/mock_device.py,sha256=B-CF5ZG1GZ5P_6LwtURbx9lysbm-nCgtRl43FBJCg6k,9880
+pyglaze/devtools/thz_pulse.py,sha256=WUAz3QTdw_ak0yVyU1zzABrqyCzWhUFRUHP5K_i3ppU,963
+pyglaze/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyglaze/helpers/_types.py,sha256=p9xSAP5Trr1FcCWl7ynCWqDOUZKgMQYzMUXSwDpAKHg,599
+pyglaze/helpers/utilities.py,sha256=FkY-jLi62JxsfS6KFCMhzZ9OO34b4nx7-m2ebPqrCy4,2436
+pyglaze/interpolation/__init__.py,sha256=BZU-mIAO7XxrPGG7tsUks-ghbylOaIANJGIYrtF5Y_Y,126
+pyglaze/interpolation/interpolation.py,sha256=x2hgS9jiQ359Ho7klaBec1L-eXZpFe0NVluTksuPLLA,1345
+pyglaze/scanning/__init__.py,sha256=uCBaeDTufOrC9KWf30ICqcmvFg_YT85olb3M9jkvZRg,99
+pyglaze/scanning/_asyncscanner.py,sha256=cS-XOGWaFsYJ5ShkchyHQo8HtPCADGEGnf-isHx_JL0,6183
+pyglaze/scanning/_exceptions.py,sha256=vS28Dijj76jVuF6cSDBKqM9SQIa9rbIyUaHF-RA3PyM,213
+pyglaze/scanning/client.py,sha256=xgsZLRFVe_rcLQD7AIcztKZ_wY6mp3v4ID3Zq40SbP0,2459
+pyglaze/scanning/scanner.py,sha256=69Bawx3m6toHH3bhHSRduVN527-aeveFI9l6WcaKWs8,7712
+pyglaze-0.4.0.dist-info/licenses/LICENSE,sha256=LCP3sGBX7LxuQopcjeug1fW4tngWCHF4zB7QCgB28xM,1504
+pyglaze-0.4.0.dist-info/METADATA,sha256=SIF4aktj9-ogBuAb9AraranYA5POn6O4aVhlKUnz01w,3515
+pyglaze-0.4.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pyglaze-0.4.0.dist-info/top_level.txt,sha256=X7d5rqVVuWNmtK4-Uh4sgOLlqye8vaHZOr5RYba0REo,8
+pyglaze-0.4.0.dist-info/RECORD,,

{pyglaze-0.2.2.dist-info → pyglaze-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyglaze-0.2.2.dist-info/RECORD

@@ -1,26 +0,0 @@
-pyglaze/__init__.py,sha256=m6kyaNpwBcP1XYcqrelX2oS3PJuOnElOcRdBa9pEb8c,22
-pyglaze/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyglaze/datamodels/__init__.py,sha256=DJLByl2C7pC4RM4Uh6PW-McM5RIGBjcopzGywCKhSlI,111
-pyglaze/datamodels/pulse.py,sha256=BoW_GDvkwEpn_UYUFPoUfi5E_oCnvv8cU4nZKG7Ph2U,20911
-pyglaze/datamodels/waveform.py,sha256=n31DhJHFeBNZ3hHqQUiCGXssm5Dc8wV6tGPkhmFYB4Q,5809
-pyglaze/device/__init__.py,sha256=5RjCHuFKMi9g2KLUkxixO9hNpAgkUBcOURNTuhAdoUk,177
-pyglaze/device/ampcom.py,sha256=9smeYg5-3accfYWRg3K2wg1tGfirnWmPxPa4IYSvyRI,17465
-pyglaze/device/configuration.py,sha256=gh_eerX8TdXx3LnFxHieJqOpfDfE9cV6Xgm5WYVnvO0,7994
-pyglaze/devtools/__init__.py,sha256=9EW20idoaZv_5GuSgDmfpTPjfCZ-Rl27EV3oJebmwnQ,90
-pyglaze/devtools/mock_device.py,sha256=Fz0ZCRIslokBz6gFEztv1-V1UJhdTDqujl7-l8seX7U,14394
-pyglaze/devtools/thz_pulse.py,sha256=xp-T9psdOrUMtSUFu8HEwQJVu_aMixJdZHtg_BCVu_k,923
-pyglaze/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyglaze/helpers/types.py,sha256=p9xSAP5Trr1FcCWl7ynCWqDOUZKgMQYzMUXSwDpAKHg,599
-pyglaze/helpers/utilities.py,sha256=n_x9Tqm305MUorS29O6CoJM8Mi4apo2bsN_odrRaVAw,2423
-pyglaze/interpolation/__init__.py,sha256=WCxHPsiI7zvJykp-jfytoEbO4Tla-YIF6A7fjDfcDvU,72
-pyglaze/interpolation/interpolation.py,sha256=rQWzPD7W8TXETps7VZI0gcfAOCWO8pGL1HhhBnyxaMw,735
-pyglaze/scanning/__init__.py,sha256=uCBaeDTufOrC9KWf30ICqcmvFg_YT85olb3M9jkvZRg,99
-pyglaze/scanning/_asyncscanner.py,sha256=blnpdKBieSrUyTqmm1wZtBqp7X66WE-sFae_PpimFNU,5314
-pyglaze/scanning/_exceptions.py,sha256=vS28Dijj76jVuF6cSDBKqM9SQIa9rbIyUaHF-RA3PyM,213
-pyglaze/scanning/client.py,sha256=3qrQStkeLQzCeu4yMHJ_ENLGQ7E5GMc4CP9J55rk-ug,1817
-pyglaze/scanning/scanner.py,sha256=5KYVUboK4f8DWp-qRHWbvdtQ0x46AIdnCkquAO4vQOI,9205
-pyglaze-0.2.2.dist-info/LICENSE,sha256=LCP3sGBX7LxuQopcjeug1fW4tngWCHF4zB7QCgB28xM,1504
-pyglaze-0.2.2.dist-info/METADATA,sha256=fZcMCJSLAWa1ZrZDV6CPQ0jdGjhQLt5jBJ9srEgYjQM,3498
-pyglaze-0.2.2.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-pyglaze-0.2.2.dist-info/top_level.txt,sha256=X7d5rqVVuWNmtK4-Uh4sgOLlqye8vaHZOr5RYba0REo,8
-pyglaze-0.2.2.dist-info/RECORD,,