dls-dodal 1.31.1__py3-none-any.whl → 1.33.0__py3-none-any.whl

dodal/devices/i24/pmac.py

@@ -1,16 +1,17 @@
+from asyncio import sleep
 from enum import Enum, IntEnum
-from typing import SupportsFloat
 
-from bluesky.protocols import Triggerable
+from bluesky.protocols import Flyable, Triggerable
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
-    CalculateTimeout,
     SignalBackend,
     SignalR,
     SignalRW,
     SoftSignalBackend,
     StandardReadable,
+    soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.epics.motor import Motor
@@ -89,7 +90,7 @@ class PMACStringLaser(SignalRW):
         self,
         value: LaserSettings,
         wait=True,
-        timeout=CalculateTimeout,
+        timeout=CALCULATE_TIMEOUT,
     ):
         await self.signal.set(value.value, wait, timeout)
 
@@ -112,13 +113,13 @@ class PMACStringEncReset(SignalRW):
         self,
         value: EncReset,
         wait=True,
-        timeout=CalculateTimeout,
+        timeout=CALCULATE_TIMEOUT,
     ):
         await self.signal.set(value.value, wait, timeout)
 
 
-class ProgramRunner(SignalRW):
-    """Trigger the collection by setting the program number on the PMAC string.
+class ProgramRunner(SignalRW, Flyable):
+    """Run the collection by setting the program number on the PMAC string.
 
     Once the program number has been set, wait for the collection to be complete.
     This will only be true when the status becomes 0.
@@ -128,22 +129,73 @@ class ProgramRunner(SignalRW):
         self,
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
+        prog_num_sig: SignalRW,
+        collection_time_sig: SignalRW,
         backend: SignalBackend,
         timeout: float | None = DEFAULT_TIMEOUT,
         name: str = "",
     ) -> None:
         self.signal = pmac_str_sig
         self.status = status_sig
+        self.prog_num = prog_num_sig
+
+        self.collection_time = collection_time_sig
+        self.KICKOFF_TIMEOUT = timeout
+
         super().__init__(backend, timeout, name)
 
+    async def _get_prog_number_string(self) -> str:
+        prog_num = await self.prog_num.get_value()
+        return f"&2b{prog_num}r"
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        """Kick off the collection by sending a program number to the pmac_string and \
+            wait for the scan status PV to go to 1.
+        """
+        prog_num_str = await self._get_prog_number_string()
+        await self.signal.set(prog_num_str, wait=True)
+        await wait_for_value(
+            self.status,
+            ScanState.RUNNING,
+            timeout=self.KICKOFF_TIMEOUT,
+        )
+
+    @AsyncStatus.wrap
+    async def complete(self):
+        """Stop collecting when the scan status PV goes to 0.
+
+        Args:
+            complete_time (float): total time required by the collection to \
+            finish correctly.
+        """
+        scan_complete_time = await self.collection_time.get_value()
+        await wait_for_value(self.status, ScanState.DONE, timeout=scan_complete_time)
+
+
+class ProgramAbort(Triggerable):
+    """Abort a data collection by setting the PMAC string and then wait for the \
+        status value to go back to 0.
+    """
+
+    def __init__(
+        self,
+        pmac_str_sig: SignalRW,
+        status_sig: SignalR,
+    ) -> None:
+        self.signal = pmac_str_sig
+        self.status = status_sig
+
     @AsyncStatus.wrap
-    async def set(self, value: int, wait=True, timeout=None):
-        prog_str = f"&2b{value}r"
-        assert isinstance(timeout, SupportsFloat) or (
-            timeout is None
-        ), f"ProgramRunner does not support calculating timeout itself, {timeout=}"
-        await self.signal.set(prog_str, wait=wait)
-        await wait_for_value(self.status, ScanState.DONE, timeout)
+    async def trigger(self):
+        await self.signal.set("A", wait=True)
+        await sleep(1.0)  # TODO Check with scientist what this sleep is really for.
+        await self.signal.set("P2401=0", wait=True)
+        await wait_for_value(
+            self.status,
+            ScanState.DONE,
+            timeout=DEFAULT_TIMEOUT,
+        )
 
 
 class PMAC(StandardReadable):
@@ -172,8 +224,18 @@ class PMAC(StandardReadable):
         self.scanstatus = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2401")
         self.counter = epics_signal_r(float, "BL24I-MO-STEP-14:signal:P2402")
 
