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

dodal/devices/pressure_jump_cell.py

@@ -0,0 +1,299 @@
+import asyncio
+from dataclasses import dataclass
+
+from bluesky.protocols import HasName, Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    DeviceVector,
+    SignalR,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+OPENSEQ_PULSE_LENGTH = 0.2
+
+
+class PumpState(StrictEnum):
+    MANUAL = "Manual"
+    AUTO_PRESSURE = "Auto Pressure"
+    AUTO_POSITION = "Auto Position"
+
+
+class StopState(StrictEnum):
+    CONTINUE = "CONTINUE"
+    STOP = "STOP"
+
+
+class FastValveControlRequest(StrictEnum):
+    OPEN = "Open"
+    CLOSE = "Close"
+    RESET = "Reset"
+    ARM = "Arm"
+    DISARM = "Disarm"
+
+
+class ValveControlRequest(StrictEnum):
+    OPEN = "Open"
+    CLOSE = "Close"
+    RESET = "Reset"
+
+
+class ValveOpenSeqRequest(StrictEnum):
+    INACTIVE = 0
+    OPEN_SEQ = 1
+
+
+class PumpMotorDirectionState(StrictEnum):
+    EMPTY = ""
+    FORWARD = "Forward"
+    REVERSE = "Reverse"
+
+
+class ValveState(StrictEnum):
+    FAULT = "Fault"
+    OPEN = "Open"
+    OPENING = "Opening"
+    CLOSED = "Closed"
+    CLOSING = "Closing"
+
+
+class FastValveState(StrictEnum):
+    FAULT = "Fault"
+    OPEN = "Open"
+    OPEN_ARMED = "Open Armed"
+    CLOSED = "Closed"
+    CLOSED_ARMED = "Closed Armed"
+    NONE = "Unused"
+
+
+@dataclass
+class AllValvesControlState:
+    valve_1: ValveControlRequest | None = None
+    valve_3: ValveControlRequest | None = None
+    valve_5: FastValveControlRequest | None = None
+    valve_6: FastValveControlRequest | None = None
+
+
+class AllValvesControl(StandardReadable, Movable):
+    """
+    valves 2, 4, 7, 8 are not controlled by the IOC,
+    as they are under manual control.
+    fast_valves: tuple[int, ...] = (5, 6)
+    slow_valves: tuple[int, ...] = (1, 3)
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        fast_valves: tuple[int, ...] = (5, 6),
+        slow_valves: tuple[int, ...] = (1, 3),
+    ) -> None:
+        self.fast_valves = fast_valves
+        self.slow_valves = slow_valves
+        with self.add_children_as_readables():
+            self.valve_states: DeviceVector[SignalR[ValveState]] = DeviceVector(
+                {
+                    i: epics_signal_r(ValveState, f"{prefix}V{i}:STA")
+                    for i in self.slow_valves
+                }
+            )
+            self.fast_valve_states: DeviceVector[SignalR[FastValveState]] = (
+                DeviceVector(
+                    {
+                        i: epics_signal_r(FastValveState, f"{prefix}V{i}:STA")
+                        for i in self.fast_valves
+                    }
+                )
+            )
+
+        self.fast_valve_control: DeviceVector[FastValveControl] = DeviceVector(
+            {i: FastValveControl(f"{prefix}V{i}") for i in self.fast_valves}
+        )
+
+        self.valve_control: DeviceVector[ValveControl] = DeviceVector(
+            {i: ValveControl(f"{prefix}V{i}") for i in self.slow_valves}
+        )
+
+        super().__init__(name)
+
+    async def set_valve(
+        self,
+        valve: int,
+        value: ValveControlRequest | FastValveControlRequest,
+    ):
+        if valve in self.slow_valves and (isinstance(value, ValveControlRequest)):
+            if value == ValveControlRequest.OPEN:
+                await self.valve_control[valve].set(ValveOpenSeqRequest.OPEN_SEQ)
+                await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
+                await self.valve_control[valve].set(ValveOpenSeqRequest.INACTIVE)
+            else:
+                await self.valve_control[valve].set(value)
+
+        elif valve in self.fast_valves and (isinstance(value, FastValveControlRequest)):
+            if value == FastValveControlRequest.OPEN:
+                await self.fast_valve_control[valve].set(ValveOpenSeqRequest.OPEN_SEQ)
+                await asyncio.sleep(OPENSEQ_PULSE_LENGTH)
+                await self.fast_valve_control[valve].set(ValveOpenSeqRequest.INACTIVE)
+            else:
+                await self.fast_valve_control[valve].set(value)
+
+    @AsyncStatus.wrap
+    async def set(self, value: AllValvesControlState):
+        await asyncio.gather(
+            *(
+                self.set_valve(int(i[-1]), value)
+                for i, value in value.__dict__.items()
+                if value is not None
+            )
+        )
+
+
+class ValveControl(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.close = epics_signal_rw(ValveControlRequest, prefix + ":CON")
+            self.open = epics_signal_rw(ValveOpenSeqRequest, prefix + ":OPENSEQ")
+
+        super().__init__(name)
+
+    def set(self, value: ValveControlRequest | ValveOpenSeqRequest) -> AsyncStatus:
+        set_status = None
+
+        if isinstance(value, ValveControlRequest):
+            set_status = self.close.set(value)
+        elif isinstance(value, ValveOpenSeqRequest):
+            set_status = self.open.set(value)
+
+        return set_status
+
+
+class FastValveControl(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.close = epics_signal_rw(FastValveControlRequest, prefix + ":CON")
+            self.open = epics_signal_rw(ValveOpenSeqRequest, prefix + ":OPENSEQ")
+
+        super().__init__(name)
+
+    def set(self, value: FastValveControlRequest | ValveOpenSeqRequest) -> AsyncStatus:
+        set_status = None
+
+        if isinstance(value, FastValveControlRequest):
+            set_status = self.close.set(value)
+        elif isinstance(value, ValveOpenSeqRequest):
+            set_status = self.open.set(value)
+
+        return set_status
+
+
+class Pump(StandardReadable):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.pump_position = epics_signal_r(float, prefix + "POS")
+            self.pump_motor_direction = epics_signal_r(
+                PumpMotorDirectionState, prefix + "MTRDIR"
+            )
+            self.pump_speed = epics_signal_rw(
+                float, write_pv=prefix + "MSPEED", read_pv=prefix + "MSPEED_RBV"
+            )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.pump_mode = epics_signal_rw(PumpState, prefix + "SP:AUTO")
+
+        super().__init__(name)
+
+
+class PressureTransducer(StandardReadable):
+    """
+    Pressure transducer for a high pressure X-ray cell.
+    This is the chamber and there are three of them.
+    1 is the start, 3 is where the sample is.
+    NOTE: the distinction between the adc prefix and the cell prefix is kept here.
+
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        cell_prefix: str,
+        number: int,
+        name: str = "",
+        full_different_prefix_adc: str = "",
+    ) -> None:
+        final_prefix = f"{prefix}{cell_prefix}"
+        with self.add_children_as_readables():
+            self.omron_pressure = epics_signal_r(
+                float, f"{final_prefix}PP{number}:PRES"
+            )
+            self.omron_voltage = epics_signal_r(float, f"{final_prefix}PP{number}:RAW")
+            self.beckhoff_pressure = epics_signal_r(
+                float, f"{final_prefix}STATP{number}:MeanValue_RBV"
+            )
+            self.slow_beckhoff_voltage_readout = epics_signal_r(
+                float, f"{full_different_prefix_adc}CH1"
+            )
+
+        super().__init__(name)
+
+
+class PressureJumpCellController(HasName):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.stop = epics_signal_rw(StopState, f"{prefix}STOP")
+
+        self.target_pressure = epics_signal_rw(float, f"{prefix}TARGET")
+        self.timeout = epics_signal_rw(float, f"{prefix}TIMER.HIGH")
+        self.go = epics_signal_rw(bool, f"{prefix}GO")
+
+        ## Jump logic ##
+        self.start_pressure = epics_signal_rw(float, f"{prefix}JUMPF")
+        self.target_pressure = epics_signal_rw(float, f"{prefix}JUMPT")
+        self.jump_ready = epics_signal_rw(bool, f"{prefix}SETJUMP")
+
+        self._name = name
+        super().__init__()
+
+    @property
+    def name(self):
+        return self._name
+
+
+class PressureJumpCell(StandardReadable):
+    """
+    High pressure X-ray cell, used to apply pressure or pressure jumps to a sample.
+    prefix: str
+        The prefix of beamline - SPECIAL - unusual that the cell prefix is computed separately
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        cell_prefix: str = "-HPXC-01:",
+        adc_prefix: str = "-ADC",
+        name: str = "",
+    ):
+        self.all_valves_control = AllValvesControl(f"{prefix}{cell_prefix}", name)
+        self.pump = Pump(f"{prefix}{cell_prefix}", name)
+
+        self.controller = PressureJumpCellController(
+            f"{prefix}{cell_prefix}CTRL:", name
+        )
+
+        with self.add_children_as_readables():
+            self.pressure_transducers: DeviceVector[PressureTransducer] = DeviceVector(
+                {
+                    i: PressureTransducer(
+                        prefix=prefix,
+                        number=i,
+                        cell_prefix=cell_prefix,
+                        full_different_prefix_adc=f"{prefix}{adc_prefix}-0{i}:",
+                    )
+                    for i in [1, 2, 3]
+                }
+            )
+
+            self.cell_temperature = epics_signal_r(float, f"{prefix}{cell_prefix}TEMP")
+
+        super().__init__(name)

dodal/devices/robot.py

@@ -42,7 +42,7 @@ class BartRobot(StandardReadable, Movable):
     """The sample changing robot."""
 
     # How long to wait for the robot if it is busy soaking/drying
-    NOT_BUSY_TIMEOUT = 60
+    NOT_BUSY_TIMEOUT = 5 * 60
     # How long to wait for the actual load to happen
     LOAD_TIMEOUT = 60
     NO_PIN_ERROR_CODE = 25

dodal/devices/tetramm.py

@@ -219,7 +219,7 @@ class TetrammDetector(StandardDetector):
         self,
         prefix: str,
         path_provider: PathProvider,
-        name: str,
+        name: str = "",
         type: str | None = None,
         **scalar_sigs: str,
     ) -> None:

dodal/devices/undulator.py

@@ -108,10 +108,13 @@ class Undulator(StandardReadable, Movable):
         """
         await self._set_undulator_gap(value)
 
