dls-dodal 1.66.0__py3-none-any.whl → 1.68.0__py3-none-any.whl

dodal/devices/cryostream.py

@@ -1,5 +1,4 @@
 from ophyd_async.core import (
-    EnabledDisabled,
     InOut,
     StandardReadable,
     StandardReadableFormat,
@@ -12,20 +11,6 @@ from ophyd_async.epics.core import (
 )
 
 
-class CryoStream(StandardReadable):
-    MAX_TEMP_K = 110
-    MAX_PRESSURE_BAR = 0.1
-
-    def __init__(self, prefix: str, name: str = ""):
-        self.course = epics_signal_rw(InOut, f"{prefix}-EA-CJET-01:COARSE:CTRL")
-        self.fine = epics_signal_rw(InOut, f"{prefix}-EA-CJET-01:FINE:CTRL")
-        self.temperature_k = epics_signal_r(float, f"{prefix}-EA-CSTRM-01:TEMP")
-        self.back_pressure_bar = epics_signal_r(
-            float, f"{prefix}-EA-CSTRM-01:BACKPRESS"
-        )
-        super().__init__(name)
-
-
 class TurboEnum(StrictEnum):
     OFF = "Off"
     ON = "On"
@@ -37,59 +22,33 @@ class CryoStreamSelection(StrictEnum):
     HC1 = "HC1"
 
 
-class OxfordCryoStreamController(StandardReadable):
+class OxfordCryoStream(StandardReadable):
     def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.temp = epics_signal_r(float, f"{prefix}TEMP")
+
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Any signals that should be read once at the start of the scan
+
             self.turbo = epics_signal_rw(str, f"{prefix}TURBO")
             self.turbo_mode = epics_signal_rw(TurboEnum, f"{prefix}TURBOMODE")
-
-            self.serial_comms = epics_signal_rw(EnabledDisabled, f"{prefix}DISABLE")
             self.status = epics_signal_r(str, f"{prefix}STATUS.SEVR")
-
-        with self.add_children_as_readables():
-            # Any signals that should be read at every point in the scan
-
-            self.purge = epics_signal_x(f"{prefix}PURGE.PROC")
-            self.hold = epics_signal_x(f"{prefix}HOLD.PROC")
-            self.start = epics_signal_x(f"{prefix}RESTART.PROC")
-            self.pause = epics_signal_x(f"{prefix}PAUSE.PROC")
-            self.resume = epics_signal_x(f"{prefix}RESUME.PROC")
-            self.end = epics_signal_x(f"{prefix}END.PROC")
-            self.stop = epics_signal_x(f"{prefix}STOP.PROC")
-
-            self.ramp_rate = epics_signal_rw(float, f"{prefix}RRATE")
-            self.ramp_temp = epics_signal_rw(float, f"{prefix}RTEMP")
-            self.ramp = epics_signal_x(f"{prefix}RAMP.PROC")
-
-            self.plat_time = epics_signal_rw(float, f"{prefix}PTIME")
-            self.plat = epics_signal_x(f"{prefix}PLAT.PROC")
-
-            self.cool_temp = epics_signal_rw(float, f"{prefix}CTEMP")
-            self.cool = epics_signal_x(f"{prefix}COOL.PROC")
-
-            self.end_rate = epics_signal_rw(float, f"{prefix}ERATE")
-
-        super().__init__(name)
-
-
-class OxfordCryoStreamStatus(StandardReadable):
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            # Any signals that should be read once at the start of the scan
-
             self.pump_uptime = epics_signal_r(float, f"{prefix}RUNTIME")
             self.controller_number = epics_signal_r(float, f"{prefix}CTRLNUM")
             self.software_version = epics_signal_r(float, f"{prefix}VER")
             self.evap_adjust = epics_signal_r(float, f"{prefix}EVAPADJUST")
             self.series = epics_signal_r(str, f"{prefix}SERIES")
+            self.error = epics_signal_r(float, f"{prefix}ERROR")
+            self.mode = epics_signal_r(str, f"{prefix}RUNMODE")
 
         with self.add_children_as_readables():
             # Any signals that should be read at every point in the scan
+            self.ramp_rate = epics_signal_rw(float, f"{prefix}RRATE")
+            self.ramp_temp = epics_signal_rw(float, f"{prefix}RTEMP")
+            self.plat_time = epics_signal_rw(float, f"{prefix}PTIME")
+            self.cool_temp = epics_signal_rw(float, f"{prefix}CTEMP")
+            self.end_rate = epics_signal_rw(float, f"{prefix}ERATE")
             self.setpoint = epics_signal_r(float, f"{prefix}SETPOINT")
-            self.temp = epics_signal_r(float, f"{prefix}TEMP")
-            self.error = epics_signal_r(float, f"{prefix}ERROR")
-            self.mode = epics_signal_r(str, f"{prefix}RUNMODE")
             self.phase = epics_signal_r(str, f"{prefix}PHASE")
             self.ramp_rate_setpoint = epics_signal_r(float, f"{prefix}RAMPRATE")
             self.target_temp = epics_signal_r(float, f"{prefix}TARGETTEMP")
@@ -102,14 +61,27 @@ class OxfordCryoStreamStatus(StandardReadable):
             self.suct_heat = epics_signal_r(float, f"{prefix}SUCTHEAT")
             self.back_pressure = epics_signal_r(float, f"{prefix}BACKPRESS")
 
+        self.purge = epics_signal_x(f"{prefix}PURGE.PROC")
+        self.hold = epics_signal_x(f"{prefix}HOLD.PROC")
+        self.start = epics_signal_x(f"{prefix}RESTART.PROC")
+        self.pause = epics_signal_x(f"{prefix}PAUSE.PROC")
+        self.resume = epics_signal_x(f"{prefix}RESUME.PROC")
+        self.end = epics_signal_x(f"{prefix}END.PROC")
+        self.stop = epics_signal_x(f"{prefix}STOP.PROC")
+        self.plat = epics_signal_x(f"{prefix}PLAT.PROC")
+        self.cool = epics_signal_x(f"{prefix}COOL.PROC")
+        self.ramp = epics_signal_x(f"{prefix}RAMP.PROC")
+
         super().__init__(name)
 
 
-class OxfordCryoStream(StandardReadable):
+class OxfordCryoJet(StandardReadable):
+    # TODO: https://github.com/DiamondLightSource/dodal/issues/1486
+    # This is a placeholder implementation to get it working with I03, the actual cryojet has many more PVs
     def __init__(self, prefix: str, name=""):
         with self.add_children_as_readables():
-            self.controller = OxfordCryoStreamController(prefix=prefix)
-            self.status = OxfordCryoStreamStatus(prefix=prefix)
+            self.coarse = epics_signal_rw(InOut, f"{prefix}COARSE:CTRL")
+            self.fine = epics_signal_rw(InOut, f"{prefix}FINE:CTRL")
 
         super().__init__(name)
 
@@ -126,5 +98,4 @@ class CryoStreamGantry(StandardReadable):
             self.cryostream_selected = epics_signal_r(
                 int, f"{prefix}-MO-STEP-02:GPIO_INP_BITS.B3"
             )
-
         super().__init__(name)

dodal/devices/eiger.py

@@ -1,11 +1,10 @@
-# type: ignore # Eiger will soon be ophyd-async https://github.com/DiamondLightSource/dodal/issues/700
 from dataclasses import dataclass
 from enum import Enum
 
 from bluesky.protocols import Stageable
 from ophyd import Component, Device, EpicsSignalRO, Signal
 from ophyd.areadetector.cam import EigerDetectorCam
-from ophyd.status import AndStatus, Status, StatusBase
+from ophyd.status import AndStatus, Status, StatusBase, SubscriptionStatus
 
 from dodal.devices.detector import DetectorParams, TriggerMode
 from dodal.devices.eiger_odin import EigerOdin
@@ -64,14 +63,12 @@ class EigerDetector(Device, Stageable):
     arming_status = Status()
     arming_status.set_finished()
 
-    disarming_status = Status()
-    disarming_status.set_finished()
-
     def __init__(self, beamline: str = "i03", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.beamline = beamline
         # using i03 timeouts as default
         self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
+        self.disarming_status = None
 
     @classmethod
     def with_params(
@@ -106,6 +103,7 @@ class EigerDetector(Device, Stageable):
             raise Exception("\n".join(errors))
 
     def async_stage(self):
+        self.disarming_status = None
         self.odin.nodes.clear_odin_errors()
         status_ok, error_message = self.odin.wait_for_odin_initialised(
             self.timeouts.general_status_timeout
@@ -124,7 +122,7 @@ class EigerDetector(Device, Stageable):
             LOGGER.info("Waiting for arming to finish")
             self.arming_status.wait(self.timeouts.arming_timeout)
 
-    def stage(self):
+    def stage(self):  # pyright: ignore[reportIncompatibleMethodOverride]
         self.wait_on_arming_if_started()
         if not self.is_armed():
             LOGGER.info("Eiger not armed, arming")
@@ -133,6 +131,7 @@ class EigerDetector(Device, Stageable):
 
     def stop_odin_when_all_frames_collected(self):
         LOGGER.info("Waiting on all frames")
+        assert self.detector_params
         try:
             await_value(
                 self.odin.file_writer.num_captured,
@@ -142,7 +141,7 @@ class EigerDetector(Device, Stageable):
             LOGGER.info("Stopping Odin")
             self.odin.stop().wait(self.timeouts.odin_stop_timeout)
 
-    def unstage(self) -> bool:
+    def unstage(self) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
         assert self.detector_params is not None
         try:
             self.disarming_status = Status()
@@ -167,25 +166,34 @@ class EigerDetector(Device, Stageable):
         self.disarming_status.set_finished()
         return status_ok
 
-    def stop(self, *args):
+    def stop(self, *args):  # pyright: ignore[reportIncompatibleMethodOverride]
         """Emergency stop the device, mainly used to clean up after error."""
         LOGGER.info("Eiger stop() called - cleaning up...")
-        if not self.disarming_status.done:
+        if self.disarming_status and not self.disarming_status.done:
             LOGGER.info("Eiger still disarming, waiting on disarm")
             self.disarming_status.wait(self.timeouts.arming_timeout)
+        elif not self.disarming_status:
+            self.disarming_status = Status()
+            try:
+                self.wait_on_arming_if_started()
+                stop_status = self.odin.stop()
+                self.odin.file_writer.start_timeout.set(1).wait(
+                    self.timeouts.general_status_timeout
+                )
+                self.disarm_detector()
+                stop_status &= self.disable_roi_mode()
+                LOGGER.info("Waiting on stop status")
+                stop_status.wait(self.timeouts.general_status_timeout)
+                # See https://github.com/DiamondLightSource/hyperion/issues/1395
+                LOGGER.info("Turning off Eiger dev/shm streaming")
+                self.odin.fan.dev_shm_enable.set(0).wait(
+                    self.timeouts.general_status_timeout
+                )
+                LOGGER.info("Eiger has successfully been stopped")
+            finally:
+                self.disarming_status.set_finished()
         else:
-            self.wait_on_arming_if_started()
-            stop_status = self.odin.stop()
-            self.odin.file_writer.start_timeout.set(1).wait(
-                self.timeouts.general_status_timeout
-            )
-            self.disarm_detector()
-            stop_status &= self.disable_roi_mode()
-            stop_status.wait(self.timeouts.general_status_timeout)
-            # See https://github.com/DiamondLightSource/hyperion/issues/1395
-            LOGGER.info("Turning off Eiger dev/shm streaming")
-            self.odin.fan.dev_shm_enable.set(0).wait()
-            LOGGER.info("Eiger has successfully been stopped")
+            LOGGER.info("Already disarmed, doing nothing")
 
     def disable_roi_mode(self):
         return self.change_roi_mode(False)
@@ -194,13 +202,13 @@ class EigerDetector(Device, Stageable):
         return self.change_roi_mode(True)
 
     def change_roi_mode(self, enable: bool) -> StatusBase:
+        LOGGER.info(f"Changing ROI mode to {enable}")
         assert self.detector_params is not None
         detector_dimensions = (
             self.detector_params.detector_size_constants.roi_size_pixels
             if enable
             else self.detector_params.detector_size_constants.det_size_pixels
         )
-
         status = self.cam.roi_mode.set(
             1 if enable else 0, timeout=self.timeouts.general_status_timeout
         )
@@ -216,7 +224,6 @@ class EigerDetector(Device, Stageable):
         status &= self.odin.file_writer.num_col_chunks.set(
             detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
-
         return status
 
     def set_cam_pvs(self) -> AndStatus:
@@ -234,7 +241,8 @@ class EigerDetector(Device, Stageable):
             1, timeout=self.timeouts.general_status_timeout
         )
         status &= self.cam.image_mode.set(
-            self.cam.ImageMode.MULTIPLE, timeout=self.timeouts.general_status_timeout
+            self.cam.ImageMode.MULTIPLE,  # pyright: ignore[reportAttributeAccessIssue]
+            timeout=self.timeouts.general_status_timeout,
         )
         status &= self.cam.trigger_mode.set(
             InternalEigerTriggerMode.EXTERNAL_SERIES.value,
@@ -296,6 +304,7 @@ class EigerDetector(Device, Stageable):
             self.detector_params.omega_increment,
             timeout=self.timeouts.general_status_timeout,
         )
+
         return status
 
     def set_detector_threshold(self, energy: float, tolerance: float = 0.1) -> Status:
@@ -307,7 +316,7 @@ class EigerDetector(Device, Stageable):
                 this tolerance it is not set again. Defaults to 0.1eV.
         """
 
-        current_energy = self.cam.photon_energy.get()
+        current_energy = float(self.cam.photon_energy.get())
         if abs(current_energy - energy) > tolerance:
             LOGGER.info(f"Setting detector threshold to {energy}")
             return self.cam.photon_energy.set(
@@ -390,7 +399,7 @@ class EigerDetector(Device, Stageable):
     def disarm_detector(self):
         self.cam.acquire.set(0).wait(self.timeouts.general_status_timeout)
 
-    def wait_for_stale_params(self) -> Status:
+    def wait_for_stale_params(self) -> SubscriptionStatus:
         LOGGER.info("Eiger arming: Waiting for stale params...")
         return await_value(self.stale_params, 0, 60)
 
@@ -404,6 +413,11 @@ class EigerDetector(Device, Stageable):
         detector_params: DetectorParams = self.detector_params
         if detector_params.use_roi_mode:
             functions_to_do_arm.append(self.enable_roi_mode)
+        threshold_energy = (
+            detector_params.expected_energy_ev
+            if detector_params.expected_energy_ev
+            else float(self.cam.photon_energy.get())
+        )
 
         arming_sequence_funcs = [
             # If a beam dump occurs after arming the eiger but prior to eiger staging,
@@ -411,7 +425,7 @@ class EigerDetector(Device, Stageable):
             # if this previously completed successfully we must reset the odin first
             self.odin.stop,
             lambda: self.change_dev_shm(detector_params.enable_dev_shm),
-            lambda: self.set_detector_threshold(detector_params.expected_energy_ev),
+            lambda: self.set_detector_threshold(threshold_energy),
             self.set_cam_pvs,
             self.set_odin_number_of_frame_chunks,
             self.set_odin_pvs,

dodal/devices/electron_analyser/__init__.py

@@ -1,33 +0,0 @@
-from .detector import (
-    ElectronAnalyserDetector,
-    ElectronAnalyserRegionDetector,
-    TElectronAnalyserDetector,
-    TElectronAnalyserRegionDetector,
-)
-from .energy_sources import DualEnergySource, EnergySource
-from .enums import EnergyMode, SelectedSource
-from .types import (
-    ElectronAnalyserDetectorImpl,
-    ElectronAnalyserDriverImpl,
-    GenericElectronAnalyserDetector,
-    GenericElectronAnalyserRegionDetector,
-)
-from .util import to_binding_energy, to_kinetic_energy
-
-__all__ = [
-    "to_binding_energy",
-    "to_kinetic_energy",
-    "DualEnergySource",
-    "SelectedSource",
-    "EnergySource",
-    "EnergyMode",
-    "SelectedSource",
-    "ElectronAnalyserDetector",
-    "ElectronAnalyserDetectorImpl",
-    "ElectronAnalyserDriverImpl",
-    "TElectronAnalyserDetector",
-    "ElectronAnalyserRegionDetector",
-    "TElectronAnalyserRegionDetector",
-    "GenericElectronAnalyserDetector",
-    "GenericElectronAnalyserRegionDetector",
-]

dodal/devices/electron_analyser/base/__init__.py

@@ -0,0 +1,58 @@
+from .base_controller import (
+    ElectronAnalyserController,
+    GenericElectronAnalyserController,
+)
+from .base_detector import (
+    BaseElectronAnalyserDetector,
+    ElectronAnalyserDetector,
+    ElectronAnalyserRegionDetector,
+    GenericBaseElectronAnalyserDetector,
+    GenericElectronAnalyserDetector,
+    GenericElectronAnalyserRegionDetector,
+)
+from .base_driver_io import (
+    AbstractAnalyserDriverIO,
+    GenericAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from .base_enums import EnergyMode, SelectedSource
+from .base_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+    GenericRegion,
+    GenericSequence,
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+    TAcquisitionMode,
+    TLensMode,
+)
+from .base_util import to_binding_energy, to_kinetic_energy
+from .energy_sources import DualEnergySource, EnergySource
+
+__all__ = [
+    "ElectronAnalyserController",
+    "GenericElectronAnalyserController",
+    "BaseElectronAnalyserDetector",
+    "ElectronAnalyserDetector",
+    "ElectronAnalyserRegionDetector",
+    "GenericBaseElectronAnalyserDetector",
+    "GenericElectronAnalyserDetector",
+    "GenericElectronAnalyserRegionDetector",
+    "AbstractAnalyserDriverIO",
+    "GenericAnalyserDriverIO",
+    "TAbstractAnalyserDriverIO",
+    "EnergyMode",
+    "SelectedSource",
+    "AbstractBaseRegion",
+    "AbstractBaseSequence",
+    "GenericRegion",
+    "GenericSequence",
+    "TAbstractBaseRegion",
+    "TAbstractBaseSequence",
+    "TAcquisitionMode",
+    "TLensMode",
+    "to_binding_energy",
+    "to_kinetic_energy",
+    "DualEnergySource",
+    "EnergySource",
+]

dodal/devices/electron_analyser/base/base_controller.py

@@ -0,0 +1,73 @@
+from typing import Generic, TypeVar
+
+from ophyd_async.core import TriggerInfo
+from ophyd_async.epics.adcore import ADImageMode
+
+from dodal.devices.controllers import ConstantDeadTimeController
+from dodal.devices.electron_analyser.base.base_driver_io import (
+    GenericAnalyserDriverIO,
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.base.base_region import (
+    GenericRegion,
+    TAbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.base.energy_sources import (
+    AbstractEnergySource,
+    DualEnergySource,
+)
+
+
+class ElectronAnalyserController(
+    ConstantDeadTimeController[TAbstractAnalyserDriverIO],
+    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
+):
+    """
+    Specialised controller for the electron analysers to provide additional setup logic
+    such as selecting the energy source to use from requested region and giving the
+    driver the correct region parameters.
+    """
+
+    def __init__(
+        self,
+        driver: TAbstractAnalyserDriverIO,
+        energy_source: AbstractEnergySource,
+        deadtime: float,
+        image_mode: ADImageMode = ADImageMode.SINGLE,
+    ):
+        """
+        Parameters:
+            driver: The electron analyser driver to wrap around that holds the PV's.
+            energy_source: Device that holds the excitation energy and ability to switch
+                           between sources.
+            deadtime: For a given exposure, what is the safest minimum time between
+                      exposures that can be determined without reading signals.
+            image_mode: The image mode to configure the driver with before measuring.
+        """
+        self.energy_source = energy_source
+        super().__init__(driver, deadtime, image_mode)
+
+    async def setup_with_region(self, region: TAbstractBaseRegion):
+        """Logic to set the driver with a region."""
+
+        if isinstance(self.energy_source, DualEnergySource):
+            self.energy_source.selected_source.set(region.excitation_energy_source)
+        excitation_energy = await self.energy_source.energy.get_value()
+        epics_region = region.prepare_for_epics(excitation_energy)
+        await self.driver.set(epics_region)
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        """Do all necessary steps to prepare the detector for triggers."""
+        # Let the driver know the excitation energy before measuring for binding energy
+        # axis calculation.
+        excitation_energy = await self.energy_source.energy.get_value()
+        await self.driver.cached_excitation_energy.set(excitation_energy)
+        await super().prepare(trigger_info)
+
+
+GenericElectronAnalyserController = ElectronAnalyserController[
+    GenericAnalyserDriverIO, GenericRegion
+]
+TElectronAnalyserController = TypeVar(
+    "TElectronAnalyserController", bound=ElectronAnalyserController
+)