Create initial analyserscan plan

src/dodal/common/data_util.py

@@ -1,3 +1,4 @@
+import os
 from typing import TypeVar
 
 from pydantic import BaseModel
@@ -9,6 +10,9 @@
     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)

src/dodal/devices/electron_analyser/__init__.py

@@ -1,4 +1,5 @@
 from .abstract_region import EnergyMode
+from .detector import ElectronAnalyserDetector, ElectronAnalyserRegionDetector
 from .specs_analyser_io import SpecsAnalyserDriverIO
 from .specs_region import SpecsRegion, SpecsSequence
 from .util import to_binding_energy, to_kinetic_energy
@@ -11,6 +12,8 @@
 
 __all__ = [
     "EnergyMode",
+    "ElectronAnalyserDetector",
+    "ElectronAnalyserRegionDetector",
     "SpecsAnalyserDriverIO",
     "SpecsRegion",
     "SpecsSequence",

src/dodal/devices/electron_analyser/abstract_analyser_io.py

@@ -1,9 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import TypeVar
+from typing import Generic, TypeVar
 
 import numpy as np
 from ophyd_async.core import (
     Array1D,
+    Reference,
     SignalR,
     StandardReadable,
     StandardReadableFormat,
@@ -13,17 +14,32 @@
 from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract_region import EnergyMode
+from dodal.devices.electron_analyser.abstract_region import (
+    EnergyMode,
+    TAbstractBaseSequence,
+)
 from dodal.devices.electron_analyser.util import to_binding_energy
 
 
-class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
+class AbstractAnalyserDriverIO(
+    ABC, StandardReadable, ADBaseIO, Generic[TAbstractBaseSequence]
+):
     """
     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 = Reference(
+                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")
@@ -40,28 +56,8 @@
             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")
-            self.step_time = epics_signal_r(float, prefix + "AcquireTime")
 
-            self.total_steps = self._create_total_steps_signal(prefix)
-            self.total_time = derived_signal_r(
-                self._calculate_total_time,
-                "s",
-                total_steps=self.total_steps,
-                step_time=self.step_time,
-                iterations=self.iterations,
-            )
-
-        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
-            )
-            # ToDo - Ideally the below are only collected once per region. However, they
-            # need to be read after the first point of a region (stream). Bluesky /
-            # ophyd currently doesn't support this and therefore must be read per point
-            # as a workaround, otherwise they return the previous region values.
-            self.excitation_energy = soft_signal_rw(float, initial_value=0, units="eV")
+            # 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,
@@ -71,6 +67,16 @@
                 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
@@ -101,20 +107,13 @@
             ]
         )
 
-    @abstractmethod
-    def _create_total_steps_signal(self, prefix: str) -> SignalR[int]:
-        """
-        The signal that defines the total steps. Depends if analyser knows this
-        information before the first point.
-        """
-
     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))
+        return float(np.sum(spectrum, dtype=np.float64))
 
     @property
     @abstractmethod
@@ -124,6 +123,10 @@
         for the underlying analyser software and cannot be changed on epics side.
         """
 
+    @abstractmethod
+    def sequence_type(self) -> type[TAbstractBaseSequence]:
+        pass
+
 
 TAbstractAnalyserDriverIO = TypeVar(
     "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO

src/dodal/devices/electron_analyser/detector.py

@@ -0,0 +1,185 @@
+import asyncio
+from typing import Generic
+
+from bluesky.protocols import (
+    Reading,
+    Stageable,
+    Triggerable,
+)
+from event_model import DataKey
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    Device,
+    Reference,
+    set_and_wait_for_value,
+)
+from ophyd_async.core._protocol import AsyncConfigurable, AsyncReadable
+from ophyd_async.epics.adcore import (
+    DEFAULT_GOOD_STATES,
+    ADState,
+    stop_busy_record,
+)
+
+from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract_region import (
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+
+class AnalyserController:
+    def __init__(
+        self,
+        driver: AbstractAnalyserDriverIO,
+        good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
+    ) -> None:
+        self.driver = driver
+        self.good_states = good_states
+        self.frame_timeout = DEFAULT_TIMEOUT
+        self._arm_status: AsyncStatus | None = None
+
+    async def arm(self):
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
+
+    async def disarm(self):
+        # We can't use caput callback as we already used it in arm() and we can't have
+        # 2 or they will deadlock
+        await stop_busy_record(self.driver.acquire, False, timeout=1)
+
+    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+        """Start acquiring driver, raising ValueError if the detector is in a bad state.
+        This sets driver.acquire to True, and waits for it to be True up to a timeout.
+        Then, it checks that the DetectorState PV is in DEFAULT_GOOD_STATES,
+        and otherwise raises a ValueError.
+        :returns AsyncStatus:
+            An AsyncStatus that can be awaited to set driver.acquire to True and perform
+            subsequent raising (if applicable) due to detector state.
+        """
+        status = await set_and_wait_for_value(
+            self.driver.acquire,
+            True,
+            timeout=DEFAULT_TIMEOUT,
+            wait_for_set_completion=False,
+        )
+
+        async def complete_acquisition() -> None:
+            # NOTE: possible race condition here between the callback from
+            # set_and_wait_for_value and the detector state updating.
+            await status
+            state = await self.driver.detector_state.get_value()
+            if state not in self.good_states:
+                raise ValueError(
+                    f"Final detector state {state.value} not "
+                    "in valid end states: {self.good_states}"
+                )
+
+        return AsyncStatus(complete_acquisition())
+
+    async def wait_for_idle(self):
+        if self._arm_status and not self._arm_status.done:
+            await self._arm_status
+        self._arm_status = None
+
+
+class BaseElectronAnalyserDetector(
+    Device,
+    Stageable,
+    Triggerable,
+    AsyncReadable,
+    AsyncConfigurable,
+):
+    """
+    Detector for data acquisition of electron analyser. Can only acquire using settings
+    already configured for the device.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        driver: AbstractAnalyserDriverIO,
+    ):
+        self.driver_ref: Reference[AbstractAnalyserDriverIO] = Reference(driver)
+        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_ref().read()
+
+    async def describe(self) -> dict[str, DataKey]:
+        data = await self.driver_ref().describe()
+        # Correct the shape for image
+        prefix = self.driver_ref().name + "-"
+        energy_size = len(await self.driver_ref().energy_axis.get_value())
+        angle_size = len(await self.driver_ref().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_ref().read_configuration()
+
+    async def describe_configuration(self) -> dict[str, DataKey]:
+        return await self.driver_ref().describe_configuration()
+
+
+class ElectronAnalyserRegionDetector(
+    BaseElectronAnalyserDetector,
+    Stageable,
+    Generic[TAbstractBaseRegion],
+):
+    """
+    Extends electron analyser detector to configure specific region settings before data
+    acqusition.
+    """
+
+    def __init__(
+        self, name: str, driver: AbstractAnalyserDriverIO, region: TAbstractBaseRegion
+    ):
+        super().__init__(name, driver)
+        self.region = region
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        super().stage()
+        # configure region here
+
+
+class ElectronAnalyserDetector(
+    BaseElectronAnalyserDetector,
+    Generic[TAbstractBaseSequence, TAbstractBaseRegion],
+):
+    """
+    Electron analyser detector with the additional functionality to load a sequence file
+    and create a list of ElectronAnalyserRegionDetector objects. These will setup
+    configured region settings before data acquisition.
+    """
+
+    def load_sequence(self, filename: str) -> TAbstractBaseSequence:
+        return load_json_file_to_class(self.driver_ref().sequence_type(), filename)
+
+    def create_region_detectors(
+        self, filename: str
+    ) -> list[ElectronAnalyserRegionDetector[TAbstractBaseRegion]]:
+        seq = self.load_sequence(filename)
+        return [
+            ElectronAnalyserRegionDetector(self.name, self.driver_ref(), region)
+            for region in seq.get_enabled_regions()
+        ]

src/dodal/devices/electron_analyser/specs_analyser_io.py

@@ -5,9 +5,10 @@
 from dodal.devices.electron_analyser.abstract_analyser_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.specs_region import SpecsSequence
 
 
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsSequence]):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
@@ -59,9 +60,9 @@ def _calculate_energy_axis(
         axis = np.array([min_energy + i * step for i in range(total_points_iterations)])
         return axis
 
-    def _create_total_steps_signal(self, prefix: str) -> SignalR[int]:
-        return epics_signal_r(int, prefix + "TOTAL_POINTS_RBV")
-
     @property
     def pass_energy_type(self) -> type:
         return float
+
+    def sequence_type(self) -> type[SpecsSequence]:
+        return SpecsSequence