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

dodal/devices/electron_analyser/energy_sources.py

@@ -0,0 +1,101 @@
+from abc import abstractmethod
+
+from ophyd_async.core import (
+    Reference,
+    SignalR,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_r,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+
+from dodal.devices.electron_analyser.enums import SelectedSource
+
+
+class AbstractEnergySource(StandardReadable):
+    """
+    Abstract device that wraps an energy source signal and provides common interface via
+    a energy signal.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        super().__init__(name)
+
+    @property
+    @abstractmethod
+    def energy(self) -> SignalR[float]:
+        """
+        Signal to provide the excitation energy value in eV.
+        """
+
+
+class EnergySource(AbstractEnergySource):
+    """
+    Wraps a signal that relates to energy and provides common interface via energy
+    signal. It provides the name of the wrapped signal as a child signal in the
+    read_configuration via wrapped_device_name and adds the signal as a readable.
+    """
+
+    def __init__(self, source: SignalR[float], name: str = "") -> None:
+        self.add_readables([source])
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.wrapped_device_name, _ = soft_signal_r_and_setter(
+                str, initial_value=source.name
+            )
+        self._source_ref = Reference(source)
+        super().__init__(name)
+
+    @property
+    def energy(self) -> SignalR[float]:
+        return self._source_ref()
+
+
+class DualEnergySource(AbstractEnergySource):
+    """
+    Holds two EnergySource devices and provides a signal to read energy depending on
+    which source is selected. This is controlled by a selected_source signal which can
+    switch source using SelectedSource enum. Both sources energy is recorded in the
+    read, the energy signal is used as a helper signal to know which source is being
+    used.
+    """
+
+    def __init__(
+        self, source1: SignalR[float], source2: SignalR[float], name: str = ""
+    ):
+        """
+        Args:
+            source1: Default energy signal to select.
+            source2: Secondary energy signal to select.
+            name: name of this device.
+        """
+
+        with self.add_children_as_readables():
+            self.selected_source = soft_signal_rw(
+                SelectedSource, initial_value=SelectedSource.SOURCE1
+            )
+            self.source1 = EnergySource(source1)
+            self.source2 = EnergySource(source2)
+
+        self._selected_energy = derived_signal_r(
+            self._get_excitation_energy,
+            "eV",
+            selected_source=self.selected_source,
+            source1=self.source1.energy,
+            source2=self.source2.energy,
+        )
+
+        super().__init__(name)
+
+    def _get_excitation_energy(
+        self, selected_source: SelectedSource, source1: float, source2: float
+    ) -> float:
+        match selected_source:
+            case SelectedSource.SOURCE1:
+                return source1
+            case SelectedSource.SOURCE2:
+                return source2
+
+    @property
+    def energy(self) -> SignalR[float]:
+        return self._selected_energy

dodal/devices/electron_analyser/specs/detector.py

@@ -1,13 +1,13 @@
-from collections.abc import Mapping
 from typing import Generic
 
-from ophyd_async.core import SignalR
-
 from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
 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.specs.driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
 
@@ -25,10 +25,10 @@ class SpecsDetector(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: DualEnergySource | EnergySource,
         name: str = "",
     ):
         driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
-            prefix, lens_mode_type, psu_mode_type, energy_sources
+            prefix, lens_mode_type, psu_mode_type, energy_source
         )
         super().__init__(SpecsSequence[lens_mode_type, psu_mode_type], driver, name)

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"""