dls-dodal 1.51.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

dodal/devices/p60/enums.py

@@ -0,0 +1,10 @@
+from ophyd_async.core import StrictEnum
+
+
+class LensMode(StrictEnum):
+    TRANSMISSION = "Transmission"
+    ANGULAR14 = "Angular14"
+    ANGULAR7NF = "Angular7NF"
+    ANGULAR30 = "Angular30"
+    ANGULAR30_SMALLSPOT = "Angular30_SmallSpot"
+    ANGULAR14_SMALLSPOT = "Angular14_SmallSpot"

dodal/devices/tetramm.py

@@ -1,12 +1,16 @@
 import asyncio
+from collections.abc import Sequence
+from typing import Annotated as A
 
-from bluesky.protocols import Hints
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
     DatasetDescriber,
     DetectorController,
     DetectorTrigger,
-    Device,
     PathProvider,
+    SignalR,
+    SignalRW,
     StandardDetector,
     StrictEnum,
     TriggerInfo,
@@ -15,15 +19,12 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.adcore import (
     ADHDFWriter,
+    NDArrayBaseIO,
     NDFileHDFIO,
     NDPluginBaseIO,
     stop_busy_record,
 )
-from ophyd_async.epics.core import (
-    epics_signal_r,
-    epics_signal_rw,
-    epics_signal_rw_rbv,
-)
+from ophyd_async.epics.core import PvSuffix
 
 
 class TetrammRange(StrictEnum):
@@ -54,208 +55,191 @@ class TetrammGeometry(StrictEnum):
     SQUARE = "Square"
 
 
-class TetrammDriver(Device):
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
-        self._prefix = prefix
-        self.range = epics_signal_rw_rbv(TetrammRange, prefix + "Range")
-        self.sample_time = epics_signal_r(float, prefix + "SampleTime_RBV")
-
-        self.values_per_reading = epics_signal_rw_rbv(int, prefix + "ValuesPerRead")
-        self.averaging_time = epics_signal_rw_rbv(float, prefix + "AveragingTime")
-        self.to_average = epics_signal_r(int, prefix + "NumAverage_RBV")
-        self.averaged = epics_signal_r(int, prefix + "NumAveraged_RBV")
-
-        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
-
-        # this PV is special, for some reason it doesn't have a _RBV suffix...
-        self.overflows = epics_signal_r(int, prefix + "RingOverflows")
-
-        self.num_channels = epics_signal_rw_rbv(TetrammChannels, prefix + "NumChannels")
-        self.resolution = epics_signal_rw_rbv(TetrammResolution, prefix + "Resolution")
-        self.trigger_mode = epics_signal_rw_rbv(TetrammTrigger, prefix + "TriggerMode")
-        self.bias = epics_signal_rw_rbv(bool, prefix + "BiasState")
-        self.bias_volts = epics_signal_rw_rbv(float, prefix + "BiasVoltage")
-        self.geometry = epics_signal_rw_rbv(TetrammGeometry, prefix + "Geometry")
-        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-
-        super().__init__(name=name)
+class TetrammDriver(NDArrayBaseIO):
+    range = A[SignalRW[TetrammRange], PvSuffix.rbv("Range")]
+    sample_time: A[SignalR[float], PvSuffix("SampleTime_RBV")]
+    values_per_reading: A[SignalRW[int], PvSuffix.rbv("ValuesPerRead")]
+    averaging_time: A[SignalRW[float], PvSuffix.rbv("AveragingTime")]
+    to_average: A[SignalR[int], PvSuffix("NumAverage_RBV")]
+    averaged: A[SignalR[int], PvSuffix("NumAveraged_RBV")]
+    overflows: A[SignalR[int], PvSuffix("RingOverflows")]
+    num_channels: A[SignalRW[TetrammChannels], PvSuffix.rbv("NumChannels")]
+    resolution: A[SignalRW[TetrammResolution], PvSuffix.rbv("Resolution")]
+    trigger_mode: A[SignalRW[TetrammTrigger], PvSuffix.rbv("TriggerMode")]
+    bias: A[SignalRW[bool], PvSuffix.rbv("BiasState")]
+    bias_volts: A[SignalRW[float], PvSuffix.rbv("BiasVoltage")]
+    geometry: A[SignalRW[TetrammGeometry], PvSuffix.rbv("Geometry")]
+    read_format: A[SignalRW[bool], PvSuffix.rbv("ReadFormat")]
 
 
 class TetrammController(DetectorController):
