dls-dodal 1.46.0__py3-none-any.whl → 1.48.0__py3-none-any.whl

dodal/devices/aperturescatterguard.py

@@ -2,17 +2,18 @@ from __future__ import annotations
 
 import asyncio
 
-from bluesky.protocols import Movable, Preparable
+from bluesky.protocols import Preparable
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
+    derived_signal_r,
+    derived_signal_rw,
 )
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
 
@@ -123,21 +124,21 @@ def load_positions_from_beamline_parameters(
     }
 
 
-class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable):
+class ApertureScatterguard(StandardReadable, Preparable):
     """Move the aperture and scatterguard assembly in a safe way. There are two ways to
     interact with the device depending on if you want simplicity or move flexibility.
 
     Examples:
         The simple interface is using::
 
-            await aperture_scatterguard.set(ApertureValue.LARGE)
+            await aperture_scatterguard.selected_aperture.set(ApertureValue.LARGE)
 
         This will move the assembly so that the large aperture is in the beam, regardless
         of where the assembly currently is.
 
         We may also want to move the assembly out of the beam with::
 
-            await aperture_scatterguard.set(ApertureValue.OUT_OF_BEAM)
+            await aperture_scatterguard.selected_aperture.set(ApertureValue.OUT_OF_BEAM)
 
         Note, to make sure we do this as quickly as possible, the scatterguard will stay
         in the same position relative to the aperture.
@@ -149,7 +150,7 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
 
         Then, at a later time, move back into the beam::
 
-            await aperture_scatterguard.set(ApertureValue.LARGE)
+            await  aperture_scatterguard.selected_aperture.set(ApertureValue.LARGE)
 
         Given the prepare has been done this move will now be faster as only the y is
         left to move.
@@ -164,11 +165,24 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.radius = create_r_hardware_backed_soft_signal(
-            float, self._get_current_radius, units="µm"
-        )
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.selected_aperture = derived_signal_rw(
+                self._get_current_aperture_position,
+                self._set_current_aperture_position,
+                large=self.aperture.large,
+                medium=self.aperture.medium,
+                small=self.aperture.small,
+                current_ap_y=self.aperture.y.user_readback,
+            )
+
+        self.radius = derived_signal_r(
+            self._get_current_radius,
+            current_aperture=self.selected_aperture,
+            derived_units="µm",
+        )
+
         self.add_readables(
             [
                 self.aperture.x.user_readback,
@@ -180,17 +194,9 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
             ],
         )
 
-        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.selected_aperture = create_r_hardware_backed_soft_signal(
-                ApertureValue, self._get_current_aperture_position
-            )
-
         super().__init__(name)
 
-    @AsyncStatus.wrap
-    async def set(self, value: ApertureValue):
-        """This set will move the aperture into the beam or move the whole assembly out"""
-
+    async def _set_current_aperture_position(self, value: ApertureValue) -> None:
         position = self._loaded_positions[value]
         await self._check_safe_to_move(position.aperture_z)
 
@@ -231,6 +237,27 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
                     "triggering another move."
                 )
 
+    def _get_current_radius(self, current_aperture: ApertureValue) -> float:
+        return self._loaded_positions[current_aperture].radius
+
+    def _is_out_of_beam(self, current_ap_y: float) -> bool:
+        out_ap_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
+        return current_ap_y <= out_ap_y + self._tolerances.aperture_y
+
+    def _get_current_aperture_position(
+        self, large: float, medium: float, small: float, current_ap_y: float
+    ) -> ApertureValue:
+        if large == 1:
+            return ApertureValue.LARGE
+        elif medium == 1:
+            return ApertureValue.MEDIUM
+        elif small == 1:
+            return ApertureValue.SMALL
+        elif self._is_out_of_beam(current_ap_y):
+            return ApertureValue.OUT_OF_BEAM
+
+        raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
+
     async def _safe_move_whilst_in_beam(self, position: AperturePosition):
         """
         Move the aperture and scatterguard combo safely to a new position.
@@ -282,33 +309,6 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
             self.scatterguard.y.set(scatterguard_y),
         )
 
-    async def _is_out_of_beam(self) -> bool:
-        current_ap_y = await self.aperture.y.user_readback.get_value()
-        out_ap_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
-        return current_ap_y <= out_ap_y + self._tolerances.aperture_y
-
-    async def _get_current_aperture_position(self) -> ApertureValue:
-        """
-        Returns the current aperture position using readback values
-        for SMALL, MEDIUM, LARGE. ROBOT_LOAD position defined when
-        mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
-        If no position is found then raises InvalidApertureMove.
-        """
-        if await self.aperture.large.get_value(cached=False) == 1:
-            return ApertureValue.LARGE
-        elif await self.aperture.medium.get_value(cached=False) == 1:
-            return ApertureValue.MEDIUM
-        elif await self.aperture.small.get_value(cached=False) == 1:
-            return ApertureValue.SMALL
-        elif await self._is_out_of_beam():
-            return ApertureValue.OUT_OF_BEAM
-
-        raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
-
-    async def _get_current_radius(self) -> float:
-        current_value = await self._get_current_aperture_position()
-        return self._loaded_positions[current_value].radius
-
     @AsyncStatus.wrap
     async def prepare(self, value: ApertureValue):
         """Moves the assembly to the position for the specified aperture, whilst keeping
@@ -317,7 +317,7 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
         Moving the assembly whilst out of the beam has no collision risk so we can just
         move all the motors together.
         """
