dls-dodal 1.53.0__py3-none-any.whl → 1.55.0__py3-none-any.whl

dodal/beamlines/i20_1.py

@@ -1,12 +1,15 @@
 from pathlib import Path
 
+from ophyd_async.epics.motor import Motor
+from ophyd_async.fastcs.panda import HDFPanda
+
 from dodal.common.beamlines.beamline_utils import (
     device_factory,
+    get_path_provider,
     set_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.common.visit import RemoteDirectoryServiceClient, StaticVisitPathProvider
-from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.turbo_slit import TurboSlit
 from dodal.devices.xspress3.xspress3 import Xspress3
 from dodal.log import set_beamline as set_log_beamline
@@ -31,9 +34,14 @@ set_path_provider(
     )
 )
 
+"""
+NOTE: Due to the CA gateway machine being switched off, PVs are not available remotely
+and you need to be on the beamline network to access them.
+The simplest way to do this is to `ssh i20-1-ws001` and run dodal connect i20_1 from there.
+"""
 
-# NOTE this is mock as we cannot move items on the beamline until we get sign-off to do so
-@device_factory(mock=True)
+
+@device_factory()
 def turbo_slit() -> TurboSlit:
     """
     turboslit for selecting energy from the polychromator
@@ -42,18 +50,39 @@ def turbo_slit() -> TurboSlit:
     return TurboSlit(f"{PREFIX.beamline_prefix}-OP-PCHRO-01:TS:")
 
 
+@device_factory()
+def turbo_slit_x() -> Motor:
+    """
+    turbo slit x motor
+    """
+    return Motor(f"{PREFIX.beamline_prefix}-OP-PCHRO-01:TS:XFINE")
+
+
+@device_factory()
+def panda() -> HDFPanda:
+    return HDFPanda(
+        f"{PREFIX.beamline_prefix}-EA-PANDA-02:", path_provider=get_path_provider()
+    )
+
+
+# Use mock device until motors are reconnected on the beamline
+@device_factory(mock=True)
+def alignment_x() -> Motor:
+    return Motor(f"{PREFIX.beamline_prefix}-MO-STAGE-01:X")
+
+
+# Use mock device until motors are reconnected on the beamline
+@device_factory(mock=True)
+def alignment_y() -> Motor:
+    return Motor(f"{PREFIX.beamline_prefix}-MO-STAGE-01:Y")
+
+
 @device_factory(skip=True)
 def xspress3() -> Xspress3:
     """
     16 channels Xspress3 detector
     """
-
     return Xspress3(
         f"{PREFIX.beamline_prefix}-EA-DET-03:",
         num_channels=16,
     )
-
-
-@device_factory()
-def synchrotron() -> Synchrotron:
-    return Synchrotron()

dodal/beamlines/i23.py

@@ -72,7 +72,7 @@ def oav_pin_tip_detection() -> PinTipDetection:
 @device_factory()
 def shutter() -> ZebraShutter:
     """Get the i23 zebra controlled shutter."""
-    return ZebraShutter(f"{PREFIX.beamline_prefix}-EA-SHTR-01:", "shutter")
+    return ZebraShutter(f"{PREFIX.beamline_prefix}-EA-SHTR-01:")
 
 
 @device_factory()
@@ -85,7 +85,6 @@ def gonio() -> SixAxisGonio:
 def zebra() -> Zebra:
     """Get the i23 zebra"""
     return Zebra(
-        name="zebra",
         prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:ZEBRA:",
         mapping=I23_ZEBRA_MAPPING,
     )

dodal/beamlines/i24.py

@@ -51,7 +51,6 @@ def attenuator() -> ReadOnlyAttenuator:
     existing object."""
     return ReadOnlyAttenuator(
         f"{PREFIX.beamline_prefix}-OP-ATTN-01:",
-        "attenuator",
     )
 
 
@@ -62,7 +61,6 @@ def aperture() -> Aperture:
     """
     return Aperture(
         f"{PREFIX.beamline_prefix}-AL-APTR-01:",
-        "aperture",
     )
 
 
@@ -73,7 +71,6 @@ def beamstop() -> Beamstop:
     """
     return Beamstop(
         f"{PREFIX.beamline_prefix}-MO-BS-01:",
-        "beamstop",
     )
 
 
@@ -84,7 +81,6 @@ def backlight() -> DualBacklight:
     """
     return DualBacklight(
         prefix=PREFIX.beamline_prefix,
-        name="backlight",
     )
 
 
@@ -94,7 +90,6 @@ def detector_motion() -> YZStage:
     If this is called when already instantiated in i24, it will return the existing object.
     """
     return YZStage(
-        name="detector_motion",
         prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:",
     )
 