-    """Controller for a TetrAMM current monitor
-
-    Attributes:
-        base_sample_rate (int): Fixed in hardware
-
-    Args:
-        drv (TetrammDriver): A configured driver for the device
-        maximum_readings_per_frame (int): Maximum number of readings per frame: actual readings may be lower if higher frame rate is required
-        minimum_values_per_reading (int): Lower bound on the values that will be averaged to create a single reading
-        readings_per_frame (int): Actual number of readings per frame.
-
+    """Controller for a TetrAMM current monitor"""
+
+    _supported_trigger_types = {
+        DetectorTrigger.EDGE_TRIGGER: TetrammTrigger.EXT_TRIGGER,
+        DetectorTrigger.CONSTANT_GATE: TetrammTrigger.EXT_TRIGGER,
+    }
+    """"On the TetrAMM ASCII mode requires a minimum value of ValuesPerRead of 500,
+    [...] binary mode the minimum value of ValuesPerRead is 5."
+    https://millenia.cars.aps.anl.gov/software/epics/quadEMDoc.html
     """
-
-    base_sample_rate: int = 100_000
+    _minimal_values_per_reading = {0: 5, 1: 500}
+    """The TetrAMM always digitizes at 100 kHz"""
+    _base_sample_rate: int = 100_000
 
     def __init__(
         self,
-        drv: TetrammDriver,
-        minimum_values_per_reading: int = 5,
-        maximum_readings_per_frame: int = 1_000,
-        readings_per_frame: int = 1_000,
-    ):
-        # TODO: Are any of these also fixed by hardware constraints?
-        self._drv = drv
-        self.maximum_readings_per_frame = maximum_readings_per_frame
-        self.minimum_values_per_reading = minimum_values_per_reading
-        self.readings_per_frame = readings_per_frame
+        driver: TetrammDriver,
+    ) -> None:
+        self.driver = driver
+        self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         # 2 internal clock cycles. Best effort approximation
-        return 2 / self.base_sample_rate
+        return 2 / self._base_sample_rate
 
-    async def prepare(self, trigger_info: TriggerInfo):
-        self._validate_trigger(trigger_info.trigger)
-        assert trigger_info.livetime is not None
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        if trigger_info.trigger not in self._supported_trigger_types:
+            raise TypeError(
+                f"{self.__class__.__name__} only supports the following trigger "
+                f"types: {[k.name for k in self._supported_trigger_types]} but was asked to "
+                f"use {trigger_info.trigger}"
+            )
+        if trigger_info.livetime is None:
+            raise ValueError(f"{self.__class__.__name__} requires that livetime is set")
 
         # trigger mode must be set first and on its own!
-        await self._drv.trigger_mode.set(TetrammTrigger.EXT_TRIGGER)
-
+        await self.driver.trigger_mode.set(
+            self._supported_trigger_types[trigger_info.trigger]
+        )
         await asyncio.gather(
-            self._drv.averaging_time.set(trigger_info.livetime),
+            self.driver.averaging_time.set(trigger_info.livetime),
             self.set_exposure(trigger_info.livetime),
         )
 
     async def arm(self):
-        self._arm_status = await set_and_wait_for_value(
-            self._drv.acquire, True, wait_for_set_completion=False
-        )
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 
     async def wait_for_idle(self):
         if self._arm_status and not self._arm_status.done:
             await self._arm_status
         self._arm_status = None
 
-    def _validate_trigger(self, trigger: DetectorTrigger) -> None:
-        supported_trigger_types = {
-            DetectorTrigger.EDGE_TRIGGER,
-            DetectorTrigger.CONSTANT_GATE,
-        }
-
-        if trigger not in supported_trigger_types:
-            raise ValueError(
-                f"{self.__class__.__name__} only supports the following trigger "
-                f"types: {supported_trigger_types} but was asked to "
-                f"use {trigger}"
-            )
-
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        # We can't use caput callback as we already used it in arm() and we can't have
+        # 2 or they will deadlock
+        await stop_busy_record(self.driver.acquire, False, timeout=1)
 
-    async def set_exposure(self, exposure: float):
-        """Tries to set the exposure time of a single frame.
+    async def set_exposure(self, exposure: float) -> None:
+        """Set the exposure time and acquire period.
 
         As during the  exposure time, the device must collect an integer number
         of readings, in the case where the exposure is not a multiple of the base
         sample rate, it will be lowered to the prior multiple ot ensure triggers
         are not missed.
 
-        Args:
-            exposure (float): The time for a single frame in seconds
-
-        Raises:
-            ValueError: If exposure is too low to collect the required number
-            of readings per frame.
+        :param exposure: Desired exposure time.
+        :type exposure: How long to wait for the exposure time and acquire
+            period to be set.
         """
