dls-dodal 1.61.0__tar.gz → 1.62.0__tar.gz

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dls-dodal
-Version: 1.61.0
+Version: 1.62.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>, Joseph Ware <joseph.ware@diamond.ac.uk>, Oliver Silvester <Oliver.Silvester@diamond.ac.uk>, Noemi Frisina <noemi.frisina@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dls_dodal.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dls-dodal
-Version: 1.61.0
+Version: 1.62.0
 Summary: Ophyd devices and other utils that could be used across DLS beamlines
 Author-email: Dominic Oram <dominic.oram@diamond.ac.uk>, Joseph Ware <joseph.ware@diamond.ac.uk>, Oliver Silvester <Oliver.Silvester@diamond.ac.uk>, Noemi Frisina <noemi.frisina@diamond.ac.uk>
 License:                                  Apache License

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dls_dodal.egg-info/SOURCES.txt

@@ -166,6 +166,7 @@ src/dodal/devices/eiger.py
 src/dodal/devices/eiger_odin.py
 src/dodal/devices/eurotherm.py
 src/dodal/devices/fast_grid_scan.py
+src/dodal/devices/fast_shutter.py
 src/dodal/devices/fluorescence_detector_motion.py
 src/dodal/devices/flux.py
 src/dodal/devices/focusing_mirror.py
@@ -297,6 +298,8 @@ src/dodal/devices/i19/beamstop.py
 src/dodal/devices/i19/blueapi_device.py
 src/dodal/devices/i19/diffractometer.py
 src/dodal/devices/i19/hutch_access.py
+src/dodal/devices/i19/mapt_configuration.py
+src/dodal/devices/i19/pin_col_stages.py
 src/dodal/devices/i19/shutter.py
 src/dodal/devices/i20_1/__init__.py
 src/dodal/devices/i21/__init__.py
@@ -426,6 +429,7 @@ tests/devices/test_common_dcm.py
 tests/devices/test_controllers.py
 tests/devices/test_diamond_filter.py
 tests/devices/test_eiger.py
+tests/devices/test_fast_shutters.py
 tests/devices/test_focusing_mirror.py
 tests/devices/test_gridscan.py
 tests/devices/test_hutch_shutter.py
@@ -521,6 +525,8 @@ tests/devices/i19/__init__.py
 tests/devices/i19/test_backlight.py
 tests/devices/i19/test_beamstop.py
 tests/devices/i19/test_diffractometer.py
+tests/devices/i19/test_mapt.py
+tests/devices/i19/test_pin_col.py
 tests/devices/i19/test_shutter.py
 tests/devices/i22/__init__.py
 tests/devices/i22/test_dcm.py

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.61.0'
-__version_tuple__ = version_tuple = (1, 61, 0)
+__version__ = version = '1.62.0'
+__version_tuple__ = version_tuple = (1, 62, 0)
 
-__commit_id__ = commit_id = 'gdf177058e'
+__commit_id__ = commit_id = 'g146f56508'

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/beamlines/i04.py

@@ -234,7 +234,7 @@ def undulator() -> Undulator:
     """
     return Undulator(
         prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
-        id_gap_lookup_table_path="/dls_sw/i04/software/gda/config/lookupTables/BeamLine_Undulator_toGap.txt",
+        id_gap_lookup_table_path="/dls_sw/i04/software/daq_configuration/lookup/BeamLine_Undulator_toGap.txt",
     )
 
 

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/beamlines/i19_2.py

@@ -11,6 +11,7 @@ from dodal.devices.i19.backlight import BacklightPosition
 from dodal.devices.i19.beamstop import BeamStop
 from dodal.devices.i19.blueapi_device import HutchState
 from dodal.devices.i19.diffractometer import FourCircleDiffractometer
+from dodal.devices.i19.pin_col_stages import PinholeCollimatorControl
 from dodal.devices.i19.shutter import AccessControlledShutter
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.zebra.zebra import Zebra
@@ -81,6 +82,15 @@ def synchrotron() -> Synchrotron:
     return Synchrotron()
 
 
+@device_factory()
+def pinhole_and_collimator() -> PinholeCollimatorControl:
+    """Get the i19-2 pinhole and collimator control device, instantiate it if it
+    hasn't already been. If this is called when already instantiated in i19-2,
+    it will return the existing object.
+    """
+    return PinholeCollimatorControl(prefix=PREFIX.beamline_prefix)
+
+
 @device_factory()
 def backlight() -> BacklightPosition:
     """Get the i19-2 backlight device, instantiate it if it hasn't already been.

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/devices/controllers.py

