dls-dodal 1.43.0__py3-none-any.whl → 1.45.0__py3-none-any.whl

dodal/devices/i10/slits.py

@@ -1,15 +1,21 @@
+from ophyd_async.core import Device
+from ophyd_async.core._device import DeviceConnector
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
-from dodal.devices.slits import Slits
+from dodal.devices.slits import MinimalSlits, Slits
 
 
-class I10Slits(Slits):
+class I10SlitsBlades(Slits):
+    """Slits with extra control for each blade."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.x_ring_blade = Motor(prefix + "XRING")
-            self.x_hall_blade = Motor(prefix + "XHALL")
-            self.y_top_blade = Motor(prefix + "YPLUS")
-            self.y_bot_blade = Motor(prefix + "YMINUS")
+            self.ring_blade = Motor(prefix + "XRING")
+            self.hall_blade = Motor(prefix + "XHALL")
+            self.top_blade = Motor(prefix + "YPLUS")
+            self.bot_blade = Motor(prefix + "YMINUS")
+
         super().__init__(
             prefix=prefix,
             x_gap="XSIZE",
@@ -20,7 +26,41 @@ class I10Slits(Slits):
         )
 
 
+class BladeDrainCurrents(Device):
+    """ "The drain current measurements on each blade. The drain current are due to
+    photoelectric effect (https://en.wikipedia.org/wiki/Photoelectric_effect).
+    Note the readings are in voltage as it is the output of a current amplifier."""
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix_ring_blade: str = "SIG1",
+        suffix_hall_blade: str = "SIG2",
+        suffix_top_blade: str = "SIG3",
+        suffix_bot_blade: str = "SIG4",
+        name: str = "",
+        connector: DeviceConnector | None = None,
+    ) -> None:
+        self.ring_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_ring_blade
+        )
+        self.hall_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_hall_blade
+        )
+        self.top_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_top_blade
+        )
+        self.bot_blade_current = epics_signal_r(
+            float, read_pv=prefix + suffix_bot_blade
+        )
+
+        super().__init__(name, connector)
+
+
 class I10PrimarySlits(Slits):
+    """First slits of the beamline with very high power load, they are two square water
+    cooled blocks(aperture/aptr) that overlap to produce slit like behavior."""
+
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
             self.x_aptr_1 = Motor(prefix + "APTR1:X")
@@ -35,3 +75,50 @@ class I10PrimarySlits(Slits):
             y_centre="YCENTRE",
             name=name,
         )
+
+
+class I10Slits(Device):
+    """Collection of all the i10 slits before end station."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.s1 = I10PrimarySlits(
+            prefix=prefix + "01:",
+        )
+        self.s2 = I10SlitsBlades(
+            prefix=prefix + "02:",
+        )
+        self.s3 = I10SlitsBlades(
+            prefix=prefix + "03:",
+        )
+        self.s4 = MinimalSlits(
+            prefix=prefix + "04:",
+            x_gap="XSIZE",
+            y_gap="YSIZE",
+        )
+        self.s5 = I10SlitsBlades(
+            prefix=prefix + "05:",
+        )
+        self.s6 = I10SlitsBlades(
+            prefix=prefix + "06:",
+        )
+        super().__init__(name=name)
+
+
+class I10SlitsDrainCurrent(Device):
+    """Collection of all the drain current from i10 slits."""
+
+    def __init__(
+        self, prefix: str, name: str = "", connector: DeviceConnector | None = None
+    ) -> None:
+        self.s2 = BladeDrainCurrents(
+            prefix=prefix + "AL-SLITS-02:",
+            suffix_ring_blade="XRING:I",
+            suffix_hall_blade="XHALL:I",
+            suffix_top_blade="YPLUS:I",
+            suffix_bot_blade="YMINUS:I",
+        )
+        self.s3 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-01:")
+        self.s4 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-02:")
+        self.s5 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-03:")
+        self.s6 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-04:")
+        super().__init__(name, connector)

dodal/devices/i13_1/merlin.py

@@ -3,7 +3,6 @@ from ophyd_async.epics import adcore
 
 from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.devices.i13_1.merlin_controller import MerlinController
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO
 
 
 class Merlin(StandardDetector):
