dls-dodal 1.60.0__py3-none-any.whl → 1.62.0__py3-none-any.whl

dodal/devices/electron_analyser/abstract/base_region.py

@@ -1,7 +1,7 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from typing import Generic, TypeVar
+from typing import Generic, Self, TypeVar
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -88,28 +88,43 @@ class AbstractBaseRegion(
         return self.energy_mode == EnergyMode.KINETIC
 
     def switch_energy_mode(
-        self, energy_mode: EnergyMode, excitation_energy: float
-    ) -> None:
+        self, energy_mode: EnergyMode, excitation_energy: float, copy: bool = True
+    ) -> Self:
         """
-        Switch region to new energy mode: Kinetic or Binding. Updates the low_energy,
-        centre_energy, high_energy, and energy_mode, only if it switches to a new one.
+        Switch region with to a new energy mode with a new energy mode: Kinetic or Binding.
+        It caculates new values for low_energy, centre_energy, high_energy, via the
+        excitation enerrgy. It doesn't calculate anything if the region is already of
+        the same energy mode.
 
         Parameters:
-            energy_mode: mode you want to switch the region to.
-            excitation_energy: the energy to calculate the new values of low_energy,
-                               centre_energy, and high_energy.
+            energy_mode: Mode you want to switch the region to.
+            excitation_energy: Energy conversion for low_energy, centre_energy, and
+                               high_energy for new energy mode.
+            copy: Defaults to True. If true, create a copy of this region for the new
+                  energy_mode and return it. If False, alter this region for the
+                  energy_mode and return it self.
+
+        Returns:
+            Region with selected energy mode and new calculated energy values.
         """
+        switched_r = self.model_copy() if copy else self
         conv = (
             to_binding_energy
             if energy_mode == EnergyMode.BINDING
             else to_kinetic_energy
         )
