dls-dodal 1.52.0__py3-none-any.whl → 1.54.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/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/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

dodal/devices/electron_analyser/abstract/types.py

@@ -0,0 +1,12 @@
+from typing import TypeVar
+
+from ophyd_async.core import StrictEnum, SupersetEnum
+
+TAcquisitionMode = TypeVar("TAcquisitionMode", bound=StrictEnum)
+# Allow SupersetEnum. Specs analysers can connect to Lens and Psu 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)
+TPsuMode = TypeVar("TPsuMode", bound=SupersetEnum | StrictEnum)
+TPassEnergy = TypeVar("TPassEnergy", bound=StrictEnum | float)
+TPassEnergyEnum = TypeVar("TPassEnergyEnum", bound=StrictEnum)

dodal/devices/electron_analyser/specs/detector.py

@@ -3,7 +3,7 @@ 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.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -13,21 +13,21 @@ from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSeque
 
 class SpecsDetector(
     ElectronAnalyserDetector[
-        SpecsAnalyserDriverIO[TLensMode],
-        SpecsSequence[TLensMode],
-        SpecsRegion[TLensMode],
+        SpecsAnalyserDriverIO[TLensMode, TPsuMode],
+        SpecsSequence[TLensMode, TPsuMode],
+        SpecsRegion[TLensMode, TPsuMode],
     ],
-    Generic[TLensMode],
+    Generic[TLensMode, TPsuMode],
 ):
     def __init__(
         self,
         prefix: str,
         lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
         energy_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ):
-        driver = SpecsAnalyserDriverIO[TLensMode](
-            prefix, lens_mode_type, energy_sources
+        driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
+            prefix, lens_mode_type, psu_mode_type, energy_sources
         )
-        seq = SpecsSequence[lens_mode_type]
-        super().__init__(seq, driver, name)
+        super().__init__(SpecsSequence[lens_mode_type, psu_mode_type], driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -15,51 +15,88 @@ 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.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 from dodal.devices.electron_analyser.specs.region import SpecsRegion
+from dodal.devices.electron_analyser.util import to_kinetic_energy
 
 
 class SpecsAnalyserDriverIO(
-    AbstractAnalyserDriverIO[SpecsRegion, AcquisitionMode, TLensMode],
-    Generic[TLensMode],
+    AbstractAnalyserDriverIO[
+        SpecsRegion[TLensMode, TPsuMode],
+        AcquisitionMode,
+        TLensMode,
+        TPsuMode,
+        float,
+    ],
+    Generic[TLensMode, TPsuMode],
 ):
     def __init__(
         self,
         prefix: str,
         lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
         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")
             self.snapshot_values = epics_signal_rw(int, prefix + "VALUES")
-            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
 
-            # 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"
-            )
+        # Used to calculate the angle axis.
+        self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
+        self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
 
-        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
+        # Used to calculate the energy axis.
+        self.energy_channels = epics_signal_r(
+            int, prefix + "TOTAL_POINTS_ITERATION_RBV"
+        )
+
+        super().__init__(
+            prefix=prefix,
+            acquisition_mode_type=AcquisitionMode,
+            lens_mode_type=lens_mode_type,
+            psu_mode_type=psu_mode_type,
+            pass_energy_type=float,
+            energy_sources=energy_sources,
+            name=name,
+        )
 
     @AsyncStatus.wrap
-    async def set(self, region: SpecsRegion[TLensMode]):
-        await super().set(region)
+    async def set(self, region: SpecsRegion[TLensMode, TPsuMode]):
+        source = self._get_energy_source(region.excitation_energy_source)
+        excitation_energy = await source.get_value()  # eV
 
+        low_energy = to_kinetic_energy(
+            region.low_energy, region.energy_mode, excitation_energy
+        )
+        centre_energy = to_kinetic_energy(
+            region.centre_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(region.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),
             self.snapshot_values.set(region.values),
             self.psu_mode.set(region.psu_mode),
         )
         if region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
-            await self.centre_energy.set(region.centre_energy)
-
-        if self.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
             await self.energy_step.set(region.energy_step)
 
+        if region.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
+            await self.centre_energy.set(centre_energy)
+
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         angle_axis = derived_signal_r(
             self._calculate_angle_axis,
@@ -97,7 +134,3 @@ class SpecsAnalyserDriverIO(
         step = (max_energy - min_energy) / (total_points_iterations - 1)
         axis = np.array([min_energy + i * step for i in range(total_points_iterations)])
         return axis
-
-    @property
-    def pass_energy_type(self) -> type:
-        return float

dodal/devices/electron_analyser/specs/region.py

@@ -5,27 +5,32 @@ from pydantic import Field
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
-    TLensMode,
 )
+from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 
 
-class SpecsRegion(AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]):
+class SpecsRegion(
+    AbstractBaseRegion[AcquisitionMode, TLensMode, float],
+    Generic[TLensMode, TPsuMode],
+):
     # Override base class with defaults
     lens_mode: TLensMode
-    pass_energy: int = 5
+    pass_energy: float = 5
     acquisition_mode: AcquisitionMode = AcquisitionMode.FIXED_TRANSMISSION
     low_energy: float = Field(default=800, alias="start_energy")
+    centre_energy: float = 0
     high_energy: float = Field(default=850, alias="end_energy")
     step_time: float = Field(default=1.0, alias="exposure_time")
     energy_step: float = Field(default=0.1, alias="step_energy")
+
     # Specific to this class
     values: int = 1
-    centre_energy: float = 0
-    # ToDo - Update to an enum https://github.com/DiamondLightSource/dodal/issues/1328
-    psu_mode: str = "1.5kV"
+    psu_mode: TPsuMode
     estimated_time_in_ms: float = 0
 
 
-class SpecsSequence(AbstractBaseSequence[SpecsRegion, TLensMode], Generic[TLensMode]):
-    regions: list[SpecsRegion[TLensMode]] = Field(default_factory=lambda: [])
+class SpecsSequence(
+    AbstractBaseSequence[SpecsRegion[TLensMode, TPsuMode]], Generic[TLensMode, TPsuMode]
+):
+    regions: list[SpecsRegion[TLensMode, TPsuMode]] = Field(default_factory=lambda: [])