@@ -105,7 +100,6 @@ def dcm() -> DCM:
     If this is called when already instantiated in i24, it will return the existing object.
     """
     return DCM(
-        name="dcm",
         prefix=PREFIX.beamline_prefix,
     )
 
@@ -145,7 +139,6 @@ def pmac() -> PMAC:
     # prefix not BL but ME14E
     return PMAC(
         "ME14E-MO-CHIP-01:",
-        "pmac",
     )
 
 
@@ -153,7 +146,6 @@ def pmac() -> PMAC:
 def oav() -> OAVBeamCentreFile:
     return OAVBeamCentreFile(
         prefix=f"{PREFIX.beamline_prefix}-DI-OAV-01:",
-        name="oav",
         config=OAVConfigBeamCentre(ZOOM_PARAMS_FILE, DISPLAY_CONFIG),
     )
 
@@ -165,7 +157,6 @@ def vgonio() -> VerticalGoniometer:
     """
     return VerticalGoniometer(
         f"{PREFIX.beamline_prefix}-MO-VGON-01:",
-        "vgonio",
     )
 
 
@@ -175,7 +166,6 @@ def zebra() -> Zebra:
     If this is called when already instantiated in i24, it will return the existing object.
     """
     return Zebra(
-        name="zebra",
         prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:",
         mapping=I24_ZEBRA_MAPPING,
     )
@@ -188,7 +178,6 @@ def shutter() -> HutchShutter:
     """
     return HutchShutter(
         f"{PREFIX.beamline_prefix}-PS-SHTR-01:",
-        "shutter",
     )
 
 
@@ -197,7 +186,6 @@ def focus_mirrors() -> FocusMirrorsMode:
     """Get the i24 focus mirror devise to find the beam size."""
     return FocusMirrorsMode(
         f"{PREFIX.beamline_prefix}-OP-MFM-01:",
-        "focus_mirrors",
     )
 
 

dodal/beamlines/p60.py

@@ -3,7 +3,13 @@ from dodal.common.beamlines.beamline_utils import (
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.devices.electron_analyser.vgscienta import VGScientaAnalyserDriverIO
-from dodal.devices.p60 import LabXraySource, LabXraySourceReadable, LensMode
+from dodal.devices.p60 import (
+    LabXraySource,
+    LabXraySourceReadable,
+    LensMode,
+    PassEnergy,
+    PsuMode,
+)
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -23,14 +29,18 @@ def mg_kalpha_source() -> LabXraySourceReadable:
     return LabXraySourceReadable(LabXraySource.MG_KALPHA)
 
 
+# Connect will work again after this work completed
+# https://jira.diamond.ac.uk/browse/P60-13
 @device_factory()
-def analyser_driver() -> VGScientaAnalyserDriverIO[LensMode]:
+def analyser_driver() -> VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy]:
     energy_sources = {
         "source1": al_kalpha_source().energy_ev,
         "source2": mg_kalpha_source().energy_ev,
     }
-    return VGScientaAnalyserDriverIO[LensMode](
+    return VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy](
         prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:",
         lens_mode_type=LensMode,
+        psu_mode_type=PsuMode,
+        pass_energy_type=PassEnergy,
         energy_sources=energy_sources,
     )

dodal/common/beamlines/beamline_parameters.py

@@ -8,7 +8,7 @@ BEAMLINE_PARAMETER_KEYWORDS = ["FB", "FULL", "deadtime"]
 
 BEAMLINE_PARAMETER_PATHS = {
     "i03": "/dls_sw/i03/software/daq_configuration/domain/beamlineParameters",
-    "i04": "/dls_sw/i04/software/gda_versions/gda_9_34/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
+    "i04": "/dls_sw/i04/software/gda_versions/gda_9_37/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
 }
 
 

dodal/common/beamlines/device_helpers.py

@@ -1,37 +1,4 @@
-from dodal.common.beamlines.beamline_utils import device_instantiation
-from dodal.devices.slits import Slits
-from dodal.utils import skip_device
-
 HDF5_SUFFIX = "HDF5:"
 TIFF_SUFFIX = "TIFF:"
 CAM_SUFFIX = "CAM:"
 DET_SUFFIX = "DET:"