+        sample_time = await self.driver.sample_time.get_value()
+        minimum_samples = self._minimal_values_per_reading[
+            await self.driver.read_format.get_value()
+        ]
+        samples_per_reading = int(exposure / sample_time)
+        if samples_per_reading < minimum_samples:
+            raise ValueError(
+                "Tetramm exposure time must be at least "
+                f"{minimum_samples * sample_time}s, asked to set it to {exposure}s"
+            )
+        await self.driver.averaging_time.set(samples_per_reading * sample_time)
 
-        # Set up the number of readings across the exposure period to scale with
-        # the exposure time
-        self._set_minimum_exposure(exposure)
-        values_per_reading: int = int(
-            exposure * self.base_sample_rate / self.readings_per_frame
-        )
-
-        await self._drv.values_per_reading.set(values_per_reading)
+    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+        """Start acquiring driver, raising ValueError if the detector is in a bad state.
 
-    @property
-    def max_frame_rate(self) -> float:
-        """Max frame rate in Hz for the current configuration"""
-        return 1 / self.minimum_exposure
+        This sets driver.acquire to True, and waits for it to be True up to a timeout.
+        Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
+        and otherwise raises a ValueError.
 
-    @max_frame_rate.setter
-    def max_frame_rate(self, mfr: float):
-        self._set_minimum_exposure(1 / mfr)
+        :returns AsyncStatus:
+            An AsyncStatus that can be awaited to set driver.acquire to True and perform
+            subsequent raising (if applicable) due to detector state.
+        """
+        status = await set_and_wait_for_value(
+            self.driver.acquire,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+            wait_for_set_completion=False,
+        )
 
-    @property
-    def minimum_exposure(self) -> float:
-        """Smallest amount of time needed to take a frame"""
-        time_per_reading = self.minimum_values_per_reading / self.base_sample_rate
-        return self.readings_per_frame * time_per_reading
+        async def complete_acquisition() -> None:
+            # NOTE: possible race condition here between the callback from
+            # set_and_wait_for_value and the detector state updating.
+            await status
 
-    def _set_minimum_exposure(self, exposure: float):
-        time_per_reading = self.minimum_values_per_reading / self.base_sample_rate
-        if exposure < time_per_reading:
-            raise ValueError(
-                "Tetramm exposure time must be at least "
-                f"{time_per_reading}s, asked to set it to {exposure}s"
-            )
-        self.readings_per_frame = int(
-            min(self.maximum_readings_per_frame, exposure / time_per_reading)
-        )
+        return AsyncStatus(complete_acquisition())
 
 
 class TetrammDatasetDescriber(DatasetDescriber):
-    max_channels = 11
-
-    def __init__(self, controller: TetrammController) -> None:
-        self.controller = controller
+    def __init__(self, driver: TetrammDriver) -> None:
+        self._driver = driver
 
     async def np_datatype(self) -> str:
         return "<f8"  # IEEE 754 double precision floating point
 
     async def shape(self) -> tuple[int, int]:
-        return (self.max_channels, self.controller.readings_per_frame)
+        return (
+            int(await self._driver.num_channels.get_value()),
+            int(
+                await self._driver.averaging_time.get_value()
+                / await self._driver.sample_time.get_value(),
+            ),
+        )
 
 
-# TODO: Support MeanValue signals https://github.com/DiamondLightSource/dodal/issues/337
 class TetrammDetector(StandardDetector):
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
+        drv_suffix: str = "DRV:",
+        fileio_suffix: str = "HDF5:",
         name: str = "",
-        type: str | None = None,
         plugins: dict[str, NDPluginBaseIO] | None = None,
-    ) -> None:
-        self.drv = TetrammDriver(prefix + "DRV:")
-        self.hdf = NDFileHDFIO(prefix + "HDF5:")
-        controller = TetrammController(self.drv)
-        config_signals = [
-            self.drv.values_per_reading,
-            self.drv.averaging_time,
-            self.drv.sample_time,
+        config_sigs: Sequence[SignalR] = (),
+        type: str | None = None,
+    ):
+        self.driver = TetrammDriver(prefix + drv_suffix)
+        self.file_io = NDFileHDFIO(prefix + fileio_suffix)
+        controller = TetrammController(self.driver)
+
+        writer = ADHDFWriter(
+            fileio=self.file_io,
+            path_provider=path_provider,
+            dataset_describer=TetrammDatasetDescriber(self.driver),
+            plugins=plugins,
+        )
+
+        config_sigs = [
+            self.driver.values_per_reading,
+            self.driver.averaging_time,
+            self.driver.sample_time,
+            *config_sigs,
         ]
+
         if type:
             self.type, _ = soft_signal_r_and_setter(str, type)
-            config_signals.append(self.type)
+            config_sigs.append(self.type)
         else:
             self.type = None
+
+        if plugins is not None:
+            for plugin_name, plugin in plugins.items():
+                setattr(self, plugin_name, plugin)
+
         super().__init__(
-            controller,
-            ADHDFWriter(
-                fileio=self.hdf,
-                path_provider=path_provider,
-                dataset_describer=TetrammDatasetDescriber(controller),
-                plugins=plugins,
-            ),
-            config_signals,
-            name,
+            controller=controller,
+            writer=writer,
+            name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return {"fields": [self.name]}

dodal/devices/xbpm_feedback.py

@@ -2,6 +2,8 @@ from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, Device, StrictEnum, observe_value
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
+from dodal.common.device_utils import periodic_reminder
+
 
 class Pause(StrictEnum):
     PAUSE = "Paused"  # 0
@@ -22,6 +24,7 @@ class XBPMFeedback(Device, Triggerable):
 
     @AsyncStatus.wrap
     async def trigger(self):
-        async for value in observe_value(self.pos_stable):
-            if value:
-                return
+        async with periodic_reminder("Waiting for XBPM"):
+            async for value in observe_value(self.pos_stable):
+                if value:
+                    return

dodal/devices/b07/grating.py

@@ -1,9 +0,0 @@
-from ophyd_async.core import StrictEnum
-
-
-class B07BGrating(StrictEnum):
-    NI_400 = "400 l/mm Ni"
-    NI_1000 = "1000 l/mm Ni"
-    PT_600 = "BAD 600 l/mm Pt"
-    AU_600 = "600 l/mm Au"
-    NO_GRATING = "No Grating"

dodal/devices/b07_1/grating.py

@@ -1,10 +0,0 @@
-from ophyd_async.core import StrictEnum
-
-
-class B07CGrating(StrictEnum):
-    AU_400 = "400 l/mm Au"
-    AU_600 = "600 l/mm Au"
-    PT_600 = "600 l/mm Pt"
-    AU_1200 = "1200 l/mm Au"
-    ML_1200 = "1200 l/mm ML"
-    NO_GRATING = "No Grating"

dodal/devices/i09/grating.py

@@ -1,7 +0,0 @@
-from ophyd_async.core import StrictEnum
-
-
-class I09Grating(StrictEnum):
-    G_300 = "300 lines/mm"
-    G_400 = "400 lines/mm"
-    G_800 = "800 lines/mm"