dls-dodal 1.67.0__py3-none-any.whl → 1.69.0__py3-none-any.whl

dodal/common/maths.py

@@ -48,3 +48,83 @@ def in_micros(t: float) -> int:
     if t < 0:
         raise ValueError(f"Expected a positive time in seconds, got {t!r}")
     return int(np.ceil(t * 1e6))
+
+
+class Rectangle2D:
+    """
+    A 2D rectangle defined by two opposite corners.
+
+    This class represents a rectangle in 2D space using two points: (x1, y1) and (x2, y2).
+    It provides methods to query rectangle properties and check point containment.
+
+    Attributes:
+        x1 (float): The x-coordinate of the first corner.
+        y1 (float): The y-coordinate of the first corner.
+        x2 (float): The x-coordinate of the second corner.
+        y2 (float): The y-coordinate of the second corner.
+    """
+
+    def __init__(self, x1: float, y1: float, x2: float, y2: float):
+        """
+        Initialize a Rectangle2D with two corner points.
+
+        Args:
+            x1 (float): The x-coordinate of the first corner.
+            y1 (float): The y-coordinate of the first corner.
+            x2 (float): The x-coordinate of the second corner.
+            y2 (float): The y-coordinate of the second corner.
+        """
+        self.x1, self.y1 = x1, y1
+        self.x2, self.y2 = x2, y2
+
+    def get_max_x(self) -> float:
+        """
+        Get the maximum x-coordinate of the rectangle.
+
+        Returns:
+            float: The larger of the two x-coordinates (x1, x2).
+        """
+        return max(self.x1, self.x2)
+
+    def get_min_x(self) -> float:
+        """
+        Get the minimum x-coordinate of the rectangle.
+
+        Returns:
+            float: The smaller of the two x-coordinates (x1, x2).
+        """
+        return min(self.x1, self.x2)
+
+    def get_max_y(self) -> float:
+        """
+        Get the maximum y-coordinate of the rectangle.
+
+        Returns:
+            float: The larger of the two y-coordinates (y1, y2).
+        """
+        return max(self.y1, self.y2)
+
+    def get_min_y(self) -> float:
+        """
+        Get the minimum y-coordinate of the rectangle.
+
+        Returns:
+            float: The smaller of the two y-coordinates (y1, y2).
+        """
+        return min(self.y1, self.y2)
+
+    def contains(self, x: float, y: float) -> bool:
+        """
+        Check if a point is contained within the rectangle.
+
+        Args:
+            x (float): The x-coordinate of the point.
+            y (float): The y-coordinate of the point.
+
+        Returns:
+            bool: True if the point is within the rectangle bounds, False otherwise.
+        """
+        return (
+            self.get_min_x() <= x <= self.get_max_x()
+            and self.get_min_y() <= y <= self.get_max_y()
+        )

dodal/devices/eiger.py

@@ -1,11 +1,11 @@
-# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from dataclasses import dataclass
 from enum import Enum
 
 from bluesky.protocols import Stageable
 from ophyd import Component, Device, EpicsSignalRO, Signal
 from ophyd.areadetector.cam import EigerDetectorCam
-from ophyd.status import AndStatus, Status, StatusBase
+from ophyd.signal import AttributeSignal
+from ophyd.status import AndStatus, Status, StatusBase, SubscriptionStatus
 
 from dodal.devices.detector import DetectorParams, TriggerMode
 from dodal.devices.eiger_odin import EigerOdin
@@ -56,7 +56,6 @@ class EigerDetector(Device, Stageable):
 
     stale_params = Component(EpicsSignalRO, "CAM:StaleParameters_RBV")
     bit_depth = Component(EpicsSignalRO, "CAM:BitDepthImage_RBV")
-
     filewriters_finished: StatusBase
 
     detector_params: DetectorParams | None = None
@@ -64,9 +63,24 @@ class EigerDetector(Device, Stageable):
     arming_status = Status()
     arming_status.set_finished()
 