@@ -1,9 +1,6 @@
 from typing import TypeVar
 
-from ophyd_async.epics.adcore import (
-    ADBaseController,
-    ADBaseIO,
-)
+from ophyd_async.epics.adcore import ADBaseController, ADBaseIO, ADImageMode
 
 ADBaseIOT = TypeVar("ADBaseIOT", bound=ADBaseIO)
 
@@ -13,8 +10,13 @@ class ConstantDeadTimeController(ADBaseController[ADBaseIOT]):
     ADBaseController with a configured constant deadtime for a driver of type ADBaseIO.
     """
 
-    def __init__(self, driver: ADBaseIOT, deadtime: float):
-        super().__init__(driver)
+    def __init__(
+        self,
+        driver: ADBaseIOT,
+        deadtime: float,
+        image_mode: ADImageMode = ADImageMode.MULTIPLE,
+    ):
+        super().__init__(driver, image_mode=image_mode)
         self.deadtime = deadtime
 
     def get_deadtime(self, exposure: float | None) -> float:

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/devices/fast_grid_scan.py

@@ -1,9 +1,10 @@
+import asyncio
 from abc import ABC, abstractmethod
 from typing import Generic, TypeVar
 
 import numpy as np
-from bluesky.plan_stubs import mv
-from bluesky.protocols import Flyable
+from bluesky.plan_stubs import prepare
+from bluesky.protocols import Flyable, Preparable
 from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
@@ -13,6 +14,7 @@ from ophyd_async.core import (
     SignalRW,
     StandardReadable,
     derived_signal_r,
+    set_and_wait_for_value,
     soft_signal_r_and_setter,
     wait_for_value,
 )
@@ -29,6 +31,10 @@ from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
 
+class GridScanInvalidException(RuntimeError):
+    """Raised when the gridscan parameters are not valid."""
+
+
 @dataclass
 class GridAxis:
     start: float
@@ -144,7 +150,7 @@ class GridScanParamsThreeD(GridScanParamsCommon):
         return GridAxis(self.z2_start_mm, self.z_step_size_mm, self.z_steps)
 
 
-ParamType = TypeVar("ParamType", bound=GridScanParamsCommon, covariant=True)
+ParamType = TypeVar("ParamType", bound=GridScanParamsCommon)
 
 
 class WithDwellTime(BaseModel):
@@ -190,7 +196,9 @@ class MotionProgram(Device):
             self.program_number = soft_signal_r_and_setter(float, -1)[0]
 
 
-class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
+class FastGridScanCommon(
+    StandardReadable, Flyable, ABC, Preparable, Generic[ParamType]
+):
     """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,
@@ -231,8 +239,9 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.KICKOFF_TIMEOUT: float = 5.0
 
         self.COMPLETE_STATUS: float = 60.0
+        self.VALIDITY_CHECK_TIMEOUT = 0.5
 
