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

dodal/devices/oav/oav_calculations.py

@@ -7,6 +7,9 @@ def camera_coordinates_to_xyz_mm(
     omega: float,
     microns_per_i_pixel: float,
     microns_per_j_pixel: float,
+    x_horizontal_sign: int,
+    y_vertical_sign: int,
+    z_vertical_sign: int,
 ) -> np.ndarray:
     """
     Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millimetres.
@@ -18,13 +21,16 @@ def camera_coordinates_to_xyz_mm(
         omega (float): The omega angle of the smargon that the horizontal, vertical measurements were obtained at.
         microns_per_i_pixel (float): The number of microns per i pixel, adjusted for the zoom level horizontal was measured at.
         microns_per_j_pixel (float): The number of microns per j pixel, adjusted for the zoom level vertical was measured at.
+        x_horizontal_sign (int): Direction mapping for x, positive means the oav and motor are on same direction, default from hyperion
+        y_vertical_sign (int): Direction mapping for y
+        z_vertical_sign (int): Direction mapping for z
     """
     # Convert the vertical and horizontal into mm.
     horizontal *= microns_per_i_pixel * 1e-3
     vertical *= microns_per_j_pixel * 1e-3
 
     # +ve x in the OAV camera becomes -ve x in the smargon motors.
-    x = -horizontal
+    x = x_horizontal_sign * horizontal
 
     # Rotating the camera causes the position on the vertical horizontal to change by raising or lowering the centre.
     # We can negate this change by multiplying sin and cosine of the omega.
@@ -33,9 +39,8 @@ def camera_coordinates_to_xyz_mm(
     sine = np.sin(radians)
 
     # +ve y in the OAV camera becomes -ve y in the smargon motors/
-    y = -vertical * cosine
-
-    z = vertical * sine
+    y = y_vertical_sign * vertical * cosine
+    z = z_vertical_sign * vertical * sine
     return np.array([x, y, z], dtype=np.float64)
 
 

dodal/devices/oav/oav_detector.py

@@ -46,9 +46,14 @@ class NullZoomController(BaseZoomController):
     def __init__(self):
         self.level = soft_signal_rw(str, "1.0x")
         self.percentage = soft_signal_rw(float, 100)
+        super().__init__()
 
-    def set(self, value):
-        raise Exception("Attempting to set zoom level of a null zoom controller")
+    @AsyncStatus.wrap
+    async def set(self, value: str) -> None:
+        if value != "1.0x":
+            raise Exception("Attempting to set zoom level of a null zoom controller")
+        else:
+            await self.level.set(value, wait=True)
 
 
 class ZoomController(BaseZoomController):
@@ -74,6 +79,16 @@ class ZoomController(BaseZoomController):
 
 
 class OAV(StandardReadable):
+    """
+    Class for oav device
+
+    x_direction(int): Should only be 1 or -1, with 1 indicating the oav x direction is the same with motor x
+    y_direction(int): Same with x_direction but for motor y
+    z_direction(int): Same with x_direction but for motor z
+    mjpg_x_size_pv(str): PV infix for x_size in mjpg
+    mjpg_y_size_pv(str): PV infix for y_size in mjpg
+    """
+
     beam_centre_i: SignalR[int]
     beam_centre_j: SignalR[int]
 
@@ -82,7 +97,13 @@ class OAV(StandardReadable):
         prefix: str,
         config: OAVConfigBase,
         name: str = "",
+        mjpeg_prefix: str = "MJPG",
         zoom_controller: BaseZoomController | None = None,
+        x_direction: int = -1,
+        y_direction: int = -1,
+        z_direction: int = 1,
+        mjpg_x_size_pv: str = "ArraySize1_RBV",
+        mjpg_y_size_pv: str = "ArraySize2_RBV",
     ):
         self.oav_config = config
         self._prefix = prefix
@@ -98,9 +119,15 @@ class OAV(StandardReadable):
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
         with self.add_children_as_readables():
-            self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
+            self.grid_snapshot = SnapshotWithGrid(
+                f"{prefix}{mjpeg_prefix}:", name, mjpg_x_size_pv, mjpg_y_size_pv
+            )
 
         self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
