dls-dodal 1.46.0__py3-none-any.whl → 1.48.0__py3-none-any.whl

dodal/devices/i04/murko_results.py

@@ -0,0 +1,192 @@
+import json
+import pickle
+from enum import Enum
+from typing import TypedDict
+
+import numpy as np
+from bluesky.protocols import Stageable, Triggerable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from redis.asyncio import StrictRedis
+
+from dodal.devices.i04.constants import RedisConstants
+from dodal.devices.oav.oav_calculations import (
+    calculate_beam_distance,
+)
+from dodal.log import LOGGER
+
+NO_MURKO_RESULT = (-1, -1)
+
+MurkoResult = dict
+FullMurkoResults = dict[str, list[MurkoResult]]
+
+
+class MurkoMetadata(TypedDict):
+    zoom_percentage: float
+    microns_per_x_pixel: float
+    microns_per_y_pixel: float
+    beam_centre_i: int
+    beam_centre_j: int
+    sample_id: str
+    omega_angle: float
+    uuid: str
+
+
+class Coord(Enum):
+    x = 0
+    y = 1
+    z = 2
+
+
+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.
+    The most_likely_click[1] value from Murko corresponds with the x coordinate of the
+    sample. The most_likely_click[0] value from Murko corresponds with a component of
+    the y and z coordinates of the sample, depending on the omega angle, as the sample
+    is rotated around the x axis.
+
+    Given a most_likely_click value at a certain omega angle θ:
+    most_likely_click[1] = x
+    most_likely_click[0] = cos(θ)y - sin(θ)z
+
+    A value for x can be found by averaging all most_likely_click[1] values, and
+    solutions for y and z can be calculated using numpy's linear algebra library.
+    """
+
+    TIMEOUT_S = 2
+
+    def __init__(
+        self,
+        redis_host=RedisConstants.REDIS_HOST,
+        redis_password=RedisConstants.REDIS_PASSWORD,
+        redis_db=RedisConstants.MURKO_REDIS_DB,
+        name="",
+        stop_angle=350,
+    ):
+        self.redis_client = StrictRedis(
+            host=redis_host,
+            password=redis_password,
+            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 = []
+
+        with self.add_children_as_readables():
+            # Diffs from current x/y/z
+            self.x_mm, self._x_mm_setter = soft_signal_r_and_setter(float)
+            self.y_mm, self._y_mm_setter = soft_signal_r_and_setter(float)
+            self.z_mm, self._z_mm_setter = soft_signal_r_and_setter(float)
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def stage(self):
+        await self.pubsub.subscribe("murko-results")
+        self._x_mm_setter(0)
+        self._y_mm_setter(0)
+        self._z_mm_setter(0)
+
+    @AsyncStatus.wrap
+    async def unstage(self):
+        await self.pubsub.unsubscribe()
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        # Wait for results
+        sample_id = await self.sample_id.get_value()
+        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
+            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)}"
+            )
+
+        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, 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)
+        self._z_mm_setter(-best_z)
+
+    async def process_batch(self, message: dict | None, sample_id: str):
+        if message and message["type"] == "message":
+            batch_results: list[dict] = pickle.loads(message["data"])
+            for results in batch_results:
+                for uuid, result in results.items():
+                    if metadata_str := await self.redis_client.hget(  # type: ignore
+                        f"murko:{sample_id}:metadata", uuid
+                    ):
+                        LOGGER.info(
+                            f"Found metadata for uuid {uuid}, processing result"
+                        )
+                        self.process_result(
+                            result, MurkoMetadata(json.loads(metadata_str))
+                        )
+                    else:
+                        LOGGER.info(f"Found no metadata for uuid {uuid}")
+
+    def process_result(self, result: dict, metadata: MurkoMetadata):
+        """Uses the 'most_likely_click' coordinates from Murko to calculate the
+        horizontal and vertical distances from the beam centre, and store these values
+        as well as the omega angle the image was taken at.
+        """
+        omega = metadata["omega_angle"]
+        coords = result["most_likely_click"]  # As proportion from top, left of image
+        LOGGER.info(f"Got most_likely_click: {coords} at angle {omega}")
+        if (
+            tuple(coords) == NO_MURKO_RESULT
+        ):  # See https://github.com/MartinSavko/murko/issues/9
+            LOGGER.info("Murko didn't produce a result, moving on")
+        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])
+
+            beam_dist_px = calculate_beam_distance(
+                (metadata["beam_centre_i"], metadata["beam_centre_j"]),
+                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.omegas.append(omega)
+            self._last_omega = omega
+
+
+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.
+
+    Args:
+        v_dists (list): List of vertical distances from beam centre. Any units
+        omegas (list): List of omega angles in degrees.
+
+    Returns:
+        tuple[float, float]: y, z distances from centre, in whichever units
+        v_dists came as.
+    """
+    thetas = np.radians(omegas)
+    matrix = np.column_stack([np.cos(thetas), -np.sin(thetas)])
+
+    yz, residuals, rank, s = np.linalg.lstsq(matrix, vertical_dists, rcond=None)
+    y, z = yz
+    return y, z

