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

dodal/devices/fast_grid_scan.py

@@ -31,7 +31,7 @@ from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
 
-class GridScanInvalidException(RuntimeError):
+class GridScanInvalidError(RuntimeError):
     """Raised when the gridscan parameters are not valid."""
 
 
@@ -302,7 +302,7 @@ class FastGridScanCommon(
             value: the gridscan parameters
 
         Raises:
-            GridScanInvalidException: if the gridscan parameters were not valid
+            GridScanInvalidError: if the gridscan parameters were not valid
         """
         set_statuses = []
 
@@ -326,7 +326,7 @@ class FastGridScanCommon(
                 self.scan_invalid, 0.0, timeout=self.VALIDITY_CHECK_TIMEOUT
             )
         except TimeoutError as e:
-            raise GridScanInvalidException(
+            raise GridScanInvalidError(
                 f"Gridscan parameters not validated after {self.VALIDITY_CHECK_TIMEOUT}s"
             ) from e
 
@@ -470,6 +470,6 @@ def set_fast_grid_scan_params(scan: FastGridScanCommon[ParamType], params: Param
         params: The parameters to set
 
     Raises:
-        GridScanInvalidException: if the grid scan parameters are not valid
+        GridScanInvalidError: if the grid scan parameters are not valid
     """
     yield from prepare(scan, params, wait=True)

dodal/devices/fast_shutter.py

@@ -21,27 +21,27 @@ class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
         await shutter.set(shutter.open_state)
         await shutter.set(shutter.close_state)
     OR
-        RE(bps.mv(shutter, shutter.open_state))
-        RE(bps.mv(shutter, shutter.close_state))
+        run_engine(bps.mv(shutter, shutter.open_state))
+        run_engine(bps.mv(shutter, shutter.close_state))
     """
 
     def __init__(
         self,
-        prefix: str,
+        pv: str,
         open_state: StrictEnumT,
         close_state: StrictEnumT,
         name: str = "",
     ):
         """
         Arguments:
-            prefix: The prefix for the shutter device.
+            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), prefix)
+            self.state = epics_signal_rw(type(self.open_state), pv)
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -49,9 +49,21 @@ class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
         await self.state.set(value)
 
     async def is_open(self) -> bool:
-        """Checks to see if shutter is currently open"""
+        """
+        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 currently closed"""
+        """
+        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/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"""