dls-dodal 1.61.0__py3-none-any.whl → 1.62.0__py3-none-any.whl

{dls_dodal-1.61.0.dist-info → dls_dodal-1.62.0.dist-info}/METADATA

@@ -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.dist-info → dls_dodal-1.62.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-dls_dodal-1.61.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+dls_dodal-1.62.0.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
 dodal/__init__.py,sha256=Ksms_WJF8LTkbm38gEpm1jBpGqcQ8NGvmb2ZJlOE1j8,198
 dodal/__main__.py,sha256=kP2S2RPitnOWpNGokjZ1Yq-1umOtp5sNOZk2B3tBPLM,111
-dodal/_version.py,sha256=R0nxjIENITg3eHoaeIFi4EMDLFAHK-E5jkMwqc20ybI,706
+dodal/_version.py,sha256=5VUVRHNcXnR6NHNHVw0jy5canKWEf1jsJRKy9oQveHA,706
 dodal/cli.py,sha256=yi8dXOp0hqzlg4ZZXCRGU-LpDa_ydaropDjyREWbZ5Y,4152
 dodal/log.py,sha256=Rt5O3hFZfMnJvQueZvgagQuXnPqHrFxhponOvVkpfrk,9871
 dodal/utils.py,sha256=abGitd4FLpLnmckF7lUqOKYUL88r5Ex_NGSVgO4gOf4,19305
@@ -20,7 +20,7 @@ dodal/beamlines/b18.py,sha256=ryxrGtcCdwoFgZ8ljWYgr1g9gKvoA7nxkARVxl1IE78,1189
 dodal/beamlines/b21.py,sha256=QGn0b88Od5-PCbleKwR6CSOleAY0vriybxcWlc58NS0,3851
 dodal/beamlines/i02_1.py,sha256=SwRm9v1U6CiT0fwLbSTECbJ6OF1BPEx4TJ0cEReuGZA,4017
 dodal/beamlines/i03.py,sha256=S2mJikFdZiV0e3VLNwHp38OCk_rL9wnWD009a7tH5kE,16203
-dodal/beamlines/i04.py,sha256=b42_K8Fe2GonF7SUMwac8oEWnJyLOuhYQ12wdys_oQQ,13757
+dodal/beamlines/i04.py,sha256=QyprATHFxnw_cP2gak1i2_ywj-i26vrGlvOYM6RmyTY,13758
 dodal/beamlines/i05.py,sha256=v4QKd8-neh4Og205oovm6NDRnAU6Oktu1WrxalXsI40,656
 dodal/beamlines/i05_1.py,sha256=R6JFFg8Bj-Izw355mx3mOd4IDvJb5ipB4p7_S0I_4Z0,670
 dodal/beamlines/i09.py,sha256=E7PgMfJAixwvxd5bKzqX8ifVNExbzVMUYFN22TTTAFU,1594
@@ -35,7 +35,7 @@ dodal/beamlines/i15_1.py,sha256=TomeTLsYSvL5en8GPvI8driQa5nMObrB5DrMKckHig8,3898
 dodal/beamlines/i17.py,sha256=Nickt8CKQ9JcQ1D_ulNICUT4jjLF1Aib7D9jblSnzA4,987
 dodal/beamlines/i18.py,sha256=FuU8G-q1piu6BRou-Shj3BQEbNtsF7CUsSIqqkvCKZc,3615
 dodal/beamlines/i19_1.py,sha256=xAI9B3fyUKtoO-tnAF7wWQelrXQ6QrYNgEyncHqVzn4,3057
-dodal/beamlines/i19_2.py,sha256=x-k6Dy2_Jy_9Z4Jh5ytcQWsOQlk4MRAsLOX55Fjz4t0,3171
+dodal/beamlines/i19_2.py,sha256=gY4YBYW_uble5rr74fxoW7490UXJdsFVDWALT_Zdp3Y,3594
 dodal/beamlines/i19_optics.py,sha256=8hdlDAAMgFrhcXrp5xCPZtLUlrDUEC9VwKnnuUAMbbU,1150
 dodal/beamlines/i20_1.py,sha256=Zsr1lsH7ySbOgK7RhMVMWzNWZAV-fuYW0iAjSEJZicY,2625
 dodal/beamlines/i21.py,sha256=5v6iiTlY4kWlWvQ_uNidJSotvkdNF3qdjR49l7sIYPc,728
