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

dodal/devices/i04/murko_results.py

@@ -32,6 +32,7 @@ class MurkoMetadata(TypedDict):
     sample_id: str
     omega_angle: float
     uuid: str
+    used_for_centring: bool | None
 
 
 class Coord(Enum):
@@ -47,6 +48,7 @@ class MurkoResult:
     y_dist_mm: float
     omega: float
     uuid: str
+    metadata: MurkoMetadata
 
 
 class NoResultsFound(ValueError):
@@ -101,7 +103,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
     def _reset(self):
         self._last_omega = 0
-        self.results: list[MurkoResult] = []
+        self._results: list[MurkoResult] = []
 
     @AsyncStatus.wrap
     async def stage(self):
@@ -126,17 +128,17 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
                 continue
             await self.process_batch(message, sample_id)
 
-        if not self.results:
+        if not self._results:
             raise NoResultsFound("No results retrieved from Murko")
 
-        for result in self.results:
+        for result in self._results:
             LOGGER.debug(result)
 
-        self.filter_outliers()
+        filtered_results = self.filter_outliers()
 
-        x_dists_mm = [result.x_dist_mm for result in self.results]
-        y_dists_mm = [result.y_dist_mm for result in self.results]
-        omegas = [result.omega for result in self.results]
+        x_dists_mm = [result.x_dist_mm for result in filtered_results]
+        y_dists_mm = [result.y_dist_mm for result in filtered_results]
+        omegas = [result.omega for result in filtered_results]
 
         LOGGER.info(f"Using average of x beam distances: {x_dists_mm}")
         avg_x = float(np.mean(x_dists_mm))
@@ -147,6 +149,11 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         self._y_mm_setter(-best_y)
         self._z_mm_setter(-best_z)
 
+        for result in self._results:
+            await self.redis_client.hset(  # type: ignore
+                f"murko:{sample_id}:metadata", result.uuid, json.dumps(result.metadata)
+            )
+
     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"])
@@ -186,13 +193,14 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
                 centre_px[0],
                 centre_px[1],
             )
-            self.results.append(
+            self._results.append(
                 MurkoResult(
                     centre_px=centre_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,
                     uuid=metadata["uuid"],
+                    metadata=metadata,
                 )
             )
             self._last_omega = omega
@@ -203,8 +211,8 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         meaning that by keeping only a percentage of the results with the smallest X we
         remove many of the outliers.
         """
-        LOGGER.info(f"Number of results before filtering: {len(self.results)}")
-        sorted_results = sorted(self.results, key=lambda item: item.centre_px[0])
+        LOGGER.info(f"Number of results before filtering: {len(self._results)}")
+        sorted_results = sorted(self._results, key=lambda item: item.centre_px[0])
 
         worst_results = [
             r.uuid for r in sorted_results[-self.NUMBER_OF_WRONG_RESULTS_TO_LOG :]
@@ -214,9 +222,13 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             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
+
         smallest_x = sorted_results[:cutoff]
-        self.results = smallest_x
-        LOGGER.info(f"Number of results after filtering: {len(self.results)}")
+
+        LOGGER.info(f"Number of results after filtering: {len(smallest_x)}")
+        return smallest_x
 
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:

dodal/devices/i10/i10_apple2.py

@@ -19,10 +19,9 @@ from ophyd_async.core import (
 )
 from pydantic import BaseModel, ConfigDict, RootModel
 
-from dodal.log import LOGGER
-
-from ..apple2_undulator import (
+from dodal.devices.apple2_undulator import (
     Apple2,
+    Apple2Motors,
     Apple2Val,
     EnergyMotorConvertor,
     Pol,
@@ -30,6 +29,8 @@ from ..apple2_undulator import (
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
+from dodal.log import LOGGER
+
 from ..pgm import PGM
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
@@ -359,14 +360,15 @@ class I10Apple2(Apple2):
 
         with self.add_children_as_readables():
             super().__init__(
-                id_gap=UndulatorGap(name="id_gap", prefix=prefix),
-                id_phase=UndulatorPhaseAxes(
-                    name="id_phase",
-                    prefix=prefix,
-                    top_outer="RPQ1",
-                    top_inner="RPQ2",
-                    btm_inner="RPQ3",
-                    btm_outer="RPQ4",
+                apple2_motors=Apple2Motors(
+                    id_gap=UndulatorGap(prefix=prefix),
+                    id_phase=UndulatorPhaseAxes(
+                        prefix=prefix,
+                        top_outer="RPQ1",
+                        top_inner="RPQ2",
+                        btm_inner="RPQ3",
+                        btm_outer="RPQ4",
+                    ),
                 ),
                 energy_motor_convertor=energy_motor_convertor,
                 name=name,
@@ -376,8 +378,7 @@ class I10Apple2(Apple2):
                 move_pv="RPQ1",
             )
 
-    @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
+    async def _set(self, value: float) -> None:
         """
         Check polarisation state and use it together with the energy(value)
         to calculate the required gap and phases before setting it.
@@ -408,11 +409,10 @@ class I10Apple2(Apple2):
         )
 
         LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self._set(value=id_set_val, energy=value)
