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

dodal/devices/oav/oav_detector.py

@@ -40,15 +40,15 @@ class ZoomController(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        super().__init__(name=name)
         self.percentage = epics_signal_rw(float, f"{prefix}ZOOMPOSCMD")
 
         # Level is the string description of the zoom level e.g. "1.0x" or "1.0"
         self.level = epics_signal_rw(str, f"{prefix}MP:SELECT")
+        super().__init__(name=name)
 
     async def _get_allowed_zoom_levels(self) -> list:
         zoom_levels = await self.level.describe()
-        return zoom_levels["level"]["choices"]  # type: ignore
+        return zoom_levels[self.level.name]["choices"]  # type: ignore
 
     @AsyncStatus.wrap
     async def set(self, level_to_set: str):

dodal/devices/oav/pin_image_recognition/__init__.py

@@ -2,7 +2,6 @@ import asyncio
 import time
 
 import numpy as np
-from numpy.typing import NDArray
 from ophyd_async.core import (
     Array1D,
     AsyncStatus,
@@ -57,12 +56,12 @@ class PinTipDetection(StandardReadable):
             Tip, name="triggered_tip"
         )
         self.triggered_top_edge, self._top_edge_setter = soft_signal_r_and_setter(
-            NDArray[np.uint32], name="triggered_top_edge"
+            Array1D[np.int32], name="triggered_top_edge"
         )
         self.triggered_bottom_edge, self._bottom_edge_setter = soft_signal_r_and_setter(
-            NDArray[np.uint32], name="triggered_bottom_edge"
+            Array1D[np.int32], name="triggered_bottom_edge"
         )
-        self.array_data = epics_signal_r(NDArray[np.uint8], f"pva://{prefix}PVA:ARRAY")
+        self.array_data = epics_signal_r(Array1D[np.uint8], f"pva://{prefix}PVA:ARRAY")
 
         # Soft parameters for pin-tip detection.
         self.preprocess_operation = soft_signal_rw(int, 10, name="preprocess")
@@ -101,7 +100,7 @@ class PinTipDetection(StandardReadable):
         self._bottom_edge_setter(results.edge_bottom)
 
     async def _get_tip_and_edge_data(
-        self, array_data: NDArray[np.uint8]
+        self, array_data: Array1D[np.uint8]
     ) -> SampleLocation:
         """
         Gets the location of the pin tip and the top and bottom edges.

dodal/devices/oav/utils.py

@@ -87,6 +87,7 @@ def calculate_x_y_z_of_pixel(
     beam_centre: tuple[int, int],
     microns_per_pixel: tuple[float, float],
 ) -> np.ndarray:
+    """Get the x, y, z position of a pixel in mm"""
     beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
 
     return current_x_y_z + camera_coordinates_to_xyz(

dodal/devices/p99/sample_stage.py

@@ -1,18 +1,13 @@
-from ophyd_async.core import Device, SubsetEnum
-from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.core import StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_rw, epics_signal_rw_rbv
 
 
-class SampleAngleStage(Device):
-    def __init__(self, prefix: str, name: str):
-        self.theta = epics_signal_rw(
-            float, prefix + "WRITETHETA:RBV", prefix + "WRITETHETA"
-        )
-        self.roll = epics_signal_rw(
-            float, prefix + "WRITEROLL:RBV", prefix + "WRITEROLL"
-        )
-        self.pitch = epics_signal_rw(
-            float, prefix + "WRITEPITCH:RBV", prefix + "WRITEPITCH"
-        )
+class SampleAngleStage(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.theta = epics_signal_rw_rbv(float, prefix + "WRITETHETA", ":RBV")
+            self.roll = epics_signal_rw_rbv(float, prefix + "WRITEROLL", ":RBV")
+            self.pitch = epics_signal_rw_rbv(float, prefix + "WRITEPITCH", ":RBV")
         super().__init__(name=name)
 
 
@@ -35,7 +30,8 @@ class p99StageSelections(SubsetEnum):
     User = "User"
 
 
-class FilterMotor(Device):
-    def __init__(self, prefix: str, name: str):
-        self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
+class FilterMotor(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
         super().__init__(name=name)

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/{plans/data_session_metadata.py → plan_stubs/data_session.py}

@@ -2,7 +2,7 @@ from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import MsgGenerator, make_decorator
 
-from dodal.common.beamlines import beamline_utils
+from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.common.types import UpdatingPathProvider
 
 DATA_SESSION = "data_session"
@@ -31,7 +31,7 @@ def attach_data_session_metadata_wrapper(
         Iterator[Msg]: Plan messages
     """
     if provider is None:
-        provider = beamline_utils.get_path_provider()
+        provider = get_path_provider()
     yield from bps.wait_for([provider.update])
     ress = yield from bps.wait_for([provider.data_session])
     data_session = ress[0].result()

dodal/{plans/motor_util_plans.py → plan_stubs/motor_utils.py}

@@ -23,7 +23,7 @@ class MoveTooLarge(Exception):
         super().__init__(*args)
 
 
-def _check_and_cache_values(
+def check_and_cache_values(
     devices_and_positions: dict[MovableReadableDevice, float],
     smallest_move: float,
     maximum_move: float,
@@ -89,7 +89,7 @@ def move_and_reset_wrapper(
                                        on. If false it is left up to the caller to wait on
                                        them. Defaults to True.
     """
-    initial_positions = yield from _check_and_cache_values(
+    initial_positions = yield from check_and_cache_values(
         device_and_positions, smallest_move, maximum_move
     )