+        # A couple of soft signals for running a collection: program number to send to
+        # the PMAC_STRING and expected collection time.
+        self.program_number = soft_signal_rw(int)
+        self.collection_time = soft_signal_rw(float, initial_value=600.0, units="s")
+
         self.run_program = ProgramRunner(
-            self.pmac_string, self.scanstatus, backend=SoftSignalBackend(str)
+            self.pmac_string,
+            self.scanstatus,
+            self.program_number,
+            self.collection_time,
+            backend=SoftSignalBackend(str),
         )
+        self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 
         super().__init__(name)

dodal/devices/oav/oav_detector.py

@@ -12,7 +12,6 @@ from ophyd import (
     OverlayPlugin,
     ProcessPlugin,
     ROIPlugin,
-    Signal,
     StatusBase,
 )
 
@@ -35,8 +34,6 @@ class ZoomController(Device):
 
     # Level is the string description of the zoom level e.g. "1.0x"
     level = Component(EpicsSignal, "MP:SELECT", string=True)
-    # Used by OAV to work out if we're changing the setpoint
-    _level_sp = Component(Signal)
 
     zrst = Component(EpicsSignal, "MP:SELECT.ZRST")
     onst = Component(EpicsSignal, "MP:SELECT.ONST")
@@ -46,14 +43,6 @@ class ZoomController(Device):
     fvst = Component(EpicsSignal, "MP:SELECT.FVST")
     sxst = Component(EpicsSignal, "MP:SELECT.SXST")
 
-    def set_flatfield_on_zoom_level_one(self, value):
-        self.parent: OAV
-        flat_applied = self.parent.proc.port_name.get()
-        no_flat_applied = self.parent.cam.port_name.get()
-        return self.parent.grid_snapshot.input_plugin.set(
-            flat_applied if value == "1.0x" else no_flat_applied
-        )
-
     @property
     def allowed_zoom_levels(self):
         return [
@@ -67,10 +56,7 @@ class ZoomController(Device):
         ]
 
     def set(self, level_to_set: str) -> StatusBase:
-        return_status = self._level_sp.set(level_to_set)
-        return_status &= self.level.set(level_to_set)
-        return_status &= self.set_flatfield_on_zoom_level_one(level_to_set)
-        return return_status
+        return self.level.set(level_to_set)
 
 
 class OAV(AreaDetector):

dodal/devices/robot.py

@@ -1,5 +1,5 @@
 import asyncio
-from asyncio import FIRST_COMPLETED, CancelledError, Task
+from asyncio import FIRST_COMPLETED, CancelledError, Task, wait_for
 from dataclasses import dataclass
 from enum import Enum
 
@@ -41,6 +41,9 @@ class PinMounted(str, Enum):
 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
+    # How long to wait for the actual load to happen
     LOAD_TIMEOUT = 60
     NO_PIN_ERROR_CODE = 25
 
@@ -54,10 +57,15 @@ class BartRobot(StandardReadable, Movable):
     ) -> None:
         self.barcode = epics_signal_r(str, prefix + "BARCODE")
         self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
+        self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
+        self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
+
         self.next_sample_id = epics_signal_rw_rbv(float, prefix + "NEXT_ID")
         self.sample_id = epics_signal_r(float, prefix + "CURRENT_ID_RBV")
