dls-dodal 1.50.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

dodal/common/device_utils.py

@@ -0,0 +1,45 @@
+from asyncio import CancelledError, create_task, sleep
+from contextlib import asynccontextmanager
+
+from dodal.log import LOGGER
+
+
+@asynccontextmanager
+async def periodic_reminder(
+    message: str = "Waiting",
+    schedule: tuple[tuple[int | float, int | None], ...] = (  # seconds, frequency
+        (1, 3),
+        (5, 3),
+        (60, 5),
+        (300, 5),
+        (1800, 5),
+        (3600, None),
+    ),
+):
+    """Periodically logs a message according to a schedule with increasing delays.
+
+    Args:
+        message: The message the user wants to output through logging.
+        schedule: A tuple list of tuples consisting of (int|float, int|None).
+            A sequence of (delay_seconds, count) pairs defining the logging intervals.
+            - delay_seconds is the number of seconds to wait between logs.
+            - count is how many times to log at this interval. If count is None, it logs indefinitely at that delay.
+    """
+
+    async def _log_loop():
+        for delay, count in schedule:
+            n = 0
+            while count is None or n < count:
+                LOGGER.info(message)
+                await sleep(delay)
+                n += 1
+
+    task = create_task(_log_loop())
+    try:
+        yield
+    finally:
+        task.cancel()
+        try:
+            await task
+        except CancelledError:
+            pass

dodal/devices/aithre_lasershaping/goniometer.py

@@ -1,11 +1,13 @@
 import asyncio
 import math
 
-from ophyd_async.core import StandardReadable, derived_signal_rw
+from ophyd_async.core import derived_signal_rw
 from ophyd_async.epics.motor import Motor
 
+from dodal.devices.motors import XYZStage
 
-class Goniometer(StandardReadable):
+
+class Goniometer(XYZStage):
     """The Aithre lab goniometer and the XYZ stage it sits on.
 
     `x`, `y` and `z` control the axes of the positioner at the base, while `sampy` and
@@ -18,9 +20,6 @@ class Goniometer(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-        self.z = Motor(prefix + "Z")
         self.sampy = Motor(prefix + "SAMPY")
         self.sampz = Motor(prefix + "SAMPZ")
         self.omega = Motor(prefix + "OMEGA")

dodal/devices/aperture.py

@@ -1,14 +1,11 @@
-from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r
-from ophyd_async.epics.motor import Motor
 
+from dodal.devices.motors import XYZStage
 
-class Aperture(StandardReadable):
+
+class Aperture(XYZStage):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.x = Motor(prefix + "X")
-        self.y = Motor(prefix + "Y")
-        self.z = Motor(prefix + "Z")
         self.small = epics_signal_r(float, prefix + "Y:SMALL_CALC")
         self.medium = epics_signal_r(float, prefix + "Y:MEDIUM_CALC")
         self.large = epics_signal_r(float, prefix + "Y:LARGE_CALC")
-        super().__init__(name)
+        super().__init__(prefix, name)

dodal/devices/aperturescatterguard.py

@@ -15,7 +15,7 @@ from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
 from dodal.devices.aperture import Aperture
-from dodal.devices.scatterguard import Scatterguard
+from dodal.devices.motors import XYStage
 
 
 class InvalidApertureMove(Exception):
@@ -164,7 +164,7 @@ class ApertureScatterguard(StandardReadable, Preparable):
         name: str = "",
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
-        self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
+        self.scatterguard = XYStage(prefix + "-MO-SCAT-01:")
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):

dodal/devices/attenuator/attenuator.py

@@ -39,10 +39,12 @@ class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     Where desired_transmission is fraction e.g. 0-1. When the actual_transmission is
     read from the device it is also fractional"""
 
