dls-dodal 1.57.0__py3-none-any.whl → 1.59.1__py3-none-any.whl

dodal/devices/electron_analyser/specs/driver_io.py

@@ -1,11 +1,9 @@
 import asyncio
-from collections.abc import Mapping
 from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
     Array1D,
-    AsyncStatus,
     SignalR,
     StandardReadableFormat,
     derived_signal_r,
@@ -16,7 +14,10 @@ from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
 from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
+from dodal.devices.electron_analyser.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
@@ -36,7 +37,7 @@ class SpecsAnalyserDriverIO(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -58,18 +59,11 @@ class SpecsAnalyserDriverIO(
             lens_mode_type=lens_mode_type,
             psu_mode_type=psu_mode_type,
             pass_energy_type=float,
-            energy_sources=energy_sources,
+            energy_source=energy_source,
             name=name,
         )
 
-    @AsyncStatus.wrap
-    async def set(self, region: SpecsRegion[TLensMode, TPsuMode]):
-        source = self._get_energy_source(region.excitation_energy_source)
-        excitation_energy = await source.get_value()  # eV
-        # Copy region so doesn't alter the actual region and switch to kinetic energy
-        ke_region = region.model_copy()
-        ke_region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
-
+    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),
@@ -81,8 +75,6 @@ class SpecsAnalyserDriverIO(
             self.pass_energy.set(ke_region.pass_energy),
             self.iterations.set(ke_region.iterations),
             self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.excitation_energy.set(excitation_energy),
-            self.excitation_energy_source.set(source.name),
             self.snapshot_values.set(ke_region.values),
             self.psu_mode.set(ke_region.psu_mode),
         )

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,8 +1,5 @@
-from collections.abc import Mapping
 from typing import Generic
 
-from ophyd_async.core import SignalR
-
 from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
     TPassEnergyEnum,
@@ -11,7 +8,10 @@ from dodal.devices.electron_analyser.abstract.types import (
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
-from dodal.devices.electron_analyser.enums import SelectedSource
+from dodal.devices.electron_analyser.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
 from dodal.devices.electron_analyser.vgscienta.driver_io import (
     VGScientaAnalyserDriverIO,
 )
@@ -35,11 +35,11 @@ class VGScientaDetector(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: DualEnergySource | EnergySource,
         name: str = "",
     ):
         driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
-            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_sources
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_source
         )
         super().__init__(
             VGScientaSequence[lens_mode_type, psu_mode_type, pass_energy_type],

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -1,11 +1,9 @@
 import asyncio
-from collections.abc import Mapping
 from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
     Array1D,
-    AsyncStatus,
     SignalR,
     StandardReadableFormat,
 )