+
         self.load = epics_signal_x(prefix + "LOAD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
@@ -93,7 +101,7 @@ class BartRobot(StandardReadable, Movable):
             for task in finished:
                 await task
         except CancelledError:
-            # If the outer enclosing task cancels after LOAD_TIMEOUT, this causes CancelledError to be raised
+            # If the outer enclosing task cancels after a timeout, this causes CancelledError to be raised
             # in the current task, when it propagates to here we should cancel all pending tasks before bubbling up
             for task in tasks:
                 task.cancel()
@@ -105,7 +113,9 @@ class BartRobot(StandardReadable, Movable):
             LOGGER.info(
                 f"Waiting on robot to finish {await self.program_name.get_value()}"
             )
-            await wait_for_value(self.program_running, False, None)
+            await wait_for_value(
+                self.program_running, False, timeout=self.NOT_BUSY_TIMEOUT
+            )
         await asyncio.gather(
             set_and_wait_for_value(self.next_puck, sample_location.puck),
             set_and_wait_for_value(self.next_pin, sample_location.pin),
@@ -121,10 +131,12 @@ class BartRobot(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def set(self, value: SampleLocation):
         try:
-            await asyncio.wait_for(
-                self._load_pin_and_puck(value), timeout=self.LOAD_TIMEOUT
+            await wait_for(
+                self._load_pin_and_puck(value),
+                timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
-        except asyncio.TimeoutError as e:
+        except (asyncio.TimeoutError, TimeoutError) as e:
+            # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             error_code = await self.error_code.get_value()
             error_string = await self.error_str.get_value()
             raise RobotLoadFailed(int(error_code), error_string) from e

dodal/devices/tetramm.py

@@ -3,13 +3,13 @@ from enum import Enum
 
 from bluesky.protocols import Hints
 from ophyd_async.core import (
-    AsyncStatus,
     DatasetDescriber,
     DetectorControl,
     DetectorTrigger,
     Device,
     PathProvider,
     StandardDetector,
+    TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
 )
@@ -113,29 +113,24 @@ class TetrammController(DetectorControl):
         # 2 internal clock cycles. Best effort approximation
         return 2 / self.base_sample_rate
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.edge_trigger,
-        exposure: float | None = None,
-    ) -> AsyncStatus:
-        if exposure is None:
-            raise ValueError(
-                "Tetramm does not support arm without exposure time. "
-                "Is this a software scan? Tetramm only supports hardware scans."
-            )
-        self._validate_trigger(trigger)
+    async def prepare(self, trigger_info: TriggerInfo):
+        self._validate_trigger(trigger_info.trigger)
+        assert trigger_info.livetime is not None
 
         # trigger mode must be set first and on its own!
         await self._drv.trigger_mode.set(TetrammTrigger.ExtTrigger)
 
         await asyncio.gather(
-            self._drv.averaging_time.set(exposure), self.set_exposure(exposure)
+            self._drv.averaging_time.set(trigger_info.livetime),
+            self.set_exposure(trigger_info.livetime),
         )
 
-        status = await set_and_wait_for_value(self._drv.acquire, True)
+    async def arm(self):
+        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
 
-        return status
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {

dodal/devices/undulator.py

@@ -1,12 +1,35 @@
 from enum import Enum
 
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
+import numpy as np
+from bluesky.protocols import Movable
+from numpy import argmin, ndarray
+from ophyd_async.core import (
+    AsyncStatus,
+    ConfigSignal,
+    StandardReadable,
+    soft_signal_r_and_setter,
+)
 from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.signal import epics_signal_r
 
+from dodal.log import LOGGER
+
+from .util.lookup_tables import energy_distance_table
+
+
+class AccessError(Exception):
+    pass
+
+
+# Enable to allow testing when the beamline is down, do not change in production!
+TEST_MODE = False
+# will be made more generic in https://github.com/DiamondLightSource/dodal/issues/754
+
+
 # The acceptable difference, in mm, between the undulator gap and the DCM
 # energy, when the latter is converted to mm using lookup tables
 UNDULATOR_DISCREPANCY_THRESHOLD_MM = 2e-3
+STATUS_TIMEOUT_S: float = 10.0
 
 
 class UndulatorGapAccess(str, Enum):
@@ -14,7 +37,15 @@ class UndulatorGapAccess(str, Enum):
     DISABLED = "DISABLED"
 
 
-class Undulator(StandardReadable):
+def _get_closest_gap_for_energy(
+    dcm_energy_ev: float, energy_to_distance_table: ndarray
+) -> float:
+    table = energy_to_distance_table.transpose()
+    idx = argmin(np.abs(table[0] - dcm_energy_ev))
+    return table[1][idx]
+
+
+class Undulator(StandardReadable, Movable):
     """
     An Undulator-type insertion device, used to control photon emission at a given
     beam energy.
@@ -23,6 +54,7 @@ class Undulator(StandardReadable):
     def __init__(
         self,
         prefix: str,
+        id_gap_lookup_table_path: str,
         name: str = "",
         poles: int | None = None,
         length: float | None = None,
@@ -36,6 +68,7 @@ class Undulator(StandardReadable):
             name (str, optional): Name for device. Defaults to "".
         """
 
+        self.id_gap_lookup_table_path = id_gap_lookup_table_path
         with self.add_children_as_readables():
             self.gap_motor = Motor(prefix + "BLGAPMTR")
             self.current_gap = epics_signal_r(float, prefix + "CURRGAPD")
@@ -63,3 +96,59 @@ class Undulator(StandardReadable):
                 self.length = None
 
         super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """
+        Set the undulator gap to a given energy in keV
+
+        Args:
+            value: energy in keV
+        """
+        await self._set_undulator_gap(value)
+
+    async def _set_undulator_gap(self, energy_kev: float) -> None:
+        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")
+        LOGGER.info(f"Setting undulator gap to {energy_kev:.2f} kev")
+        target_gap = await self._get_gap_to_match_energy(energy_kev)
+
+        # Check if undulator gap is close enough to the value from the DCM
+        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"
+            )
+            if not TEST_MODE:
+                # Only move if the gap is sufficiently different to the value from the
+                # DCM lookup table AND we're not in TEST_MODE
+                await self.gap_motor.set(
+                    target_gap,
+                    timeout=STATUS_TIMEOUT_S,
+                )
+            else:
+                LOGGER.debug("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"
+            )
+
+    async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
+        """
+        get a 2d np.array from lookup table that
+        converts energies to undulator gap distance
+        """
+        energy_to_distance_table: np.ndarray = await energy_distance_table(
+            self.id_gap_lookup_table_path
+        )
+
+        # Use the lookup table to get the undulator gap associated with this dcm energy
+        return _get_closest_gap_for_energy(
+            energy_kev * 1000,
+            energy_to_distance_table,
+        )

dodal/devices/undulator_dcm.py

@@ -1,19 +1,14 @@
 import asyncio
 
-import numpy as np
 from bluesky.protocols import Movable
-from numpy import argmin, ndarray
 from ophyd_async.core import AsyncStatus, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
-from dodal.log import LOGGER
 
 from .dcm import DCM
 from .undulator import Undulator, UndulatorGapAccess
-from .util.lookup_tables import energy_distance_table
 
 ENERGY_TIMEOUT_S: float = 30.0
-STATUS_TIMEOUT_S: float = 10.0
 
 # Enable to allow testing when the beamline is down, do not change in production!
 TEST_MODE = False
@@ -23,14 +18,6 @@ class AccessError(Exception):
     pass
 
 
-def _get_closest_gap_for_energy(
-    dcm_energy_ev: float, energy_to_distance_table: ndarray
-) -> float:
-    table = energy_to_distance_table.transpose()
-    idx = argmin(np.abs(table[0] - dcm_energy_ev))
-    return table[1][idx]
-
-
 class UndulatorDCM(StandardReadable, Movable):
     """
     Composite device to handle changing beamline energies, wraps the Undulator and the
@@ -48,7 +35,6 @@ class UndulatorDCM(StandardReadable, Movable):
         self,
         undulator: Undulator,
         dcm: DCM,
-        id_gap_lookup_table_path: str,
         daq_configuration_path: str,
         prefix: str = "",
         name: str = "",
@@ -61,11 +47,10 @@ class UndulatorDCM(StandardReadable, Movable):
         self.dcm = dcm
 
         # These attributes are just used by hyperion for lookup purposes
-        self.id_gap_lookup_table_path = id_gap_lookup_table_path
-        self.dcm_pitch_converter_lookup_table_path = (
+        self.pitch_energy_table_path = (
             daq_configuration_path + "/lookup/BeamLineEnergy_DCM_Pitch_converter.txt"
         )
-        self.dcm_roll_converter_lookup_table_path = (
+        self.roll_energy_table_path = (
             daq_configuration_path + "/lookup/BeamLineEnergy_DCM_Roll_converter.txt"
         )
         # I03 configures the DCM Perp as a side effect of applying this fixed value to the DCM Offset after an energy change
@@ -78,7 +63,7 @@ class UndulatorDCM(StandardReadable, Movable):
     async def set(self, value: float):
         await asyncio.gather(
             self._set_dcm_energy(value),
-            self._set_undulator_gap_if_required(value),
+            self.undulator.set(value),
         )
 
     async def _set_dcm_energy(self, energy_kev: float) -> None:
@@ -90,42 +75,3 @@ class UndulatorDCM(StandardReadable, Movable):
             energy_kev,
             timeout=ENERGY_TIMEOUT_S,
         )
-
-    async def _set_undulator_gap_if_required(self, energy_kev: float) -> None:
-        LOGGER.info(f"Setting DCM energy to {energy_kev:.2f} kev")
-        gap_to_match_dcm_energy = await self._gap_to_match_dcm_energy(energy_kev)
-
-        # Check if undulator gap is close enough to the value from the DCM
-        current_gap = await self.undulator.current_gap.get_value()
-        tolerance = await self.undulator.gap_discrepancy_tolerance_mm.get_value()
-        if abs(gap_to_match_dcm_energy - current_gap) > tolerance:
-            LOGGER.info(
-                f"Undulator gap mismatch. {abs(gap_to_match_dcm_energy-current_gap):.3f}mm is outside tolerance.\
-                Moving gap to nominal value, {gap_to_match_dcm_energy:.3f}mm"
-            )
-            if not TEST_MODE:
-                # Only move if the gap is sufficiently different to the value from the
-                # DCM lookup table AND we're not in TEST_MODE
-                await self.undulator.gap_motor.set(
-                    gap_to_match_dcm_energy,
-                    timeout=STATUS_TIMEOUT_S,
-                )
-            else:
-                LOGGER.debug("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"
-            )
-
-    async def _gap_to_match_dcm_energy(self, energy_kev: float) -> float:
-        # Get 2d np.array converting energies to undulator gap distance, from lookup table
-        energy_to_distance_table = await energy_distance_table(
-            self.id_gap_lookup_table_path
-        )
-
-        # Use the lookup table to get the undulator gap associated with this dcm energy
-        return _get_closest_gap_for_energy(
-            energy_kev * 1000,
-            energy_to_distance_table,
-        )

dodal/devices/webcam.py

@@ -1,12 +1,24 @@
+from collections.abc import ByteString
+from io import BytesIO
 from pathlib import Path
 
 import aiofiles
 from aiohttp import ClientSession
 from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, HintedSignal, StandardReadable, soft_signal_rw
+from PIL import Image
 
 from dodal.log import LOGGER
 
+PLACEHOLDER_IMAGE_SIZE = (1024, 768)
+IMAGE_FORMAT = "png"
+
+
+def create_placeholder_image() -> ByteString:
+    image = Image.new("RGB", PLACEHOLDER_IMAGE_SIZE)
+    image.save(buffer := BytesIO(), format=IMAGE_FORMAT)
+    return buffer.getbuffer()
+
 
 class Webcam(StandardReadable, Triggerable):
     def __init__(self, name, prefix, url):
@@ -18,19 +30,33 @@ class Webcam(StandardReadable, Triggerable):
         self.add_readables([self.last_saved_path], wrapper=HintedSignal)
         super().__init__(name=name)
 
-    async def _write_image(self, file_path: str):
+    async def _write_image(self, file_path: str, image: ByteString):
+        async with aiofiles.open(file_path, "wb") as file:
+            await file.write(image)
+
+    async def _get_and_write_image(self, file_path: str):
         async with ClientSession() as session:
             async with session.get(self.url) as response:
-                response.raise_for_status()
-                LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
-                async with aiofiles.open(file_path, "wb") as file:
-                    await file.write(await response.read())
+                if not response.ok:
+                    LOGGER.warning(
+                        f"Webcam responded with {response.status}: {response.reason}. Attempting to read anyway."
+                    )
+                try:
+                    data = await response.read()
+                    LOGGER.info(f"Saving webcam image from {self.url} to {file_path}")
+                except Exception as e:
+                    LOGGER.warning(
+                        f"Failed to read data from {self.url} ({e}). Using placeholder image."
+                    )
+                    data = create_placeholder_image()
+
+                await self._write_image(file_path, data)
 
     @AsyncStatus.wrap
     async def trigger(self) -> None:
         filename = await self.filename.get_value()
         directory = await self.directory.get_value()
 
-        file_path = Path(f"{directory}/{filename}.png").as_posix()
-        await self._write_image(file_path)
+        file_path = Path(f"{directory}/{filename}.{IMAGE_FORMAT}").as_posix()
+        await self._get_and_write_image(file_path)
         await self.last_saved_path.set(file_path)

dodal/devices/zocalo/zocalo_interaction.py

@@ -39,7 +39,12 @@ class ZocaloStartInfo:
 
 
 def _get_zocalo_headers() -> tuple[str, str]:
-    user = os.environ.get("ZOCALO_GO_USER", getpass.getuser())
+    user = os.environ.get("ZOCALO_GO_USER")
+
+    # cannot default as getuser() will throw when called from inside a container
+    if not user:
+        user = getpass.getuser()
+
     hostname = os.environ.get("ZOCALO_GO_HOSTNAME", socket.gethostname())
     return user, hostname