dls-dodal 1.55.1__py3-none-any.whl → 1.57.0__py3-none-any.whl

dodal/devices/collimation_table.py

@@ -0,0 +1,36 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class CollimationTable(StandardReadable):
+    """Basic collimation table device for motion plus the motion disable signal
+    when laser curtain triggered and hutch not locked.
+
+    The table has 3 physical vertical motors, the jacks. 1 upstream and 2 downstream.
+    The two downstream jacks are labelled as outboard (away from the ring) and
+    inboard (towards the ring).
+    Together these 3 jacks provide compound motion for vertical motion and pitch/roll.
+    There are 2 physical horizontal motors 1 upstream, 1 downstream. These provide yaw.
+
+    Table motion is disabled by an object being within the laser curtain area and can be
+    overridden by use of the dead man's handle device or locking the hutch. The effect of
+    these disabling systems is to cut power to the motors - signal for this is crate_power
+    """
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.inboard_y = Motor(f"{prefix}:INBOARDY")
+            self.outboard_y = Motor(f"{prefix}:OUTBOARDY")
+            self.upstream_y = Motor(f"{prefix}:UPSTREAMY")
+            self.combined_downstream_y = Motor(f"{prefix}:DOWNSTREAMY")
+            self.combined_all_y = Motor(f"{prefix}:Y")
+
+            self.downstream_x = Motor(f"{prefix}:DOWNSTREAMX")
+            self.upstream_x = Motor(f"{prefix}:UPSTREAMX")
+            self.combined_all_x = Motor(f"{prefix}:X")
+
+            self.pitch = Motor(f"{prefix}:PITCH")
+            self.roll = Motor(f"{prefix}:ROLL")
+            self.yaw = Motor(f"{prefix}:YAW")
+
+            super().__init__(name)

dodal/devices/controllers.py

@@ -0,0 +1,21 @@
+from typing import TypeVar
+
+from ophyd_async.epics.adcore import (
+    ADBaseController,
+    ADBaseIO,
+)
+
+ADBaseIOT = TypeVar("ADBaseIOT", bound=ADBaseIO)
+
+
+class ConstantDeadTimeController(ADBaseController[ADBaseIOT]):
+    """
+    ADBaseController with a configured constant deadtime for a driver of type ADBaseIO.
+    """
+
+    def __init__(self, driver: ADBaseIOT, deadtime: float):
+        super().__init__(driver)
+        self.deadtime = deadtime
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return self.deadtime

dodal/devices/cryostream.py

@@ -1,13 +1,21 @@
-from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
-
-
-class InOut(StrictEnum):
-    IN = "In"
-    OUT = "Out"
+from ophyd_async.core import (
+    EnabledDisabled,
+    InOut,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_x,
+)
 
 
 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")
@@ -15,5 +23,87 @@ class CryoStream(StandardReadable):
         self.back_pressure_bar = epics_signal_r(
             float, f"{prefix}-EA-CSTRM-01:BACKPRESS"
         )
