dls-dodal 1.67.0__py3-none-any.whl → 1.69.0__py3-none-any.whl

dodal/devices/electron_analyser/{abstract → base}/base_driver_io.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generic, TypeVar
+from typing import Generic, TypeAlias, TypeVar
 
 import numpy as np
 from bluesky.protocols import Movable
@@ -9,27 +9,29 @@ from ophyd_async.core import (
     SignalR,
     StandardReadable,
     StandardReadableFormat,
+    StrictEnum,
+    SupersetEnum,
     derived_signal_r,
     soft_signal_rw,
 )
-from ophyd_async.epics.adcore import ADBaseIO, ADImageMode
+from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_enums import EnergyMode
+from dodal.devices.electron_analyser.base.base_region import (
+    AnyAcqMode,
+    AnyLensMode,
+    AnyPassEnergy,
+    GenericRegion,
     TAbstractBaseRegion,
-)
-from dodal.devices.electron_analyser.abstract.types import (
     TAcquisitionMode,
     TLensMode,
     TPassEnergy,
-    TPsuMode,
-)
-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
+from dodal.devices.electron_analyser.base.base_util import to_binding_energy
+
+AnyPsuMode: TypeAlias = SupersetEnum | StrictEnum
+TPsuMode = TypeVar("TPsuMode", bound=AnyPsuMode)
 
 
 class AbstractAnalyserDriverIO(
@@ -52,7 +54,6 @@ class AbstractAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergy],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         """
@@ -87,7 +88,6 @@ class AbstractAnalyserDriverIO(
             self.total_intensity = derived_signal_r(
                 self._calculate_total_intensity, spectrum=self.spectrum
             )
-            self.energy_source = energy_source
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Read once per scan after data acquired
@@ -96,6 +96,9 @@ class AbstractAnalyserDriverIO(
             self.energy_mode = soft_signal_rw(
                 EnergyMode, initial_value=EnergyMode.KINETIC
             )
+            self.cached_excitation_energy = soft_signal_rw(
+                float, initial_value=0, units="eV"
+            )
             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")
@@ -121,7 +124,7 @@ class AbstractAnalyserDriverIO(
                 self._calculate_binding_energy_axis,
                 "eV",
                 energy_axis=self.energy_axis,
-                excitation_energy=self.energy_source.energy,
+                excitation_energy=self.cached_excitation_energy,
                 energy_mode=self.energy_mode,
             )
             self.angle_axis = self._create_angle_axis_signal(prefix)
@@ -134,34 +137,9 @@ class AbstractAnalyserDriverIO(
                 iterations=self.iterations,
             )
 
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        await self.image_mode.set(ADImageMode.SINGLE)
-        await super().stage()
-
-    @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()
-
-        # Switch to kinetic energy as epics doesn't support BINDING.
-        ke_region = region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
-        await self._set_region(ke_region)
-        # Set the true energy mode from original region so binding_energy_axis can be
-        # calculated correctly.
-        await self.energy_mode.set(region.energy_mode)
-
     @abstractmethod
-    async def _set_region(self, ke_region: TAbstractBaseRegion):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: TAbstractBaseRegion):
         """
         Move a group of signals defined in a region. Each implementation of this class
         is responsible for implementing this method correctly.
