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

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)

dodal/devices/oav/oav_detector.py

@@ -40,15 +40,15 @@ class ZoomController(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        super().__init__(name=name)
         self.percentage = epics_signal_rw(float, f"{prefix}ZOOMPOSCMD")
 
         # Level is the string description of the zoom level e.g. "1.0x" or "1.0"
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
+        super().__init__(name=name)
 
     async def _get_allowed_zoom_levels(self) -> list:
         zoom_levels = await self.level.describe()
-        return zoom_levels["level"]["choices"]  # type: ignore
+        return zoom_levels[self.level.name]["choices"]  # type: ignore
 
     @AsyncStatus.wrap
     async def set(self, level_to_set: str):

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -2,7 +2,6 @@ import asyncio
 import time
 
 import numpy as np
-from numpy.typing import NDArray
 from ophyd_async.core import (
     Array1D,
     AsyncStatus,
@@ -57,12 +56,12 @@ class PinTipDetection(StandardReadable):
             Tip, name="triggered_tip"
         )
         self.triggered_top_edge, self._top_edge_setter = soft_signal_r_and_setter(
-            NDArray[np.uint32], name="triggered_top_edge"
+            Array1D[np.int32], name="triggered_top_edge"
         )
         self.triggered_bottom_edge, self._bottom_edge_setter = soft_signal_r_and_setter(
-            NDArray[np.uint32], name="triggered_bottom_edge"
+            Array1D[np.int32], name="triggered_bottom_edge"
         )
-        self.array_data = epics_signal_r(NDArray[np.uint8], f"pva://{prefix}PVA:ARRAY")
+        self.array_data = epics_signal_r(Array1D[np.uint8], f"pva://{prefix}PVA:ARRAY")
 
         # Soft parameters for pin-tip detection.
         self.preprocess_operation = soft_signal_rw(int, 10, name="preprocess")
@@ -101,7 +100,7 @@ class PinTipDetection(StandardReadable):
         self._bottom_edge_setter(results.edge_bottom)
 
     async def _get_tip_and_edge_data(
-        self, array_data: NDArray[np.uint8]
+        self, array_data: Array1D[np.uint8]
     ) -> SampleLocation:
         """
         Gets the location of the pin tip and the top and bottom edges.

dodal/devices/oav/utils.py

@@ -87,6 +87,7 @@ def calculate_x_y_z_of_pixel(
     beam_centre: tuple[int, int],
     microns_per_pixel: tuple[float, float],
 ) -> np.ndarray:
+    """Get the x, y, z position of a pixel in mm"""
     beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
 
     return current_x_y_z + camera_coordinates_to_xyz(

dodal/devices/p99/sample_stage.py

@@ -1,18 +1,13 @@
-from ophyd_async.core import Device, SubsetEnum
-from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.core import StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_rw, epics_signal_rw_rbv
 
 
-class SampleAngleStage(Device):
-    def __init__(self, prefix: str, name: str):
-        self.theta = epics_signal_rw(
-            float, prefix + "WRITETHETA:RBV", prefix + "WRITETHETA"
-        )
-        self.roll = epics_signal_rw(
-            float, prefix + "WRITEROLL:RBV", prefix + "WRITEROLL"
-        )
-        self.pitch = epics_signal_rw(
-            float, prefix + "WRITEPITCH:RBV", prefix + "WRITEPITCH"
-        )
+class SampleAngleStage(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.theta = epics_signal_rw_rbv(float, prefix + "WRITETHETA", ":RBV")
+            self.roll = epics_signal_rw_rbv(float, prefix + "WRITEROLL", ":RBV")
+            self.pitch = epics_signal_rw_rbv(float, prefix + "WRITEPITCH", ":RBV")
         super().__init__(name=name)
 
 
@@ -35,7 +30,8 @@ class p99StageSelections(SubsetEnum):
     User = "User"
 
 
-class FilterMotor(Device):
-    def __init__(self, prefix: str, name: str):
-        self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
+class FilterMotor(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
         super().__init__(name=name)