-        self.movable_params: dict[str, Signal] = {
+        self._movable_params: dict[str, Signal] = {
             "x_steps": self.x_steps,
             "y_steps": self.y_steps,
             "x_step_size_mm": self.x_step_size,
@@ -284,6 +293,45 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self, motion_controller_prefix: str
     ) -> MotionProgram: ...
 
+    @AsyncStatus.wrap
+    async def prepare(self, value: ParamType):
+        """
+        Submit the gridscan parameters to the device for validation prior to
+        gridscan kickoff
+        Args:
+            value: the gridscan parameters
+
+        Raises:
+            GridScanInvalidException: if the gridscan parameters were not valid
+        """
+        set_statuses = []
+
+        LOGGER.info("Applying gridscan parameters...")
+        # Create arguments for bps.mv
+        for key, signal in self._movable_params.items():
+            param_value = value.__dict__[key]
+            set_statuses.append(await set_and_wait_for_value(signal, param_value))  # type: ignore
+
+        # Counter should always start at 0
+        set_statuses.append(await set_and_wait_for_value(self.position_counter, 0))
+
+        LOGGER.info("Gridscan parameters applied, waiting for sets to complete...")
+
+        # wait for parameter sets to complete
+        await asyncio.gather(*set_statuses)
+
+        LOGGER.info("Sets confirmed, waiting for validity checks to pass...")
+        try:
+            await wait_for_value(
+                self.scan_invalid, 0.0, timeout=self.VALIDITY_CHECK_TIMEOUT
+            )
+        except TimeoutError as e:
+            raise GridScanInvalidException(
+                f"Gridscan parameters not validated after {self.VALIDITY_CHECK_TIMEOUT}s"
+            ) from e
+
+        LOGGER.info("Gridscan validity confirmed, gridscan is now prepared.")
+
 
 class FastGridScanThreeD(FastGridScanCommon[ParamType]):
     """Device for standard 3D FGS.
@@ -309,10 +357,10 @@ class FastGridScanThreeD(FastGridScanCommon[ParamType]):
 
         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
+        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(
@@ -329,7 +377,35 @@ class FastGridScanThreeD(FastGridScanCommon[ParamType]):
         return first_grid + second_grid
 
     def _create_scan_invalid_signal(self, prefix: str) -> SignalR[float]:
-        return epics_signal_r(float, f"{prefix}SCAN_INVALID")
+        self.x_scan_valid = epics_signal_r(float, f"{prefix}X_SCAN_VALID")
+        self.y_scan_valid = epics_signal_r(float, f"{prefix}Y_SCAN_VALID")
+        self.z_scan_valid = epics_signal_r(float, f"{prefix}Z_SCAN_VALID")
+        self.device_scan_invalid = epics_signal_r(float, f"{prefix}SCAN_INVALID")
+
+        def compute_derived_value(
+            x_scan_valid: float,
+            y_scan_valid: float,
+            z_scan_valid: float,
+            device_scan_invalid: float,
+        ) -> float:
+            return (
+                1.0
+                if not (
+                    x_scan_valid
+                    and y_scan_valid
+                    and z_scan_valid
+                    and not device_scan_invalid
+                )
+                else 0.0
+            )
+
+        return derived_signal_r(
+            compute_derived_value,
+            x_scan_valid=self.x_scan_valid,
+            y_scan_valid=self.y_scan_valid,
+            z_scan_valid=self.z_scan_valid,
+            device_scan_invalid=self.device_scan_invalid,
+        )
 
     def _create_motion_program(self, motion_controller_prefix: str):
         return MotionProgram(motion_controller_prefix)
@@ -349,7 +425,7 @@ class ZebraFastGridScanThreeD(FastGridScanThreeD[ZebraGridScanParamsThreeD]):
         self.dwell_time_ms = epics_signal_rw_rbv(float, f"{full_prefix}DWELL_TIME")
         self.x_counter = epics_signal_r(int, f"{full_prefix}X_COUNTER")
         super().__init__(prefix, infix, name)
-        self.movable_params["dwell_time_ms"] = self.dwell_time_ms
+        self._movable_params["dwell_time_ms"] = self.dwell_time_ms
 
     def _create_position_counter(self, prefix: str):
         return epics_signal_rw(
@@ -380,20 +456,20 @@ class PandAFastGridScan(FastGridScanThreeD[PandAGridScanParams]):
         )
         super().__init__(prefix, infix, name)
 
-        self.movable_params["run_up_distance_mm"] = self.run_up_distance_mm
+        self._movable_params["run_up_distance_mm"] = self.run_up_distance_mm
 
     def _create_position_counter(self, prefix: str):
         return epics_signal_rw(int, f"{prefix}Y_COUNTER")
 
 
 def set_fast_grid_scan_params(scan: FastGridScanCommon[ParamType], params: ParamType):
-    to_move = []
-
-    # Create arguments for bps.mv
-    for key in scan.movable_params.keys():
-        to_move.extend([scan.movable_params[key], params.__dict__[key]])
-
-    # Counter should always start at 0
-    to_move.extend([scan.position_counter, 0])
+    """
+    Apply the fast grid scan parameters to the grid scan device and validate them
+    Args:
+        scan: The fast grid scan device
+        params: The parameters to set
 
-    yield from mv(*to_move)
+    Raises:
+        GridScanInvalidException: if the grid scan parameters are not valid
+    """
+    yield from prepare(scan, params, wait=True)

dls_dodal-1.62.0/src/dodal/devices/fast_shutter.py

@@ -0,0 +1,57 @@
+from typing import TypeVar
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    EnumTypes,
+    StandardReadable,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+StrictEnumT = TypeVar("StrictEnumT", bound=EnumTypes)
+
+
+class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
+    """
+    Basic enum device specialised for a fast shutter with configured open_state and
+    close_state so it is generic enough to be used with any device or plan without
+    knowing the specific enum to use.
+
+    For example:
+        await shutter.set(shutter.open_state)
+        await shutter.set(shutter.close_state)
+    OR
+        RE(bps.mv(shutter, shutter.open_state))
+        RE(bps.mv(shutter, shutter.close_state))
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        open_state: StrictEnumT,
+        close_state: StrictEnumT,
+        name: str = "",
+    ):
+        """
+        Arguments:
+            prefix: The prefix for the shutter device.
+            open_state: The enum value that corresponds with opening the shutter.
+            close_state: The enum value that corresponds with closing the shutter.
+        """
+        self.open_state = open_state
+        self.close_state = close_state
+        with self.add_children_as_readables():
+            self.state = epics_signal_rw(type(self.open_state), prefix)
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: StrictEnumT) -> None:
+        await self.state.set(value)
+
+    async def is_open(self) -> bool:
+        """Checks to see if shutter is currently open"""
+        return await self.state.get_value() == self.open_state
+
+    async def is_closed(self) -> bool:
+        """Checks to see if shutter is currently closed"""
+        return await self.state.get_value() == self.close_state

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/devices/i02_1/fast_grid_scan.py