dodal/devices/i10/diagnostics.py

@@ -1,6 +1,4 @@
-from bluesky.protocols import Movable
 from ophyd_async.core import (
-    AsyncStatus,
     Device,
     StandardReadable,
     StrictEnum,
@@ -13,7 +11,6 @@ from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
 )
-from ophyd_async.epics.motor import Motor
 
 from dodal.devices.current_amplifiers import (
     CurrentAmpDet,
@@ -23,6 +20,7 @@ from dodal.devices.current_amplifiers import (
     FemtoDDPCA,
     StruckScaler,
 )
+from dodal.devices.positioner import create_positioner
 
 
 class D3Position(StrictEnum):
@@ -70,36 +68,6 @@ class InOutReadBackTable(StrictEnum):
     OUT_OF_BEAM = "Out of Beam"
 
 
-class Positioner(StandardReadable, Movable):
-    """1D stage with a enum table to select positions."""
-
-    def __init__(
-        self,
-        prefix: str,
-        positioner_enum: type[StrictEnum],
-        positioner_suffix: str = "",
-        Positioner_pv_suffix: str = ":MP:SELECT",
-        name: str = "",
-    ) -> None:
-        self._stage_motion = Motor(prefix=prefix + positioner_suffix)
-        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.stage_position = epics_signal_rw(
-                positioner_enum,
-                read_pv=prefix + positioner_suffix + Positioner_pv_suffix,
-            )
-        super().__init__(name=name)
-        self.positioner_enum = positioner_enum
-
-    @AsyncStatus.wrap
-    async def set(self, value: StrictEnum) -> None:
-        if value in self.positioner_enum:
-            await self.stage_position.set(value=value)
-        else:
-            raise ValueError(
-                f"{value} is not an allow position. Position must be: {self.positioner_enum}"
-            )
-
-
 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.
@@ -154,16 +122,13 @@ class FullDiagnostic(Device):
         self,
         prefix: str,
         positioner_enum: type[StrictEnum],
-        positioner_suffix: str = "",
-        Positioner_pv_suffix: str = ":MP:SELECT",
+        positioner_suffix: str,
         cam_infix: str = "DCAM:",
         name: str = "",
     ) -> None:
