dls-dodal 1.50.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

dodal/devices/tetramm.py

@@ -1,12 +1,16 @@
 import asyncio
+from collections.abc import Sequence
+from typing import Annotated as A
 
-from bluesky.protocols import Hints
 from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
     DatasetDescriber,
     DetectorController,
     DetectorTrigger,
-    Device,
     PathProvider,
+    SignalR,
+    SignalRW,
     StandardDetector,
     StrictEnum,
     TriggerInfo,
@@ -15,15 +19,12 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.adcore import (
     ADHDFWriter,
+    NDArrayBaseIO,
     NDFileHDFIO,
     NDPluginBaseIO,
     stop_busy_record,
 )
-from ophyd_async.epics.core import (
-    epics_signal_r,
-    epics_signal_rw,
-    epics_signal_rw_rbv,
-)
+from ophyd_async.epics.core import PvSuffix
 
 
 class TetrammRange(StrictEnum):
@@ -54,208 +55,191 @@ class TetrammGeometry(StrictEnum):
     SQUARE = "Square"
 
 
-class TetrammDriver(Device):
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
-        self._prefix = prefix
-        self.range = epics_signal_rw_rbv(TetrammRange, prefix + "Range")
-        self.sample_time = epics_signal_r(float, prefix + "SampleTime_RBV")
-
-        self.values_per_reading = epics_signal_rw_rbv(int, prefix + "ValuesPerRead")
-        self.averaging_time = epics_signal_rw_rbv(float, prefix + "AveragingTime")
-        self.to_average = epics_signal_r(int, prefix + "NumAverage_RBV")
-        self.averaged = epics_signal_r(int, prefix + "NumAveraged_RBV")
-
-        self.acquire = epics_signal_rw_rbv(bool, prefix + "Acquire")
-
-        # this PV is special, for some reason it doesn't have a _RBV suffix...
-        self.overflows = epics_signal_r(int, prefix + "RingOverflows")
-
-        self.num_channels = epics_signal_rw_rbv(TetrammChannels, prefix + "NumChannels")
-        self.resolution = epics_signal_rw_rbv(TetrammResolution, prefix + "Resolution")
-        self.trigger_mode = epics_signal_rw_rbv(TetrammTrigger, prefix + "TriggerMode")
-        self.bias = epics_signal_rw_rbv(bool, prefix + "BiasState")
-        self.bias_volts = epics_signal_rw_rbv(float, prefix + "BiasVoltage")
-        self.geometry = epics_signal_rw_rbv(TetrammGeometry, prefix + "Geometry")
-        self.nd_attributes_file = epics_signal_rw(str, prefix + "NDAttributesFile")
-
-        super().__init__(name=name)
+class TetrammDriver(NDArrayBaseIO):
+    range = A[SignalRW[TetrammRange], PvSuffix.rbv("Range")]
+    sample_time: A[SignalR[float], PvSuffix("SampleTime_RBV")]
+    values_per_reading: A[SignalRW[int], PvSuffix.rbv("ValuesPerRead")]
+    averaging_time: A[SignalRW[float], PvSuffix.rbv("AveragingTime")]
+    to_average: A[SignalR[int], PvSuffix("NumAverage_RBV")]
+    averaged: A[SignalR[int], PvSuffix("NumAveraged_RBV")]
+    overflows: A[SignalR[int], PvSuffix("RingOverflows")]
+    num_channels: A[SignalRW[TetrammChannels], PvSuffix.rbv("NumChannels")]
+    resolution: A[SignalRW[TetrammResolution], PvSuffix.rbv("Resolution")]
+    trigger_mode: A[SignalRW[TetrammTrigger], PvSuffix.rbv("TriggerMode")]
+    bias: A[SignalRW[bool], PvSuffix.rbv("BiasState")]
+    bias_volts: A[SignalRW[float], PvSuffix.rbv("BiasVoltage")]
+    geometry: A[SignalRW[TetrammGeometry], PvSuffix.rbv("Geometry")]
+    read_format: A[SignalRW[bool], PvSuffix.rbv("ReadFormat")]
 
 
 class TetrammController(DetectorController):