@@ -74,13 +74,14 @@ dodal/devices/baton.py,sha256=315I_0V73_DYYVT0PBs0luVy4CMqdPo0kLvHBi12MIU,606
 dodal/devices/bimorph_mirror.py,sha256=OGe6aCczG0gVco4OvIRLJVxn2kw5F2QG1e06uqhFLTw,4609
 dodal/devices/collimation_table.py,sha256=64HunSPJH-L2gZdfIj_RYdOlOuwRFEfMHfLHzu4BAKI,1681
 dodal/devices/common_dcm.py,sha256=8QSRE6Z10RQjfL3g4JZhyHRNI_aCKxWlzKSsDgiJHhE,3049
-dodal/devices/controllers.py,sha256=un-12-ts65rKJ4Az6gwnIWIUGvAH6KxAQhZ2u2iJ1O4,542
+dodal/devices/controllers.py,sha256=W_Ras1c6xLjcOMKPSHN8Z1eCUCH-ktaah2hzQXyuFLk,652
 dodal/devices/cryostream.py,sha256=2FxCGioEZNMHItsGm_rsnkRnHjwMUIwRMAX_x8odKIw,4678
 dodal/devices/diamond_filter.py,sha256=hySd7HnLdplpPNvBrLddLjO_3LqgD8-99Zr__Sy_GbI,689
 dodal/devices/eiger.py,sha256=ZKaRXF-YnYWuMW94BIg-gmdKW7JKmtMUvehF3S5XaLY,16670
 dodal/devices/eiger_odin.py,sha256=1JoqPppTp99IZCiFOXJZB3h62xXRYKZINxTYXdLnT8c,7480
 dodal/devices/eurotherm.py,sha256=rdLldmWYP1PZBckoya6svPy1mDxHYaa1IfMleMPGzD4,3832
-dodal/devices/fast_grid_scan.py,sha256=4HHOVAPwhUf4u1nC_kNhCAUzCqYuEsJ15lqcnxfdrVg,14659
+dodal/devices/fast_grid_scan.py,sha256=2k2Ub-ywwfwCfmlofjnhkumXk07bidDfF86DPN7hcrA,17365
+dodal/devices/fast_shutter.py,sha256=kgYafhBURRTN6edrhv0xKggxkSEWGXg2rhWz_ewLZhc,1837
 dodal/devices/fluorescence_detector_motion.py,sha256=hJ1M9Zs6Dlw8DDL9APh7yVePlS4tU2hnlySd16hqfwE,346
 dodal/devices/flux.py,sha256=1CDsq9yU2-ho8MfYBl50Tl9ABZwpUBHnV486PQXKNoQ,462
 dodal/devices/focusing_mirror.py,sha256=2UWVrY6bs6_0i-h6JJ_LAUZPX_FgMzIx04JqZafdtYU,7464
@@ -160,7 +161,7 @@ dodal/devices/electron_analyser/vgscienta/driver_io.py,sha256=c1v3AOSGKp6DlVmE82
 dodal/devices/electron_analyser/vgscienta/enums.py,sha256=3vmX67ExATU8clueVp_mCzw3OUQx799oZMc8gyHtMJE,205
 dodal/devices/electron_analyser/vgscienta/region.py,sha256=6k6Eah6_I74Pi2_a0KfyMYFfwHwJbh1ndqy0fuq5o14,2184
 dodal/devices/i02_1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dodal/devices/i02_1/fast_grid_scan.py,sha256=eyWE-urpxY10_KZK4Vg48Rau0rTK3O2Ul4IcK6P2Geg,2428
+dodal/devices/i02_1/fast_grid_scan.py,sha256=bfiumNayrISFGYqdcd3Bh6lEZvkOxrqyX_B24LYW1nU,2429
 dodal/devices/i02_1/sample_motors.py,sha256=fAHAyeuP4hjOnYsp2x5VQNrTh8Di35ezJV1si2YmKPY,607
 dodal/devices/i03/__init__.py,sha256=Kvukapy4a5lUQ20qaCqYCJzKNaqJn2DfXP5nKZ_Pec8,118
 dodal/devices/i03/dcm.py,sha256=zDcgxOdMRVOQZBGDsLaIlr7o4UJIK2vehPWHxAxt6VA,2268
@@ -196,7 +197,7 @@ dodal/devices/i13_1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 dodal/devices/i13_1/merlin.py,sha256=mgTFSMJftRzLL-HXAUuJkOYxtyA3Rp8YX0L46JCb30Y,1019
 dodal/devices/i13_1/merlin_controller.py,sha256=myfmByOEXyMrlJZfsjOxDHeGQVwZGfsRtzrfSy2001o,1495
 dodal/devices/i15/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dodal/devices/i15/dcm.py,sha256=QLqnKhNbkcVuCFEy9yB-2Ga4fAR0EOGZQshfSoVN8-w,3113