-    def __init__(self, prefix: str, name: str = ""):
+    def __init__(self, prefix: str, num_filters: int, name: str = ""):
         self._calculated_filter_states: DeviceVector[SignalR[int]] = DeviceVector(
             {
-                int(digit, 16): epics_signal_r(int, f"{prefix}DEC_TO_BIN.B{digit}")
+                int(digit, num_filters): epics_signal_r(
+                    int, f"{prefix}DEC_TO_BIN.B{digit}"
+                )
                 for digit in string.hexdigits
                 if not digit.islower()
             }
@@ -50,7 +52,7 @@ class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
         self._filters_in_position: DeviceVector[SignalR[bool]] = DeviceVector(
             {
                 i - 1: epics_signal_r(bool, f"{prefix}FILTER{i}:INLIM")
-                for i in range(1, 17)
+                for i in range(1, num_filters + 1)
             }
         )
 

dodal/devices/b07/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.b07.enums import Grating, LensMode
+
+__all__ = ["Grating", "LensMode"]

dodal/devices/b07/enums.py

@@ -0,0 +1,24 @@
+from ophyd_async.core import StrictEnum, SupersetEnum
+
+
+class Grating(StrictEnum):
+    NI_400 = "400 l/mm Ni"
+    NI_1000 = "1000 l/mm Ni"
+    PT_600 = "BAD 600 l/mm Pt"
+    AU_600 = "600 l/mm Au"
+    NO_GRATING = "No Grating"
+
+
+class LensMode(SupersetEnum):
+    LARGE_AREA = "LargeArea"
+    HIGH_MAGNIFICATION = "HighMagnification"
+    MEDIUM_MAGNIFICATION = "MediumMagnification"
+    LOW_MAGNIFICATION = "LowMagnification"
+    MEDIUM_ANGULAR_DISPERSION = "MediumAngularDispersion"
+    LOW_ANGULAR_DISPERSION = "LowAngularDispersion"
+    HIGH_ANGULAR_DISPERSION = "HighAngularDispersion"
+    WIDE_ANGLE_MODE = "WideAngleMode"
+    MEDIUM_AREA = "MediumArea"
+    SMALL_AREA = "SmallArea"
+    HIGH_MAGNIFICATION2 = "HighMagnification2"
+    NOT_CONNECTED = "Not connected"

dodal/devices/b07_1/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.b07_1.enums import Grating, LensMode
+
+__all__ = ["Grating", "LensMode"]

dodal/devices/b07_1/enums.py

@@ -0,0 +1,18 @@
+from ophyd_async.core import StrictEnum, SupersetEnum
+
+
+class Grating(StrictEnum):
+    AU_400 = "400 l/mm Au"
+    AU_600 = "600 l/mm Au"
+    PT_600 = "600 l/mm Pt"
+    AU_1200 = "1200 l/mm Au"
+    ML_1200 = "1200 l/mm ML"
+    NO_GRATING = "No Grating"
+
+
+class LensMode(SupersetEnum):
+    SMALL_AREA = "SmallArea"
+    ANGLE_RESOLVED_MODE_22 = "AngleResolvedMode22"
+    ANGLE_RESOLVED_MODE_30 = "AngleResolvedMode30"
+    LARGE_AREA = "LargeArea"
+    NOT_CONNECTED = "Not connected"

dodal/devices/detector/detector_motion.py

@@ -1,42 +1,44 @@
-from ophyd_async.core import Device, StrictEnum
+from ophyd_async.core import StrictEnum
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
 
+from dodal.devices.motors import XYZStage
+
 
 class ShutterState(StrictEnum):
     CLOSED = "Closed"
     OPEN = "Open"
 
 
-class DetectorMotion(Device):
+class DetectorMotion(XYZStage):
+    _device_prefix = "-MO-DET-01:"
+    _pmac_prefix = "-MO-PMAC-02:"
+
     def __init__(self, prefix: str, name: str = ""):
-        device_prefix = "-MO-DET-01:"
-        pmac_prefix = "-MO-PMAC-02:"
+        device_prefix = f"{prefix}{self._device_prefix}"
+        pmac_prefix = f"{prefix}{self._pmac_prefix}"
 
-        self.upstream_x = Motor(f"{prefix}{device_prefix}UPSTREAMX")
-        self.downstream_x = Motor(f"{prefix}{device_prefix}DOWNSTREAMX")
-        self.x = Motor(f"{prefix}{device_prefix}X")
-        self.y = Motor(f"{prefix}{device_prefix}Y")
-        self.z = Motor(f"{prefix}{device_prefix}Z")
-        self.yaw = Motor(f"{prefix}{device_prefix}YAW")
+        self.upstream_x = Motor(f"{device_prefix}UPSTREAMX")
+        self.downstream_x = Motor(f"{device_prefix}DOWNSTREAMX")
+        self.yaw = Motor(f"{device_prefix}YAW")
 
         self.shutter = epics_signal_rw(
-            ShutterState, f"{prefix}{device_prefix}SET_SHUTTER_STATE"
+            ShutterState, f"{device_prefix}SET_SHUTTER_STATE"
         )
         self.shutter_closed_lim = epics_signal_r(
-            float, f"{prefix}{device_prefix}CLOSE_LIMIT"
+            float, f"{device_prefix}CLOSE_LIMIT"
         )  # on limit = 1, off = 0
         self.shutter_open_lim = epics_signal_r(
-            float, f"{prefix}{device_prefix}OPEN_LIMIT"
+            float, f"{device_prefix}OPEN_LIMIT"
         )  # on limit = 1, off = 0
         self.z_disabled = epics_signal_r(
-            float, f"{prefix}{device_prefix}Z:DISABLED"
+            float, f"{device_prefix}Z:DISABLED"
         )  # robot interlock, 0=ok to move, 1=blocked
         self.crate_power = epics_signal_r(
-            float, f"{prefix}{pmac_prefix}CRATE2_HEALTHY"
+            float, f"{pmac_prefix}CRATE2_HEALTHY"
         )  # returns 0 if no power
         self.in_robot_load_safe_position = epics_signal_r(
-            int, f"{prefix}{pmac_prefix}GPIO_INP_BITS.B2"
+            int, f"{pmac_prefix}GPIO_INP_BITS.B2"
         )  # returns 1 if safe
 
-        super().__init__(name)
+        super().__init__(device_prefix, name)

dodal/devices/electron_analyser/abstract/__init__.py

@@ -8,6 +8,8 @@ from .base_region import (
     AbstractBaseSequence,
     TAbstractBaseRegion,
     TAbstractBaseSequence,
+    TAcquisitionMode,
+    TLensMode,
 )
 
 __all__ = [
@@ -15,6 +17,8 @@ __all__ = [
     "AbstractBaseSequence",
     "TAbstractBaseRegion",
     "TAbstractBaseSequence",
+    "TAcquisitionMode",
+    "TLensMode",
     "AbstractAnalyserDriverIO",
     "AbstractElectronAnalyserDetector",
     "AbstractAnalyserDriverIO",

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -1,25 +1,26 @@
 import asyncio
 from abc import ABC, abstractmethod
+from collections.abc import Mapping
 from typing import Generic, TypeVar
 
 import numpy as np
-from bluesky.protocols import Movable, Preparable
+from bluesky.protocols import Movable
 from ophyd_async.core import (
     Array1D,
     AsyncStatus,
     SignalR,
     StandardReadable,
     StandardReadableFormat,
-    StrictEnum,
     derived_signal_r,
     soft_signal_rw,
 )
 from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
-from ophyd_async.epics.motor import Motor
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     TAbstractBaseRegion,
+    TAcquisitionMode,
+    TLensMode,
 )
 from dodal.devices.electron_analyser.enums import EnergyMode
 from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
@@ -29,9 +30,8 @@ class AbstractAnalyserDriverIO(
     ABC,
     StandardReadable,
     ADBaseIO,
-    Preparable,
     Movable[TAbstractBaseRegion],
-    Generic[TAbstractBaseRegion],
+    Generic[TAbstractBaseRegion, TAcquisitionMode, TLensMode],
 ):
     """
     Generic device to configure electron analyser with new region settings.
@@ -39,8 +39,30 @@ class AbstractAnalyserDriverIO(
     """
 
     def __init__(
-        self, prefix: str, acquisition_mode_type: type[StrictEnum], name: str = ""
+        self,
+        prefix: str,
+        acquisition_mode_type: type[TAcquisitionMode],
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
     ) -> None:
+        """
+        Constructor method for setting up electron analyser.
+
+        Args:
+            prefix: Base PV to connect to EPICS for this device.
+            acquisition_mode_type: Enum that determines the available acquisition modes
+                                   for this device.
+            lens_mode_type: Enum that determines the available lens mode for this
+                            device.
+            energy_sources: Map that pairs a source name to an energy value signal
+                            (in eV).
+            name: Name of the device.
+        """
+        self.energy_sources = energy_sources
+        self.acquisition_mode_type = acquisition_mode_type
+        self.lens_mode_type = lens_mode_type
+
         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")
@@ -58,7 +80,7 @@ class AbstractAnalyserDriverIO(
             self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
             self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
             self.slices = epics_signal_rw(int, prefix + "SLICES")
-            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.lens_mode = epics_signal_rw(lens_mode_type, prefix + "LENS_MODE")
             self.pass_energy = epics_signal_rw(
                 self.pass_energy_type, prefix + "PASS_ENERGY"
             )
@@ -92,26 +114,6 @@ class AbstractAnalyserDriverIO(
 
         super().__init__(prefix=prefix, name=name)
 
-    @AsyncStatus.wrap
-    async def prepare(self, value: Motor):
-        """
-        Prepare the driver for a region by passing in the energy source motor selected
-        by a region.
-
-        Args:
-            value: The motor that contains the information on the current excitation
-                   energy. Needed to prepare region for epics to accuratly calculate
-                   kinetic energy for an energy scan when in binding energy mode.
-        """
-        energy_source = value
-        excitation_energy_value = await energy_source.user_readback.get_value()  # eV
-        excitation_energy_source_name = energy_source.name
-
-        await asyncio.gather(
-            self.excitation_energy.set(excitation_energy_value),
-            self.excitation_energy_source.set(excitation_energy_source_name),
-        )
-
     @AsyncStatus.wrap
     async def set(self, region: TAbstractBaseRegion):
         """
@@ -121,10 +123,13 @@ class AbstractAnalyserDriverIO(
         Args:
             region: Contains the parameters to setup the driver for a scan.
         """
+
+        source = self._get_energy_source(region.excitation_energy_source)
+        excitation_energy = await source.get_value()  # eV
+
         pass_energy_type = self.pass_energy_type
         pass_energy = pass_energy_type(region.pass_energy)
 
-        excitation_energy = await self.excitation_energy.get_value()
         low_energy = to_kinetic_energy(
             region.low_energy, region.energy_mode, excitation_energy
         )
@@ -141,8 +146,19 @@ class AbstractAnalyserDriverIO(
             self.pass_energy.set(pass_energy),
             self.iterations.set(region.iterations),
             self.acquisition_mode.set(region.acquisition_mode),
+            self.excitation_energy.set(excitation_energy),
+            self.excitation_energy_source.set(source.name),
         )
 
+    def _get_energy_source(self, alias_name: str) -> SignalR[float]:
+        energy_source = self.energy_sources.get(alias_name)
+        if energy_source is None:
+            raise KeyError(
+                f"'{energy_source}' is an invalid energy source. Avaliable energy "
+                + f"sources are '{list(self.energy_sources.keys())}'"
+            )
+        return energy_source
+
     @abstractmethod
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         """

dodal/devices/electron_analyser/abstract/base_region.py

@@ -3,13 +3,11 @@ from abc import ABC
 from collections.abc import Callable
 from typing import Generic, TypeVar
 
-from ophyd_async.core import StrictEnum
+from ophyd_async.core import StrictEnum, SupersetEnum
 from pydantic import BaseModel, Field, model_validator
 
 from dodal.devices.electron_analyser.enums import EnergyMode
 
-TStrictEnum = TypeVar("TStrictEnum", bound=StrictEnum)
-
 
 def java_to_python_case(java_str: str) -> str:
     """
@@ -46,7 +44,18 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
+TAcquisitionMode = TypeVar("TAcquisitionMode", bound=StrictEnum)
+# Allow SupersetEnum. Specs analysers can connect to Lens mode separately to the
+# analyser which leaves the enum to either be "Not connected" OR the available enums
+# when connected.
+TLensMode = TypeVar("TLensMode", bound=SupersetEnum | StrictEnum)
+
+
+class AbstractBaseRegion(
+    ABC,
+    JavaToPythonModel,
+    Generic[TAcquisitionMode, TLensMode],
+):
     """
     Generic region model that holds the data. Specialised region models should inherit
     this to extend functionality. All energy units are assumed to be in eV.
@@ -58,9 +67,9 @@ class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
     iterations: int = 1
     excitation_energy_source: str = "source1"
     # These ones we need subclasses to provide default values
-    lens_mode: str
+    lens_mode: TLensMode
     pass_energy: int
-    acquisition_mode: TStrictEnum
+    acquisition_mode: TAcquisitionMode
     low_energy: float
     high_energy: float
     step_time: float
@@ -83,7 +92,11 @@ class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
 TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
 
 
-class AbstractBaseSequence(ABC, JavaToPythonModel, Generic[TAbstractBaseRegion]):
+class AbstractBaseSequence(
+    ABC,
+    JavaToPythonModel,
+    Generic[TAbstractBaseRegion, TLensMode],
+):
     """
     Generic sequence model that holds the list of region data. Specialised sequence
     models should inherit this to extend functionality and define type of region to

dodal/devices/electron_analyser/detector.py

@@ -1,11 +1,9 @@
 from typing import Generic, TypeVar
 
-from bluesky.protocols import Preparable
 from ophyd_async.core import (
     AsyncStatus,
     Reference,
 )
-from ophyd_async.epics.motor import Motor
 
 from dodal.common.data_util import load_json_file_to_class
 from dodal.devices.electron_analyser.abstract.base_detector import (
@@ -22,7 +20,6 @@ from dodal.devices.electron_analyser.abstract.base_region import (
 
 class ElectronAnalyserRegionDetector(
     AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Preparable,
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
     """
@@ -48,16 +45,10 @@ class ElectronAnalyserRegionDetector(
         return self._driver_ref()
 
     @AsyncStatus.wrap
-    async def prepare(self, value: Motor) -> None:
-        """
-        Prepare driver with the region stored and energy_source motor.
-
-        Args:
-            value: The excitation energy source that the region has selected.
-        """
-        excitation_energy_source = value
-        await self.driver.prepare(excitation_energy_source)
+    async def trigger(self) -> None:
+        # Configure region parameters on the driver first before data collection.
         await self.driver.set(self.region)
+        await super().trigger()
 
 
 TElectronAnalyserRegionDetector = TypeVar(
@@ -82,7 +73,6 @@ class ElectronAnalyserDetector(
 
     def __init__(
         self,
-        prefix: str,
         sequence_class: type[TAbstractBaseSequence],
         driver: TAbstractAnalyserDriverIO,
         name: str = "",

dodal/devices/electron_analyser/specs/detector.py

@@ -1,3 +1,9 @@
+from collections.abc import Mapping
+from typing import Generic
+
+from ophyd_async.core import SignalR
+
+from dodal.devices.electron_analyser.abstract.base_driver_io import TLensMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -6,8 +12,22 @@ from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSeque
 
 
 class SpecsDetector(
-    ElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+    ElectronAnalyserDetector[
+        SpecsAnalyserDriverIO[TLensMode],
+        SpecsSequence[TLensMode],
+        SpecsRegion[TLensMode],
+    ],
+    Generic[TLensMode],
 ):
-    def __init__(self, prefix: str, name: str = ""):
-        driver = SpecsAnalyserDriverIO(prefix=prefix)
-        super().__init__(prefix, SpecsSequence, driver, name)
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
+    ):
+        driver = SpecsAnalyserDriverIO[TLensMode](
+            prefix, lens_mode_type, energy_sources
+        )
+        seq = SpecsSequence[lens_mode_type]
+        super().__init__(seq, driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -1,4 +1,6 @@
 import asyncio
+from collections.abc import Mapping
+from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
@@ -13,12 +15,22 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.abstract.base_region import TLensMode
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
 
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
-    def __init__(self, prefix: str, name: str = "") -> None:
+class SpecsAnalyserDriverIO(
+    AbstractAnalyserDriverIO[SpecsRegion, AcquisitionMode, TLensMode],
+    Generic[TLensMode],
+):
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
+    ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
             self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
@@ -28,11 +40,14 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             # Used to read detector data after acqusition.
             self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
             self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
+            self.energy_channels = epics_signal_r(
+                int, prefix + "TOTAL_POINTS_ITERATION_RBV"
+            )
 
-        super().__init__(prefix, AcquisitionMode, name)
+        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
 
     @AsyncStatus.wrap
-    async def set(self, region: SpecsRegion):
+    async def set(self, region: SpecsRegion[TLensMode]):
         await super().set(region)
 
         await asyncio.gather(
@@ -70,7 +85,7 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             "eV",
             min_energy=self.low_energy,
             max_energy=self.high_energy,
-            total_points_iterations=self.slices,
+            total_points_iterations=self.energy_channels,
         )
         return energy_axis
 

dodal/devices/electron_analyser/specs/region.py

@@ -1,15 +1,18 @@
+from typing import Generic
+
 from pydantic import Field
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
+    TLensMode,
 )
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 
 
-class SpecsRegion(AbstractBaseRegion[AcquisitionMode]):
+class SpecsRegion(AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]):
     # Override base class with defaults
-    lens_mode: str = "SmallArea"
+    lens_mode: TLensMode
     pass_energy: int = 5
     acquisition_mode: AcquisitionMode = AcquisitionMode.FIXED_TRANSMISSION
     low_energy: float = Field(default=800, alias="start_energy")
@@ -19,9 +22,10 @@ class SpecsRegion(AbstractBaseRegion[AcquisitionMode]):
     # Specific to this class
     values: int = 1
     centre_energy: float = 0
-    psu_mode: str = "1.5keV"
+    # ToDo - Update to an enum https://github.com/DiamondLightSource/dodal/issues/1328
+    psu_mode: str = "1.5kV"
     estimated_time_in_ms: float = 0
 
 
-class SpecsSequence(AbstractBaseSequence[SpecsRegion]):
-    regions: list[SpecsRegion] = Field(default_factory=lambda: [])
+class SpecsSequence(AbstractBaseSequence[SpecsRegion, TLensMode], Generic[TLensMode]):
+    regions: list[SpecsRegion[TLensMode]] = Field(default_factory=lambda: [])