dls-dodal 1.65.0__py3-none-any.whl → 1.66.0__py3-none-any.whl

dodal/beamlines/i10_optics.py

@@ -6,6 +6,8 @@ note:
     idd == id1,    idu == id2.
 """
 
+from pathlib import Path
+
 from daq_config_server.client import ConfigServer
 
 from dodal.common.beamlines.beamline_utils import device_factory
@@ -34,6 +36,12 @@ from dodal.devices.i10.i10_apple2 import (
 from dodal.devices.i10.i10_setting_data import I10Grating
 from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.util.lookup_tables_apple2 import (
+    DEFAULT_GAP_FILE,
+    DEFAULT_PHASE_FILE,
+    EnergyMotorLookup,
+    LookupTableConfig,
+)
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -115,12 +123,13 @@ def idd() -> I10Apple2:
 @device_factory()
 def idd_controller() -> I10Apple2Controller:
     """I10 downstream insertion device controller."""
-    return I10Apple2Controller(
-        apple2=idd(),
-        lookuptable_dir=LOOK_UPTABLE_DIR,
-        source=("Source", "idd"),
+    idd_energy_motor_lut = EnergyMotorLookup(
         config_client=I10_CONF_CLIENT,
+        lut_config=LookupTableConfig(source=("Source", "idd")),
+        gap_path=Path(LOOK_UPTABLE_DIR, DEFAULT_GAP_FILE),
+        phase_path=Path(LOOK_UPTABLE_DIR, DEFAULT_PHASE_FILE),
     )
+    return I10Apple2Controller(apple2=idd(), energy_motor_lut=idd_energy_motor_lut)
 
 
 @device_factory()
@@ -179,12 +188,13 @@ def idu() -> I10Apple2:
 @device_factory()
 def idu_controller() -> I10Apple2Controller:
     """I10 upstream insertion device controller."""
-    return I10Apple2Controller(
-        apple2=idu(),
-        lookuptable_dir=LOOK_UPTABLE_DIR,
-        source=("Source", "idu"),
+    idu_energy_motor_lut = EnergyMotorLookup(
         config_client=I10_CONF_CLIENT,
+        lut_config=LookupTableConfig(source=("Source", "idu")),
+        gap_path=Path(LOOK_UPTABLE_DIR, DEFAULT_GAP_FILE),
+        phase_path=Path(LOOK_UPTABLE_DIR, DEFAULT_PHASE_FILE),
     )
+    return I10Apple2Controller(apple2=idd(), energy_motor_lut=idu_energy_motor_lut)
 
 
 @device_factory()

dodal/beamlines/i18.py

@@ -23,7 +23,7 @@ from dodal.devices.motors import XYStage, XYZThetaStage
 from dodal.devices.slits import Slits
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.tetramm import TetrammDetector
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -53,8 +53,8 @@ def synchrotron() -> Synchrotron:
 
 
 @device_factory()
-def undulator() -> Undulator:
-    return Undulator(f"{PREFIX.insertion_prefix}-MO-SERVC-01:")
+def undulator() -> UndulatorInKeV:
+    return UndulatorInKeV(f"{PREFIX.insertion_prefix}-MO-SERVC-01:")
 
 
 # See https://github.com/DiamondLightSource/dodal/issues/1180

dodal/beamlines/i22.py

@@ -23,7 +23,7 @@ from dodal.devices.motors import XYPitchStage
 from dodal.devices.slits import Slits
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.tetramm import TetrammDetector
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.watsonmarlow323_pump import WatsonMarlow323Pump
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
@@ -160,8 +160,8 @@ def dcm() -> DCM:
 
 
 @device_factory()
-def undulator() -> Undulator:
-    return Undulator(
+def undulator() -> UndulatorInKeV:
+    return UndulatorInKeV(
         prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
         id_gap_lookup_table_path="/dls_sw/i22/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
         poles=80,

dodal/beamlines/p38.py

@@ -22,7 +22,7 @@ from dodal.devices.linkam3 import Linkam3
 from dodal.devices.pressure_jump_cell import PressureJumpCell
 from dodal.devices.slits import Slits
 from dodal.devices.tetramm import TetrammDetector
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.watsonmarlow323_pump import WatsonMarlow323Pump
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
@@ -157,8 +157,8 @@ def dcm() -> DCM:
 
 
 @device_factory(mock=True)
-def undulator() -> Undulator:
-    return Undulator(
+def undulator() -> UndulatorInKeV:
+    return UndulatorInKeV(
         f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
         poles=80,
         length=2.0,

dodal/devices/aithre_lasershaping/goniometer.py

@@ -1,9 +1,9 @@
 from ophyd_async.epics.motor import Motor
 
-from dodal.devices.motors import XYZStage, create_axis_perp_to_rotation
+from dodal.devices.motors import XYZOmegaStage, create_axis_perp_to_rotation
 
 
-class Goniometer(XYZStage):
+class Goniometer(XYZOmegaStage):
     """The Aithre lab goniometer and the XYZ stage it sits on.
 
     `x`, `y` and `z` control the axes of the positioner at the base, while `sampy` and
