dls-dodal 1.35.0__py3-none-any.whl → 1.36.1a0__py3-none-any.whl

dodal/devices/eiger.py

@@ -1,4 +1,5 @@
 # type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
+from dataclasses import dataclass
 from enum import Enum
 
 from ophyd import Component, Device, EpicsSignalRO, Signal
@@ -14,6 +15,15 @@ from dodal.log import LOGGER
 FREE_RUN_MAX_IMAGES = 1000000
 
 
+@dataclass
+class EigerTimeouts:
+    stale_params_timeout: int = 60
+    general_status_timeout: int = 10
+    meta_file_ready_timeout: int = 30
+    all_frames_timeout: int = 120
+    arming_timeout: int = 60
+
+
 class InternalEigerTriggerMode(Enum):
     INTERNAL_SERIES = 0
     INTERNAL_ENABLE = 1
@@ -21,6 +31,17 @@ class InternalEigerTriggerMode(Enum):
     EXTERNAL_ENABLE = 3
 
 
+AVAILABLE_TIMEOUTS = {
+    "i03": EigerTimeouts(
+        stale_params_timeout=60,
+        general_status_timeout=10,
+        meta_file_ready_timeout=30,
+        all_frames_timeout=120,  # Long timeout for meta file to compensate for filesystem issues
+        arming_timeout=60,
+    )
+}
+
+
 class EigerDetector(Device):
     class ArmingSignal(Signal):
         def set(self, value, *, timeout=None, settle_time=None, **kwargs):
@@ -34,13 +55,6 @@ class EigerDetector(Device):
     stale_params = Component(EpicsSignalRO, "CAM:StaleParameters_RBV")
     bit_depth = Component(EpicsSignalRO, "CAM:BitDepthImage_RBV")
 
-    STALE_PARAMS_TIMEOUT = 60
-    GENERAL_STATUS_TIMEOUT = 10
-    # Long timeout for meta file to compensate for filesystem issues
-    META_FILE_READY_TIMEOUT = 30
-    ALL_FRAMES_TIMEOUT = 120
-    ARMING_TIMEOUT = 60
-
     filewriters_finished: StatusBase
 
     detector_params: DetectorParams | None = None
@@ -48,13 +62,20 @@ class EigerDetector(Device):
     arming_status = Status()
     arming_status.set_finished()
 
+    def __init__(self, beamline: str = "i03", *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.beamline = beamline
+        # using i03 timeouts as default
+        self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
+
     @classmethod
     def with_params(
         cls,
         params: DetectorParams,
         name: str = "EigerDetector",
+        beamline: str = "i03",
     ):
-        det = cls(name=name)
+        det = cls(name=name, beamline=beamline)
         det.set_detector_parameters(params)
         return det
 
@@ -82,7 +103,7 @@ class EigerDetector(Device):
     def async_stage(self):
         self.odin.nodes.clear_odin_errors()
         status_ok, error_message = self.odin.wait_for_odin_initialised(
-            self.GENERAL_STATUS_TIMEOUT
+            self.timeouts.general_status_timeout
         )
         if not status_ok:
             raise Exception(f"Odin not initialised: {error_message}")
@@ -96,14 +117,14 @@ class EigerDetector(Device):
     def wait_on_arming_if_started(self):
         if not self.arming_status.done:
             LOGGER.info("Waiting for arming to finish")
-            self.arming_status.wait(self.ARMING_TIMEOUT)
+            self.arming_status.wait(self.timeouts.arming_timeout)
 
     def stage(self):
         self.wait_on_arming_if_started()
         if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
 
-            self.async_stage().wait(timeout=self.ARMING_TIMEOUT)
+            self.async_stage().wait(timeout=self.timeouts.arming_timeout)
 
     def stop_odin_when_all_frames_collected(self):
         LOGGER.info("Waiting on all frames")
@@ -111,7 +132,7 @@ class EigerDetector(Device):
             await_value(
                 self.odin.file_writer.num_captured,
                 self.detector_params.full_number_of_images,
-            ).wait(self.ALL_FRAMES_TIMEOUT)
+            ).wait(self.timeouts.all_frames_timeout)
         finally:
             LOGGER.info("Stopping Odin")
             self.odin.stop().wait(5)
