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

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 GridScanInvalidError(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:
+            GridScanInvalidError: 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 GridScanInvalidError(
+                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:
+        GridScanInvalidError: if the grid scan parameters are not valid
+    """
+    yield from prepare(scan, params, wait=True)

dodal/devices/fast_shutter.py

@@ -0,0 +1,69 @@
+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
+        run_engine(bps.mv(shutter, shutter.open_state))
+        run_engine(bps.mv(shutter, shutter.close_state))
+    """
+
+    def __init__(
+        self,
+        pv: str,
+        open_state: StrictEnumT,
+        close_state: StrictEnumT,
+        name: str = "",
+    ):
+        """
+        Arguments:
+            pv: The pv to connect to 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), pv)
+        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 in open_state. Should not be used directly inside a
+        plan. A user should use the following instead in a plan:
+
+            from bluesky import plan_stubs as bps
+            is_open = yield from bps.rd(shutter.state) == shutter.open_state
+        """
+        return await self.state.get_value() == self.open_state
+
+    async def is_closed(self) -> bool:
+        """
+        Checks to see if shutter is in close_state. Should not be used directly inside a
+        plan. A user should use the following instead in a plan:
+
+            from bluesky import plan_stubs as bps
+            is_closed = yield from bps.rd(shutter.state) == shutter.close_state
+        """
+        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/i03/dcm.py

@@ -9,13 +9,15 @@ from dodal.common.crystal_metadata import (
     make_crystal_metadata_from_material,
 )
 from dodal.devices.common_dcm import (
-    BaseDCM,
+    DoubleCrystalMonochromatorWithDSpacing,
     PitchAndRollCrystal,
     StationaryCrystal,
 )
 
 
-class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
+class DCM(
+    DoubleCrystalMonochromatorWithDSpacing[PitchAndRollCrystal, StationaryCrystal]
+):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 

dodal/devices/i04/murko_results.py

@@ -43,7 +43,7 @@ class Coord(Enum):
 
 @dataclass
 class MurkoResult:
-    centre_px: tuple
+    chosen_point_px: tuple[int, int]
     x_dist_mm: float
     y_dist_mm: float
     omega: float
@@ -51,7 +51,7 @@ class MurkoResult:
     metadata: MurkoMetadata
 
 
-class NoResultsFound(ValueError):
+class NoResultsFoundError(ValueError):
     pass
 
 
@@ -73,6 +73,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
     TIMEOUT_S = 2
     PERCENTAGE_TO_USE = 25
+    LEFTMOST_PIXEL_TO_USE = 10
     NUMBER_OF_WRONG_RESULTS_TO_LOG = 5
 
     def __init__(
@@ -129,7 +130,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             await self.process_batch(message, sample_id)
 
         if not self._results:
-            raise NoResultsFound("No results retrieved from Murko")
+            raise NoResultsFoundError("No results retrieved from Murko")
 
         for result in self._results:
             LOGGER.debug(result)
@@ -186,16 +187,16 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         else:
             shape = result["original_shape"]  # Dimensions of image in pixels
             # Murko returns coords as y, x
-            centre_px = (coords[1] * shape[1], coords[0] * shape[0])
+            chosen_point_px = (coords[1] * shape[1], coords[0] * shape[0])
 
             beam_dist_px = calculate_beam_distance(
                 (metadata["beam_centre_i"], metadata["beam_centre_j"]),
-                centre_px[0],
-                centre_px[1],
+                chosen_point_px[0],
+                chosen_point_px[1],
             )
             self._results.append(
                 MurkoResult(
-                    centre_px=centre_px,
+                    chosen_point_px=chosen_point_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,
@@ -209,10 +210,27 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         """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.
+        remove many of the outliers. Murko also occasionally picks a point in the bottom
+        left corner, which can be removed by filtering results with a small x pixel.
         """
+
         LOGGER.info(f"Number of results before filtering: {len(self._results)}")
-        sorted_results = sorted(self._results, key=lambda item: item.centre_px[0])
+        sorted_results = sorted(self._results, key=lambda item: item.chosen_point_px[0])
+
+        results_without_tiny_x = [
+            result
+            for result in sorted_results
+            if result.chosen_point_px[0] >= self.LEFTMOST_PIXEL_TO_USE
+        ]
+        result_uuids_with_tiny_x = [
+            result.uuid
+            for result in sorted_results
+            if result not in results_without_tiny_x
+        ]
+
+        LOGGER.info(
+            f"Results with tiny x have been removed: {result_uuids_with_tiny_x}"
+        )
 
         worst_results = [
             r.uuid for r in sorted_results[-self.NUMBER_OF_WRONG_RESULTS_TO_LOG :]
@@ -221,14 +239,17 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         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))
-        for i, result in enumerate(sorted_results):
-            result.metadata["used_for_centring"] = i < cutoff
+        cutoff = min(cutoff, len(results_without_tiny_x))
+
+        best_x = results_without_tiny_x[:cutoff]
 
-        smallest_x = sorted_results[:cutoff]
+        for result in sorted_results:
+            result.metadata["used_for_centring"] = result in best_x
 
-        LOGGER.info(f"Number of results after filtering: {len(smallest_x)}")
-        return smallest_x
+        LOGGER.info(f"Number of results after filtering: {len(best_x)}")
+        return best_x
 
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:

dodal/devices/i09/__init__.py

@@ -1,4 +1,3 @@
-from dodal.devices.i09.dcm import DCM
 from dodal.devices.i09.enums import Grating, LensMode, PassEnergy, PsuMode
 
-__all__ = ["DCM", "Grating", "LensMode", "PsuMode", "PassEnergy"]
+__all__ = ["Grating", "LensMode", "PsuMode", "PassEnergy"]

dodal/devices/i10/__init__.py

@@ -0,0 +1,29 @@
+from .diagnostics import (
+    I10Diagnostic,
+    I10Diagnostic5ADet,
+    I10JDiagnostic,
+    I10PneumaticStage,
+    I10SharedDiagnostic,
+)
+from .mirrors import PiezoMirror
+from .slits import (
+    I10JSlits,
+    I10SharedSlits,
+    I10SharedSlitsDrainCurrent,
+    I10Slits,
+    I10SlitsDrainCurrent,
+)
+
+__all__ = [
+    "I10Diagnostic",
+    "I10Diagnostic5ADet",
+    "I10PneumaticStage",
+    "PiezoMirror",
+    "I10Slits",
+    "I10SlitsDrainCurrent",
+    "I10SharedDiagnostic",
+    "I10SharedSlits",
+    "I10JSlits",
+    "I10SharedSlitsDrainCurrent",
+    "I10JDiagnostic",
+]

dodal/devices/i10/diagnostics.py

@@ -28,7 +28,7 @@ class D3Position(StrictEnum):
     GRID = "Grid"
 
 
-class D5Position(StrictEnum):
+class CellPosition(StrictEnum):
     CELL_IN = "Cell In"
     CELL_OUT = "Cell Out"
 
@@ -68,6 +68,21 @@ class InStateReadBackTable(StrictEnum):
     OUT_OF_BEAM = "Out of Beam"
 
 
+class D2jPosition(StrictEnum):
+    OUT_OF_THE_BEAM = "Out of the beam"
+    DIODE = "Diode"
+    BLADE = "Blade"
+    LA = "La ref"
+    GD = "Gd ref"
+    YB = "Yb ref"
+
+
+class D3jPosition(StrictEnum):
+    OUT_OF_THE_BEAM = "Out of the beam"
+    DIODE_IN = "Diode In"
+    DIAMOND_WINDOW = "Diamond window"
+
+
 class I10PneumaticStage(StandardReadable):
     """Pneumatic stage only has two real positions in or out.
     Use for fluorescent screen which can be insert into the x-ray beam.
@@ -138,9 +153,7 @@ class FullDiagnostic(Device):
         super().__init__(name)
 
 
-class I10Diagnostic(Device):
-    """Collection of all the diagnostic stage on i10."""
-
+class I10SharedDiagnostic(Device):
     def __init__(self, prefix, name: str = "") -> None:
         self.d1 = ScreenCam(prefix=prefix + "PHDGN-01:")
         self.d2 = ScreenCam(prefix=prefix + "PHDGN-02:")
@@ -149,8 +162,15 @@ class I10Diagnostic(Device):
             positioner_enum=D3Position,
             positioner_suffix="DET:X",
         )
+        super().__init__(name)
+
+
+class I10Diagnostic(Device):
+    """Collection of all the diagnostic stage on i10."""
+
+    def __init__(self, prefix, name: str = "") -> None:
         self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
-        self.d5 = create_positioner(D5Position, f"{prefix}IONC-01:Y")
+        self.d5 = create_positioner(CellPosition, f"{prefix}IONC-01:Y")
         self.d5A = create_positioner(D5APosition, f"{prefix}PHDGN-06:DET:X")
         self.d6 = FullDiagnostic(f"{prefix}PHDGN-05:", D6Position, "DET:X")
         self.d7 = create_positioner(D7Position, f"{prefix}PHDGN-07:Y")
@@ -158,6 +178,18 @@ class I10Diagnostic(Device):
         super().__init__(name)
 
 
+class I10JDiagnostic(Device):
+    """Collection of all the diagnostic stage on i10-1."""
+
+    def __init__(self, prefix, name: str = "") -> None:
+        self.dj1 = ScreenCam(prefix=prefix + "PHDGN-01:")
+        self.dj2 = create_positioner(CellPosition, f"{prefix}IONC-01:Y")
+        self.dj2A = create_positioner(D2jPosition, f"{prefix}PHDGN-03:DET:X")
+        self.dj3 = FullDiagnostic(f"{prefix}PHDGN-02:", D3jPosition, "DET:X")
+
+        super().__init__(name)
+
+
 class I10Diagnostic5ADet(Device):
     """Diagnostic 5a detection with drain current and photo diode"""