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

dodal/devices/i02_1/fast_grid_scan.py

@@ -0,0 +1,61 @@
+from ophyd_async.core import SignalR, derived_signal_r, soft_signal_r_and_setter
+from ophyd_async.epics.core import epics_signal_rw_rbv
+
+from dodal.devices.fast_grid_scan import (
+    FastGridScanCommon,
+    GridScanParamsCommon,
+    MotionProgram,
+    WithDwellTime,
+)
+from dodal.log import LOGGER
+
+
+class ZebraGridScanParamsTwoD(GridScanParamsCommon, WithDwellTime):
+    """
+    Params for 2D Zebra FGS. Adds on the dwell time, which is really the time
+    between trigger positions.
+    """
+
+
+class ZebraFastGridScanTwoD(FastGridScanCommon[ZebraGridScanParamsTwoD]):
+    """i02-1's EPICS interface for the 2D FGS differs slightly from the standard 3D
+    version:
+    - No Z steps, Z step sizes, or Y2 start positions, or Z2 start
+    - No scan valid PV - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    - No program_number - see https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    """
+
+    def __init__(
+        self, prefix: str, motion_controller_prefix: str, name: str = ""
+    ) -> None:
+        full_prefix = prefix + "FGS:"
+        super().__init__(full_prefix, motion_controller_prefix, name)
+
+        # This signal could be put in the common device if the prefix gets standardised.
+        # 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
+
+    def _create_expected_images_signal(self):
+        return derived_signal_r(
+            self._calculate_expected_images,
+            x=self.x_steps,
+            y=self.y_steps,
+        )
+
+    def _calculate_expected_images(self, x: int, y: int) -> int:
+        LOGGER.info(f"Reading num of images found {x, y} images in each axis")
+        return x * y
+
+    # VMXm triggers the grid scan through GDA, which has its own validity check
+    # so whilst this PV is being added, it isn't essential
+    def _create_scan_invalid_signal(self, prefix: str) -> SignalR[float]:
+        return soft_signal_r_and_setter(float, 0)[0]
+
+    def _create_motion_program(self, motion_controller_prefix):
+        return MotionProgram(motion_controller_prefix, has_prog_num=False)
+
+    # To be standardised in https://github.com/DiamondLightSource/mx-bluesky/issues/1203
+    def _create_position_counter(self, prefix: str):
+        return epics_signal_rw_rbv(int, f"{prefix}POS_COUNTER")

dodal/devices/i02_1/sample_motors.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class SampleMotors(StandardReadable):
+    """Virtual Smaract motors on i02-1 (VMXm)"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        # See https://github.com/DiamondLightSource/mx-bluesky/issues/1212
+        # regarding a potential motion issue with omega
+        with self.add_children_as_readables():
+            self.x = Motor(f"{prefix}X")
+            self.z = Motor(f"{prefix}Z")
+            self.omega = Motor(f"{prefix}OMEGA")
+        super().__init__(name=name)

dodal/devices/i04/murko_results.py

@@ -1,5 +1,6 @@
 import json
 import pickle
+from dataclasses import dataclass
 from enum import Enum
 from typing import TypedDict
 
@@ -21,9 +22,6 @@ from dodal.log import LOGGER
 
 NO_MURKO_RESULT = (-1, -1)
 
-MurkoResult = dict
-FullMurkoResults = dict[str, list[MurkoResult]]
-
 
 class MurkoMetadata(TypedDict):
     zoom_percentage: float
@@ -42,6 +40,19 @@ class Coord(Enum):
     z = 2
 
 
+@dataclass
+class MurkoResult:
+    centre_px: tuple
+    x_dist_mm: float
+    y_dist_mm: float
+    omega: float
+    uuid: str
+
+
+class NoResultsFound(ValueError):
+    pass
+
+
 class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
     """Device that takes crystal centre values from Murko and uses them to set the
     x, y, z coordinate of the sample to be in line with the beam centre.
@@ -59,6 +70,8 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
     """
 
     TIMEOUT_S = 2
+    PERCENTAGE_TO_USE = 25
+    NUMBER_OF_WRONG_RESULTS_TO_LOG = 5
 
     def __init__(
         self,
@@ -74,12 +87,10 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             db=redis_db,
         )
         self.pubsub = self.redis_client.pubsub()
-        self._last_omega = 0
         self.sample_id = soft_signal_rw(str)  # Should get from redis
         self.stop_angle = stop_angle
-        self.x_dists_mm = []
-        self.y_dists_mm = []
-        self.omegas = []
+
+        self._reset()
 
         with self.add_children_as_readables():
             # Diffs from current x/y/z
@@ -88,6 +99,10 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             self.z_mm, self._z_mm_setter = soft_signal_r_and_setter(float)
         super().__init__(name=name)
 
+    def _reset(self):
+        self._last_omega = 0
+        self.results: list[MurkoResult] = []
+
     @AsyncStatus.wrap
     async def stage(self):
         await self.pubsub.subscribe("murko-results")
@@ -97,6 +112,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
     @AsyncStatus.wrap
     async def unstage(self):
+        self._reset()
         await self.pubsub.unsubscribe()
 
     @AsyncStatus.wrap
@@ -106,19 +122,26 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         while self._last_omega < self.stop_angle:
             # waits here for next batch to be received
             message = await self.pubsub.get_message(timeout=self.TIMEOUT_S)
-            if message is None:  # No more messages to process
-                break
+            if message is None:
+                continue
             await self.process_batch(message, sample_id)
 
-        for i in range(len(self.omegas)):
-            LOGGER.debug(
-                f"omega: {round(self.omegas[i], 2)}, x: {round(self.x_dists_mm[i], 2)}, y: {round(self.y_dists_mm[i], 2)}"
-            )
+        if not self.results:
+            raise NoResultsFound("No results retrieved from Murko")
+
+        for result in self.results:
+            LOGGER.debug(result)
+
+        self.filter_outliers()
 
-        LOGGER.info(f"Using average of x beam distances: {self.x_dists_mm}")
-        avg_x = float(np.mean(self.x_dists_mm))
-        LOGGER.info(f"Finding least square y and z from y distances: {self.y_dists_mm}")
-        best_y, best_z = get_yz_least_squares(self.y_dists_mm, self.omegas)
+        x_dists_mm = [result.x_dist_mm for result in self.results]
+        y_dists_mm = [result.y_dist_mm for result in self.results]
+        omegas = [result.omega for result in self.results]
+
+        LOGGER.info(f"Using average of x beam distances: {x_dists_mm}")
+        avg_x = float(np.mean(x_dists_mm))
+        LOGGER.info(f"Finding least square y and z from y distances: {y_dists_mm}")
+        best_y, best_z = get_yz_least_squares(y_dists_mm, omegas)
         # x, y, z are relative to beam centre. Need to move negative these values to get centred.
         self._x_mm_setter(-avg_x)
         self._y_mm_setter(-best_y)
@@ -163,15 +186,38 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
                 centre_px[0],
                 centre_px[1],
             )
-            self.x_dists_mm.append(
-                beam_dist_px[0] * metadata["microns_per_x_pixel"] / 1000
-            )
-            self.y_dists_mm.append(
-                beam_dist_px[1] * metadata["microns_per_y_pixel"] / 1000
+            self.results.append(
+                MurkoResult(
+                    centre_px=centre_px,
+                    x_dist_mm=beam_dist_px[0] * metadata["microns_per_x_pixel"] / 1000,
+                    y_dist_mm=beam_dist_px[1] * metadata["microns_per_y_pixel"] / 1000,
+                    omega=omega,
+                    uuid=metadata["uuid"],
+                )
             )
-            self.omegas.append(omega)
             self._last_omega = omega
 
+    def filter_outliers(self):
+        """Whilst murko is not fully trained it often gives us poor results.
+        When it is wrong it usually picks up the base of the pin, rather than the tip,
+        meaning that by keeping only a percentage of the results with the smallest X we
+        remove many of the outliers.
+        """
+        LOGGER.info(f"Number of results before filtering: {len(self.results)}")
+        sorted_results = sorted(self.results, key=lambda item: item.centre_px[0])
+
+        worst_results = [
+            r.uuid for r in sorted_results[-self.NUMBER_OF_WRONG_RESULTS_TO_LOG :]
+        ]
+
+        LOGGER.info(
+            f"Worst {self.NUMBER_OF_WRONG_RESULTS_TO_LOG} murko results were {worst_results}"
+        )
+        cutoff = max(1, int(len(sorted_results) * self.PERCENTAGE_TO_USE / 100))
+        smallest_x = sorted_results[:cutoff]
+        self.results = smallest_x
+        LOGGER.info(f"Number of results after filtering: {len(self.results)}")
+
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:
     """Get the least squares solution for y and z from the vertical distances and omega angles.