dls-dodal 1.35.0__py3-none-any.whl → 1.36.1a0__py3-none-any.whl

dodal/beamlines/p99.py

@@ -1,61 +1,30 @@
-from dodal.common.beamlines.beamline_utils import device_instantiation, set_beamline
+from dodal.common.beamlines.beamline_utils import device_factory, set_beamline
 from dodal.devices.motors import XYZPositioner
 from dodal.devices.p99.sample_stage import FilterMotor, SampleAngleStage
 from dodal.log import set_beamline as set_log_beamline
-from dodal.utils import get_beamline_name
+from dodal.utils import BeamlinePrefix, get_beamline_name
 
-BL = get_beamline_name("BL99P")
+BL = get_beamline_name("p99")
+PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
 set_beamline(BL)
 
 
-def sample_angle_stage(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> SampleAngleStage:
-    """Sample stage for p99"""
-
-    return device_instantiation(
-        SampleAngleStage,
-        prefix="-MO-STAGE-01:",
-        name="sample_angle_stage",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-    )
-
-
-def sample_stage_filer(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> FilterMotor:
-    """Sample stage for p99"""
-
-    return device_instantiation(
-        FilterMotor,
-        prefix="-MO-STAGE-02:MP:SELECT",
-        name="sample_stage_filer",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-    )
-
-
-def sample_xyz_stage(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> XYZPositioner:
-    return device_instantiation(
-        FilterMotor,
-        prefix="-MO-STAGE-02:",
-        name="sample_xyz_stage",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-    )
-
-
-def sample_lab_xyz_stage(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> XYZPositioner:
-    return device_instantiation(
-        FilterMotor,
-        prefix="-MO-STAGE-02:LAB:",
-        name="sample_lab_xyz_stage",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-    )
+@device_factory()
+def angle_stage() -> SampleAngleStage:
+    return SampleAngleStage(f"{PREFIX.beamline_prefix}-MO-STAGE-01:")
+
+
+@device_factory()
+def filter() -> FilterMotor:
+    return FilterMotor(f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:SELECT")
+
+
+@device_factory()
+def sample_stage() -> XYZPositioner:
+    return XYZPositioner(f"{PREFIX.beamline_prefix}-MO-STAGE-02:")
+
+
+@device_factory()
+def lab_stage() -> XYZPositioner:
+    return XYZPositioner(f"{PREFIX.beamline_prefix}-MO-STAGE-02:LAB:")

dodal/beamlines/training_rig.py

@@ -3,15 +3,16 @@ from pathlib import Path
 from ophyd_async.epics.adaravis import AravisDetector
 
 from dodal.common.beamlines.beamline_utils import (
-    device_instantiation,
+    device_factory,
     get_path_provider,
     set_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.beamlines.device_helpers import HDF5_PREFIX
 from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.training_rig.sample_stage import TrainingRigSampleStage
 from dodal.log import set_beamline as set_log_beamline
-from dodal.utils import get_beamline_name
+from dodal.utils import BeamlinePrefix, get_beamline_name
 
 #
 # HTSS Training Rig
@@ -20,11 +21,12 @@ from dodal.utils import get_beamline_name
 # simple motors, a GigE camera and a PandA.
 # Since there are multiple rigs whose PVs are identical aside from the prefix,
 # this module can be used for any rig. It should fill in the prefix automatically
-# if the ${BEAMLINE} environment variable is correctly set. It currently defaults
-# to p47.
+# if the ${BEAMLINE} environment variable is correctly set, else defaulting
+# to p46, which is known to be in good working order.
 #
 
-BL = get_beamline_name("p47")
+BL = get_beamline_name("p46")
+PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
@@ -37,28 +39,16 @@ set_path_provider(
 )
 
 
-def sample_stage(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> TrainingRigSampleStage:
-    return device_instantiation(
-        TrainingRigSampleStage,
-        "sample_stage",
-        "-MO-MAP-01:STAGE:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-    )
+@device_factory()
+def sample_stage() -> TrainingRigSampleStage:
+    return TrainingRigSampleStage(f"{PREFIX.beamline_prefix}-MO-MAP-01:STAGE:")
 
 
-def det(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> AravisDetector:
-    return device_instantiation(
-        AravisDetector,
-        "det",
-        "-EA-DET-01:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-        drv_suffix="DET:",
-        hdf_suffix="HDF5:",
+@device_factory()
+def det() -> AravisDetector:
+    return AravisDetector(
+        f"{PREFIX.beamline_prefix}-EA-DET-01:",
         path_provider=get_path_provider(),
+        drv_suffix="DET:",
+        hdf_suffix=HDF5_PREFIX,
     )

dodal/cli.py

@@ -1,11 +1,13 @@
 import os
+from collections.abc import Mapping
 
 import click
 from bluesky.run_engine import RunEngine
 from ophyd_async.core import NotConnected
+from ophyd_async.plan_stubs import ensure_connected
 
 from dodal.beamlines import all_beamline_names, module_name_for_beamline
-from dodal.utils import make_all_devices
+from dodal.utils import AnyDevice, filter_ophyd_devices, make_all_devices
 
 from . import __version__
 
@@ -50,22 +52,66 @@ def connect(beamline: str, all: bool, sim_backend: bool) -> None:
 
     # We need to make a RunEngine to allow ophyd-async devices to connect.
     # See https://blueskyproject.io/ophyd-async/main/explanations/event-loop-choice.html
-    RunEngine()
+    RE = RunEngine(call_returns_result=True)
 
     print(f"Attempting connection to {beamline} (using {full_module_path})")
-    devices, exceptions = make_all_devices(
+
+    # Force all devices to be lazy (don't connect to PVs on instantiation) and do
+    # connection as an extra step, because the alternatives is handling the fact
+    # that only some devices may be lazy.
+    devices, instance_exceptions = make_all_devices(
         full_module_path,
         include_skipped=all,
         fake_with_ophyd_sim=sim_backend,
+        wait_for_connection=False,
     )
-    sim_statement = " (sim mode)" if sim_backend else ""
+    devices, connect_exceptions = _connect_devices(RE, devices, sim_backend)
 
-    print(f"{len(devices)} devices connected{sim_statement}:")
+    # Inform user of successful connections
+    _report_successful_devices(devices, sim_backend)
+
+    # If exceptions have occurred, this will print details of the relevant PVs
+    exceptions = {**instance_exceptions, **connect_exceptions}
+    if len(exceptions) > 0:
+        raise NotConnected(exceptions)
+
+
+def _report_successful_devices(
+    devices: Mapping[str, AnyDevice],
+    sim_backend: bool,
+) -> None:
+    sim_statement = " (sim mode)" if sim_backend else ""
     connected_devices = "\n".join(
         sorted([f"\t{device_name}" for device_name in devices.keys()])
     )
+
+    print(f"{len(devices)} devices connected{sim_statement}:")
     print(connected_devices)
 
-    # If exceptions have occurred, this will print details of the relevant PVs
-    if len(exceptions) > 0:
-        raise NotConnected(exceptions)
+
+def _connect_devices(
+    RE: RunEngine,
+    devices: Mapping[str, AnyDevice],
+    sim_backend: bool,
+) -> tuple[Mapping[str, AnyDevice], Mapping[str, Exception]]:
+    ophyd_devices, ophyd_async_devices = filter_ophyd_devices(devices)
+    exceptions = {}
+
+    # Connect ophyd devices
+    for name, device in ophyd_devices.items():
+        try:
+            device.wait_for_connection()
+        except Exception as ex:
+            exceptions[name] = ex
+
+    # Connect ophyd-async devices
+    try:
+        RE(ensure_connected(*ophyd_async_devices.values(), mock=sim_backend))
+    except NotConnected as ex:
+        exceptions = {**exceptions, **ex.sub_errors}
+
+    # Only return the subset of devices that haven't raised an exception
+    successful_devices = {
+        name: device for name, device in devices.items() if name not in exceptions
+    }
+    return successful_devices, exceptions

dodal/common/beamlines/beamline_utils.py

@@ -1,15 +1,23 @@
 import inspect
 from collections.abc import Callable
-from typing import Final, TypeVar, cast
+from typing import Annotated, Final, TypeVar, cast
 
 from bluesky.run_engine import call_in_bluesky_event_loop
 from ophyd import Device as OphydV1Device
 from ophyd.sim import make_fake_device
+from ophyd_async.core import DEFAULT_TIMEOUT
 from ophyd_async.core import Device as OphydV2Device
 from ophyd_async.core import wait_for_connection as v2_device_wait_for_connection
 
 from dodal.common.types import UpdatingPathProvider
-from dodal.utils import AnyDevice, BeamlinePrefix, skip_device
+from dodal.utils import (
+    AnyDevice,
+    BeamlinePrefix,
+    D,
+    DeviceInitializationController,
+    SkipType,
+    skip_device,
+)
 
 DEFAULT_CONNECTION_TIMEOUT: Final[float] = 5.0
 
@@ -124,6 +132,28 @@ def device_instantiation(
     return device_instance
 
 
+def device_factory(
+    *,
+    use_factory_name: Annotated[bool, "Use factory name as name of device"] = True,
+    timeout: Annotated[float, "Timeout for connecting to the device"] = DEFAULT_TIMEOUT,
+    mock: Annotated[bool, "Use Signals with mock backends for device"] = False,
+    skip: Annotated[
+        SkipType,
+        "mark the factory to be (conditionally) skipped when beamline is imported by external program",
+    ] = False,
+) -> Callable[[Callable[[], D]], DeviceInitializationController[D]]:
+    def decorator(factory: Callable[[], D]) -> DeviceInitializationController[D]:
+        return DeviceInitializationController(
+            factory,
+            use_factory_name,
+            timeout,
+            mock,
+            skip,
+        )
+
+    return decorator
+
+
 def set_path_provider(provider: UpdatingPathProvider):
     global PATH_PROVIDER
 

dodal/common/beamlines/device_helpers.py

@@ -2,6 +2,8 @@ from dodal.common.beamlines.beamline_utils import device_instantiation
 from dodal.devices.slits import Slits
 from dodal.utils import skip_device
 
+HDF5_PREFIX = "HDF5:"
+
 
 @skip_device()
 def numbered_slits(

dodal/devices/aperture.py

@@ -12,3 +12,10 @@ class Aperture(StandardReadable):
         self.medium = epics_signal_r(float, prefix + "Y:MEDIUM_CALC")
         self.large = epics_signal_r(float, prefix + "Y:LARGE_CALC")
         super().__init__(name)
+
+    async def in_position(self):
+        return (
+            await self.small.get_value()
+            or await self.medium.get_value()
+            or await self.large.get_value()
+        )

dodal/devices/aperturescatterguard.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Callable, Coroutine
+from typing import Any
 
-from bluesky.protocols import Movable
+from bluesky.protocols import Movable, Triggerable
 from ophyd_async.core import (
     AsyncStatus,
+    Reference,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
 )
+from ophyd_async.epics.motor import Motor
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
@@ -107,7 +111,157 @@ def load_positions_from_beamline_parameters(
     }
 
 
+async def _safe_move_whilst_in_beam(
+    aperture: Aperture,
+    scatterguard: Scatterguard,
+    position: AperturePosition,
+    aperture_z_tolerance: float,
+):
+    """
+    Move the aperture and scatterguard combo safely to a new position.
+    See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
+    for why this is required. TLDR is that we have a collision at the top of y so we need
+    to make sure we move the assembly down before we move the scatterguard up.
+
+    We also check that the assembly has been moved into the correct z position
+    previously. If we try and move whilst in the incorrect Z position we will collide
+    with the table.
+    """
+    ap_z_in_position = await aperture.z.motor_done_move.get_value()
+    if not ap_z_in_position:
+        raise InvalidApertureMove(
+            "ApertureScatterguard z is still moving. Wait for it to finish "
+            "before triggering another move."
+        )
+
+    current_ap_z = await aperture.z.user_readback.get_value()
+    diff_on_z = abs(current_ap_z - position.aperture_z)
+    if diff_on_z > aperture_z_tolerance:
+        raise InvalidApertureMove(
+            f"Current aperture z ({current_ap_z}), outside of tolerance ({aperture_z_tolerance}) from target ({position.aperture_z})."
+        )
+
+    current_ap_y = await aperture.y.user_readback.get_value()
+
+    aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = position.values
+
+    if aperture_y > current_ap_y:
+        # Assembly needs to move up so move the scatterguard down first
+        await asyncio.gather(
+            scatterguard.x.set(scatterguard_x),
+            scatterguard.y.set(scatterguard_y),
+        )
+        await asyncio.gather(
+            aperture.x.set(aperture_x),
+            aperture.y.set(aperture_y),
+            aperture.z.set(aperture_z),
+        )
+    else:
+        await asyncio.gather(
+            aperture.x.set(aperture_x),
+            aperture.y.set(aperture_y),
+            aperture.z.set(aperture_z),
+        )
+
+        await asyncio.gather(
+            scatterguard.x.set(scatterguard_x),
+            scatterguard.y.set(scatterguard_y),
+        )
+
+
+class ApertureSelector(StandardReadable, Movable):
+    """Allows for moving all axes other than Y into the correct position, this means
+    that we can set up the aperture while it is out of the beam then move it in later."""
+
+    def __init__(
+        self,
+        aperture: Aperture,
+        scatterguard: Scatterguard,
+        out_of_beam: Callable[[], Coroutine[Any, Any, bool]],
+        loaded_positions: dict[ApertureValue, AperturePosition],
+        aperture_z_tolerance: float,
+    ):
+        self.aperture = Reference(aperture)
+        self.scatterguard = Reference(scatterguard)
+        self.loaded_positions = loaded_positions
+        self.get_is_out_of_beam = out_of_beam
+        self.aperture_z_tolerance = aperture_z_tolerance
+        super().__init__()
+
+    @AsyncStatus.wrap
+    async def set(self, value: ApertureValue):
+        """Moves the assembly to the position for the specified aperture, whilst keeping
+        it out of the beam if it already is so.
+
+        Moving the assembly whilst out of the beam has no collision risk so we can just
+        move all the motors together.
+        """
+        if await self.get_is_out_of_beam():
+            aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
+                self.loaded_positions[value].values
+            )
+
+            await asyncio.gather(
+                self.aperture().x.set(aperture_x),
+                self.aperture().z.set(aperture_z),
+                self.scatterguard().x.set(scatterguard_x),
+                self.scatterguard().y.set(scatterguard_y),
+            )
+        else:
+            await _safe_move_whilst_in_beam(
+                self.aperture(),
+                self.scatterguard(),
+                self.loaded_positions[value],
+                self.aperture_z_tolerance,
+            )
+
+
+class OutTrigger(StandardReadable, Triggerable):
+    """Allows for moving just the Y stage of the assembly out of the beam."""
+
+    def __init__(
+        self,
+        aperture_y: Motor,
+        out_y: float,
+    ):
+        self.aperture_y = Reference(aperture_y)
+        self.out_y = out_y
+        super().__init__()
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        """Moves the assembly out of the beam."""
+        await self.aperture_y().set(self.out_y)
+
+
 class ApertureScatterguard(StandardReadable, Movable):
+    """Move the aperture and scatterguard assembly in a safe way. There are two ways to
+    interact with the device depending on if you want simplicity or move flexibility.
+
+    The simple interface is using:
+
+        await aperture_scatterguard.set(ApertureValue.LARGE)
+
+    This will move the assembly so that the large aperture is in the beam, regardless
+    of where the assembly currently is.
+
+    However, the aperture Y axis is faster than the others. In some cases we may want to
+    move the assembly out of the beam with this axis without moving others:
+
+        await aperture_scatterguard.move_out.trigger()
+
+    We may then want to keep the assembly out of the beam whilst asynchronously preparing
+    the other axes for the aperture that's to follow:
+
+        await aperture_scatterguard.aperture_outside_beam.set(ApertureValue.LARGE)
+
+    Then, at a later time, move back into the beam:
+
+        await aperture_scatterguard.set(ApertureValue.LARGE)
+
+    This move will now be faster as only the y is left to move.
+    """
+
     def __init__(
         self,
         loaded_positions: dict[ApertureValue, AperturePosition],
@@ -115,8 +269,8 @@ class ApertureScatterguard(StandardReadable, Movable):
         prefix: str = "",
         name: str = "",
     ) -> None:
-        self.aperture = Aperture(prefix + "-MO-MAPT-01:")
-        self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
+        self._aperture = Aperture(prefix + "-MO-MAPT-01:")
+        self._scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
         self.radius = create_hardware_backed_soft_signal(
             float, self._get_current_radius, units="µm"
         )
@@ -124,30 +278,43 @@ class ApertureScatterguard(StandardReadable, Movable):
         self._tolerances = tolerances
         self.add_readables(
             [
-                self.aperture.x.user_readback,
-                self.aperture.y.user_readback,
-                self.aperture.z.user_readback,
-                self.scatterguard.x.user_readback,
-                self.scatterguard.y.user_readback,
+                self._aperture.x.user_readback,
+                self._aperture.y.user_readback,
+                self._aperture.z.user_readback,
+                self._scatterguard.x.user_readback,
+                self._scatterguard.y.user_readback,
                 self.radius,
             ],
         )
+
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.selected_aperture = create_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )
 
-        super().__init__(name)
+        # Setting this will select the aperture but not move it into beam
+        self.aperture_outside_beam = ApertureSelector(
+            self._aperture,
+            self._scatterguard,
+            self._is_out_of_beam,
+            self._loaded_positions,
+            self._tolerances.aperture_z,
+        )
+
+        # Setting this will just move the assembly out of the beam
+        self.move_out = OutTrigger(
+            self._aperture.y, loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
+        )
 
-    def get_position_from_gda_aperture_name(
-        self, gda_aperture_name: str
-    ) -> ApertureValue:
-        return ApertureValue(gda_aperture_name)
+        super().__init__(name)
 
     @AsyncStatus.wrap
     async def set(self, value: ApertureValue):
+        """This set will move the aperture into the beam or move to robot load"""
         position = self._loaded_positions[value]
-        await self._safe_move_within_datacollection_range(position, value)
+        await _safe_move_whilst_in_beam(
+            self._aperture, self._scatterguard, position, self._tolerances.aperture_z
+        )
 
     @AsyncStatus.wrap
     async def _set_raw_unsafe(self, position: AperturePosition):
@@ -157,13 +324,18 @@ class ApertureScatterguard(StandardReadable, Movable):
         )
 
         await asyncio.gather(
-            self.aperture.x.set(aperture_x),
-            self.aperture.y.set(aperture_y),
-            self.aperture.z.set(aperture_z),
-            self.scatterguard.x.set(scatterguard_x),
-            self.scatterguard.y.set(scatterguard_y),
+            self._aperture.x.set(aperture_x),
+            self._aperture.y.set(aperture_y),
+            self._aperture.z.set(aperture_z),
+            self._scatterguard.x.set(scatterguard_x),
+            self._scatterguard.y.set(scatterguard_y),
         )
 
+    async def _is_out_of_beam(self) -> bool:
+        current_ap_y = await self._aperture.y.user_readback.get_value()
+        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
+        return current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y
+
     async def _get_current_aperture_position(self) -> ApertureValue:
         """
         Returns the current aperture position using readback values
@@ -171,15 +343,13 @@ class ApertureScatterguard(StandardReadable, Movable):
         mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
         If no position is found then raises InvalidApertureMove.
         """
-        current_ap_y = await self.aperture.y.user_readback.get_value(cached=False)
-        robot_load_ap_y = self._loaded_positions[ApertureValue.ROBOT_LOAD].aperture_y
-        if await self.aperture.large.get_value(cached=False) == 1:
+        if await self._aperture.large.get_value(cached=False) == 1:
             return ApertureValue.LARGE
-        elif await self.aperture.medium.get_value(cached=False) == 1:
+        elif await self._aperture.medium.get_value(cached=False) == 1:
             return ApertureValue.MEDIUM
-        elif await self.aperture.small.get_value(cached=False) == 1:
+        elif await self._aperture.small.get_value(cached=False) == 1:
             return ApertureValue.SMALL
-        elif current_ap_y <= robot_load_ap_y + self._tolerances.aperture_y:
+        elif await self._is_out_of_beam():
             return ApertureValue.ROBOT_LOAD
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
@@ -187,57 +357,3 @@ class ApertureScatterguard(StandardReadable, Movable):
     async def _get_current_radius(self) -> float:
         current_value = await self._get_current_aperture_position()
         return self._loaded_positions[current_value].radius
-
-    async def _safe_move_within_datacollection_range(
-        self, position: AperturePosition, value: ApertureValue
-    ):
-        """
-        Move the aperture and scatterguard combo safely to a new position.
-        See https://github.com/DiamondLightSource/hyperion/wiki/Aperture-Scatterguard-Collisions
-        for why this is required.
-        """
-        assert self._loaded_positions is not None
-
-        ap_z_in_position = await self.aperture.z.motor_done_move.get_value()
-        if not ap_z_in_position:
-            raise InvalidApertureMove(
-                "ApertureScatterguard z is still moving. Wait for it to finish "
-                "before triggering another move."
-            )
-
-        current_ap_z = await self.aperture.z.user_readback.get_value()
-        diff_on_z = abs(current_ap_z - position.aperture_z)
-        if diff_on_z > self._tolerances.aperture_z:
-            raise InvalidApertureMove(
-                "ApertureScatterguard safe move is not yet defined for positions "
-                "outside of LARGE, MEDIUM, SMALL, ROBOT_LOAD. "
-                f"Current aperture z ({current_ap_z}), outside of tolerance ({self._tolerances.aperture_z}) from target ({position.aperture_z})."
-            )
-
-        current_ap_y = await self.aperture.y.user_readback.get_value()
-
-        aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
-            position.values
-        )
-
-        if position.aperture_y > current_ap_y:
-            await asyncio.gather(
-                self.scatterguard.x.set(scatterguard_x),
-                self.scatterguard.y.set(scatterguard_y),
-            )
-            await asyncio.gather(
-                self.aperture.x.set(aperture_x),
-                self.aperture.y.set(aperture_y),
-                self.aperture.z.set(aperture_z),
-            )
-        else:
-            await asyncio.gather(
-                self.aperture.x.set(aperture_x),
-                self.aperture.y.set(aperture_y),
-                self.aperture.z.set(aperture_z),
-            )
-
-            await asyncio.gather(
-                self.scatterguard.x.set(scatterguard_x),
-                self.scatterguard.y.set(scatterguard_y),
-            )

dodal/devices/dcm.py

@@ -1,6 +1,5 @@
 import numpy as np
-from numpy.typing import NDArray
-from ophyd_async.core import StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import Array1D, StandardReadable, soft_signal_r_and_setter
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
@@ -56,8 +55,10 @@ class DCM(StandardReadable):
             )
             reflection_array = np.array(cm.reflection)
             self.crystal_metadata_reflection, _ = soft_signal_r_and_setter(
-                NDArray[np.uint64],
+                Array1D[np.uint64],
                 initial_value=reflection_array,
             )
-            self.crystal_metadata_d_spacing = epics_signal_r(float, "DSPACING:RBV")
+            self.crystal_metadata_d_spacing = epics_signal_r(
+                float, prefix + "DSPACING:RBV"
+            )
         super().__init__(name)