@@ -245,6 +223,9 @@ class AbstractAnalyserDriverIO(
         return float(np.sum(spectrum, dtype=np.float64))
 
 
+GenericAnalyserDriverIO = AbstractAnalyserDriverIO[
+    GenericRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
+]
 TAbstractAnalyserDriverIO = TypeVar(
     "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
 )

dodal/devices/electron_analyser/{enums.py → base/base_enums.py}

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

dodal/devices/electron_analyser/{abstract → base}/base_region.py

@@ -1,17 +1,30 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from typing import Generic, Self, TypeVar
+from typing import Generic, Self, TypeAlias, 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.base.base_enums import EnergyMode
+from dodal.devices.electron_analyser.base.base_util import (
+    to_binding_energy,
+    to_kinetic_energy,
 )
-from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
-from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
+from dodal.devices.selectable_source import SelectedSource
+
+AnyAcqMode: TypeAlias = StrictEnum
+AnyLensMode: TypeAlias = SupersetEnum | StrictEnum
+AnyPassEnergy: TypeAlias = StrictEnum | float
+AnyPsuMode: TypeAlias = SupersetEnum | StrictEnum
+
+TAcquisitionMode = TypeVar("TAcquisitionMode", bound=AnyAcqMode)
+# 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=AnyLensMode)
+TPassEnergy = TypeVar("TPassEnergy", bound=AnyPassEnergy)
+TPsuMode = TypeVar("TPsuMode", bound=AnyPsuMode)
 
 
 def java_to_python_case(java_str: str) -> str:
@@ -88,10 +101,13 @@ class AbstractBaseRegion(
         return self.energy_mode == EnergyMode.KINETIC
 
     def switch_energy_mode(
-        self, energy_mode: EnergyMode, excitation_energy: float, copy: bool = True
+        self,
+        energy_mode: EnergyMode,
+        excitation_energy: float,
+        copy: bool = True,
     ) -> Self:
         """
-        Switch region with to a new energy mode with a new energy mode: Kinetic or Binding.
+        Get a region with a new energy mode: Kinetic or Binding.
         It caculates new values for low_energy, centre_energy, high_energy, via the
         excitation enerrgy. It doesn't calculate anything if the region is already of
         the same energy mode.
@@ -100,8 +116,8 @@ class AbstractBaseRegion(
             energy_mode: Mode you want to switch the region to.
             excitation_energy: Energy conversion for low_energy, centre_energy, and
                                high_energy for new energy mode.
-            copy: Defaults to True. If true, create a copy of this region for the new
-                  energy_mode and return it. If False, alter this region for the
+            copy: Defaults to True. If true, create a copy of this region to alter for
+                  the new energy_mode and return it. If False, alter this region for the
                   energy_mode and return it self.
 
         Returns:
@@ -126,6 +142,25 @@ class AbstractBaseRegion(
 
         return switched_r
 
+    def prepare_for_epics(self, excitation_energy: float, copy: bool = True) -> Self:
+        """Prepares a region for epics by converting BINDING to KINETIC by calculating
+        new values for low_energy, centre_energy, and high_energy while also preserving
+        the original energy mode e.g mode BINDING will stay as BINDING.
+
+        Parameters:
+            excitation_energy: Energy conversion for low_energy, centre_energy, and
+                               high_energy for new energy mode.
+            copy: Defaults to True. If true, create a copy of this region to alter to
+                  calculate new energy values to return. If false, alter this region.
+        Returns:
+            Region with selected original energy mode and new calculated KINETIC energy
+            values for epics.
+        """
+        original_energy_mode = self.energy_mode
+        r = self.switch_energy_mode(EnergyMode.KINETIC, excitation_energy, copy)
+        r.energy_mode = original_energy_mode
+        return r
+
     @model_validator(mode="before")
     @classmethod
     def before_validation(cls, data: dict) -> dict:
@@ -133,6 +168,7 @@ class AbstractBaseRegion(
         return energy_mode_validation(data)
 
 
+GenericRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode, AnyPassEnergy]
 TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
 
 
@@ -163,4 +199,5 @@ class AbstractBaseSequence(
         return next((region for region in self.regions if region.name == name), None)
 
 
+GenericSequence = AbstractBaseSequence[GenericRegion]
 TAbstractBaseSequence = TypeVar("TAbstractBaseSequence", bound=AbstractBaseSequence)

dodal/devices/electron_analyser/{util.py → base/base_util.py}

@@ -1,4 +1,4 @@
-from dodal.devices.electron_analyser.enums import EnergyMode
+from dodal.devices.electron_analyser.base.base_enums import EnergyMode
 
 
 def to_kinetic_energy(

dodal/devices/electron_analyser/{energy_sources.py → base/energy_sources.py}

@@ -3,14 +3,14 @@ from abc import abstractmethod
 from ophyd_async.core import (
     Reference,
     SignalR,
+    SignalRW,
     StandardReadable,
     StandardReadableFormat,
     derived_signal_r,
     soft_signal_r_and_setter,
-    soft_signal_rw,
 )
 
-from dodal.devices.electron_analyser.enums import SelectedSource
+from dodal.devices.selectable_source import SelectedSource, get_obj_from_selected_source
 
 
 class AbstractEnergySource(StandardReadable):
@@ -51,51 +51,52 @@ class EnergySource(AbstractEnergySource):
         return self._source_ref()
 
 
+def get_float_from_selected_source(
+    selected: SelectedSource, s1: float, s2: float
+) -> float:
+    """Wrapper function to provide type hints for derived signal."""
+    return get_obj_from_selected_source(selected, s1, s2)
+
+
 class DualEnergySource(AbstractEnergySource):
     """
     Holds two EnergySource devices and provides a signal to read energy depending on
-    which source is selected. This is controlled by a selected_source signal which can
-    switch source using SelectedSource enum. Both sources energy is recorded in the
-    read, the energy signal is used as a helper signal to know which source is being
-    used.
+    which source is selected. The energy is the one that corrosponds to the
+    selected_source signal. For example, selected_source is source1 if selected_source
+    is at SelectedSource.SOURCE1 and vise versa for source2 and SelectedSource.SOURCE2.
     """
 
     def __init__(
-        self, source1: SignalR[float], source2: SignalR[float], name: str = ""
+        self,
+        source1: SignalR[float],
+        source2: SignalR[float],
+        selected_source: SignalRW[SelectedSource],
+        name: str = "",
     ):
         """
         Args:
-            source1: Default energy signal to select.
-            source2: Secondary energy signal to select.
-            name: name of this device.
+            source1: Energy source that corrosponds to SelectedSource.SOURCE1.
+            source2: Energy source that corrosponds to SelectedSource.SOURCE2.
+            selected_source: Signal that decides the active energy source.
+            name: Name of this device.
         """
 
+        self.selected_source_ref = Reference(selected_source)
         with self.add_children_as_readables():
-            self.selected_source = soft_signal_rw(
-                SelectedSource, initial_value=SelectedSource.SOURCE1
-            )
             self.source1 = EnergySource(source1)
             self.source2 = EnergySource(source2)
 
         self._selected_energy = derived_signal_r(
-            self._get_excitation_energy,
+            get_float_from_selected_source,
             "eV",
-            selected_source=self.selected_source,
-            source1=self.source1.energy,
-            source2=self.source2.energy,
+            selected=self.selected_source_ref(),
+            s1=self.source1.energy,
+            s2=self.source2.energy,
         )
+        self.add_readables([selected_source])
 
         super().__init__(name)
 
-    def _get_excitation_energy(
-        self, selected_source: SelectedSource, source1: float, source2: float
-    ) -> float:
-        match selected_source:
-            case SelectedSource.SOURCE1:
-                return source1
-            case SelectedSource.SOURCE2:
-                return source2
-
     @property
     def energy(self) -> SignalR[float]:
         return self._selected_energy

dodal/devices/electron_analyser/specs/__init__.py

@@ -1,7 +1,7 @@
-from .detector import SpecsDetector
-from .driver_io import SpecsAnalyserDriverIO
-from .enums import AcquisitionMode
-from .region import SpecsRegion, SpecsSequence
+from .specs_detector import SpecsDetector
+from .specs_driver_io import SpecsAnalyserDriverIO
+from .specs_enums import AcquisitionMode
+from .specs_region import SpecsRegion, SpecsSequence
 
 __all__ = [
     "SpecsDetector",

dodal/devices/electron_analyser/specs/specs_detector.py

@@ -0,0 +1,47 @@
+from typing import Generic
+
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
+from dodal.devices.electron_analyser.specs.specs_driver_io import SpecsAnalyserDriverIO
+from dodal.devices.electron_analyser.specs.specs_region import (
+    SpecsRegion,
+    SpecsSequence,
+)
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
+
+
+class SpecsDetector(
+    ElectronAnalyserDetector[
+        SpecsSequence[TLensMode, TPsuMode],
+        SpecsAnalyserDriverIO[TLensMode, TPsuMode],
+        SpecsRegion[TLensMode, TPsuMode],
+    ],
+    Generic[TLensMode, TPsuMode],
+):
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
+        name: str = "",
+    ):
+        # Save to class so takes part with connect()
+        self.driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
+            prefix, lens_mode_type, psu_mode_type
+        )
+
+        controller = ElectronAnalyserController[
+            SpecsAnalyserDriverIO[TLensMode, TPsuMode], SpecsRegion[TLensMode, TPsuMode]
+        ](self.driver, energy_source, shutter, source_selector)
+
+        sequence_class = SpecsSequence[lens_mode_type, psu_mode_type]
+
+        super().__init__(sequence_class, controller, name)

dodal/devices/electron_analyser/specs/{driver_io.py → specs_driver_io.py}

@@ -4,22 +4,19 @@ from typing import Generic
 import numpy as np
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadableFormat,
     derived_signal_r,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
+from dodal.devices.electron_analyser.base.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
-from dodal.devices.electron_analyser.specs.region import SpecsRegion
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.specs.specs_enums import AcquisitionMode
+from dodal.devices.electron_analyser.specs.specs_region import SpecsRegion
 
 
 class SpecsAnalyserDriverIO(
@@ -37,7 +34,6 @@ class SpecsAnalyserDriverIO(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -59,29 +55,30 @@ class SpecsAnalyserDriverIO(
             lens_mode_type=lens_mode_type,
             psu_mode_type=psu_mode_type,
             pass_energy_type=float,
-            energy_source=energy_source,
             name=name,
         )
 
-    async def _set_region(self, ke_region: SpecsRegion[TLensMode, TPsuMode]):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: SpecsRegion[TLensMode, TPsuMode]):
         await asyncio.gather(
-            self.region_name.set(ke_region.name),
-            self.low_energy.set(ke_region.low_energy),
-            self.high_energy.set(ke_region.high_energy),
-            self.slices.set(ke_region.slices),
-            self.acquire_time.set(ke_region.acquire_time),
-            self.lens_mode.set(ke_region.lens_mode),
-            self.pass_energy.set(ke_region.pass_energy),
-            self.iterations.set(ke_region.iterations),
-            self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.snapshot_values.set(ke_region.values),
-            self.psu_mode.set(ke_region.psu_mode),
+            self.region_name.set(epics_region.name),
+            self.low_energy.set(epics_region.low_energy),
+            self.high_energy.set(epics_region.high_energy),
+            self.slices.set(epics_region.slices),
+            self.acquire_time.set(epics_region.acquire_time),
+            self.lens_mode.set(epics_region.lens_mode),
+            self.pass_energy.set(epics_region.pass_energy),
+            self.iterations.set(epics_region.iterations),
+            self.acquisition_mode.set(epics_region.acquisition_mode),
+            self.snapshot_values.set(epics_region.values),
+            self.psu_mode.set(epics_region.psu_mode),
+            self.energy_mode.set(epics_region.energy_mode),
         )
-        if ke_region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
-            await self.energy_step.set(ke_region.energy_step)
+        if epics_region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
+            await self.energy_step.set(epics_region.energy_step)
 
-        if ke_region.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
-            await self.centre_energy.set(ke_region.centre_energy)
+        if epics_region.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
+            await self.centre_energy.set(epics_region.centre_energy)
 
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         angle_axis = derived_signal_r(

dodal/devices/electron_analyser/specs/{region.py → specs_region.py}

@@ -2,12 +2,13 @@ from typing import Generic
 
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
+    TLensMode,
+    TPsuMode,
 )
-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.specs_enums import AcquisitionMode
 
 
 class SpecsRegion(

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -1,7 +1,7 @@
-from .detector import VGScientaDetector
-from .driver_io import VGScientaAnalyserDriverIO
-from .enums import AcquisitionMode, DetectorMode
-from .region import VGScientaRegion, VGScientaSequence
+from .vgscienta_detector import VGScientaDetector
+from .vgscienta_driver_io import VGScientaAnalyserDriverIO
+from .vgscienta_enums import AcquisitionMode, DetectorMode
+from .vgscienta_region import VGScientaRegion, VGScientaSequence
 
 __all__ = [
     "VGScientaDetector",

dodal/devices/electron_analyser/vgscienta/vgscienta_detector.py

@@ -0,0 +1,53 @@
+from typing import Generic
+
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
+from dodal.devices.electron_analyser.vgscienta.vgscienta_driver_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
+    TPassEnergyEnum,
+    VGScientaRegion,
+    VGScientaSequence,
+)
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
+
+
+class VGScientaDetector(
+    ElectronAnalyserDetector[
+        VGScientaSequence[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
+    ],
+    Generic[TLensMode, TPsuMode, TPassEnergyEnum],
+):
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
+        pass_energy_type: type[TPassEnergyEnum],
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
+        name: str = "",
+    ):
+        # Save to class so takes part with connect()
+        self.driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type
+        )
+
+        controller = ElectronAnalyserController[
+            VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+            VGScientaRegion[TLensMode, TPassEnergyEnum],
+        ](self.driver, energy_source, shutter, source_selector)
+
+        sequence_class = VGScientaSequence[
+            lens_mode_type, psu_mode_type, pass_energy_type
+        ]
+        super().__init__(sequence_class, controller, name)

dodal/devices/electron_analyser/vgscienta/{driver_io.py → vgscienta_driver_io.py}

@@ -4,28 +4,22 @@ from typing import Generic
 import numpy as np
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadableFormat,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
+from dodal.devices.electron_analyser.base.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.types import (
-    TLensMode,
-    TPassEnergyEnum,
-    TPsuMode,
-)
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.vgscienta.enums import (
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.vgscienta.vgscienta_enums import (
     AcquisitionMode,
     DetectorMode,
 )
-from dodal.devices.electron_analyser.vgscienta.region import (
+from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
+    TPassEnergyEnum,
     VGScientaRegion,
 )
 
@@ -46,7 +40,6 @@ class VGScientaAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -67,28 +60,29 @@ class VGScientaAnalyserDriverIO(
             lens_mode_type,
             psu_mode_type,
             pass_energy_type,
-            energy_source,
             name,
         )
 
-    async def _set_region(self, ke_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         await asyncio.gather(
-            self.region_name.set(ke_region.name),
-            self.low_energy.set(ke_region.low_energy),
-            self.centre_energy.set(ke_region.centre_energy),
-            self.high_energy.set(ke_region.high_energy),
-            self.slices.set(ke_region.slices),
-            self.lens_mode.set(ke_region.lens_mode),
-            self.pass_energy.set(ke_region.pass_energy),
-            self.iterations.set(ke_region.iterations),
-            self.acquire_time.set(ke_region.acquire_time),
-            self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.energy_step.set(ke_region.energy_step),
-            self.detector_mode.set(ke_region.detector_mode),
-            self.region_min_x.set(ke_region.min_x),
-            self.region_size_x.set(ke_region.size_x),
-            self.region_min_y.set(ke_region.min_y),
-            self.region_size_y.set(ke_region.size_y),
+            self.region_name.set(epics_region.name),
+            self.low_energy.set(epics_region.low_energy),
+            self.centre_energy.set(epics_region.centre_energy),
+            self.high_energy.set(epics_region.high_energy),
+            self.slices.set(epics_region.slices),
+            self.lens_mode.set(epics_region.lens_mode),
+            self.pass_energy.set(epics_region.pass_energy),
+            self.iterations.set(epics_region.iterations),
+            self.acquire_time.set(epics_region.acquire_time),
+            self.acquisition_mode.set(epics_region.acquisition_mode),
+            self.energy_step.set(epics_region.energy_step),
+            self.detector_mode.set(epics_region.detector_mode),
+            self.region_min_x.set(epics_region.min_x),
+            self.region_size_x.set(epics_region.size_x),
+            self.region_min_y.set(epics_region.min_y),
+            self.region_size_y.set(epics_region.size_y),
+            self.energy_mode.set(epics_region.energy_mode),
         )
 
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]: