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

dodal/devices/insertion_device/energy.py

@@ -0,0 +1,88 @@
+import abc
+import asyncio
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    SignalRW,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_rw,
+)
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.insertion_device import MAXIMUM_MOVE_TIME, Apple2Controller
+from dodal.log import LOGGER
+
+
+class InsertionDeviceEnergyBase(abc.ABC, StandardReadable, Movable):
+    """Base class for ID energy movable device."""
+
+    def __init__(self, name: str = "") -> None:
+        self.energy: Reference[SignalRW[float]]
+        super().__init__(name=name)
+
+    @abc.abstractmethod
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None: ...
+
+
+class BeamEnergy(StandardReadable, Movable[float]):
+    """
+    Compound device to set both ID and energy motor at the same time with an option to add an offset.
+    """
+
+    def __init__(
+        self, id_energy: InsertionDeviceEnergyBase, mono: Motor, name: str = ""
+    ) -> None:
+        """
+        Parameters
+        ----------
+
+        id_energy: InsertionDeviceEnergy
+            An InsertionDeviceEnergy device.
+        mono: Motor
+            A Motor(energy) device.
+        name:
+            New device name.
+        """
+        super().__init__(name=name)
+        self._id_energy = Reference(id_energy)
+        self._mono_energy = Reference(mono)
+
+        self.add_readables(
+            [
+                self._id_energy().energy(),
+                self._mono_energy().user_readback,
+            ],
+            StandardReadableFormat.HINTED_SIGNAL,
+        )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.id_energy_offset = soft_signal_rw(float, initial_value=0)
+
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None:
+        LOGGER.info(f"Moving f{self.name} energy to {energy}.")
+        await asyncio.gather(
+            self._id_energy().set(
+                energy=energy + await self.id_energy_offset.get_value()
+            ),
+            self._mono_energy().set(energy),
+        )
+
+
+class InsertionDeviceEnergy(InsertionDeviceEnergyBase):
+    """Apple2 ID energy movable device."""
+
+    def __init__(self, id_controller: Apple2Controller, name: str = "") -> None:
+        self.energy = Reference(id_controller.energy)
+        super().__init__(name=name)
+
+        self.add_readables([self.energy()], StandardReadableFormat.HINTED_SIGNAL)
+
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None:
+        LOGGER.info(f"Setting insertion device energy to {energy}.")
+        await self.energy().set(energy, timeout=MAXIMUM_MOVE_TIME)

dodal/devices/insertion_device/energy_motor_lookup.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from daq_config_server.client import ConfigServer
 
-from dodal.devices.insertion_device.id_enum import Pol
+from dodal.devices.insertion_device.enum import Pol
 from dodal.devices.insertion_device.lookup_table_models import (
     LookupTable,
     LookupTableColumnConfig,

dodal/devices/insertion_device/lookup_table_models.py

@@ -39,7 +39,7 @@ from pydantic import (
     field_validator,
 )
 
-from dodal.devices.insertion_device.id_enum import Pol
+from dodal.devices.insertion_device.enum import Pol
 
 DEFAULT_POLY_DEG = [
     "7th-order",
@@ -57,7 +57,7 @@ DEFAULT_GAP_FILE = "IDEnergy2GapCalibrations.csv"
 DEFAULT_PHASE_FILE = "IDEnergy2PhaseCalibrations.csv"
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
-ROW_PHASE_CIRCULAR = 15
+ROW_PHASE_CIRCULAR = 15.0
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
 MAXIMUM_GAP_MOTOR_POSITION = 100
 

dodal/devices/insertion_device/polarisation.py

@@ -0,0 +1,36 @@
+import asyncio
+
+from bluesky.protocols import Locatable, Location
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    StandardReadable,
+    StandardReadableFormat,
+)
+
+from dodal.devices.insertion_device import MAXIMUM_MOVE_TIME, Apple2Controller
+from dodal.devices.insertion_device.enum import Pol
+from dodal.log import LOGGER
+
+
+class InsertionDevicePolarisation(StandardReadable, Locatable[Pol]):
+    """Apple2 ID polarisation movable device."""
+
+    def __init__(self, id_controller: Apple2Controller, name: str = "") -> None:
+        self.polarisation = Reference(id_controller.polarisation)
+        self.polarisation_setpoint = Reference(id_controller.polarisation_setpoint)
+        super().__init__(name=name)
+
+        self.add_readables([self.polarisation()], StandardReadableFormat.HINTED_SIGNAL)
+
+    @AsyncStatus.wrap
+    async def set(self, pol: Pol) -> None:
+        LOGGER.info(f"Setting insertion device polarisation to {pol.name}")
+        await self.polarisation().set(pol, timeout=MAXIMUM_MOVE_TIME)
+
+    async def locate(self) -> Location[Pol]:
+        """Return the current polarisation"""
+        setpoint, readback = await asyncio.gather(
+            self.polarisation_setpoint().get_value(), self.polarisation().get_value()
+        )
+        return Location(setpoint=setpoint, readback=readback)

dodal/devices/oav/oav_detector.py

@@ -1,13 +1,17 @@
+import asyncio
 from enum import IntEnum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
+    DeviceMock,
+    DeviceVector,
     LazyMock,
     SignalR,
     SignalRW,
     StandardReadable,
+    default_mock_class,
     derived_signal_r,
     soft_signal_rw,
 )