+dodal/devices/i15/dcm.py,sha256=MQK2oHQOPB1pUyc4uWwIvzb3WWP8PuzaPe5O4Zqt0TM,3089
 dodal/devices/i15/focussing_mirror.py,sha256=E6T_c7M2osgHLa7u8eUfQJlXlJbZHtOp95FhP3qZ4gY,1739
 dodal/devices/i15/jack.py,sha256=VafCNx-uqkIy0LxbBAhSm_tuC8_SbGCrnTbvQCExAzA,962
 dodal/devices/i15/laue.py,sha256=H0nLPH8gqJejBZtZeY0lv84EaE2lqdL3CmXvT9iHhpk,496
@@ -212,6 +213,8 @@ dodal/devices/i19/beamstop.py,sha256=JkcvkEmcC3eY3GHrvYNGqv2yDwrfgdpWKVZJWSadWW8
 dodal/devices/i19/blueapi_device.py,sha256=Tsl4vsREz7FM2d-kKJK-9tGrYbyKq4SLxnMlEKIM-g8,3966
 dodal/devices/i19/diffractometer.py,sha256=QCEi0Gko6Ja9_ec2vfdazwMspknvX63jcz8hQ2XW1xo,1182
 dodal/devices/i19/hutch_access.py,sha256=hnClUWCL1qTYzuBMmhXX85jiNak7mbYfyHEh54tZ27U,377
+dodal/devices/i19/mapt_configuration.py,sha256=0zUzCSDofQORdaqbgD5NU-Vuf-EljgTKfvFDRDA9IjQ,1717
+dodal/devices/i19/pin_col_stages.py,sha256=SAdokjoTmlRcCQQSVTz4jCkBibSsKCye7s5aYtfhsfg,6691
 dodal/devices/i19/shutter.py,sha256=B4KP0Ruc8Ex47OfCskbjYSSu81jz4tK9GC_7pxMIkgI,2140
 dodal/devices/i20_1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dodal/devices/i21/__init__.py,sha256=1H0Ov9s8K7nu6e20WtQDH39wgSKWz2ChRVAUzytIyzQ,67
@@ -280,7 +283,7 @@ dodal/plan_stubs/motor_utils.py,sha256=Mf8utOA_xmxUa2dLmQ1uRkdfyDTip7D8YcKeCBCQL
 dodal/plan_stubs/wrapped.py,sha256=kC8HH7bx3-sLYu2oieY_502tAdT2OECF8n-fqoL5Bfc,4266
 dodal/plans/__init__.py,sha256=nH1jNxw3DzDMg9O8Uda0kqKIalRVEWBrq07OLY6Ey38,93
 dodal/plans/bimorph.py,sha256=JxDmZDiEvZnz5f22tlaoyivpnaNGiX8kSL82qz5uvMM,11738
-dodal/plans/configure_arm_trigger_and_disarm_detector.py,sha256=Ndg6Tuqvu4WesTxtDlzzgeJh0BP7aWJ-TbYlforDkjM,5454
+dodal/plans/configure_arm_trigger_and_disarm_detector.py,sha256=VLsNhHx8NPFLhNeUd_EjlbOPqe18C-SEZEWGGmXtf_Y,6170
 dodal/plans/save_panda.py,sha256=1fumH7Ih8uDIv8ahAtgQ_vUuR3dz0sfUs4n9TEtEbSs,3053
 dodal/plans/scanspec.py,sha256=Q0AcvTKRT401iGMRDSqK-D523UX5_ofiVMZ_rNXKOx8,2074
 dodal/plans/verify_undulator_gap.py,sha256=OcDN09-eCoMzsmhKGxvzsH5EapG2zYz0yGCqUtQxLSc,568
@@ -291,8 +294,8 @@ dodal/testing/__init__.py,sha256=AUYZKAvVOs7ZvxO1dVhL0pDTleRO34FQlO5MNe_cwgU,96
 dodal/testing/setup.py,sha256=8cQnrzE5MQD4Etf0eqMarmtr-opsUOMQww-k1V7DzIQ,2442
 dodal/testing/electron_analyser/__init__.py,sha256=-lc1opD2dCv0x678-J-ApOhHtvEvcslfOQ7E613U8-Y,118
 dodal/testing/electron_analyser/device_factory.py,sha256=tkMY6fW3iI02DTD1XXHi4lH6sjo8RHHZBGDHSuTdmNU,2243
