dls-dodal 1.33.0__py3-none-any.whl → 1.35.0__py3-none-any.whl

dodal/devices/i24/dual_backlight.py

@@ -1,10 +1,8 @@
-from enum import Enum
+from ophyd_async.core import AsyncStatus, StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 
-from ophyd_async.core import AsyncStatus, StandardReadable
-from ophyd_async.epics.signal import epics_signal_rw
 
-
-class BacklightPositions(str, Enum):
+class BacklightPositions(StrictEnum):
     OUT = "Out"
     IN = "In"
     LOAD_CHECK = "LoadCheck"
@@ -12,7 +10,7 @@ class BacklightPositions(str, Enum):
     DIODE = "Diode"
 
 
-class LEDStatus(str, Enum):
+class LEDStatus(StrictEnum):
     OFF = "OFF"
     ON = "ON"
 
@@ -26,8 +24,8 @@ class BacklightPositioner(StandardReadable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, position: BacklightPositions):
-        await self.pos_level.set(position, wait=True)
+    async def set(self, value: BacklightPositions):
+        await self.pos_level.set(value, wait=True)
 
 
 class DualBacklight(StandardReadable):
@@ -53,9 +51,9 @@ class DualBacklight(StandardReadable):
         super().__init__(name)
 
     @AsyncStatus.wrap
-    async def set(self, position: BacklightPositions):
-        await self.backlight_position.set(position)
-        if position == BacklightPositions.OUT:
+    async def set(self, value: BacklightPositions):
+        await self.backlight_position.set(value)
+        if value == BacklightPositions.OUT:
             await self.backlight_state.set(LEDStatus.OFF, wait=True)
         else:
             await self.backlight_state.set(LEDStatus.ON, wait=True)

dodal/devices/i24/pmac.py

@@ -1,21 +1,20 @@
 from asyncio import sleep
 from enum import Enum, IntEnum
 
-from bluesky.protocols import Flyable, Triggerable
+from bluesky.protocols import Flyable, Movable, Triggerable
 from ophyd_async.core import (
-    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    SignalBackend,
+    Device,
+    Reference,
     SignalR,
     SignalRW,
-    SoftSignalBackend,
     StandardReadable,
     soft_signal_rw,
     wait_for_value,
 )
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
 
 HOME_STR = r"\#1hmz\#2hmz\#3hmz"  # Command to home the PMAC motors
 ZERO_STR = "!x0y0z0"  # Command to blend any ongoing move into new position
@@ -64,61 +63,53 @@ class PMACStringMove(Triggerable):
         pmac_str_sig: SignalRW,
         string_to_send: str,
     ) -> None:
-        self.signal = pmac_str_sig
+        self.signal_ref = Reference(pmac_str_sig)
         self.cmd_string = string_to_send
 
     @AsyncStatus.wrap
     async def trigger(self):
-        await self.signal.set(self.cmd_string, wait=True)
+        await self.signal_ref().set(self.cmd_string, wait=True)
 
 
-class PMACStringLaser(SignalRW):
+class PMACStringLaser(Device, Movable):
     """Set the pmac_string to control the laser."""
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        super().__init__(backend, timeout, name)
+        self._signal_ref = Reference(pmac_str_sig)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(
         self,
         value: LaserSettings,
-        wait=True,
-        timeout=CALCULATE_TIMEOUT,
     ):
-        await self.signal.set(value.value, wait, timeout)
+        await self._signal_ref().set(value.value)
 
 
-class PMACStringEncReset(SignalRW):
+class PMACStringEncReset(Device, Movable):
     """Set a pmac_string to control the encoder channels in the controller."""
 
     def __init__(
         self,
         pmac_str_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        super().__init__(backend, timeout, name)
+        self._signal_ref = Reference(pmac_str_sig)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(
         self,
         value: EncReset,
-        wait=True,
-        timeout=CALCULATE_TIMEOUT,
     ):
-        await self.signal.set(value.value, wait, timeout)
+        await self._signal_ref().set(value.value)
 
 
-class ProgramRunner(SignalRW, Flyable):
+class ProgramRunner(Device, Flyable):
     """Run the collection by setting the program number on the PMAC string.
 
     Once the program number has been set, wait for the collection to be complete.
@@ -131,21 +122,18 @@ class ProgramRunner(SignalRW, Flyable):
         status_sig: SignalR,
         prog_num_sig: SignalRW,
         collection_time_sig: SignalRW,
-        backend: SignalBackend,
-        timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
-        self.signal = pmac_str_sig
-        self.status = status_sig
-        self.prog_num = prog_num_sig
+        self._signal_ref = Reference(pmac_str_sig)
+        self._status_ref = Reference(status_sig)
+        self._prog_num_ref = Reference(prog_num_sig)
 
-        self.collection_time = collection_time_sig
-        self.KICKOFF_TIMEOUT = timeout
+        self._collection_time_ref = Reference(collection_time_sig)
 
-        super().__init__(backend, timeout, name)
+        super().__init__(name)
 
     async def _get_prog_number_string(self) -> str:
-        prog_num = await self.prog_num.get_value()
+        prog_num = await self._prog_num_ref().get_value()
         return f"&2b{prog_num}r"
 
     @AsyncStatus.wrap
@@ -154,11 +142,11 @@ class ProgramRunner(SignalRW, Flyable):
             wait for the scan status PV to go to 1.
         """
         prog_num_str = await self._get_prog_number_string()
-        await self.signal.set(prog_num_str, wait=True)
+        await self._signal_ref().set(prog_num_str, wait=True)
         await wait_for_value(
-            self.status,
+            self._status_ref(),
             ScanState.RUNNING,
-            timeout=self.KICKOFF_TIMEOUT,
+            timeout=DEFAULT_TIMEOUT,
         )
 
     @AsyncStatus.wrap
@@ -169,8 +157,10 @@ class ProgramRunner(SignalRW, Flyable):
             complete_time (float): total time required by the collection to \
             finish correctly.
         """
-        scan_complete_time = await self.collection_time.get_value()
-        await wait_for_value(self.status, ScanState.DONE, timeout=scan_complete_time)
+        scan_complete_time = await self._collection_time_ref().get_value()
+        await wait_for_value(
+            self._status_ref(), ScanState.DONE, timeout=scan_complete_time
+        )
 
 
 class ProgramAbort(Triggerable):
@@ -183,16 +173,16 @@ class ProgramAbort(Triggerable):
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
     ) -> None:
-        self.signal = pmac_str_sig
-        self.status = status_sig
+        self._signal_ref = Reference(pmac_str_sig)
+        self._status_ref = Reference(status_sig)
 
     @AsyncStatus.wrap
     async def trigger(self):
-        await self.signal.set("A", wait=True)
+        await self._signal_ref().set("A", wait=True)
         await sleep(1.0)  # TODO Check with scientist what this sleep is really for.
-        await self.signal.set("P2401=0", wait=True)
+        await self._signal_ref().set("P2401=0", wait=True)
         await wait_for_value(
-            self.status,
+            self._status_ref(),
             ScanState.DONE,
             timeout=DEFAULT_TIMEOUT,
         )
@@ -209,10 +199,10 @@ class PMAC(StandardReadable):
         )
         self.to_xyz_zero = PMACStringMove(self.pmac_string, ZERO_STR)
 
-        self.laser = PMACStringLaser(self.pmac_string, backend=SoftSignalBackend(str))
+        self.laser = PMACStringLaser(self.pmac_string)
 
         self.enc_reset = PMACStringEncReset(
-            self.pmac_string, backend=SoftSignalBackend(str)
+            self.pmac_string,
         )
 
         self.x = Motor(prefix + "X")
@@ -234,7 +224,6 @@ class PMAC(StandardReadable):
             self.scanstatus,
             self.program_number,
             self.collection_time,
-            backend=SoftSignalBackend(str),
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 

dodal/devices/i24/vgonio.py

@@ -0,0 +1,16 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class VerticalGoniometer(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.x = Motor(prefix + "PINX")
+        self.z = Motor(prefix + "PINZ")
+        self.yh = Motor(prefix + "PINYH")
+        self.omega = Motor(prefix + "OMEGA")
+
+        self.real_x = Motor(prefix + "PINXS")
+        self.real_z = Motor(prefix + "PINZS")
+        self.fast_y = Motor(prefix + "PINYS")
+
+        super().__init__(name)

dodal/devices/ipin.py

@@ -1,11 +1,13 @@
-from ophyd_async.core import HintedSignal, StandardReadable
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.core import StandardReadable, StandardReadableFormat
+from ophyd_async.epics.core import epics_signal_r
 
 
 class IPin(StandardReadable):
     """Simple device to get the ipin reading"""
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables(wrapper=HintedSignal):
+        with self.add_children_as_readables(
+            format=StandardReadableFormat.HINTED_SIGNAL
+        ):
             self.pin_readback = epics_signal_r(float, prefix + "I")
         super().__init__(name)

dodal/devices/linkam3.py

@@ -1,20 +1,19 @@
 import asyncio
 import time
-from enum import Enum
 
 from bluesky.protocols import Location
 from ophyd_async.core import (
-    ConfigSignal,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
     observe_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 
-class PumpControl(str, Enum):
+class PumpControl(StrictEnum):
     Manual = "Manual"
     Auto = "Auto"
 
@@ -62,9 +61,10 @@ class Linkam3(StandardReadable):
         # status is a bitfield stored in a double?
         self.status = epics_signal_r(float, prefix + "STATUS:")
 
-        self.add_readables((self.temp,), wrapper=HintedSignal)
+        self.add_readables((self.temp,), format=StandardReadableFormat.HINTED_SIGNAL)
         self.add_readables(
-            (self.ramp_rate, self.speed, self.set_point), wrapper=ConfigSignal
+            (self.ramp_rate, self.speed, self.set_point),
+            format=StandardReadableFormat.CONFIG_SIGNAL,
         )
 
         super().__init__(name=name)

dodal/devices/oav/oav_calculations.py

@@ -37,3 +37,25 @@ def camera_coordinates_to_xyz(
 
     z = vertical * sine
     return np.array([x, y, z], dtype=np.float64)
+
+
+def calculate_beam_distance(
+    beam_centre: tuple[int, int],
+    horizontal_pixels: int,
+    vertical_pixels: int,
+) -> tuple[int, int]:
+    """
+    Calculates the distance between the beam centre and the given (horizontal, vertical).
+
+    Args:
+        horizontal_pixels (int): The x (camera coordinates) value in pixels.
+        vertical_pixels (int): The y (camera coordinates) value in pixels.
+    Returns:
+        The distance between the beam centre and the (horizontal, vertical) point in pixels as a tuple
+        (horizontal_distance, vertical_distance).
+    """
+    beam_x, beam_y = beam_centre
+    return (
+        beam_x - horizontal_pixels,
+        beam_y - vertical_pixels,
+    )

dodal/devices/oav/oav_detector.py

@@ -1,26 +1,35 @@
-# type: ignore # OAV will soon be ophyd-async, see https://github.com/DiamondLightSource/dodal/issues/716
-from functools import partial
-
-from ophyd import ADComponent as ADC
-from ophyd import (
-    AreaDetector,
-    CamBase,
-    Component,
-    Device,
-    EpicsSignal,
-    HDF5Plugin,
-    OverlayPlugin,
-    ProcessPlugin,
-    ROIPlugin,
-    StatusBase,
-)
-
-from dodal.devices.areadetector.plugins.MJPG import SnapshotWithBeamCentre
-from dodal.devices.oav.grid_overlay import SnapshotWithGrid
-from dodal.devices.oav.oav_parameters import OAVConfigParams
-
-
-class ZoomController(Device):
+from enum import IntEnum
+
+from ophyd_async.core import DEFAULT_TIMEOUT, AsyncStatus, LazyMock, StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.devices.areadetector.plugins.CAM import Cam
+from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
+from dodal.devices.oav.snapshots.snapshot_with_beam_centre import SnapshotWithBeamCentre
+from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
+from dodal.log import LOGGER
+
+
+class ZoomLevelNotFoundError(Exception):
+    def __init__(self, errmsg):
+        LOGGER.error(errmsg)
+
+
+class Coords(IntEnum):
+    X = 0
+    Y = 1
+
+
+# Workaround to deal with the fact that beamlines may have slightly different string
+# descriptions of the zoom level"
+def _get_correct_zoom_string(zoom: str) -> str:
+    if zoom.endswith("x"):
+        zoom = zoom.strip("x")
+    return zoom
+
+
+class ZoomController(StandardReadable):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
@@ -30,63 +39,89 @@ class ZoomController(Device):
     you should wait on any zoom changs to finish before changing the OAV wiring.
     """
 
-    percentage = Component(EpicsSignal, "ZOOMPOSCMD")
-
-    # Level is the string description of the zoom level e.g. "1.0x"
-    level = Component(EpicsSignal, "MP:SELECT", string=True)
-
-    zrst = Component(EpicsSignal, "MP:SELECT.ZRST")
-    onst = Component(EpicsSignal, "MP:SELECT.ONST")
-    twst = Component(EpicsSignal, "MP:SELECT.TWST")
-    thst = Component(EpicsSignal, "MP:SELECT.THST")
-    frst = Component(EpicsSignal, "MP:SELECT.FRST")
-    fvst = Component(EpicsSignal, "MP:SELECT.FVST")
-    sxst = Component(EpicsSignal, "MP:SELECT.SXST")
-
-    @property
-    def allowed_zoom_levels(self):
-        return [
-            self.zrst.get(),
-            self.onst.get(),
-            self.twst.get(),
-            self.thst.get(),
-            self.frst.get(),
-            self.fvst.get(),
-            self.sxst.get(),
-        ]
-
-    def set(self, level_to_set: str) -> StatusBase:
-        return self.level.set(level_to_set)
-
-
-class OAV(AreaDetector):
-    cam = ADC(CamBase, "-DI-OAV-01:CAM:")
-    roi = ADC(ROIPlugin, "-DI-OAV-01:ROI:")
-    proc = ADC(ProcessPlugin, "-DI-OAV-01:PROC:")
-    over = ADC(OverlayPlugin, "-DI-OAV-01:OVER:")
-    tiff = ADC(OverlayPlugin, "-DI-OAV-01:TIFF:")
-    hdf5 = ADC(HDF5Plugin, "-DI-OAV-01:HDF5:")
-    grid_snapshot = Component(SnapshotWithGrid, "-DI-OAV-01:MJPG:")
-    snapshot = Component(SnapshotWithBeamCentre, "-DI-OAV-01:MJPG:")
-    zoom_controller = Component(ZoomController, "-EA-OAV-01:FZOOM:")
-
-    def __init__(self, *args, params: OAVConfigParams, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.parameters = params
-        self.grid_snapshot.oav_params = params
-        self.snapshot.oav_params = params
-        self.subscription_id = None
-        self._snapshot_trigger_subscription_id = None
-
-    def wait_for_connection(self, all_signals=False, timeout=2):
-        connected = super().wait_for_connection(all_signals, timeout)
-        x = self.grid_snapshot.x_size.get()
-        y = self.grid_snapshot.y_size.get()
-
-        cb = partial(self.parameters.update_on_zoom, xsize=x, ysize=y)
-
-        if self.subscription_id is not None:
-            self.zoom_controller.level.unsubscribe(self.subscription_id)
-        self.subscription_id = self.zoom_controller.level.subscribe(cb)
-
-        return connected
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(name=name)
+        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")
+
+    async def _get_allowed_zoom_levels(self) -> list:
+        zoom_levels = await self.level.describe()
+        return zoom_levels["level"]["choices"]  # type: ignore
+
+    @AsyncStatus.wrap
+    async def set(self, level_to_set: str):
+        allowed_zoom_levels = await self._get_allowed_zoom_levels()
+        if level_to_set not in allowed_zoom_levels:
+            raise ZoomLevelNotFoundError(
+                f"{level_to_set} not found, expected one of {allowed_zoom_levels}"
+            )
+        await self.level.set(level_to_set, wait=True)
+
+
+class OAV(StandardReadable):
+    def __init__(self, prefix: str, config: OAVConfig, name: str = ""):
+        self.oav_config = config
+        self._prefix = prefix
+        self._name = name
+        _bl_prefix = prefix.split("-")[0]
+        self.zoom_controller = ZoomController(f"{_bl_prefix}-EA-OAV-01:FZOOM:", name)
+
+        self.cam = Cam(f"{prefix}CAM:", name=name)
+
+        with self.add_children_as_readables():
+            self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
+            self.microns_per_pixel_x = create_hardware_backed_soft_signal(
+                float,
+                lambda: self._get_microns_per_pixel(Coords.X),
+            )
+            self.microns_per_pixel_y = create_hardware_backed_soft_signal(
+                float,
+                lambda: self._get_microns_per_pixel(Coords.Y),
+            )
+            self.beam_centre_i = create_hardware_backed_soft_signal(
+                int, lambda: self._get_beam_position(Coords.X)
+            )
+            self.beam_centre_j = create_hardware_backed_soft_signal(
+                int, lambda: self._get_beam_position(Coords.Y)
+            )
+            self.snapshot = SnapshotWithBeamCentre(
+                f"{self._prefix}MJPG:",
+                self.beam_centre_i,
+                self.beam_centre_j,
+                self._name,
+            )
+
+        self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
+
+        super().__init__(name)
+
+    async def _read_current_zoom(self) -> str:
+        _zoom = await self.zoom_controller.level.get_value()
+        return _get_correct_zoom_string(_zoom)
+
+    async def _get_microns_per_pixel(self, coord: int) -> float:
+        """Extracts the microns per x pixel and y pixel for a given zoom level."""
+        _zoom = await self._read_current_zoom()
+        value = self.parameters[_zoom].microns_per_pixel[coord]
+        size = await self.sizes[coord].get_value()
+        return value * DEFAULT_OAV_WINDOW[coord] / size
+
+    async def _get_beam_position(self, coord: int) -> int:
+        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
+        zoom level. """
+        _zoom = await self._read_current_zoom()
+        value = self.parameters[_zoom].crosshair[coord]
+        size = await self.sizes[coord].get_value()
+        return int(value * size / DEFAULT_OAV_WINDOW[coord])
+
+    async def connect(
+        self,
+        mock: bool | LazyMock = False,
+        timeout: float = DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+    ):
+        self.parameters = self.oav_config.get_parameters()
+
+        return await super().connect(mock, timeout, force_reconnect)