-    def __init__(self, beamline: str = "i03", *args, **kwargs):
+    def __init__(
+        self,
+        beamline: str = "i03",
+        ispyb_detector_id: int | None = None,
+        *args,
+        **kwargs,
+    ):
         super().__init__(*args, **kwargs)
         self.beamline = beamline
+
+        self.detector_id = ispyb_detector_id
+        self.ispyb_detector_id = AttributeSignal(
+            attr="detector_id",
+            parent=self,
+            name="eiger-ispyb_detector_id",
+            write_access=False,
+        )
+
         # using i03 timeouts as default
         self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
         self.disarming_status = None
@@ -75,10 +89,11 @@ class EigerDetector(Device, Stageable):
     def with_params(
         cls,
         params: DetectorParams,
-        name: str = "EigerDetector",
         beamline: str = "i03",
+        ispyb_detector_id: int | None = None,
+        name: str = "EigerDetector",
     ):
-        det = cls(name=name, beamline=beamline)
+        det = cls(name=name, beamline=beamline, ispyb_detector_id=ispyb_detector_id)
         det.set_detector_parameters(params)
         return det
 
@@ -123,7 +138,7 @@ class EigerDetector(Device, Stageable):
             LOGGER.info("Waiting for arming to finish")
             self.arming_status.wait(self.timeouts.arming_timeout)
 
-    def stage(self):
+    def stage(self):  # pyright: ignore[reportIncompatibleMethodOverride]
         self.wait_on_arming_if_started()
         if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
@@ -132,6 +147,7 @@ class EigerDetector(Device, Stageable):
 
     def stop_odin_when_all_frames_collected(self):
         LOGGER.info("Waiting on all frames")
