dls-dodal 1.65.0__py3-none-any.whl → 1.67.0__py3-none-any.whl

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -9,6 +9,7 @@ from bluesky.protocols import Flyable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
     DeviceVector,
+    Reference,
     StandardReadable,
     observe_value,
     soft_signal_r_and_setter,
@@ -17,6 +18,7 @@ from ophyd_async.core import (
 from ophyd_async.epics.core import epics_signal_r
 from redis.asyncio import StrictRedis
 
+from dodal.devices.oav.oav_detector import OAV
 from dodal.log import LOGGER
 
 
@@ -35,13 +37,10 @@ class Source(IntEnum):
 
 
 class OAVSource(StandardReadable):
-    def __init__(
-        self,
-        prefix: str,
-        oav_name: str,
-    ):
-        self.url = epics_signal_r(str, f"{prefix}MJPG_URL_RBV")
-        self.oav_name = oav_name
+    def __init__(self, oav: OAV, label: str):
+        self.url_ref = Reference(oav.snapshot.video_url)
+        self.oav_ref = Reference(oav)
+        self.label = label
         super().__init__()
 
 
@@ -62,6 +61,8 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
     def __init__(
         self,
         prefix: str,
+        oav_roi: OAV,
+        oav_fs: OAV,
         redis_host: str,
         redis_password: str,
         redis_db: int = 0,
@@ -78,13 +79,13 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
             name: str               the name of this device
         """
         self.counter = epics_signal_r(int, f"{prefix}CAM:ArrayCounter_RBV")
-
         self.sources = DeviceVector(
             {
-                Source.ROI.value: OAVSource(f"{prefix}MJPG:", "roi"),
-                Source.FULL_SCREEN.value: OAVSource(f"{prefix}XTAL:", "fullscreen"),
+                Source.ROI.value: OAVSource(oav_roi, "roi"),
+                Source.FULL_SCREEN.value: OAVSource(oav_fs, "fullscreen"),
             }
         )
+
         self.selected_source = soft_signal_rw(int)
 
         self.forwarding_task = None
@@ -120,11 +121,11 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
         self, function_to_do: Callable[[ClientResponse, OAVSource], Awaitable]
     ):
         source_idx = await self.selected_source.get_value()
+        source = self.sources[source_idx]
+        stream_url = await source.url_ref().get_value()
         LOGGER.info(
-            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_idx}"
+            f"Forwarding data from sample {await self.sample_id.get_value()} and OAV {source_idx} from URL {stream_url}"
         )
-        source = self.sources[source_idx]
-        stream_url = await source.url.get_value()
         async with ClientSession() as session:
             async with session.get(stream_url) as response:
                 await function_to_do(response, source)
@@ -141,12 +142,14 @@ class OAVToRedisForwarder(StandardReadable, Flyable, Stoppable):
             asyncio.wait_for(self._stop_flag.wait(), timeout=self.TIMEOUT)
         )
         async for frame_count in observe_value(self.counter, done_status=done_status):
-            redis_uuid = f"{source.oav_name}-{frame_count}-{uuid4()}"
+            redis_uuid = f"{source.label}-{frame_count}-{uuid4()}"
             await self._get_frame_and_put_to_redis(redis_uuid, response)
 
     async def _confirm_mjpg_stream(self, response: ClientResponse, source: OAVSource):
         if response.content_type != "multipart/x-mixed-replace":
-            raise ValueError(f"{await source.url.get_value()} is not an MJPG stream")
+            raise ValueError(
+                f"{await source.url_ref().get_value()} is not an MJPG stream"
+            )
 
     @AsyncStatus.wrap
     async def kickoff(self):

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -67,6 +67,8 @@ class PinTipDetection(StandardReadable):
         )
         self.canny_upper_threshold = soft_signal_rw(int, 100, name="canny_upper")
         self.canny_lower_threshold = soft_signal_rw(int, 50, name="canny_lower")
+        self.open_ksize = soft_signal_rw(int, 0, name="open_ksize")
+        self.open_iterations = soft_signal_rw(int, 5, name="open_iterations")
         self.close_ksize = soft_signal_rw(int, 5, name="close_ksize")
         self.close_iterations = soft_signal_rw(int, 5, name="close_iterations")
         self.scan_direction = soft_signal_rw(
@@ -105,7 +107,7 @@ class PinTipDetection(StandardReadable):
 
         try:
             preprocess_func = ARRAY_PROCESSING_FUNCTIONS_MAP[preprocess_key](
-                iter=preprocess_iter, ksize=preprocess_ksize
+                iterations=preprocess_iter, ksize=preprocess_ksize
             )
         except KeyError:
             LOGGER.error("Invalid preprocessing function, using identity")
@@ -121,6 +123,8 @@ class PinTipDetection(StandardReadable):
             preprocess=preprocess_func,
             canny_lower=await self.canny_lower_threshold.get_value(),
             canny_upper=await self.canny_upper_threshold.get_value(),
+            open_ksize=await self.open_ksize.get_value(),
+            open_iterations=await self.open_iterations.get_value(),
             close_ksize=await self.close_ksize.get_value(),
             close_iterations=await self.close_iterations.get_value(),
             scan_direction=direction,

dodal/devices/oav/pin_image_recognition/utils.py

@@ -14,6 +14,12 @@ class ScanDirections(Enum):
     REVERSE = -1
 
 
+"""
+See https://opencv24-python-tutorials.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_morphological_ops/py_morphological_ops.html
+for description of functions below.
+"""
+
+
 def identity(*args, **kwargs) -> Callable[[np.ndarray], np.ndarray]:
     return lambda arr: arr
 
@@ -109,6 +115,8 @@ class MxSampleDetect:
         self,
         *,
         preprocess: Callable[[np.ndarray], np.ndarray] = lambda arr: arr,
+        open_ksize: int = 0,
+        open_iterations: int = 5,
         canny_upper: int = 100,
         canny_lower: int = 50,
         close_ksize: int = 5,
@@ -123,6 +131,12 @@ class MxSampleDetect:
             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
@@ -132,6 +146,8 @@ class MxSampleDetect:
         """
 
         self.preprocess = preprocess
+        self.open_ksize = open_ksize
+        self.open_iterations = open_iterations
         self.canny_upper = canny_upper
         self.canny_lower = canny_lower
         self.close_ksize = close_ksize
@@ -148,8 +164,14 @@ class MxSampleDetect:
             assert arr.ndim == 2
             gray_arr = arr
 
+        # Remove Noises if open set to non-zero
+        if self.open_ksize == 0:
+            open_arr = gray_arr
+        else:
+            open_arr = open_morph(self.open_ksize, self.open_iterations)(gray_arr)
+
         # Preprocess the array. (Use the greyscale one.)
-        pp_arr = self.preprocess(gray_arr)
+        pp_arr = self.preprocess(open_arr)
 
         # Find some edges.
         edge_arr = cv2.Canny(pp_arr, self.canny_upper, self.canny_lower)

dodal/devices/oav/snapshots/snapshot_with_grid.py

@@ -12,7 +12,13 @@ from dodal.log import LOGGER
 
 
 class SnapshotWithGrid(MJPG):
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_size_pv: str = "ArraySize1_RBV",
+        y_size_pv: str = "ArraySize2_RBV",
+    ) -> None:
         with self.add_children_as_readables():
             self.top_left_x = soft_signal_rw(float)
             self.top_left_y = soft_signal_rw(float)
@@ -23,7 +29,7 @@ class SnapshotWithGrid(MJPG):
             self.last_path_outer = soft_signal_rw(str)
             self.last_path_full_overlay = soft_signal_rw(str)
 
-        super().__init__(prefix, name)
+        super().__init__(prefix, name, x_size_pv, y_size_pv)
 
     async def post_processing(self, image: Image):
         # Save an unmodified image with no suffix

dodal/devices/oav/utils.py

@@ -5,13 +5,13 @@ import bluesky.plan_stubs as bps
 import numpy as np
 from bluesky.utils import Msg
 
+from dodal.devices.motors import XYZOmegaStage
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
     camera_coordinates_to_xyz_mm,
 )
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
-from dodal.devices.smargon import Smargon
 
 Pixel = tuple[int, int]
 