-    """Controller for a TetrAMM current monitor
-
-    Attributes:
-        base_sample_rate (int): Fixed in hardware
-
-    Args:
-        drv (TetrammDriver): A configured driver for the device
-        maximum_readings_per_frame (int): Maximum number of readings per frame: actual readings may be lower if higher frame rate is required
-        minimum_values_per_reading (int): Lower bound on the values that will be averaged to create a single reading
-        readings_per_frame (int): Actual number of readings per frame.
-
+    """Controller for a TetrAMM current monitor"""
+
+    _supported_trigger_types = {
+        DetectorTrigger.EDGE_TRIGGER: TetrammTrigger.EXT_TRIGGER,
+        DetectorTrigger.CONSTANT_GATE: TetrammTrigger.EXT_TRIGGER,
+    }
+    """"On the TetrAMM ASCII mode requires a minimum value of ValuesPerRead of 500,
+    [...] binary mode the minimum value of ValuesPerRead is 5."
+    https://millenia.cars.aps.anl.gov/software/epics/quadEMDoc.html
     """
-
-    base_sample_rate: int = 100_000
+    _minimal_values_per_reading = {0: 5, 1: 500}
+    """The TetrAMM always digitizes at 100 kHz"""
+    _base_sample_rate: int = 100_000
 
     def __init__(
         self,
-        drv: TetrammDriver,
-        minimum_values_per_reading: int = 5,
-        maximum_readings_per_frame: int = 1_000,
-        readings_per_frame: int = 1_000,
-    ):
-        # TODO: Are any of these also fixed by hardware constraints?
-        self._drv = drv
-        self.maximum_readings_per_frame = maximum_readings_per_frame
-        self.minimum_values_per_reading = minimum_values_per_reading
-        self.readings_per_frame = readings_per_frame
+        driver: TetrammDriver,
+    ) -> None:
+        self.driver = driver
+        self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         # 2 internal clock cycles. Best effort approximation
-        return 2 / self.base_sample_rate
+        return 2 / self._base_sample_rate
 
-    async def prepare(self, trigger_info: TriggerInfo):
-        self._validate_trigger(trigger_info.trigger)
-        assert trigger_info.livetime is not None
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        if trigger_info.trigger not in self._supported_trigger_types:
+            raise TypeError(
+                f"{self.__class__.__name__} only supports the following trigger "
+                f"types: {[k.name for k in self._supported_trigger_types]} but was asked to "
+                f"use {trigger_info.trigger}"
+            )
+        if trigger_info.livetime is None:
+            raise ValueError(f"{self.__class__.__name__} requires that livetime is set")
 
         # trigger mode must be set first and on its own!
-        await self._drv.trigger_mode.set(TetrammTrigger.EXT_TRIGGER)
-
+        await self.driver.trigger_mode.set(
+            self._supported_trigger_types[trigger_info.trigger]
+        )
         await asyncio.gather(
-            self._drv.averaging_time.set(trigger_info.livetime),
+            self.driver.averaging_time.set(trigger_info.livetime),
             self.set_exposure(trigger_info.livetime),
         )
 
     async def arm(self):
-        self._arm_status = await set_and_wait_for_value(
-            self._drv.acquire, True, wait_for_set_completion=False
-        )
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 
     async def wait_for_idle(self):
         if self._arm_status and not self._arm_status.done:
             await self._arm_status
         self._arm_status = None
 
-    def _validate_trigger(self, trigger: DetectorTrigger) -> None:
-        supported_trigger_types = {
-            DetectorTrigger.EDGE_TRIGGER,
-            DetectorTrigger.CONSTANT_GATE,
-        }
-
-        if trigger not in supported_trigger_types:
-            raise ValueError(
-                f"{self.__class__.__name__} only supports the following trigger "
-                f"types: {supported_trigger_types} but was asked to "
-                f"use {trigger}"
-            )
-
     async def disarm(self):
-        await stop_busy_record(self._drv.acquire, False, timeout=1)
+        # 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 set_exposure(self, exposure: float):
-        """Tries to set the exposure time of a single frame.
+    async def set_exposure(self, exposure: float) -> None:
+        """Set the exposure time and acquire period.
 
         As during the  exposure time, the device must collect an integer number
         of readings, in the case where the exposure is not a multiple of the base
         sample rate, it will be lowered to the prior multiple ot ensure triggers
         are not missed.
 
-        Args:
-            exposure (float): The time for a single frame in seconds
-
-        Raises:
-            ValueError: If exposure is too low to collect the required number
-            of readings per frame.
+        :param exposure: Desired exposure time.
+        :type exposure: How long to wait for the exposure time and acquire
+            period to be set.
         """
