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

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]]:
         """

dodal/devices/electron_analyser/energy_sources.py

@@ -0,0 +1,101 @@
+from abc import abstractmethod
+
+from ophyd_async.core import (
+    Reference,
+    SignalR,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_r,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+
+from dodal.devices.electron_analyser.enums import SelectedSource
+
+
+class AbstractEnergySource(StandardReadable):
+    """
+    Abstract device that wraps an energy source signal and provides common interface via
+    a energy signal.
+    """
+
+    def __init__(self, name: str = "") -> None:
+        super().__init__(name)
+
+    @property
+    @abstractmethod
+    def energy(self) -> SignalR[float]:
+        """
+        Signal to provide the excitation energy value in eV.
+        """
+
+
+class EnergySource(AbstractEnergySource):
+    """
+    Wraps a signal that relates to energy and provides common interface via energy
+    signal. It provides the name of the wrapped signal as a child signal in the
+    read_configuration via wrapped_device_name and adds the signal as a readable.
+    """
+
+    def __init__(self, source: SignalR[float], name: str = "") -> None:
+        self.add_readables([source])
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.wrapped_device_name, _ = soft_signal_r_and_setter(
+                str, initial_value=source.name
+            )
+        self._source_ref = Reference(source)
+        super().__init__(name)
+
+    @property
+    def energy(self) -> SignalR[float]:
+        return self._source_ref()
+
+
+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.
+    """
+
+    def __init__(
+        self, source1: SignalR[float], source2: SignalR[float], name: str = ""
+    ):
+        """
+        Args:
+            source1: Default energy signal to select.
+            source2: Secondary energy signal to select.
+            name: name of this device.
+        """
+
+        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,
+            "eV",
+            selected_source=self.selected_source,
+            source1=self.source1.energy,
+            source2=self.source2.energy,
+        )
+
+        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/detector.py

@@ -1,13 +1,13 @@
-from collections.abc import Mapping
 from typing import Generic
 
-from ophyd_async.core import SignalR
-
 from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
-from dodal.devices.electron_analyser.enums import SelectedSource
+from dodal.devices.electron_analyser.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
 from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
 
@@ -25,10 +25,10 @@ class SpecsDetector(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: DualEnergySource | EnergySource,
         name: str = "",
     ):
         driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
-            prefix, lens_mode_type, psu_mode_type, energy_sources
+            prefix, lens_mode_type, psu_mode_type, energy_source
         )
         super().__init__(SpecsSequence[lens_mode_type, psu_mode_type], driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -1,11 +1,9 @@
 import asyncio
-from collections.abc import Mapping
 from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
     Array1D,
-    AsyncStatus,
     SignalR,
     StandardReadableFormat,
     derived_signal_r,
@@ -16,7 +14,10 @@ from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
 from dodal.devices.electron_analyser.abstract.types import TLensMode, 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.specs.enums import AcquisitionMode
 from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
@@ -36,7 +37,7 @@ class SpecsAnalyserDriverIO(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -58,18 +59,11 @@ class SpecsAnalyserDriverIO(
             lens_mode_type=lens_mode_type,
             psu_mode_type=psu_mode_type,
             pass_energy_type=float,
-            energy_sources=energy_sources,
+            energy_source=energy_source,
             name=name,
         )
 
-    @AsyncStatus.wrap
-    async def set(self, region: SpecsRegion[TLensMode, TPsuMode]):
-        source = self._get_energy_source(region.excitation_energy_source)
-        excitation_energy = await source.get_value()  # eV
-        # 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)
-
+    async def _set_region(self, ke_region: SpecsRegion[TLensMode, TPsuMode]):
         await asyncio.gather(
             self.region_name.set(ke_region.name),
             self.energy_mode.set(ke_region.energy_mode),
@@ -81,8 +75,6 @@ class SpecsAnalyserDriverIO(
             self.pass_energy.set(ke_region.pass_energy),
             self.iterations.set(ke_region.iterations),
             self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.excitation_energy.set(excitation_energy),
-            self.excitation_energy_source.set(source.name),
             self.snapshot_values.set(ke_region.values),
             self.psu_mode.set(ke_region.psu_mode),
         )

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,8 +1,5 @@
-from collections.abc import Mapping
 from typing import Generic
 
-from ophyd_async.core import SignalR
-
 from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
     TPassEnergyEnum,
@@ -11,7 +8,10 @@ from dodal.devices.electron_analyser.abstract.types import (
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
-from dodal.devices.electron_analyser.enums import SelectedSource
+from dodal.devices.electron_analyser.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
 from dodal.devices.electron_analyser.vgscienta.driver_io import (
     VGScientaAnalyserDriverIO,
 )
@@ -35,11 +35,11 @@ class VGScientaDetector(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: DualEnergySource | EnergySource,
         name: str = "",
     ):
         driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
-            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_sources
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_source
         )
         super().__init__(
             VGScientaSequence[lens_mode_type, psu_mode_type, pass_energy_type],

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -1,11 +1,9 @@
 import asyncio
-from collections.abc import Mapping
 from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
     Array1D,
-    AsyncStatus,
     SignalR,
     StandardReadableFormat,
 )
@@ -19,7 +17,10 @@ from dodal.devices.electron_analyser.abstract.types import (
     TPassEnergyEnum,
     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.vgscienta.enums import (
     AcquisitionMode,
     DetectorMode,
@@ -45,7 +46,7 @@ class VGScientaAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_sources: Mapping[SelectedSource, SignalR[float]],
+        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -66,17 +67,11 @@ class VGScientaAnalyserDriverIO(
             lens_mode_type,
             psu_mode_type,
             pass_energy_type,
-            energy_sources,
+            energy_source,
             name,
         )
 
-    @AsyncStatus.wrap
-    async def set(self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
-        source = self._get_energy_source(region.excitation_energy_source)
-        excitation_energy = await source.get_value()  # eV
-        # 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)
+    async def _set_region(self, ke_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         await asyncio.gather(
             self.region_name.set(ke_region.name),
             self.energy_mode.set(ke_region.energy_mode),
@@ -89,8 +84,6 @@ class VGScientaAnalyserDriverIO(
             self.iterations.set(ke_region.iterations),
             self.acquire_time.set(ke_region.acquire_time),
             self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.excitation_energy.set(excitation_energy),
-            self.excitation_energy_source.set(source.name),
             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),