+        with self.add_children_as_readables():
+            self.x_direction = soft_signal_rw(int, x_direction, name="x_direction")
+            self.y_direction = soft_signal_rw(int, y_direction, name="y_direction")
+            self.z_direction = soft_signal_rw(int, z_direction, name="z_direction")
 
         with self.add_children_as_readables():
             self.microns_per_pixel_x = derived_signal_r(
@@ -116,7 +143,7 @@ class OAV(StandardReadable):
                 coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
             self.snapshot = Snapshot(
-                f"{self._prefix}MJPG:",
+                f"{self._prefix}{mjpeg_prefix}:",
                 self._name,
             )
 
@@ -143,9 +170,16 @@ class OAV(StandardReadable):
 
 
 class OAVBeamCentreFile(OAV):
-    """OAV device that reads its beam centre values from a file. The config parameter
+    """
+    OAV device that reads its beam centre values from a file. The config parameter
     must be a OAVConfigBeamCentre object, as this contains a filepath to where the beam
     centre values are stored.
+
+    x_direction(int): Should only be 1 or -1, with 1 indicating the oav x direction is the same with motor x
+    y_direction(int): Same with x_direction but for motor y
+    z_direction(int): Same with x_direction but for motor z
+    mjpg_x_size_pv(str): PV infix for x_size in mjpg
+    mjpg_y_size_pv(str): PV infix for y_size in mjpg
     """
 
     def __init__(
@@ -153,9 +187,26 @@ class OAVBeamCentreFile(OAV):
         prefix: str,
         config: OAVConfigBeamCentre,
         name: str = "",
+        mjpeg_prefix: str = "MJPG",
         zoom_controller: BaseZoomController | None = None,
+        mjpg_x_size_pv: str = "ArraySize1_RBV",
+        mjpg_y_size_pv: str = "ArraySize2_RBV",
+        x_direction: int = -1,
+        y_direction: int = -1,
+        z_direction: int = 1,
     ):
-        super().__init__(prefix, config, name, zoom_controller)
+        super().__init__(
+            prefix=prefix,
+            config=config,
+            name=name,
+            mjpeg_prefix=mjpeg_prefix,
+            zoom_controller=zoom_controller,
+            mjpg_x_size_pv=mjpg_x_size_pv,
+            mjpg_y_size_pv=mjpg_y_size_pv,
+            x_direction=x_direction,
+            y_direction=y_direction,
+            z_direction=z_direction,
+        )
 
         with self.add_children_as_readables():
             self.beam_centre_i = derived_signal_r(
@@ -189,6 +240,7 @@ class OAVBeamCentrePV(OAV):
         prefix: str,
         config: OAVConfig,
         name: str = "",
+        mjpeg_prefix: str = "MJPG",
         zoom_controller: BaseZoomController | None = None,
         overlay_channel: int = 1,
     ):
@@ -199,4 +251,10 @@ class OAVBeamCentrePV(OAV):
             self.beam_centre_j = epics_signal_r(
                 int, prefix + f"OVER:{overlay_channel}:CenterY"
             )
-        super().__init__(prefix, config, name, zoom_controller)
+        super().__init__(
+            prefix=prefix,
+            config=config,
+            name=name,
+            mjpeg_prefix=mjpeg_prefix,
+            zoom_controller=zoom_controller,
+        )

dodal/devices/oav/oav_parameters.py

@@ -92,8 +92,10 @@ class OAVParameters:
         self.preprocess_K_size: int = update(
             "preProcessKSize", int
         )  # length scale for blur preprocessing
+        self.preprocess_iter: int = update("preProcessIteration", int, default=5)
         self.detection_script_filename: str = update("filename", str)
-        self.close_ksize: int = update("close_ksize", int, default=11)
+        self.open_ksize: int = update("open_ksize", int, default=0)
+        self.close_ksize: int = update("close_ksize", int, default=5)
         self.min_callback_time: float = update("min_callback_time", float, default=0.08)
         self.direction: int = update("direction", int)
         self.max_tip_distance: float = update("max_tip_distance", float, default=300)

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -9,6 +9,7 @@ from bluesky.protocols import Flyable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
     DeviceVector,
+    Reference,
     StandardReadable,
     observe_value,
     soft_signal_r_and_setter,
@@ -17,6 +18,7 @@ from ophyd_async.core import (
 from ophyd_async.epics.core import epics_signal_r
 from redis.asyncio import StrictRedis
 
+from dodal.devices.oav.oav_detector import OAV
 from dodal.log import LOGGER
 
 
@@ -35,13 +37,10 @@ class Source(IntEnum):
 
 
 class OAVSource(StandardReadable):
-    def __init__(
-        self,
-        prefix: str,
-        oav_name: str,
-    ):
-        self.url = epics_signal_r(str, f"{prefix}MJPG_URL_RBV")
-        self.oav_name = oav_name
+    def __init__(self, oav: OAV, label: str):
+        self.url_ref = Reference(oav.snapshot.video_url)
+        self.oav_ref = Reference(oav)
+        self.label = label
         super().__init__()
 
 
@@ -62,6 +61,8 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     def __init__(
         self,
         prefix: str,
+        oav_roi: OAV,
+        oav_fs: OAV,
         redis_host: str,
         redis_password: str,
         redis_db: int = 0,
@@ -78,13 +79,13 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
             name: str               the name of this device
         """
         self.counter = epics_signal_r(int, f"{prefix}CAM:ArrayCounter_RBV")
-
         self.sources = DeviceVector(
             {
-                Source.ROI.value: OAVSource(f"{prefix}MJPG:", "roi"),
-                Source.FULL_SCREEN.value: OAVSource(f"{prefix}XTAL:", "fullscreen"),
+                Source.ROI.value: OAVSource(oav_roi, "roi"),
+                Source.FULL_SCREEN.value: OAVSource(oav_fs, "fullscreen"),
             }
         )
+
         self.selected_source = soft_signal_rw(int)
 
         self.forwarding_task = None
@@ -120,11 +121,11 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
         self, function_to_do: Callable[[ClientResponse, OAVSource], Awaitable]
     ):
         source_idx = await self.selected_source.get_value()
