dls-dodal 1.58.0__py3-none-any.whl → 1.60.0__py3-none-any.whl

dodal/beamlines/i24.py

@@ -1,13 +1,22 @@
+from pathlib import PurePath
+
+from ophyd_async.core import AutoIncrementingPathProvider, StaticFilenameProvider
+
 from dodal.common.beamlines.beamline_utils import (
     BL,
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.attenuator.attenuator import ReadOnlyAttenuator
+from dodal.devices.attenuator.attenuator import EnumFilterAttenuator
+from dodal.devices.attenuator.filter_selections import (
+    I24_FilterOneSelections,
+    I24_FilterTwoSelections,
+)
 from dodal.devices.hutch_shutter import HutchShutter
 from dodal.devices.i24.aperture import Aperture
 from dodal.devices.i24.beam_center import DetectorBeamCenter
 from dodal.devices.i24.beamstop import Beamstop
+from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
 from dodal.devices.i24.dcm import DCM
 from dodal.devices.i24.dual_backlight import DualBacklight
 from dodal.devices.i24.focus_mirrors import FocusMirrorsMode
@@ -44,12 +53,13 @@ PREFIX = BeamlinePrefix(BL)
 
 
 @device_factory()
-def attenuator() -> ReadOnlyAttenuator:
+def attenuator() -> EnumFilterAttenuator:
     """Get a read-only attenuator device for i24, instantiate it if it hasn't already
     been. If this is called when already instantiated in i24, it will return the
     existing object."""
-    return ReadOnlyAttenuator(
+    return EnumFilterAttenuator(
         f"{PREFIX.beamline_prefix}-OP-ATTN-01:",
+        filter_selection=(I24_FilterOneSelections, I24_FilterTwoSelections),
     )
 
 
@@ -187,3 +197,22 @@ def eiger_beam_center() -> DetectorBeamCenter:
         f"{PREFIX.beamline_prefix}-EA-EIGER-01:CAM:",
         "eiger_bc",
     )
+
+
+@device_factory()
+def commissioning_jungfrau(
+    path_to_dir: str = "/tmp/jf",  # Device factory doesn't allow for required args,
+    filename: str = "jf_output",  # but these should be manually entered when commissioning
+) -> CommissioningJungfrau:
+    """Get the commissionning Jungfrau 9M device, which uses a temporary filewriter
+    device in place of Odin while the detector is in commissioning.
+    Instantiates the device if it hasn't already been.
+    If this is called when already instantiated, it will return the existing object."""
+
+    return CommissioningJungfrau(
+        f"{PREFIX.beamline_prefix}-EA-JFRAU-01:",
+        f"{PREFIX.beamline_prefix}-JUNGFRAU-META:FD:",
+        AutoIncrementingPathProvider(
+            StaticFilenameProvider(filename), PurePath(path_to_dir)
+        ),
+    )

dodal/beamlines/k07.py

@@ -0,0 +1,31 @@
+from ophyd_async.core import StrictEnum
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.pgm import PGM
+from dodal.devices.synchrotron import Synchrotron
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("k07")
+PREFIX = BeamlinePrefix(BL)
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+
+@device_factory()
+def synchrotron() -> Synchrotron:
+    return Synchrotron()
+
+
+# Grating does not exist yet - this class is a placeholder for when it does
+class Grating(StrictEnum):
+    NO_GRATING = "No Grating"
+
+
+# Grating does not exist yet - this class is a placeholder for when it does
+@device_factory(skip=True)
+def pgm() -> PGM:
+    return PGM(prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:", grating=Grating)

dodal/beamlines/p60.py

@@ -2,8 +2,8 @@ from dodal.common.beamlines.beamline_utils import (
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.electron_analyser import SelectedSource
-from dodal.devices.electron_analyser.vgscienta import VGScientaAnalyserDriverIO
+from dodal.devices.electron_analyser import DualEnergySource
+from dodal.devices.electron_analyser.vgscienta import VGScientaDetector
 from dodal.devices.p60 import (
     LabXraySource,
     LabXraySourceReadable,
@@ -30,18 +30,19 @@ def mg_kalpha_source() -> LabXraySourceReadable:
     return LabXraySourceReadable(LabXraySource.MG_KALPHA)
 
 
+@device_factory()
+def energy_source() -> DualEnergySource:
+    return DualEnergySource(al_kalpha_source().energy_ev, mg_kalpha_source().energy_ev)
+
+
 # Connect will work again after this work completed
 # https://jira.diamond.ac.uk/browse/P60-13
 @device_factory()
-def analyser_driver() -> VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy]:
-    energy_sources = {
-        SelectedSource.SOURCE1: al_kalpha_source().energy_ev,
-        SelectedSource.SOURCE2: mg_kalpha_source().energy_ev,
-    }
-    return VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy](
+def r4000() -> VGScientaDetector[LensMode, PsuMode, PassEnergy]:
+    return VGScientaDetector[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,
+        energy_source=energy_source(),
     )

dodal/common/watcher_utils.py

@@ -12,7 +12,6 @@ class _LogOnPercentageProgressWatcher(Watcher[Number]):
         message_prefix: str,
         percent_interval: Number = 25,
     ):
-        status.watch(self)
         self.percent_interval = percent_interval
         self._current_percent_interval = 0
         self.message_prefix = message_prefix
@@ -20,6 +19,7 @@ class _LogOnPercentageProgressWatcher(Watcher[Number]):
             raise ValueError(
                 f"Percent interval on class _LogOnPercentageProgressWatcher must be a positive number, but received {self.percent_interval}"
             )
+        status.watch(self)
 
     def __call__(
         self,

dodal/devices/apple2_undulator.py

@@ -2,7 +2,7 @@ import abc
 import asyncio
 from dataclasses import dataclass
 from math import isclose
-from typing import Any, Generic, TypeVar
+from typing import Generic, Protocol, TypeVar
 
 import numpy as np
 from bluesky.protocols import Movable
@@ -18,7 +18,6 @@ from ophyd_async.core import (
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
-from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.log import LOGGER
 
@@ -49,46 +48,6 @@ class Apple2Val:
     btm_outer: str
 
 
-class EnergyMinMax(BaseModel):
-    Minimum: float
-    Maximum: float
-
-
-class EnergyCoverageEntry(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    Low: float
-    High: float
-    Poly: np.poly1d
-
-
-class EnergyCoverage(RootModel):
-    root: dict[str, EnergyCoverageEntry]
-
-
-class LookupTableEntries(BaseModel):
-    Energies: EnergyCoverage
-    Limit: EnergyMinMax
-
-
-class Lookuptable(RootModel):
-    """BaseModel class for the lookup table.
-    Apple2 lookup table should be in this format.
-
-    {mode: {'Energies': {Any: {'Low': float,
-                            'High': float,
-                            'Poly':np.poly1d
-                            }
-                        }
-            'Limit': {'Minimum': float,
-                    'Maximum': float
-                    }
-        }
-    }
-    """
-
-    root: dict[str, LookupTableEntries]
-
-
 class Pol(StrictEnum):
     NONE = "None"
     LH = "lh"
@@ -342,6 +301,12 @@ class UndulatorJawPhase(SafeUndulatorMover[float]):
         )
 
 
+class EnergyMotorConvertor(Protocol):
+    def __call__(self, energy: float, pol: Pol) -> tuple[float, float]:
+        """Protocol to provide energy to motor position convertion"""
+        ...
+
+
 class Apple2(abc.ABC, StandardReadable, Movable):
     """
     Apple2 Undulator Device
@@ -353,9 +318,8 @@ class Apple2(abc.ABC, StandardReadable, Movable):
     The class is designed to manage the undulator's gap, phase motors, and polarisation settings, while
     abstracting hardware interactions and providing a high-level interface for beamline operations.
 
-
-    A pair of look up tables are needed to provide the conversion between motor position
-    and energy.
+    The class is abstract and requires beamline-specific implementations for set motor
+     positions based on energy and polarisation.
 
     Attributes
     ----------
@@ -371,27 +335,22 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         A hardware-backed signal for polarisation readback and control.
     lookup_tables : dict
         A dictionary storing lookup tables for gap and phase motor positions, used for energy and polarisation conversion.
-    _available_pol : list
-        A list of available polarisations supported by the device.
+    energy_to_motor : EnergyMotorConvertor
+        A callable that converts energy and polarisation to motor positions.
 
     Abstract Methods
     ----------------
     set(value: float) -> None
         Abstract method to set motor positions for a given energy and polarisation.
-    update_lookuptable() -> None
-        Abstract method to load and validate lookup tables from external sources.
 
     Methods
     -------
-    _set_pol_setpoint(pol: Pol) -> None
-        Sets the polarisation setpoint without moving hardware.
     determine_phase_from_hardware(...) -> tuple[Pol, float]
         Determines the polarisation and phase value based on motor positions.
 
     Notes
     -----
     - This class requires beamline-specific implementations of the abstract methods.
-    - The lookup tables must follow the `Lookuptable` format and be validated before use.
     - The device supports multiple polarisation modes, including linear horizontal (LH), linear vertical (LV),
       positive circular (PC), negative circular (NC), and linear arbitrary (LA).
 
@@ -406,6 +365,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self,
         id_gap: UndulatorGap,
         id_phase: UndulatorPhaseAxes,
+        energy_motor_convertor: EnergyMotorConvertor,
         name: str = "",
     ) -> None:
         """
@@ -414,16 +374,13 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         ----------
         id_gap: An UndulatorGap device.
         id_phase: An UndulatorPhaseAxes device.
-        prefix: Not in use but needed for device_instantiation.
+        energy_motor_convertor: A callable that converts energy and polarisation to motor positions.
         name: Name of the device.
         """
-        super().__init__(name)
 
-        # Attributes are set after super call so they are not renamed to
-        # <name>-undulator, etc.
         self.gap = id_gap
         self.phase = id_phase
-
+        self.energy_to_motor = energy_motor_convertor
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Store the set energy for readback.
             self.energy, self._set_energy_rbv = soft_signal_r_and_setter(
@@ -435,11 +392,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self.polarisation_setpoint, self._polarisation_setpoint_set = (
             soft_signal_r_and_setter(Pol)
         )
-        # This store two lookup tables, Gap and Phase in the Lookuptable format
-        self.lookup_tables: dict[str, dict[str | None, dict[str, dict[str, Any]]]] = {
-            "Gap": {},
-            "Phase": {},
-        }
+
         # Hardware backed read/write for polarisation.
         self.polarisation = derived_signal_rw(
             raw_to_derived=self._read_pol,
@@ -451,13 +404,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
             btm_outer=self.phase.btm_outer.user_readback,
             gap=id_gap.user_readback,
         )
-
-        self._available_pol = []
-        """
-        Abstract method that run at start up to load lookup tables into  self.lookup_tables
-        and set available_pol.
-        """
-        self.update_lookuptable()
+        super().__init__(name)
 
     def _set_pol_setpoint(self, pol: Pol) -> None:
         """Set the polarisation setpoint without moving hardware. The polarisation
@@ -488,8 +435,8 @@ class Apple2(abc.ABC, StandardReadable, Movable):
 
         Examples
         --------
-        >>> RE( id.set(888.0)) # This will set the ID to 888 eV
-        >>> RE(scan([detector], id,600,700,100)) # This will scan the ID from 600 to 700 eV in 100 steps.
+        RE( id.set(888.0)) # This will set the ID to 888 eV
+        RE(scan([detector], id,600,700,100)) # This will scan the ID from 600 to 700 eV in 100 steps.
         """
 
     def _read_pol(
@@ -551,77 +498,6 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         await wait_for_value(self.gap.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
         self._set_energy_rbv(energy)  # Update energy after move for readback.
 
-    async def _get_id_gap_phase(self, energy: float) -> tuple[float, float]:
-        """
-        Converts energy and polarisation to gap and phase.
-        """
-        gap_poly = await self._get_poly(
-            lookup_table=self.lookup_tables["Gap"], new_energy=energy
-        )
-        phase_poly = await self._get_poly(
-            lookup_table=self.lookup_tables["Phase"], new_energy=energy
-        )
-        return gap_poly(energy), phase_poly(energy)
-
-    async def _get_poly(
-        self,
-        new_energy: float,
-        lookup_table: dict[str | None, dict[str, dict[str, Any]]],
-    ) -> np.poly1d:
-        """
-        Get the correct polynomial for a given energy form lookuptable
-        for the current polarisation setpoint.
-        Parameters
-        ----------
-        new_energy : float
-            The energy in eV for which the polynomial is requested.
-        lookup_table : dict[str | None, dict[str, dict[str, Any]]]
-            The lookup table containing polynomial coefficients for different energies
-            and polarisations.
-        Returns
-        -------
-        np.poly1d
-            The polynomial coefficients for the requested energy and polarisation.
-        Raises
-        ------
-        ValueError
-            If the requested energy is outside the limits defined in the lookup table
-            or if no polynomial coefficients are found for the requested energy.
-        """
-        pol = await self.polarisation_setpoint.get_value()
-        if (
-            new_energy < lookup_table[pol]["Limit"]["Minimum"]
-            or new_energy > lookup_table[pol]["Limit"]["Maximum"]
-        ):
-            raise ValueError(
-                "Demanding energy must lie between {} and {} eV!".format(
-                    lookup_table[pol]["Limit"]["Minimum"],
-                    lookup_table[pol]["Limit"]["Maximum"],
-                )
-            )
-        else:
-            for energy_range in lookup_table[pol]["Energies"].values():
-                if (
-                    new_energy >= energy_range["Low"]
-                    and new_energy < energy_range["High"]
-                ):
-                    return energy_range["Poly"]
-
-        raise ValueError(
-            """Cannot find polynomial coefficients for your requested energy.
-        There might be gap in the calibration lookup table."""
-        )
-
-    @abc.abstractmethod
-    def update_lookuptable(self) -> None:
-        """
-        Abstract method to update the stored lookup tabled from file.
-        This function should include check to ensure the lookuptable is in the correct format:
-            # ensure the importing lookup table is the correct format
-            Lookuptable.model_validate(<loockuptable>)
-
-        """
-
     def determine_phase_from_hardware(
         self,
         top_outer: float,

dodal/devices/attenuator/attenuator.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     DeviceVector,
     SignalR,
     StandardReadable,
+    StrictEnum,
     SubsetEnum,
     wait_for_value,
 )
@@ -26,6 +27,9 @@ class ReadOnlyAttenuator(StandardReadable):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
+            # Closest obtainable transmission to the current desired transmission given the specific
+            # set of filters in the attenuator. This value updates immediately after setting desired
+            # transmission, before the motors may have finished moving. It is not a readback value.
             self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
 
         super().__init__(name)
@@ -92,7 +96,18 @@ class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
         )
 
 
-class EnumFilterAttenuator(ReadOnlyAttenuator):
+# Replace with ophyd async enum after https://github.com/bluesky/ophyd-async/pull/1067
+class YesNo(StrictEnum):
+    YES = "YES"
+    NO = "NO"
+
+
+# Time given to allow for motors to begin moving after the desired transmission has been set,
+# so that we can work out when the set is complete.
+ENUM_ATTENUATOR_SETTLE_TIME_S = 0.15
+
+
+class EnumFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """The attenuator will insert filters into the beam to reduce its transmission.
 
     This device is currently working, but feature incomplete. See https://github.com/DiamondLightSource/dodal/issues/972
@@ -107,11 +122,42 @@ class EnumFilterAttenuator(ReadOnlyAttenuator):
         filter_selection: tuple[type[SubsetEnum], ...],
         name: str = "",
     ):
+        self._auto_move_on_desired_transmission_set = epics_signal_rw(
+            YesNo, prefix + "AUTOMOVE"
+        )
+        self._desired_transmission = epics_signal_rw(float, prefix + "T2A:SETVAL1")
+        self._use_current_energy = epics_signal_x(prefix + "E2WL:USECURRENTENERGY.PROC")
+
         with self.add_children_as_readables():
-            self.filters: DeviceVector[FilterMotor] = DeviceVector(
+            self._filters: DeviceVector[FilterMotor] = DeviceVector(
                 {
                     index: FilterMotor(f"{prefix}MP{index + 1}:", filter, name)
                     for index, filter in enumerate(filter_selection)
                 }
             )
         super().__init__(prefix, name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """Set the transmission to the fractional (0-1) value given.
+
+        The attenuator IOC will then insert filters to reach the desired transmission for
+        the current beamline energy, the set will only complete when they have all been
+        applied.
+        """
+
+        # auto move should normally be on, but check here incase it was manually turned off
+        await self._auto_move_on_desired_transmission_set.set(YesNo.YES)
+
+        # Currently uncertain if _use_current_energy correctly waits for completion: https://github.com/DiamondLightSource/dodal/issues/1588
+        await self._use_current_energy.trigger()
+        await self._desired_transmission.set(value)
+
+        # Give EPICS a chance to start moving the filter motors. Not needed after
+        # a transmission readback PV is added at the controls level: https://jira.diamond.ac.uk/browse/I24-725
+        await asyncio.sleep(ENUM_ATTENUATOR_SETTLE_TIME_S)
+        coros = [
+            wait_for_value(self._filters[i].done_move, 1, timeout=DEFAULT_TIMEOUT)
+            for i in self._filters
+        ]
+        await asyncio.gather(*coros)

dodal/devices/attenuator/filter.py

@@ -8,4 +8,7 @@ class FilterMotor(StandardReadable):
     ):
         with self.add_children_as_readables():
             self.user_setpoint = epics_signal_rw(filter_selections, f"{prefix}SELECT")
+            self.done_move = epics_signal_rw(
+                int, f"{prefix}DMOV"
+            )  # 1 for yes, 0 for no
         super().__init__(name=name)

dodal/devices/attenuator/filter_selections.py

@@ -70,3 +70,29 @@ class I02_1FilterFourSelections(SubsetEnum):
     TI300 = "Ti300"
     TI400 = "Ti400"
     TI500 = "Ti500"
+
+
+class I24_FilterOneSelections(SubsetEnum):
+    EMPTY = "Empty"
+    AL12_5 = "Al12.5"
+    AL25 = "Al25"
+    AL50 = "Al50"
+    AL75 = "Al75"
+    AL1000 = "Al1000"
+    AL2000 = "Al2000"
+    AL3000 = "Al3000"
+    PT25 = "Pt25"
+    TI500 = "Ti500"
+
+
+class I24_FilterTwoSelections(SubsetEnum):
+    EMPTY = "Empty"
+    AL100 = "Al100"
+    AL200 = "Al200"
+    AL300 = "Al300"
+    AL400 = "Al400"
+    AL500 = "Al500"
+    AL600 = "Al600"
+    AL700 = "Al700"
+    AL800 = "Al800"
+    AL900 = "Al900"

dodal/devices/eiger.py

@@ -23,6 +23,7 @@ class EigerTimeouts:
     meta_file_ready_timeout: int = 30
     all_frames_timeout: int = 120
     arming_timeout: int = 60
+    odin_stop_timeout: int = 30
 
 
 class InternalEigerTriggerMode(Enum):
@@ -139,7 +140,7 @@ class EigerDetector(Device, Stageable):
             ).wait(self.timeouts.all_frames_timeout)
         finally:
             LOGGER.info("Stopping Odin")
-            self.odin.stop().wait(5)
+            self.odin.stop().wait(self.timeouts.odin_stop_timeout)
 
     def unstage(self) -> bool:
         assert self.detector_params is not None

dodal/devices/electron_analyser/__init__.py

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

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from collections.abc import Mapping
 from typing import Generic, TypeVar
 
 import numpy as np
@@ -25,7 +24,11 @@ from dodal.devices.electron_analyser.abstract.types import (
     TPassEnergy,
     TPsuMode,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
+from dodal.devices.electron_analyser.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
+from dodal.devices.electron_analyser.enums import EnergyMode
 from dodal.devices.electron_analyser.util import to_binding_energy
 
 
@@ -49,7 +52,7 @@ class AbstractAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergy],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         """
@@ -65,11 +68,11 @@ class AbstractAnalyserDriverIO(
             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
+            energy_source: Device that can give us the correct excitation energy and
+                           switch sources if applicable.
                             (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
         self.psu_mode_type = psu_mode_type
@@ -84,7 +87,7 @@ class AbstractAnalyserDriverIO(
             self.total_intensity = derived_signal_r(
                 self._calculate_total_intensity, spectrum=self.spectrum
             )
-            self.excitation_energy = soft_signal_rw(float, initial_value=0, units="eV")
+            self.energy_source = energy_source
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Read once per scan after data acquired
@@ -104,7 +107,6 @@ class AbstractAnalyserDriverIO(
             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")
@@ -119,7 +121,7 @@ class AbstractAnalyserDriverIO(
                 self._calculate_binding_energy_axis,
                 "eV",
                 energy_axis=self.energy_axis,
-                excitation_energy=self.excitation_energy,
+                excitation_energy=self.energy_source.energy,
                 energy_mode=self.energy_mode,
             )
             self.angle_axis = self._create_angle_axis_signal(prefix)
@@ -137,9 +139,28 @@ class AbstractAnalyserDriverIO(
         await self.image_mode.set(ADImageMode.SINGLE)
         await super().stage()
 
-    @abstractmethod
     @AsyncStatus.wrap
     async def set(self, region: TAbstractBaseRegion):
+        """
+        Take a region object and setup the driver with it. If using a DualEnergySource,
+        set it to use the source selected by the region. It also converts the region to
+        kinetic mode before we move the driver signals to the region parameter values:
+
+        Args:
+            region: Contains the parameters to setup the driver for a scan.
+        """
+        if isinstance(self.energy_source, DualEnergySource):
+            self.energy_source.selected_source.set(region.excitation_energy_source)
+        excitation_energy = await self.energy_source.energy.get_value()
+
+        # Copy region so doesn't alter the actual region and switch to kinetic energy
+        ke_region = region.model_copy()
+        ke_region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
+
+        await self._set_region(ke_region)
+
+    @abstractmethod
+    async def _set_region(self, ke_region: TAbstractBaseRegion):
         """
         Move a group of signals defined in a region. Each implementation of this class
         is responsible for implementing this method correctly.
@@ -148,15 +169,6 @@ class AbstractAnalyserDriverIO(
             region: Contains the parameters to setup the driver for a scan.
         """
 
-    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(
-                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]]:
         """