dls-dodal 1.65.0__py3-none-any.whl → 1.67.0__py3-none-any.whl

dodal/devices/undulator.py

@@ -1,4 +1,5 @@
 import os
+from abc import ABC, abstractmethod
 
 import numpy as np
 from bluesky.protocols import Locatable, Location, Movable
@@ -39,111 +40,177 @@ def _get_gap_for_energy(
     )
 
 
-class Undulator(StandardReadable, Movable[float]):
+class BaseUndulator(StandardReadable, Movable[float], ABC):
     """
-    An Undulator-type insertion device, used to control photon emission at a given
-    beam energy.
+    Base class for undulator devices providing gap control and access management.
+    This class expects target gap value [mm] passed in set method.
     """
 
     def __init__(
         self,
         prefix: str,
-        id_gap_lookup_table_path: str = os.devnull,
-        name: str = "",
         poles: int | None = None,
         length: float | None = None,
+        undulator_period: int | None = None,
         baton: Baton | None = None,
+        name: str = "",
     ) -> None:
-        """Constructor
-
+        """
         Args:
             prefix: PV prefix
-            poles (int): Number of magnetic poles built into the undulator
-            length (float): Length of the undulator in meters
+            poles (int, optional): Number of magnetic poles built into the undulator
+            length (float, optional): Length of the undulator in meters
+            undulator_period(int, optional): Undulator period
+            baton (optional): Baton object if provided.
             name (str, optional): Name for device. Defaults to "".
         """
-
         self.baton_ref = Reference(baton) if baton else None
-        self.id_gap_lookup_table_path = id_gap_lookup_table_path
+
         with self.add_children_as_readables():
+            self.gap_access = epics_signal_r(EnabledDisabledUpper, prefix + "IDBLENA")
             self.gap_motor = Motor(prefix + "BLGAPMTR")
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
-            self.gap_access = epics_signal_r(EnabledDisabledUpper, prefix + "IDBLENA")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.gap_discrepancy_tolerance_mm, _ = soft_signal_r_and_setter(
                 float,
                 initial_value=UNDULATOR_DISCREPANCY_THRESHOLD_MM,
             )
-            if poles is not None:
-                self.poles, _ = soft_signal_r_and_setter(
-                    int,
-                    initial_value=poles,
-                )
-            else:
-                self.poles = None
-
-            if length is not None:
-                self.length, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=length,
-                )
-            else:
-                self.length = None
-
-        super().__init__(name)
+            self.poles = self._make_signal_if_not_none(poles, int)
+            self.length = self._make_signal_if_not_none(length, float)
+            self.undulator_period = self._make_signal_if_not_none(undulator_period, int)
 
+        super().__init__(name=name)
+
+    def _make_signal_if_not_none(self, initial_value, type):
+        if initial_value is None:
+            return None
+        signal, _ = soft_signal_r_and_setter(type, initial_value=initial_value)
+        return signal
+
+    @abstractmethod
     @AsyncStatus.wrap
-    async def set(self, value: float):
+    async def set(self, value: float) -> None:
         """
-        Set the undulator gap to a given energy in keV
+        Move undulator to a given position.
+        Abstract method - must be implemented by subclasses.
 
         Args:
-            value: energy in keV
+            value: target position - units depend on implementation
         """
-        await self._set_undulator_gap(value)
+        ...
 
-    async def raise_if_not_enabled(self):
-        access_level = await self.gap_access.get_value()
-        commissioning_mode = await self._is_commissioning_mode_enabled()
-        if access_level is EnabledDisabledUpper.DISABLED and not commissioning_mode:
-            raise AccessError("Undulator gap access is disabled. Contact Control Room")
+    async def _set_gap(self, value: float) -> None:
+        """
+        Set the undulator gap to a given value in mm.
+
+        Args:
+            value: gap in mm
+        """
+        await self.raise_if_not_enabled()  # Check access
+        if await self._check_gap_within_threshold(value):
+            LOGGER.debug(
+                "Gap is already in the correct place, no need to ask it to move"
+            )
+            return
 
-    async def _set_undulator_gap(self, energy_kev: float) -> None:
-        await self.raise_if_not_enabled()
-        target_gap = await self._get_gap_to_match_energy(energy_kev)
         LOGGER.info(
-            f"Setting undulator gap to {target_gap:.3f}mm based on {energy_kev:.2f}kev"
+            f"Undulator gap mismatch. Moving gap to nominal value, {value:.3f}mm"
         )
+        commissioning_mode = await self._is_commissioning_mode_enabled()
+        if not commissioning_mode:
+            # Only move if the gap is sufficiently different to the value from the
+            # DCM lookup table AND we're not in commissioning mode
+            await self.gap_motor.set(
+                value,
+                timeout=STATUS_TIMEOUT_S,
+            )
+        else:
+            LOGGER.warning("In test mode, not moving ID gap")
 
-        # Check if undulator gap is close enough to the value from the DCM
+    async def _check_gap_within_threshold(self, target_gap: float) -> bool:
+        """
+        Check if the undulator gap is within the acceptable threshold of the target gap.
+
+        Args:
+            target_gap: target gap in mm
+        Returns:
+            True if the gap is within the threshold, False otherwise
+        """
         current_gap = await self.current_gap.get_value()
         tolerance = await self.gap_discrepancy_tolerance_mm.get_value()
-        difference = abs(target_gap - current_gap)
-        if difference > tolerance:
-            LOGGER.info(
-                f"Undulator gap mismatch. {difference:.3f}mm is outside tolerance.\
-                Moving gap to nominal value, {target_gap:.3f}mm"
-            )
-            commissioning_mode = await self._is_commissioning_mode_enabled()
-            if not commissioning_mode:
-                # Only move if the gap is sufficiently different to the value from the
-                # DCM lookup table AND we're not in commissioning mode
-                await self.gap_motor.set(
-                    target_gap,
-                    timeout=STATUS_TIMEOUT_S,
-                )
-            else:
-                LOGGER.warning("In test mode, not moving ID gap")
-        else:
-            LOGGER.debug(
-                "Gap is already in the correct place for the new energy value "
-                f"{energy_kev}, no need to ask it to move"
-            )
+        return abs(target_gap - current_gap) <= tolerance
 
-    async def _is_commissioning_mode_enabled(self):
+    async def _is_commissioning_mode_enabled(self) -> bool | None:
+        """
+        Asynchronously checks if commissioning mode is enabled via the baton reference.
+        """
         return self.baton_ref and await self.baton_ref().commissioning.get_value()
 
+    async def raise_if_not_enabled(self) -> AccessError | None:
+        """
+        Asynchronously raises AccessError if gap access is disabled and not in commissioning mode.
+        """
+        access_level = await self.gap_access.get_value()
+        commissioning_mode = await self._is_commissioning_mode_enabled()
+        if access_level is EnabledDisabledUpper.DISABLED and not commissioning_mode:
+            raise AccessError("Undulator gap access is disabled. Contact Control Room")
+
+
+class UndulatorInKeV(BaseUndulator):
+    """
+    An Undulator-type insertion device, used to control photon emission at a given beam energy.
+    This class expects energy [keV] passed in set method and does conversion to gap
+    internally, for which it requires path to lookup table file in constructor.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        id_gap_lookup_table_path: str = os.devnull,
+        poles: int | None = None,
+        length: float | None = None,
+        undulator_period: int | None = None,
+        baton: Baton | None = None,
+        name: str = "",
+    ) -> None:
+        """Constructor
+
+        Args:
+            prefix: PV prefix
+            id_gap_lookup_table_path (str): Path to a lookup table file
+            poles (int, optional): Number of magnetic poles built into the undulator
+            length (float, optional): Length of the undulator in meters
+            undulator_period(int, optional): Undulator period
+            baton (optional): Baton object if provided.
+            name (str, optional): Name for device. Defaults to "".
+        """
+
+        self.id_gap_lookup_table_path = id_gap_lookup_table_path
+        super().__init__(
+            prefix=prefix,
+            poles=poles,
+            length=length,
+            undulator_period=undulator_period,
+            baton=baton,
+            name=name,
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """
+        Check conditions and Set undulator gap to a given energy in keV
+
+        Args:
+            value: energy in keV
+        """
+        # Convert energy in keV to gap in mm first
+        target_gap = await self._get_gap_to_match_energy(value)
+        LOGGER.info(
+            f"Setting undulator gap to {target_gap:.3f}mm based on {value:.2f}kev"
+        )
+        await self._set_gap(target_gap)
+
     async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
         """
         get a 2d np.array from lookup table that
@@ -160,6 +227,23 @@ class Undulator(StandardReadable, Movable[float]):
         )
 
 
+class UndulatorInMm(BaseUndulator):
+    """
+    An Undulator-type insertion device, used to control photon emission.
+    This class expects gap [mm] passed in set method.
+    """
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """
+        Check conditions and Set undulator gap to a given value in mm
+
+        Args:
+            value: value in mm
+        """
+        await self._set_gap(value)
+
+
 class UndulatorOrder(StandardReadable, Locatable[int]):
     """
     Represents the order of an undulator device. Allows setting and locating the order.
@@ -171,17 +255,17 @@ class UndulatorOrder(StandardReadable, Locatable[int]):
             name: Name for device. Defaults to ""
         """
         with self.add_children_as_readables():
-            self._value = soft_signal_rw(int, initial_value=3)
+            self.value = soft_signal_rw(int, initial_value=3)
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, value: int) -> None:
         if (value >= 0) and isinstance(value, int):
-            await self._value.set(value)
+            await self.value.set(value)
         else:
             raise ValueError(
                 f"Undulator order must be a positive integer. Requested value: {value}"
             )
 
     async def locate(self) -> Location[int]:
-        return await self._value.locate()
+        return await self.value.locate()

dodal/plans/__init__.py

@@ -1,4 +1,4 @@
-from .scanspec import spec_scan
+from .spec_path import spec_scan
 from .wrapped import count
 
 __all__ = ["count", "spec_scan"]

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -12,7 +12,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.fastcs.eiger import EigerDetector
 
-from dodal.beamlines.i03 import fastcs_eiger, set_path_provider
+from dodal.beamlines.i03 import fastcs_eiger
 from dodal.devices.detector import DetectorParams
 from dodal.log import LOGGER, do_default_logging_setup
 
@@ -163,9 +163,7 @@ if __name__ == "__main__":
         PurePath("/dls/i03/data/2025/cm40607-2/test_new_eiger/"),
     )
 
-    set_path_provider(path_provider)
-
-    eiger = fastcs_eiger(connect_immediately=True)
+    eiger = fastcs_eiger.build(connect_immediately=True, path_provider=path_provider)
     run_engine(
         configure_arm_trigger_and_disarm_detector(
             eiger=eiger,

dodal/plans/load_panda_yaml.py

@@ -0,0 +1,9 @@
+from ophyd_async.core import YamlSettingsProvider
+from ophyd_async.fastcs.panda import HDFPanda
+from ophyd_async.plan_stubs import apply_panda_settings, retrieve_settings
+
+
+def load_panda_from_yaml(yaml_directory: str, yaml_file_name: str, panda: HDFPanda):
+    provider = YamlSettingsProvider(yaml_directory)
+    settings = yield from retrieve_settings(provider, yaml_file_name, panda)
+    yield from apply_panda_settings(settings)

dodal/plans/verify_undulator_gap.py

@@ -3,12 +3,12 @@ from typing import Protocol, runtime_checkable
 from bluesky import plan_stubs as bps
 
 from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 
 
 @runtime_checkable
 class CheckUndulatorDevices(Protocol):
-    undulator: Undulator
+    undulator: UndulatorInKeV
     dcm: DoubleCrystalMonochromatorBase
 
 

dodal/testing/fixtures/devices/apple2.py

@@ -0,0 +1,78 @@
+from unittest.mock import MagicMock
+
+import pytest
+from daq_config_server.client import ConfigServer
+from ophyd_async.core import (
+    init_devices,
+    set_mock_value,
+)
+
+from dodal.devices.insertion_device.apple2_undulator import (
+    EnabledDisabledUpper,
+    UndulatorGap,
+    UndulatorGateStatus,
+    UndulatorJawPhase,
+    UndulatorPhaseAxes,
+)
+
+
+@pytest.fixture
+def mock_config_client() -> ConfigServer:
+    mock_config_client = ConfigServer()
+
+    mock_config_client.get_file_contents = MagicMock(spec=["get_file_contents"])
+
+    def my_side_effect(file_path, reset_cached_result) -> str:
+        assert reset_cached_result is True
+        with open(file_path) as f:
+            return f.read()
+
+    mock_config_client.get_file_contents.side_effect = my_side_effect
+    return mock_config_client
+
+
+@pytest.fixture
+async def mock_id_gap(prefix: str = "BLXX-EA-DET-007:") -> UndulatorGap:
+    async with init_devices(mock=True):
+        mock_id_gap = UndulatorGap(prefix, "mock_id_gap")
+    assert mock_id_gap.name == "mock_id_gap"
+    set_mock_value(mock_id_gap.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_id_gap.velocity, 1)
+    set_mock_value(mock_id_gap.user_readback, 1)
+    set_mock_value(mock_id_gap.user_setpoint, "1")
+    set_mock_value(mock_id_gap.status, EnabledDisabledUpper.ENABLED)
+    return mock_id_gap
+
+
+@pytest.fixture
+async def mock_phase_axes(prefix: str = "BLXX-EA-DET-007:") -> UndulatorPhaseAxes:
+    async with init_devices(mock=True):
+        mock_phase_axes = UndulatorPhaseAxes(
+            prefix=prefix,
+            top_outer="RPQ1",
+            top_inner="RPQ2",
+            btm_outer="RPQ3",
+            btm_inner="RPQ4",
+        )
+    assert mock_phase_axes.name == "mock_phase_axes"
+    set_mock_value(mock_phase_axes.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_phase_axes.top_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.top_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.status, EnabledDisabledUpper.ENABLED)
+    return mock_phase_axes
+
+
+@pytest.fixture
+async def mock_jaw_phase(prefix: str = "BLXX-EA-DET-007:") -> UndulatorJawPhase:
+    async with init_devices(mock=True):
+        mock_jaw_phase = UndulatorJawPhase(
+            prefix=prefix, move_pv="RPQ1", jaw_phase="JAW"
+        )
+    set_mock_value(mock_jaw_phase.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_jaw_phase.jaw_phase.velocity, 2)
+    set_mock_value(mock_jaw_phase.jaw_phase.user_readback, 0)
+    set_mock_value(mock_jaw_phase.jaw_phase.user_setpoint_readback, 0)
+    set_mock_value(mock_jaw_phase.status, EnabledDisabledUpper.ENABLED)
+    return mock_jaw_phase

dodal/utils.py

@@ -11,7 +11,7 @@ from functools import update_wrapper, wraps
 from importlib import import_module
 from inspect import signature
 from os import environ
-from types import ModuleType
+from types import FunctionType, ModuleType
 from typing import (
     Any,
     Generic,
@@ -240,7 +240,8 @@ def make_device(
 def make_all_devices(
     module: str | ModuleType | None = None, include_skipped: bool = False, **kwargs
 ) -> tuple[dict[str, AnyDevice], dict[str, Exception]]:
-    """Makes all devices in the given beamline module.
+    """Makes all devices in the given beamline module, for those modules using device factories
+    as opposed to the DeviceManager.
 
     In cases of device interdependencies it ensures a device is created before any which
     depend on it.
@@ -413,7 +414,9 @@ def is_v2_device_factory(func: Callable) -> TypeGuard[V2DeviceFactory]:
 
 
 def is_any_device_factory(func: Callable) -> TypeGuard[AnyDeviceFactory]:
-    return is_v1_device_factory(func) or is_v2_device_factory(func)
+    return isinstance(func, FunctionType | DeviceInitializationController) and (
+        is_v1_device_factory(func) or is_v2_device_factory(func)
+    )
 
 
 def is_v2_device_type(obj: type[Any]) -> bool:

dodal/beamline_specific_utils/i03.py

@@ -1,17 +0,0 @@
-from dataclasses import dataclass
-
-I03_BEAM_HEIGHT_UM = 20.0
-I03_BEAM_WIDTH_UM = 80.0
-
-
-@dataclass
-class BeamSize:
-    x_um: float | None
-    y_um: float | None
-
-
-def beam_size_from_aperture(aperture_size: float | None):
-    return BeamSize(
-        min(aperture_size, I03_BEAM_WIDTH_UM) if aperture_size else None,
-        I03_BEAM_HEIGHT_UM if aperture_size else None,
-    )

dodal/testing/__init__.py

@@ -1,3 +0,0 @@
-from .setup import patch_all_motors, patch_motor
-
-__all__ = ["patch_motor", "patch_all_motors"]

dodal/testing/setup.py

@@ -1,67 +0,0 @@
-from contextlib import ExitStack
-
-from ophyd_async.core import Device
-from ophyd_async.epics.motor import Motor
-from ophyd_async.testing import (
-    callback_on_mock_put,
-    set_mock_value,
-)
-
-
-def patch_motor(
-    motor: Motor,
-    initial_position: float = 0,
-    deadband: float = 0.001,
-    velocity: float = 3,
-    max_velocity: float = 5,
-    low_limit_travel: float = float("-inf"),
-    high_limit_travel: float = float("inf"),
-):
-    """
-    Patch a mock motor with sensible default values so that it can still be used in
-    tests and plans without running into errors as default values are zero.
-
-    Parameters:
-        motor: The mock motor to set mock values with.
-        initial_position: The default initial position of the motor to be set.
-        deadband: The tolerance between readback value and demand setpoint which the
-                  motor is considered at position.
-        velocity: Requested move speed when the mock motor moves.
-        max_velocity: The maximum allowable velocity that can be set for the motor.
-        low_limit_travel: The lower limit that the motor can move to.
-        high_limit_travel: The higher limit that the motor can move to.
-    """
-    set_mock_value(motor.user_setpoint, initial_position)
-    set_mock_value(motor.user_readback, initial_position)
-    set_mock_value(motor.deadband, deadband)
-    set_mock_value(motor.motor_done_move, 1)
-    set_mock_value(motor.velocity, velocity)
-    set_mock_value(motor.max_velocity, max_velocity)
-    set_mock_value(motor.low_limit_travel, low_limit_travel)
-    set_mock_value(motor.high_limit_travel, high_limit_travel)
-    return callback_on_mock_put(
-        motor.user_setpoint,
-        lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),
-    )
-
-
-def patch_all_motors(parent_device: Device):
-    """
-    Check all children of a device and patch any motors with mock values.
-
-    Parameters:
-        parent_device: The device that hold motor(s) as children.
-    """
-    motors = []
-
-    def recursively_find_motors(device: Device):
-        for _, child_device in device.children():
-            if isinstance(child_device, Motor):
-                motors.append(child_device)
-            recursively_find_motors(child_device)
-
-    recursively_find_motors(parent_device)
-    motor_patch_stack = ExitStack()
-    for motor in motors:
-        motor_patch_stack.enter_context(patch_motor(motor))
-    return motor_patch_stack