@@ -124,7 +145,9 @@ class EigerDetector(Device):
                 # In free run mode we have to manually stop odin
                 self.stop_odin_when_all_frames_collected()
 
-            self.odin.file_writer.start_timeout.set(1).wait(self.GENERAL_STATUS_TIMEOUT)
+            self.odin.file_writer.start_timeout.set(1).wait(
+                self.timeouts.general_status_timeout
+            )
             LOGGER.info("Waiting on filewriter to finish")
             self.filewriters_finished.wait(30)
 
@@ -132,7 +155,7 @@ class EigerDetector(Device):
         finally:
             self.disarm_detector()
             status_ok = self.odin.check_and_wait_for_odin_state(
-                self.GENERAL_STATUS_TIMEOUT
+                self.timeouts.general_status_timeout
             )
             self.disable_roi_mode()
         return status_ok
@@ -142,10 +165,12 @@ class EigerDetector(Device):
         LOGGER.info("Eiger stop() called - cleaning up...")
         self.wait_on_arming_if_started()
         stop_status = self.odin.stop()
-        self.odin.file_writer.start_timeout.set(1).wait(self.GENERAL_STATUS_TIMEOUT)
+        self.odin.file_writer.start_timeout.set(1).wait(
+            self.timeouts.general_status_timeout
+        )
         self.disarm_detector()
         stop_status &= self.disable_roi_mode()
-        stop_status.wait(self.GENERAL_STATUS_TIMEOUT)
+        stop_status.wait(self.timeouts.general_status_timeout)
         # See https://github.com/DiamondLightSource/hyperion/issues/1395
         LOGGER.info("Turning off Eiger dev/shm streaming")
         self.odin.fan.dev_shm_enable.set(0).wait()