+        source = self.sources[source_idx]
+        stream_url = await source.url_ref().get_value()
         LOGGER.info(
-            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_idx}"
+            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_idx} from URL {stream_url}"
         )
-        source = self.sources[source_idx]
-        stream_url = await source.url.get_value()
         async with ClientSession() as session:
             async with session.get(stream_url) as response:
                 await function_to_do(response, source)
@@ -141,12 +142,14 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
             asyncio.wait_for(self._stop_flag.wait(), timeout=self.TIMEOUT)
         )
         async for frame_count in observe_value(self.counter, done_status=done_status):
-            redis_uuid = f"{source.oav_name}-{frame_count}-{uuid4()}"
+            redis_uuid = f"{source.label}-{frame_count}-{uuid4()}"
             await self._get_frame_and_put_to_redis(redis_uuid, response)
 
     async def _confirm_mjpg_stream(self, response: ClientResponse, source: OAVSource):
         if response.content_type != "multipart/x-mixed-replace":
-            raise ValueError(f"{await source.url.get_value()} is not an MJPG stream")
+            raise ValueError(
+                f"{await source.url_ref().get_value()} is not an MJPG stream"
+            )
 
     @AsyncStatus.wrap
     async def kickoff(self):

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -67,6 +67,8 @@ class PinTipDetection(StandardReadable):
         )
         self.canny_upper_threshold = soft_signal_rw(int, 100, name="canny_upper")
         self.canny_lower_threshold = soft_signal_rw(int, 50, name="canny_lower")