+        super().__init__(name)
+
+
+class TurboEnum(StrictEnum):
+    OFF = "Off"
+    ON = "On"
+    AUTO = "Auto"
+
+
+class OxfordCryoStreamController(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.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")
+
+        with self.add_children_as_readables():
+            # Any signals that should be read at every point in the scan
+            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")
+            self.evap_temp = epics_signal_r(float, f"{prefix}EVAPTEMP")
+            self.time_remaining = epics_signal_r(float, f"{prefix}REMAINING")
+            self.gas_flow = epics_signal_r(float, f"{prefix}GASFLOW")
+            self.gas_heat = epics_signal_r(float, f"{prefix}GASHEAT")
+            self.evap_heat = epics_signal_r(float, f"{prefix}EVAPHEAT")
+            self.suct_temp = epics_signal_r(float, f"{prefix}SUCTTEMP")
+            self.suct_heat = epics_signal_r(float, f"{prefix}SUCTHEAT")
+            self.back_pressure = epics_signal_r(float, f"{prefix}BACKPRESS")
+
+        super().__init__(name)
+
+
+class OxfordCryoStream(StandardReadable):
+    def __init__(self, prefix: str, name=""):
+        with self.add_children_as_readables():
+            self.controller = OxfordCryoStreamController(prefix=prefix)
+            self.status = OxfordCryoStreamStatus(prefix=prefix)
 
         super().__init__(name)

dodal/devices/current_amplifiers/femto.py

@@ -108,7 +108,7 @@ class FemtoDDPCA(CurrentAmp):
         LOGGER.info(f"{self.name} gain change to {SEN_setting}:{value}")
 
         await self.gain.set(
-            value=self.gain_table[SEN_setting].value,
+            value=self.gain_table[SEN_setting],
             timeout=self.timeout,
         )
         # wait for current amplifier's bandpass filter to settle.

dodal/devices/detector/detector_motion.py

@@ -11,13 +11,7 @@ class ShutterState(StrictEnum):
 
 
 class DetectorMotion(XYZStage):
-    _device_prefix = "-MO-DET-01:"
-    _pmac_prefix = "-MO-PMAC-02:"
-
-    def __init__(self, prefix: str, name: str = ""):
-        device_prefix = f"{prefix}{self._device_prefix}"
-        pmac_prefix = f"{prefix}{self._pmac_prefix}"
-
+    def __init__(self, device_prefix: str, pmac_prefix: str, name: str = ""):
         self.upstream_x = Motor(f"{device_prefix}UPSTREAMX")
         self.downstream_x = Motor(f"{device_prefix}DOWNSTREAMX")
         self.yaw = Motor(f"{device_prefix}YAW")

dodal/devices/eiger.py

@@ -219,6 +219,7 @@ class EigerDetector(Device, Stageable):
         return status
 
     def set_cam_pvs(self) -> AndStatus:
+        LOGGER.info("Eiger arming: Setting eiger camera PVs...")
         assert self.detector_params is not None
         status = self.cam.acquire_time.set(
             self.detector_params.exposure_time_s,
@@ -241,6 +242,7 @@ class EigerDetector(Device, Stageable):
         return status
 
     def set_odin_number_of_frame_chunks(self) -> Status:
+        LOGGER.info("Eiger arming: Setting odin number of frames chunks...")
         assert self.detector_params is not None
         status = self.odin.file_writer.num_frames_chunks.set(
             1, timeout=self.timeouts.general_status_timeout
@@ -248,6 +250,7 @@ class EigerDetector(Device, Stageable):
         return status
 
     def set_odin_pvs(self) -> StatusBase:
+        LOGGER.info("Eiger arming: Setting odin PVs...")
         assert self.detector_params is not None
         file_prefix = self.detector_params.full_filename
         status = self.odin.file_writer.file_path.set(
@@ -269,6 +272,7 @@ class EigerDetector(Device, Stageable):
         return status
 
     def set_mx_settings_pvs(self):
+        LOGGER.info("Eiger arming: Setting mx setting PVs...")
         assert self.detector_params is not None
         beam_x_pixels, beam_y_pixels = self.detector_params.get_beam_position_pixels(
             self.detector_params.detector_distance
@@ -304,10 +308,14 @@ class EigerDetector(Device, Stageable):
 
         current_energy = 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(
                 energy, timeout=self.timeouts.general_status_timeout
             )
         else:
+            LOGGER.info(
+                f"Not setting detector threshold as already close to {current_energy}"
+            )
             status = Status()
             status.set_finished()
             return status
@@ -317,7 +325,7 @@ class EigerDetector(Device, Stageable):
         during the datacollection. The number of images is the number of images per
         trigger.
         """
-
+        LOGGER.info("Eiger arming: setting num triggers and captures...")
         assert self.detector_params is not None
         status = self.cam.num_images.set(
             self.detector_params.num_images_per_trigger,
@@ -351,7 +359,7 @@ class EigerDetector(Device, Stageable):
         status = self.odin.file_writer.capture.set(
             1, timeout=self.timeouts.general_status_timeout
         )
-        LOGGER.info("Eiger staging: awaiting odin metadata")
+        LOGGER.info("Eiger arming: awaiting odin metadata")
         status &= await_value(
             self.odin.meta.ready, 1, timeout=self.timeouts.meta_file_ready_timeout
         )
@@ -359,11 +367,11 @@ class EigerDetector(Device, Stageable):
 
     def _wait_fan_ready(self) -> StatusBase:
         self.filewriters_finished = self.odin.create_finished_status()
-        LOGGER.info("Eiger staging: awaiting odin fan ready")
+        LOGGER.info("Eiger arming: awaiting odin fan ready")
         return await_value(self.odin.fan.ready, 1, self.timeouts.general_status_timeout)
 
     def _finish_arm(self) -> Status:
-        LOGGER.info("Eiger staging: Finishing arming")
+        LOGGER.info("Eiger arming: Finishing arming")
         status = Status()
         status.set_finished()
         return status
@@ -381,6 +389,14 @@ 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:
+        LOGGER.info("Eiger arming: Waiting for stale params...")
+        return await_value(self.stale_params, 0, 60)
+
+    def set_cam_acquire(self) -> Status:
+        LOGGER.info("Eiger arming: Setting cam acquire...")
+        return self.cam.acquire.set(1, timeout=self.timeouts.general_status_timeout)
+
     def do_arming_chain(self) -> Status:
         functions_to_do_arm = []
         assert self.detector_params
@@ -400,11 +416,9 @@ class EigerDetector(Device, Stageable):
             self.set_odin_pvs,
             self.set_mx_settings_pvs,
             self.set_num_triggers_and_captures,
-            lambda: await_value(self.stale_params, 0, 60),
+            self.wait_for_stale_params,
             self._wait_for_odin_status,
-            lambda: self.cam.acquire.set(
-                1, timeout=self.timeouts.general_status_timeout
-            ),
+            self.set_cam_acquire,
             self._wait_fan_ready,
             self._finish_arm,
         ]

dodal/devices/eiger_odin.py

@@ -7,6 +7,7 @@ from ophyd.sim import NullStatus
 from ophyd.status import StatusBase, SubscriptionStatus
 
 from dodal.devices.status import await_value
+from dodal.log import LOGGER
 
 
 class EigerFan(Device):
@@ -167,6 +168,7 @@ class EigerOdin(Device):
 
     def stop(self) -> StatusBase:
         """Stop odin manually"""
+        LOGGER.info("Stopping Odin...")
         status = self.file_writer.capture.set(0)
         status &= self.meta.stop_writing.set(1)
         return status

dodal/devices/electron_analyser/__init__.py

@@ -4,7 +4,7 @@ from .detector import (
     TElectronAnalyserDetector,
     TElectronAnalyserRegionDetector,
 )
-from .enums import EnergyMode
+from .enums import EnergyMode, SelectedSource
 from .types import (
     ElectronAnalyserDetectorImpl,
     ElectronAnalyserDriverImpl,
@@ -17,6 +17,7 @@ __all__ = [
     "to_binding_energy",
     "to_kinetic_energy",
     "EnergyMode",
+    "SelectedSource",
     "ElectronAnalyserDetector",
     "ElectronAnalyserDetectorImpl",
     "ElectronAnalyserDriverImpl",

dodal/devices/electron_analyser/abstract/__init__.py

@@ -1,5 +1,4 @@
 from .base_detector import (
-    AbstractAnalyserDriverIO,
     AbstractElectronAnalyserDetector,
 )
 from .base_driver_io import AbstractAnalyserDriverIO, TAbstractAnalyserDriverIO

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -1,8 +1,7 @@
-import asyncio
 from abc import abstractmethod
 from typing import Generic
 
-from bluesky.protocols import Reading, Stageable, Triggerable
+from bluesky.protocols import Reading, Triggerable
 from event_model import DataKey
 from ophyd_async.core import (
     AsyncConfigurable,
@@ -10,24 +9,15 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
 )
-from ophyd_async.epics.adcore import (
-    ADBaseController,
-)
 
+from dodal.devices.controllers import ConstantDeadTimeController
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
-    AbstractAnalyserDriverIO,
     TAbstractAnalyserDriverIO,
 )
 
 
-class ElectronAnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
-    def get_deadtime(self, exposure: float | None) -> float:
-        return 0
-
-
 class AbstractElectronAnalyserDetector(
     Device,
-    Stageable,
     Triggerable,
     AsyncReadable,
     AsyncConfigurable,
@@ -47,9 +37,7 @@ class AbstractElectronAnalyserDetector(
         driver: TAbstractAnalyserDriverIO,
         name: str = "",
     ):
-        self.controller: ElectronAnalyserController = ElectronAnalyserController(
-            driver=driver
-        )
+        self.controller = ConstantDeadTimeController(driver, 0)
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -57,16 +45,6 @@ class AbstractElectronAnalyserDetector(
         await self.controller.arm()
         await self.controller.wait_for_idle()
 
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        """Make sure the detector is idle and ready to be used."""
-        await asyncio.gather(self.controller.disarm())
-
-    @AsyncStatus.wrap
-    async def unstage(self) -> None:
-        """Disarm the detector."""
-        await asyncio.gather(self.controller.disarm())
-
     async def read(self) -> dict[str, Reading]:
         return await self.driver.read()
 

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -13,7 +13,7 @@ from ophyd_async.core import (
     derived_signal_r,
     soft_signal_rw,
 )
-from ophyd_async.epics.adcore import ADBaseIO
+from ophyd_async.epics.adcore import ADBaseIO, ADImageMode
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.electron_analyser.abstract.base_region import (
@@ -25,7 +25,7 @@ from dodal.devices.electron_analyser.abstract.types import (
     TPassEnergy,
     TPsuMode,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode
+from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
 from dodal.devices.electron_analyser.util import to_binding_energy
 
 
@@ -49,7 +49,7 @@ class AbstractAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergy],
-        energy_sources: Mapping[str, SignalR[float]],
+        energy_sources: Mapping[SelectedSource, SignalR[float]],
         name: str = "",
     ) -> None:
         """
@@ -75,6 +75,9 @@ class AbstractAnalyserDriverIO(
         self.psu_mode_type = psu_mode_type
         self.pass_energy_type = pass_energy_type
 
+        # must call first to initiate parent variables
+        super().__init__(prefix=prefix, name=name)
+
         with self.add_children_as_readables():
             self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
             self.spectrum = epics_signal_r(Array1D[np.float64], prefix + "INT_SPECTRUM")
@@ -84,7 +87,8 @@ class AbstractAnalyserDriverIO(
             self.excitation_energy = soft_signal_rw(float, initial_value=0, units="eV")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            # Used for setting up region data acquisition.
+            # Read once per scan after data acquired
+            # Used for setting up region data acquisition
             self.region_name = soft_signal_rw(str, initial_value="null")
             self.energy_mode = soft_signal_rw(
                 EnergyMode, initial_value=EnergyMode.KINETIC
@@ -105,8 +109,11 @@ class AbstractAnalyserDriverIO(
             # analyser type to know if is moved with region settings.
             self.psu_mode = epics_signal_rw(psu_mode_type, prefix + "PSU_MODE")
 
+        # This is defined in the parent class, add it as readable configuration.
+        self.add_readables([self.acquire_time], StandardReadableFormat.CONFIG_SIGNAL)
+
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            # Read once per scan after data acquired
+            # NOT used for setting up region data acquisition.
             self.energy_axis = self._create_energy_axis_signal(prefix)
             self.binding_energy_axis = derived_signal_r(
                 self._calculate_binding_energy_axis,
@@ -116,17 +123,19 @@ class AbstractAnalyserDriverIO(
                 energy_mode=self.energy_mode,
             )
             self.angle_axis = self._create_angle_axis_signal(prefix)
-            self.step_time = epics_signal_r(float, prefix + "AcquireTime")
             self.total_steps = epics_signal_r(int, prefix + "TOTAL_POINTS_RBV")
             self.total_time = derived_signal_r(
                 self._calculate_total_time,
                 "s",
                 total_steps=self.total_steps,
-                step_time=self.step_time,
+                step_time=self.acquire_time,
                 iterations=self.iterations,
             )
 
-        super().__init__(prefix=prefix, name=name)
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        await self.image_mode.set(ADImageMode.SINGLE)
+        await super().stage()
 
     @abstractmethod
     @AsyncStatus.wrap
@@ -139,7 +148,7 @@ class AbstractAnalyserDriverIO(
             region: Contains the parameters to setup the driver for a scan.
         """
 
-    def _get_energy_source(self, alias_name: str) -> SignalR[float]:
+    def _get_energy_source(self, alias_name: SelectedSource) -> SignalR[float]:
         energy_source = self.energy_sources.get(alias_name)
         if energy_source is None:
             raise KeyError(

dodal/devices/electron_analyser/abstract/base_region.py

@@ -10,7 +10,8 @@ from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
     TPassEnergy,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode
+from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
+from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
 
 
 def java_to_python_case(java_str: str) -> str:
@@ -62,7 +63,7 @@ class AbstractBaseRegion(
     enabled: bool = False
     slices: int = 1
     iterations: int = 1
-    excitation_energy_source: str = "source1"
+    excitation_energy_source: SelectedSource = SelectedSource.SOURCE1
     # These ones we need subclasses to provide default values
     lens_mode: TLensMode
     pass_energy: TPassEnergy
@@ -70,16 +71,46 @@ class AbstractBaseRegion(
     low_energy: float
     centre_energy: float
     high_energy: float
-    step_time: float
+    acquire_time: float
     energy_step: float  # in eV
     energy_mode: EnergyMode = EnergyMode.KINETIC
 
     def is_binding_energy(self) -> bool:
+        """
+        Returns true if the energy_mode is binding.
+        """
         return self.energy_mode == EnergyMode.BINDING
 
     def is_kinetic_energy(self) -> bool:
+        """
+        Returns true if the energy_mode is kinetic.
+        """
         return self.energy_mode == EnergyMode.KINETIC
 
+    def switch_energy_mode(
+        self, energy_mode: EnergyMode, excitation_energy: float
+    ) -> None:
+        """
+        Switch region to new energy mode: Kinetic or Binding. Updates the low_energy,
+        centre_energy, high_energy, and energy_mode, only if it switches to a new one.
+
+        Parameters:
+            energy_mode: mode you want to switch the region to.
+            excitation_energy: the energy to calculate the new values of low_energy,
+                               centre_energy, and high_energy.
+        """
+        conv = (
+            to_binding_energy
+            if energy_mode == EnergyMode.BINDING
+            else to_kinetic_energy
+        )
+        self.low_energy = conv(self.low_energy, self.energy_mode, excitation_energy)
+        self.centre_energy = conv(
+            self.centre_energy, self.energy_mode, excitation_energy
+        )
+        self.high_energy = conv(self.high_energy, self.energy_mode, excitation_energy)
+        self.energy_mode = energy_mode
+
     @model_validator(mode="before")
     @classmethod
     def before_validation(cls, data: dict) -> dict:

dodal/devices/electron_analyser/detector.py

@@ -1,5 +1,6 @@
 from typing import Generic, TypeVar
 
+from bluesky.protocols import Stageable
 from ophyd_async.core import (
     AsyncStatus,
     Reference,
@@ -59,6 +60,7 @@ TElectronAnalyserRegionDetector = TypeVar(
 
 class ElectronAnalyserDetector(
     AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Stageable,
     Generic[
         TAbstractAnalyserDriverIO,
         TAbstractBaseSequence,
@@ -88,6 +90,28 @@ class ElectronAnalyserDetector(
         # can be used with connect() method.
         return self._driver
 
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        """
+        Prepare the detector for use by ensuring it is idle and ready.
+
+        This method asynchronously stages the detector by first disarming the controller
+        to ensure the detector is not actively acquiring data, then invokes the driver's
+        stage procedure. This ensures the detector is in a known, ready state
+        before use.
+
+        Raises:
+            Any exceptions raised by the driver's stage or controller's disarm methods.
+        """
+        await self.controller.disarm()
+        await self.driver.stage()
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        """Disarm the detector."""
+        await self.controller.disarm()
+        await self.driver.unstage()
+
     def load_sequence(self, filename: str) -> TAbstractBaseSequence:
         """
         Load the sequence data from a provided json file into a sequence class.

dodal/devices/electron_analyser/enums.py

@@ -4,3 +4,8 @@ from ophyd_async.core import StrictEnum
 class EnergyMode(StrictEnum):
     KINETIC = "Kinetic"
     BINDING = "Binding"
+
+
+class SelectedSource(StrictEnum):
+    SOURCE1 = "source1"
+    SOURCE2 = "source2"

dodal/devices/electron_analyser/specs/detector.py

@@ -7,6 +7,7 @@ from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
+from dodal.devices.electron_analyser.enums import SelectedSource
 from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
 
@@ -24,7 +25,7 @@ class SpecsDetector(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_sources: Mapping[str, SignalR[float]],
+        energy_sources: Mapping[SelectedSource, SignalR[float]],
         name: str = "",
     ):
         driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](