-        self.low_energy = conv(self.low_energy, self.energy_mode, excitation_energy)
-        self.centre_energy = conv(
-            self.centre_energy, self.energy_mode, excitation_energy
+        switched_r.low_energy = conv(
+            switched_r.low_energy, switched_r.energy_mode, excitation_energy
         )
-        self.high_energy = conv(self.high_energy, self.energy_mode, excitation_energy)
-        self.energy_mode = energy_mode
+        switched_r.centre_energy = conv(
+            switched_r.centre_energy, switched_r.energy_mode, excitation_energy
+        )
+        switched_r.high_energy = conv(
+            switched_r.high_energy, switched_r.energy_mode, excitation_energy
+        )
+        switched_r.energy_mode = energy_mode
+
+        return switched_r
 
     @model_validator(mode="before")
     @classmethod

dodal/devices/electron_analyser/detector.py

@@ -1,14 +1,13 @@
 from typing import Generic, TypeVar
 
 from bluesky.protocols import Stageable
-from ophyd_async.core import (
-    AsyncStatus,
-    Reference,
-)
+from ophyd_async.core import AsyncStatus
+from ophyd_async.epics.adcore import ADBaseController
 
 from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.controllers import ConstantDeadTimeController
 from dodal.devices.electron_analyser.abstract.base_detector import (
-    AbstractElectronAnalyserDetector,
+    BaseElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     TAbstractAnalyserDriverIO,
@@ -20,35 +19,27 @@ from dodal.devices.electron_analyser.abstract.base_region import (
 
 
 class ElectronAnalyserRegionDetector(
-    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
     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.
+    acquisition. It is designed to only exist inside a plan.
     """
 
     def __init__(
         self,
-        driver: TAbstractAnalyserDriverIO,
+        controller: ADBaseController[TAbstractAnalyserDriverIO],
         region: TAbstractBaseRegion,
         name: str = "",
     ):
-        self._driver_ref = Reference(driver)
         self.region = region
-        super().__init__(driver, name)
-
-    @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()
+        super().__init__(controller, name)
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
         # Configure region parameters on the driver first before data collection.
-        await self.driver.set(self.region)
+        await self._controller.driver.set(self.region)
         await super().trigger()
 
 
@@ -59,7 +50,7 @@ TElectronAnalyserRegionDetector = TypeVar(
 
 
 class ElectronAnalyserDetector(
-    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
     Stageable,
     Generic[
         TAbstractAnalyserDriverIO,
@@ -79,16 +70,11 @@ class ElectronAnalyserDetector(
         driver: TAbstractAnalyserDriverIO,
         name: str = "",
     ):
-        # Pass in driver
-        self._driver = driver
+        # Save driver as direct child so participates with connect()
+        self.driver = driver
         self._sequence_class = sequence_class
-        super().__init__(self.driver, name)
-
-    @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
+        controller = ConstantDeadTimeController[TAbstractAnalyserDriverIO](driver, 0)
+        super().__init__(controller, name)
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
@@ -103,13 +89,13 @@ class ElectronAnalyserDetector(
         Raises:
             Any exceptions raised by the driver's stage or controller's disarm methods.
         """
-        await self.controller.disarm()
+        await self._controller.disarm()
         await self.driver.stage()
 
     @AsyncStatus.wrap
     async def unstage(self) -> None:
         """Disarm the detector."""
-        await self.controller.disarm()
+        await self._controller.disarm()
         await self.driver.unstage()
 
     def load_sequence(self, filename: str) -> TAbstractBaseSequence:
@@ -144,7 +130,9 @@ class ElectronAnalyserDetector(
         seq = self.load_sequence(filename)
         regions = seq.get_enabled_regions() if enabled_only else seq.regions
         return [
-            ElectronAnalyserRegionDetector(self.driver, r, self.name + "_" + r.name)
+            ElectronAnalyserRegionDetector(
+                self._controller, r, self.name + "_" + r.name
+            )
             for r in regions
         ]
 

dodal/devices/electron_analyser/specs/driver_io.py

@@ -66,7 +66,6 @@ class SpecsAnalyserDriverIO(
     async def _set_region(self, ke_region: SpecsRegion[TLensMode, TPsuMode]):
         await asyncio.gather(
             self.region_name.set(ke_region.name),
-            self.energy_mode.set(ke_region.energy_mode),
             self.low_energy.set(ke_region.low_energy),
             self.high_energy.set(ke_region.high_energy),
             self.slices.set(ke_region.slices),

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -74,7 +74,6 @@ class VGScientaAnalyserDriverIO(
     async def _set_region(self, ke_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         await asyncio.gather(
             self.region_name.set(ke_region.name),
-            self.energy_mode.set(ke_region.energy_mode),
             self.low_energy.set(ke_region.low_energy),
             self.centre_energy.set(ke_region.centre_energy),
             self.high_energy.set(ke_region.high_energy),

dodal/devices/fast_grid_scan.py

@@ -1,9 +1,10 @@
+import asyncio
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
 import numpy as np
-from bluesky.plan_stubs import mv
-from bluesky.protocols import Flyable
+from bluesky.plan_stubs import prepare
+from bluesky.protocols import Flyable, Preparable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
@@ -13,6 +14,7 @@ from ophyd_async.core import (
     SignalRW,
     StandardReadable,
     derived_signal_r,
+    set_and_wait_for_value,
     soft_signal_r_and_setter,
     wait_for_value,
 )
@@ -29,6 +31,10 @@ from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
 
+class GridScanInvalidException(RuntimeError):
+    """Raised when the gridscan parameters are not valid."""
+
+
 @dataclass
 class GridAxis:
     start: float
@@ -144,7 +150,7 @@ class GridScanParamsThreeD(GridScanParamsCommon):
         return GridAxis(self.z2_start_mm, self.z_step_size_mm, self.z_steps)
 
 
-ParamType = TypeVar("ParamType", bound=GridScanParamsCommon, covariant=True)
+ParamType = TypeVar("ParamType", bound=GridScanParamsCommon)
 
 
 class WithDwellTime(BaseModel):
@@ -190,7 +196,9 @@ class MotionProgram(Device):
             self.program_number = soft_signal_r_and_setter(float, -1)[0]
 
 
-class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
+class FastGridScanCommon(
+    StandardReadable, Flyable, ABC, Preparable, Generic[ParamType]
+):
     """Device containing the minimal signals for a general fast grid scan.
 
     When the motion program is started, the goniometer will move in a snake-like grid trajectory,
@@ -231,8 +239,9 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.KICKOFF_TIMEOUT: float = 5.0
 
         self.COMPLETE_STATUS: float = 60.0
+        self.VALIDITY_CHECK_TIMEOUT = 0.5
 
-        self.movable_params: dict[str, Signal] = {
+        self._movable_params: dict[str, Signal] = {
             "x_steps": self.x_steps,
             "y_steps": self.y_steps,
             "x_step_size_mm": self.x_step_size,
@@ -284,6 +293,45 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self, motion_controller_prefix: str
     ) -> MotionProgram: ...
 
+    @AsyncStatus.wrap
+    async def prepare(self, value: ParamType):
+        """
+        Submit the gridscan parameters to the device for validation prior to
+        gridscan kickoff
+        Args:
+            value: the gridscan parameters
+
+        Raises:
+            GridScanInvalidException: if the gridscan parameters were not valid
+        """
+        set_statuses = []
+
+        LOGGER.info("Applying gridscan parameters...")
+        # Create arguments for bps.mv
+        for key, signal in self._movable_params.items():
+            param_value = value.__dict__[key]
+            set_statuses.append(await set_and_wait_for_value(signal, param_value))  # type: ignore
+
+        # Counter should always start at 0
+        set_statuses.append(await set_and_wait_for_value(self.position_counter, 0))
+
+        LOGGER.info("Gridscan parameters applied, waiting for sets to complete...")
+
+        # wait for parameter sets to complete
+        await asyncio.gather(*set_statuses)
+
+        LOGGER.info("Sets confirmed, waiting for validity checks to pass...")
+        try:
+            await wait_for_value(
+                self.scan_invalid, 0.0, timeout=self.VALIDITY_CHECK_TIMEOUT
+            )
+        except TimeoutError as e:
+            raise GridScanInvalidException(
+                f"Gridscan parameters not validated after {self.VALIDITY_CHECK_TIMEOUT}s"
+            ) from e
+
+        LOGGER.info("Gridscan validity confirmed, gridscan is now prepared.")
+
 
 class FastGridScanThreeD(FastGridScanCommon[ParamType]):
     """Device for standard 3D FGS.
@@ -296,23 +344,23 @@ class FastGridScanThreeD(FastGridScanCommon[ParamType]):
     Subclasses must implement _create_position_counter.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        full_prefix = prefix + "FGS:"
+    def __init__(self, prefix: str, infix: str, name: str = "") -> None:
+        full_prefix = prefix + infix
 
         # Number of vertical steps during the second grid scan, after the rotation in omega
-        self.z_steps = epics_signal_rw_rbv(int, f"{prefix}Z_NUM_STEPS")
-        self.z_step_size = epics_signal_rw_rbv(float, f"{prefix}Z_STEP_SIZE")
-        self.z2_start = epics_signal_rw_rbv(float, f"{prefix}Z2_START")
-        self.y2_start = epics_signal_rw_rbv(float, f"{prefix}Y2_START")
-        self.x_counter = epics_signal_r(int, f"{full_prefix}X_COUNTER")
+        self.z_steps = epics_signal_rw_rbv(int, f"{full_prefix}Z_NUM_STEPS")
+        self.z_step_size = epics_signal_rw_rbv(float, f"{full_prefix}Z_STEP_SIZE")
+        self.z2_start = epics_signal_rw_rbv(float, f"{full_prefix}Z2_START")
+        self.y2_start = epics_signal_rw_rbv(float, f"{full_prefix}Y2_START")
+        # panda does not have x counter
         self.y_counter = epics_signal_r(int, f"{full_prefix}Y_COUNTER")
 
         super().__init__(full_prefix, prefix, name)
 
-        self.movable_params["z_step_size_mm"] = self.z_step_size
-        self.movable_params["z2_start_mm"] = self.z2_start
-        self.movable_params["y2_start_mm"] = self.y2_start
-        self.movable_params["z_steps"] = self.z_steps
+        self._movable_params["z_step_size_mm"] = self.z_step_size
+        self._movable_params["z2_start_mm"] = self.z2_start
+        self._movable_params["y2_start_mm"] = self.y2_start
+        self._movable_params["z_steps"] = self.z_steps
 
     def _create_expected_images_signal(self):
         return derived_signal_r(
@@ -329,7 +377,35 @@ class FastGridScanThreeD(FastGridScanCommon[ParamType]):
         return first_grid + second_grid
 
     def _create_scan_invalid_signal(self, prefix: str) -> SignalR[float]:
-        return epics_signal_r(float, f"{prefix}SCAN_INVALID")
+        self.x_scan_valid = epics_signal_r(float, f"{prefix}X_SCAN_VALID")
+        self.y_scan_valid = epics_signal_r(float, f"{prefix}Y_SCAN_VALID")
+        self.z_scan_valid = epics_signal_r(float, f"{prefix}Z_SCAN_VALID")
+        self.device_scan_invalid = epics_signal_r(float, f"{prefix}SCAN_INVALID")
+
+        def compute_derived_value(
+            x_scan_valid: float,
+            y_scan_valid: float,
+            z_scan_valid: float,
+            device_scan_invalid: float,
+        ) -> float:
+            return (
+                1.0
+                if not (
+                    x_scan_valid
+                    and y_scan_valid
+                    and z_scan_valid
+                    and not device_scan_invalid
+                )
+                else 0.0
+            )
+
+        return derived_signal_r(
+            compute_derived_value,
+            x_scan_valid=self.x_scan_valid,
+            y_scan_valid=self.y_scan_valid,
+            z_scan_valid=self.z_scan_valid,
+            device_scan_invalid=self.device_scan_invalid,
+        )
 
     def _create_motion_program(self, motion_controller_prefix: str):
         return MotionProgram(motion_controller_prefix)
@@ -343,11 +419,13 @@ class ZebraFastGridScanThreeD(FastGridScanThreeD[ZebraGridScanParamsThreeD]):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        full_prefix = prefix + "FGS:"
+        infix = "FGS:"
+        full_prefix = prefix + infix
         # Time taken to travel between X steps
         self.dwell_time_ms = epics_signal_rw_rbv(float, f"{full_prefix}DWELL_TIME")
-        super().__init__(prefix, name)
-        self.movable_params["dwell_time_ms"] = self.dwell_time_ms
+        self.x_counter = epics_signal_r(int, f"{full_prefix}X_COUNTER")
+        super().__init__(prefix, infix, name)
+        self._movable_params["dwell_time_ms"] = self.dwell_time_ms
 
     def _create_position_counter(self, prefix: str):
         return epics_signal_rw(
@@ -363,7 +441,8 @@ class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        full_prefix = prefix + "PGS:"
+        infix = "PGS:"
+        full_prefix = prefix + infix
         self.time_between_x_steps_ms = (
             epics_signal_rw_rbv(  # Used by motion controller to set goniometer velocity
                 float, f"{full_prefix}TIME_BETWEEN_X_STEPS"
@@ -375,22 +454,22 @@ class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
         self.run_up_distance_mm = epics_signal_rw_rbv(
             float, f"{full_prefix}RUNUP_DISTANCE"
         )
-        super().__init__(prefix, name)
+        super().__init__(prefix, infix, name)
 
-        self.movable_params["run_up_distance_mm"] = self.run_up_distance_mm
+        self._movable_params["run_up_distance_mm"] = self.run_up_distance_mm
 
     def _create_position_counter(self, prefix: str):
         return epics_signal_rw(int, f"{prefix}Y_COUNTER")
 
 
 def set_fast_grid_scan_params(scan: FastGridScanCommon[ParamType], params: ParamType):
-    to_move = []
-
-    # Create arguments for bps.mv
-    for key in scan.movable_params.keys():
-        to_move.extend([scan.movable_params[key], params.__dict__[key]])
-
-    # Counter should always start at 0
-    to_move.extend([scan.position_counter, 0])
+    """
+    Apply the fast grid scan parameters to the grid scan device and validate them
+    Args:
+        scan: The fast grid scan device
+        params: The parameters to set
 
-    yield from mv(*to_move)
+    Raises:
+        GridScanInvalidException: if the grid scan parameters are not valid
+    """
+    yield from prepare(scan, params, wait=True)

dodal/devices/fast_shutter.py

@@ -0,0 +1,57 @@
+from typing import TypeVar
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    EnumTypes,
+    StandardReadable,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+StrictEnumT = TypeVar("StrictEnumT", bound=EnumTypes)
+
+
+class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
+    """
+    Basic enum device specialised for a fast shutter with configured open_state and
+    close_state so it is generic enough to be used with any device or plan without
+    knowing the specific enum to use.
+
+    For example:
+        await shutter.set(shutter.open_state)
+        await shutter.set(shutter.close_state)
+    OR
+        RE(bps.mv(shutter, shutter.open_state))
+        RE(bps.mv(shutter, shutter.close_state))
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        open_state: StrictEnumT,
+        close_state: StrictEnumT,
+        name: str = "",
+    ):
+        """
+        Arguments:
+            prefix: The prefix for the shutter device.
+            open_state: The enum value that corresponds with opening the shutter.
+            close_state: The enum value that corresponds with closing the shutter.
+        """
+        self.open_state = open_state
+        self.close_state = close_state
+        with self.add_children_as_readables():
+            self.state = epics_signal_rw(type(self.open_state), prefix)
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: StrictEnumT) -> None:
+        await self.state.set(value)
+
+    async def is_open(self) -> bool:
+        """Checks to see if shutter is currently open"""
+        return await self.state.get_value() == self.open_state
+
+    async def is_closed(self) -> bool:
+        """Checks to see if shutter is currently closed"""
+        return await self.state.get_value() == self.close_state

dodal/devices/i02_1/fast_grid_scan.py

@@ -35,7 +35,7 @@ class ZebraFastGridScanTwoD(FastGridScanCommon[ZebraGridScanParamsTwoD]):
         # See https://github.com/DiamondLightSource/mx-bluesky/issues/1203
         self.dwell_time_ms = epics_signal_rw_rbv(float, f"{full_prefix}EXPOSURE_TIME")
 
-        self.movable_params["dwell_time_ms"] = self.dwell_time_ms
+        self._movable_params["dwell_time_ms"] = self.dwell_time_ms
 
     def _create_expected_images_signal(self):
         return derived_signal_r(

dodal/devices/i04/murko_results.py

@@ -32,6 +32,7 @@ class MurkoMetadata(TypedDict):
     sample_id: str
     omega_angle: float
     uuid: str
+    used_for_centring: bool | None
 
 
 class Coord(Enum):
@@ -47,6 +48,7 @@ class MurkoResult:
     y_dist_mm: float
     omega: float
     uuid: str
+    metadata: MurkoMetadata
 
 
 class NoResultsFound(ValueError):
@@ -101,7 +103,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
     def _reset(self):
         self._last_omega = 0
-        self.results: list[MurkoResult] = []
+        self._results: list[MurkoResult] = []
 
     @AsyncStatus.wrap
     async def stage(self):
@@ -126,17 +128,17 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
                 continue
             await self.process_batch(message, sample_id)
 
-        if not self.results:
+        if not self._results:
             raise NoResultsFound("No results retrieved from Murko")
 
-        for result in self.results:
+        for result in self._results:
             LOGGER.debug(result)
 
-        self.filter_outliers()
+        filtered_results = self.filter_outliers()
 
-        x_dists_mm = [result.x_dist_mm for result in self.results]
-        y_dists_mm = [result.y_dist_mm for result in self.results]
-        omegas = [result.omega for result in self.results]
+        x_dists_mm = [result.x_dist_mm for result in filtered_results]
+        y_dists_mm = [result.y_dist_mm for result in filtered_results]
+        omegas = [result.omega for result in filtered_results]
 
         LOGGER.info(f"Using average of x beam distances: {x_dists_mm}")
         avg_x = float(np.mean(x_dists_mm))
@@ -147,6 +149,11 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         self._y_mm_setter(-best_y)
         self._z_mm_setter(-best_z)
 
+        for result in self._results:
+            await self.redis_client.hset(  # type: ignore
+                f"murko:{sample_id}:metadata", result.uuid, json.dumps(result.metadata)
+            )
+
     async def process_batch(self, message: dict | None, sample_id: str):
         if message and message["type"] == "message":
             batch_results: list[dict] = pickle.loads(message["data"])
@@ -186,13 +193,14 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
                 centre_px[0],
                 centre_px[1],
             )
-            self.results.append(
+            self._results.append(
                 MurkoResult(
                     centre_px=centre_px,
                     x_dist_mm=beam_dist_px[0] * metadata["microns_per_x_pixel"] / 1000,
                     y_dist_mm=beam_dist_px[1] * metadata["microns_per_y_pixel"] / 1000,
                     omega=omega,
                     uuid=metadata["uuid"],
+                    metadata=metadata,
                 )
             )
             self._last_omega = omega
@@ -203,8 +211,8 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         meaning that by keeping only a percentage of the results with the smallest X we
         remove many of the outliers.
         """
-        LOGGER.info(f"Number of results before filtering: {len(self.results)}")
-        sorted_results = sorted(self.results, key=lambda item: item.centre_px[0])
+        LOGGER.info(f"Number of results before filtering: {len(self._results)}")
+        sorted_results = sorted(self._results, key=lambda item: item.centre_px[0])
 
         worst_results = [
             r.uuid for r in sorted_results[-self.NUMBER_OF_WRONG_RESULTS_TO_LOG :]
@@ -214,9 +222,13 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             f"Worst {self.NUMBER_OF_WRONG_RESULTS_TO_LOG} murko results were {worst_results}"
         )
         cutoff = max(1, int(len(sorted_results) * self.PERCENTAGE_TO_USE / 100))
+        for i, result in enumerate(sorted_results):
+            result.metadata["used_for_centring"] = i < cutoff
+
         smallest_x = sorted_results[:cutoff]
-        self.results = smallest_x
-        LOGGER.info(f"Number of results after filtering: {len(self.results)}")
+
+        LOGGER.info(f"Number of results after filtering: {len(smallest_x)}")
+        return smallest_x
 
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:

dodal/devices/i10/i10_apple2.py

@@ -19,10 +19,9 @@ from ophyd_async.core import (
 )
 from pydantic import BaseModel, ConfigDict, RootModel
 
-from dodal.log import LOGGER
-
-from ..apple2_undulator import (
+from dodal.devices.apple2_undulator import (
     Apple2,
+    Apple2Motors,
     Apple2Val,
     EnergyMotorConvertor,
     Pol,
@@ -30,6 +29,8 @@ from ..apple2_undulator import (
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
+from dodal.log import LOGGER
+
 from ..pgm import PGM
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
@@ -359,14 +360,15 @@ class I10Apple2(Apple2):
 
         with self.add_children_as_readables():
             super().__init__(
-                id_gap=UndulatorGap(name="id_gap", prefix=prefix),
-                id_phase=UndulatorPhaseAxes(
-                    name="id_phase",
-                    prefix=prefix,
-                    top_outer="RPQ1",
-                    top_inner="RPQ2",
-                    btm_inner="RPQ3",
-                    btm_outer="RPQ4",
+                apple2_motors=Apple2Motors(
+                    id_gap=UndulatorGap(prefix=prefix),
+                    id_phase=UndulatorPhaseAxes(
+                        prefix=prefix,
+                        top_outer="RPQ1",
+                        top_inner="RPQ2",
+                        btm_inner="RPQ3",
+                        btm_outer="RPQ4",
+                    ),
                 ),
                 energy_motor_convertor=energy_motor_convertor,
                 name=name,
@@ -376,8 +378,7 @@ class I10Apple2(Apple2):
                 move_pv="RPQ1",
             )
 
-    @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
+    async def _set(self, value: float) -> None:
         """
         Check polarisation state and use it together with the energy(value)
         to calculate the required gap and phases before setting it.
@@ -408,11 +409,10 @@ class I10Apple2(Apple2):
         )
 
         LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self._set(value=id_set_val, energy=value)
+        await self.motors.set(id_motor_values=id_set_val)
         if pol != Pol.LA:
             await self.id_jaw_phase.set(0)
             await self.id_jaw_phase.set_move.set(1)
-        LOGGER.info(f"Energy set to {value} eV successfully.")
 
 
 class EnergySetter(StandardReadable, Movable[float]):