-    async def _set_undulator_gap(self, energy_kev: float) -> None:
+    async def raise_if_not_enabled(self):
         access_level = await self.gap_access.get_value()
         if access_level is UndulatorGapAccess.DISABLED and not TEST_MODE:
             raise AccessError("Undulator gap access is disabled. Contact Control Room")
+
+    async def _set_undulator_gap(self, energy_kev: float) -> None:
+        await self.raise_if_not_enabled()
         LOGGER.info(f"Setting undulator gap to {energy_kev:.2f} kev")
         target_gap = await self._get_gap_to_match_energy(energy_kev)
 

dodal/devices/undulator_dcm.py

@@ -6,17 +6,10 @@ from ophyd_async.core import AsyncStatus, StandardReadable
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 
 from .dcm import DCM
-from .undulator import Undulator, UndulatorGapAccess
+from .undulator import Undulator
 
 ENERGY_TIMEOUT_S: float = 30.0
 
-# Enable to allow testing when the beamline is down, do not change in production!
-TEST_MODE = False
-
-
-class AccessError(Exception):
-    pass
-
 
 class UndulatorDCM(StandardReadable, Movable):
     """
@@ -61,17 +54,8 @@ class UndulatorDCM(StandardReadable, Movable):
 
     @AsyncStatus.wrap
     async def set(self, value: float):
+        await self.undulator.raise_if_not_enabled()
         await asyncio.gather(
-            self._set_dcm_energy(value),
+            self.dcm.energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator.set(value),
         )
-
-    async def _set_dcm_energy(self, energy_kev: float) -> None:
-        access_level = await self.undulator.gap_access.get_value()
-        if access_level is UndulatorGapAccess.DISABLED and not TEST_MODE:
-            raise AccessError("Undulator gap access is disabled. Contact Control Room")
-
-        await self.dcm.energy_in_kev.set(
-            energy_kev,
-            timeout=ENERGY_TIMEOUT_S,
-        )

dodal/devices/zocalo/zocalo_results.py

@@ -12,8 +12,8 @@ import workflows.transport
 from bluesky.protocols import Triggerable
 from bluesky.utils import Msg
 from deepdiff import DeepDiff
-from numpy.typing import NDArray
 from ophyd_async.core import (
+    Array1D,
     AsyncStatus,
     StandardReadable,
     StandardReadableFormat,
@@ -133,22 +133,22 @@ class ZocaloResults(StandardReadable, Triggerable):
         self.use_cpu_and_gpu = use_cpu_and_gpu
 
         self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="centre_of_mass"
+            Array1D[np.uint64], name="centre_of_mass"
         )
         self.bounding_box, self._bounding_box_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="bounding_box"
+            Array1D[np.uint64], name="bounding_box"
         )
         self.max_voxel, self._max_voxel_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="max_voxel"
+            Array1D[np.uint64], name="max_voxel"
         )
         self.max_count, self._max_count_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="max_count"
+            Array1D[np.uint64], name="max_count"
         )
         self.n_voxels, self._n_voxels_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="n_voxels"
+            Array1D[np.uint64], name="n_voxels"
         )
         self.total_count, self._total_count_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="total_count"
+            Array1D[np.uint64], name="total_count"
         )
         self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
             int, name="ispyb_dcid"

dodal/utils.py

@@ -1,3 +1,4 @@
+import functools
 import importlib
 import inspect
 import os
@@ -6,13 +7,14 @@ import socket
 import string
 from collections.abc import Callable, Iterable, Mapping
 from dataclasses import dataclass
-from functools import wraps
+from functools import update_wrapper, wraps
 from importlib import import_module
 from inspect import signature
 from os import environ
 from types import ModuleType
 from typing import (
     Any,
+    Generic,
     Protocol,
     TypeGuard,
     TypeVar,
@@ -35,6 +37,7 @@ from bluesky.protocols import (
     Triggerable,
     WritesExternalAssets,
 )
+from bluesky.run_engine import call_in_bluesky_event_loop
 from ophyd.device import Device as OphydV1Device
 from ophyd_async.core import Device as OphydV2Device
 
@@ -99,6 +102,8 @@ class BeamlinePrefix:
 
 
 T = TypeVar("T", bound=AnyDevice)
+D = TypeVar("D", bound=OphydV2Device)
+SkipType = bool | Callable[[], bool]
 
 
 def skip_device(precondition=lambda: True):
@@ -114,6 +119,91 @@ def skip_device(precondition=lambda: True):
     return decorator
 
 
+class DeviceInitializationController(Generic[D]):
+    def __init__(
+        self,
+        factory: Callable[[], D],
+        use_factory_name: bool,
+        timeout: float,
+        mock: bool,
+        skip: SkipType,
+    ):
+        self._factory: Callable[[], D] = functools.cache(factory)
+        self._use_factory_name = use_factory_name
+        self._timeout = timeout
+        self._mock = mock
+        self._skip = skip
+        update_wrapper(self, factory)
+
+    @property
+    def skip(self) -> bool:
+        return self._skip() if callable(self._skip) else self._skip
+
+    def cache_clear(self) -> None:
+        """Clears the controller's internal cached instance of the device, if present.
+        Noop if not."""
+
+        # Functools adds the cache_clear function via setattr so the type checker
+        # does not pick it up.
+        self._factory.cache_clear()  # type: ignore
+
+    def __call__(
+        self,
+        connect_immediately: bool = False,
+        name: str | None = None,
+        connection_timeout: float | None = None,
+        mock: bool | None = None,
+    ) -> D:
+        """Returns an instance of the Device the wrapped factory produces: the same
+        instance will be returned if this method is called multiple times, and arguments
+        may be passed to override this Controller's configuration.
+        Once the device is connected, the value of mock must be consistent, or connect
+        must be False.
+
+
+        Args:
+            connect_immediately (bool, default False): whether to call connect on the
+              device before returning it- connect is idempotent for ophyd-async devices.
+              Not connecting to the device allows for the instance to be created prior
+              to the RunEngine event loop being configured or for connect to be called
+              lazily e.g. by the `ensure_connected` stub.
+            name (str | None, optional): an override name to give the device, which is
+              also used to name its children. Defaults to None, which does not name the
+              device unless the device has no name and this Controller is configured to
+              use_factory_name, which propagates the name of the wrapped factory
+              function to the device instance.
+            connection_timeout (float | None, optional): an override timeout length in
+              seconds for the connect method, if it is called. Defaults to None, which
+              defers to the timeout configured for this Controller: the default uses
+              ophyd_async's DEFAULT_TIMEOUT.
+            mock (bool | None, optional): overrides whether to connect to Mock signal
+              backends, if connect is called. Defaults to None, which uses the mock
+              parameter of this Controller. This value must be used consistently when
+              connect is called on the Device.
+
+        Returns:
+            D: a singleton instance of the Device class returned by the wrapped factory.
+        """
+        device = self._factory()
+
+        if connect_immediately:
+            call_in_bluesky_event_loop(
+                device.connect(
+                    timeout=connection_timeout
+                    if connection_timeout is not None
+                    else self._timeout,
+                    mock=mock if mock is not None else self._mock,
+                )
+            )
+
+        if name:
+            device.set_name(name)
+        elif not device.name and self._use_factory_name:
+            device.set_name(self._factory.__name__)
+
+        return device
+
+
 def make_device(
     module: str | ModuleType,
     device_name: str,
@@ -206,7 +296,33 @@ def invoke_factories(
         dependent_name = leaves.pop()
         params = {name: devices[name] for name in dependencies[dependent_name]}
         try:
-            devices[dependent_name] = factories[dependent_name](**params, **kwargs)
+            factory = factories[dependent_name]
+            if isinstance(factory, DeviceInitializationController):
+                # For now we translate the old-style parameters that
+                # device_instantiation expects. Once device_instantiation is gone and
+                # replaced with DeviceInitializationController we can formalise the
+                # API of make_all_devices and make these parameters explicit.
+                # https://github.com/DiamondLightSource/dodal/issues/844
+                mock = kwargs.get(
+                    "mock",
+                    kwargs.get(
+                        "fake_with_ophyd_sim",
+                        False,
+                    ),
+                )
+                connect_immediately = kwargs.get(
+                    "connect_immediately",
+                    kwargs.get(
+                        "wait_for_connection",
+                        False,
+                    ),
+                )
+                devices[dependent_name] = factory(
+                    mock=mock,
+                    connect_immediately=connect_immediately,
+                )
+            else:
+                devices[dependent_name] = factory(**params, **kwargs)
         except Exception as e:
             exceptions[dependent_name] = e
 
@@ -268,6 +384,8 @@ def collect_factories(
 
 
 def _is_device_skipped(func: AnyDeviceFactory) -> bool:
+    if isinstance(func, DeviceInitializationController):
+        return func.skip
     return getattr(func, "__skip__", False)
 
 
@@ -301,6 +419,37 @@ def is_v1_device_type(obj: type[Any]) -> bool:
     return is_class and follows_protocols and not is_v2_device_type(obj)
 
 
+def filter_ophyd_devices(
+    devices: Mapping[str, AnyDevice],
+) -> tuple[Mapping[str, OphydV1Device], Mapping[str, OphydV2Device]]:
+    """
+    Split a dictionary of ophyd and ophyd-async devices
+    (i.e. the output of make_all_devices) into 2 separate dictionaries of the
+    different types. Useful when special handling is needed for each type of device.
+
+    Args:
+        devices: Dictionary of device name to ophyd or ophyd-async device.
+
+    Raises:
+        ValueError: If anything in the dictionary doesn't come from either library.
+
+    Returns:
+        Tuple of two dictionaries, one mapping names to ophyd devices and one mapping
+        names to ophyd-async devices.
+    """
+
+    ophyd_devices = {}
+    ophyd_async_devices = {}
+    for name, device in devices.items():
+        if isinstance(device, OphydV1Device):
+            ophyd_devices[name] = device
+        elif isinstance(device, OphydV2Device):
+            ophyd_async_devices[name] = device
+        else:
+            raise ValueError(f"{name}: {device} is not an ophyd or ophyd-async device")
+    return ophyd_devices, ophyd_async_devices
+
+
 def get_beamline_based_on_environment_variable() -> ModuleType:
     """
     Gets the dodal module for the current beamline, as specified by the