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

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,
+)

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -0,0 +1,121 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+import numpy as np
+from ophyd_async.core import (
+    Array1D,
+    SignalR,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_r,
+    soft_signal_rw,
+)
+from ophyd_async.epics.adcore import ADBaseIO
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.util import to_binding_energy
+
+
+class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
+    """
+    Generic device to configure electron analyser with new region settings.
+    Electron analysers should inherit from this class for further specialisation.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
+            self.spectrum = epics_signal_r(Array1D[np.float64], prefix + "INT_SPECTRUM")
+            self.total_intensity = derived_signal_r(
+                self._calculate_total_intensity, spectrum=self.spectrum
+            )
+            self.excitation_energy = soft_signal_rw(float, initial_value=0, units="eV")
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.region_name = soft_signal_rw(str, initial_value="null")
+            self.energy_mode = soft_signal_rw(
+                EnergyMode, initial_value=EnergyMode.KINETIC
+            )
+            self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
+            self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
+            self.slices = epics_signal_rw(int, prefix + "SLICES")
+            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.pass_energy = epics_signal_rw(
+                self.pass_energy_type, prefix + "PASS_ENERGY"
+            )
+            self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
+            self.iterations = epics_signal_rw(int, prefix + "NumExposures")
+            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
+
+            # Read once per scan after data acquired
+            self.energy_axis = self._create_energy_axis_signal(prefix)
+            self.binding_energy_axis = derived_signal_r(
+                self._calculate_binding_energy_axis,
+                "eV",
+                energy_axis=self.energy_axis,
+                excitation_energy=self.excitation_energy,
+                energy_mode=self.energy_mode,
+            )
+            self.angle_axis = self._create_angle_axis_signal(prefix)
+            self.step_time = epics_signal_r(float, prefix + "AcquireTime")
+            self.total_steps = epics_signal_r(int, prefix + "TOTAL_POINTS_RBV")
+            self.total_time = derived_signal_r(
+                self._calculate_total_time,
+                "s",
+                total_steps=self.total_steps,
+                step_time=self.step_time,
+                iterations=self.iterations,
+            )
+
+        super().__init__(prefix=prefix, name=name)
+
+    @abstractmethod
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        """
+        The signal that defines the angle axis. Depends on analyser model.
+        """
+
+    @abstractmethod
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        """
+        The signal that defines the energy axis. Depends on analyser model.
+        """
+
+    def _calculate_binding_energy_axis(
+        self,
+        energy_axis: Array1D[np.float64],
+        excitation_energy: float,
+        energy_mode: EnergyMode,
+    ) -> Array1D[np.float64]:
+        is_binding = energy_mode == EnergyMode.BINDING
+        return np.array(
+            [
+                to_binding_energy(i_energy_axis, EnergyMode.KINETIC, excitation_energy)
+                if is_binding
+                else i_energy_axis
+                for i_energy_axis in energy_axis
+            ]
+        )
+
+    def _calculate_total_time(
+        self, total_steps: int, step_time: float, iterations: int
+    ) -> float:
+        return total_steps * step_time * iterations
+
+    def _calculate_total_intensity(self, spectrum: Array1D[np.float64]) -> float:
+        return float(np.sum(spectrum, dtype=np.float64))
+
+    @property
+    @abstractmethod
+    def pass_energy_type(self) -> type:
+        """
+        Return the type the pass_energy should be. Each one is unfortunately different
+        for the underlying analyser software and cannot be changed on epics side.
+        """
+
+
+TAbstractAnalyserDriverIO = TypeVar(
+    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
+)

dodal/devices/electron_analyser/{abstract_region.py → abstract/base_region.py}

@@ -1,11 +1,12 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from enum import Enum
 from typing import Generic, TypeVar
 
 from pydantic import BaseModel, Field, model_validator
 
+from dodal.devices.electron_analyser.types import EnergyMode
+
 
 def java_to_python_case(java_str: str) -> str:
     """