-        if await self._is_out_of_beam():
+        if self._is_out_of_beam(await self.aperture.y.user_readback.get_value()):
             aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
                 self._loaded_positions[value].values
             )
@@ -329,4 +329,4 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
                 self.scatterguard.y.set(scatterguard_y),
             )
         else:
-            await self.set(value)
+            await self.selected_aperture.set(value)

dodal/devices/current_amplifiers/struck_scaler_counter.py

@@ -18,7 +18,7 @@ class CountMode(StrictEnum):
 
 class CountState(StrictEnum):
     DONE = "Done"
-    COUNT = "Count"  # type: ignore
+    COUNT = "Count"
 
 
 COUNT_PER_VOLTAGE = 100000

dodal/devices/diamond_filter.py

@@ -1,8 +1,8 @@
-from typing import Generic, TypeVar
+from typing import TypeVar
 
-from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.core import epics_signal_rw
-from ophyd_async.epics.motor import Motor
+from ophyd_async.core import StrictEnum
+
+from dodal.devices.positioner import Positioner1D
 
 
 class _Filters(StrictEnum):
@@ -25,22 +25,10 @@ class I04Filters(_Filters):
 T = TypeVar("T", bound=_Filters)
 
 
-class DiamondFilter(StandardReadable, Generic[T]):
+class DiamondFilter(Positioner1D[T]):
     """
     A filter set that is used to reduce the heat load on the monochromator.
 
     It has 4 slots that can contain filters of different thickness. Changing the thickness
     signal will move the filter set to select this filter.
     """
-
-    def __init__(
-        self,
-        prefix: str,
-        data_type: type[T],
-        name: str = "",
-    ) -> None:
-        with self.add_children_as_readables():
-            self.y_motor = Motor(prefix + "Y")
-            self.thickness = epics_signal_rw(data_type, f"{prefix}Y:MP:SELECT")
-
-        super().__init__(name)

dodal/devices/eiger.py

