dls-dodal 1.68.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/electron_analyser/base/__init__.py

@@ -15,7 +15,7 @@ from .base_driver_io import (
     GenericAnalyserDriverIO,
     TAbstractAnalyserDriverIO,
 )
-from .base_enums import EnergyMode, SelectedSource
+from .base_enums import EnergyMode
 from .base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
@@ -27,7 +27,7 @@ from .base_region import (
     TLensMode,
 )
 from .base_util import to_binding_energy, to_kinetic_energy
-from .energy_sources import DualEnergySource, EnergySource
+from .energy_sources import AbstractEnergySource, DualEnergySource, EnergySource
 
 __all__ = [
     "ElectronAnalyserController",
@@ -42,7 +42,6 @@ __all__ = [
     "GenericAnalyserDriverIO",
     "TAbstractAnalyserDriverIO",
     "EnergyMode",
-    "SelectedSource",
     "AbstractBaseRegion",
     "AbstractBaseSequence",
     "GenericRegion",
@@ -53,6 +52,7 @@ __all__ = [
     "TLensMode",
     "to_binding_energy",
     "to_kinetic_energy",
+    "AbstractEnergySource",
     "DualEnergySource",
     "EnergySource",
 ]

dodal/devices/electron_analyser/base/base_controller.py

@@ -12,46 +12,53 @@ from dodal.devices.electron_analyser.base.base_region import (
     GenericRegion,
     TAbstractBaseRegion,
 )
-from dodal.devices.electron_analyser.base.energy_sources import (
-    AbstractEnergySource,
-    DualEnergySource,
-)
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
 
 
 class ElectronAnalyserController(
     ConstantDeadTimeController[TAbstractAnalyserDriverIO],
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
-    """
-    Specialised controller for the electron analysers to provide additional setup logic
-    such as selecting the energy source to use from requested region and giving the
-    driver the correct region parameters.
+    """Specialised controller for the electron analysers to provide additional setup
+    logic such as selecting the energy source to use from requested region and giving
+    the driver the correct region parameters.
+
+    Args:
+        driver (TAbstractAnalyserDriverIO): The electron analyser driver to wrap
+            around that holds the PV's.
+        energy_source (AbstractEnergySource): Device that holds the excitation
+            energy and ability to switch between sources.
+        deadtime (float, optional): For a given exposure, what is the safest minimum
+            time between exposures that can be determined without reading signals.
+        image_mode (ADImageMode, optional): The image mode to configure the driver
+            with before measuring.
     """
 
     def __init__(
         self,
         driver: TAbstractAnalyserDriverIO,
         energy_source: AbstractEnergySource,
-        deadtime: float,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
+        deadtime: float = 0,
         image_mode: ADImageMode = ADImageMode.SINGLE,
     ):
-        """
-        Parameters:
-            driver: The electron analyser driver to wrap around that holds the PV's.
-            energy_source: Device that holds the excitation energy and ability to switch
-                           between sources.
-            deadtime: For a given exposure, what is the safest minimum time between
-                      exposures that can be determined without reading signals.
-            image_mode: The image mode to configure the driver with before measuring.
-        """
         self.energy_source = energy_source
+        self.shutter = shutter
+        self.source_selector = source_selector
         super().__init__(driver, deadtime, image_mode)
 
-    async def setup_with_region(self, region: TAbstractBaseRegion):
+    async def setup_with_region(self, region: TAbstractBaseRegion) -> None:
         """Logic to set the driver with a region."""
+        if self.source_selector is not None:
+            await self.source_selector.set(region.excitation_energy_source)
+
+        # Should this be moved to a VGScientController only?
+        if self.shutter is not None:
+            await self.shutter.set(self.shutter.close_state)
 
-        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()
         epics_region = region.prepare_for_epics(excitation_energy)
         await self.driver.set(epics_region)
@@ -62,6 +69,10 @@ class ElectronAnalyserController(
         # axis calculation.
         excitation_energy = await self.energy_source.energy.get_value()
         await self.driver.cached_excitation_energy.set(excitation_energy)
+
+        if self.shutter is not None:
+            await self.shutter.set(self.shutter.open_state)
+
         await super().prepare(trigger_info)
 
 

dodal/devices/electron_analyser/base/base_detector.py

@@ -33,9 +33,8 @@ class BaseElectronAnalyserDetector(
     AsyncConfigurable,
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
-    """
-    Detector for data acquisition of electron analyser. Can only acquire using settings
-    already configured for the device.
+    """Detector for data acquisition of electron analyser. Can only acquire using
+    settings already configured for the device.
 
     If possible, this should be changed to inherit from a StandardDetector. Currently,
     StandardDetector forces you to use a file writer which doesn't apply here.
@@ -90,9 +89,8 @@ class ElectronAnalyserRegionDetector(
     BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
     Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
-    """
-    Extends electron analyser detector to configure specific region settings before data
-    acquisition. It is designed to only exist inside a plan.
+    """Extends electron analyser detector to configure specific region settings before
+    data acquisition. It is designed to only exist inside a plan.
     """
 
     def __init__(
@@ -127,10 +125,9 @@ class ElectronAnalyserDetector(
     Stageable,
     Generic[TAbstractBaseSequence, TAbstractAnalyserDriverIO, TAbstractBaseRegion],
 ):
-    """
-    Electron analyser detector with the additional functionality to load a sequence file
-    and create a list of temporary ElectronAnalyserRegionDetector objects. These will
-    setup configured region settings before data acquisition.
+    """Electron analyser detector with the additional functionality to load a sequence
+    file and create a list of temporary ElectronAnalyserRegionDetector objects. These
+    will setup configured region settings before data acquisition.
     """
 
     def __init__(
@@ -146,8 +143,7 @@ class ElectronAnalyserDetector(
 
     @AsyncStatus.wrap
     async def stage(self) -> None:
-        """
-        Prepare the detector for use by ensuring it is idle and ready.
+        """Prepare the detector for use by ensuring it is idle and ready.
 
         This method asynchronously stages the detector by first disarming the controller
         to ensure the detector is not actively acquiring data, then invokes the driver's
@@ -165,11 +161,10 @@ class ElectronAnalyserDetector(
         await self._controller.disarm()
 
     def load_sequence(self, filename: str) -> TAbstractBaseSequence:
-        """
-        Load the sequence data from a provided json file into a sequence class.
+        """Load the sequence data from a provided json file into a sequence class.
 
         Args:
-            filename: Path to the sequence file containing the region data.
+            filename (str): Path to the sequence file containing the region data.
 
         Returns:
             Pydantic model representing the sequence file.
@@ -181,17 +176,17 @@ class ElectronAnalyserDetector(
     ) -> list[
         ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
     ]:
-        """
-        Create a list of detectors equal to the number of regions in a sequence file.
+        """Create a list of detectors equal to the number of regions in a sequence file.
         Each detector is responsible for setting up a specific region.
 
         Args:
-            filename:     Path to the sequence file containing the region data.
-            enabled_only: If true, only include the region if enabled is True.
+            filename (str): Path to the sequence file containing the region data.
+            enabled_only (bool, optional): If true, only include the region if enabled
+                is True.
 
         Returns:
             List of ElectronAnalyserRegionDetector, equal to the number of regions in
-            the sequence file.
+                the sequence file.
         """
         seq = self.load_sequence(filename)
         regions: list[TAbstractBaseRegion] = (

dodal/devices/electron_analyser/base/base_driver_io.py

@@ -41,10 +41,24 @@ class AbstractAnalyserDriverIO(
     Movable[TAbstractBaseRegion],
     Generic[TAbstractBaseRegion, TAcquisitionMode, TLensMode, TPsuMode, TPassEnergy],
 ):
-    """
-    Driver device that defines signals and readables that should be common to all
+    """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.
+
+    Args:
+        prefix (str): Base PV to connect to EPICS for this device.
+        acquisition_mode_type (type[TAcquisitionMode]): Enum that determines the
+            available acquisition modes for this device.
+        lens_mode_type (type[TLensMode]): Enum that determines the available lens
+            mode for this device.
+        psu_mode_type (type[TPsuMode]): Enum that determines the available psu modes
+            for this device.
+        pass_energy_type (type[TPassEnergy]): Can be enum or float, depending on
+            electron analyser model. If enum, it determines the available pass
+            energies for this device.
+        energy_source: Device that can give us the correct excitation energy (in eV)
+            and switch sources if applicable.
+        name (str, optional): Name of the device.
     """
 
     def __init__(
@@ -56,24 +70,6 @@ class AbstractAnalyserDriverIO(
         pass_energy_type: type[TPassEnergy],
         name: str = "",
     ) -> None:
-        """
-        Constructor method for setting up electron analyser.
-
-        Args:
-            prefix: Base PV to connect to EPICS for this device.
-            acquisition_mode_type: Enum that determines the available acquisition modes
-                                   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_source: Device that can give us the correct excitation energy and
-                           switch sources if applicable.
-                            (in eV).
-            name: Name of the device.
-        """
         self.acquisition_mode_type = acquisition_mode_type
         self.lens_mode_type = lens_mode_type
         self.psu_mode_type = psu_mode_type
@@ -140,33 +136,31 @@ class AbstractAnalyserDriverIO(
     @abstractmethod
     @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.
+        """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.
+            epics_region (TAbstractBaseRegion): Contains the parameters to setup the
+                driver for a scan.
         """
 
     @abstractmethod
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
-        """
-        The signal that defines the angle axis. Depends on analyser model.
+        """The signal that defines the angle axis. Depends on analyser model.
 
         Args:
-            prefix: PV string used for connecting to angle axis.
+            prefix (str): PV string used for connecting to angle axis.
 
         Returns:
-            Signal that can give us angle axis array data.
+            SignalR that can give us angle axis array data.
         """
 
     @abstractmethod
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
-        """
-        The signal that defines the energy axis. Depends on analyser model.
+        """The signal that defines the energy axis. Depends on analyser model.
 
         Args:
-            prefix: PV string used for connecting to energy axis.
+            prefix (str): PV string used for connecting to energy axis.
 
         Returns:
             Signal that can give us energy axis array data.
@@ -178,16 +172,16 @@ class AbstractAnalyserDriverIO(
         excitation_energy: float,
         energy_mode: EnergyMode,
     ) -> Array1D[np.float64]:
-        """
-        Calculate the binding energy axis to calibrate the spectra data. Function for a
-        derived signal.
+        """Calculate the binding energy axis to calibrate the spectra data. Function for
+        a derived signal.
 
         Args:
-            energy_axis:       Array data of the original energy_axis from epics.
-            excitation_energy: The excitation energy value used for the scan of this
-                               region.
-            energy_mode:       The energy_mode of the region that was used for the scan
-                               of this region.
+            energy_axis (Array1D[np.float64]): Array data of the original energy_axis
+                from epics.
+            excitation_energy (float): The excitation energy value used for the scan of
+                this region.
+            energy_mode (EnergyMode): The energy_mode of the region that was used for
+                the scan of this region.
 
         Returns:
             Array that is the correct axis for the spectra data.
@@ -205,17 +199,16 @@ class AbstractAnalyserDriverIO(
     def _calculate_total_time(
         self, total_steps: int, step_time: float, iterations: int
     ) -> float:
-        """
-        Calulcate the total time the scan takes for this region. Function for a derived
-        signal.
+        """Calulcate the total time the scan takes for this region. Function for a
+        derived signal.
 
         Args:
-            total_steps: Number of steps for the region.
-            step_time: Time for each step for the region.
-            iterations: The number of iterations the region collected data for.
+            total_steps (int): Number of steps for the region.
+            step_time (float): Time for each step for the region.
+            iterations (int): The number of iterations the region collected data for.
 
         Returns:
-            Calculated total time in seconds.
+            Float: Calculated total time in seconds.
         """
         return total_steps * step_time * iterations
 

dodal/devices/electron_analyser/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/base/base_region.py

@@ -6,11 +6,12 @@ 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.base.base_enums import EnergyMode, SelectedSource
+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.selectable_source import SelectedSource
 
 AnyAcqMode: TypeAlias = StrictEnum
 AnyLensMode: TypeAlias = SupersetEnum | StrictEnum
@@ -27,11 +28,13 @@ TPsuMode = TypeVar("TPsuMode", bound=AnyPsuMode)
 
 
 def java_to_python_case(java_str: str) -> str:
-    """
-    Convert a camelCase Java-style string to a snake_case Python-style string.
+    """Convert a camelCase Java-style string to a snake_case Python-style string.
+
+    Args:
+        java_str (str): The Java-style camelCase string.
 
-    :param java_str: The Java-style camelCase string.
-    :return: The Python-style snake_case string.
+    Returns:
+        str: The Python-style snake_case string.
     """
     new_value = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", java_str)
     new_value = re.sub("([a-z0-9])([A-Z])", r"\1_\2", new_value).lower()
@@ -66,9 +69,8 @@ class AbstractBaseRegion(
     JavaToPythonModel,
     Generic[TAcquisitionMode, TLensMode, TPassEnergy],
 ):
-    """
-    Generic region model that holds the data. Specialised region models should inherit
-    this to extend functionality. All energy units are assumed to be in eV.
+    """Generic region model that holds the data. Specialised region models should
+    inherit this to extend functionality. All energy units are assumed to be in eV.
     """
 
     name: str = "New_region"
@@ -88,15 +90,11 @@ class AbstractBaseRegion(
     energy_mode: EnergyMode = EnergyMode.KINETIC
 
     def is_binding_energy(self) -> bool:
-        """
-        Returns true if the energy_mode is binding.
-        """
+        """Returns true if the energy_mode is binding."""
         return self.energy_mode == EnergyMode.BINDING
 
     def is_kinetic_energy(self) -> bool:
-        """
-        Returns true if the energy_mode is kinetic.
-        """
+        """Returns true if the energy_mode is kinetic."""
         return self.energy_mode == EnergyMode.KINETIC
 
     def switch_energy_mode(
@@ -105,19 +103,18 @@ class AbstractBaseRegion(
         excitation_energy: float,
         copy: bool = True,
     ) -> Self:
-        """
-        Get a region 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.
 
-        Parameters:
-            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 to alter for
-                  the new energy_mode and return it. If False, alter this region for the
-                  energy_mode and return it self.
+        Args:
+            energy_mode (EnergyMode): Mode you want to switch the region to.
+            excitation_energy (float): Energy conversion for low_energy, centre_energy,
+                and high_energy for new energy mode.
+            copy (bool, optional): 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:
             Region with selected energy mode and new calculated energy values.
@@ -146,14 +143,16 @@ class AbstractBaseRegion(
         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.
+        Args:
+            excitation_energy (float): Energy conversion for low_energy, centre_energy,
+                and high_energy for new energy mode.
+            copy (bool, optional): 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.
+                values for epics.
         """
         original_energy_mode = self.energy_mode
         r = self.switch_energy_mode(EnergyMode.KINETIC, excitation_energy, copy)
@@ -176,8 +175,7 @@ class AbstractBaseSequence(
     JavaToPythonModel,
     Generic[TAbstractBaseRegion],
 ):
-    """
-    Generic sequence model that holds the list of region data. Specialised sequence
+    """Generic sequence model that holds the list of region data. Specialised sequence
     models should inherit this to extend functionality and define type of region to
     hold.
     """

dodal/devices/electron_analyser/base/base_util.py

@@ -4,15 +4,16 @@ from dodal.devices.electron_analyser.base.base_enums import EnergyMode
 def to_kinetic_energy(
     value: float, value_mode: EnergyMode, excitation_energy: float
 ) -> float:
-    """
-    Convert a value that is binding energy to kinetic energy.
-    Parameters:
-        value: The value to convert.
-        value_mode: Energy mode of the value. If it is already kinetic, return the
-                    same value. If it is binding, convert to kinetic.
-        excitation_energy: Value to calculate the conversion.
+    """Convert a value that is binding energy to kinetic energy.
+
+    Args:
+        value (float): The value to convert.
+        value_mode (EnergyMode): Energy mode of the value. If it is already kinetic,
+            return the same value. If it is binding, convert to kinetic.
+        excitation_energy (float): Value to calculate the conversion.
+
     Returns:
-        Caluclated kinetic energy value
+        float: Caluclated kinetic energy value.
     """
     return value if value_mode == EnergyMode.KINETIC else excitation_energy - value
 
@@ -20,14 +21,15 @@ def to_kinetic_energy(
 def to_binding_energy(
     value: float, value_mode: EnergyMode, excitation_energy: float
 ) -> float:
-    """
-    Convert a value that is kinetic energy to binding energy.
-    Parameters:
-        value: The value to convert.
-        value_mode: Energy mode of the value. If it is already binding, return the
-                    same value. If it is kinetic, convert to binding.
-        excitation_energy: Value to calculate the conversion.
+    """Convert a value that is kinetic energy to binding energy.
+
+    Args:
+        value (float): The value to convert.
+        value_mode (EnergyMode): Energy mode of the value. If it is already binding,
+            return the same value. If it is kinetic, convert to binding.
+        excitation_energy (float): Value to calculate the conversion.
+
     Returns:
-        Caluclated binding energy value
+        float: Caluclated binding energy value.
     """
     return value if value_mode == EnergyMode.BINDING else excitation_energy - value

dodal/devices/electron_analyser/base/energy_sources.py

@@ -3,20 +3,19 @@ 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.base.base_enums import SelectedSource
+from dodal.devices.selectable_source import SelectedSource, get_obj_from_selected_source
 
 
 class AbstractEnergySource(StandardReadable):
-    """
-    Abstract device that wraps an energy source signal and provides common interface via
-    a energy signal.
+    """Abstract device that wraps an energy source signal and provides common interface
+    via a energy signal.
     """
 
     def __init__(self, name: str = "") -> None:
@@ -25,14 +24,11 @@ class AbstractEnergySource(StandardReadable):
     @property
     @abstractmethod
     def energy(self) -> SignalR[float]:
-        """
-        Signal to provide the excitation energy value in eV.
-        """
+        """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
+    """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.
     """
@@ -51,51 +47,50 @@ 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.
+    """Holds two EnergySource devices and provides a signal to read energy depending on
+    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.
+
+    Args:
+        source1 (SignalR): Energy source that corrosponds to SelectedSource.SOURCE1.
+        source2 (SignalR): Energy source that corrosponds to SelectedSource.SOURCE2.
+        selected_source (SignalRW): Signal that decides the active energy source.
+        name (str, optional): Name of this device.
     """
 
     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.
-        """
-
+        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