@@ -52,24 +52,29 @@ class EdgeOutputArrayImageType(IntEnum):
 
 
 def get_move_required_so_that_beam_is_at_pixel(
-    smargon: Smargon, pixel: Pixel, oav: OAV
+    gonio: XYZOmegaStage,
+    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."""
 
     current_motor_xyz = np.array(
         [
-            (yield from bps.rd(smargon.x)),
-            (yield from bps.rd(smargon.y)),
-            (yield from bps.rd(smargon.z)),
+            (yield from bps.rd(gonio.x)),
+            (yield from bps.rd(gonio.y)),
+            (yield from bps.rd(gonio.z)),
         ],
         dtype=np.float64,
     )
-    current_angle = yield from bps.rd(smargon.omega)
+    current_angle = yield from bps.rd(gonio.omega)
 
     beam_x = yield from bps.rd(oav.beam_centre_i)
     beam_y = yield from bps.rd(oav.beam_centre_j)
     microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
     microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
+    x_direction = yield from bps.rd(oav.x_direction)
+    y_direction = yield from bps.rd(oav.y_direction)
+    z_direction = yield from bps.rd(oav.z_direction)
 
     return calculate_x_y_z_of_pixel(
         current_motor_xyz,
@@ -77,6 +82,7 @@ def get_move_required_so_that_beam_is_at_pixel(
         pixel,
         (beam_x, beam_y),
         (microns_per_pixel_x, microns_per_pixel_y),
+        (x_direction, y_direction, z_direction),
     )
 
 
@@ -86,6 +92,7 @@ def calculate_x_y_z_of_pixel(
     pixel: Pixel,
     beam_centre: tuple[int, int],
     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"""
     beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
@@ -96,6 +103,9 @@ def calculate_x_y_z_of_pixel(
         current_omega,
         microns_per_pixel[0],
         microns_per_pixel[1],
+        xyz_direction[0],
+        xyz_direction[1],
+        xyz_direction[2],
     )
 
 

dodal/devices/robot.py

@@ -61,7 +61,7 @@ class ErrorStatus(Device):
             raise RobotLoadError(int(error_code), error_string) from raise_from
 
 
-class BartRobot(StandardReadable, Movable[SampleLocation]):
+class BartRobot(StandardReadable, Movable[SampleLocation | None]):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying
@@ -71,6 +71,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
     LOAD_TIMEOUT = 60
 
     # Error codes that we do special things on
+    NO_ERROR = 0
     NO_PIN_ERROR_CODE = 25
     LIGHT_CURTAIN_TRIPPED = 40
 
@@ -104,7 +105,6 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.init = epics_signal_x(prefix + "INIT.PROC")
         self.soak = epics_signal_x(prefix + "SOAK.PROC")
         self.home = epics_signal_x(prefix + "GOHM.PROC")
-        self.unload = epics_signal_x(prefix + "UNLD.PROC")
         self.dry = epics_signal_x(prefix + "DRY.PROC")
         self.open = epics_signal_x(prefix + "COLO.PROC")
         self.close = epics_signal_x(prefix + "COLC.PROC")
@@ -116,21 +116,25 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         )
         super().__init__(name=name)
 
