dls-dodal 1.36.1a0__py3-none-any.whl → 1.36.3__py3-none-any.whl

dodal/devices/slits.py

@@ -2,16 +2,38 @@ from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class Slits(StandardReadable):
+class MinimalSlits(StandardReadable):
+    """Gap only X Y slits."""
+
+    def __init__(
+        self,
+        prefix: str,
+        x_gap: str = "X:SIZE",
+        y_gap: str = "Y:SIZE",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.x_gap = Motor(prefix + x_gap)
+            self.y_gap = Motor(prefix + y_gap)
+        super().__init__(name=name)
+
+
+class Slits(MinimalSlits):
     """
     Representation of a 4-blade set of slits. Allows control/readout of the gap
     between each pair of blades.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self,
+        prefix: str,
+        x_gap: str = "X:SIZE",
+        y_gap: str = "Y:SIZE",
+        x_centre: str = "X:CENTRE",
+        y_centre: str = "Y:CENTRE",
+        name: str = "",
+    ) -> None:
         with self.add_children_as_readables():
-            self.x_gap = Motor(prefix + "X:SIZE")
-            self.y_gap = Motor(prefix + "Y:SIZE")
-            self.x_centre = Motor(prefix + "X:CENTRE")
-            self.y_centre = Motor(prefix + "Y:CENTRE")
-        super().__init__(name)
+            self.x_centre = Motor(prefix + x_centre)
+            self.y_centre = Motor(prefix + y_centre)
+        super().__init__(prefix=prefix, x_gap=x_gap, y_gap=y_gap, name=name)

dodal/devices/tetramm.py

@@ -22,31 +22,31 @@ from ophyd_async.epics.core import (
 
 
 class TetrammRange(StrictEnum):
-    uA = "+- 120 uA"
-    nA = "+- 120 nA"
+    UA = "+- 120 uA"
+    NA = "+- 120 nA"
 
 
 class TetrammTrigger(StrictEnum):
-    FreeRun = "Free run"
-    ExtTrigger = "Ext. trig."
-    ExtBulb = "Ext. bulb"
-    ExtGate = "Ext. gate"
+    FREE_RUN = "Free run"
+    EXT_TRIGGER = "Ext. trig."
+    EXT_BULB = "Ext. bulb"
+    EXT_GATE = "Ext. gate"
 
 
 class TetrammChannels(StrictEnum):
-    One = "1"
-    Two = "2"
-    Four = "4"
+    ONE = "1"
+    TWO = "2"
+    FOUR = "4"
 
 
 class TetrammResolution(StrictEnum):
-    SixteenBits = "16 bits"
-    TwentyFourBits = "24 bits"
+    SIXTEEN_BITS = "16 bits"
+    TWENTY_FOUR_BITS = "24 bits"
 
 
 class TetrammGeometry(StrictEnum):
-    Diamond = "Diamond"
-    Square = "Square"
+    DIAMOND = "Diamond"
+    SQUARE = "Square"
 
 
 class TetrammDriver(Device):
@@ -118,7 +118,7 @@ class TetrammController(DetectorController):
         assert trigger_info.livetime is not None
 
         # trigger mode must be set first and on its own!
-        await self._drv.trigger_mode.set(TetrammTrigger.ExtTrigger)
+        await self._drv.trigger_mode.set(TetrammTrigger.EXT_TRIGGER)
 
         await asyncio.gather(
             self._drv.averaging_time.set(trigger_info.livetime),
@@ -134,8 +134,8 @@ class TetrammController(DetectorController):
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {
-            DetectorTrigger.edge_trigger,
-            DetectorTrigger.constant_gate,
+            DetectorTrigger.EDGE_TRIGGER,
+            DetectorTrigger.CONSTANT_GATE,
         }
 
         if trigger not in supported_trigger_types:

dodal/devices/undulator_dcm.py

@@ -5,6 +5,7 @@ from ophyd_async.core import AsyncStatus, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 
+from ..log import LOGGER
 from .dcm import DCM
 from .undulator import Undulator
 
@@ -59,3 +60,6 @@ class UndulatorDCM(StandardReadable, Movable):
             self.dcm.energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator.set(value),
         )
+        # DCM Perp pitch
+        LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
+        await self.dcm.offset_in_mm.set(self.dcm_fixed_offset_mm)

dodal/devices/util/test_utils.py

@@ -1,8 +1,8 @@
-from ophyd_async.core import (
+from ophyd_async.epics.motor import Motor
+from ophyd_async.testing import (
     callback_on_mock_put,
     set_mock_value,
 )
-from ophyd_async.epics.motor import Motor
 
 
 def patch_motor(motor: Motor, initial_position=0):

dodal/devices/xspress3/xspress3.py

@@ -26,12 +26,12 @@ class TriggerMode(StrictEnum):
     SOFTWARE = "Software"
     HARDWARE = "Hardware"
     BURST = "Burst"
-    TTL_Veto_Only = "TTL Veto Only"
+    TTL_VETO_ONLY = "TTL Veto Only"
     IDC = "IDC"
     SOTWARE_START_STOP = "Software Start/Stop"
     TTL_BOTH = "TTL Both"
     LVDS_VETO_ONLY = "LVDS Veto Only"
-    LVDS_both = "LVDS Both"
+    LVDS_BOTH = "LVDS Both"
 
 
 class UpdateRBV(StrictEnum):
@@ -49,7 +49,7 @@ class DetectorState(StrictEnum):
     ACQUIRE = "Acquire"
     READOUT = "Readout"
     CORRECT = "Correct"
-    Saving = "Saving"
+    SAVING = "Saving"
     ABORTING = "Aborting"
     ERROR = "Error"
     WAITING = "Waiting"

dodal/devices/zebra.py

@@ -59,25 +59,25 @@ class TrigSource(StrictEnum):
 
 
 class EncEnum(StrictEnum):
-    Enc1 = "Enc1"
-    Enc2 = "Enc2"
-    Enc3 = "Enc3"
-    Enc4 = "Enc4"
-    Enc1_4Av = "Enc1-4Av"
+    ENC1 = "Enc1"
+    ENC2 = "Enc2"
+    ENC3 = "Enc3"
+    ENC4 = "Enc4"
+    ENC1_4AV = "Enc1-4Av"
 
 
 class I03Axes:
-    SMARGON_X1 = EncEnum.Enc1
-    SMARGON_Y = EncEnum.Enc2
-    SMARGON_Z = EncEnum.Enc3
-    OMEGA = EncEnum.Enc4
+    SMARGON_X1 = EncEnum.ENC1
+    SMARGON_Y = EncEnum.ENC2
+    SMARGON_Z = EncEnum.ENC3
+    OMEGA = EncEnum.ENC4
 
 
 class I24Axes:
-    VGON_Z = EncEnum.Enc1
-    OMEGA = EncEnum.Enc2
-    VGON_X = EncEnum.Enc3
-    VGON_YH = EncEnum.Enc4
+    VGON_Z = EncEnum.ENC1
+    OMEGA = EncEnum.ENC2
+    VGON_X = EncEnum.ENC3
+    VGON_YH = EncEnum.ENC4
 
 
 class RotationDirection(StrictEnum):

dodal/adsim.py

@@ -1,17 +0,0 @@
-import os
-
-from dodal.devices.adsim import SimStage
-from dodal.devices.areadetector import AdSimDetector
-
-from .utils import get_hostname
-
-# Default prefix to hostname unless overriden with export PREFIX=<prefix>
-PREFIX: str = os.environ.get("PREFIX", get_hostname())
-
-
-def stage(name: str = "sim_motors") -> SimStage:
-    return SimStage(name=name, prefix=f"{PREFIX}-MO-SIM-01:")
-
-
-def det(name: str = "adsim") -> AdSimDetector:
-    return AdSimDetector(name=name, prefix=f"{PREFIX}-AD-SIM-01:")

dodal/devices/areadetector/__init__.py

@@ -1,10 +0,0 @@
-from .adaravis import AdAravisDetector
-from .adsim import AdSimDetector
-from .adutils import Hdf5Writer, SynchronisedAdDriverBase
-
-__all__ = [
-    "AdSimDetector",
-    "SynchronisedAdDriverBase",
-    "Hdf5Writer",
-    "AdAravisDetector",
-]

dodal/devices/areadetector/adaravis.py

@@ -1,101 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-from ophyd import EpicsSignal, Signal
-from ophyd.areadetector.base import ADComponent as Cpt
-from ophyd.areadetector.detectors import DetectorBase
-
-from .adutils import Hdf5Writer, SingleTriggerV33, SynchronisedAdDriverBase
-
-_ACQUIRE_BUFFER_PERIOD = 0.2
-
-
-class AdAravisDetector(SingleTriggerV33, DetectorBase):
-    cam = Cpt(SynchronisedAdDriverBase, suffix="DET:")
-    hdf = Cpt(
-        Hdf5Writer,
-        suffix="HDF5:",
-        root="",
-        write_path_template="",
-    )
-    _priming_settings: Mapping[Signal, Any]
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.hdf.kind = "normal"
-
-        # Values for staging
-        self.stage_sigs = {
-            # Get stage to wire up the plugins
-            self.hdf.nd_array_port: self.cam.port_name.get(),
-            # Reset array counter on stage
-            self.cam.array_counter: 0,
-            # Set image mode to multiple on stage so we have the option, can still
-            # set num_images to 1
-            self.cam.image_mode: "Multiple",
-            # For now, this Ophyd device does not support hardware
-            # triggered scanning, disable on stage
-            self.cam.trigger_mode: "Off",
-            **self.stage_sigs,  # type: ignore
-        }
-
-        # Settings to apply when priming plugins during pre-stage
-        self._priming_settings = {
-            self.hdf.enable: 1,
-            self.hdf.nd_array_port: self.cam.port_name.get(),
-            self.cam.array_callbacks: 1,
-            self.cam.image_mode: "Single",
-            self.cam.trigger_mode: "Off",
-            # Take the quickest possible frame
-            self.cam.acquire_time: 6.3e-05,
-            self.cam.acquire_period: 0.003,
-        }
-
-        # Signals that control driver and hdf writer should be put_complete to
-        # avoid race conditions during priming
-        for signal in set(self.stage_sigs.keys()).union(
-            set(self._priming_settings.keys())
-        ):
-            if isinstance(signal, EpicsSignal):
-                signal.put_complete = True
-        self.cam.acquire.put_complete = True
-
-    def stage(self, *args, **kwargs) -> list[object]:
-        # We have to manually set the acquire period bcause the EPICS driver
-        # doesn't do it for us. If acquire time is a staged signal, we use the
-        # stage value to calculate the acquire period, otherwise we perform
-        # a caget and use the current acquire time.
-        if self.cam.acquire_time in self.stage_sigs:
-            acquire_time = self.stage_sigs[self.cam.acquire_time]
-        else:
-            acquire_time = self.cam.acquire_time.get()
-        self.stage_sigs[self.cam.acquire_period] = (
-            float(acquire_time) + _ACQUIRE_BUFFER_PERIOD
-        )
-
-        # Ensure detector warmed up
-        self._prime_hdf()
-
-        # Now calling the super method should set the acquire period
-        return super().stage(*args, **kwargs)
-
-    def _prime_hdf(self) -> None:
-        """
-        Take a single frame and pipe it through the HDF5 writer plugin
-        """
-
-        # Backup state and ensure we are not acquiring
-        reset_to = {signal: signal.get() for signal in self._priming_settings.keys()}
-        self.cam.acquire.set(0).wait(timeout=10)
-
-        # Apply all settings for acquisition
-        for signal, value in self._priming_settings.items():
-            # Ensure that .wait really will wait until the PV is set including its RBV
-            signal.set(value).wait(timeout=10)
-
-        # Acquire a frame
-        self.cam.acquire.set(1).wait(timeout=10)
-
-        # Revert settings to previous values
-        for signal, value in reversed(reset_to.items()):
-            signal.set(value).wait(timeout=10)

dodal/devices/areadetector/adsim.py

@@ -1,47 +0,0 @@
-from ophyd.areadetector.base import ADComponent as Cpt
-from ophyd.areadetector.detectors import DetectorBase
-
-from .adutils import Hdf5Writer, SingleTriggerV33, SynchronisedAdDriverBase
-
-
-class AdSimDetector(SingleTriggerV33, DetectorBase):
-    cam = Cpt(SynchronisedAdDriverBase, suffix="CAM:", lazy=True)
-    hdf = Cpt(
-        Hdf5Writer,
-        suffix="HDF5:",
-        root="",
-        write_path_template="",
-        lazy=True,
-    )
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.hdf.kind = "normal"
-
-        self.stage_sigs = {
-            # Get stage to wire up the plugins
-            self.hdf.nd_array_port: self.cam.port_name.get(),
-            # Reset array counter on stage
-            self.cam.array_counter: 0,
-            # Set image mode to multiple on stage so we have the option, can still
-            # set num_images to 1
-            self.cam.image_mode: "Multiple",
-            # For now, this Ophyd device does not support hardware
-            # triggered scanning, disable on stage
-            self.cam.trigger_mode: "Internal",
-            **self.stage_sigs,  # type: ignore
-        }
-
-    def stage(self, *args, **kwargs) -> list[object]:
-        # We have to manually set the acquire period bcause the EPICS driver
-        # doesn't do it for us. If acquire time is a staged signal, we use the
-        # stage value to calculate the acquire period, otherwise we perform
-        # a caget and use the current acquire time.
-        if self.cam.acquire_time in self.stage_sigs:
-            acquire_time = self.stage_sigs[self.cam.acquire_time]
-        else:
-            acquire_time = self.cam.acquire_time.get()
-        self.stage_sigs[self.cam.acquire_period] = acquire_time
-
-        # Now calling the super method should set the acquire period
-        return super().stage(*args, **kwargs)

dodal/devices/areadetector/adutils.py

@@ -1,81 +0,0 @@
-import time as ttime
-
-from ophyd import Component as Cpt
-from ophyd import DetectorBase, Device, EpicsSignal, EpicsSignalRO, Staged
-from ophyd.areadetector import ADTriggerStatus, TriggerBase
-from ophyd.areadetector.cam import AreaDetectorCam
-from ophyd.areadetector.filestore_mixins import FileStoreHDF5, FileStoreIterativeWrite
-from ophyd.areadetector.plugins import HDF5Plugin
-
-
-class SingleTriggerV33(TriggerBase):
-    _status_type = ADTriggerStatus
-
-    def __init__(self, *args, image_name=None, **kwargs):
-        super().__init__(*args, **kwargs)
-        if image_name is None:
-            # Ensure that this mixin is part of valid device with name
-            assert isinstance(self, Device)
-            image_name = "_".join([self.name, "image"])
-        self._image_name = image_name
-
-    def trigger(self):
-        "Trigger one acquisition."
-        if self._staged != Staged.yes:
-            raise RuntimeError(
-                "This detector is not ready to trigger."
-                "Call the stage() method before triggering."
-            )
-
-        self._status = self._status_type(self)
-
-        def _acq_done(*args, **kwargs):
-            # TODO sort out if anything useful in here
-            self._status._finished()  # noqa: SLF001
-
-        self._acquisition_signal.put(1, use_complete=True, callback=_acq_done)
-        # Ensure that this mixin is part of valid Detector with generate_datum
-        assert isinstance(self, DetectorBase)
-        self.generate_datum(self._image_name, ttime.time())
-        return self._status
-
-
-class SynchronisedAdDriverBase(AreaDetectorCam):
-    """
-    Base Ophyd device to control an AreaDetector driver and
-    syncrhonise it on other AreaDetector plugins, even non-blocking ones.
-    """
-
-    adcore_version = Cpt(EpicsSignalRO, "ADCoreVersion_RBV", string=True, kind="config")
-    driver_version = Cpt(EpicsSignalRO, "DriverVersion_RBV", string=True, kind="config")
-    wait_for_plugins = Cpt(EpicsSignal, "WaitForPlugins", string=True, kind="config")
-
-    def stage(self, *args, **kwargs):
-        # Makes the detector allow non-blocking AD plugins but makes Ophyd use
-        # the AcquireBusy PV to determine when an acquisition is complete
-        self.ensure_nonblocking()
-        return super().stage(*args, **kwargs)
-
-    def ensure_nonblocking(self):
-        self.stage_sigs["wait_for_plugins"] = "Yes"
-        if self.parent is not None:
-            for c in self.parent.component_names:
-                cpt = getattr(self.parent, c)
-                if cpt is self:
-                    continue
-                if hasattr(cpt, "ensure_nonblocking"):
-                    cpt.ensure_nonblocking()
-
-
-# ophyd code to be removed, only used for adim
-# https://github.com/DiamondLightSource/dodal/issues/404
-class Hdf5Writer(HDF5Plugin, FileStoreHDF5, FileStoreIterativeWrite):  # type: ignore
-    """ """
-
-    pool_max_buffers = None
-    file_number_sync = None
-    file_number_write = None
-
-    def get_frames_per_point(self):
-        assert isinstance(self.parent, DetectorBase)
-        return self.parent.cam.num_images.get()