+        sample_time = await self.driver.sample_time.get_value()
+        minimum_samples = self._minimal_values_per_reading[
+            await self.driver.read_format.get_value()
+        ]
+        samples_per_reading = int(exposure / sample_time)
+        if samples_per_reading < minimum_samples:
+            raise ValueError(
+                "Tetramm exposure time must be at least "
+                f"{minimum_samples * sample_time}s, asked to set it to {exposure}s"
+            )
+        await self.driver.averaging_time.set(samples_per_reading * sample_time)
 
-        # Set up the number of readings across the exposure period to scale with
-        # the exposure time
-        self._set_minimum_exposure(exposure)
-        values_per_reading: int = int(
-            exposure * self.base_sample_rate / self.readings_per_frame
-        )
-
-        await self._drv.values_per_reading.set(values_per_reading)
+    async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
+        """Start acquiring driver, raising ValueError if the detector is in a bad state.
 
-    @property
-    def max_frame_rate(self) -> float:
-        """Max frame rate in Hz for the current configuration"""
-        return 1 / self.minimum_exposure
+        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.
 
-    @max_frame_rate.setter
-    def max_frame_rate(self, mfr: float):
-        self._set_minimum_exposure(1 / mfr)
+        :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,
+        )
 
-    @property
-    def minimum_exposure(self) -> float:
-        """Smallest amount of time needed to take a frame"""
-        time_per_reading = self.minimum_values_per_reading / self.base_sample_rate
-        return self.readings_per_frame * time_per_reading
+        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
 
-    def _set_minimum_exposure(self, exposure: float):
-        time_per_reading = self.minimum_values_per_reading / self.base_sample_rate
-        if exposure < time_per_reading:
-            raise ValueError(
-                "Tetramm exposure time must be at least "
-                f"{time_per_reading}s, asked to set it to {exposure}s"
-            )
-        self.readings_per_frame = int(
-            min(self.maximum_readings_per_frame, exposure / time_per_reading)
-        )
+        return AsyncStatus(complete_acquisition())
 
 
 class TetrammDatasetDescriber(DatasetDescriber):
-    max_channels = 11
-
-    def __init__(self, controller: TetrammController) -> None:
-        self.controller = controller
+    def __init__(self, driver: TetrammDriver) -> None:
+        self._driver = driver
 
     async def np_datatype(self) -> str:
         return "<f8"  # IEEE 754 double precision floating point
 
     async def shape(self) -> tuple[int, int]:
-        return (self.max_channels, self.controller.readings_per_frame)
+        return (
+            int(await self._driver.num_channels.get_value()),
+            int(
+                await self._driver.averaging_time.get_value()
+                / await self._driver.sample_time.get_value(),
+            ),
+        )
 
 
-# TODO: Support MeanValue signals https://github.com/DiamondLightSource/dodal/issues/337
 class TetrammDetector(StandardDetector):
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
+        drv_suffix: str = "DRV:",
+        fileio_suffix: str = "HDF5:",
         name: str = "",
-        type: str | None = None,
         plugins: dict[str, NDPluginBaseIO] | None = None,
-    ) -> None:
-        self.drv = TetrammDriver(prefix + "DRV:")
-        self.hdf = NDFileHDFIO(prefix + "HDF5:")
-        controller = TetrammController(self.drv)
-        config_signals = [
-            self.drv.values_per_reading,
-            self.drv.averaging_time,
-            self.drv.sample_time,
+        config_sigs: Sequence[SignalR] = (),
+        type: str | None = None,
+    ):
+        self.driver = TetrammDriver(prefix + drv_suffix)
+        self.file_io = NDFileHDFIO(prefix + fileio_suffix)
+        controller = TetrammController(self.driver)
+
+        writer = ADHDFWriter(
+            fileio=self.file_io,
+            path_provider=path_provider,
+            dataset_describer=TetrammDatasetDescriber(self.driver),
+            plugins=plugins,
+        )
+
+        config_sigs = [
+            self.driver.values_per_reading,
+            self.driver.averaging_time,
+            self.driver.sample_time,
+            *config_sigs,
         ]
+
         if type:
             self.type, _ = soft_signal_r_and_setter(str, type)
-            config_signals.append(self.type)
+            config_sigs.append(self.type)
         else:
             self.type = None
+
+        if plugins is not None:
+            for plugin_name, plugin in plugins.items():
+                setattr(self, plugin_name, plugin)
+
         super().__init__(
-            controller,
-            ADHDFWriter(
-                fileio=self.hdf,
-                path_provider=path_provider,
-                dataset_describer=TetrammDatasetDescriber(controller),
-                plugins=plugins,
-            ),
-            config_signals,
-            name,
+            controller=controller,
+            writer=writer,
+            name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return {"fields": [self.name]}

dodal/devices/xbpm_feedback.py

@@ -2,6 +2,8 @@ from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, Device, StrictEnum, observe_value
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
+from dodal.common.device_utils import periodic_reminder
+
 
 class Pause(StrictEnum):
     PAUSE = "Paused"  # 0
@@ -22,6 +24,7 @@ class XBPMFeedback(Device, Triggerable):
 
     @AsyncStatus.wrap
     async def trigger(self):
-        async for value in observe_value(self.pos_stable):
-            if value:
-                return
+        async with periodic_reminder("Waiting for XBPM"):
+            async for value in observe_value(self.pos_stable):
+                if value:
+                    return

dodal/devices/zocalo/zocalo_results.py

@@ -10,7 +10,6 @@ import workflows.recipe
 import workflows.transport
 from bluesky.protocols import Triggerable
 from bluesky.utils import Msg
-from deepdiff.diff import DeepDiff
 from ophyd_async.core import (
     Array1D,
     AsyncStatus,
@@ -49,6 +48,9 @@ DEFAULT_SORT_KEY = SortKeys.max_count
 CLEAR_QUEUE_WAIT_S = 2.0
 ZOCALO_STAGE_GROUP = "clear zocalo queue"
 
+# Sentinel value required for inserting into the soft signal array
+_NO_SAMPLE_ID = -1
+
 
 class XrcResult(TypedDict):
     """
@@ -69,6 +71,7 @@ class XrcResult(TypedDict):
             as the volume of whole boxes as a half-open range i.e such that
             p1 = (x1, y1, z1) <= p < p2 = (x2, y2, z2) and
             p2 - p1 gives the dimensions in whole voxels.
+         sample_id: The sample id associated with the centre.
     """
 
     centre_of_mass: list[float]
@@ -77,6 +80,7 @@ class XrcResult(TypedDict):
     n_voxels: int
     total_count: int
     bounding_box: list[list[int]]
+    sample_id: int | None
 
 
 def bbox_size(result: XrcResult):
@@ -86,18 +90,6 @@ def bbox_size(result: XrcResult):
     ]
 
 
-def get_dict_differences(
-    dict1: dict, dict1_source: str, dict2: dict, dict2_source: str
-) -> str | None:
-    """Returns a string containing dict1 and dict2 if there are differences between them, greater than a
-    1e-5 tolerance. If dictionaries are identical, return None"""
-
-    diff = DeepDiff(dict1, dict2, math_epsilon=1e-5, ignore_numeric_type_changes=True)
-
-    if diff:
-        return f"Zocalo results from {dict1_source} and {dict2_source} are not identical.\n Results from {dict1_source}: {dict1}\n Results from {dict2_source}: {dict2}"
-
-
 def source_from_results(results):
     return (
         ZocaloSource.GPU.value
@@ -127,10 +119,6 @@ class ZocaloResults(StandardReadable, Triggerable):
 
         prefix (str): EPICS PV prefix for the device
 
-        use_cpu_and_gpu (bool): When True, ZocaloResults will wait for results from the
-        CPU and the GPU, compare them, and provide a warning if the results differ. When
-        False, ZocaloResults will only use results from the CPU
-
         use_gpu (bool): When True, ZocaloResults will take the first set of
         results that it receives (which are likely the GPU results)
 
@@ -144,7 +132,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
         prefix: str = "",
-        use_cpu_and_gpu: bool = False,
         use_gpu: bool = False,
     ) -> None:
         self.zocalo_environment = zocalo_environment
@@ -154,7 +141,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._prefix = prefix
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
-        self.use_cpu_and_gpu = use_cpu_and_gpu
         self.use_gpu = use_gpu
 
         self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
@@ -175,6 +161,9 @@ class ZocaloResults(StandardReadable, Triggerable):
         self.total_count, self._total_count_setter = soft_signal_r_and_setter(
             Array1D[np.uint64], name="total_count"
         )
+        self.sample_id, self._sample_id_setter = soft_signal_r_and_setter(
+            Array1D[np.int64], name="sample_id"
+        )
         self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
             int, name="ispyb_dcid"
         )
@@ -189,6 +178,7 @@ class ZocaloResults(StandardReadable, Triggerable):
                 self.total_count,
                 self.centre_of_mass,
                 self.bounding_box,
+                self.sample_id,
                 self.ispyb_dcid,
                 self.ispyb_dcgid,
             ],
@@ -197,13 +187,15 @@ class ZocaloResults(StandardReadable, Triggerable):
         super().__init__(name)
 
     async def _put_results(self, results: Sequence[XrcResult], recipe_parameters):
-        centres_of_mass = np.array([r["centre_of_mass"] for r in results])
-        self._com_setter(centres_of_mass)
+        self._com_setter(np.array([r["centre_of_mass"] for r in results]))
         self._bounding_box_setter(np.array([r["bounding_box"] for r in results]))
         self._max_voxel_setter(np.array([r["max_voxel"] for r in results]))
         self._max_count_setter(np.array([r["max_count"] for r in results]))
         self._n_voxels_setter(np.array([r["n_voxels"] for r in results]))
         self._total_count_setter(np.array([r["total_count"] for r in results]))
+        self._sample_id_setter(
+            np.array([r.get("sample_id") or _NO_SAMPLE_ID for r in results])
+        )
         self._ispyb_dcid_setter(recipe_parameters["dcid"])
         self._ispyb_dcgid_setter(recipe_parameters["dcgid"])
 
@@ -218,11 +210,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         clearing the queue. Plans using this device should wait on ZOCALO_STAGE_GROUP
         before triggering processing for the experiment"""
 