-    async def pin_mounted_or_no_pin_found(self):
-        """This co-routine will finish when either a pin is detected or the robot gives
-        an error saying no pin was found (whichever happens first). In the case where no
-        pin was found a RobotLoadError error is raised.
+    async def pin_state_or_error(self, expected_state=PinMounted.PIN_MOUNTED):
+        """This co-routine will finish when either the pin sensor reaches the specified
+        state or the robot gives an error (whichever happens first). In the case where
+        there is an error a RobotLoadError error is raised.
         """
 
-        async def raise_if_no_pin():
-            await wait_for_value(self.prog_error.code, self.NO_PIN_ERROR_CODE, None)
-            raise RobotLoadError(self.NO_PIN_ERROR_CODE, "Pin was not detected")
+        async def raise_if_error():
+            await wait_for_value(
+                self.prog_error.code, lambda value: value != self.NO_ERROR, None
+            )
+            error_code = await self.prog_error.code.get_value()
+            error_msg = await self.prog_error.str.get_value()
+            raise RobotLoadError(error_code, error_msg)
 
         async def wfv():
-            await wait_for_value(self.gonio_pin_sensor, PinMounted.PIN_MOUNTED, None)
+            await wait_for_value(self.gonio_pin_sensor, expected_state, None)
 
         tasks = [
-            (Task(raise_if_no_pin())),
+            (Task(raise_if_error())),
             (Task(wfv())),
         ]
         try:
@@ -169,18 +173,29 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         await self.load.trigger()
         if await self.gonio_pin_sensor.get_value() == PinMounted.PIN_MOUNTED:
             LOGGER.info(WAIT_FOR_OLD_PIN_MSG)
-            await wait_for_value(self.gonio_pin_sensor, PinMounted.NO_PIN_MOUNTED, None)
+            await self.pin_state_or_error(PinMounted.NO_PIN_MOUNTED)
         LOGGER.info(WAIT_FOR_NEW_PIN_MSG)
 
-        await self.pin_mounted_or_no_pin_found()
+        await self.pin_state_or_error()
 
     @AsyncStatus.wrap
-    async def set(self, value: SampleLocation):
+    async def set(self, value: SampleLocation | None):
+        """
+        Perform a sample load from the specified sample location
+        Args:
+            value: The pin and puck to load, or None to unload the sample.
+        Raises:
+            RobotLoadError if a timeout occurs, or if an error occurs loading the smaple.
+        """
         try:
-            await wait_for(
-                self._load_pin_and_puck(value),
-                timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
-            )
+            if value is not None:
+                await wait_for(
+                    self._load_pin_and_puck(value),
+                    timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
+                )
+            else:
+                await self.unload.trigger(timeout=self.LOAD_TIMEOUT)
+                await wait_for_value(self.program_running, False, self.NOT_BUSY_TIMEOUT)
         except TimeoutError as e:
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)

dodal/devices/scintillator.py

@@ -8,9 +8,10 @@ from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureVal
 
 
 class InOut(StrictEnum):
-    """Currently Hyperion only needs to move the scintillator out for data collection."""
+    """Moves scintillator in and out of the beam."""
 
-    OUT = "Out"
+    OUT = "Out"  # Out of beam
+    IN = "In"  # In to beam
     UNKNOWN = "Unknown"
 
 
@@ -45,27 +46,46 @@ class Scintillator(StandardReadable):
         self._scintillator_out_yz_mm = [
             float(beamline_parameters[f"scin_{axis}_SCIN_OUT"]) for axis in ("y", "z")
         ]
+        self._scintillator_in_yz_mm = [
+            float(beamline_parameters[f"scin_{axis}_SCIN_IN"]) for axis in ("y", "z")
+        ]
         self._yz_tolerance_mm = [
             float(beamline_parameters[f"scin_{axis}_tolerance"]) for axis in ("y", "z")
         ]
 
         super().__init__(name)
 
-    def _get_selected_position(self, y: float, z: float) -> InOut:
-        current_pos = [y, z]
-        if all(
+    def _check_position(self, current_pos: list[float], pos_to_check: list[float]):
+        return all(
             isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
             for axis_pos, axis_in_beam, axis_tolerance in zip(
                 current_pos,
-                self._scintillator_out_yz_mm,
+                pos_to_check,
                 self._yz_tolerance_mm,
                 strict=False,
             )
-        ):
+        )
+
+    def _get_selected_position(self, y: float, z: float) -> InOut:
+        current_pos = [y, z]
+        if self._check_position(current_pos, self._scintillator_out_yz_mm):
             return InOut.OUT
+
+        elif self._check_position(current_pos, self._scintillator_in_yz_mm):
+            return InOut.IN
+
         else:
             return InOut.UNKNOWN
 
+    async def _check_aperture_parked(self):
+        if (
+            await self._aperture_scatterguard().selected_aperture.get_value()
+            != ApertureValue.PARKED
+        ):
+            raise ValueError(
+                f"Cannot move scintillator if aperture/scatterguard is not parked. Position is currently {await self._aperture_scatterguard().selected_aperture.get_value()}"
+            )
+
     async def _set_selected_position(self, position: InOut) -> None:
         match position:
             case InOut.OUT:
@@ -73,14 +93,16 @@ class Scintillator(StandardReadable):
                 current_z = await self.z_mm.user_readback.get_value()
                 if self._get_selected_position(current_y, current_z) == InOut.OUT:
                     return
-                if (
-                    self._aperture_scatterguard().selected_aperture.get_value()
-                    != ApertureValue.PARKED
-                ):
-                    raise ValueError(
-                        "Cannot move scintillator out if aperture/scatterguard is not parked"
-                    )
+                await self._check_aperture_parked()
                 await self.y_mm.set(self._scintillator_out_yz_mm[0])
                 await self.z_mm.set(self._scintillator_out_yz_mm[1])
+            case InOut.IN:
+                current_y = await self.y_mm.user_readback.get_value()
+                current_z = await self.z_mm.user_readback.get_value()
+                if self._get_selected_position(current_y, current_z) == InOut.IN:
+                    return
+                await self._check_aperture_parked()
+                await self.z_mm.set(self._scintillator_in_yz_mm[1])
+                await self.y_mm.set(self._scintillator_in_yz_mm[0])
             case _:
                 raise ValueError(f"Cannot set scintillator to position {position}")

dodal/devices/smargon.py

@@ -14,7 +14,7 @@ from ophyd_async.core import (
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
 
-from dodal.devices.motors import XYZStage
+from dodal.devices.motors import XYZOmegaStage
 from dodal.devices.util.epics_util import SetWhenEnabled
 
 
@@ -78,7 +78,7 @@ class CombinedMove(TypedDict, total=False):
     chi: float | None
 
 
-class Smargon(XYZStage, Movable):
+class Smargon(XYZOmegaStage, Movable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -92,7 +92,6 @@ class Smargon(XYZStage, Movable):
         with self.add_children_as_readables():
             self.chi = Motor(prefix + "CHI")
             self.phi = Motor(prefix + "PHI")
-            self.omega = Motor(prefix + "OMEGA")
             self.real_x1 = Motor(prefix + "MOTOR_3")
             self.real_x2 = Motor(prefix + "MOTOR_4")
             self.real_y = Motor(prefix + "MOTOR_1")

dodal/devices/thawer.py

@@ -1,59 +1,21 @@
-from asyncio import CancelledError, Task, create_task, sleep
-
 from bluesky.protocols import Movable, Stoppable
 from ophyd_async.core import (
     AsyncStatus,
-    Device,
     OnOff,
-    Reference,
-    SignalRW,
     StandardReadable,
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.log import LOGGER
-
-
-class ThawingTimer(Device, Stoppable, Movable[float]):
-    def __init__(self, control_signal: SignalRW[OnOff]) -> None:
-        self._control_signal_ref = Reference(control_signal)
-        self._thawing_task: Task | None = None
-        super().__init__("thaw_for_time_s")
 
-    @AsyncStatus.wrap
-    async def set(self, value: float):
-        if self._thawing_task:
-            LOGGER.info("Thawing task already in progress, resetting timer")
-            self._thawing_task.cancel()
-        else:
-            LOGGER.info("Thawing started")
-            await self._control_signal_ref().set(OnOff.ON)
-        self._thawing_task = create_task(sleep(value))
-        try:
-            await self._thawing_task
-        except CancelledError:
-            LOGGER.info("Timer task cancelled.")
-            raise
-        else:
-            LOGGER.info("Thawing completed")
-            await self._control_signal_ref().set(OnOff.OFF)
-
-    @AsyncStatus.wrap
-    async def stop(self, *args, **kwargs):
-        if self._thawing_task:
-            self._thawing_task.cancel()
-            self._thawing_task = None
-        LOGGER.info("Thawer stopped.")
-        await self._control_signal_ref().set(OnOff.OFF)
-
-
-class Thawer(StandardReadable, Stoppable):
+class Thawer(StandardReadable, Stoppable, Movable[OnOff]):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.control = epics_signal_rw(OnOff, prefix + ":CTRL")
-        self.thaw_for_time_s = ThawingTimer(self.control)
+        self._control = epics_signal_rw(OnOff, prefix + ":CTRL")
         super().__init__(name)
 
+    @AsyncStatus.wrap
+    async def set(self, value: OnOff):
+        await self._control.set(value)
+
     @AsyncStatus.wrap
     async def stop(self, *args, **kwargs):
-        await self.thaw_for_time_s.stop()
-        await self.control.set(OnOff.OFF)
+        await self._control.set(OnOff.OFF)