dls-dodal 1.49.0__py3-none-any.whl → 1.51.0__py3-none-any.whl

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -1,9 +1,10 @@
 import asyncio
 from abc import ABC, abstractmethod
+from collections.abc import Mapping
 from typing import Generic, TypeVar
 
 import numpy as np
-from bluesky.protocols import Movable, Preparable
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     Array1D,
     AsyncStatus,
@@ -16,7 +17,6 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
-from ophyd_async.epics.motor import Motor
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     TAbstractBaseRegion,
@@ -29,7 +29,6 @@ class AbstractAnalyserDriverIO(
     ABC,
     StandardReadable,
     ADBaseIO,
-    Preparable,
     Movable[TAbstractBaseRegion],
     Generic[TAbstractBaseRegion],
 ):
@@ -39,8 +38,14 @@ class AbstractAnalyserDriverIO(
     """
 
     def __init__(
-        self, prefix: str, acquisition_mode_type: type[StrictEnum], name: str = ""
+        self,
+        prefix: str,
+        acquisition_mode_type: type[StrictEnum],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
     ) -> None:
+        self.energy_sources = energy_sources
+
         with self.add_children_as_readables():
             self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
             self.spectrum = epics_signal_r(Array1D[np.float64], prefix + "INT_SPECTRUM")
@@ -92,26 +97,6 @@ class AbstractAnalyserDriverIO(
 
         super().__init__(prefix=prefix, name=name)
 
-    @AsyncStatus.wrap
-    async def prepare(self, value: Motor):
-        """
-        Prepare the driver for a region by passing in the energy source motor selected
-        by a region.
-
-        Args:
-            value: The motor that contains the information on the current excitation
-                   energy. Needed to prepare region for epics to accuratly calculate
-                   kinetic energy for an energy scan when in binding energy mode.
-        """
-        energy_source = value
-        excitation_energy_value = await energy_source.user_readback.get_value()  # eV
-        excitation_energy_source_name = energy_source.name
-
-        await asyncio.gather(
-            self.excitation_energy.set(excitation_energy_value),
-            self.excitation_energy_source.set(excitation_energy_source_name),
-        )
-
     @AsyncStatus.wrap
     async def set(self, region: TAbstractBaseRegion):
         """
@@ -121,10 +106,13 @@ class AbstractAnalyserDriverIO(
         Args:
             region: Contains the parameters to setup the driver for a scan.
         """
+
+        source = self._get_energy_source(region.excitation_energy_source)
+        excitation_energy = await source.get_value()  # eV
+
         pass_energy_type = self.pass_energy_type
         pass_energy = pass_energy_type(region.pass_energy)
 
-        excitation_energy = await self.excitation_energy.get_value()
         low_energy = to_kinetic_energy(
             region.low_energy, region.energy_mode, excitation_energy
         )
@@ -141,8 +129,19 @@ class AbstractAnalyserDriverIO(
             self.pass_energy.set(pass_energy),
             self.iterations.set(region.iterations),
             self.acquisition_mode.set(region.acquisition_mode),
+            self.excitation_energy.set(excitation_energy),
+            self.excitation_energy_source.set(source.name),
         )
 
+    def _get_energy_source(self, alias_name: str) -> SignalR[float]:
+        energy_source = self.energy_sources.get(alias_name)
+        if energy_source is None:
+            raise KeyError(
+                f"'{energy_source}' is an invalid energy source. Avaliable energy "
+                + f"sources are '{list(self.energy_sources.keys())}'"
+            )
+        return energy_source
+
     @abstractmethod
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         """

dodal/devices/electron_analyser/detector.py

@@ -1,11 +1,9 @@
 from typing import Generic, TypeVar
 
-from bluesky.protocols import Preparable
 from ophyd_async.core import (
     AsyncStatus,
     Reference,
 )
-from ophyd_async.epics.motor import Motor
 
 from dodal.common.data_util import load_json_file_to_class
 from dodal.devices.electron_analyser.abstract.base_detector import (
@@ -22,7 +20,6 @@ from dodal.devices.electron_analyser.abstract.base_region import (
 
 class ElectronAnalyserRegionDetector(
     AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Preparable,
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
     """
@@ -48,16 +45,10 @@ class ElectronAnalyserRegionDetector(
         return self._driver_ref()
 
     @AsyncStatus.wrap
-    async def prepare(self, value: Motor) -> None:
-        """
-        Prepare driver with the region stored and energy_source motor.
-
-        Args:
-            value: The excitation energy source that the region has selected.
-        """
-        excitation_energy_source = value
-        await self.driver.prepare(excitation_energy_source)
+    async def trigger(self) -> None:
+        # Configure region parameters on the driver first before data collection.
         await self.driver.set(self.region)
+        super().trigger()
 
 
 TElectronAnalyserRegionDetector = TypeVar(
@@ -82,7 +73,6 @@ class ElectronAnalyserDetector(
 
     def __init__(
         self,
-        prefix: str,
         sequence_class: type[TAbstractBaseSequence],
         driver: TAbstractAnalyserDriverIO,
         name: str = "",

dodal/devices/electron_analyser/specs/detector.py

@@ -1,3 +1,7 @@
+from collections.abc import Mapping
+
+from ophyd_async.core import SignalR
+
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -8,6 +12,8 @@ from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSeque
 class SpecsDetector(
     ElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
 ):
-    def __init__(self, prefix: str, name: str = ""):
-        driver = SpecsAnalyserDriverIO(prefix=prefix)
-        super().__init__(prefix, SpecsSequence, driver, name)
+    def __init__(
+        self, prefix: str, energy_sources: Mapping[str, SignalR[float]], name: str = ""
+    ):
+        driver = SpecsAnalyserDriverIO(prefix, energy_sources)
+        super().__init__(SpecsSequence, driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections.abc import Mapping
 
 import numpy as np
 from ophyd_async.core import (
@@ -18,7 +19,9 @@ from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
 
 class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self, prefix: str, energy_sources: Mapping[str, SignalR[float]], name: str = ""
+    ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
             self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
@@ -29,7 +32,7 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
             self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
 
-        super().__init__(prefix, AcquisitionMode, name)
+        super().__init__(prefix, AcquisitionMode, energy_sources, name)
 
     @AsyncStatus.wrap
     async def set(self, region: SpecsRegion):

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,3 +1,7 @@
+from collections.abc import Mapping
+
+from ophyd_async.core import SignalR
+
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -17,6 +21,8 @@ class VGScientaDetector(
         VGScientaRegion,
     ]
 ):
-    def __init__(self, prefix: str, name: str = ""):
-        driver = VGScientaAnalyserDriverIO(prefix)
-        super().__init__(prefix, VGScientaSequence, driver, name)
+    def __init__(
+        self, prefix: str, energy_sources: Mapping[str, SignalR], name: str = ""
+    ):
+        driver = VGScientaAnalyserDriverIO(prefix, energy_sources)
+        super().__init__(VGScientaSequence, driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -1,4 +1,5 @@
 import asyncio
+from collections.abc import Mapping
 
 import numpy as np
 from ophyd_async.core import (
@@ -22,7 +23,9 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 
 
 class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self, prefix: str, energy_sources: Mapping[str, SignalR[float]], name: str = ""
+    ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
             self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
@@ -32,11 +35,7 @@ class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
             self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
             self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
 
-        with self.add_children_as_readables():
-            # Used to read detector data after acqusition.
-            self.external_io = epics_signal_r(Array1D[np.float64], prefix + "EXTIO")
-
-        super().__init__(prefix, AcquisitionMode, name)
+        super().__init__(prefix, AcquisitionMode, energy_sources, name)
 
     @AsyncStatus.wrap
     async def set(self, region: VGScientaRegion):

dodal/devices/electron_analyser/vgscienta/region.py

@@ -28,7 +28,6 @@ class VGScientaRegion(AbstractBaseRegion[AcquisitionMode]):
     fix_energy: float = 9.0
     total_steps: float = 13.0
     total_time: float = 13.0
-    exposure_time: float = 1.0
     first_x_channel: int = 1
     last_x_channel: int = 1000
     first_y_channel: int = 101

dodal/devices/fast_grid_scan.py

@@ -1,4 +1,3 @@
-import asyncio
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
@@ -258,7 +257,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
     async def complete(self):
         try:
             await wait_for_value(self.status, 0, self.COMPLETE_STATUS)
-        except asyncio.TimeoutError:
+        except TimeoutError:
             LOGGER.error(
                 "Hyperion timed out waiting for FGS motion to complete. This may have been caused by a goniometer stage getting stuck.\n\
                 Forcibly stopping the FGS motion program..."

dodal/devices/hutch_shutter.py

@@ -81,14 +81,14 @@ class HutchShutter(StandardReadable, Movable[ShutterDemand]):
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
-        interlock_state = await self.interlock.shutter_safe_to_operate()
-        if not interlock_state and not TEST_MODE:
-            # If not in test mode, fail. If in test mode, the optics hutch may be open.
-            raise ShutterNotSafeToOperateError(
-                "The hutch has not been locked, not operating shutter."
-            )
         if not TEST_MODE:
             if value == ShutterDemand.OPEN:
+                interlock_state = await self.interlock.shutter_safe_to_operate()
+                if not interlock_state:
+                    # If not in test mode, fail. If in test mode, the optics hutch may be open.
+                    raise ShutterNotSafeToOperateError(
+                        "The hutch has not been locked, not operating shutter."
+                    )
                 await self.control.set(ShutterDemand.RESET, wait=True)
                 await self.control.set(value, wait=True)
                 return await wait_for_value(

dodal/devices/i04/constants.py

@@ -4,6 +4,6 @@ from dataclasses import dataclass
 
 @dataclass(frozen=True)
 class RedisConstants:
-    REDIS_HOST = os.environ.get("VALKEY_PROD_SVC_SERVICE_HOST", "test_redis")
+    REDIS_HOST = os.environ.get("VALKEY_FOR_MURKO_PROD_SVC_SERVICE_HOST", "test_redis")
     REDIS_PASSWORD = os.environ.get("VALKEY_PASSWORD", "test_redis_password")
     MURKO_REDIS_DB = 7

dodal/devices/i09/__init__.py

@@ -0,0 +1,4 @@
+from dodal.devices.i09.dcm import DCM
+from dodal.devices.i09.grating import I09Grating
+
+__all__ = ["DCM", "I09Grating"]

dodal/devices/i09/dcm.py

@@ -0,0 +1,26 @@
+from ophyd_async.core import derived_signal_r
+
+from dodal.devices.common_dcm import BaseDCM, PitchAndRollCrystal, StationaryCrystal
+
+
+class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
+    """
+    I09 double crystal monochromator (DCM), used to select the energy of the beam.
+    Differences:
+
+    1. Can provide energy in eV via dcm.energy_in_ev read signal
+
+    This DCM is available on i09 and i09_1 endstations.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(prefix, PitchAndRollCrystal, StationaryCrystal, name)
+        self.energy_in_ev = derived_signal_r(
+            self._convert_keV_to_eV, energy_signal=self.energy_in_kev.user_readback
+        )
+        # Set name so that new child signals get correct name
+        # need to do it until https://github.com/bluesky/ophyd-async/pull/899 merged
+        self.set_name(self.name)
+
+    def _convert_keV_to_eV(self, energy_signal: float) -> float:
+        return energy_signal * 1000

dodal/devices/i09/grating.py

@@ -0,0 +1,7 @@
+from ophyd_async.core import StrictEnum
+
+
+class I09Grating(StrictEnum):
+    G_300 = "300 lines/mm"
+    G_400 = "400 lines/mm"
+    G_800 = "800 lines/mm"

dodal/devices/i10/mirrors.py

@@ -1,18 +1,16 @@
-from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
 
+from dodal.devices.motors import XYZStage
 
-class PiezoMirror(StandardReadable):
+
+class PiezoMirror(XYZStage):
     def __init__(
         self,
         prefix: str,
         name: str = "",
     ):
         with self.add_children_as_readables():
-            self.x = Motor(prefix + "X")
-            self.y = Motor(prefix + "Y")
-            self.z = Motor(prefix + "Z")
             self.yaw = Motor(prefix + "YAW")
             self.pitch = Motor(prefix + "PITCH")
             self.roll = Motor(prefix + "ROLL")
@@ -21,4 +19,4 @@ class PiezoMirror(StandardReadable):
                 read_pv=prefix + "FPITCH:RBV:AI",
                 write_pv=prefix + "FPITCH:DMD:AO",
             )
-        super().__init__(name=name)
+        super().__init__(prefix, name)

dodal/devices/i10/rasor/rasor_motors.py

@@ -2,20 +2,6 @@ from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class PinHole(StandardReadable):
-    "Two motors stage for rasor pinhole"
-
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
-        with self.add_children_as_readables():
-            self.x = Motor(prefix + "X")
-            self.y = Motor(prefix + "Y")
-        super().__init__(name=name)
-
-
 class Diffractometer(StandardReadable):
     def __init__(
         self,

dodal/devices/i19/beamstop.py

@@ -1,6 +1,7 @@
 from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw, epics_signal_x
-from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import XYZStage
 
 
 class HomeGroup(StrictEnum):
@@ -18,13 +19,8 @@ class HomingControl(StandardReadable):
         super().__init__(name)
 
 
-class BeamStop(StandardReadable):
+class BeamStop(XYZStage):
     def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.x = Motor(f"{prefix}X")
-            self.y = Motor(f"{prefix}Y")
-            self.z = Motor(f"{prefix}Z")
-
         self.homing = HomingControl(f"{prefix}HM", name)
 
         super().__init__(name)

dodal/devices/i24/aperture.py

@@ -1,6 +1,7 @@
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
-from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import XYStage
 
 
 class AperturePositions(StrictEnum):
@@ -10,7 +11,7 @@ class AperturePositions(StrictEnum):
     MANUAL = "Manual Mounting"
 
 
-class Aperture(StandardReadable):
+class Aperture(XYStage):
     """Device to trigger the aperture motor move on I24.
 
     The aperture positioner has 4 possible positions: In, Out, Robot and Manual.
@@ -20,8 +21,5 @@ class Aperture(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-
         self.position = epics_signal_rw(AperturePositions, prefix + "MP:SELECT")
         super().__init__(name)

dodal/devices/i24/beamstop.py

@@ -1,7 +1,9 @@
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
 
+from dodal.devices.motors import XYZStage
+
 
 class BeamstopPositions(StrictEnum):
     CHECK_BEAM = "CheckBeam"
@@ -12,7 +14,7 @@ class BeamstopPositions(StrictEnum):
     ROBOT = "Robot"
 
 
-class Beamstop(StandardReadable):
+class Beamstop(XYZStage):
     """Device to move the beamstop.
 
     The positioner moves the x,y,z motors when a position is selected.
@@ -25,12 +27,7 @@ class Beamstop(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-        self.z = Motor(prefix + "Z")
-
         self.y_rotation = Motor(prefix + "ROTY")
-
         self.pos_select = epics_signal_rw(BeamstopPositions, prefix + "MP:SELECT")
 
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/i24/pmac.py

@@ -9,13 +9,13 @@ from ophyd_async.core import (
     Reference,
     SignalR,
     SignalRW,
-    StandardReadable,
     observe_signals_value,
     soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
-from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import XYZStage
 
 HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
@@ -192,7 +192,7 @@ class ProgramAbort(Triggerable):
         )
 
 
-class PMAC(StandardReadable):
+class PMAC(XYZStage):
     """Device to control the chip stage on I24."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -209,10 +209,6 @@ class PMAC(StandardReadable):
             self.pmac_string,
         )
 
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-        self.z = Motor(prefix + "Z")
-
         # These next signals are readback values on PVARS which are set by the motion
         # program.
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
@@ -232,4 +228,4 @@ class PMAC(StandardReadable):
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/motors.py

@@ -1,61 +1,118 @@
+from abc import ABC
+
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
+_X, _Y, _Z = "X", "Y", "Z"
 
-class XYZPositioner(StandardReadable):
-    """
 
-    Standard ophyd_async xyz motor stage, by combining 3 Motors,
-    with added infix for extra flexibliy to allow different axes other than x,y,z.
+class Stage(StandardReadable, ABC):
+    """
+    For these devices, the following co-ordinates are typical but not enforced:
+    - z is horizontal & parallel to the direction of beam travel
+    - y is vertical and antiparallel to the force of gravity
+    - x is the cross product of y🞬z
 
     Parameters
     ----------
     prefix:
-        EPICS PV (Common part up to and including :).
+        Common part of the EPICS PV for all motors, including ":".
     name:
-        name for the stage.
-    infix:
-        EPICS PV, default is the ("X", "Y", "Z").
-    Notes
-    -----
-    Example usage::
-        async with init_devices():
-            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
-    Or::
-        with init_devices():
-            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", infix = ("A", "B", "C"))
-
+        Name of the stage, each child motor will be named "{name}-{field_name}"
+    *_infix:
+        Infix between the common prefix and the EPICS motor record fields for the field.
     """
 
+    ...
+
+
+class XThetaStage(Stage):
+    def __init__(
+        self, prefix: str, name: str = "", x_infix: str = _X, theta_infix: str = "A"
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + x_infix)
+            self.theta = Motor(prefix + theta_infix)
+        super().__init__(name=name)
+
+
+class XYStage(Stage):
+    def __init__(
+        self, prefix: str, name: str = "", x_infix: str = _X, y_infix: str = _Y
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + x_infix)
+            self.y = Motor(prefix + y_infix)
+        super().__init__(name=name)
+
+
+class XYZStage(XYStage):
     def __init__(
         self,
         prefix: str,
         name: str = "",
-        infix: tuple[str, str, str] = ("X", "Y", "Z"),
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
     ):
         with self.add_children_as_readables():
-            self.x = Motor(prefix + infix[0])
-            self.y = Motor(prefix + infix[1])
-            self.z = Motor(prefix + infix[2])
-        super().__init__(name=name)
+            self.z = Motor(prefix + z_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
 
 
-class SixAxisGonio(XYZPositioner):
+class XYZThetaStage(XYZStage):
     def __init__(
         self,
         prefix: str,
         name: str = "",
-        infix: tuple[str, str, str, str, str, str] = (
-            "X",
-            "Y",
-            "Z",
-            "KAPPA",
-            "PHI",
-            "OMEGA",
-        ),
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        theta_infix: str = _Z,
+    ) -> None:
+        with self.add_children_as_readables():
+            self.theta = Motor(prefix + theta_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
+class XYPitchStage(XYStage):
+    def __init__(
+        self,
+        prefix: str,
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        pitch_infix: str = "PITCH",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + pitch_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
+
+
+class SixAxisGonio(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        kappa_infix: str = "KAPPA",
+        phi_infix: str = "PHI",
+        omega_infix: str = "OMEGA",
     ):
         with self.add_children_as_readables():
-            self.kappa = Motor(prefix + infix[3])
-            self.phi = Motor(prefix + infix[4])
-            self.omega = Motor(prefix + infix[5])
-        super().__init__(name=name, prefix=prefix, infix=infix[0:3])
+            self.kappa = Motor(prefix + kappa_infix)
+            self.phi = Motor(prefix + phi_infix)
+            self.omega = Motor(prefix + omega_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
+class YZStage(Stage):
+    def __init__(
+        self, prefix: str, name: str = "", y_infix: str = _Y, z_infix: str = _Z
+    ) -> None:
+        with self.add_children_as_readables():
+            self.y = Motor(prefix + y_infix)
+            self.z = Motor(prefix + z_infix)
+        super().__init__(name)