@@ -42,11 +43,6 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class EnergyMode(str, Enum):
-    KINETIC = "Kinetic"
-    BINDING = "Binding"
-
-
 class AbstractBaseRegion(ABC, JavaToPythonModel):
     """
     Generic region model that holds the data. Specialised region models should inherit
@@ -73,9 +69,6 @@ class AbstractBaseRegion(ABC, JavaToPythonModel):
     def is_kinetic_energy(self) -> bool:
         return self.energy_mode == EnergyMode.KINETIC
 
-    def to_kinetic_energy(self, value: float, excitation_energy: float) -> float:
-        return value if self.is_binding_energy() else excitation_energy - value
-
     @model_validator(mode="before")
     @classmethod
     def before_validation(cls, data: dict) -> dict:

dodal/devices/electron_analyser/specs/__init__.py

@@ -0,0 +1,11 @@
+from .detector import SpecsDetector, SpecsRegionDetector
+from .driver_io import SpecsAnalyserDriverIO
+from .region import SpecsRegion, SpecsSequence
+
+__all__ = [
+    "SpecsDetector",
+    "SpecsRegionDetector",
+    "SpecsAnalyserDriverIO",
+    "SpecsRegion",
+    "SpecsSequence",
+]

dodal/devices/electron_analyser/specs/detector.py

@@ -0,0 +1,29 @@
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    AbstractElectronAnalyserDetector,
+    AbstractElectronAnalyserRegionDetector,
+)
+from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
+from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
+
+
+class SpecsRegionDetector(
+    AbstractElectronAnalyserRegionDetector[SpecsAnalyserDriverIO, SpecsRegion]
+):
+    def configure_region(self):
+        # ToDo - Need to move configure plans to here and rewrite tests
+        pass
+
+
+class SpecsDetector(
+    AbstractElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+):
+    def __init__(self, prefix: str, name: str):
+        super().__init__(prefix, name, SpecsSequence)
+
+    def _create_driver(self, prefix: str) -> SpecsAnalyserDriverIO:
+        return SpecsAnalyserDriverIO(prefix, "driver")
+
+    def _create_region_detector(
+        self, driver: SpecsAnalyserDriverIO, region: SpecsRegion
+    ) -> SpecsRegionDetector:
+        return SpecsRegionDetector(self.name, driver, region)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -0,0 +1,64 @@
+import numpy as np
+from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, derived_signal_r
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+
+
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
+            self.snapshot_values = epics_signal_rw(int, prefix + "VALUES")
+            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
+
+            # Used to read detector data after acqusition.
+            self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
+            self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
+
+        super().__init__(prefix, name)
+
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        angle_axis = derived_signal_r(
+            self._calculate_angle_axis,
+            min_angle=self.min_angle_axis,
+            max_angle=self.max_angle_axis,
+            slices=self.slices,
+        )
+        return angle_axis
+
+    def _calculate_angle_axis(
+        self, min_angle: float, max_angle: float, slices: int
+    ) -> Array1D[np.float64]:
+        # SPECS returns the extreme edges of the range, not the centre of the pixels
+        width = (max_angle - min_angle) / slices
+        offset = width / 2
+
+        axis = np.array([min_angle + offset + i * width for i in range(slices)])
+        return axis
+
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        energy_axis = derived_signal_r(
+            self._calculate_energy_axis,
+            "eV",
+            min_energy=self.low_energy,
+            max_energy=self.high_energy,
+            total_points_iterations=self.slices,
+        )
+        return energy_axis
+
+    def _calculate_energy_axis(
+        self, min_energy: float, max_energy: float, total_points_iterations: int
+    ) -> Array1D[np.float64]:
+        # Note: Don't use the energy step because of the case where the step doesn't
+        # exactly fill the range
+        step = (max_energy - min_energy) / (total_points_iterations - 1)
+        axis = np.array([min_energy + i * step for i in range(total_points_iterations)])
+        return axis
+
+    @property
+    def pass_energy_type(self) -> type:
+        return float

dodal/devices/electron_analyser/{specs_region.py → specs/region.py}

@@ -1,6 +1,6 @@
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract_region import (
+from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
 )

dodal/devices/electron_analyser/types.py

@@ -0,0 +1,6 @@
+from ophyd_async.core import StrictEnum
+
+
+class EnergyMode(StrictEnum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"

dodal/devices/electron_analyser/util.py

@@ -0,0 +1,13 @@
+from dodal.devices.electron_analyser.types import EnergyMode
+
+
+def to_kinetic_energy(
+    value: float, value_mode: EnergyMode, excitation_energy: float
+) -> float:
+    return value if value_mode == EnergyMode.KINETIC else excitation_energy - value
+
+
+def to_binding_energy(
+    value: float, value_mode: EnergyMode, excitation_energy: float
+) -> float:
+    return value if value_mode == EnergyMode.BINDING else excitation_energy - value

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -0,0 +1,12 @@
+from .detector import VGScientaDetector, VGScientaRegionDetector
+from .driver_io import VGScientaAnalyserDriverIO
+from .region import VGScientaExcitationEnergySource, VGScientaRegion, VGScientaSequence
+
+__all__ = [
+    "VGScientaDetector",
+    "VGScientaRegionDetector",
+    "VGScientaAnalyserDriverIO",
+    "VGScientaExcitationEnergySource",
+    "VGScientaRegion",
+    "VGScientaSequence",
+]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -0,0 +1,36 @@
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    AbstractElectronAnalyserDetector,
+    AbstractElectronAnalyserRegionDetector,
+)
+from dodal.devices.electron_analyser.vgscienta.driver_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
+    VGScientaRegion,
+    VGScientaSequence,
+)
+
+
+class VGScientaRegionDetector(
+    AbstractElectronAnalyserRegionDetector[VGScientaAnalyserDriverIO, VGScientaRegion]
+):
+    def configure_region(self):
+        # ToDo - Need to move configure plans to here and rewrite tests
+        pass
+
+
+class VGScientaDetector(
+    AbstractElectronAnalyserDetector[
+        VGScientaAnalyserDriverIO, VGScientaSequence, VGScientaRegion
+    ]
+):
+    def __init__(self, prefix: str, name: str):
+        super().__init__(prefix, name, VGScientaSequence)
+
+    def _create_driver(self, prefix: str) -> VGScientaAnalyserDriverIO:
+        return VGScientaAnalyserDriverIO(prefix, "driver")
+
+    def _create_region_detector(
+        self, driver: VGScientaAnalyserDriverIO, region: VGScientaRegion
+    ) -> VGScientaRegionDetector:
+        return VGScientaRegionDetector(self.name, driver, region)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -0,0 +1,39 @@
+import numpy as np
+from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, soft_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
+    DetectorMode,
+)
+
+
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.excitation_energy_source = soft_signal_rw(str, initial_value=None)
+            # Used for setting up region data acquisition.
+            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
+            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
+            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
+            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
+            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
+            self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
+
+        with self.add_children_as_readables():
+            # Used to read detector data after acqusition.
+            self.external_io = epics_signal_r(Array1D[np.float64], prefix + "EXTIO")
+
+        super().__init__(prefix, name)
+
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        return epics_signal_r(Array1D[np.float64], prefix + "X_SCALE_RBV")
+
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        return epics_signal_r(Array1D[np.float64], prefix + "Y_SCALE_RBV")
+
+    @property
+    def pass_energy_type(self) -> type:
+        return str

dodal/devices/electron_analyser/{vgscienta_region.py → vgscienta/region.py}

@@ -4,7 +4,7 @@ from enum import Enum
 from ophyd_async.core import StrictEnum
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract_region import (
+from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
     JavaToPythonModel,

dodal/devices/fast_grid_scan.py

@@ -12,6 +12,7 @@ from ophyd_async.core import (
     Signal,
     SignalRW,
     StandardReadable,
+    derived_signal_r,
     wait_for_value,
 )
 from ophyd_async.epics.core import (
@@ -23,7 +24,6 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -203,8 +203,11 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = create_r_hardware_backed_soft_signal(
-            float, self._calculate_expected_images
+        self.expected_images = derived_signal_r(
+            self._calculate_expected_images,
+            x=self.x_steps,
+            y=self.y_steps,
+            z=self.z_steps,
         )
 
         self.motion_program = MotionProgram(smargon_prefix)
@@ -231,12 +234,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
-    async def _calculate_expected_images(self):
-        x, y, z = await asyncio.gather(
-            self.x_steps.get_value(),
-            self.y_steps.get_value(),
-            self.z_steps.get_value(),
-        )
+    def _calculate_expected_images(self, x: float, y: float, z: float) -> float:
         LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
         first_grid = x * y
         second_grid = x * z

dodal/devices/i03/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+
+__all__ = ["Beamstop", "BeamstopPositions"]