-
-
-@skip_device()
-def numbered_slits(
-    slit_number: int = 1,
-    wait_for_connection: bool = True,
-    fake_with_ophyd_sim: bool = False,
-) -> Slits:
-    """
-    Create a slits object following the {beamline}-AL-SLITS-{slit_number} PV
-    convention
-
-    Args:
-        slit_number: The number assigned to the slits in the control system, usually
-        its position in the assembly. Defaults to 1.
-        wait_for_connection: Require connection on instantiation. Defaults to True.
-        fake_with_ophyd_sim: Make a fake device. Defaults to False.
-
-    Returns:
-        Slits: A new slits object
-    """
-
-    return device_instantiation(
-        Slits,
-        f"slits_{slit_number}",
-        f"-AL-SLITS-{slit_number:02}:",
-        wait_for_connection,
-        fake_with_ophyd_sim,
-    )

dodal/devices/aithre_lasershaping/goniometer.py

@@ -1,10 +1,6 @@
-import asyncio
-import math
-
-from ophyd_async.core import derived_signal_rw
 from ophyd_async.epics.motor import Motor
 
-from dodal.devices.motors import XYZStage
+from dodal.devices.motors import XYZStage, create_axis_perp_to_rotation
 
 
 class Goniometer(XYZStage):
@@ -23,26 +19,7 @@ class Goniometer(XYZStage):
         self.sampy = Motor(prefix + "SAMPY")
         self.sampz = Motor(prefix + "SAMPZ")
         self.omega = Motor(prefix + "OMEGA")