@@ -19,7 +17,10 @@ from dodal.devices.electron_analyser.abstract.types import (
     TPassEnergyEnum,
     TPsuMode,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
+from dodal.devices.electron_analyser.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
 from dodal.devices.electron_analyser.vgscienta.enums import (
     AcquisitionMode,
     DetectorMode,
@@ -45,7 +46,7 @@ class VGScientaAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -66,17 +67,11 @@ class VGScientaAnalyserDriverIO(
             lens_mode_type,
             psu_mode_type,
             pass_energy_type,
-            energy_sources,
+            energy_source,
             name,
         )
 
-    @AsyncStatus.wrap
-    async def set(self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
-        source = self._get_energy_source(region.excitation_energy_source)
-        excitation_energy = await source.get_value()  # eV
-        # Copy region so doesn't alter the actual region and switch to kinetic energy
-        ke_region = region.model_copy()
-        ke_region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
+    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),
@@ -89,8 +84,6 @@ class VGScientaAnalyserDriverIO(
             self.iterations.set(ke_region.iterations),
             self.acquire_time.set(ke_region.acquire_time),
             self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.excitation_energy.set(excitation_energy),
-            self.excitation_energy_source.set(source.name),
             self.energy_step.set(ke_region.energy_step),
             self.detector_mode.set(ke_region.detector_mode),
             self.region_min_x.set(ke_region.min_x),

dodal/devices/fast_grid_scan.py

@@ -9,9 +9,11 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
     Signal,
+    SignalR,
     SignalRW,
     StandardReadable,
     derived_signal_r,
+    soft_signal_r_and_setter,
     wait_for_value,
 )
 from ophyd_async.epics.core import (
@@ -20,7 +22,7 @@ from ophyd_async.epics.core import (
     epics_signal_rw_rbv,
     epics_signal_x,
 )
-from pydantic import field_validator
+from pydantic import BaseModel, field_validator
 from pydantic.dataclasses import dataclass
 
 from dodal.log import LOGGER
@@ -63,7 +65,7 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     """
     Common holder class for the parameters of a grid scan in a similar
     layout to EPICS. The parameters and functions of this class are common
-    to both the zebra and panda triggered fast grid scans.
+    to both the zebra and panda triggered fast grid scans in 2d or 3d.
 
     The grid specified is where data is taken e.g. it can be assumed the first frame is
     at x_start, y1_start, z1_start and subsequent frames are N*step_size away.
@@ -71,15 +73,11 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
 
     x_steps: int = 1
     y_steps: int = 1
-    z_steps: int = 0
     x_step_size_mm: float = 0.1
     y_step_size_mm: float = 0.1
-    z_step_size_mm: float = 0.1
     x_start_mm: float = 0.1
     y1_start_mm: float = 0.1
-    y2_start_mm: float = 0.1
     z1_start_mm: float = 0.1
-    z2_start_mm: float = 0.1
 
     # Whether to set the stub offsets after centering
     set_stub_offsets: bool = False
@@ -92,16 +90,10 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     def y_axis(self) -> GridAxis:
         return GridAxis(self.y1_start_mm, self.y_step_size_mm, self.y_steps)
 
+    # In 2D grid scans, z axis is just the start position
     @property
     def z_axis(self) -> GridAxis:
-        return GridAxis(self.z2_start_mm, self.z_step_size_mm, self.z_steps)
-
-    def get_num_images(self):
-        return self.x_steps * (self.y_steps + self.z_steps)
-
-    @property
-    def is_3d_grid_scan(self):
-        return self.z_steps > 0
+        return GridAxis(self.z1_start_mm, 0, 1)
 
     def grid_position_to_motor_position(self, grid_position: ndarray) -> ndarray:
         """Converts a grid position, given as steps in the x, y, z grid,
@@ -130,15 +122,33 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         )
 
 
-ParamType = TypeVar("ParamType", bound=GridScanParamsCommon)
-
+class GridScanParamsThreeD(GridScanParamsCommon):
+    """Additional parameters required to do a 3 dimensional gridscan.
 
-class ZebraGridScanParams(GridScanParamsCommon):
-    """
-    Params for standard Zebra FGS. Adds on the dwell time
+    A 3D gridscan works by doing two 2D gridscans. The first of these grids is x_steps by
+    y_steps. The sample is then rotated by 90 degrees, and then the second grid is
+    x_steps by z_steps.
     """
 
-    dwell_time_ms: float = 10
+    # Start position for z and y during the second gridscan
+    z2_start_mm: float = 0.1
+    y2_start_mm: float = 0.1
+
+    z_step_size_mm: float = 0.1
+
+    # Number of vertical steps during the second grid scan, after the rotation in omega
+    z_steps: int = 1
+
+    @property
+    def z_axis(self) -> GridAxis:
+        return GridAxis(self.z2_start_mm, self.z_step_size_mm, self.z_steps)
+
+
+ParamType = TypeVar("ParamType", bound=GridScanParamsCommon, covariant=True)
+
+
+class WithDwellTime(BaseModel):
+    dwell_time_ms: float = 213
 
     @field_validator("dwell_time_ms")
     @classmethod
@@ -154,7 +164,14 @@ class ZebraGridScanParams(GridScanParamsCommon):
         return dwell_time_ms
 
 
-class PandAGridScanParams(GridScanParamsCommon):
+class ZebraGridScanParamsThreeD(GridScanParamsThreeD, WithDwellTime):
+    """
+    Params for standard Zebra FGS. Adds on the dwell time, which is really the time
+    between trigger positions.
+    """
+
+
+class PandAGridScanParams(GridScanParamsThreeD):
     """
     Params for panda constant-motion scan. Adds on the goniometer run-up distance
     """
@@ -163,53 +180,50 @@ class PandAGridScanParams(GridScanParamsCommon):
 
 
 class MotionProgram(Device):
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(self, prefix: str, name: str = "", has_prog_num=True) -> None:
         super().__init__(name)
         self.running = epics_signal_r(int, prefix + "PROGBITS")
-        self.program_number = epics_signal_r(float, prefix + "CS1:PROG_NUM")
+        if has_prog_num:
+            self.program_number = epics_signal_r(float, prefix + "CS1:PROG_NUM")
+        else:
+            # Prog number PV doesn't currently exist for i02-1
+            self.program_number = soft_signal_r_and_setter(float, -1)[0]
 
 
 class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
-    """Device for a general fast grid scan
+    """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,
-    with X as the fast axis and Y as the slow axis. If Z steps isn't 0, the goniometer will
-    then rotate in the omega direction such that it moves from the X-Y, to the X-Z plane then
-    do a second grid scan. The detector is triggered after every x step.
-    See https://github.com/DiamondLightSource/hyperion/wiki/Coordinate-Systems for more
+    with X as the fast axis and Y as the slow axis.
+
+    See ZebraFastGridScanThreeD as an example of how to implement.
     """
 
-    def __init__(self, prefix: str, smargon_prefix: str, name: str = "") -> None:
+    def __init__(
+        self, prefix: str, motion_controller_prefix: str, name: str = ""
+    ) -> None:
+        super().__init__(name)
         self.x_steps = epics_signal_rw_rbv(int, f"{prefix}X_NUM_STEPS")
         self.y_steps = epics_signal_rw_rbv(
             int, f"{prefix}Y_NUM_STEPS"
         )  # Number of vertical steps during the first grid scan
-        self.z_steps = epics_signal_rw_rbv(
-            int, f"{prefix}Z_NUM_STEPS"
-        )  # Number of vertical steps during the second grid scan, after the rotation in omega
         self.x_step_size = epics_signal_rw_rbv(float, f"{prefix}X_STEP_SIZE")
         self.y_step_size = epics_signal_rw_rbv(float, f"{prefix}Y_STEP_SIZE")
-        self.z_step_size = epics_signal_rw_rbv(float, f"{prefix}Z_STEP_SIZE")
         self.x_start = epics_signal_rw_rbv(float, f"{prefix}X_START")
         self.y1_start = epics_signal_rw_rbv(float, f"{prefix}Y_START")
-        self.y2_start = epics_signal_rw_rbv(float, f"{prefix}Y2_START")
         self.z1_start = epics_signal_rw_rbv(float, f"{prefix}Z_START")
-        self.z2_start = epics_signal_rw_rbv(float, f"{prefix}Z2_START")
 
-        self.scan_invalid = epics_signal_r(float, f"{prefix}SCAN_INVALID")
+        # This can be created like a regular signal instead of an abstract method
+        # once https://github.com/DiamondLightSource/mx-bluesky/issues/1203 is done
+        self.scan_invalid = self._create_scan_invalid_signal(prefix)
 
         self.run_cmd = epics_signal_x(f"{prefix}RUN.PROC")
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = derived_signal_r(
-            self._calculate_expected_images,
-            x=self.x_steps,
-            y=self.y_steps,
-            z=self.z_steps,
-        )
+        self.expected_images = self._create_expected_images_signal()
 
-        self.motion_program = MotionProgram(smargon_prefix)
+        self.motion_program = self._create_motion_program(motion_controller_prefix)
 
         self.position_counter = self._create_position_counter(prefix)
 
@@ -221,23 +235,12 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.movable_params: dict[str, Signal] = {
             "x_steps": self.x_steps,
             "y_steps": self.y_steps,
-            "z_steps": self.z_steps,
             "x_step_size_mm": self.x_step_size,
             "y_step_size_mm": self.y_step_size,
-            "z_step_size_mm": self.z_step_size,
             "x_start_mm": self.x_start,
             "y1_start_mm": self.y1_start,
-            "y2_start_mm": self.y2_start,
             "z1_start_mm": self.z1_start,
-            "z2_start_mm": self.z2_start,
         }
-        super().__init__(name)
-
-    def _calculate_expected_images(self, x: int, y: int, z: int) -> int:
-        LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
-        first_grid = x * y
-        second_grid = x * z
-        return first_grid + second_grid
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -266,25 +269,84 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
             raise
 
     @abstractmethod
-    def _create_position_counter(self, prefix: str) -> SignalRW[int]:
-        pass
+    def _create_expected_images_signal(self) -> SignalR[int]: ...
 
+    @abstractmethod
+    def _create_position_counter(self, prefix: str) -> SignalRW[int]: ...
 
-class ZebraFastGridScan(FastGridScanCommon[ZebraGridScanParams]):
-    """Device for standard Zebra FGS. In this scan, the goniometer's velocity profile follows a parabolic shape between X steps,
-    with the slowest points occuring at each X step.
+    # This can be created within init rather than as a separate method after https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    @abstractmethod
+    def _create_scan_invalid_signal(self, prefix: str) -> SignalR[float]: ...
+
+    # This can be created within init rather than as a separate method after https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    @abstractmethod
+    def _create_motion_program(
+        self, motion_controller_prefix: str
+    ) -> MotionProgram: ...
+
+
+class FastGridScanThreeD(FastGridScanCommon[ParamType]):
+    """Device for standard 3D FGS.
+
+    After completeing the first grid, if Z steps isn't 0, the goniometer will
+    rotate in the omega direction such that it moves from the X-Y, to the X-Z plane then
+    do a second grid scan. The detector is triggered after every x step.
+    See https://github.com/DiamondLightSource/hyperion/wiki/Coordinate-Systems for more.
+
+    Subclasses must implement _create_position_counter.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
         full_prefix = prefix + "FGS:"
-        # Time taken to travel between X steps
-        self.dwell_time_ms = epics_signal_rw_rbv(float, f"{full_prefix}DWELL_TIME")
 
+        # 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.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
+
+    def _create_expected_images_signal(self):
+        return derived_signal_r(
+            self._calculate_expected_images,
+            x=self.x_steps,
+            y=self.y_steps,
+            z=self.z_steps,
+        )
+
+    def _calculate_expected_images(self, x: int, y: int, z: int) -> int:
+        LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
+        first_grid = x * y
+        second_grid = x * z
+        return first_grid + second_grid
+
+    def _create_scan_invalid_signal(self, prefix: str) -> SignalR[float]:
+        return epics_signal_r(float, f"{prefix}SCAN_INVALID")
+
+    def _create_motion_program(self, motion_controller_prefix: str):
+        return MotionProgram(motion_controller_prefix)
+
+
+class ZebraFastGridScanThreeD(FastGridScanThreeD[ZebraGridScanParamsThreeD]):
+    """Device for standard Zebra 3D FGS.
+
+    In this scan, the goniometer's velocity profile follows a parabolic shape between X steps,
+    with the slowest points occuring at each X step.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        full_prefix = prefix + "FGS:"
+        # 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
 
     def _create_position_counter(self, prefix: str):
@@ -293,8 +355,12 @@ class ZebraFastGridScan(FastGridScanCommon[ZebraGridScanParams]):
         )
 
 
-class PandAFastGridScan(FastGridScanCommon[PandAGridScanParams]):
-    """Device for panda constant-motion scan"""
+class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
+    """Device for panda constant-motion scan.
+
+    In this scan, the goniometer's velocity
+    is constant through each row. It doesn't slow down when going through trigger points.
+    """
 
     def __init__(self, prefix: str, name: str = "") -> None:
         full_prefix = prefix + "PGS:"
@@ -309,7 +375,7 @@ class PandAFastGridScan(FastGridScanCommon[PandAGridScanParams]):
         self.run_up_distance_mm = epics_signal_rw_rbv(
             float, f"{full_prefix}RUNUP_DISTANCE"
         )
-        super().__init__(full_prefix, prefix, name)
+        super().__init__(prefix, name)
 
         self.movable_params["run_up_distance_mm"] = self.run_up_distance_mm
 

dodal/devices/focusing_mirror.py

@@ -17,6 +17,7 @@ from ophyd_async.epics.core import (
 )
 from ophyd_async.epics.motor import Motor
 
+from dodal.devices.motors import XYPitchStage
 from dodal.log import LOGGER
 
 VOLTAGE_POLLING_DELAY_S = 0.5
@@ -134,6 +135,35 @@ class MirrorVoltages(StandardReadable):
         )
 
 
+class SimpleMirror(XYPitchStage):
+    """Simple Focusing Mirror"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = "X",
+        y_infix: str = "Y",
+        pitch_infix: str = "PITCH",
+    ):
+        super().__init__(
+            name=name,
+            prefix=prefix,
+            x_infix=x_infix,
+            y_infix=y_infix,
+            pitch_infix=pitch_infix,
+        )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.type, _ = soft_signal_r_and_setter(MirrorType, MirrorType.SINGLE)
+
+        with self.add_children_as_readables():
+            self.yaw = Motor(prefix + "YAW")
+            self.bend = Motor(prefix + "BEND")
+            self.jack1 = Motor(prefix + "J1")
+            self.jack2 = Motor(prefix + "J2")
+
+
 class FocusingMirror(StandardReadable):
     """Focusing Mirror"""
 

dodal/devices/i02_1/fast_grid_scan.py

@@ -0,0 +1,61 @@
+from ophyd_async.core import SignalR, derived_signal_r, soft_signal_r_and_setter
+from ophyd_async.epics.core import epics_signal_rw_rbv
+
+from dodal.devices.fast_grid_scan import (
+    FastGridScanCommon,
+    GridScanParamsCommon,
+    MotionProgram,
+    WithDwellTime,
+)
+from dodal.log import LOGGER
+
+
+class ZebraGridScanParamsTwoD(GridScanParamsCommon, WithDwellTime):
+    """
+    Params for 2D Zebra FGS. Adds on the dwell time, which is really the time
+    between trigger positions.
+    """
+
+
+class ZebraFastGridScanTwoD(FastGridScanCommon[ZebraGridScanParamsTwoD]):
+    """i02-1's EPICS interface for the 2D FGS differs slightly from the standard 3D
+    version:
+    - No Z steps, Z step sizes, or Y2 start positions, or Z2 start
+    - No scan valid PV - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    - No program_number - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    """
+
+    def __init__(
+        self, prefix: str, motion_controller_prefix: str, name: str = ""
+    ) -> None:
+        full_prefix = prefix + "FGS:"
+        super().__init__(full_prefix, motion_controller_prefix, name)
+
+        # This signal could be put in the common device if the prefix gets standardised.
+        # 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
+
+    def _create_expected_images_signal(self):
+        return derived_signal_r(
+            self._calculate_expected_images,
+            x=self.x_steps,
+            y=self.y_steps,
+        )
+
+    def _calculate_expected_images(self, x: int, y: int) -> int:
+        LOGGER.info(f"Reading num of images found {x, y} images in each axis")
+        return x * y
+
+    # VMXm triggers the grid scan through GDA, which has its own validity check
+    # so whilst this PV is being added, it isn't essential
+    def _create_scan_invalid_signal(self, prefix: str) -> SignalR[float]:
+        return soft_signal_r_and_setter(float, 0)[0]
+
+    def _create_motion_program(self, motion_controller_prefix):
+        return MotionProgram(motion_controller_prefix, has_prog_num=False)
+
+    # To be standardised in https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    def _create_position_counter(self, prefix: str):
+        return epics_signal_rw_rbv(int, f"{prefix}POS_COUNTER")

dodal/devices/i02_1/sample_motors.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class SampleMotors(StandardReadable):
+    """Virtual Smaract motors on i02-1 (VMXm)"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        # See https://github.com/DiamondLightSource/mx-bluesky/issues/1212
+        # regarding a potential motion issue with omega
+        with self.add_children_as_readables():
+            self.x = Motor(f"{prefix}X")
+            self.z = Motor(f"{prefix}Z")
+            self.omega = Motor(f"{prefix}OMEGA")
+        super().__init__(name=name)