+        assert self.detector_params
         try:
             await_value(
                 self.odin.file_writer.num_captured,
@@ -141,7 +157,7 @@ class EigerDetector(Device, Stageable):
             LOGGER.info("Stopping Odin")
             self.odin.stop().wait(self.timeouts.odin_stop_timeout)
 
-    def unstage(self) -> bool:
+    def unstage(self) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
         assert self.detector_params is not None
         try:
             self.disarming_status = Status()
@@ -166,7 +182,7 @@ class EigerDetector(Device, Stageable):
         self.disarming_status.set_finished()
         return status_ok
 
-    def stop(self, *args):
+    def stop(self, *args):  # pyright: ignore[reportIncompatibleMethodOverride]
         """Emergency stop the device, mainly used to clean up after error."""
         LOGGER.info("Eiger stop() called - cleaning up...")
         if self.disarming_status and not self.disarming_status.done:
@@ -241,7 +257,8 @@ class EigerDetector(Device, Stageable):
             1, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.image_mode.set(
-            self.cam.ImageMode.MULTIPLE, timeout=self.timeouts.general_status_timeout
+            self.cam.ImageMode.MULTIPLE,  # pyright: ignore[reportAttributeAccessIssue]
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.trigger_mode.set(
             InternalEigerTriggerMode.EXTERNAL_SERIES.value,
@@ -285,25 +302,24 @@ class EigerDetector(Device, Stageable):
         beam_x_pixels, beam_y_pixels = self.detector_params.get_beam_position_pixels(
             self.detector_params.detector_distance
         )
-        status = self.cam.beam_center_x.set(
+        self.cam.beam_center_x.set(
             beam_x_pixels, timeout=self.timeouts.general_status_timeout
-        )
-        status &= self.cam.beam_center_y.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        self.cam.beam_center_y.set(
             beam_y_pixels, timeout=self.timeouts.general_status_timeout
-        )
-        status &= self.cam.det_distance.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        self.cam.det_distance.set(
             self.detector_params.detector_distance,
             timeout=self.timeouts.general_status_timeout,
-        )
-        status &= self.cam.omega_start.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        self.cam.omega_start.set(
             self.detector_params.omega_start,
             timeout=self.timeouts.general_status_timeout,
-        )
-        status &= self.cam.omega_incr.set(
+        ).wait(timeout=self.timeouts.general_status_timeout)
+        status = self.cam.omega_incr.set(
             self.detector_params.omega_increment,
             timeout=self.timeouts.general_status_timeout,
         )
-
         return status
 
     def set_detector_threshold(self, energy: float, tolerance: float = 0.1) -> Status:
@@ -315,7 +331,7 @@ class EigerDetector(Device, Stageable):
                 this tolerance it is not set again. Defaults to 0.1eV.
         """
 
-        current_energy = self.cam.photon_energy.get()
+        current_energy = float(self.cam.photon_energy.get())
         if abs(current_energy - energy) > tolerance:
             LOGGER.info(f"Setting detector threshold to {energy}")
             return self.cam.photon_energy.set(
@@ -398,7 +414,7 @@ class EigerDetector(Device, Stageable):
     def disarm_detector(self):
         self.cam.acquire.set(0).wait(self.timeouts.general_status_timeout)
 
-    def wait_for_stale_params(self) -> Status:
+    def wait_for_stale_params(self) -> SubscriptionStatus:
         LOGGER.info("Eiger arming: Waiting for stale params...")
         return await_value(self.stale_params, 0, 60)
 
@@ -412,6 +428,11 @@ class EigerDetector(Device, Stageable):
         detector_params: DetectorParams = self.detector_params
         if detector_params.use_roi_mode:
             functions_to_do_arm.append(self.enable_roi_mode)
+        threshold_energy = (
+            detector_params.expected_energy_ev
+            if detector_params.expected_energy_ev
+            else float(self.cam.photon_energy.get())
+        )
 
         arming_sequence_funcs = [
             # If a beam dump occurs after arming the eiger but prior to eiger staging,
@@ -419,7 +440,7 @@ class EigerDetector(Device, Stageable):
             # if this previously completed successfully we must reset the odin first
             self.odin.stop,
             lambda: self.change_dev_shm(detector_params.enable_dev_shm),
-            lambda: self.set_detector_threshold(detector_params.expected_energy_ev),
+            lambda: self.set_detector_threshold(threshold_energy),
             self.set_cam_pvs,
             self.set_odin_number_of_frame_chunks,
             self.set_odin_pvs,

dodal/devices/electron_analyser/__init__.py

@@ -1,33 +0,0 @@
-from .detector import (
-    ElectronAnalyserDetector,
-    ElectronAnalyserRegionDetector,
-    TElectronAnalyserDetector,
-    TElectronAnalyserRegionDetector,
-)
-from .energy_sources import DualEnergySource, EnergySource
-from .enums import EnergyMode, SelectedSource
-from .types import (
-    ElectronAnalyserDetectorImpl,
-    ElectronAnalyserDriverImpl,
-    GenericElectronAnalyserDetector,
-    GenericElectronAnalyserRegionDetector,
-)
-from .util import to_binding_energy, to_kinetic_energy
-
-__all__ = [
-    "to_binding_energy",
-    "to_kinetic_energy",
-    "DualEnergySource",
-    "SelectedSource",
-    "EnergySource",
-    "EnergyMode",
-    "SelectedSource",
-    "ElectronAnalyserDetector",
-    "ElectronAnalyserDetectorImpl",
-    "ElectronAnalyserDriverImpl",
-    "TElectronAnalyserDetector",
-    "ElectronAnalyserRegionDetector",
-    "TElectronAnalyserRegionDetector",
-    "GenericElectronAnalyserDetector",
-    "GenericElectronAnalyserRegionDetector",
-]

dodal/devices/electron_analyser/base/__init__.py

@@ -0,0 +1,58 @@
+from .base_controller import (
+    ElectronAnalyserController,
+    GenericElectronAnalyserController,
+)
+from .base_detector import (
+    BaseElectronAnalyserDetector,
+    ElectronAnalyserDetector,
+    ElectronAnalyserRegionDetector,
+    GenericBaseElectronAnalyserDetector,
+    GenericElectronAnalyserDetector,
+    GenericElectronAnalyserRegionDetector,
+)
+from .base_driver_io import (
+    AbstractAnalyserDriverIO,
+    GenericAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from .base_enums import EnergyMode
+from .base_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+    GenericRegion,
+    GenericSequence,
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+    TAcquisitionMode,
+    TLensMode,
+)
+from .base_util import to_binding_energy, to_kinetic_energy
+from .energy_sources import AbstractEnergySource, DualEnergySource, EnergySource
+
+__all__ = [
+    "ElectronAnalyserController",
+    "GenericElectronAnalyserController",
+    "BaseElectronAnalyserDetector",
+    "ElectronAnalyserDetector",
+    "ElectronAnalyserRegionDetector",
+    "GenericBaseElectronAnalyserDetector",
+    "GenericElectronAnalyserDetector",
+    "GenericElectronAnalyserRegionDetector",
+    "AbstractAnalyserDriverIO",
+    "GenericAnalyserDriverIO",
+    "TAbstractAnalyserDriverIO",
+    "EnergyMode",
+    "AbstractBaseRegion",
+    "AbstractBaseSequence",
+    "GenericRegion",
+    "GenericSequence",
+    "TAbstractBaseRegion",
+    "TAbstractBaseSequence",
+    "TAcquisitionMode",
+    "TLensMode",
+    "to_binding_energy",
+    "to_kinetic_energy",
+    "AbstractEnergySource",
+    "DualEnergySource",
+    "EnergySource",
+]

dodal/devices/electron_analyser/base/base_controller.py

@@ -0,0 +1,84 @@
+from typing import Generic, TypeVar
+
+from ophyd_async.core import TriggerInfo
+from ophyd_async.epics.adcore import ADImageMode
+
+from dodal.devices.controllers import ConstantDeadTimeController
+from dodal.devices.electron_analyser.base.base_driver_io import (
+    GenericAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.base.base_region import (
+    GenericRegion,
+    TAbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
+
+
+class ElectronAnalyserController(
+    ConstantDeadTimeController[TAbstractAnalyserDriverIO],
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Specialised controller for the electron analysers to provide additional setup logic
+    such as selecting the energy source to use from requested region and giving the
+    driver the correct region parameters.
+    """
+
+    def __init__(
+        self,
+        driver: TAbstractAnalyserDriverIO,
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
+        deadtime: float = 0,
+        image_mode: ADImageMode = ADImageMode.SINGLE,
+    ):
+        """
+        Parameters:
+            driver: The electron analyser driver to wrap around that holds the PV's.
+            energy_source: Device that holds the excitation energy and ability to switch
+                           between sources.
+            deadtime: For a given exposure, what is the safest minimum time between
+                      exposures that can be determined without reading signals.
+            image_mode: The image mode to configure the driver with before measuring.
+        """
+        self.energy_source = energy_source
+        self.shutter = shutter
+        self.source_selector = source_selector
+        super().__init__(driver, deadtime, image_mode)
+
+    async def setup_with_region(self, region: TAbstractBaseRegion) -> None:
+        """Logic to set the driver with a region."""
+        if self.source_selector is not None:
+            await self.source_selector.set(region.excitation_energy_source)
+
+        # Should this be moved to a VGScientController only?
+        if self.shutter is not None:
+            await self.shutter.set(self.shutter.close_state)
+
+        excitation_energy = await self.energy_source.energy.get_value()
+        epics_region = region.prepare_for_epics(excitation_energy)
+        await self.driver.set(epics_region)
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        """Do all necessary steps to prepare the detector for triggers."""
+        # Let the driver know the excitation energy before measuring for binding energy
+        # axis calculation.
+        excitation_energy = await self.energy_source.energy.get_value()
+        await self.driver.cached_excitation_energy.set(excitation_energy)
+
+        if self.shutter is not None:
+            await self.shutter.set(self.shutter.open_state)
+
+        await super().prepare(trigger_info)
+
+
+GenericElectronAnalyserController = ElectronAnalyserController[
+    GenericAnalyserDriverIO, GenericRegion
+]
+TElectronAnalyserController = TypeVar(
+    "TElectronAnalyserController", bound=ElectronAnalyserController
+)

dodal/devices/electron_analyser/base/base_detector.py

@@ -0,0 +1,214 @@
+from typing import Generic, TypeVar
+
+from bluesky.protocols import Reading, Stageable, Triggerable
+from event_model import DataKey
+from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
+    AsyncStatus,
+    Device,
+    TriggerInfo,
+)
+
+from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_driver_io import (
+    GenericAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.base.base_region import (
+    GenericRegion,
+    GenericSequence,
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+
+class BaseElectronAnalyserDetector(
+    Device,
+    Triggerable,
+    AsyncReadable,
+    AsyncConfigurable,
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    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,
+        controller: ElectronAnalyserController[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ],
+        name: str = "",
+    ):
+        self._controller = controller
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, region: TAbstractBaseRegion) -> None:
+        await self._controller.setup_with_region(region)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        await self._controller.prepare(TriggerInfo())
+        await self._controller.arm()
+        await self._controller.wait_for_idle()
+
+    async def read(self) -> dict[str, Reading]:
+        return await self._controller.driver.read()
+
+    async def describe(self) -> dict[str, DataKey]:
+        data = await self._controller.driver.describe()
+        # Correct the shape for image
+        prefix = self._controller.driver.name + "-"
+        energy_size = len(await self._controller.driver.energy_axis.get_value())
+        angle_size = len(await self._controller.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._controller.driver.read_configuration()
+
+    async def describe_configuration(self) -> dict[str, DataKey]:
+        return await self._controller.driver.describe_configuration()
+
+
+GenericBaseElectronAnalyserDetector = BaseElectronAnalyserDetector[
+    GenericAnalyserDriverIO, GenericRegion
+]
+
+
+class ElectronAnalyserRegionDetector(
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Extends electron analyser detector to configure specific region settings before data
+    acquisition. It is designed to only exist inside a plan.
+    """
+
+    def __init__(
+        self,
+        controller: ElectronAnalyserController[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ],
+        region: TAbstractBaseRegion,
+        name: str = "",
+    ):
+        self.region = region
+        super().__init__(controller, name)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        # Configure region parameters on the driver first before data collection.
+        await self.set(self.region)
+        await super().trigger()
+
+
+GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
+    GenericAnalyserDriverIO, GenericRegion
+]
+TElectronAnalyserRegionDetector = TypeVar(
+    "TElectronAnalyserRegionDetector",
+    bound=ElectronAnalyserRegionDetector,
+)
+
+
+class ElectronAnalyserDetector(
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+    Stageable,
+    Generic[TAbstractBaseSequence, TAbstractAnalyserDriverIO, 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,
+        sequence_class: type[TAbstractBaseSequence],
+        controller: ElectronAnalyserController[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ],
+        name: str = "",
+    ):
+        self._sequence_class = sequence_class
+        super().__init__(controller, name)
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        """
+        Prepare the detector for use by ensuring it is idle and ready.
+
+        This method asynchronously stages the detector by first disarming the controller
+        to ensure the detector is not actively acquiring data, then invokes the driver's
+        stage procedure. This ensures the detector is in a known, ready state
+        before use.
+
+        Raises:
+            Any exceptions raised by the driver's stage or controller's disarm methods.
+        """
+        await self._controller.disarm()
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        """Disarm the detector."""
+        await self._controller.disarm()
+
+    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: list[TAbstractBaseRegion] = (
+            seq.get_enabled_regions() if enabled_only else seq.regions
+        )
+        return [
+            ElectronAnalyserRegionDetector[
+                TAbstractAnalyserDriverIO, TAbstractBaseRegion
+            ](self._controller, r, self.name + "_" + r.name)
+            for r in regions
+        ]
+
+
+GenericElectronAnalyserDetector = ElectronAnalyserDetector[
+    GenericSequence, GenericAnalyserDriverIO, GenericRegion
+]
+TElectronAnalyserDetector = TypeVar(
+    "TElectronAnalyserDetector",
+    bound=ElectronAnalyserDetector,
+)