@@ -15,11 +15,28 @@ class Goniometer(XYZStage):
     regardless of the current rotation.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.sampy = Motor(prefix + "SAMPY")
-        self.sampz = Motor(prefix + "SAMPZ")
-        self.omega = Motor(prefix + "OMEGA")
-        self.vertical_position = create_axis_perp_to_rotation(
-            self.omega, self.sampz, self.sampy
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = "X",
+        y_infix: str = "Y",
+        z_infix: str = "Z",
+        omega_infix: str = "OMEGA",
+        sampy_infix: str = "SAMPY",
+        sampz_infix: str = "SAMPZ",
+    ) -> None:
+        super().__init__(
+            prefix=prefix,
+            name=name,
+            x_infix=x_infix,
+            y_infix=y_infix,
+            z_infix=z_infix,
+            omega_infix=omega_infix,
         )
-        super().__init__(name)
+        with self.add_children_as_readables():
+            self.sampy = Motor(prefix + sampy_infix)
+            self.sampz = Motor(prefix + sampz_infix)
+            self.vertical_position = create_axis_perp_to_rotation(
+                self.omega, self.sampz, self.sampy
+            )

dodal/devices/aperturescatterguard.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+from math import inf
 
 from bluesky.protocols import Preparable
 from ophyd_async.core import (
@@ -112,7 +113,7 @@ def load_positions_from_beamline_parameters(
 ) -> dict[ApertureValue, AperturePosition]:
     return {
         ApertureValue.OUT_OF_BEAM: AperturePosition.from_gda_params(
-            _GDAParamApertureValue.ROBOT_LOAD, 0, params
+            _GDAParamApertureValue.ROBOT_LOAD, inf, params
         ),
         ApertureValue.SMALL: AperturePosition.from_gda_params(
             _GDAParamApertureValue.SMALL, 20, params
@@ -124,7 +125,7 @@ def load_positions_from_beamline_parameters(
             _GDAParamApertureValue.LARGE, 100, params
         ),
         ApertureValue.PARKED: AperturePosition.from_gda_params(
-            _GDAParamApertureValue.MANUAL_LOAD, 0, params
+            _GDAParamApertureValue.MANUAL_LOAD, inf, params
         ),
     }
 

dodal/devices/apple2_undulator.py

@@ -23,11 +23,13 @@ from ophyd_async.core import (
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 from ophyd_async.epics.motor import Motor
 
+from dodal.common.enums import EnabledDisabledUpper
 from dodal.log import LOGGER
 
 T = TypeVar("T")
 
 DEFAULT_MOTOR_MIN_TIMEOUT = 10
+MAXIMUM_MOVE_TIME = 550  # There is no useful movements take longer than this.
 
 
 class UndulatorGateStatus(StrictEnum):
@@ -36,16 +38,24 @@ class UndulatorGateStatus(StrictEnum):
 
 
 @dataclass
-class Apple2PhasesVal:
+class Apple2LockedPhasesVal:
     top_outer: str
-    top_inner: str
     btm_inner: str
+
+
+@dataclass
+class Apple2PhasesVal(Apple2LockedPhasesVal):
+    top_inner: str
     btm_outer: str
 
 
 @dataclass
-class Apple2Val(Apple2PhasesVal):
+class Apple2Val:
     gap: str
+    phase: Apple2LockedPhasesVal | Apple2PhasesVal
+
+    def extract_phase_val(self):
+        return self.phase
 
 
 class Pol(StrictEnum):
@@ -80,10 +90,7 @@ class SafeUndulatorMover(StandardReadable, Movable[T], Generic[T]):
     def __init__(self, set_move: SignalW, prefix: str, name: str = ""):
         # Gate keeper open when move is requested, closed when move is completed
         self.gate = epics_signal_r(UndulatorGateStatus, prefix + "BLGATE")
-
-        split_pv = prefix.split("-")
-        fault_pv = f"{split_pv[0]}-{split_pv[1]}-STAT-{split_pv[3]}ANYFAULT"
-        self.fault = epics_signal_r(float, fault_pv)
+        self.status = epics_signal_r(EnabledDisabledUpper, prefix + "IDBLENA")
         self.set_move = set_move
         super().__init__(name)
 
@@ -91,14 +98,14 @@ class SafeUndulatorMover(StandardReadable, Movable[T], Generic[T]):
     async def set(self, value: T) -> None:
         LOGGER.info(f"Setting {self.name} to {value}")
         await self.raise_if_cannot_move()
-        await self._set_demand_positions(value)
+        await self.set_demand_positions(value)
         timeout = await self.get_timeout()
         LOGGER.info(f"Moving {self.name} to {value} with timeout = {timeout}")
         await self.set_move.set(value=1, timeout=timeout)
         await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     @abc.abstractmethod
-    async def _set_demand_positions(self, value: T) -> None:
+    async def set_demand_positions(self, value: T) -> None:
         """Set the demand positions on the device without actually hitting move."""
 
     @abc.abstractmethod
@@ -106,8 +113,8 @@ class SafeUndulatorMover(StandardReadable, Movable[T], Generic[T]):
         """Get the timeout for the move based on an estimate of how long it will take."""
 
     async def raise_if_cannot_move(self) -> None:
-        if await self.fault.get_value() != 0:
-            raise RuntimeError(f"{self.name} is in fault state")
+        if await self.status.get_value() is not EnabledDisabledUpper.ENABLED:
+            raise RuntimeError(f"{self.name} is DISABLED and cannot move.")
         if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
@@ -158,7 +165,7 @@ class UndulatorGap(SafeUndulatorMover[float]):
             self.user_readback = epics_signal_r(float, prefix + "CURRGAPD")
         super().__init__(self.set_move, prefix, name)
 
-    async def _set_demand_positions(self, value: float) -> None:
+    async def set_demand_positions(self, value: float) -> None:
         await self.user_setpoint.set(str(value))
 
     async def get_timeout(self) -> float:
@@ -206,49 +213,39 @@ class UndulatorPhaseMotor(StandardReadable):
         super().__init__(name=name)
 
 
-class UndulatorPhaseAxes(SafeUndulatorMover[Apple2PhasesVal]):
-    """
-    A collection of 4 phase Motor to make up the full id phase motion. We are using the diamond pv convention.
-    e.g. top_outer == Q1
-         top_inner == Q2
-         btm_inner == q3
-         btm_outer == q4
+Apple2PhaseValType = TypeVar("Apple2PhaseValType", bound=Apple2LockedPhasesVal)
 
-    """
+
+class UndulatorLockedPhaseAxes(SafeUndulatorMover[Apple2PhaseValType]):
+    """Two phase Motor to make up the locked id phase motion."""
 
     def __init__(
         self,
         prefix: str,
         top_outer: str,
-        top_inner: str,
         btm_inner: str,
-        btm_outer: str,
         name: str = "",
     ):
         # Gap demand set point and readback
         with self.add_children_as_readables():
             self.top_outer = UndulatorPhaseMotor(prefix=prefix, infix=top_outer)
-            self.top_inner = UndulatorPhaseMotor(prefix=prefix, infix=top_inner)
             self.btm_inner = UndulatorPhaseMotor(prefix=prefix, infix=btm_inner)
-            self.btm_outer = UndulatorPhaseMotor(prefix=prefix, infix=btm_outer)
         # Nothing move until this is set to 1 and it will return to 0 when done.
         self.set_move = epics_signal_rw(int, f"{prefix}BL{top_outer}" + "MOVE")
-
+        self.axes = [self.top_outer, self.btm_inner]
         super().__init__(self.set_move, prefix, name)
 
-    async def _set_demand_positions(self, value: Apple2PhasesVal) -> None:
+    async def set_demand_positions(self, value: Apple2PhaseValType) -> None:
         await asyncio.gather(
             self.top_outer.user_setpoint.set(value=value.top_outer),
-            self.top_inner.user_setpoint.set(value=value.top_inner),
             self.btm_inner.user_setpoint.set(value=value.btm_inner),
-            self.btm_outer.user_setpoint.set(value=value.btm_outer),
         )
 
     async def get_timeout(self) -> float:
         """
         Get all four motor speed, current positions and target positions to calculate required timeout.
         """
-        axes = [self.top_outer, self.top_inner, self.btm_inner, self.btm_outer]
+
         timeouts = await asyncio.gather(
             *[
                 estimate_motor_timeout(
@@ -256,7 +253,7 @@ class UndulatorPhaseAxes(SafeUndulatorMover[Apple2PhasesVal]):
                     axis.user_readback,
                     axis.velocity,
                 )
-                for axis in axes
+                for axis in self.axes
             ]
         )
         """A 2.0 multiplier is required to prevent premature motor timeouts in phase
@@ -266,6 +263,42 @@ class UndulatorPhaseAxes(SafeUndulatorMover[Apple2PhasesVal]):
         return np.max(timeouts) * 2.0
 
 
+class UndulatorPhaseAxes(UndulatorLockedPhaseAxes[Apple2PhasesVal]):
+    """
+    A collection of 4 phase Motor to make up the full id phase motion. We are using the diamond pv convention.
+    e.g. top_outer == Q1
+         top_inner == Q2
+         btm_inner == q3
+         btm_outer == q4
+
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        top_outer: str,
+        top_inner: str,
+        btm_inner: str,
+        btm_outer: str,
+        name: str = "",
+    ):
+        # Gap demand set point and readback
+        with self.add_children_as_readables():
+            self.top_inner = UndulatorPhaseMotor(prefix=prefix, infix=top_inner)
+            self.btm_outer = UndulatorPhaseMotor(prefix=prefix, infix=btm_outer)
+
+        super().__init__(prefix, top_outer=top_outer, btm_inner=btm_inner, name=name)
+        self.axes.extend([self.top_inner, self.btm_outer])
+
+    async def set_demand_positions(self, value: Apple2PhasesVal) -> None:
+        await asyncio.gather(
+            self.top_outer.user_setpoint.set(value=value.top_outer),
+            self.top_inner.user_setpoint.set(value=value.top_inner),
+            self.btm_inner.user_setpoint.set(value=value.btm_inner),
+            self.btm_outer.user_setpoint.set(value=value.btm_outer),
+        )
+
+
 class UndulatorJawPhase(SafeUndulatorMover[float]):
     """
     A JawPhase movable, this is use for moving the jaw phase which is use to control the
@@ -287,7 +320,7 @@ class UndulatorJawPhase(SafeUndulatorMover[float]):
 
         super().__init__(self.set_move, prefix, name)
 
-    async def _set_demand_positions(self, value: float) -> None:
+    async def set_demand_positions(self, value: float) -> None:
         await self.jaw_phase.user_setpoint.set(value=str(value))
 
     async def get_timeout(self) -> float:
@@ -301,7 +334,10 @@ class UndulatorJawPhase(SafeUndulatorMover[float]):
         )
 
 
-class Apple2(StandardReadable, Movable):
+PhaseAxesType = TypeVar("PhaseAxesType", bound=UndulatorLockedPhaseAxes)
+
+
+class Apple2(StandardReadable, Movable[Apple2Val], Generic[PhaseAxesType]):
     """
     Device representing the combined motor controls for an Apple2 undulator.
 
@@ -313,7 +349,7 @@ class Apple2(StandardReadable, Movable):
         The undulator phase axes device, consisting of four phase motors.
     """
 
-    def __init__(self, id_gap: UndulatorGap, id_phase: UndulatorPhaseAxes, name=""):
+    def __init__(self, id_gap: UndulatorGap, id_phase: PhaseAxesType, name=""):
         """
         Parameters
         ----------
@@ -339,12 +375,12 @@ class Apple2(StandardReadable, Movable):
 
         # Only need to check gap as the phase motors share both fault and gate with gap.
         await self.gap().raise_if_cannot_move()
+
         await asyncio.gather(
-            self.phase().top_outer.user_setpoint.set(value=id_motor_values.top_outer),
-            self.phase().top_inner.user_setpoint.set(value=id_motor_values.top_inner),
-            self.phase().btm_inner.user_setpoint.set(value=id_motor_values.btm_inner),
-            self.phase().btm_outer.user_setpoint.set(value=id_motor_values.btm_outer),
-            self.gap().user_setpoint.set(value=id_motor_values.gap),
+            self.phase().set_demand_positions(
+                value=id_motor_values.extract_phase_val()
+            ),
+            self.gap().set_demand_positions(value=float(id_motor_values.gap)),
         )
         timeout = np.max(
             await asyncio.gather(self.gap().get_timeout(), self.phase().get_timeout())
@@ -367,7 +403,7 @@ class EnergyMotorConvertor(Protocol):
         ...
 
 
-Apple2Type = TypeVar("Apple2Type", bound="Apple2")
+Apple2Type = TypeVar("Apple2Type", bound=Apple2)
 
 
 class Apple2Controller(abc.ABC, StandardReadable, Generic[Apple2Type]):
@@ -444,16 +480,25 @@ class Apple2Controller(abc.ABC, StandardReadable, Generic[Apple2Type]):
         self.polarisation_setpoint, self._polarisation_setpoint_set = (
             soft_signal_r_and_setter(Pol)
         )
+        # check if undulator phase is unlocked.
+        if isinstance(self.apple2().phase(), UndulatorPhaseAxes):
+            top_inner = self.apple2().phase().top_inner.user_readback
+            btm_outer = self.apple2().phase().btm_outer.user_readback
+        else:
+            # If locked phase axes make the locked phase 0.
+            top_inner = btm_outer = soft_signal_rw(float, initial_value=0.0)
+
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Hardware backed read/write for polarisation.
+
             self.polarisation = derived_signal_rw(
                 raw_to_derived=self._read_pol,
                 set_derived=self._set_pol,
                 pol=self.polarisation_setpoint,
                 top_outer=self.apple2().phase().top_outer.user_readback,
-                top_inner=self.apple2().phase().top_inner.user_readback,
+                top_inner=top_inner,
                 btm_inner=self.apple2().phase().btm_inner.user_readback,
-                btm_outer=self.apple2().phase().btm_outer.user_readback,
+                btm_outer=btm_outer,
                 gap=self.apple2().gap().user_readback,
             )
         super().__init__(name)
@@ -501,7 +546,7 @@ class Apple2Controller(abc.ABC, StandardReadable, Generic[Apple2Type]):
     ) -> None:
         # This changes the pol setpoint and then changes polarisation via set energy.
         self._polarisation_setpoint_set(value)
-        await self.energy.set(await self.energy.get_value())
+        await self.energy.set(await self.energy.get_value(), timeout=MAXIMUM_MOVE_TIME)
 
     def _read_pol(
         self,
@@ -681,7 +726,7 @@ class InsertionDeviceEnergy(InsertionDeviceEnergyBase):
 
     @AsyncStatus.wrap
     async def set(self, energy: float) -> None:
-        await self.energy().set(energy)
+        await self.energy().set(energy, timeout=MAXIMUM_MOVE_TIME)
 
 
 class InsertionDevicePolarisation(StandardReadable, Locatable[Pol]):
@@ -696,7 +741,7 @@ class InsertionDevicePolarisation(StandardReadable, Locatable[Pol]):
 
     @AsyncStatus.wrap
     async def set(self, pol: Pol) -> None:
-        await self.polarisation().set(pol)
+        await self.polarisation().set(pol, timeout=MAXIMUM_MOVE_TIME)
 
     async def locate(self) -> Location[Pol]:
         """Return the current polarisation"""

dodal/devices/areadetector/plugins/mjpg.py

@@ -28,11 +28,18 @@ class MJPG(StandardReadable, Triggerable, ABC):
     latest image from the stream to the `post_processing` method for child classes to handle.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_size_pv: str = "ArraySize1_RBV",
+        y_size_pv: str = "ArraySize2_RBV",
+    ) -> None:
         self.url = epics_signal_rw(str, prefix + "JPG_URL_RBV")
+        self.video_url = epics_signal_rw(str, prefix + "MJPG_URL_RBV")
 
-        self.x_size = epics_signal_r(int, prefix + "ArraySize1_RBV")
-        self.y_size = epics_signal_r(int, prefix + "ArraySize2_RBV")
+        self.x_size = epics_signal_r(int, prefix + x_size_pv)
+        self.y_size = epics_signal_r(int, prefix + y_size_pv)
 
         with self.add_children_as_readables():
             self.filename = soft_signal_rw(str)

dodal/devices/beamsize/beamsize.py

@@ -0,0 +1,6 @@
+from ophyd_async.core import SignalR, StandardReadable
+
+
+class BeamsizeBase(StandardReadable):
+    x_um: SignalR[float]
+    y_um: SignalR[float]

dodal/devices/detector/det_resolution.py

@@ -10,14 +10,16 @@ def _get_detector_radius_mm(detector_params: DetectorParams):
     return 0.5 * _get_detector_max_size_mm(detector_params)
 
 
-def _get_detector_max_size_mm(detector_params):
+def _get_detector_max_size_mm(detector_params: DetectorParams):
     return max(
         detector_params.detector_size_constants.det_dimension.width,
         detector_params.detector_size_constants.det_dimension.height,
     )
 
 
-def _get_beam_xy_accounting_for_roi(detector_params, det_distance_mm):
+def _get_beam_xy_accounting_for_roi(
+    detector_params: DetectorParams, det_distance_mm: float
+):
     beam_x = detector_params.beam_xy_converter.get_beam_xy_from_det_dist(
         det_distance_mm, Axis.X_AXIS
     )

dodal/devices/fast_grid_scan.py

@@ -1,5 +1,7 @@
 import asyncio
 from abc import ABC, abstractmethod
+from functools import partial
+from math import isclose
 from typing import Generic, TypeVar
 
 import numpy as np
@@ -307,13 +309,23 @@ class FastGridScanCommon(
         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
+
+            matcher = partial(isclose, param_value, abs_tol=0.001)
+
+            set_statuses.append(
+                set_and_wait_for_value(
+                    signal,  # type: ignore
+                    param_value,
+                    match_value=matcher,
+                )
+            )
 
         # Counter should always start at 0
-        set_statuses.append(await set_and_wait_for_value(self.position_counter, 0))
+        set_statuses.append(set_and_wait_for_value(self.position_counter, 0))
 
         LOGGER.info("Gridscan parameters applied, waiting for sets to complete...")
 

dodal/devices/i03/beamsize.py

@@ -0,0 +1,35 @@
+from ophyd_async.core import Reference, derived_signal_r
+
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamsize.beamsize import BeamsizeBase
+from dodal.devices.i03.constants import BeamsizeConstants
+
+
+class Beamsize(BeamsizeBase):
+    def __init__(self, aperture_scatterguard: ApertureScatterguard, name=""):
+        super().__init__(name=name)
+        self._aperture_scatterguard_ref = Reference(aperture_scatterguard)
+
+        with self.add_children_as_readables():
+            self.x_um = derived_signal_r(
+                self._get_beamsize_x,
+                aperture_radius=self._aperture_scatterguard_ref().radius,
+                derived_units="µm",
+            )
+            self.y_um = derived_signal_r(
+                self._get_beamsize_y,
+                aperture_radius=self._aperture_scatterguard_ref().radius,
+                derived_units="µm",
+            )
+
+    def _get_beamsize_x(
+        self,
+        aperture_radius: float,
+    ) -> float:
+        return min(aperture_radius, BeamsizeConstants.BEAM_WIDTH_UM)
+
+    def _get_beamsize_y(
+        self,
+        aperture_radius: float,
+    ) -> float:
+        return min(aperture_radius, BeamsizeConstants.BEAM_HEIGHT_UM)

dodal/devices/i03/constants.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class BeamsizeConstants:
+    BEAM_WIDTH_UM = 80.0
+    BEAM_HEIGHT_UM = 20.0

dodal/devices/i03/undulator_dcm.py

@@ -5,7 +5,7 @@ from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 from dodal.devices.i03.dcm import DCM
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.log import LOGGER
 
 ENERGY_TIMEOUT_S: float = 30.0
@@ -31,7 +31,7 @@ class UndulatorDCM(StandardReadable, Movable[float]):
 
     def __init__(
         self,
-        undulator: Undulator,
+        undulator: UndulatorInKeV,
         dcm: DCM,
         daq_configuration_path: str,
         name: str = "",