@@ -22,6 +26,7 @@ from dodal.devices.oav.oav_parameters import (
 )
 from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
+from dodal.log import LOGGER
 
 
 class Coords(IntEnum):
@@ -56,6 +61,35 @@ class NullZoomController(BaseZoomController):
             await self.level.set(value, wait=True)
 
 
+class BeamCentreForZoom(StandardReadable):
+    """These PVs hold the beam centre on the OAV at each zoom level.
+
+    When the zoom level is changed the IOC will update the OAV overlay PVs to be at these positions."""
+
+    def __init__(
+        self, prefix: str, level_name_pv_suffix: str, centre_value_pv_suffix: str
+    ) -> None:
+        self.level_name = epics_signal_r(
+            str, f"{prefix}MP:SELECT.{level_name_pv_suffix}"
+        )
+        self.x_centre = epics_signal_rw(
+            float, f"{prefix}PBCX:VAL{centre_value_pv_suffix}"
+        )
+        self.y_centre = epics_signal_rw(
+            float, f"{prefix}PBCY:VAL{centre_value_pv_suffix}"
+        )
+        super().__init__()
+
+
+class InstantMovingZoom(DeviceMock["ZoomController"]):
+    """Mock behaviour that instantly moves the zoom."""
+
+    async def connect(self, device: "ZoomController") -> None:
+        """Mock signals to do an instant move on setpoint write."""
+        device.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 0.001  # type:ignore
+
+
+@default_mock_class(InstantMovingZoom)
 class ZoomController(BaseZoomController):
     """
     Device to control the zoom level. This should be set like
@@ -63,19 +97,49 @@ class ZoomController(BaseZoomController):
         oav.zoom_controller.set("1.0x")
 
     Note that changing the zoom may change the AD wiring on the associated OAV, as such
-    you should wait on any zoom changs to finish before changing the OAV wiring.
+    you should wait on any zoom changes to finish before changing the OAV wiring.
     """
 
+    DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S = 2
+
     def __init__(self, prefix: str, name: str = "") -> None:
         self.percentage = epics_signal_rw(float, f"{prefix}ZOOMPOSCMD")
 
         # Level is the string description of the zoom level e.g. "1.0x" or "1.0"
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
+
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, value: str):
         await self.level.set(value, wait=True)
+        LOGGER.info(
+            "Waiting {self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S} seconds for zoom to be noticeable"
+        )
+        await asyncio.sleep(self.DELAY_BETWEEN_MOTORS_AND_IMAGE_UPDATING_S)
+
+
+class ZoomControllerWithBeamCentres(ZoomController):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        level_to_centre_mapping = [
+            ("ZRST", "A"),
+            ("ONST", "B"),
+            ("TWST", "C"),
+            ("THST", "D"),
+            ("FRST", "E"),
+            ("FVST", "F"),
+            ("SXST", "G"),
+            ("SVST", "H"),
+        ]
+
+        self.beam_centres = DeviceVector(
+            {
+                i: BeamCentreForZoom(prefix, *level_to_centre_mapping[i])
+                for i in range(len(level_to_centre_mapping))
+            }
+        )
+
+        super().__init__(prefix, name)
 
 
 class OAV(StandardReadable):
@@ -118,6 +182,7 @@ class OAV(StandardReadable):
             self.zoom_controller = zoom_controller
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
+
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(
                 f"{prefix}{mjpeg_prefix}:", name, mjpg_x_size_pv, mjpg_y_size_pv

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
 
@@ -119,3 +120,19 @@ 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/robot.py

@@ -1,6 +1,7 @@
 import asyncio
 from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
+from enum import IntEnum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
@@ -21,8 +22,8 @@ from ophyd_async.epics.core import (
 
 from dodal.log import LOGGER
 
-WAIT_FOR_OLD_PIN_MSG = "Waiting on old pin unloaded"
-WAIT_FOR_NEW_PIN_MSG = "Waiting on new pin loaded"
+WAIT_FOR_BEAMLINE_DISABLE_MSG = "Waiting on beamline disable"
+WAIT_FOR_BEAMLINE_ENABLE_MSG = "Waiting on beamline enable"
 
 
 class RobotLoadError(Exception):
@@ -43,11 +44,19 @@ class SampleLocation:
     pin: int
 
 
+SAMPLE_LOCATION_EMPTY = SampleLocation(-1, -1)
+
+
 class PinMounted(StrictEnum):
     NO_PIN_MOUNTED = "No Pin Mounted"
     PIN_MOUNTED = "Pin Mounted"
 
 
+class BeamlineStatus(IntEnum):
+    ENABLED = 0
+    DISABLED = 1
+
+
 class ErrorStatus(Device):
     def __init__(self, prefix: str) -> None:
         self.str = epics_signal_r(str, prefix + "_ERR_MSG")
@@ -61,7 +70,7 @@ class ErrorStatus(Device):
             raise RobotLoadError(int(error_code), error_string) from raise_from
 
 
-class BartRobot(StandardReadable, Movable[SampleLocation | None]):
+class BartRobot(StandardReadable, Movable[SampleLocation]):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying
@@ -86,6 +95,8 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
             self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
             self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
+        self.beamline_disabled = epics_signal_r(int, prefix + "ROBOT_OP_16_BITS.B8")
+
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
 
@@ -116,8 +127,8 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
         )
         super().__init__(name=name)
 
-    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
+    async def beamline_status_or_error(self, expected_state: BeamlineStatus):
+        """This co-routine will finish when either the beamline 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.
         """
@@ -130,12 +141,12 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
             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, expected_state, None)
+        async def wait_for_expected_state():
+            await wait_for_value(self.beamline_disabled, expected_state.value, None)
 
         tasks = [
             (Task(raise_if_error())),
-            (Task(wfv())),
+            (Task(wait_for_expected_state())),
         ]
         try:
             finished, unfinished = await asyncio.wait(
@@ -171,31 +182,37 @@ class BartRobot(StandardReadable, Movable[SampleLocation | None]):
             set_and_wait_for_value(self.next_pin, sample_location.pin),
         )
         await self.load.trigger()
-        if await self.gonio_pin_sensor.get_value() == PinMounted.PIN_MOUNTED:
-            LOGGER.info(WAIT_FOR_OLD_PIN_MSG)
-            await self.pin_state_or_error(PinMounted.NO_PIN_MOUNTED)
-        LOGGER.info(WAIT_FOR_NEW_PIN_MSG)
+        await self._wait_for_beamline_enabled_after_load_or_unload()
 
-        await self.pin_state_or_error()
+    async def _wait_for_beamline_enabled_after_load_or_unload(self):
+        if await self.beamline_disabled.get_value() == BeamlineStatus.ENABLED.value:
+            LOGGER.info(WAIT_FOR_BEAMLINE_DISABLE_MSG)
+            await self.beamline_status_or_error(BeamlineStatus.DISABLED)
+
+        LOGGER.info(WAIT_FOR_BEAMLINE_ENABLE_MSG)
+        await self.beamline_status_or_error(BeamlineStatus.ENABLED)
 
     @AsyncStatus.wrap
-    async def set(self, value: SampleLocation | None):
+    async def set(self, value: SampleLocation):
         """
         Perform a sample load from the specified sample location
         Args:
-            value: The pin and puck to load, or None to unload the sample.
+            value: The pin and puck to load, or SAMPLE_LOCATION_EMPTY to unload the sample.
         Raises:
-            RobotLoadError if a timeout occurs, or if an error occurs loading the smaple.
+            RobotLoadError if a timeout occurs, or if an error occurs loading the sample.
         """
         try:
-            if value is not None:
+            if value != SAMPLE_LOCATION_EMPTY:
                 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)
+                await wait_for(
+                    self._wait_for_beamline_enabled_after_load_or_unload(),
+                    timeout=self.LOAD_TIMEOUT + 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/selectable_source.py

@@ -0,0 +1,38 @@
+from typing import TypeVar
+
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum, soft_signal_rw
+
+
+class SelectedSource(StrictEnum):
+    SOURCE1 = "source1"
+    SOURCE2 = "source2"
+
+
+T = TypeVar("T")
+
+
+def get_obj_from_selected_source(selected_source: SelectedSource, s1: T, s2: T) -> T:
+    """Util function that maps enum values for SelectedSource to two objects. It then
+    returns one of the objects that corrosponds to the selected_source value."""
+    match selected_source:
+        case SelectedSource.SOURCE1:
+            return s1
+        case SelectedSource.SOURCE2:
+            return s2
+
+
+class SourceSelector(StandardReadable, Movable[SelectedSource]):
+    """Device that holds a selected_source signal enum of SelectedSource. Useful for
+    beamlines with multiple sources to coordinate which energy source or shutter to use."""
+
+    def __init__(self, name: str = ""):
+        with self.add_children_as_readables():
+            self.selected_source = soft_signal_rw(
+                SelectedSource, SelectedSource.SOURCE1
+            )
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: SelectedSource):
+        await self.selected_source.set(value)

dodal/devices/zebra/zebra.py

@@ -7,11 +7,15 @@ from functools import partialmethod
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
+    DeviceMock,
     DeviceVector,
     SignalRW,
     StandardReadable,
     StrictEnum,
+    callback_on_mock_put,
+    default_mock_class,
     observe_value,
+    set_mock_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
@@ -88,6 +92,17 @@ class SoftInState(StrictEnum):
     NO = "No"
 
 
+class InstantArmMock(DeviceMock["ArmingDevice"]):
+    async def connect(self, device: ArmingDevice) -> None:
+        callback_on_mock_put(
+            device.arm_set, lambda *_, **__: set_mock_value(device.armed, 1)
+        )
+        callback_on_mock_put(
+            device.disarm_set, lambda *_, **__: set_mock_value(device.armed, 0)
+        )
+
+
+@default_mock_class(InstantArmMock)
 class ArmingDevice(StandardReadable, Movable[ArmDemand]):
     """A useful device that can abstract some of the logic of arming.
     Allows a user to just call arm.set(ArmDemand.ARM)"""

dodal/devices/zebra/zebra_constants_mapping.py

@@ -49,6 +49,7 @@ class ZebraTTLOutputs(ZebraMappingValidations):
     TTL_SHUTTER: int = Field(default=-1, ge=-1, le=4)
     TTL_XSPRESS3: int = Field(default=-1, ge=-1, le=4)
     TTL_PANDA: int = Field(default=-1, ge=-1, le=4)
+    TTL_JUNGFRAU: int = Field(default=-1, ge=-1, le=4)
 
 
 class ZebraSources(ZebraMappingValidations):

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -76,7 +76,6 @@ def set_cam_pvs(
     yield from bps.abs_set(
         eiger.drv.detector.frame_time, detector_params.exposure_time_s, group=group
     )
-    yield from bps.abs_set(eiger.drv.detector.nexpi, 1, group=group)
 
     if wait:
         yield from bps.wait(group)