dls-dodal 1.36.0__py3-none-any.whl → 1.36.2__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/adsim.py

@@ -1,13 +1,13 @@
-from ophyd import Component, EpicsMotor, MotorBundle
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
 
 
-class SimStage(MotorBundle):
-    """
-    ADSIM EPICS motors
-    """
+class SimStage(StandardReadable):
+    """Simulated Sample Stage for use with the containerised simulated beamline
+    https://github.com/epics-containers/example-services"""
 
-    x = Component(EpicsMotor, "M1")
-    y = Component(EpicsMotor, "M2")
-    z = Component(EpicsMotor, "M3")
-    theta = Component(EpicsMotor, "M4")
-    load = Component(EpicsMotor, "M5")
+    def __init__(self, prefix: str, name: str = "sim"):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "M1")
+            self.y = Motor(prefix + "M2")
+        super().__init__(name=name)

dodal/devices/attenuator.py

@@ -14,7 +14,20 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal
 from dodal.log import LOGGER
 
 
-class Attenuator(StandardReadable, Movable):
+class ReadOnlyAttenuator(StandardReadable):
+    """A read-only attenuator class with a minimum set of PVs for reading.
+
+    The actual_transmission will return a fractional transmission between 0-1.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
+
+        super().__init__(name)
+
+
+class Attenuator(ReadOnlyAttenuator, Movable):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
     This device should be set with:
@@ -42,10 +55,7 @@ class Attenuator(StandardReadable, Movable):
         self._use_current_energy = epics_signal_x(prefix + "E2WL:USECURRENTENERGY.PROC")
         self._change = epics_signal_x(prefix + "FANOUT")
 
-        with self.add_children_as_readables():
-            self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
-
-        super().__init__(name)
+        super().__init__(prefix, name)
 
     @AsyncStatus.wrap
     async def set(self, value: float):

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)

dodal/devices/fast_grid_scan.py

@@ -31,12 +31,12 @@ from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBea
 @dataclass
 class GridAxis:
     start: float
-    step_size: float
+    step_size_mm: float
     full_steps: int
 
     def steps_to_motor_position(self, steps):
         """Gives the motor position based on steps, where steps are 0 indexed"""
-        return self.start + self.step_size * steps
+        return self.start + self.step_size_mm * steps
 
     @property
     def end(self):
@@ -62,44 +62,29 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
     x_steps: int = 1
     y_steps: int = 1
     z_steps: int = 0
-    x_step_size: float = 0.1
-    y_step_size: float = 0.1
-    z_step_size: float = 0.1
-    x_start: float = 0.1
-    y1_start: float = 0.1
-    y2_start: float = 0.1
-    z1_start: float = 0.1
-    z2_start: float = 0.1
+    x_step_size_mm: float = 0.1
+    y_step_size_mm: float = 0.1
+    z_step_size_mm: float = 0.1
+    x_start_mm: float = 0.1
+    y1_start_mm: float = 0.1
+    y2_start_mm: float = 0.1
+    z1_start_mm: float = 0.1
+    z2_start_mm: float = 0.1
 
     # Whether to set the stub offsets after centering
     set_stub_offsets: bool = False
 
-    def get_param_positions(self) -> dict:
-        return {
-            "x_steps": self.x_steps,
-            "y_steps": self.y_steps,
-            "z_steps": self.z_steps,
-            "x_step_size": self.x_step_size,
-            "y_step_size": self.y_step_size,
-            "z_step_size": self.z_step_size,
-            "x_start": self.x_start,
-            "y1_start": self.y1_start,
-            "y2_start": self.y2_start,
-            "z1_start": self.z1_start,
-            "z2_start": self.z2_start,
-        }
-
     @property
     def x_axis(self) -> GridAxis:
-        return GridAxis(self.x_start, self.x_step_size, self.x_steps)
+        return GridAxis(self.x_start_mm, self.x_step_size_mm, self.x_steps)
 
     @property
     def y_axis(self) -> GridAxis:
-        return GridAxis(self.y1_start, self.y_step_size, self.y_steps)
+        return GridAxis(self.y1_start_mm, self.y_step_size_mm, self.y_steps)
 
     @property
     def z_axis(self) -> GridAxis:
-        return GridAxis(self.z2_start, self.z_step_size, self.z_steps)
+        return GridAxis(self.z2_start_mm, self.z_step_size_mm, self.z_steps)
 
     def get_num_images(self):
         return self.x_steps * (self.y_steps + self.z_steps)
@@ -140,11 +125,6 @@ class ZebraGridScanParams(GridScanParamsCommon):
 
     dwell_time_ms: float = 10
 
-    def get_param_positions(self):
-        param_positions = super().get_param_positions()
-        param_positions["dwell_time_ms"] = self.dwell_time_ms
-        return param_positions
-
     @field_validator("dwell_time_ms")
     @classmethod
     def non_integer_dwell_time(cls, dwell_time_ms: float) -> float:
@@ -166,11 +146,6 @@ class PandAGridScanParams(GridScanParamsCommon):
 
     run_up_distance_mm: float = 0.17
 
-    def get_param_positions(self):
-        param_positions = super().get_param_positions()
-        param_positions["run_up_distance_mm"] = self.run_up_distance_mm
-        return param_positions
-
 
 class MotionProgram(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -241,14 +216,14 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
             "x_steps": self.x_steps,
             "y_steps": self.y_steps,
             "z_steps": self.z_steps,
-            "x_step_size": self.x_step_size,
-            "y_step_size": self.y_step_size,
-            "z_step_size": self.z_step_size,
-            "x_start": self.x_start,
-            "y1_start": self.y1_start,
-            "y2_start": self.y2_start,
-            "z1_start": self.z1_start,
-            "z2_start": self.z2_start,
+            "x_step_size_mm": self.x_step_size,
+            "y_step_size_mm": self.y_step_size,
+            "z_step_size_mm": self.z_step_size,
+            "x_start_mm": self.x_start,
+            "y1_start_mm": self.y1_start,
+            "y2_start_mm": self.y2_start,
+            "z1_start_mm": self.z1_start,
+            "z2_start_mm": self.z2_start,
         }
         super().__init__(name)
 

dodal/devices/focusing_mirror.py

@@ -1,3 +1,5 @@
+from typing import TypedDict
+
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -36,6 +38,12 @@ class MirrorStripe(StrictEnum):
     PLATINUM = "Platinum"
 
 
+class MirrorStripeConfiguration(TypedDict):
+    stripe: MirrorStripe
+    yaw_mrad: float
+    lat_mm: float
+
+
 class MirrorVoltageDemand(StrictEnum):
     N_A = "N/A"
     OK = "OK"
@@ -130,7 +138,12 @@ class FocusingMirror(StandardReadable):
     """Focusing Mirror"""
 
     def __init__(
-        self, name, prefix, bragg_to_lat_lut_path=None, x_suffix="X", y_suffix="Y"
+        self,
+        prefix: str,
+        name: str = "",
+        bragg_to_lat_lut_path: str | None = None,
+        x_suffix: str = "X",
+        y_suffix: str = "Y",
     ):
         self.bragg_to_lat_lookup_table_path = bragg_to_lat_lut_path
         self.yaw_mrad = Motor(prefix + "YAW")
@@ -161,16 +174,17 @@ class FocusingMirrorWithStripes(FocusingMirror):
     """A focusing mirror where the stripe material can be changed. This is usually done
     based on the energy of the beamline."""
 
-    def __init__(self, name, prefix, *args, **kwargs):
+    def __init__(self, prefix: str, name: str = "", *args, **kwargs):
         self.stripe = epics_signal_rw(MirrorStripe, prefix + "STRP:DVAL")
         # apply the current set stripe setting
         self.apply_stripe = epics_signal_x(prefix + "CHANGE.PROC")
 
-        super().__init__(name, prefix, *args, **kwargs)
+        super().__init__(prefix, name, *args, **kwargs)
 
-    def energy_to_stripe(self, energy_kev) -> MirrorStripe:
+    def energy_to_stripe(self, energy_kev) -> MirrorStripeConfiguration:
+        """Return the stripe, yaw angle and lateral position for the specified energy"""
         # In future, this should be configurable per-mirror
         if energy_kev < 7:
-            return MirrorStripe.BARE
+            return {"stripe": MirrorStripe.BARE, "yaw_mrad": 6.2, "lat_mm": 0.0}
         else:
-            return MirrorStripe.RHODIUM
+            return {"stripe": MirrorStripe.RHODIUM, "yaw_mrad": 0.0, "lat_mm": 10.0}

dodal/devices/i24/beam_center.py

@@ -0,0 +1,12 @@
+"""A small temporary device to get the beam center positions from \
+    eiger or pilatus detector on i24"""
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class DetectorBeamCenter(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.beam_x = epics_signal_rw(float, prefix + "BeamX")
+        self.beam_y = epics_signal_rw(float, prefix + "BeamY")
+        super().__init__(name)

dodal/devices/i24/focus_mirrors.py

@@ -0,0 +1,60 @@
+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
+
+
+class HFocusMode(StrictEnum):
+    focus10 = "HMFMfocus10"
+    focus20d = "HMFMfocus20d"
+    focus30d = "HMFMfocus30d"
+    focus50d = "HMFMfocus50d"
+    focus1050d = "HMFMfocus1030d"
+    focus3010d = "HMFMfocus3010d"
+
+
+class VFocusMode(StrictEnum):
+    focus10 = "VMFMfocus10"
+    focus20d = "VMFMfocus20d"
+    focus30d = "VMFMfocus30d"
+    focus50d = "VMFMfocus50d"
+    focus1030d = "VMFMfocus1030d"
+    focus3010d = "VMFMfocus3010d"
+
+
+BEAM_SIZES = {
+    "focus10": [7, 7],
+    "focus20d": [20, 20],
+    "focus30d": [30, 30],
+    "focus50d": [50, 50],
+    "focus1030d": [10, 30],
+    "focus3010d": [30, 10],
+}
+
+
+class FocusMirrorsMode(StandardReadable):
+    """A small device to read the focus mode and work out the beam size."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.horizontal = epics_signal_rw(HFocusMode, prefix + "G1:TARGETAPPLY")
+        self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
+
+        with self.add_children_as_readables():
+            self.beam_size_x = create_hardware_backed_soft_signal(
+                int, self._get_beam_size_x, units="um"
+            )
+            self.beam_size_y = create_hardware_backed_soft_signal(
+                int, self._get_beam_size_y, units="um"
+            )
+
+        super().__init__(name)
+
+    async def _get_beam_size_x(self) -> int:
+        h_mode = await self.horizontal.get_value()
+        beam_x = BEAM_SIZES[h_mode.removeprefix("HMFM")][0]
+        return beam_x
+
+    async def _get_beam_size_y(self) -> int:
+        v_mode = await self.vertical.get_value()
+        beam_y = BEAM_SIZES[v_mode.removeprefix("VMFM")][1]
+        return beam_y