-dls_dodal-1.61.0.dist-info/METADATA,sha256=CzbkDC58MYPwQdjxT6ArCdVqQWB9qWGQSHRUC8iWB7A,16941
-dls_dodal-1.61.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dls_dodal-1.61.0.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
-dls_dodal-1.61.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
-dls_dodal-1.61.0.dist-info/RECORD,,
+dls_dodal-1.62.0.dist-info/METADATA,sha256=oUaFqOHwl4hc_7ifCVwr1lskpYdxni_oGRG1eihyPog,16941
+dls_dodal-1.62.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dls_dodal-1.62.0.dist-info/entry_points.txt,sha256=bycw_EKUzup_rxfCetOwcauXV4kLln_OPpPT8jEnr-I,94
+dls_dodal-1.62.0.dist-info/top_level.txt,sha256=xIozdmZk_wmMV4wugpq9-6eZs0vgADNUKz3j2UAwlhc,6
+dls_dodal-1.62.0.dist-info/RECORD,,

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 = None

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

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.

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:

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)

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

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(

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:

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)

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

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -1,12 +1,18 @@
 import time
+from pathlib import PurePath
 
 import bluesky.plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import DetectorTrigger, TriggerInfo
+from ophyd_async.core import (
+    DetectorTrigger,
+    StaticFilenameProvider,
+    StaticPathProvider,
+    TriggerInfo,
+)
 from ophyd_async.fastcs.eiger import EigerDetector
 
-from dodal.beamlines.i03 import fastcs_eiger
+from dodal.beamlines.i03 import fastcs_eiger, set_path_provider
 from dodal.devices.detector import DetectorParams
 from dodal.log import LOGGER, do_default_logging_setup
 
@@ -28,9 +34,17 @@ def configure_arm_trigger_and_disarm_detector(
     yield from change_roi_mode(eiger, detector_params, wait=True)
     LOGGER.info(f"Changing ROI Mode: {time.time() - start}s")
     start = time.time()
-    yield from bps.abs_set(eiger.odin.num_frames_chunks, 1)
+    yield from bps.abs_set(eiger.odin.num_frames_chunks, 1, wait=True)
     LOGGER.info(f"Setting # of Frame Chunks: {time.time() - start}s")
     start = time.time()
+    yield from bps.abs_set(
+        eiger.drv.detector.photon_energy, detector_params.expected_energy_ev, wait=True
+    )
+    LOGGER.info(f"Setting Photon Energy: {time.time() - start}s")
+    start = time.time()
+    yield from bps.abs_set(eiger.drv.detector.ntrigger, 1, wait=True)
+    LOGGER.info(f"Setting Number of Triggers: {time.time() - start}s")
+    start = time.time()
     yield from set_mx_settings_pvs(eiger, detector_params, wait=True)
     LOGGER.info(f"Setting MX PVs: {time.time() - start}s")
     start = time.time()
@@ -40,7 +54,7 @@ def configure_arm_trigger_and_disarm_detector(
     yield from bps.kickoff(eiger, wait=True)
     LOGGER.info(f"Kickoff Eiger: {time.time() - start}s")
     start = time.time()
-    yield from bps.trigger(eiger.drv.detector.trigger)  # type: ignore
+    yield from bps.trigger(eiger.drv.detector.trigger, wait=True)
     LOGGER.info(f"Triggering Eiger: {time.time() - start}s")
     start = time.time()
     yield from bps.complete(eiger, wait=True)
@@ -82,7 +96,7 @@ def change_roi_mode(
 
     yield from bps.abs_set(
         eiger.drv.detector.roi_mode,
-        1 if detector_params.use_roi_mode else 0,
+        "4M" if detector_params.use_roi_mode else "disabled",
         group=group,
     )
     yield from bps.abs_set(
@@ -143,6 +157,14 @@ def set_mx_settings_pvs(
 if __name__ == "__main__":
     RE = RunEngine()
     do_default_logging_setup()
+
+    path_provider = StaticPathProvider(
+        StaticFilenameProvider("eiger_test_file12.h5"),
+        PurePath("/dls/i03/data/2025/cm40607-2/test_new_eiger/"),
+    )
+
+    set_path_provider(path_provider)
+
     eiger = fastcs_eiger(connect_immediately=True)
     RE(
         configure_arm_trigger_and_disarm_detector(