-        if self.use_cpu_and_gpu and self.use_gpu:
-            raise ValueError(
-                "Cannot compare GPU and CPU results and use GPU results at the same time."
-            )
-
         LOGGER.info("Subscribing to results queue")
         try:
             self._subscribe_to_results()
@@ -268,55 +255,6 @@ class ZocaloResults(StandardReadable, Triggerable):
                     "Configured to use GPU results but CPU came first, using CPU results."
                 )
 
-            if self.use_cpu_and_gpu:
-                # Wait for results from CPU and GPU, warn and continue if only GPU times out. Error if CPU times out
-                if source_of_first_results == ZocaloSource.CPU:
-                    LOGGER.warning("Received zocalo results from CPU before GPU")
-                raw_results_two_sources = [raw_results]
-                try:
-                    raw_results_two_sources.append(
-                        self._raw_results_received.get(timeout=self.timeout_s / 2)
-                    )
-                    source_of_second_results = source_from_results(
-                        raw_results_two_sources[1]
-                    )
-                    first_results = raw_results_two_sources[0]["results"]
-                    second_results = raw_results_two_sources[1]["results"]
-
-                    if first_results and second_results:
-                        # Compare results from both sources and warn if they aren't the same
-                        differences_str = get_dict_differences(
-                            first_results[0],
-                            source_of_first_results,
-                            second_results[0],
-                            source_of_second_results,
-                        )
-                        if differences_str:
-                            LOGGER.warning(differences_str)
-
-                    # Always use CPU results
-                    raw_results = (
-                        raw_results_two_sources[0]
-                        if source_of_first_results == ZocaloSource.CPU
-                        else raw_results_two_sources[1]
-                    )
-
-                except Empty as err:
-                    source_of_missing_results = (
-                        ZocaloSource.CPU.value
-                        if source_of_first_results == ZocaloSource.GPU.value
-                        else ZocaloSource.GPU.value
-                    )
-                    if source_of_missing_results == ZocaloSource.GPU.value:
-                        LOGGER.warning(
-                            f"Zocalo results from {source_of_missing_results} timed out. Using results from {source_of_first_results}"
-                        )
-                    else:
-                        LOGGER.error(
-                            f"Zocalo results from {source_of_missing_results} timed out and GPU results not yet reliable"
-                        )
-                        raise err
-
             LOGGER.info(
                 f"Zocalo results from {source_from_results(raw_results)} processing: found {len(raw_results['results'])} crystals."
             )