@@ -35,7 +35,7 @@ class ZebraFastGridScanTwoD(FastGridScanCommon[ZebraGridScanParamsTwoD]):
         # 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
+        self._movable_params["dwell_time_ms"] = self.dwell_time_ms
 
     def _create_expected_images_signal(self):
         return derived_signal_r(

{dls_dodal-1.61.0 → dls_dodal-1.62.0}/src/dodal/devices/i15/dcm.py

@@ -28,19 +28,17 @@ Xtal_1 = TypeVar("Xtal_1", bound=StationaryCrystal)
 Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
 
 
-class DualCrystalMonoSimple(StandardReadable, Generic[Xtal_1, Xtal_2]):
+class BaseDCMforI15(StandardReadable, Generic[Xtal_1, Xtal_2]):
     """
-    Device for simple double crystal monochromators (DCM), which only allow energy of the beam to be selected.
+    Device for double crystal monochromators (DCM), which only allow energy of the beam to be selected.
 
     Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
     each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
-    This base device accounts for all combinations of this.
+    This device only accounts for combinations of energy plus two crystals.
 
-    This device is more able to act as a parent for beamline-specific DCM's, in which any other missing signals can be added,
-    as it doesn't assume WAVELENGTH, BRAGG and OFFSET are available for all DCM deivces, as BaseDCM does.
-
-    Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan
-    which only requires one crystal which can roll should be typed 'def my_plan(dcm: BaseDCM[RollCrystal, StationaryCrystal])`
+    This device is designed to be a drop in replacement for BaseDCM for i15, which doesn't require WAVELENGTH, BRAGG and OFFSET to
+    be available. Once the i15 DCM supports all of the PVs required by BaseDCM, the i15 DCM device can switch to inheriting from
+    BaseDCM and this class can be removed.
     """
 
     def __init__(
@@ -64,9 +62,12 @@ class DualCrystalMonoSimple(StandardReadable, Generic[Xtal_1, Xtal_2]):
             self.xtal_2 = xtal_2(prefix)
 
 
-class DCM(DualCrystalMonoSimple[ThetaRollYZCrystal, ThetaYCrystal]):
+class DCM(BaseDCMforI15[ThetaRollYZCrystal, ThetaYCrystal]):
     """
     A double crystal monocromator device, used to select the beam energy.
+
+    Once the i15 DCM supports all of the PVs required by BaseDCM, this class can be
+    changed to inherit from BaseDCM and BaseDCMforI15 can be removed.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:

dls_dodal-1.62.0/src/dodal/devices/i19/mapt_configuration.py

@@ -0,0 +1,38 @@
+from ophyd_async.core import DeviceVector, SignalR, StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
+
+
+class MAPTConfigurationTable(StandardReadable):
+    """Readable device that can be used to build the read-only MAPT (Mini Apertures)
+    configuration table in controls for aperture motors in the available positions.
+    For each aperture it sets up a readable signal with the position of all the motors
+    in the MAPT configuration.
+    This device can be used to build the table for both eh1 and eh2 on I19, in
+    combination with the MAPTConfigurationControl device.
+    """
+
+    def __init__(
+        self, prefix: str, motor_name: str, aperture_list: list[int], name: str = ""
+    ) -> None:
+        with self.add_children_as_readables():
+            self.in_positions: DeviceVector[SignalR[float]] = DeviceVector(
+                {
+                    pos: epics_signal_r(float, f"{prefix}:{pos}UM:{motor_name}")
+                    for pos in aperture_list
+                }
+            )
+        super().__init__(name)
+
+
+class MAPTConfigurationControl(StandardReadable):
+    """A device to control the MAPT (Mini Aperture) configuration. It provides a signal
+    to set the configuration PV to the requested value and a triggerable signal that
+    will move all the motors to the correct position."""
+
+    def __init__(
+        self, prefix: str, aperture_request: type[SubsetEnum], name: str = ""
+    ) -> None:
+        with self.add_children_as_readables():
+            self.select_config = epics_signal_rw(aperture_request, f"{prefix}")
+        self.apply_selection = epics_signal_x(f"{prefix}:APPLY.PROC")
+        super().__init__(name)

dls_dodal-1.62.0/src/dodal/devices/i19/pin_col_stages.py

@@ -0,0 +1,170 @@
+import asyncio
+from enum import StrEnum
+
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_r
+from pydantic import BaseModel
+
+from dodal.devices.i19.mapt_configuration import (
+    MAPTConfigurationControl,
+    MAPTConfigurationTable,
+)
+from dodal.devices.motors import XYStage
+from dodal.log import LOGGER
+
+_PIN = "-MO-PIN-01:"
+_COL = "-MO-COL-01:"
+_CONFIG = "-OP-PCOL-01:"
+
+
+class PinColRequest(StrEnum):
+    """Aperture request positions."""
+
+    PCOL20 = "20um"
+    PCOL40 = "40um"
+    PCOL100 = "100um"
+    PCOL3000 = "3000um"
+    OUT = "OUT"
+
+
+# NOTE. Using subset enum because from the OUT positions should only be used by
+# the beamline scientists from the synoptic. Another option will be needed in the
+# device for OUT position.
+class _PinColPosition(SubsetEnum):
+    """Aperture request IN positions."""
+
+    PCOL20 = "20um"
+    PCOL40 = "40um"
+    PCOL100 = "100um"
+    PCOL3000 = "3000um"
+
+
+class AperturePosition(BaseModel):
+    """Describe the positions of the pinhole and collimator stage motors for
+    one of the available apertures.
+
+    Attributes:
+        pinhole_x: The position of the x motor on the pinhole stage
+        pinhole_y: The position of the y motor on the pinhole stage
+        collimator_x: The position of the x motor on the collimator stage
+        collimator_y: The position of the y motor on the collimator stage
+    """
+
+    pinhole_x: float
+    pinhole_y: float
+    collimator_x: float
+    collimator_y: float
+
+
+class PinColConfiguration(StandardReadable):
+    """Full MAPT configuration table, including out positions and selection for the
+    Pinhole and Collimator control."""
+
+    def __init__(self, prefix: str, apertures: list[int], name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.configuration = MAPTConfigurationControl(prefix, _PinColPosition)
+            self.pin_x = MAPTConfigurationTable(prefix, "PINX", apertures)
+            self.pin_y = MAPTConfigurationTable(prefix, "PINY", apertures)
+            self.col_x = MAPTConfigurationTable(prefix, "COLX", apertures)
+            self.col_y = MAPTConfigurationTable(prefix, "COLY", apertures)
+            self.pin_x_out = epics_signal_r(float, f"{prefix}:OUT:PINX")
+            self.col_x_out = epics_signal_r(float, f"{prefix}:OUT:COLX")
+        super().__init__(name)
+
+
+class PinholeCollimatorControl(StandardReadable, Movable[str]):
+    """Device to control the Pinhole and Collimator stages moves on I19-2, using the
+    MAPT configuration table to look up the positions."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        pin_infix: str = _PIN,
+        col_infix: str = _COL,
+        config_infix: str = _CONFIG,
+    ):
+        self._aperture_sizes = [self._get_aperture_size(i) for i in _PinColPosition]
+        with self.add_children_as_readables():
+            self._pinhole = XYStage(f"{prefix}{pin_infix}")
+            self._collimator = XYStage(f"{prefix}{col_infix}")
+            self.mapt = PinColConfiguration(
+                f"{prefix}{config_infix}CONFIG", apertures=self._aperture_sizes
+            )
+        super().__init__(name=name)
+
+    def _get_aperture_size(self, ap_request: str) -> int:
+        return int(ap_request.strip("um"))
+
+    async def _get_motor_positions_for_requested_aperture(
+        self, ap_request: _PinColPosition
+    ) -> AperturePosition:
+        val = self._get_aperture_size(ap_request.value)
+
+        pinx = await self.mapt.pin_x.in_positions[val].get_value()
+        piny = await self.mapt.pin_y.in_positions[val].get_value()
+        colx = await self.mapt.col_x.in_positions[val].get_value()
+        coly = await self.mapt.col_y.in_positions[val].get_value()
+
+        return AperturePosition(
+            pinhole_x=pinx, pinhole_y=piny, collimator_x=colx, collimator_y=coly
+        )
+
+    async def _safe_move_out(self):
+        """Move the pinhole and collimator stages safely to the out position, which
+        involves only the x motors of the stages.
+        In order to avoid a collision, we have to make sure that the collimator stage is
+        always moved out first and the pinhole stage second.
+        """
+        LOGGER.info("Moving pinhole and collimator stages to out position")
+        colx_out = await self.mapt.col_x_out.get_value()
+        pin_x_out = await self.mapt.pin_x_out.get_value()
+        # First move Collimator x motor
+        LOGGER.debug(f"Move collimator stage x motor to {colx_out}")
+        await self._collimator.x.set(colx_out)
+        # Then move Pinhole x motor
+        LOGGER.debug(f"Move pinhole stage x motor to {pin_x_out}")
+        await self._pinhole.x.set(pin_x_out)
+
+    async def _safe_move_in(self, value: _PinColPosition):
+        """Move the pinhole and collimator stages safely to the in position.
+        In order to avoid a collision, we have to make sure that the pinhole stage is
+        always moved in before the collimator stage."""
+        LOGGER.info(
+            f"Moving pinhole and collimator stages to in position: {value.value}"
+        )
+        await self.mapt.configuration.select_config.set(value, wait=True)
+        # NOTE. The apply PV will not be used here unless fixed in controls first.
+        # This is to avoid collisions. A safe move in will move first the pinhole stage
+        # and then the collimator stage, but apply will try to move all the motors
+        # at the same time.
+        aperture_positions = await self._get_motor_positions_for_requested_aperture(
+            value
+        )
+        LOGGER.debug(f"Moving motors to {aperture_positions}")
+
+        # First move Pinhole motors,
+        LOGGER.debug("Moving pinhole stage in")
+        await asyncio.gather(
+            self._pinhole.x.set(aperture_positions.pinhole_x),
+            self._pinhole.y.set(aperture_positions.pinhole_y),
+        )
+        # Then move Collimator motors
+        LOGGER.debug("Moving collimator stage in")
+        await asyncio.gather(
+            self._collimator.x.set(aperture_positions.collimator_x),
+            self._collimator.y.set(aperture_positions.collimator_y),
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, value: PinColRequest):
+        """Moves the motor stages to the position for the requested aperture while
+        avoiding possible collisions.
+        The request coming from a plan should always be one of accepted request values:
+        ('20um', '40um', '100um', '3000um', 'OUT').
+        """
+        if value is PinColRequest.OUT:
+            await self._safe_move_out()
+        else:
+            await self._safe_move_in(_PinColPosition(value))