@@ -18,7 +17,7 @@ class Merlin(StandardDetector):
         fileio_suffix=HDF5_SUFFIX,
         name: str = "",
     ):
-        self.drv = MerlinDriverIO(prefix + drv_suffix)
+        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
         self.hdf = adcore.NDFileHDFIO(prefix + fileio_suffix)
 
         super().__init__(

dodal/devices/i13_1/merlin_controller.py

@@ -6,17 +6,21 @@ from ophyd_async.core import (
     AsyncStatus,
     TriggerInfo,
 )
-from ophyd_async.epics import adcore
-from ophyd_async.epics.adcore import ADBaseController
-
-from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
+from ophyd_async.epics.adcore import (
+    DEFAULT_GOOD_STATES,
+    ADBaseController,
+    ADBaseIO,
+    ADImageMode,
+    ADState,
+    stop_busy_record,
+)
 
 
 class MerlinController(ADBaseController):
     def __init__(
         self,
-        driver: MerlinDriverIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        driver: ADBaseIO,
+        good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
@@ -34,7 +38,7 @@ class MerlinController(ADBaseController):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
+            self.driver.image_mode.set(ADImageMode.MULTIPLE),
         )
 
     async def wait_for_idle(self):
@@ -44,4 +48,4 @@ class MerlinController(ADBaseController):
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)
+        await stop_busy_record(self.driver.acquire, False, timeout=1)

dodal/devices/i19/beamstop.py

@@ -0,0 +1,30 @@
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw, epics_signal_x
+from ophyd_async.epics.motor import Motor
+
+
+class HomeGroup(StrictEnum):
+    NONE = "none"
+    ALL = "All"
+    X = "X"
+    Y = "Y"
+    Z = "Z"
+
+
+class HomingControl(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.homing_group = epics_signal_rw(HomeGroup, f"{prefix}:HMGRP")
+        self.home = epics_signal_x(f"{prefix}:HOME")
+        super().__init__(name)
+
+
+class BeamStop(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(f"{prefix}X")
+            self.y = Motor(f"{prefix}Y")
+            self.z = Motor(f"{prefix}Z")
+
+        self.homing = HomingControl(f"{prefix}HM", name)
+
+        super().__init__(name)

dodal/devices/i19/blueapi_device.py

@@ -0,0 +1,102 @@
+import asyncio
+import json
+from enum import Enum
+from typing import TypeVar
+
+from aiohttp import ClientSession
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
+
+from dodal.log import LOGGER
+
+OPTICS_BLUEAPI_URL = "https://i19-blueapi.diamond.ac.uk"
+HEADERS = {"Accept": "application/json", "Content-Type": "application/json"}
+
+D = TypeVar("D")
+
+
+class HutchState(str, Enum):
+    EH1 = "EH1"
+    EH2 = "EH2"
+
+
+class OpticsBlueAPIDevice(StandardReadable, Movable[D]):
+    """General device that a REST call to the blueapi instance controlling the optics \
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    the hutch sending the request and decide if the plan will be run or not.
+
+    For details see the architecture described in \
+    https://github.com/DiamondLightSource/i19-bluesky/issues/30.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        self.url = OPTICS_BLUEAPI_URL
+        self.headers = HEADERS
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: D):
+        """ On set send a POST request to the optics blueapi with the name and \
+        parameters, gets the generated task_id and then sends a PUT request that runs \
+        the plan.
+
+        Args:
+            value (dict): The value passed here should be the parameters for the POST \
+                request, taking the form:
+                {
+                    "name": "plan_name",
+                    "params": {
+                        "experiment_hutch": f"{hutch_name}",
+                        "access_device": "access_control",
+                        "other_params": "...",
+                        ...
+                    }
+                }
+        """
+        # Value here vould be request params dictionary.
+        request_params = json.dumps(value)
+
+        async with ClientSession(base_url=self.url, raise_for_status=True) as session:
+            # First submit the plan to the worker
+            async with session.post(
+                "/tasks", data=request_params, headers=HEADERS
+            ) as response:
+                LOGGER.info(
+                    f"Task submitted to the worker, response status: {response.status}"
+                )
+
+                try:
+                    data = await response.json()
+                    task_id = data["task_id"]
+                except Exception as e:
+                    LOGGER.error(
+                        f"Failed to get task_id from {self.url}/tasks POST. ({e})"
+                    )
+                    raise
+            # Then set the task as active and run asap
+            async with session.put(
+                "/worker/task", data=json.dumps({"task_id": task_id}), headers=HEADERS
+            ) as response:
+                if not response.ok:
+                    LOGGER.error(
+                        f"""Session PUT responded with {response.status}: {response.reason}.
+                        Unable to run plan {value["name"]}."""  # type: ignore
+                    )
+                    return
+                LOGGER.info(f"Running plan: {value['name']}, task_id: {task_id}")  # type: ignore
+
+            # Poll server at 2Hz until plan complete or errored
+            interval = 0.5
+            plan_complete = False
+
+            while not plan_complete:
+                async with session.get(f"/tasks/{task_id}") as res:
+                    plan_result = await res.json()
+                    plan_complete = plan_result["is_complete"]
+                    errors = plan_result["errors"]
+                    if len(errors) > 0:
+                        message = "\n".join(errors)
+                        LOGGER.error(f"Plan {value['name']} failed: {message}")  # type:ignore
+                        raise RuntimeError(f"Plan failed with error: {message}")
+                await asyncio.sleep(interval)
+            LOGGER.info(f"Plan {value['name']} done.")  # type: ignore

dodal/devices/i19/hutch_access.py

@@ -1,6 +1,8 @@
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r
 
+ACCESS_DEVICE_NAME = "access_control"  # Device name in i19-blueapi
+
 
 class HutchAccessControl(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:

dodal/devices/i19/shutter.py

@@ -1,57 +1,41 @@
-from enum import Enum
-
-from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, StandardReadableFormat
 from ophyd_async.epics.core import epics_signal_r
 
-from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
-from dodal.log import LOGGER
-
-
-class HutchInvalidError(Exception):
-    pass
+from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
+from dodal.devices.i19.blueapi_device import HutchState, OpticsBlueAPIDevice
+from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME
 
 
-class HutchState(str, Enum):
-    EH1 = "EH1"
-    EH2 = "EH2"
-    INVALID = "INVALID"
-
-
-class HutchConditionalShutter(StandardReadable, Movable[ShutterDemand]):
+class AccessControlledShutter(OpticsBlueAPIDevice):
     """ I19-specific device to operate the hutch shutter.
 
-    This device evaluates the hutch state value to work out which of the two I19 \
-    hutches is in use and then implements the HutchShutter device to operate the \
-    experimental shutter.
+    This device will send a REST call to the blueapi instance controlling the optics \
+    hutch running on the I19 cluster, which will evaluate the current hutch in use vs \
+    the hutch sending the request and decide if the plan will be run or not.
     As the two hutches are located in series, checking the hutch in use is necessary to \
     avoid accidentally operating the shutter from one hutch while the other has beamtime.
 
-    The hutch name should be passed to the device upon instantiation. If this does not \
-    coincide with the current hutch in use, a warning will be logged and the shutter \
-    will not be operated. This is to allow for testing of plans.
-    An error will instead be raised if the hutch state reads as "INVALID".
+    The name of the hutch that wants to operate the shutter should be passed to the \
+    device upon instantiation.
+
+    For details see the architecture described in \
+    https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 
     def __init__(self, prefix: str, hutch: HutchState, name: str = "") -> None:
-        self.shutter = HutchShutter(prefix=prefix, name=name)
-        bl_prefix = prefix.split("-")[0]
-        self.hutch_state = epics_signal_r(str, f"{bl_prefix}-OP-STAT-01:EHStatus.VALA")
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.shutter_status = epics_signal_r(ShutterState, f"{prefix}STA")
         self.hutch_request = hutch
         super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
-        hutch_in_use = await self.hutch_state.get_value()
-        LOGGER.info(f"Current hutch in use: {hutch_in_use}")
-        if hutch_in_use == HutchState.INVALID:
-            raise HutchInvalidError(
-                "The hutch state is invalid. Contact the beamline staff."
-            )
-        if hutch_in_use != self.hutch_request:
-            # NOTE Warn but don't fail
-            LOGGER.warning(
-                f"{self.hutch_request} is not the hutch in use. Shutter will not be operated."
-            )
-        else:
-            await self.shutter.set(value)
+        REQUEST_PARAMS = {
+            "name": "operate_shutter_plan",
+            "params": {
+                "experiment_hutch": self.hutch_request.value,
+                "access_device": ACCESS_DEVICE_NAME,
+                "shutter_demand": value.value,
+            },
+        }
+        await super().set(REQUEST_PARAMS)

dodal/devices/i22/nxsas.py

@@ -6,7 +6,7 @@ from typing import TypeVar
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import PathProvider
-from ophyd_async.epics.adaravis import AravisController, AravisDetector
+from ophyd_async.epics.adaravis import AravisDetector
 from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
@@ -149,7 +149,6 @@ class NXSasOAV(AravisDetector):
         fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
-        gpio_number: AravisController.GPIO_NUMBER = 1,
     ):
         """Extends detector with configuration metadata required or desired
         to comply with the NXsas application definition.
@@ -162,7 +161,6 @@ class NXSasOAV(AravisDetector):
             drv_suffix=drv_suffix,
             fileio_suffix=fileio_suffix,
             name=name,
-            gpio_number=gpio_number,
         )
         self._metadata_holder = metadata_holder
 

dodal/devices/i24/focus_mirrors.py

@@ -1,7 +1,7 @@
 from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class HFocusMode(StrictEnum):
@@ -40,10 +40,10 @@ class FocusMirrorsMode(StandardReadable):
         self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
 
         with self.add_children_as_readables():
-            self.beam_size_x = create_hardware_backed_soft_signal(
+            self.beam_size_x = create_r_hardware_backed_soft_signal(
                 int, self._get_beam_size_x, units="um"
             )
-            self.beam_size_y = create_hardware_backed_soft_signal(
+            self.beam_size_y = create_r_hardware_backed_soft_signal(
                 int, self._get_beam_size_y, units="um"
             )
 

dodal/devices/i24/pilatus_metadata.py

@@ -5,7 +5,7 @@ import re
 from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class PilatusMetadata(StandardReadable):
@@ -14,7 +14,7 @@ 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_hardware_backed_soft_signal(
+            self.filename_template = create_r_hardware_backed_soft_signal(
                 str, self._get_full_filename_template
             )
         super().__init__(name)

dodal/devices/motors.py

@@ -38,3 +38,24 @@ class XYZPositioner(StandardReadable):
             self.y = Motor(prefix + infix[1])
             self.z = Motor(prefix + infix[2])
         super().__init__(name=name)
+
+
+class SixAxisGonio(XYZPositioner):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        infix: tuple[str, str, str, str, str, str] = (
+            "X",
+            "Y",
+            "Z",
+            "KAPPA",
+            "PHI",
+            "OMEGA",
+        ),
+    ):
+        with self.add_children_as_readables():
+            self.kappa = Motor(prefix + infix[3])
+            self.phi = Motor(prefix + infix[4])
+            self.omega = Motor(prefix + infix[5])
+        super().__init__(name=name, prefix=prefix, infix=infix[0:3])

dodal/devices/oav/oav_detector.py

@@ -9,10 +9,10 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_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 import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
 
 
@@ -63,24 +63,22 @@ class OAV(StandardReadable):
 
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
-            self.microns_per_pixel_x = create_hardware_backed_soft_signal(
+            self.microns_per_pixel_x = create_r_hardware_backed_soft_signal(
                 float,
                 lambda: self._get_microns_per_pixel(Coords.X),
             )
-            self.microns_per_pixel_y = create_hardware_backed_soft_signal(
+            self.microns_per_pixel_y = create_r_hardware_backed_soft_signal(
                 float,
                 lambda: self._get_microns_per_pixel(Coords.Y),
             )
-            self.beam_centre_i = create_hardware_backed_soft_signal(
+            self.beam_centre_i = create_r_hardware_backed_soft_signal(
                 int, lambda: self._get_beam_position(Coords.X)
             )
-            self.beam_centre_j = create_hardware_backed_soft_signal(
+            self.beam_centre_j = create_r_hardware_backed_soft_signal(
                 int, lambda: self._get_beam_position(Coords.Y)
             )
-            self.snapshot = SnapshotWithBeamCentre(
+            self.snapshot = Snapshot(
                 f"{self._prefix}MJPG:",
-                self.beam_centre_i,
-                self.beam_centre_j,
                 self._name,
             )
 

dodal/devices/oav/snapshots/snapshot.py

@@ -0,0 +1,21 @@
+from PIL import Image
+
+from dodal.devices.areadetector.plugins.MJPG import MJPG
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+class Snapshot(MJPG):
+    """A child of MJPG which, when triggered, saves the image to disk."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        super().__init__(prefix, name)
+
+    async def post_processing(self, image: Image.Image):
+        await self._save_image(image)

dodal/devices/oav/snapshots/snapshot_image_processing.py

@@ -0,0 +1,74 @@
+from PIL import Image, ImageDraw
+
+from dodal.devices.oav.utils import Pixel
+
+CROSSHAIR_LENGTH_PX = 20
+CROSSHAIR_OUTLINE_COLOUR = "Black"
+CROSSHAIR_FILL_COLOUR = "White"
+
+
+def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
+    """
+    Draw a crosshair at the beam centre coordinates specified.
+    Args:
+        image: The image to draw the crosshair onto. This is mutated.
+        beam_x: The x-coordinate of the crosshair (pixels)
+        beam_y: The y-coordinate of the crosshair (pixels)
+    """
+    draw = ImageDraw.Draw(image)
+    OUTLINE_WIDTH = 1
+    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
+    draw.rectangle(
+        [
+            beam_x - OUTLINE_WIDTH,
+            beam_y - HALF_LEN - OUTLINE_WIDTH,
+            beam_x + OUTLINE_WIDTH,
+            beam_y + HALF_LEN + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.rectangle(
+        [
+            beam_x - HALF_LEN - OUTLINE_WIDTH,
+            beam_y - OUTLINE_WIDTH,
+            beam_x + HALF_LEN + OUTLINE_WIDTH,
+            beam_y + OUTLINE_WIDTH,
+        ],
+        fill=CROSSHAIR_OUTLINE_COLOUR,
+    )
+    draw.line(
+        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+    draw.line(
+        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
+        fill=CROSSHAIR_FILL_COLOUR,
+    )
+
+
+def compute_beam_centre_pixel_xy_for_mm_position(
+    sample_pos_mm: tuple[float, float],
+    beam_pos_at_origin_px: Pixel,
+    microns_per_pixel: tuple[float, float],
+) -> Pixel:
+    """
+    Compute the location of the beam centre in pixels on a reference image.
+    Args:
+        sample_pos_mm: x, y location of the sample in mm relative to when the reference image
+            was taken.
+        beam_pos_at_origin_px: x, y position of the beam centre in the reference image (pixels)
+        microns_per_pixel: x, y scaling factor relating the sample position to the position in the image.
+    Returns:
+        x, y location of the beam centre (pixels)
+
+    """
+
+    def centre(sample_pos, beam_pos, um_per_px) -> int:
+        return beam_pos + sample_pos * 1000 / um_per_px
+
+    return Pixel(
+        centre(sp, bp, mpp)
+        for sp, bp, mpp in zip(
+            sample_pos_mm, beam_pos_at_origin_px, microns_per_pixel, strict=True
+        )
+    )

dodal/devices/turbo_slit.py

@@ -1,8 +1,9 @@
-from ophyd_async.core import StandardReadable
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class TurboSlit(StandardReadable):
+class TurboSlit(StandardReadable, Movable[float]):
     """
     This collection of motors coordinates time resolved XAS experiments.
     It selects a beam out of the polychromatic fan.
@@ -23,3 +24,8 @@ class TurboSlit(StandardReadable):
             self.arc = Motor(prefix=prefix + "ARC")
             self.xfine = Motor(prefix=prefix + "XFINE")
         super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """This will move the default XFINE"""
+        await self.xfine.set(value)