-        self.positioner = Positioner(
-            prefix=prefix,
-            positioner_enum=positioner_enum,
-            positioner_suffix=positioner_suffix,
-            Positioner_pv_suffix=Positioner_pv_suffix,
+        self.positioner = create_positioner(
+            positioner_enum,
+            prefix + positioner_suffix,
         )
         self.screen = ScreenCam(
             prefix,
@@ -185,28 +150,11 @@ class I10Diagnostic(Device):
             positioner_suffix="DET:X",
         )
         self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
-        self.d5 = Positioner(
-            prefix=prefix + "IONC-01:",
-            positioner_enum=D5Position,
-            positioner_suffix="Y",
-        )
-
-        self.d5A = Positioner(
-            prefix=prefix + "PHDGN-06:",
-            positioner_enum=D5APosition,
-            positioner_suffix="DET:X",
-        )
+        self.d5 = create_positioner(D5Position, 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")
 
-        self.d6 = FullDiagnostic(
-            prefix=prefix + "PHDGN-05:",
-            positioner_enum=D6Position,
-            positioner_suffix="DET:X",
-        )
-        self.d7 = Positioner(
-            prefix=prefix + "PHDGN-07:",
-            positioner_enum=D7Position,
-            positioner_suffix="Y",
-        )
         super().__init__(name)
 
 

dodal/devices/i18/diode.py

@@ -1,8 +1,36 @@
-from ophyd_async.core import (
-    StandardReadable,
-)
+from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_r
 
+from dodal.devices.positioner import create_positioner
+
+
+class FilterAValues(StrictEnum):
+    """Maps from a short usable name to the string name in EPICS"""
+
+    AL_2MM = "2 mm Al"
+    AL_1_5MM = "1.5 mm Al"
+    AL_1_25MM = "1.25 mm Al"
+    AL_0_8MM = "0.8 mm Al"
+    AL_0_55MM = "0.55 mm Al"
+    AL_0_5MM = "0.5 mm Al"
+    AL_0_3MM = "0.3 mm Al"
+    AL_0_25MM = "0.25 mm Al"
+    AL_0_15MM = "0.15 mm Al"
+    AL_0_1MM = "0.1 mm Al"
+    AL_0_05MM = "0.05 mm Al"
+    AL_0_025MM = "0.025 mm Al"
+    AL_GAP = "Gap"
+
+
+class FilterBValues(StrictEnum):
+    DIAMOND_THIN = "Diamond thin"
+    DIAMOND_THICK = "Diamond thick"
+    NI_DRAIN = "ni drain"
+    AU_DRAIN = "au drain"
+    AL_DRAIN = "al drain"
+    GAP = "Gap"
+    IN_LINE_DIODE = "in line diode"
+
 
 class Diode(StandardReadable):
     def __init__(
@@ -10,8 +38,13 @@ class Diode(StandardReadable):
         prefix: str,
         name: str = "",
     ):
-        self._prefix = prefix
         with self.add_children_as_readables():
             self.signal = epics_signal_r(float, prefix + "B:DIODE:I")
+            self.positioner_a = create_positioner(
+                FilterAValues, prefix + "A:MP", positioner_pv_suffix=":SELECT"
+            )  # more complex, will be fixed on Tuesday 20.05.2025
+            self.positioner_b = create_positioner(
+                FilterBValues, prefix + "B:MP", positioner_pv_suffix=":SELECT"
+            )
 
         super().__init__(name=name)

dodal/devices/i24/focus_mirrors.py

@@ -1,8 +1,6 @@
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import StandardReadable, StrictEnum, derived_signal_r
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
-
 
 class HFocusMode(StrictEnum):
     FOCUS_10 = "HMFMfocus10"
@@ -40,21 +38,19 @@ class FocusMirrorsMode(StandardReadable):
         self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
 
         with self.add_children_as_readables():
-            self.beam_size_x = create_r_hardware_backed_soft_signal(
-                int, self._get_beam_size_x, units="um"
+            self.beam_size_x = derived_signal_r(
+                self._get_beam_size_x, horizontal=self.horizontal, derived_units="um"
             )
-            self.beam_size_y = create_r_hardware_backed_soft_signal(
-                int, self._get_beam_size_y, units="um"
+            self.beam_size_y = derived_signal_r(
+                self._get_beam_size_y, vertical=self.vertical, derived_units="um"
             )
 
         super().__init__(name)
 
-    async def _get_beam_size_x(self) -> int:
-        h_mode = await self.horizontal.get_value()
-        beam_x = BEAM_SIZES[h_mode.removeprefix("HMFM")][0]
+    def _get_beam_size_x(self, horizontal: HFocusMode) -> int:
+        beam_x = BEAM_SIZES[horizontal.removeprefix("HMFM")][0]
         return beam_x
 
-    async def _get_beam_size_y(self) -> int:
-        v_mode = await self.vertical.get_value()
-        beam_y = BEAM_SIZES[v_mode.removeprefix("VMFM")][1]
+    def _get_beam_size_y(self, vertical: VFocusMode) -> int:
+        beam_y = BEAM_SIZES[vertical.removeprefix("VMFM")][1]
         return beam_y

dodal/devices/i24/pilatus_metadata.py

@@ -2,11 +2,9 @@
 
 import re
 
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, derived_signal_r
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
-
 
 class PilatusMetadata(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -14,21 +12,23 @@ class PilatusMetadata(StandardReadable):
         self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
         self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
         with self.add_children_as_readables():
-            self.filename_template = create_r_hardware_backed_soft_signal(
-                str, self._get_full_filename_template
+            self.filename_template = derived_signal_r(
+                self._get_full_filename_template,
+                filename=self.filename,
+                filename_template=self.template,
+                file_number=self.filenumber,
             )
         super().__init__(name)
 
-    async def _get_full_filename_template(self) -> str:
+    def _get_full_filename_template(
+        self, filename: str, filename_template: str, file_number: int
+    ) -> str:
         """
         Get the template file path by querying the detector PVs.
         Mirror the construction that the PPU does.
 
         Returns: A template string, with the image numbers replaced with '#'
         """
-        filename = await self.filename.get_value()
-        filename_template = await self.template.get_value()
-        file_number = await self.filenumber.get_value()
         # Exploit fact that passing negative numbers will put the - before the 0's
         expected_filename = str(
             filename_template % (filename, f"{file_number:05d}_", -9)

dodal/devices/i24/pmac.py

@@ -10,6 +10,7 @@ from ophyd_async.core import (
     SignalR,
     SignalRW,
     StandardReadable,
+    observe_signals_value,
     soft_signal_rw,
     wait_for_value,
 )
@@ -120,15 +121,16 @@ class ProgramRunner(Device, Flyable):
         self,
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
+        counter_sig: SignalR,
         prog_num_sig: SignalRW,
-        collection_time_sig: SignalRW,
+        counter_time_sig: SignalRW,
         name: str = "",
     ) -> None:
         self._signal_ref = Reference(pmac_str_sig)
         self._status_ref = Reference(status_sig)
+        self._counter_ref = Reference(counter_sig)
         self._prog_num_ref = Reference(prog_num_sig)
-
-        self._collection_time_ref = Reference(collection_time_sig)
+        self._counter_time_ref = Reference(counter_time_sig)
 
         super().__init__(name)
 
@@ -151,16 +153,18 @@ class ProgramRunner(Device, Flyable):
 
     @AsyncStatus.wrap
     async def complete(self):
-        """Stop collecting when the scan status PV goes to 0.
-
-        Args:
-            complete_time (float): total time required by the collection to \
-            finish correctly.
+        """Stop collecting when the scan status PV goes to 0 or when counter PV hasn't \
+            updated for 30 seconds.
         """
-        scan_complete_time = await self._collection_time_ref().get_value()
-        await wait_for_value(
-            self._status_ref(), ScanState.DONE, timeout=scan_complete_time
-        )
+        counter_time = await self._counter_time_ref().get_value()
+        async for signal, value in observe_signals_value(
+            self._status_ref(),
+            self._counter_ref(),
+            timeout=counter_time,
+        ):
+            if signal is self._status_ref():
+                if value == ScanState.DONE:
+                    break
 
 
 class ProgramAbort(Triggerable):
@@ -217,13 +221,14 @@ class PMAC(StandardReadable):
         # A couple of soft signals for running a collection: program number to send to
         # the PMAC_STRING and expected collection time.
         self.program_number = soft_signal_rw(int)
-        self.collection_time = soft_signal_rw(float, initial_value=600.0, units="s")
+        self.counter_time = soft_signal_rw(float, initial_value=30.0, units="s")
 
         self.run_program = ProgramRunner(
             self.pmac_string,
             self.scanstatus,
+            self.counter,
             self.program_number,
-            self.collection_time,
+            self.counter_time,
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 

dodal/devices/{i03 → mx_phase1}/beamstop.py

@@ -1,11 +1,14 @@
-from asyncio import gather
+import asyncio
 from math import isclose
 
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import (
+    StandardReadable,
+    StrictEnum,
+    derived_signal_rw,
+)
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class BeamstopPositions(StrictEnum):
@@ -33,14 +36,13 @@ class BeamstopPositions(StrictEnum):
 
 class Beamstop(StandardReadable):
     """
-    Beamstop for I03.
+    Beamstop for I03 and I04.
 
     Attributes:
         x: beamstop x position in mm
         y: beamstop y position in mm
         z: beamstop z position in mm
-        selected_pos: Get the current position of the beamstop as an enum. Currently this
-            is read-only.
+        selected_pos: Get or set the current position of the beamstop as an enum.
     """
 
     def __init__(
@@ -53,10 +55,13 @@ class Beamstop(StandardReadable):
             self.x_mm = Motor(prefix + "X")
             self.y_mm = Motor(prefix + "Y")
             self.z_mm = Motor(prefix + "Z")
-            self.selected_pos = create_r_hardware_backed_soft_signal(
-                BeamstopPositions, self._get_selected_position
+            self.selected_pos = derived_signal_rw(
+                self._get_selected_position,
+                self._set_selected_position,
+                x=self.x_mm,
+                y=self.y_mm,
+                z=self.z_mm,
             )
-
         self._in_beam_xyz_mm = [
             float(beamline_parameters[f"in_beam_{axis}_STANDARD"])
             for axis in ("x", "y", "z")
@@ -68,12 +73,8 @@ class Beamstop(StandardReadable):
 
         super().__init__(name)
 
-    async def _get_selected_position(self) -> BeamstopPositions:
-        current_pos = await gather(
-            self.x_mm.user_readback.get_value(),
-            self.y_mm.user_readback.get_value(),
-            self.z_mm.user_readback.get_value(),
-        )
+    def _get_selected_position(self, x: float, y: float, z: float) -> BeamstopPositions:
+        current_pos = [x, y, z]
         if all(
             isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
             for axis_pos, axis_in_beam, axis_tolerance in zip(
@@ -83,3 +84,13 @@ class Beamstop(StandardReadable):
             return BeamstopPositions.DATA_COLLECTION
         else:
             return BeamstopPositions.UNKNOWN
+
+    async def _set_selected_position(self, position: BeamstopPositions) -> None:
+        if position == BeamstopPositions.DATA_COLLECTION:
+            await asyncio.gather(
+                self.x_mm.set(self._in_beam_xyz_mm[0]),
+                self.y_mm.set(self._in_beam_xyz_mm[1]),
+                self.z_mm.set(self._in_beam_xyz_mm[2]),
+            )
+        elif position == BeamstopPositions.UNKNOWN:
+            raise ValueError(f"Cannot set beamstop to position {position}")

dodal/devices/oav/oav_calculations.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 
-def camera_coordinates_to_xyz(
+def camera_coordinates_to_xyz_mm(
     horizontal: float,
     vertical: float,
     omega: float,
@@ -9,7 +9,7 @@ def camera_coordinates_to_xyz(
     microns_per_j_pixel: float,
 ) -> np.ndarray:
     """
-    Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millmeters.
+    Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millimetres.
     For an overview of the coordinate system for I03 see https://github.com/DiamondLightSource/hyperion/wiki/Gridscan-Coordinate-System.
 
     Args: