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

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/i15/focussing_mirror.py

@@ -5,11 +5,7 @@ from ophyd_async.epics.motor import Motor
 class FocusingMirrorBase(StandardReadable):
     """Focusing Mirror with curve, ellip & pitch"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.curve = Motor(prefix + "CURVE")
             self.ellipticity = Motor(prefix + "ELLIP")
@@ -21,11 +17,7 @@ class FocusingMirrorBase(StandardReadable):
 class FocusingMirrorHorizontal(FocusingMirrorBase):
     """Focusing Mirror with curve, ellip, pitch & X"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.x = Motor(prefix + "X")
 
@@ -35,11 +27,7 @@ class FocusingMirrorHorizontal(FocusingMirrorBase):
 class FocusingMirrorVertical(FocusingMirrorBase):
     """Focusing Mirror with curve, ellip, pitch & Y"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.y = Motor(prefix + "Y")
 
@@ -49,11 +37,7 @@ class FocusingMirrorVertical(FocusingMirrorBase):
 class FocusingMirror(FocusingMirrorBase):
     """Focusing Mirror with curve, ellip, pitch, yaw, X & Y"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.yaw = Motor(prefix + "YAW")
             self.x = Motor(prefix + "X")

dodal/devices/i15/jack.py

@@ -5,11 +5,7 @@ from ophyd_async.epics.motor import Motor
 class JackX(StandardReadable):
     """Focusing Mirror"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.rotation = Motor(prefix + "Ry")
             self.transx = Motor(prefix + "X")
@@ -23,11 +19,7 @@ class JackX(StandardReadable):
 class JackY(StandardReadable):
     """Focusing Mirror"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.j1 = Motor(prefix + "J1")
             self.j2 = Motor(prefix + "J2")

dodal/devices/i15/laue.py

@@ -3,11 +3,7 @@ from ophyd_async.epics.motor import Motor
 
 
 class LaueMonochrometer(StandardReadable):
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.bend = Motor(prefix + "BENDER")
             self.bragg = Motor(prefix + "PITCH")

dodal/devices/i15/multilayer_mirror.py

@@ -5,11 +5,7 @@ from ophyd_async.epics.motor import Motor
 class MultiLayerMirror(StandardReadable):
     """Multilayer Mirror"""
 
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.ds_x = Motor(prefix + "X2")
             self.ds_y = Motor(prefix + "J3")

dodal/devices/i15/rail.py

@@ -3,11 +3,7 @@ from ophyd_async.epics.motor import Motor
 
 
 class Rail(StandardReadable):
-    def __init__(
-        self,
-        prefix: str,
-        name: str = "",
-    ):
+    def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
             self.pitch = Motor(prefix + "PITCH")
             self.y = Motor(prefix + "Y")

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/devices/i24/commissioning_jungfrau.py

@@ -5,11 +5,13 @@ from pathlib import Path
 from bluesky.protocols import StreamAsset
 from event_model import DataKey  # type: ignore
 from ophyd_async.core import (
+    AsyncStatus,
     AutoIncrementingPathProvider,
     DetectorWriter,
     StandardDetector,
     StandardReadable,
     StaticPathProvider,
+    TriggerInfo,
     observe_value,
     wait_for_value,
 )
@@ -40,6 +42,7 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
             self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
             self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
             self.writer_ready = epics_signal_r(int, f"{prefix}Ready_RBV")
+            self.expected_frames = epics_signal_rw(int, f"{prefix}NumCapture")
         super().__init__(name)
 
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
@@ -80,7 +83,7 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
     async def observe_indices_written(
         self, timeout: float
     ) -> AsyncGenerator[int, None]:
-        timeout = timeout * 2  # This filewriter is slow
+        timeout = timeout * 4  # This filewriter is very slow
         async for num_captured in observe_value(self.frame_counter, timeout):
             yield num_captured // (self._exposures_per_event)
 
@@ -112,3 +115,8 @@ class CommissioningJungfrau(
         writer = JunfrauCommissioningWriter(writer_prefix, path_provider)
         controller = JungfrauController(self.drv)
         super().__init__(controller, writer, name=name)
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: TriggerInfo) -> None:
+        await super().prepare(value)
+        await self._writer.expected_frames.set(value.total_number_of_exposures)

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(