-        self.vertical_position = derived_signal_rw(
-            self._get,
-            self._set,
-            sampy=self.sampy,
-            sampz=self.sampz,
-            omega=self.omega,
+        self.vertical_position = create_axis_perp_to_rotation(
+            self.omega, self.sampz, self.sampy
         )
         super().__init__(name)
-
-    def _get(self, sampz: float, sampy: float, omega: float) -> float:
-        z_component = sampz * math.cos(math.radians(omega))
-        y_component = sampy * math.sin(math.radians(omega))
-        return z_component + y_component
-
-    async def _set(self, value: float) -> None:
-        omega = await self.omega.user_readback.get_value()
-        z_component = value * math.cos(math.radians(omega))
-        y_component = value * math.sin(math.radians(omega))
-        await asyncio.gather(
-            self.sampy.set(y_component),
-            self.sampz.set(z_component),
-            self.omega.set(omega),
-        )

dodal/devices/aithre_lasershaping/laser_robot.py

@@ -16,7 +16,7 @@ class LidHeatEnable(StrictEnum):
 
 
 class LaserRobot(BartRobot):
-    def __init__(self, name: str, prefix: str) -> None:
+    def __init__(self, prefix: str, name: str = "") -> None:
         self.dewar_lid_heater = epics_signal_rw(
             LidHeatEnable, prefix + "DW_1_ENABLED", prefix + "DW_1_CTRL"
         )
@@ -24,4 +24,4 @@ class LaserRobot(BartRobot):
         self.set_beamline_safe = epics_signal_rw(
             ForceBit, prefix + "IP_16_FORCE_OPTION"
         )
-        super().__init__(name=name, prefix=prefix)
+        super().__init__(prefix, name)

dodal/devices/b07/__init__.py

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

dodal/devices/b07/enums.py

@@ -21,4 +21,19 @@ class LensMode(SupersetEnum):
     MEDIUM_AREA = "MediumArea"
     SMALL_AREA = "SmallArea"
     HIGH_MAGNIFICATION2 = "HighMagnification2"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
+    NOT_CONNECTED = "Not connected"
+
+
+class PsuMode(SupersetEnum):
+    V3500 = "3.5kV"
+    V1500 = "1.5kV"
+    V400 = "400V"
+    V100 = "100V"
+    V10 = "10V"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
     NOT_CONNECTED = "Not connected"

dodal/devices/b07_1/__init__.py

@@ -1,3 +1,12 @@
+from dodal.devices.b07_1.ccmc import (
+    ChannelCutMonochromator,
+    ChannelCutMonochromatorPositions,
+)
 from dodal.devices.b07_1.enums import Grating, LensMode
 
-__all__ = ["Grating", "LensMode"]
+__all__ = [
+    "Grating",
+    "LensMode",
+    "ChannelCutMonochromator",
+    "ChannelCutMonochromatorPositions",
+]

dodal/devices/b07_1/ccmc.py

@@ -0,0 +1,79 @@
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StrictEnum,
+    derived_signal_r,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.motors import XYZStage
+
+
+class ChannelCutMonochromatorPositions(StrictEnum):
+    OUT = "Out of Beam"
+    XTAL_2000 = "Xtal_2000"
+    XTAL_2250 = "Xtal_2250"
+    XTAL_2500 = "Xtal_2500"
+
+
+ccmc_lower_limit = 1500.0
+ccmc_upper_limit = 3000.0
+error_message = "Can not get energy value in eV from ccmc position: "
+
+
+class ChannelCutMonochromator(
+    StandardReadable, Movable[ChannelCutMonochromatorPositions]
+):
+    """
+    Device to move the channel cut monochromator (ccmc). CCMC has three
+    choices of crystal (Xtal for short). Setting energy is by means of a
+    multi-positioner. The positions are named after the nominal energies of the
+    crystals. To change energy select one of the crystals from the list.
+    This causes the Y motor to move that crystal into the beam and other
+    motors have to align the angles correctly.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        """
+        Parameters
+        ----------
+        prefix:
+            Beamline specific part of the PV
+        name:
+            Name of the device
+        """
+        with self.add_children_as_readables():
+            # crystal motors
+            self._xyz = XYZStage(prefix)
+            # piezo motor in epics
+            self._y_rotation = epics_signal_rw(
+                float,
+                read_pv=prefix + "ROTY:POS:RD",
+                write_pv=prefix + "ROTY:MOV:WR",
+            )
+            # Must be a CHILD as read() must return this signal
+            self.crystal = epics_signal_rw(
+                ChannelCutMonochromatorPositions, prefix + "CRYSTAL:MP:SELECT"
+            )
+
+        # energy derived signal as property
+        self.energy_in_ev = derived_signal_r(
+            self._convert_pos_to_ev, pos_signal=self.crystal
+        )
+        super().__init__(name=name)
+
+    def _convert_pos_to_ev(self, pos_signal: ChannelCutMonochromatorPositions) -> float:
+        if pos_signal != ChannelCutMonochromatorPositions.OUT:
+            energy = float(str(pos_signal.value).split("Xtal_")[1])
+            if ccmc_lower_limit < energy < ccmc_upper_limit:
+                return energy
+        raise ValueError(error_message)
+
+    @AsyncStatus.wrap
+    async def set(self, value: ChannelCutMonochromatorPositions) -> None:
+        await self.crystal.set(value, wait=True)

dodal/devices/b07_1/enums.py

@@ -15,4 +15,7 @@ class LensMode(SupersetEnum):
     ANGLE_RESOLVED_MODE_22 = "AngleResolvedMode22"
     ANGLE_RESOLVED_MODE_30 = "AngleResolvedMode30"
     LARGE_AREA = "LargeArea"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
     NOT_CONNECTED = "Not connected"

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -1,4 +1,3 @@
-import asyncio
 from abc import ABC, abstractmethod
 from collections.abc import Mapping
 from typing import Generic, TypeVar
@@ -19,11 +18,15 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     TAbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.abstract.types import (
     TAcquisitionMode,
     TLensMode,
+    TPassEnergy,
+    TPsuMode,
 )
 from dodal.devices.electron_analyser.enums import EnergyMode
-from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
+from dodal.devices.electron_analyser.util import to_binding_energy
 
 
 class AbstractAnalyserDriverIO(
@@ -31,11 +34,12 @@ class AbstractAnalyserDriverIO(
     StandardReadable,
     ADBaseIO,
     Movable[TAbstractBaseRegion],
-    Generic[TAbstractBaseRegion, TAcquisitionMode, TLensMode],
+    Generic[TAbstractBaseRegion, TAcquisitionMode, TLensMode, TPsuMode, TPassEnergy],
 ):
     """
-    Generic device to configure electron analyser with new region settings.
-    Electron analysers should inherit from this class for further specialisation.
+    Driver device that defines signals and readables that should be common to all
+    electron analysers. Implementations of electron analyser devices should inherit
+    from this class and define additional specialised signals and methods.
     """
 
     def __init__(
@@ -43,6 +47,8 @@ class AbstractAnalyserDriverIO(
         prefix: str,
         acquisition_mode_type: type[TAcquisitionMode],
         lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
+        pass_energy_type: type[TPassEnergy],
         energy_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ) -> None:
@@ -55,6 +61,10 @@ class AbstractAnalyserDriverIO(
                                    for this device.
             lens_mode_type: Enum that determines the available lens mode for this
                             device.
+            psu_mode_type: Enum that determines the available psu modes for this device.
+            pass_energy_type: Can be enum or float, depends on electron analyser model.
+                              If enum, it determines the available pass energies for
+                              this device.
             energy_sources: Map that pairs a source name to an energy value signal
                             (in eV).
             name: Name of the device.
@@ -62,6 +72,8 @@ class AbstractAnalyserDriverIO(
         self.energy_sources = energy_sources
         self.acquisition_mode_type = acquisition_mode_type
         self.lens_mode_type = lens_mode_type
+        self.psu_mode_type = psu_mode_type
+        self.pass_energy_type = pass_energy_type
 
         with self.add_children_as_readables():
             self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
@@ -78,18 +90,20 @@ class AbstractAnalyserDriverIO(
                 EnergyMode, initial_value=EnergyMode.KINETIC
             )
             self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
+            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_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(lens_mode_type, prefix + "LENS_MODE")
-            self.pass_energy = epics_signal_rw(
-                self.pass_energy_type, prefix + "PASS_ENERGY"
-            )
+            self.pass_energy = epics_signal_rw(pass_energy_type, prefix + "PASS_ENERGY")
             self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
             self.iterations = epics_signal_rw(int, prefix + "NumExposures")
             self.acquisition_mode = epics_signal_rw(
                 acquisition_mode_type, prefix + "ACQ_MODE"
             )
             self.excitation_energy_source = soft_signal_rw(str, initial_value="")
+            # This is used by each electron analyser, however it depends on the electron
+            # analyser type to know if is moved with region settings.
+            self.psu_mode = epics_signal_rw(psu_mode_type, prefix + "PSU_MODE")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Read once per scan after data acquired
@@ -114,42 +128,17 @@ class AbstractAnalyserDriverIO(
 
         super().__init__(prefix=prefix, name=name)
 
+    @abstractmethod
     @AsyncStatus.wrap
     async def set(self, region: TAbstractBaseRegion):
         """
-        This should encompass all core region logic which is common to every electron
-        analyser for setting up the driver.
+        Move a group of signals defined in a region. Each implementation of this class
+        is responsible for implementing this method correctly.
 
         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)