+        self.open_ksize = soft_signal_rw(int, 0, name="open_ksize")
+        self.open_iterations = soft_signal_rw(int, 5, name="open_iterations")
         self.close_ksize = soft_signal_rw(int, 5, name="close_ksize")
         self.close_iterations = soft_signal_rw(int, 5, name="close_iterations")
         self.scan_direction = soft_signal_rw(
@@ -105,7 +107,7 @@ class PinTipDetection(StandardReadable):
 
         try:
             preprocess_func = ARRAY_PROCESSING_FUNCTIONS_MAP[preprocess_key](
-                iter=preprocess_iter, ksize=preprocess_ksize
+                iterations=preprocess_iter, ksize=preprocess_ksize
             )
         except KeyError:
             LOGGER.error("Invalid preprocessing function, using identity")
@@ -121,6 +123,8 @@ class PinTipDetection(StandardReadable):
             preprocess=preprocess_func,
             canny_lower=await self.canny_lower_threshold.get_value(),
             canny_upper=await self.canny_upper_threshold.get_value(),
+            open_ksize=await self.open_ksize.get_value(),
+            open_iterations=await self.open_iterations.get_value(),
             close_ksize=await self.close_ksize.get_value(),
             close_iterations=await self.close_iterations.get_value(),
             scan_direction=direction,

dodal/devices/oav/pin_image_recognition/utils.py

@@ -14,6 +14,12 @@ class ScanDirections(Enum):
     REVERSE = -1
 
 
+"""
+See https://opencv24-python-tutorials.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_morphological_ops/py_morphological_ops.html
+for description of functions below.
+"""
+
+
 def identity(*args, **kwargs) -> Callable[[np.ndarray], np.ndarray]:
     return lambda arr: arr
 
@@ -109,6 +115,8 @@ class MxSampleDetect:
         self,
         *,
         preprocess: Callable[[np.ndarray], np.ndarray] = lambda arr: arr,
+        open_ksize: int = 0,
+        open_iterations: int = 5,
         canny_upper: int = 100,
         canny_lower: int = 50,
         close_ksize: int = 5,
@@ -123,6 +131,12 @@ class MxSampleDetect:
             preprocess: A preprocessing function applied to the array after conversion to grayscale.
                 See implementations of common functions above for predefined conversions
                 Defaults to a no-op (i.e. no preprocessing)
+
+            for open and close operations, please read:
+                https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html
+
+            open_ksize: kernel size for "open" operation, if set to zero then ignore "open" operation
+            open_iterations: number of iterations for "open" operation
             canny_upper: upper threshold for canny edge detection
             canny_lower: lower threshold for canny edge detection
             close_ksize: kernel size for "close" operation
@@ -132,6 +146,8 @@ class MxSampleDetect:
         """
 
         self.preprocess = preprocess
+        self.open_ksize = open_ksize
+        self.open_iterations = open_iterations
         self.canny_upper = canny_upper
         self.canny_lower = canny_lower
         self.close_ksize = close_ksize
@@ -148,8 +164,14 @@ class MxSampleDetect:
             assert arr.ndim == 2
             gray_arr = arr
 
+        # Remove Noises if open set to non-zero
+        if self.open_ksize == 0:
+            open_arr = gray_arr
+        else:
+            open_arr = open_morph(self.open_ksize, self.open_iterations)(gray_arr)
+
         # Preprocess the array. (Use the greyscale one.)
-        pp_arr = self.preprocess(gray_arr)
+        pp_arr = self.preprocess(open_arr)
 
         # Find some edges.
         edge_arr = cv2.Canny(pp_arr, self.canny_upper, self.canny_lower)

dodal/devices/oav/snapshots/snapshot_with_grid.py

@@ -12,7 +12,13 @@ from dodal.log import LOGGER
 
 
 class SnapshotWithGrid(MJPG):
-    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:
         with self.add_children_as_readables():
             self.top_left_x = soft_signal_rw(float)
             self.top_left_y = soft_signal_rw(float)
@@ -23,7 +29,7 @@ class SnapshotWithGrid(MJPG):
             self.last_path_outer = soft_signal_rw(str)
             self.last_path_full_overlay = soft_signal_rw(str)
 
-        super().__init__(prefix, name)
+        super().__init__(prefix, name, x_size_pv, y_size_pv)
 
     async def post_processing(self, image: Image):
         # Save an unmodified image with no suffix

dodal/devices/oav/utils.py

@@ -5,13 +5,13 @@ import bluesky.plan_stubs as bps
 import numpy as np
 from bluesky.utils import Msg
 
+from dodal.devices.motors import XYZOmegaStage
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
     camera_coordinates_to_xyz_mm,
 )
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
-from dodal.devices.smargon import Smargon
 
 Pixel = tuple[int, int]
 
@@ -52,24 +52,29 @@ class EdgeOutputArrayImageType(IntEnum):
 
 
 def get_move_required_so_that_beam_is_at_pixel(
-    smargon: Smargon, pixel: Pixel, oav: OAV
+    gonio: XYZOmegaStage,
+    pixel: Pixel,
+    oav: OAV,
 ) -> Generator[Msg, None, np.ndarray]:
     """Calculate the required move so that the given pixel is in the centre of the beam."""
 
     current_motor_xyz = np.array(
         [
-            (yield from bps.rd(smargon.x)),
-            (yield from bps.rd(smargon.y)),
-            (yield from bps.rd(smargon.z)),
+            (yield from bps.rd(gonio.x)),
+            (yield from bps.rd(gonio.y)),
+            (yield from bps.rd(gonio.z)),
         ],
         dtype=np.float64,
     )
-    current_angle = yield from bps.rd(smargon.omega)
+    current_angle = yield from bps.rd(gonio.omega)
 
     beam_x = yield from bps.rd(oav.beam_centre_i)
     beam_y = yield from bps.rd(oav.beam_centre_j)
     microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
     microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
+    x_direction = yield from bps.rd(oav.x_direction)
+    y_direction = yield from bps.rd(oav.y_direction)
+    z_direction = yield from bps.rd(oav.z_direction)
 
     return calculate_x_y_z_of_pixel(
         current_motor_xyz,
@@ -77,6 +82,7 @@ def get_move_required_so_that_beam_is_at_pixel(
         pixel,
         (beam_x, beam_y),
         (microns_per_pixel_x, microns_per_pixel_y),
+        (x_direction, y_direction, z_direction),
     )
 
 
@@ -86,6 +92,7 @@ def calculate_x_y_z_of_pixel(
     pixel: Pixel,
     beam_centre: tuple[int, int],
     microns_per_pixel: tuple[float, float],
+    xyz_direction: tuple[int, int, int],
 ) -> np.ndarray:
     """Get the x, y, z position of a pixel in mm"""
     beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
@@ -96,6 +103,9 @@ def calculate_x_y_z_of_pixel(
         current_omega,
         microns_per_pixel[0],
         microns_per_pixel[1],
+        xyz_direction[0],
+        xyz_direction[1],
+        xyz_direction[2],
     )
 
 

dodal/devices/pgm.py

@@ -7,7 +7,7 @@ from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
 
 
-class PGM(StandardReadable):
+class PlaneGratingMonochromator(StandardReadable):
     """
     Plane grating monochromator, it is use in soft x-ray beamline to generate monochromic beam.
     """

dodal/devices/robot.py

@@ -61,7 +61,7 @@ class ErrorStatus(Device):
             raise RobotLoadError(int(error_code), error_string) from raise_from
 
 
-class BartRobot(StandardReadable, Movable[SampleLocation]):
+class BartRobot(StandardReadable, Movable[SampleLocation | None]):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying
@@ -104,7 +104,6 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.init = epics_signal_x(prefix + "INIT.PROC")
         self.soak = epics_signal_x(prefix + "SOAK.PROC")
         self.home = epics_signal_x(prefix + "GOHM.PROC")
-        self.unload = epics_signal_x(prefix + "UNLD.PROC")
         self.dry = epics_signal_x(prefix + "DRY.PROC")
         self.open = epics_signal_x(prefix + "COLO.PROC")
         self.close = epics_signal_x(prefix + "COLC.PROC")
@@ -175,12 +174,23 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         await self.pin_mounted_or_no_pin_found()
 
     @AsyncStatus.wrap
-    async def set(self, value: SampleLocation):
+    async def set(self, value: SampleLocation | None):
+        """
+        Perform a sample load from the specified sample location
+        Args:
+            value: The pin and puck to load, or None to unload the sample.
+        Raises:
+            RobotLoadError if a timeout occurs, or if an error occurs loading the smaple.
+        """
         try:
-            await wait_for(
-                self._load_pin_and_puck(value),
-                timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
-            )
+            if value is not None:
+                await wait_for(
+                    self._load_pin_and_puck(value),
+                    timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
+                )
+            else:
+                await self.unload.trigger(timeout=self.LOAD_TIMEOUT)
+                await wait_for_value(self.program_running, False, self.NOT_BUSY_TIMEOUT)
         except TimeoutError as e:
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)

dodal/devices/scintillator.py

@@ -8,9 +8,10 @@ from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureVal
 
 
 class InOut(StrictEnum):
-    """Currently Hyperion only needs to move the scintillator out for data collection."""
+    """Moves scintillator in and out of the beam."""
 
-    OUT = "Out"
+    OUT = "Out"  # Out of beam
+    IN = "In"  # In to beam
     UNKNOWN = "Unknown"
 
 
@@ -45,38 +46,63 @@ class Scintillator(StandardReadable):
         self._scintillator_out_yz_mm = [
             float(beamline_parameters[f"scin_{axis}_SCIN_OUT"]) for axis in ("y", "z")
         ]
+        self._scintillator_in_yz_mm = [
+            float(beamline_parameters[f"scin_{axis}_SCIN_IN"]) for axis in ("y", "z")
+        ]
         self._yz_tolerance_mm = [
             float(beamline_parameters[f"scin_{axis}_tolerance"]) for axis in ("y", "z")
         ]
 
         super().__init__(name)
 
-    def _get_selected_position(self, y: float, z: float) -> InOut:
-        current_pos = [y, z]
-        if all(
+    def _check_position(self, current_pos: list[float], pos_to_check: list[float]):
+        return all(
             isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
             for axis_pos, axis_in_beam, axis_tolerance in zip(
                 current_pos,
-                self._scintillator_out_yz_mm,
+                pos_to_check,
                 self._yz_tolerance_mm,
                 strict=False,
             )
-        ):
+        )
+
+    def _get_selected_position(self, y: float, z: float) -> InOut:
+        current_pos = [y, z]
+        if self._check_position(current_pos, self._scintillator_out_yz_mm):
             return InOut.OUT
+
+        elif self._check_position(current_pos, self._scintillator_in_yz_mm):
+            return InOut.IN
+
         else:
             return InOut.UNKNOWN
 
+    async def _check_aperture_parked(self):
+        if (
+            await self._aperture_scatterguard().selected_aperture.get_value()
+            != ApertureValue.PARKED
+        ):
+            raise ValueError(
+                f"Cannot move scintillator if aperture/scatterguard is not parked. Position is currently {await self._aperture_scatterguard().selected_aperture.get_value()}"
+            )
+
     async def _set_selected_position(self, position: InOut) -> None:
         match position:
             case InOut.OUT:
-                if (
-                    self._aperture_scatterguard().selected_aperture.get_value()
-                    != ApertureValue.PARKED
-                ):
-                    raise ValueError(
-                        "Cannot move scintillator out if aperture/scatterguard is not parked"
-                    )
+                current_y = await self.y_mm.user_readback.get_value()
+                current_z = await self.z_mm.user_readback.get_value()
+                if self._get_selected_position(current_y, current_z) == InOut.OUT:
+                    return
+                await self._check_aperture_parked()
                 await self.y_mm.set(self._scintillator_out_yz_mm[0])
                 await self.z_mm.set(self._scintillator_out_yz_mm[1])
+            case InOut.IN:
+                current_y = await self.y_mm.user_readback.get_value()
+                current_z = await self.z_mm.user_readback.get_value()
+                if self._get_selected_position(current_y, current_z) == InOut.IN:
+                    return
+                await self._check_aperture_parked()
+                await self.z_mm.set(self._scintillator_in_yz_mm[1])
+                await self.y_mm.set(self._scintillator_in_yz_mm[0])
             case _:
                 raise ValueError(f"Cannot set scintillator to position {position}")

dodal/devices/smargon.py

@@ -14,7 +14,7 @@ from ophyd_async.core import (
 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
+from dodal.devices.motors import XYZOmegaStage
 from dodal.devices.util.epics_util import SetWhenEnabled
 
 
@@ -78,7 +78,7 @@ class CombinedMove(TypedDict, total=False):
     chi: float | None
 
 
-class Smargon(XYZStage, Movable):
+class Smargon(XYZOmegaStage, Movable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -92,7 +92,6 @@ class Smargon(XYZStage, Movable):
         with self.add_children_as_readables():
             self.chi = Motor(prefix + "CHI")
             self.phi = Motor(prefix + "PHI")
-            self.omega = Motor(prefix + "OMEGA")
             self.real_x1 = Motor(prefix + "MOTOR_3")
             self.real_x2 = Motor(prefix + "MOTOR_4")
             self.real_y = Motor(prefix + "MOTOR_1")