@@ -350,7 +288,7 @@ class ZocaloResults(StandardReadable, Triggerable):
 
             results = message.get("results", [])
 
-            if self.use_cpu_and_gpu or self.use_gpu:
+            if self.use_gpu:
                 self._raw_results_received.put(
                     {"results": results, "recipe_parameters": recipe_parameters}
                 )
@@ -360,6 +298,8 @@ class ZocaloResults(StandardReadable, Triggerable):
                     self._raw_results_received.put(
                         {"results": results, "recipe_parameters": recipe_parameters}
                     )
+                else:
+                    LOGGER.warning("Discarding results as they are from GPU")
 
         subscription = workflows.recipe.wrap_subscribe(
             self.transport,
@@ -393,6 +333,7 @@ def get_full_processing_results(
     n_voxels = yield from bps.rd(zocalo.n_voxels, default_value=[])
     total_count = yield from bps.rd(zocalo.total_count, default_value=[])
     bounding_box = yield from bps.rd(zocalo.bounding_box, default_value=[])
+    sample_id = yield from bps.rd(zocalo.sample_id, default_value=[])
     return [
         _corrected_xrc_result(
             XrcResult(
@@ -402,9 +343,17 @@ def get_full_processing_results(
                 n_voxels=int(n),
                 total_count=int(tc),
                 bounding_box=bb.tolist(),
+                sample_id=int(s_id) if s_id != _NO_SAMPLE_ID else None,
             )
         )
-        for com, mv, mc, n, tc, bb in zip(
-            com, max_voxel, max_count, n_voxels, total_count, bounding_box, strict=True
+        for com, mv, mc, n, tc, bb, s_id in zip(
+            com,
+            max_voxel,
+            max_count,
+            n_voxels,
+            total_count,
+            bounding_box,
+            sample_id,
+            strict=True,
         )
     ]

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -3,8 +3,8 @@ import time
 import bluesky.plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import DetectorTrigger
-from ophyd_async.fastcs.eiger import EigerDetector, EigerTriggerInfo
+from ophyd_async.core import DetectorTrigger, TriggerInfo
+from ophyd_async.fastcs.eiger import EigerDetector
 
 from dodal.beamlines.i03 import fastcs_eiger
 from dodal.devices.detector import DetectorParams
@@ -15,7 +15,7 @@ from dodal.log import LOGGER, do_default_logging_setup
 def configure_arm_trigger_and_disarm_detector(
     eiger: EigerDetector,
     detector_params: DetectorParams,
-    trigger_info: EigerTriggerInfo,
+    trigger_info: TriggerInfo,
 ):
     assert detector_params.expected_energy_ev
     start = time.time()
@@ -132,6 +132,9 @@ def set_mx_settings_pvs(
     yield from bps.abs_set(
         eiger.drv.detector.omega_increment, detector_params.omega_increment, group
     )
+    yield from bps.abs_set(
+        eiger.drv.detector.photon_energy, detector_params.expected_energy_ev, group
+    )
 
     if wait:
         yield from bps.wait(group)
@@ -157,9 +160,8 @@ if __name__ == "__main__":
                 use_roi_mode=False,
                 det_dist_to_beam_converter_path="/dls_sw/i03/software/daq_configuration/lookup/DetDistToBeamXYConverter.txt",
             ),
-            trigger_info=EigerTriggerInfo(
+            trigger_info=TriggerInfo(
                 number_of_events=1,
-                energy_ev=12800,
                 trigger=DetectorTrigger.INTERNAL,
                 deadtime=0.0001,
             ),

dodal/devices/adsim.py

@@ -1,13 +0,0 @@
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.motor import Motor
-
-
-class SimStage(StandardReadable):
-    """Simulated Sample Stage for use with the containerised simulated beamline
-    https://github.com/epics-containers/example-services"""
-
-    def __init__(self, prefix: str, name: str = "sim"):
-        with self.add_children_as_readables():
-            self.x = Motor(prefix + "M1")
-            self.y = Motor(prefix + "M2")
-        super().__init__(name=name)