-
-        low_energy = to_kinetic_energy(
-            region.low_energy, region.energy_mode, excitation_energy
-        )
-        high_energy = to_kinetic_energy(
-            region.high_energy, region.energy_mode, excitation_energy
-        )
-        await asyncio.gather(
-            self.region_name.set(region.name),
-            self.energy_mode.set(region.energy_mode),
-            self.low_energy.set(low_energy),
-            self.high_energy.set(high_energy),
-            self.slices.set(region.slices),
-            self.lens_mode.set(region.lens_mode),
-            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:
@@ -233,18 +222,6 @@ class AbstractAnalyserDriverIO(
     def _calculate_total_intensity(self, spectrum: Array1D[np.float64]) -> float:
         return float(np.sum(spectrum, dtype=np.float64))
 
-    @property
-    @abstractmethod
-    def pass_energy_type(self) -> type:
-        """
-        Return the type the pass_energy should be. Depends on underlying analyser
-        software.
-
-        Returns:
-            Type the pass energy parameter from a region needs to be cast to so it can
-            be set correctly on the signal.
-        """
-
 
 TAbstractAnalyserDriverIO = TypeVar(
     "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO

dodal/devices/electron_analyser/abstract/base_region.py

@@ -3,9 +3,13 @@ from abc import ABC
 from collections.abc import Callable
 from typing import Generic, TypeVar
 
-from ophyd_async.core import StrictEnum, SupersetEnum
 from pydantic import BaseModel, Field, model_validator
 
+from dodal.devices.electron_analyser.abstract.types import (
+    TAcquisitionMode,
+    TLensMode,
+    TPassEnergy,
+)
 from dodal.devices.electron_analyser.enums import EnergyMode
 
 
@@ -44,17 +48,10 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-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[TAcquisitionMode, TLensMode, TPassEnergy],
 ):
     """
     Generic region model that holds the data. Specialised region models should inherit
@@ -68,9 +65,10 @@ class AbstractBaseRegion(
     excitation_energy_source: str = "source1"
     # These ones we need subclasses to provide default values
     lens_mode: TLensMode
-    pass_energy: int
+    pass_energy: TPassEnergy
     acquisition_mode: TAcquisitionMode
     low_energy: float
+    centre_energy: float
     high_energy: float
     step_time: float
     energy_step: float  # in eV
@@ -95,7 +93,7 @@ TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
 class AbstractBaseSequence(
     ABC,
     JavaToPythonModel,
-    Generic[TAbstractBaseRegion, TLensMode],
+    Generic[TAbstractBaseRegion],
 ):
     """
     Generic sequence model that holds the list of region data. Specialised sequence