@@ -35,7 +35,7 @@ class InternalEigerTriggerMode(Enum):
 AVAILABLE_TIMEOUTS = {
     "i03": EigerTimeouts(
         stale_params_timeout=60,
-        general_status_timeout=10,
+        general_status_timeout=20,
         meta_file_ready_timeout=30,
         all_frames_timeout=120,  # Long timeout for meta file to compensate for filesystem issues
         arming_timeout=60,

dodal/devices/electron_analyser/__init__.py

@@ -0,0 +1,18 @@
+from .abstract.base_detector import (
+    ElectronAnalyserDetector,
+    ElectronAnalyserRegionDetector,
+    TElectronAnalyserDetector,
+    TElectronAnalyserRegionDetector,
+)
+from .types import EnergyMode
+from .util import to_binding_energy, to_kinetic_energy
+
+__all__ = [
+    "to_binding_energy",
+    "to_kinetic_energy",
+    "EnergyMode",
+    "ElectronAnalyserDetector",
+    "TElectronAnalyserDetector",
+    "ElectronAnalyserRegionDetector",
+    "TElectronAnalyserRegionDetector",
+]

dodal/devices/electron_analyser/abstract/__init__.py

@@ -0,0 +1,22 @@
+from .base_detector import (
+    AbstractAnalyserDriverIO,
+    AbstractElectronAnalyserDetector,
+)
+from .base_driver_io import AbstractAnalyserDriverIO, TAbstractAnalyserDriverIO
+from .base_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+__all__ = [
+    "AbstractBaseRegion",
+    "AbstractBaseSequence",
+    "TAbstractBaseRegion",
+    "TAbstractBaseSequence",
+    "AbstractAnalyserDriverIO",
+    "AbstractElectronAnalyserDetector",
+    "AbstractAnalyserDriverIO",
+    "TAbstractAnalyserDriverIO",
+]

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -0,0 +1,223 @@
+import asyncio
+from abc import abstractmethod
+from typing import Generic, TypeVar
+
+from bluesky.protocols import Preparable, Reading, Stageable, Triggerable
+from event_model import DataKey
+from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
+    AsyncStatus,
+    Device,
+    Reference,
+)
+from ophyd_async.epics.adcore import (
+    ADBaseController,
+)
+from ophyd_async.epics.motor import Motor
+
+from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract.base_region import (
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+
+class ElectronAnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
+    def get_deadtime(self, exposure: float | None) -> float:
+        return 0
+
+
+class AbstractElectronAnalyserDetector(
+    Device,
+    Stageable,
+    Triggerable,
+    AsyncReadable,
+    AsyncConfigurable,
+    Generic[TAbstractAnalyserDriverIO],
+):
+    """
+    Detector for data acquisition of electron analyser. Can only acquire using settings
+    already configured for the device.
+
+    If possible, this should be changed to inherit from a StandardDetector. Currently,
+    StandardDetector forces you to use a file writer which doesn't apply here.
+    See issue https://github.com/bluesky/ophyd-async/issues/888
+    """
+
+    def __init__(
+        self,
+        name: str,
+        driver: TAbstractAnalyserDriverIO,
+    ):
+        self.controller: ElectronAnalyserController = ElectronAnalyserController(
+            driver=driver
+        )
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        await self.controller.arm()
+        await self.controller.wait_for_idle()
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        """Make sure the detector is idle and ready to be used."""
+        await asyncio.gather(self.controller.disarm())
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        """Disarm the detector."""
+        await asyncio.gather(self.controller.disarm())
+
+    async def read(self) -> dict[str, Reading]:
+        return await self.driver.read()
+
+    async def describe(self) -> dict[str, DataKey]:
+        data = await self.driver.describe()
+        # Correct the shape for image
+        prefix = self.driver.name + "-"
+        energy_size = len(await self.driver.energy_axis.get_value())
+        angle_size = len(await self.driver.angle_axis.get_value())
+        data[prefix + "image"]["shape"] = [angle_size, energy_size]
+        return data
+
+    async def read_configuration(self) -> dict[str, Reading]:
+        return await self.driver.read_configuration()
+
+    async def describe_configuration(self) -> dict[str, DataKey]:
+        return await self.driver.describe_configuration()
+
+    @property
+    @abstractmethod
+    def driver(self) -> TAbstractAnalyserDriverIO:
+        """
+        Define common property for all implementations to access the driver. Some
+        implementations will store this as a reference so it doesn't have conflicting
+        parents.
+
+        Returns:
+            instance of the driver.
+        """
+
+
+class ElectronAnalyserRegionDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Preparable,
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Extends electron analyser detector to configure specific region settings before data
+    acqusition. This object must be passed in a driver and store it as a reference. It
+    is designed to only exist inside a plan.
+    """
+
+    def __init__(
+        self, name: str, driver: TAbstractAnalyserDriverIO, region: TAbstractBaseRegion
+    ):
+        self._driver_ref = Reference(driver)
+        self.region = region
+        super().__init__(name, driver)
+
+    @property
+    def driver(self) -> TAbstractAnalyserDriverIO:
+        # Store as a reference, this implementation will be given a driver so needs to
+        # make sure we don't get conflicting parents.
+        return self._driver_ref()
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: Motor) -> None:
+        """
+        Prepare driver with the region stored and energy_source motor.
+
+        Args:
+            value: The excitation energy source that the region has selected.
+        """
+        excitation_energy_source = value
+        await self.driver.prepare(excitation_energy_source)
+        await self.driver.set(self.region)
+
+
+TElectronAnalyserRegionDetector = TypeVar(
+    "TElectronAnalyserRegionDetector",
+    bound=ElectronAnalyserRegionDetector,
+)
+
+
+class ElectronAnalyserDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Generic[
+        TAbstractAnalyserDriverIO,
+        TAbstractBaseSequence,
+        TAbstractBaseRegion,
+    ],
+):
+    """
+    Electron analyser detector with the additional functionality to load a sequence file
+    and create a list of temporary ElectronAnalyserRegionDetector objects. These will
+    setup configured region settings before data acquisition.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        sequence_class: type[TAbstractBaseSequence],
+        driver: TAbstractAnalyserDriverIO,
+        name: str = "",
+    ):
+        # Pass in driver
+        self._driver = driver
+        self._sequence_class = sequence_class
+        super().__init__(name, self.driver)
+
+    @property
+    def driver(self) -> TAbstractAnalyserDriverIO:
+        # This implementation creates the driver and wants this to be the parent so it
+        # can be used with connect() method.
+        return self._driver
+
+    def load_sequence(self, filename: str) -> TAbstractBaseSequence:
+        """
+        Load the sequence data from a provided json file into a sequence class.
+
+        Args:
+            filename: Path to the sequence file containing the region data.
+
+        Returns:
+            Pydantic model representing the sequence file.
+        """
+        return load_json_file_to_class(self._sequence_class, filename)
+
+    def create_region_detector_list(
+        self, filename: str, enabled_only=True
+    ) -> list[
+        ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
+    ]:
+        """
+        Create a list of detectors equal to the number of regions in a sequence file.
+        Each detector is responsible for setting up a specific region.
+
+        Args:
+            filename:     Path to the sequence file containing the region data.
+            enabled_only: If true, only include the region if enabled is True.
+
+        Returns:
+            List of ElectronAnalyserRegionDetector, equal to the number of regions in
+            the sequence file.
+        """
+        seq = self.load_sequence(filename)
+        regions = seq.get_enabled_regions() if enabled_only else seq.regions
+        return [
+            ElectronAnalyserRegionDetector(self.name + "_" + r.name, self.driver, r)
+            for r in regions
+        ]
+
+
+TElectronAnalyserDetector = TypeVar(
+    "TElectronAnalyserDetector",
+    bound=ElectronAnalyserDetector,
+)