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

dodal/beamlines/p99.py

@@ -1,7 +1,22 @@
-from dodal.common.beamlines.beamline_utils import device_factory, set_beamline
+from pathlib import Path
+
+from ophyd_async.epics.adandor import Andor2Detector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+    get_path_provider,
+    set_beamline,
+    set_path_provider,
+)
+from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
+from dodal.common.visit import (
+    LocalDirectoryServiceClient,
+    StaticVisitPathProvider,
+)
 from dodal.devices.attenuator.filter import FilterMotor
 from dodal.devices.attenuator.filter_selections import P99FilterSelections
 from dodal.devices.motors import XYZPositioner
+from dodal.devices.p99.andor2_point import Andor2Point
 from dodal.devices.p99.sample_stage import SampleAngleStage
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
@@ -19,9 +34,7 @@ def angle_stage() -> SampleAngleStage:
 
 @device_factory()
 def filter() -> FilterMotor:
-    return FilterMotor(
-        f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:SELECT", P99FilterSelections
-    )
+    return FilterMotor(f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:", P99FilterSelections)
 
 
 @device_factory()
@@ -32,3 +45,34 @@ def sample_stage() -> XYZPositioner:
 @device_factory()
 def lab_stage() -> XYZPositioner:
     return XYZPositioner(f"{PREFIX.beamline_prefix}-MO-STAGE-02:LAB:")
+
+
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/dls/p99/data/2024/cm37284-2/processing/writenData"),
+        client=LocalDirectoryServiceClient(),  # RemoteDirectoryServiceClient("http://p99-control:8088/api"),
+    )
+)
+
+
+@device_factory()
+def andor2_det() -> Andor2Detector:
+    """Andor model:DU897_BV."""
+    return Andor2Detector(
+        prefix=f"{PREFIX.beamline_prefix}-EA-DET-03:",
+        path_provider=get_path_provider(),
+        drv_suffix=CAM_SUFFIX,
+        fileio_suffix=HDF5_SUFFIX,
+    )
+
+
+@device_factory()
+def andor2_point() -> Andor2Point:
+    """Using the andor2 as if it is a massive point detector, read the meanValue and total after
+    a picture is taken."""
+    return Andor2Point(
+        prefix=f"{PREFIX.beamline_prefix}-EA-DET-03:",
+        drv_suffix=CAM_SUFFIX,
+        read_uncached={"mean": "STAT:MeanValue_RBV", "total": "STAT:Total_RBV"},
+    )

dodal/common/beamlines/beamline_parameters.py

@@ -8,7 +8,6 @@ BEAMLINE_PARAMETER_KEYWORDS = ["FB", "FULL", "deadtime"]
 BEAMLINE_PARAMETER_PATHS = {
     "i03": "/dls_sw/i03/software/daq_configuration/domain/beamlineParameters",
     "i04": "/dls_sw/i04/software/gda_versions/gda_9_34/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
-    "s03": "tests/test_data/test_beamline_parameters.txt",
 }
 
 
@@ -92,7 +91,7 @@ def get_beamline_parameters(beamline_param_path: str | None = None):
     """Loads the beamline parameters from the specified path, or according to the
     environment variable if none is given"""
     if not beamline_param_path:
-        beamline_name = get_beamline_name("s03")
+        beamline_name = get_beamline_name("i03")
         beamline_param_path = BEAMLINE_PARAMETER_PATHS.get(beamline_name)
         if beamline_param_path is None:
             raise KeyError(

dodal/common/data_util.py

@@ -1,3 +1,4 @@
+import os
 from typing import TypeVar
 
 from pydantic import BaseModel
@@ -9,6 +10,9 @@ def load_json_file_to_class(
     t: type[TBaseModel],
     file: str,
 ) -> TBaseModel:
+    if not os.path.isfile(file):
+        raise FileNotFoundError(f"Cannot find file {file}")
+
     with open(file) as f:
         json_obj = f.read()
     cls = t.model_validate_json(json_obj)

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,8 @@
+from .types import EnergyMode
+from .util import to_binding_energy, to_kinetic_energy
+
+__all__ = [
+    "to_binding_energy",
+    "to_kinetic_energy",
+    "EnergyMode",
+]

dodal/devices/electron_analyser/abstract/__init__.py

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

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -0,0 +1,210 @@
+import asyncio
+from abc import abstractmethod
+from typing import Generic, TypeVar
+
+from bluesky.protocols import (
+    Reading,
+    Stageable,
+    Triggerable,
+)
+from event_model import DataKey
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    Reference,
+)
+from ophyd_async.core._protocol import AsyncConfigurable, AsyncReadable
+from ophyd_async.epics.adcore import (
+    ADBaseController,
+)
+
+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 AnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
+    def get_deadtime(self, exposure: float | None) -> float:
+        return 0
+
+
+class BaseElectronAnalyserDetector(
+    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 inheirt 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: AnalyserController = AnalyserController(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 property for the driver. Some implementations will store this as a
+        reference so it doesn't run into errors with conflicting parents.
+        """
+
+
+class AbstractElectronAnalyserRegionDetector(
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Stageable,
+    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 stage(self) -> None:
+        super().stage()
+        self.configure_region()
+
+    @abstractmethod
+    def configure_region(self):
+        """
+        Setup analyser with configured region.
+        """
+
+
+TAbstractElectronAnalyserRegionDetector = TypeVar(
+    "TAbstractElectronAnalyserRegionDetector",
+    bound=AbstractElectronAnalyserRegionDetector,
+)
+
+
+class AbstractElectronAnalyserDetector(
+    BaseElectronAnalyserDetector[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, name: str, sequence_class: type[TAbstractBaseSequence]
+    ):
+        self._driver = self._create_driver(prefix)
+        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:
+        return load_json_file_to_class(self._sequence_class, filename)
+
+    @abstractmethod
+    def _create_driver(self, prefix: str) -> TAbstractAnalyserDriverIO:
+        """
+        Define implementation of the driver used for this detector.
+        """
+
+    @abstractmethod
+    def _create_region_detector(
+        self, driver: TAbstractAnalyserDriverIO, region: TAbstractBaseRegion
+    ) -> AbstractElectronAnalyserRegionDetector[
+        TAbstractAnalyserDriverIO, TAbstractBaseRegion
+    ]:
+        """
+        Define a way to create a temporary detector object that will always setup a
+        specific region before acquiring.
+        """
+
+    def create_region_detector_list(
+        self, filename: str
+    ) -> list[
+        AbstractElectronAnalyserRegionDetector[
+            TAbstractAnalyserDriverIO, TAbstractBaseRegion
+        ]
+    ]:
+        """
+        Create a list of detectors that will setup a specific region from the sequence
+        file when used.
+        """
+        seq = self.load_sequence(filename)
+        return [
+            self._create_region_detector(self.driver, r)
+            for r in seq.get_enabled_regions()
+        ]
+
+
+TAbstractElectronAnalyserDetector = TypeVar(
+    "TAbstractElectronAnalyserDetector",
+    bound=AbstractElectronAnalyserDetector,
+)