dls-dodal 1.47.0__py3-none-any.whl → 1.49.0__py3-none-any.whl

dodal/devices/bimorph_mirror.py

@@ -1,10 +1,8 @@
 import asyncio
-from collections.abc import Mapping
 from typing import Annotated as A
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
     AsyncStatus,
     DeviceVector,
     SignalR,
@@ -12,6 +10,7 @@ from ophyd_async.core import (
     SignalW,
     StandardReadable,
     StrictEnum,
+    set_and_wait_for_other_value,
     wait_for_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
@@ -23,6 +22,8 @@ from ophyd_async.epics.core import (
     epics_signal_x,
 )
 
+DEFAULT_TIMEOUT = 60
+
 
 class BimorphMirrorOnOff(StrictEnum):
     ON = "ON"
@@ -41,7 +42,7 @@ class BimorphMirrorStatus(StrictEnum):
     ERROR = "Error"
 
 
-class BimorphMirrorChannel(StandardReadable, Movable[float], EpicsDevice):
+class BimorphMirrorChannel(StandardReadable, EpicsDevice):
     """Collection of PVs comprising a single bimorph channel.
 
     Attributes:
@@ -56,23 +57,13 @@ class BimorphMirrorChannel(StandardReadable, Movable[float], EpicsDevice):
     status: A[SignalR[BimorphMirrorOnOff], PvSuffix("STATUS"), Format.CONFIG_SIGNAL]
     shift: A[SignalW[float], PvSuffix("SHIFT")]
 
-    @AsyncStatus.wrap
-    async def set(self, value: float):
-        """Sets channel's VOUT to given value.
-
-        Args:
-            value: float to set VOUT to
-        """
-        await self.output_voltage.set(value)
-
 
-class BimorphMirror(StandardReadable, Movable[Mapping[int, float]]):
+class BimorphMirror(StandardReadable, Movable[list[float]]):
     """Class to represent CAENels Bimorph Mirrors.
 
     Attributes:
         channels: DeviceVector of BimorphMirrorChannel, indexed from 1, for each channel
         enabled: Writeable BimorphOnOff
-        commit_target_voltages: Procable signal that writes values in each channel's VTRGT to VOUT
         status: Readable BimorphMirrorStatus Busy/Idle status
         err: Alarm status"""
 
@@ -103,49 +94,51 @@ class BimorphMirror(StandardReadable, Movable[Mapping[int, float]]):
         super().__init__(name=name)
 
     @AsyncStatus.wrap
-    async def set(self, value: Mapping[int, float], tolerance: float = 0.0001) -> None:
-        """Sets bimorph voltages in parrallel via target voltage and all proc.
+    async def set(self, value: list[float]) -> None:
+        """Sets bimorph voltages in parallel via target voltage and all proc.
 
         Args:
-            value: Dict of channel numbers to target voltages
+            value: List of float target voltages
 
         Raises:
             ValueError: On set to non-existent channel"""
 
-        if any(key not in self.channels for key in value):
+        if len(value) != len(self.channels):
             raise ValueError(
-                f"Attempting to put to non-existent channels: {[key for key in value if (key not in self.channels)]}"
+                f"Length of value input array does not match number of \
+                             channels: {len(value)} and {len(self.channels)}"
             )
 
-        # Write target voltages:
-        await asyncio.gather(
-            *[
-                self.channels[i].target_voltage.set(target, wait=True)
-                for i, target in value.items()
-            ]
-        )
+        # Write target voltages in serial
+        # Voltages are written in serial as bimorph PSU cannot handle simultaneous sets
+        for i, target in enumerate(value):
+            await wait_for_value(
+                self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+            )
+            await set_and_wait_for_other_value(
+                self.channels[i + 1].target_voltage,
+                target,
+                self.status,
+                BimorphMirrorStatus.BUSY,
+            )
 
         # Trigger set target voltages:
+        await wait_for_value(
+            self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+        )
         await self.commit_target_voltages.trigger()
 
         # Wait for values to propogate to voltage out rbv:
         await asyncio.gather(
             *[
                 wait_for_value(
-                    self.channels[i].output_voltage,
-                    tolerance_func_builder(tolerance, target),
+                    self.channels[i + 1].output_voltage,
+                    target,
                     timeout=DEFAULT_TIMEOUT,
                 )
-                for i, target in value.items()
+                for i, target in enumerate(value)
             ],
             wait_for_value(
                 self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
             ),
         )
-
-
-def tolerance_func_builder(tolerance: float, target_value: float):
-    def is_within_value(x):
-        return abs(x - target_value) <= tolerance
-
-    return is_within_value

dodal/devices/electron_analyser/__init__.py

@@ -1,8 +1,28 @@
-from .types import EnergyMode
+from .detector import (
+    ElectronAnalyserDetector,
+    ElectronAnalyserRegionDetector,
+    TElectronAnalyserDetector,
+    TElectronAnalyserRegionDetector,
+)
+from .enums import EnergyMode
+from .types import (
+    ElectronAnalyserDetectorImpl,
+    ElectronAnalyserDriverImpl,
+    GenericElectronAnalyserDetector,
+    GenericElectronAnalyserRegionDetector,
+)
 from .util import to_binding_energy, to_kinetic_energy
 
 __all__ = [
     "to_binding_energy",
     "to_kinetic_energy",
     "EnergyMode",
+    "ElectronAnalyserDetector",
+    "ElectronAnalyserDetectorImpl",
+    "ElectronAnalyserDriverImpl",
+    "TElectronAnalyserDetector",
+    "ElectronAnalyserRegionDetector",
+    "TElectronAnalyserRegionDetector",
+    "GenericElectronAnalyserDetector",
+    "GenericElectronAnalyserRegionDetector",
 ]

dodal/devices/electron_analyser/abstract/__init__.py

@@ -1,9 +1,6 @@
 from .base_detector import (
     AbstractAnalyserDriverIO,
     AbstractElectronAnalyserDetector,
-    AbstractElectronAnalyserRegionDetector,
-    TAbstractElectronAnalyserDetector,
-    TAbstractElectronAnalyserRegionDetector,
 )
 from .base_driver_io import AbstractAnalyserDriverIO, TAbstractAnalyserDriverIO
 from .base_region import (
@@ -20,9 +17,6 @@ __all__ = [
     "TAbstractBaseSequence",
     "AbstractAnalyserDriverIO",
     "AbstractElectronAnalyserDetector",
-    "AbstractElectronAnalyserRegionDetector",
-    "TAbstractElectronAnalyserDetector",
-    "TAbstractElectronAnalyserRegionDetector",
     "AbstractAnalyserDriverIO",
     "TAbstractAnalyserDriverIO",
 ]

dodal/devices/electron_analyser/abstract/base_detector.py

@@ -1,40 +1,31 @@
 import asyncio
 from abc import abstractmethod
-from typing import Generic, TypeVar
+from typing import Generic
 
-from bluesky.protocols import (
-    Reading,
-    Stageable,
-    Triggerable,
-)
+from bluesky.protocols import Reading, Stageable, Triggerable
 from event_model import DataKey
 from ophyd_async.core import (
+    AsyncConfigurable,
+    AsyncReadable,
     AsyncStatus,
     Device,
-    Reference,
 )
-from ophyd_async.core._protocol import AsyncConfigurable, AsyncReadable
 from ophyd_async.epics.adcore import (
     ADBaseController,
 )
 
-from dodal.common.data_util import load_json_file_to_class
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
     TAbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.base_region import (
-    TAbstractBaseRegion,
-    TAbstractBaseSequence,
-)
 
 
-class AnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
+class ElectronAnalyserController(ADBaseController[AbstractAnalyserDriverIO]):
     def get_deadtime(self, exposure: float | None) -> float:
         return 0
 
 
-class BaseElectronAnalyserDetector(
+class AbstractElectronAnalyserDetector(
     Device,
     Stageable,
     Triggerable,
@@ -46,17 +37,19 @@ class BaseElectronAnalyserDetector(
     Detector for data acquisition of electron analyser. Can only acquire using settings
     already configured for the device.
 
-    If possible, this should be changed to inheirt from a StandardDetector. Currently,
+    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.
     See issue https://github.com/bluesky/ophyd-async/issues/888
     """
 
     def __init__(
         self,
-        name: str,
         driver: TAbstractAnalyserDriverIO,
+        name: str = "",
     ):
-        self.controller: AnalyserController = AnalyserController(driver=driver)
+        self.controller: ElectronAnalyserController = ElectronAnalyserController(
+            driver=driver
+        )
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -96,115 +89,10 @@ class BaseElectronAnalyserDetector(
     @abstractmethod
     def driver(self) -> TAbstractAnalyserDriverIO:
         """
-        Define property for the driver. Some implementations will store this as a
-        reference so it doesn't run into errors with conflicting parents.
-        """
-
-
-class AbstractElectronAnalyserRegionDetector(
-    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Stageable,
-    Generic[TAbstractAnalyserDriverIO, TAbstractBaseRegion],
-):
-    """
-    Extends electron analyser detector to configure specific region settings before data
-    acqusition. This object must be passed in a driver and store it as a reference. It
-    is designed to only exist inside a plan.
-    """
+        Define common property for all implementations to access the driver. Some
+        implementations will store this as a reference so it doesn't have conflicting
+        parents.
 
-    def __init__(
-        self, name: str, driver: TAbstractAnalyserDriverIO, region: TAbstractBaseRegion
-    ):
-        self._driver_ref = Reference(driver)
-        self.region = region
-        super().__init__(name, driver)
-
-    @property
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        # Store as a reference, this implementation will be given a driver so needs to
-        # make sure we don't get conflicting parents.
-        return self._driver_ref()
-
-    @AsyncStatus.wrap
-    async def stage(self) -> None:
-        super().stage()
-        self.configure_region()
-
-    @abstractmethod
-    def configure_region(self):
-        """
-        Setup analyser with configured region.
+        Returns:
+            instance of the driver.
         """
-
-
-TAbstractElectronAnalyserRegionDetector = TypeVar(
-    "TAbstractElectronAnalyserRegionDetector",
-    bound=AbstractElectronAnalyserRegionDetector,
-)
-
-
-class AbstractElectronAnalyserDetector(
-    BaseElectronAnalyserDetector[TAbstractAnalyserDriverIO],
-    Generic[TAbstractAnalyserDriverIO, TAbstractBaseSequence, 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.
-    """
-
-    def __init__(
-        self, prefix: str, name: str, sequence_class: type[TAbstractBaseSequence]
-    ):
-        self._driver = self._create_driver(prefix)
-        self._sequence_class = sequence_class
-        super().__init__(name, self.driver)
-
-    @property
-    def driver(self) -> TAbstractAnalyserDriverIO:
-        # This implementation creates the driver and wants this to be the parent so it
-        # can be used with connect() method.
-        return self._driver
-
-    def load_sequence(self, filename: str) -> TAbstractBaseSequence:
-        return load_json_file_to_class(self._sequence_class, filename)
-
-    @abstractmethod
-    def _create_driver(self, prefix: str) -> TAbstractAnalyserDriverIO:
-        """
-        Define implementation of the driver used for this detector.
-        """
-
-    @abstractmethod
-    def _create_region_detector(
-        self, driver: TAbstractAnalyserDriverIO, region: TAbstractBaseRegion
-    ) -> AbstractElectronAnalyserRegionDetector[
-        TAbstractAnalyserDriverIO, TAbstractBaseRegion
-    ]:
-        """
-        Define a way to create a temporary detector object that will always setup a
-        specific region before acquiring.
-        """
-
-    def create_region_detector_list(
-        self, filename: str
-    ) -> list[
-        AbstractElectronAnalyserRegionDetector[
-            TAbstractAnalyserDriverIO, TAbstractBaseRegion
-        ]
-    ]:
-        """
-        Create a list of detectors that will setup a specific region from the sequence
-        file when used.
-        """
-        seq = self.load_sequence(filename)
-        return [
-            self._create_region_detector(self.driver, r)
-            for r in seq.get_enabled_regions()
-        ]
-
-
-TAbstractElectronAnalyserDetector = TypeVar(
-    "TAbstractElectronAnalyserDetector",
-    bound=AbstractElectronAnalyserDetector,
-)

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -1,29 +1,46 @@
+import asyncio
 from abc import ABC, abstractmethod
-from typing import TypeVar
+from typing import Generic, TypeVar
 
 import numpy as np
+from bluesky.protocols import Movable, Preparable
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadable,
     StandardReadableFormat,
+    StrictEnum,
     derived_signal_r,
     soft_signal_rw,
 )
 from ophyd_async.epics.adcore import ADBaseIO
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+from ophyd_async.epics.motor import Motor
 
-from dodal.devices.electron_analyser.types import EnergyMode
-from dodal.devices.electron_analyser.util import to_binding_energy
+from dodal.devices.electron_analyser.abstract.base_region import (
+    TAbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.enums import EnergyMode
+from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
 
 
-class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
+class AbstractAnalyserDriverIO(
+    ABC,
+    StandardReadable,
+    ADBaseIO,
+    Preparable,
+    Movable[TAbstractBaseRegion],
+    Generic[TAbstractBaseRegion],
+):
     """
     Generic device to configure electron analyser with new region settings.
     Electron analysers should inherit from this class for further specialisation.
     """
 
-    def __init__(self, prefix: str, name: str = "") -> None:
+    def __init__(
+        self, prefix: str, acquisition_mode_type: type[StrictEnum], name: str = ""
+    ) -> None:
         with self.add_children_as_readables():
             self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
             self.spectrum = epics_signal_r(Array1D[np.float64], prefix + "INT_SPECTRUM")
@@ -47,8 +64,12 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
             )
             self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
             self.iterations = epics_signal_rw(int, prefix + "NumExposures")
-            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
+            self.acquisition_mode = epics_signal_rw(
+                acquisition_mode_type, prefix + "ACQ_MODE"
+            )
+            self.excitation_energy_source = soft_signal_rw(str, initial_value="")
 
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Read once per scan after data acquired
             self.energy_axis = self._create_energy_axis_signal(prefix)
             self.binding_energy_axis = derived_signal_r(
@@ -71,16 +92,79 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
 
         super().__init__(prefix=prefix, name=name)
 
+    @AsyncStatus.wrap
+    async def prepare(self, value: Motor):
+        """
+        Prepare the driver for a region by passing in the energy source motor selected
+        by a region.
+
+        Args:
+            value: The motor that contains the information on the current excitation
+                   energy. Needed to prepare region for epics to accuratly calculate
+                   kinetic energy for an energy scan when in binding energy mode.
+        """
+        energy_source = value
+        excitation_energy_value = await energy_source.user_readback.get_value()  # eV
+        excitation_energy_source_name = energy_source.name
+
+        await asyncio.gather(
+            self.excitation_energy.set(excitation_energy_value),
+            self.excitation_energy_source.set(excitation_energy_source_name),
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, region: TAbstractBaseRegion):
+        """
+        This should encompass all core region logic which is common to every electron
+        analyser for setting up the driver.
+
+        Args:
+            region: Contains the parameters to setup the driver for a scan.
+        """
+        pass_energy_type = self.pass_energy_type
+        pass_energy = pass_energy_type(region.pass_energy)
+
+        excitation_energy = await self.excitation_energy.get_value()
+        low_energy = to_kinetic_energy(
+            region.low_energy, region.energy_mode, excitation_energy
+        )
+        high_energy = to_kinetic_energy(
+            region.high_energy, region.energy_mode, excitation_energy
+        )
+        await asyncio.gather(
+            self.region_name.set(region.name),
+            self.energy_mode.set(region.energy_mode),
+            self.low_energy.set(low_energy),
+            self.high_energy.set(high_energy),
+            self.slices.set(region.slices),
+            self.lens_mode.set(region.lens_mode),
+            self.pass_energy.set(pass_energy),
+            self.iterations.set(region.iterations),
+            self.acquisition_mode.set(region.acquisition_mode),
+        )
+
     @abstractmethod
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         """
         The signal that defines the angle axis. Depends on analyser model.
+
+        Args:
+            prefix: PV string used for connecting to angle axis.
+
+        Returns:
+            Signal 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.
+
+        Args:
+            prefix: PV string used for connecting to energy axis.
+
+        Returns:
+            Signal that can give us energy axis array data.
         """
 
     def _calculate_binding_energy_axis(
@@ -89,6 +173,20 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
         excitation_energy: float,
         energy_mode: EnergyMode,
     ) -> Array1D[np.float64]:
+        """
+        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.
+
+        Returns:
+            Array that is the correct axis for the spectra data.
+        """
         is_binding = energy_mode == EnergyMode.BINDING
         return np.array(
             [
@@ -102,6 +200,18 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
     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.
+
+        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.
+
+        Returns:
+            Calculated total time in seconds.
+        """
         return total_steps * step_time * iterations
 
     def _calculate_total_intensity(self, spectrum: Array1D[np.float64]) -> float:
@@ -111,8 +221,12 @@ class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
     @abstractmethod
     def pass_energy_type(self) -> type:
         """
-        Return the type the pass_energy should be. Each one is unfortunately different
-        for the underlying analyser software and cannot be changed on epics side.
+        Return the type the pass_energy should be. Depends on underlying analyser
+        software.
+
+        Returns:
+            Type the pass energy parameter from a region needs to be cast to so it can
+            be set correctly on the signal.
         """
 
 

dodal/devices/electron_analyser/abstract/base_region.py

@@ -3,9 +3,12 @@ from abc import ABC
 from collections.abc import Callable
 from typing import Generic, TypeVar
 
+from ophyd_async.core import StrictEnum
 from pydantic import BaseModel, Field, model_validator
 
-from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.enums import EnergyMode
+
+TStrictEnum = TypeVar("TStrictEnum", bound=StrictEnum)
 
 
 def java_to_python_case(java_str: str) -> str:
@@ -43,7 +46,7 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class AbstractBaseRegion(ABC, JavaToPythonModel):
+class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
     """
     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.
@@ -53,10 +56,11 @@ class AbstractBaseRegion(ABC, JavaToPythonModel):
     enabled: bool = False
     slices: int = 1
     iterations: int = 1
+    excitation_energy_source: str = "source1"
     # These ones we need subclasses to provide default values
     lens_mode: str
     pass_energy: int
-    acquisition_mode: str
+    acquisition_mode: TStrictEnum
     low_energy: float
     high_energy: float
     step_time: float