@@ -166,19 +191,19 @@ class EigerDetector(Device):
         )
 
         status = self.cam.roi_mode.set(
-            1 if enable else 0, timeout=self.GENERAL_STATUS_TIMEOUT
+            1 if enable else 0, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.image_height.set(
-            detector_dimensions.height, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.height, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.image_width.set(
-            detector_dimensions.width, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.num_row_chunks.set(
-            detector_dimensions.height, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.height, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.num_col_chunks.set(
-            detector_dimensions.width, timeout=self.GENERAL_STATUS_TIMEOUT
+            detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
 
         return status
@@ -186,25 +211,29 @@ class EigerDetector(Device):
     def set_cam_pvs(self) -> AndStatus:
         assert self.detector_params is not None
         status = self.cam.acquire_time.set(
-            self.detector_params.exposure_time, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.exposure_time,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.acquire_period.set(
-            self.detector_params.exposure_time, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.exposure_time,
+            timeout=self.timeouts.general_status_timeout,
+        )
+        status &= self.cam.num_exposures.set(
+            1, timeout=self.timeouts.general_status_timeout
         )
-        status &= self.cam.num_exposures.set(1, timeout=self.GENERAL_STATUS_TIMEOUT)
         status &= self.cam.image_mode.set(
-            self.cam.ImageMode.MULTIPLE, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.cam.ImageMode.MULTIPLE, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.trigger_mode.set(
             InternalEigerTriggerMode.EXTERNAL_SERIES.value,
-            timeout=self.GENERAL_STATUS_TIMEOUT,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
     def set_odin_number_of_frame_chunks(self) -> Status:
         assert self.detector_params is not None
         status = self.odin.file_writer.num_frames_chunks.set(
-            1, timeout=self.GENERAL_STATUS_TIMEOUT
+            1, timeout=self.timeouts.general_status_timeout
         )
         return status
 
@@ -212,16 +241,20 @@ class EigerDetector(Device):
         assert self.detector_params is not None
         file_prefix = self.detector_params.full_filename
         status = self.odin.file_writer.file_path.set(
-            self.detector_params.directory, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.directory, timeout=self.timeouts.general_status_timeout
         )
         status &= self.odin.file_writer.file_name.set(
-            file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            file_prefix, timeout=self.timeouts.general_status_timeout
         )
         status &= await_value(
-            self.odin.meta.file_name, file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.meta.file_name,
+            file_prefix,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= await_value(
-            self.odin.file_writer.id, file_prefix, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.odin.file_writer.id,
+            file_prefix,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
@@ -231,19 +264,22 @@ class EigerDetector(Device):
             self.detector_params.detector_distance
         )
         status = self.cam.beam_center_x.set(
-            beam_x_pixels, timeout=self.GENERAL_STATUS_TIMEOUT
+            beam_x_pixels, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.beam_center_y.set(
-            beam_y_pixels, timeout=self.GENERAL_STATUS_TIMEOUT
+            beam_y_pixels, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.det_distance.set(
-            self.detector_params.detector_distance, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.detector_distance,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.omega_start.set(
-            self.detector_params.omega_start, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.omega_start,
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.omega_incr.set(
-            self.detector_params.omega_increment, timeout=self.GENERAL_STATUS_TIMEOUT
+            self.detector_params.omega_increment,
+            timeout=self.timeouts.general_status_timeout,
         )
         return status
 
@@ -259,7 +295,7 @@ class EigerDetector(Device):
         current_energy = self.cam.photon_energy.get()
         if abs(current_energy - energy) > tolerance:
             return self.cam.photon_energy.set(
-                energy, timeout=self.GENERAL_STATUS_TIMEOUT
+                energy, timeout=self.timeouts.general_status_timeout
             )
         else:
             status = Status()
@@ -275,45 +311,46 @@ class EigerDetector(Device):
         assert self.detector_params is not None
         status = self.cam.num_images.set(
             self.detector_params.num_images_per_trigger,
-            timeout=self.GENERAL_STATUS_TIMEOUT,
+            timeout=self.timeouts.general_status_timeout,
         )
         if self.detector_params.trigger_mode == TriggerMode.FREE_RUN:
             # The Eiger can't actually free run so we set a very large number of frames
             status &= self.cam.num_triggers.set(
-                FREE_RUN_MAX_IMAGES, timeout=self.GENERAL_STATUS_TIMEOUT
+                FREE_RUN_MAX_IMAGES, timeout=self.timeouts.general_status_timeout
             )
             # Setting Odin to write 0 frames tells it to write until externally stopped
             status &= self.odin.file_writer.num_capture.set(
-                0, timeout=self.GENERAL_STATUS_TIMEOUT
+                0, timeout=self.timeouts.general_status_timeout
             )
         elif self.detector_params.trigger_mode == TriggerMode.SET_FRAMES:
             status &= self.cam.num_triggers.set(
-                self.detector_params.num_triggers, timeout=self.GENERAL_STATUS_TIMEOUT
+                self.detector_params.num_triggers,
+                timeout=self.timeouts.general_status_timeout,
             )
             status &= self.odin.file_writer.num_capture.set(
                 self.detector_params.full_number_of_images,
-                timeout=self.GENERAL_STATUS_TIMEOUT,
+                timeout=self.timeouts.general_status_timeout,
             )
 
         return status
 
     def _wait_for_odin_status(self) -> StatusBase:
         self.forward_bit_depth_to_filewriter()
-        await_value(self.odin.meta.active, 1).wait(self.GENERAL_STATUS_TIMEOUT)
+        await_value(self.odin.meta.active, 1).wait(self.timeouts.general_status_timeout)
 
         status = self.odin.file_writer.capture.set(
-            1, timeout=self.GENERAL_STATUS_TIMEOUT
+            1, timeout=self.timeouts.general_status_timeout
         )
         LOGGER.info("Eiger staging: awaiting odin metadata")
         status &= await_value(
-            self.odin.meta.ready, 1, timeout=self.META_FILE_READY_TIMEOUT
+            self.odin.meta.ready, 1, timeout=self.timeouts.meta_file_ready_timeout
         )
         return status
 
     def _wait_fan_ready(self) -> StatusBase:
         self.filewriters_finished = self.odin.create_finished_status()
         LOGGER.info("Eiger staging: awaiting odin fan ready")
-        return await_value(self.odin.fan.ready, 1, self.GENERAL_STATUS_TIMEOUT)
+        return await_value(self.odin.fan.ready, 1, self.timeouts.general_status_timeout)
 
     def _finish_arm(self) -> Status:
         LOGGER.info("Eiger staging: Finishing arming")
@@ -324,7 +361,7 @@ class EigerDetector(Device):
     def forward_bit_depth_to_filewriter(self):
         bit_depth = self.bit_depth.get()
         self.odin.file_writer.data_type.set(f"UInt{bit_depth}").wait(
-            self.GENERAL_STATUS_TIMEOUT
+            self.timeouts.general_status_timeout
         )
 
     def change_dev_shm(self, enable_dev_shm: bool):
@@ -332,7 +369,7 @@ class EigerDetector(Device):
         return self.odin.fan.dev_shm_enable.set(1 if enable_dev_shm else 0)
 
     def disarm_detector(self):
-        self.cam.acquire.set(0).wait(self.GENERAL_STATUS_TIMEOUT)
+        self.cam.acquire.set(0).wait(self.timeouts.general_status_timeout)
 
     def do_arming_chain(self) -> Status:
         functions_to_do_arm = []
@@ -355,7 +392,9 @@ class EigerDetector(Device):
             self.set_num_triggers_and_captures,
             lambda: await_value(self.stale_params, 0, 60),
             self._wait_for_odin_status,
-            lambda: self.cam.acquire.set(1, timeout=self.GENERAL_STATUS_TIMEOUT),
+            lambda: self.cam.acquire.set(
+                1, timeout=self.timeouts.general_status_timeout
+            ),
             self._wait_fan_ready,
             self._finish_arm,
         ]

dodal/devices/fast_grid_scan.py

@@ -31,12 +31,12 @@ from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBea
 @dataclass
 class GridAxis:
     start: float
-    step_size: float
+    step_size_mm: float
     full_steps: int
 
     def steps_to_motor_position(self, steps):
         """Gives the motor position based on steps, where steps are 0 indexed"""
-        return self.start + self.step_size * steps
+        return self.start + self.step_size_mm * steps
 
     @property
     def end(self):
@@ -62,44 +62,29 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     x_steps: int = 1
     y_steps: int = 1
     z_steps: int = 0
-    x_step_size: float = 0.1
-    y_step_size: float = 0.1
-    z_step_size: float = 0.1
-    x_start: float = 0.1
-    y1_start: float = 0.1
-    y2_start: float = 0.1
-    z1_start: float = 0.1
-    z2_start: float = 0.1
+    x_step_size_mm: float = 0.1
+    y_step_size_mm: float = 0.1
+    z_step_size_mm: float = 0.1
+    x_start_mm: float = 0.1
+    y1_start_mm: float = 0.1
+    y2_start_mm: float = 0.1
+    z1_start_mm: float = 0.1
+    z2_start_mm: float = 0.1
 
     # Whether to set the stub offsets after centering
     set_stub_offsets: bool = False
 
-    def get_param_positions(self) -> dict:
-        return {
-            "x_steps": self.x_steps,
-            "y_steps": self.y_steps,
-            "z_steps": self.z_steps,
-            "x_step_size": self.x_step_size,
-            "y_step_size": self.y_step_size,
-            "z_step_size": self.z_step_size,
-            "x_start": self.x_start,
-            "y1_start": self.y1_start,
-            "y2_start": self.y2_start,
-            "z1_start": self.z1_start,
-            "z2_start": self.z2_start,
-        }
-
     @property
     def x_axis(self) -> GridAxis:
-        return GridAxis(self.x_start, self.x_step_size, self.x_steps)
+        return GridAxis(self.x_start_mm, self.x_step_size_mm, self.x_steps)
 
     @property
     def y_axis(self) -> GridAxis:
-        return GridAxis(self.y1_start, self.y_step_size, self.y_steps)
+        return GridAxis(self.y1_start_mm, self.y_step_size_mm, self.y_steps)
 
     @property
     def z_axis(self) -> GridAxis:
-        return GridAxis(self.z2_start, self.z_step_size, self.z_steps)
+        return GridAxis(self.z2_start_mm, self.z_step_size_mm, self.z_steps)
 
     def get_num_images(self):
         return self.x_steps * (self.y_steps + self.z_steps)
@@ -140,11 +125,6 @@ class ZebraGridScanParams(GridScanParamsCommon):
 
     dwell_time_ms: float = 10
 
-    def get_param_positions(self):
-        param_positions = super().get_param_positions()
-        param_positions["dwell_time_ms"] = self.dwell_time_ms
-        return param_positions
-
     @field_validator("dwell_time_ms")
     @classmethod
     def non_integer_dwell_time(cls, dwell_time_ms: float) -> float:
@@ -166,11 +146,6 @@ class PandAGridScanParams(GridScanParamsCommon):
 
     run_up_distance_mm: float = 0.17
 
-    def get_param_positions(self):
-        param_positions = super().get_param_positions()
-        param_positions["run_up_distance_mm"] = self.run_up_distance_mm
-        return param_positions
-
 
 class MotionProgram(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -241,14 +216,14 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
             "x_steps": self.x_steps,
             "y_steps": self.y_steps,
             "z_steps": self.z_steps,
-            "x_step_size": self.x_step_size,
-            "y_step_size": self.y_step_size,
-            "z_step_size": self.z_step_size,
-            "x_start": self.x_start,
-            "y1_start": self.y1_start,
-            "y2_start": self.y2_start,
-            "z1_start": self.z1_start,
-            "z2_start": self.z2_start,
+            "x_step_size_mm": self.x_step_size,
+            "y_step_size_mm": self.y_step_size,
+            "z_step_size_mm": self.z_step_size,
+            "x_start_mm": self.x_start,
+            "y1_start_mm": self.y1_start,
+            "y2_start_mm": self.y2_start,
+            "z1_start_mm": self.z1_start,
+            "z2_start_mm": self.z2_start,
         }
         super().__init__(name)
 

dodal/devices/focusing_mirror.py

@@ -130,7 +130,12 @@ class FocusingMirror(StandardReadable):
     """Focusing Mirror"""
 
     def __init__(
-        self, name, prefix, bragg_to_lat_lut_path=None, x_suffix="X", y_suffix="Y"
+        self,
+        prefix: str,
+        name: str = "",
+        bragg_to_lat_lut_path: str | None = None,
+        x_suffix: str = "X",
+        y_suffix: str = "Y",
     ):
         self.bragg_to_lat_lookup_table_path = bragg_to_lat_lut_path
         self.yaw_mrad = Motor(prefix + "YAW")
@@ -161,12 +166,12 @@ class FocusingMirrorWithStripes(FocusingMirror):
     """A focusing mirror where the stripe material can be changed. This is usually done
     based on the energy of the beamline."""
 
-    def __init__(self, name, prefix, *args, **kwargs):
+    def __init__(self, prefix: str, name: str = "", *args, **kwargs):
         self.stripe = epics_signal_rw(MirrorStripe, prefix + "STRP:DVAL")
         # apply the current set stripe setting
         self.apply_stripe = epics_signal_x(prefix + "CHANGE.PROC")
 
-        super().__init__(name, prefix, *args, **kwargs)
+        super().__init__(prefix, name, *args, **kwargs)
 
     def energy_to_stripe(self, energy_kev) -> MirrorStripe:
         # In future, this should be configurable per-mirror

dodal/devices/i24/beam_center.py

@@ -0,0 +1,12 @@
+"""A small temporary device to get the beam center positions from \
+    eiger or pilatus detector on i24"""
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class DetectorBeamCenter(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.beam_x = epics_signal_rw(float, prefix + "BeamX")
+        self.beam_y = epics_signal_rw(float, prefix + "BeamY")
+        super().__init__(name)

dodal/devices/i24/focus_mirrors.py

@@ -0,0 +1,60 @@
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+
+
+class HFocusMode(StrictEnum):
+    focus10 = "HMFMfocus10"
+    focus20d = "HMFMfocus20d"
+    focus30d = "HMFMfocus30d"
+    focus50d = "HMFMfocus50d"
+    focus1050d = "HMFMfocus1030d"
+    focus3010d = "HMFMfocus3010d"
+
+
+class VFocusMode(StrictEnum):
+    focus10 = "VMFMfocus10"
+    focus20d = "VMFMfocus20d"
+    focus30d = "VMFMfocus30d"
+    focus50d = "VMFMfocus50d"
+    focus1030d = "VMFMfocus1030d"
+    focus3010d = "VMFMfocus3010d"
+
+
+BEAM_SIZES = {
+    "focus10": [7, 7],
+    "focus20d": [20, 20],
+    "focus30d": [30, 30],
+    "focus50d": [50, 50],
+    "focus1030d": [10, 30],
+    "focus3010d": [30, 10],
+}
+
+
+class FocusMirrorsMode(StandardReadable):
+    """A small device to read the focus mode and work out the beam size."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.horizontal = epics_signal_rw(HFocusMode, prefix + "G1:TARGETAPPLY")
+        self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
+
+        with self.add_children_as_readables():
+            self.beam_size_x = create_hardware_backed_soft_signal(
+                int, self._get_beam_size_x, units="um"
+            )
+            self.beam_size_y = create_hardware_backed_soft_signal(
+                int, self._get_beam_size_y, units="um"
+            )
+
+        super().__init__(name)
+
+    async def _get_beam_size_x(self) -> int:
+        h_mode = await self.horizontal.get_value()
+        beam_x = BEAM_SIZES[h_mode.removeprefix("HMFM")][0]
+        return beam_x
+
+    async def _get_beam_size_y(self) -> int:
+        v_mode = await self.vertical.get_value()
+        beam_y = BEAM_SIZES[v_mode.removeprefix("VMFM")][1]
+        return beam_y

dodal/devices/i24/pilatus_metadata.py

@@ -0,0 +1,44 @@
+"""A small temporary device to set and read the filename template from the pilatus"""
+
+import re
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+
+
+class PilatusMetadata(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.filename = epics_signal_rw(str, prefix + "cam1:FileName")
+        self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
+        self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
+        with self.add_children_as_readables():
+            self.filename_template = create_hardware_backed_soft_signal(
+                str, self._get_full_filename_template
+            )
+        super().__init__(name)
+
+    async def _get_full_filename_template(self) -> str:
+        """
+        Get the template file path by querying the detector PVs.
+        Mirror the construction that the PPU does.
+
+        Returns: A template string, with the image numbers replaced with '#'
+        """
+        filename = await self.filename.get_value()
+        filename_template = await self.template.get_value()
+        file_number = await self.filenumber.get_value()
+        # Exploit fact that passing negative numbers will put the - before the 0's
+        expected_filename = str(
+            filename_template % (filename, f"{file_number:05d}_", -9)
+        )
+        # Now, find the -09 part of this
+        numberpart = re.search(r"(-0+9)", expected_filename)
+        assert numberpart is not None
+        template_fill = "#" * len(numberpart.group(0))
+        return (
+            expected_filename[: numberpart.start()]
+            + template_fill
+            + expected_filename[numberpart.end() :]
+        )

dodal/devices/linkam3.py

@@ -33,7 +33,7 @@ class Linkam3(StandardReadable):
     tolerance: float = 0.5
     settle_time: int = 0
 
-    def __init__(self, prefix: str, name: str):
+    def __init__(self, prefix: str, name: str = ""):
         self.temp = epics_signal_r(float, prefix + "TEMP:")
         self.dsc = epics_signal_r(float, prefix + "DSC:")
         self.start_heat = epics_signal_rw(bool, prefix + "STARTHEAT:")

dodal/devices/motors.py

@@ -1,8 +1,8 @@
-from ophyd_async.core import Device
+from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class XYZPositioner(Device):
+class XYZPositioner(StandardReadable):
     """
 
     Standard ophyd_async xyz motor stage, by combining 3 Motors,
@@ -15,7 +15,7 @@ class XYZPositioner(Device):
     name:
         name for the stage.
     infix:
-        EPICS PV, default is the ["X", "Y", "Z"].
+        EPICS PV, default is the ("X", "Y", "Z").
     Notes
     -----
     Example usage::
@@ -23,14 +23,18 @@ class XYZPositioner(Device):
             xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:")
     Or::
         with DeviceCollector():
-            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", suffix = ["A", "B", "C"])
+            xyz_stage = XYZPositioner("BLXX-MO-STAGE-XX:", infix = ("A", "B", "C"))
 
     """
 
-    def __init__(self, prefix: str, name: str, infix: list[str] | None = None):
-        if infix is None:
-            infix = ["X", "Y", "Z"]
-        self.x = Motor(prefix + infix[0])
-        self.y = Motor(prefix + infix[1])
-        self.z = Motor(prefix + infix[2])
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        infix: tuple[str, str, str] = ("X", "Y", "Z"),
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + infix[0])
+            self.y = Motor(prefix + infix[1])
+            self.z = Motor(prefix + infix[2])
         super().__init__(name=name)