+        await self.motors.set(id_motor_values=id_set_val)
         if pol != Pol.LA:
             await self.id_jaw_phase.set(0)
             await self.id_jaw_phase.set_move.set(1)
-        LOGGER.info(f"Energy set to {value} eV successfully.")
 
 
 class EnergySetter(StandardReadable, Movable[float]):

dodal/devices/i15/dcm.py

@@ -0,0 +1,77 @@
+from typing import Generic, TypeVar
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.common_dcm import (
+    StationaryCrystal,
+)
+
+
+class ThetaYCrystal(StationaryCrystal):
+    def __init__(self, prefix):
+        with self.add_children_as_readables():
+            self.theta = Motor(prefix + "THETA")
+            self.y = Motor(prefix + "Y")
+        super().__init__(prefix)
+
+
+class ThetaRollYZCrystal(ThetaYCrystal):
+    def __init__(self, prefix):
+        with self.add_children_as_readables():
+            self.roll = Motor(prefix + "ROLL")
+            self.z = Motor(prefix + "Z")
+        super().__init__(prefix)
+
+
+Xtal_1 = TypeVar("Xtal_1", bound=StationaryCrystal)
+Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
+
+
+class DualCrystalMonoSimple(StandardReadable, Generic[Xtal_1, Xtal_2]):
+    """
+    Device for simple double crystal monochromators (DCM), which only allow energy of the beam to be selected.
+
+    Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
+    each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
+    This base device accounts for all combinations of this.
+
+    This device is more able to act as a parent for beamline-specific DCM's, in which any other missing signals can be added,
+    as it doesn't assume WAVELENGTH, BRAGG and OFFSET are available for all DCM deivces, as BaseDCM does.
+
+    Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan
+    which only requires one crystal which can roll should be typed 'def my_plan(dcm: BaseDCM[RollCrystal, StationaryCrystal])`
+    """
+
+    def __init__(
+        self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2], name: str = ""
+    ) -> None:
+        with self.add_children_as_readables():
+            # Virtual motor PV's which set the physical motors so that the DCM produces requested
+            # wavelength/energy
+            self.energy_in_kev = Motor(prefix + "ENERGY")
+            self._make_crystals(prefix, xtal_1, xtal_2)
+
+        super().__init__(name)
+
+    # Prefix convention is different depending on whether there are one or two controllable crystals
+    def _make_crystals(self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2]):
+        if StationaryCrystal not in [xtal_1, xtal_2]:
+            self.xtal_1 = xtal_1(f"{prefix}XTAL1:")
+            self.xtal_2 = xtal_2(f"{prefix}XTAL2:")
+        else:
+            self.xtal_1 = xtal_1(prefix)
+            self.xtal_2 = xtal_2(prefix)
+
+
+class DCM(DualCrystalMonoSimple[ThetaRollYZCrystal, ThetaYCrystal]):
+    """
+    A double crystal monocromator device, used to select the beam energy.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.calibrated_energy_in_kev = Motor(prefix + "CAL")
+            self.x1 = Motor(prefix + "X1")
+
+        super().__init__(prefix, ThetaRollYZCrystal, ThetaYCrystal, name)

dodal/devices/i15/focussing_mirror.py

@@ -0,0 +1,55 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class FocusingMirrorBase(StandardReadable):
+    """Focusing Mirror with curve, ellip & pitch"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.curve = Motor(prefix + "CURVE")
+            self.ellipticity = Motor(prefix + "ELLIP")
+            self.pitch = Motor(prefix + "PITCH")
+
+        super().__init__(name)
+
+
+class FocusingMirrorHorizontal(FocusingMirrorBase):
+    """Focusing Mirror with curve, ellip, pitch & X"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+
+        super().__init__(prefix, name)
+
+
+class FocusingMirrorVertical(FocusingMirrorBase):
+    """Focusing Mirror with curve, ellip, pitch & Y"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.y = Motor(prefix + "Y")
+
+        super().__init__(prefix, name)
+
+
+class FocusingMirror(FocusingMirrorBase):
+    """Focusing Mirror with curve, ellip, pitch, yaw, X & Y"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.yaw = Motor(prefix + "YAW")
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+
+        super().__init__(prefix, name)
+
+
+class FocusingMirrorWithRoll(FocusingMirror):
+    """Focusing Mirror with curve, ellip, pitch, roll, yaw, X & Y"""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.roll = Motor(prefix + "ROLL")
+        super().__init__(prefix, name)

dodal/devices/i15/jack.py

@@ -0,0 +1,31 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class JackX(StandardReadable):
+    """Focusing Mirror"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.rotation = Motor(prefix + "Ry")
+            self.transx = Motor(prefix + "X")
+            self.y1 = Motor(prefix + "Y1")
+            self.y2 = Motor(prefix + "Y2")
+            self.y3 = Motor(prefix + "Y3")
+
+        super().__init__(name)
+
+
+class JackY(StandardReadable):
+    """Focusing Mirror"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.j1 = Motor(prefix + "J1")
+            self.j2 = Motor(prefix + "J2")
+            self.j3 = Motor(prefix + "J3")
+            self.pitch = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.y = Motor(prefix + "Y")
+
+        super().__init__(name)

dodal/devices/i15/laue.py

@@ -0,0 +1,14 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class LaueMonochrometer(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.bend = Motor(prefix + "BENDER")
+            self.bragg = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.yaw = Motor(prefix + "YAW")
+            self.y = Motor(prefix + "Y")
+
+        super().__init__(name)

dodal/devices/i15/motors.py

@@ -0,0 +1,27 @@
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import Stage
+
+
+class UpstreamDownstreamPair(Stage):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.upstream = Motor(prefix + "US")
+            self.downstream = Motor(prefix + "DS")
+        super().__init__(name=name)
+
+
+class NumberedTripleAxisStage(Stage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        axis1_infix: str = "AXIS1",
+        axis2_infix: str = "AXIS2",
+        axis3_infix: str = "AXIS3",
+    ):
+        with self.add_children_as_readables():
+            self.axis1 = Motor(prefix + axis1_infix)
+            self.axis2 = Motor(prefix + axis2_infix)
+            self.axis3 = Motor(prefix + axis3_infix)
+        super().__init__(name=name)

dodal/devices/i15/multilayer_mirror.py

@@ -0,0 +1,21 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class MultiLayerMirror(StandardReadable):
+    """Multilayer Mirror"""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.ds_x = Motor(prefix + "X2")
+            self.ds_y = Motor(prefix + "J3")
+            self.ib_y = Motor(prefix + "J1")
+            self.ob_y = Motor(prefix + "J2")
+            self.pitch = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.us_x = Motor(prefix + "X1")
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+            self.yaw = Motor(prefix + "YAW")
+
+        super().__init__(name)

dodal/devices/i15/rail.py

@@ -0,0 +1,13 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class Rail(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + "PITCH")
+            self.y = Motor(prefix + "Y")
+            self.y1 = Motor(prefix + "Y1")
+            self.y2 = Motor(prefix + "Y2")
+
+        super().__init__(name)

dodal/devices/i24/commissioning_jungfrau.py

@@ -5,11 +5,13 @@ from pathlib import Path
 from bluesky.protocols import StreamAsset
 from event_model import DataKey  # type: ignore
 from ophyd_async.core import (
+    AsyncStatus,
     AutoIncrementingPathProvider,
     DetectorWriter,
     StandardDetector,
     StandardReadable,
     StaticPathProvider,
+    TriggerInfo,
     observe_value,
     wait_for_value,
 )
@@ -40,6 +42,7 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
             self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
             self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
             self.writer_ready = epics_signal_r(int, f"{prefix}Ready_RBV")
+            self.expected_frames = epics_signal_rw(int, f"{prefix}NumCapture")
         super().__init__(name)
 
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
@@ -80,7 +83,7 @@ class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
     async def observe_indices_written(
         self, timeout: float
     ) -> AsyncGenerator[int, None]:
-        timeout = timeout * 2  # This filewriter is slow
+        timeout = timeout * 4  # This filewriter is very slow
         async for num_captured in observe_value(self.frame_counter, timeout):
             yield num_captured // (self._exposures_per_event)
 
@@ -112,3 +115,8 @@ class CommissioningJungfrau(
         writer = JunfrauCommissioningWriter(writer_prefix, path_provider)
         controller = JungfrauController(self.drv)
         super().__init__(controller, writer, name=name)
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: TriggerInfo) -> None:
+        await super().prepare(value)
+        await self._writer.expected_frames.set(value.total_number_of_exposures)

dodal/devices/motors.py

@@ -70,13 +70,27 @@ class XYZThetaStage(XYZStage):
         x_infix: str = _X,
         y_infix: str = _Y,
         z_infix: str = _Z,
-        theta_infix: str = _Z,
+        theta_infix: str = "THETA",
     ) -> None:
         with self.add_children_as_readables():
             self.theta = Motor(prefix + theta_infix)
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
+class XYPhiStage(XYStage):
+    def __init__(
+        self,
+        prefix: str,
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        phi_infix: str = "PHI",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.phi = Motor(prefix + phi_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
+
+
 class XYPitchStage(XYStage):
     def __init__(
         self,
@@ -91,6 +105,23 @@ class XYPitchStage(XYStage):
         super().__init__(prefix, name, x_infix, y_infix)
 
 
+class XYZPitchYawStage(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        pitch_infix="PITCH",
+        yaw_infix="YAW",
+    ):
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + pitch_infix)
+            self.yaw = Motor(prefix + yaw_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class XYZPitchYawRollStage(XYZStage):
     def __init__(
         self,
@@ -136,6 +167,26 @@ class SixAxisGonio(XYZStage):
         )
 
 
+class SixAxisGonioKappaPhi(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        kappa_infix: str = "KAPPA",
+        phi_infix: str = "PHI",
+    ):
+        """Six-axis goniometer with a standard xyz stage and two axes of rotation:
+        kappa and phi.
+        """
+        with self.add_children_as_readables():
+            self.kappa = Motor(prefix + kappa_infix)
+            self.phi = Motor(prefix + phi_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class YZStage(Stage):
     def __init__(
         self, prefix: str, name: str = "", y_infix: str = _Y, z_infix: str = _Z

dodal/devices/slits.py

@@ -37,3 +37,21 @@ class Slits(MinimalSlits):
             self.x_centre = Motor(prefix + x_centre)
             self.y_centre = Motor(prefix + y_centre)
         super().__init__(prefix=prefix, x_gap=x_gap, y_gap=y_gap, name=name)
+
+
+class SlitsY(StandardReadable):
+    """
+    Representation of a 2-blade slits.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        y_gap: str = "Y:SIZE",
+        y_centre: str = "Y:CENTRE",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.y_gap = Motor(prefix + y_gap)
+            self.y_centre = Motor(prefix + y_centre)
+        super().__init__(name=name)

dodal/devices/v2f.py

@@ -10,13 +10,13 @@ class V2FGain(StrictEnum):
     LOW_NOISE7 = "10^7 low noise"
     LOW_NOISE8 = "10^8 low noise"
     LOW_NOISE9 = "10^9 low noise"
-    HIGHSPEED5 = "10^5 high speed"
-    HIGHSPEED6 = "10^6 high speed"
-    HIGHSPEED7 = "10^7 high speed"
-    HIGHSPEED8 = "10^8 high speed"
-    HIGHSPEED9 = "10^9 high speed"
-    HIGHSPEED10 = "10^10 high spd"
-    HIGHSPEED11 = "10^11 high spd"
+    HIGH_SPEED5 = "10^5 high speed"
+    HIGH_SPEED6 = "10^6 high speed"
+    HIGH_SPEED7 = "10^7 high speed"
+    HIGH_SPEED8 = "10^8 high speed"
+    HIGH_SPEED9 = "10^9 high speed"
+    HIGH_SPEED10 = "10^10 high spd"
+    HIGH_SPEED11 = "10^11 high spd"
 
 
 class QDV2F(StandardReadable):