dls-dodal 1.68.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -30,8 +30,7 @@ class InvalidPinError(Exception):
 
 
 class PinTipDetection(StandardReadable):
-    """
-    A device which will read from an on-axis view and calculate the location of the
+    """A device which will read from an on-axis view and calculate the location of the
     pin-tip (in pixels) of that frame.
 
     Used for pin tip centring workflow.
@@ -42,7 +41,8 @@ class PinTipDetection(StandardReadable):
     If no tip is found it will return {INVALID_POSITION}. However, it will also
     occasionally give incorrect data. Therefore, it is recommended that you trigger
     this device, which will attempt to find a pin within {validity_timeout} seconds if
-    no tip is found after this time it will not error but instead return {INVALID_POSITION}.
+    no tip is found after this time it will not error but instead return
+    {INVALID_POSITION}.
     """
 
     INVALID_POSITION = np.array([np.iinfo(np.int32).min, np.iinfo(np.int32).min])
@@ -98,9 +98,7 @@ class PinTipDetection(StandardReadable):
         self._bottom_edge_setter(results.edge_bottom)
 
     async def _get_tip_and_edge_data(self, array_data: np.ndarray) -> SampleLocation:
-        """
-        Gets the location of the pin tip and the top and bottom edges.
-        """
+        """Gets the location of the pin tip and the top and bottom edges."""
         preprocess_key = await self.preprocess_operation.get_value()
         preprocess_iter = await self.preprocess_iterations.get_value()
         preprocess_ksize = await self.preprocess_ksize.get_value()

dodal/devices/oav/pin_image_recognition/manual_test.py

@@ -1,5 +1,4 @@
-"""
-Note: this file exists exclusively to make it easier to manually run
+"""Note: this file exists exclusively to make it easier to manually run
 image recognition on a beamline without setting up all of the
 bluesky infrastructure.
 

dodal/devices/oav/pin_image_recognition/utils.py

@@ -100,9 +100,7 @@ NONE_VALUE: Final[int] = -1
 
 @dataclass
 class SampleLocation:
-    """
-    Holder type for results from sample detection.
-    """
+    """Holder type for results from sample detection."""
 
     tip_x: int | None
     tip_y: int | None
@@ -111,6 +109,28 @@ class SampleLocation:
 
 
 class MxSampleDetect:
+    """Configures sample detection parameters.
+
+    Args:
+        preprocess (Callable): A preprocessing function applied to the array after
+            conversion to grayscale. See implementations of common functions above
+            for predefined conversions. Defaults to a no-op (i.e. no preprocessing).
+
+        for open and close operations, please read:
+            https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html
+
+        open_ksize (int, optional): Kernel size for "open" operation, if set to zero
+            then ignore "open" operation.
+        open_iterations (int, optional): Number of iterations for "open" operation.
+        canny_upper (int, optional): Upper threshold for canny edge detection.
+        canny_lower (int, optional): Lower threshold for canny edge detection.
+        close_ksize (int, optional): Kernel size for "close" operation.
+        close_iterations (int, optional): Number of iterations for "close" operation.
+        scan_direction (ScanDirections, optional): ScanDirections.FORWARD for
+            left-to-right, ScanDirections.REVERSE for right-to-left.
+        min_tip_height (int, optional): Minimum height of pin tip.
+    """
+
     def __init__(
         self,
         *,
@@ -124,27 +144,6 @@ class MxSampleDetect:
         scan_direction: ScanDirections = ScanDirections.FORWARD,
         min_tip_height: int = 5,
     ):
-        """
-        Configures sample detection parameters.
-
-        Args:
-            preprocess: A preprocessing function applied to the array after conversion to grayscale.
-                See implementations of common functions above for predefined conversions
-                Defaults to a no-op (i.e. no preprocessing)
-
-            for open and close operations, please read:
-                https://docs.opencv.org/4.x/d9/d61/tutorial_py_morphological_ops.html
-
-            open_ksize: kernel size for "open" operation, if set to zero then ignore "open" operation
-            open_iterations: number of iterations for "open" operation
-            canny_upper: upper threshold for canny edge detection
-            canny_lower: lower threshold for canny edge detection
-            close_ksize: kernel size for "close" operation
-            close_iterations: number of iterations for "close" operation
-            scan_direction: ScanDirections.FORWARD for left-to-right, ScanDirections.REVERSE for right-to-left
-            min_tip_height: minimum height of pin tip
-        """
-
         self.preprocess = preprocess
         self.open_ksize = open_ksize
         self.open_iterations = open_iterations
@@ -185,17 +184,16 @@ class MxSampleDetect:
     def _first_and_last_nonzero_by_columns(
         arr: np.ndarray,
     ) -> tuple[np.ndarray, np.ndarray]:
-        """
-        Finds the indexes of the first & last non-zero values by column in a 2d array.
+        """Finds the indexes of the first & last non-zero values by column in a 2d array.
 
         Outputs will contain NONE_VALUE if no non-zero values exist in a column.
 
-        i.e. for input:
-        [
-            [0, 0, 0, 1],
-            [1, 1, 0, 0],
-            [0, 1, 0, 1],
-        ]
+        i.e. for input::
+            [
+                [0, 0, 0, 1],
+                [1, 1, 0, 0],
+                [0, 1, 0, 1],
+            ]
 
         first_nonzero will be: [1, 1, NONE_VALUE, 0]
         last_nonzero will be [1, 2, NONE_VALUE, 2]

dodal/devices/oav/snapshots/grid_overlay.py

@@ -19,12 +19,12 @@ def _add_parallel_lines_to_image(
     orientation=Orientation.horizontal,
 ):
     """Draws horizontal or vertical parallel lines on a given image.
-    Draws a line of a given length and orientation starting from a given point; then \
-    draws a given number of parallel lines equally spaced with a given spacing. \
-    If the line is horizontal, the start point corresponds to left end of the initial \
-    line and the other parallel lines will be drawn below the initial line; if \
-    vertical, the start point corresponds to the top end of the initial line and the \
-    other parallel lines will be drawn to the right of the initial line. (0,0) is the \
+    Draws a line of a given length and orientation starting from a given point; then
+    draws a given number of parallel lines equally spaced with a given spacing.
+    If the line is horizontal, the start point corresponds to left end of the initial
+    line and the other parallel lines will be drawn below the initial line; if
+    vertical, the start point corresponds to the top end of the initial line and the
+    other parallel lines will be drawn to the right of the initial line. (0,0) is the
     top left of the image.
 
     Args:
@@ -32,11 +32,12 @@ def _add_parallel_lines_to_image(
         start_x (int): The x coordinate (in pixels) of the start of the initial line.
         start_y (int): The y coordinate (in pixels) of the start of the initial line.
         line_length (int): The length of each of the parallel lines in pixels.
-        spacing (float): The spacing, in pixels, between each parallel line. Strictly, \
+        spacing (float): The spacing, in pixels, between each parallel line. Strictly,
             there are spacing-1 pixels between each line
         num_lines (int): The total number of parallel lines to draw.
-        orientation (Orientation): The orientation (horizontal or vertical) of the \
-            parallel lines to draw."""
+        orientation (Orientation): The orientation (horizontal or vertical) of the
+            parallel lines to draw.
+    """
     lines = [
         (
             (

dodal/devices/oav/snapshots/snapshot_image_processing.py

@@ -8,12 +8,12 @@ CROSSHAIR_FILL_COLOUR = "White"
 
 
 def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
-    """
-    Draw a crosshair at the beam centre coordinates specified.
+    """Draw a crosshair at the beam centre coordinates specified.
+
     Args:
-        image: The image to draw the crosshair onto. This is mutated.
-        beam_x: The x-coordinate of the crosshair (pixels)
-        beam_y: The y-coordinate of the crosshair (pixels)
+        image (Image): The image to draw the crosshair onto. This is mutated.
+        beam_x (int): The x-coordinate of the crosshair (pixels).
+        beam_y (int): The y-coordinate of the crosshair (pixels).
     """
     draw = ImageDraw.Draw(image)
     outline_width = 1
@@ -51,16 +51,18 @@ def compute_beam_centre_pixel_xy_for_mm_position(
     beam_pos_at_origin_px: Pixel,
     microns_per_pixel: tuple[float, float],
 ) -> Pixel:
-    """
-    Compute the location of the beam centre in pixels on a reference image.
+    """Compute the location of the beam centre in pixels on a reference image.
+
     Args:
-        sample_pos_mm: x, y location of the sample in mm relative to when the reference image
-            was taken.
-        beam_pos_at_origin_px: x, y position of the beam centre in the reference image (pixels)
-        microns_per_pixel: x, y scaling factor relating the sample position to the position in the image.
-    Returns:
-        x, y location of the beam centre (pixels)
+        sample_pos_mm (tuple[float, float]): x, y location of the sample in mm relative
+            to when the reference image was taken.
+        beam_pos_at_origin_px (Pixel): x, y position of the beam centre in the reference
+            image (pixels).
+        microns_per_pixel (tuple[float, float]): x, y scaling factor relating the sample
+            position to the position in the image.
 
+    Returns:
+        Pixel: x, y location of the beam centre (pixels).
     """
 
     def centre(sample_pos, beam_pos, um_per_px) -> int:

dodal/devices/oav/utils.py

@@ -2,6 +2,7 @@ from collections.abc import Generator
 from enum import IntEnum
 
 import bluesky.plan_stubs as bps
+import cv2
 import numpy as np
 from bluesky.utils import Msg
 
@@ -40,9 +41,7 @@ def bottom_right_from_top_left(
 
 
 class EdgeOutputArrayImageType(IntEnum):
-    """
-    Enum to store the types of image to tweak the output array. We use Original.
-    """
+    """Enum to store the types of image to tweak the output array. We use Original."""
 
     ORIGINAL = 0
     GREYSCALE = 1
@@ -56,8 +55,9 @@ def get_move_required_so_that_beam_is_at_pixel(
     pixel: Pixel,
     oav: OAV,
 ) -> Generator[Msg, None, np.ndarray]:
-    """Calculate the required move so that the given pixel is in the centre of the beam."""
-
+    """Calculate the required move so that the given pixel is in the centre of the
+    beam.
+    """
     current_motor_xyz = np.array(
         [
             (yield from bps.rd(gonio.x)),
@@ -94,7 +94,7 @@ def calculate_x_y_z_of_pixel(
     microns_per_pixel: tuple[float, float],
     xyz_direction: tuple[int, int, int],
 ) -> np.ndarray:
-    """Get the x, y, z position of a pixel in mm"""
+    """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_mm(
@@ -119,3 +119,17 @@ def wait_for_tip_to_be_found(
         raise PinNotFoundError(f"No pin found after {timeout} seconds")
 
     return Pixel((int(found_tip[0]), int(found_tip[1])))
+
+
+def convert_to_gray_and_blur(data: cv2.typing.MatLike) -> cv2.typing.MatLike:
+    """Preprocess the image array data (convert to grayscale and apply a gaussian blur)
+    Image is converted to grayscale (using a weighted mean as green contributes more to
+    brightness) as we aren't interested in data relating to colour. A blur is then
+    applied to mitigate errors due to rogue hot pixels.
+    """
+    # kernel size describes how many of the neighbouring pixels are used for the blur,
+    # higher kernal size means more of a blur effect
+    kernel_size = (7, 7)
+
+    gray_arr = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY)
+    return cv2.GaussianBlur(gray_arr, kernel_size, 0)

dodal/devices/p45.py

@@ -3,9 +3,7 @@ from ophyd_async.epics.motor import Motor
 
 
 class SampleY(StandardReadable):
-    """
-    Motors for controlling the sample's y position and stretch in the y axis.
-    """
+    """Motors for controlling the sample's y position and stretch in the y axis."""
 
     def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
@@ -17,9 +15,7 @@ class SampleY(StandardReadable):
 
 
 class SampleTheta(StandardReadable):
-    """
-    Motors for controlling the sample's theta position and skew
-    """
+    """Motors for controlling the sample's theta position and skew."""
 
     def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
@@ -31,9 +27,7 @@ class SampleTheta(StandardReadable):
 
 
 class TomoStageWithStretchAndSkew(StandardReadable):
-    """
-    Grouping of motors for the P45 tomography stage
-    """
+    """Grouping of motors for the P45 tomography stage."""
 
     def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():

dodal/devices/pgm.py

@@ -8,8 +8,14 @@ from ophyd_async.epics.motor import Motor
 
 
 class PlaneGratingMonochromator(StandardReadable):
-    """
-    Plane grating monochromator, it is use in soft x-ray beamline to generate monochromic beam.
+    """Plane grating monochromator, it is use in soft x-ray beamline to generate
+    monochromic beam.
+
+    Args:
+        prefix (str): Beamline specific part of the PV.
+        grating (type[StrictEnum]): The Enum for the grating table.
+        grating_pv (str): The suffix PV part of grating PV.
+        name (str, optional): Name of the device.
     """
 
     def __init__(
@@ -19,18 +25,6 @@ class PlaneGratingMonochromator(StandardReadable):
         grating_pv: str = "GRATINGSELECT:SELECT",
         name: str = "",
     ) -> None:
-        """
-        Parameters
-        ----------
-        prefix:
-            Beamline specific part of the PV
-        grating:
-            The Enum for the grating table.
-        grating_pv:
-            The suffix pv part of grating Pv
-        name:
-            Name of the device
-        """
         with self.add_children_as_readables():
             self.energy = Motor(prefix + "ENERGY")
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):

dodal/devices/pressure_jump_cell.py

@@ -2,14 +2,21 @@ import asyncio
 from enum import IntEnum
 from typing import Generic, TypeVar
 
-from bluesky.protocols import Movable
+from bluesky.protocols import Movable, Stoppable, Triggerable
 from ophyd_async.core import (
     AsyncStatus,
+    DeviceMock,
     DeviceVector,
+    Reference,
     SignalR,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
+    callback_on_mock_put,
+    default_mock_class,
+    set_and_wait_for_other_value,
+    set_mock_value,
+    wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
@@ -22,11 +29,6 @@ class PumpState(StrictEnum):
     AUTO_POSITION = "Auto Position"
 
 
-class StopState(StrictEnum):
-    CONTINUE = "CONTINUE"
-    STOP = "STOP"
-
-
 class ValveControlRequest(StrictEnum):
     OPEN = "Open"
     CLOSE = "Close"
@@ -99,10 +101,8 @@ class ValveControl(
 
 
 class AllValvesControl(StandardReadable):
-    """
-    The default IOC for this device only controls
-    specific valves. Other valves are under manual
-    control.
+    """The default IOC for this device only controls specific valves. Other valves are
+    under manual control.
     """
 
     def __init__(
@@ -163,12 +163,10 @@ class Pump(StandardReadable):
 
 
 class PressureTransducer(StandardReadable):
-    """
-    Pressure transducer for a high pressure X-ray cell.
+    """Pressure transducer for a high pressure X-ray cell.
     This is the chamber and there are three of them.
     1 is the start, 3 is where the sample is.
     NOTE: the distinction between the adc prefix and the cell prefix is kept here.
-
     """
 
     def __init__(
@@ -201,34 +199,99 @@ class PressureTransducer(StandardReadable):
         super().__init__(name)
 
 
-class PressureJumpCellController(StandardReadable):
-    """
-    Top-level control for a fixed pressure or pressure jumps.
-    """
+class DoJump(StandardReadable, Triggerable):
+    def __init__(
+        self,
+        prefix: str,
+        busy_signal: Reference,
+        timeout_signal: Reference,
+        name: str = "",
+    ):
+        self._busy_signal = busy_signal
+        self._timeout_signal = timeout_signal
 
-    def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.stop = epics_signal_rw(StopState, f"{prefix}STOP")
+            self.set_jump = epics_signal_rw(bool, f"{prefix}SETJUMP")
+
+        self._name = name
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        await set_and_wait_for_other_value(
+            self.set_jump, True, self._busy_signal(), True
+        )
+
+        timeout_value = await self._timeout_signal().get_value()
+        await wait_for_value(self._busy_signal(), False, timeout_value)
 
-            self.target_pressure = epics_signal_rw(float, f"{prefix}TARGET")
-            self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
-            self.go = epics_signal_rw(bool, f"{prefix}GO")
 
-            self.from_pressure = epics_signal_rw(float, f"{prefix}JUMPF")
-            self.to_pressure = epics_signal_rw(float, f"{prefix}JUMPT")
-            self.jump_ready = epics_signal_rw(bool, f"{prefix}SETJUMP")
+class PressureJumpCellController(StandardReadable, Movable, Stoppable):
+    """Top-level control for a fixed pressure or pressure jumps."""
 
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            # Common
+            self.busy = epics_signal_r(bool, f"{prefix}GOTOBUSY")
             self.result = epics_signal_r(str, f"{prefix}RESULT")
+            self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
 
+            # Constant pressure
+            self.target_pressure = epics_signal_rw(int, f"{prefix}TARGET")
+            self.go = epics_signal_rw(bool, f"{prefix}GO")
+
+            # Pressure jump
+            self.from_pressure = epics_signal_rw(int, f"{prefix}JUMPF")
+            self.to_pressure = epics_signal_rw(int, f"{prefix}JUMPT")
+            self.do_jump = DoJump(
+                prefix, Reference(self.busy), Reference(self.timeout), name
+            )
+
+            # Internal
+            self._stop = epics_signal_rw(bool, f"{prefix}STOP")
             self._name = name
+
         super().__init__(name)
 
+    @AsyncStatus.wrap
+    async def set(self, value: int):
+        """Sets the desired pressure waiting for the device to complete the
+        operation.
+        """
+        timeout = await self.timeout.get_value()
+
+        await self.target_pressure.set(value)
+        await set_and_wait_for_other_value(self.go, True, self.busy, True)
+
+        await wait_for_value(self.busy, False, timeout)  # Change complete
 
+    @AsyncStatus.wrap
+    async def stop(self, success=True):
+        await self._stop.set(True)
+
+
+class BusyMock(DeviceMock["PressureJumpCell"]):
+    async def connect(self, device) -> None:
+        async def busy(*_, **__):
+            async def busy_idle():
+                await asyncio.sleep(0)
+                set_mock_value(device.control.busy, True)
+                await asyncio.sleep(0)
+                set_mock_value(device.control.busy, False)
+
+            asyncio.create_task(busy_idle())
+
+        callback_on_mock_put(device.control.go, busy)
+        callback_on_mock_put(device.control.do_jump.set_jump, busy)
+
+
+@default_mock_class(BusyMock)
 class PressureJumpCell(StandardReadable):
-    """
-    High pressure X-ray cell, used to apply pressure or pressure jumps to a sample.
-    prefix: str
-        The prefix of beamline - SPECIAL - unusual that the cell prefix is computed separately
+    """High pressure X-ray cell, used to apply pressure or pressure jumps to a sample.
+
+    Args:
+        prefix (str): The prefix of beamline - SPECIAL - unusual that the cell prefix is
+            computed separately.
     """
 
     def __init__(
@@ -241,9 +304,7 @@ class PressureJumpCell(StandardReadable):
         self.all_valves_control = AllValvesControl(f"{prefix}{cell_prefix}", name)
         self.pump = Pump(f"{prefix}{cell_prefix}", name)
 
-        self.controller = PressureJumpCellController(
-            f"{prefix}{cell_prefix}CTRL:", name
-        )
+        self.control = PressureJumpCellController(f"{prefix}{cell_prefix}CTRL:", name)
 
         with self.add_children_as_readables():
             self.pressure_transducers: DeviceVector[PressureTransducer] = DeviceVector(

dodal/devices/qbpm.py

@@ -3,9 +3,7 @@ from ophyd_async.epics.core import epics_signal_r
 
 
 class QBPM(StandardReadable):
-    """
-    A beam position monitor that gives a position and intensity of the beam.
-    """
+    """A beam position monitor that gives a position and intensity of the beam."""
 
     def __init__(
         self,