dls-dodal 1.46.0__py3-none-any.whl → 1.48.0__py3-none-any.whl

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -0,0 +1,230 @@
+import asyncio
+from abc import ABC, abstractmethod
+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,
+    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.abstract.base_region import (
+    TAbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
+
+
+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:
+        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")
+            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")
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.region_name = soft_signal_rw(str, initial_value="null")
+            self.energy_mode = soft_signal_rw(
+                EnergyMode, initial_value=EnergyMode.KINETIC
+            )
+            self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
+            self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
+            self.slices = epics_signal_rw(int, prefix + "SLICES")
+            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.pass_energy = epics_signal_rw(
+                self.pass_energy_type, prefix + "PASS_ENERGY"
+            )
+            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.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(
+                self._calculate_binding_energy_axis,
+                "eV",
+                energy_axis=self.energy_axis,
+                excitation_energy=self.excitation_energy,
+                energy_mode=self.energy_mode,
+            )
+            self.angle_axis = self._create_angle_axis_signal(prefix)
+            self.step_time = epics_signal_r(float, prefix + "AcquireTime")
+            self.total_steps = epics_signal_r(int, prefix + "TOTAL_POINTS_RBV")
+            self.total_time = derived_signal_r(
+                self._calculate_total_time,
+                "s",
+                total_steps=self.total_steps,
+                step_time=self.step_time,
+                iterations=self.iterations,
+            )
+
+        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(
+        self,
+        energy_axis: Array1D[np.float64],
+        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(
+            [
+                to_binding_energy(i_energy_axis, EnergyMode.KINETIC, excitation_energy)
+                if is_binding
+                else i_energy_axis
+                for i_energy_axis in energy_axis
+            ]
+        )
+
+    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:
+        return float(np.sum(spectrum, dtype=np.float64))
+
+    @property
+    @abstractmethod
+    def pass_energy_type(self) -> type:
+        """
+        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.
+        """
+
+
+TAbstractAnalyserDriverIO = TypeVar(
+    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
+)

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

@@ -1,11 +1,12 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from enum import Enum
 from typing import Generic, TypeVar
 
 from pydantic import BaseModel, Field, model_validator
 
+from dodal.devices.electron_analyser.types import EnergyMode
+
 
 def java_to_python_case(java_str: str) -> str:
     """
@@ -42,11 +43,6 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class EnergyMode(str, Enum):
-    KINETIC = "Kinetic"
-    BINDING = "Binding"
-
-
 class AbstractBaseRegion(ABC, JavaToPythonModel):
     """
     Generic region model that holds the data. Specialised region models should inherit
@@ -57,6 +53,7 @@ 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
@@ -73,9 +70,6 @@ class AbstractBaseRegion(ABC, JavaToPythonModel):
     def is_kinetic_energy(self) -> bool:
         return self.energy_mode == EnergyMode.KINETIC
 
-    def to_kinetic_energy(self, value: float, excitation_energy: float) -> float:
-        return value if self.is_binding_energy() else excitation_energy - value
-
     @model_validator(mode="before")
     @classmethod
     def before_validation(cls, data: dict) -> dict:

dodal/devices/electron_analyser/specs/__init__.py

@@ -0,0 +1,10 @@
+from .detector import SpecsDetector
+from .driver_io import SpecsAnalyserDriverIO
+from .region import SpecsRegion, SpecsSequence
+
+__all__ = [
+    "SpecsDetector",
+    "SpecsAnalyserDriverIO",
+    "SpecsRegion",
+    "SpecsSequence",
+]

dodal/devices/electron_analyser/specs/detector.py

@@ -0,0 +1,13 @@
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    ElectronAnalyserDetector,
+)
+from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
+from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
+
+
+class SpecsDetector(
+    ElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+):
+    def __init__(self, prefix: str, name: str = ""):
+        driver = SpecsAnalyserDriverIO(prefix=prefix)
+        super().__init__(prefix, SpecsSequence, driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -0,0 +1,89 @@
+import asyncio
+
+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 (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.specs.region import SpecsRegion
+
+
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
+            self.snapshot_values = epics_signal_rw(int, prefix + "VALUES")
+            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
+
+            # Used to read detector data after acqusition.
+            self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
+            self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
+
+        super().__init__(prefix, name)
+
+    @AsyncStatus.wrap
+    async def set(self, region: SpecsRegion):
+        await super().set(region)
+
+        await asyncio.gather(
+            self.snapshot_values.set(region.values),
+            self.psu_mode.set(region.psu_mode),
+        )
+        # ToDo - This needs to be changed to an Enum
+        # https://github.com/DiamondLightSource/dodal/issues/1258
+        if region.acquisition_mode == "Fixed Transmission":
+            await self.centre_energy.set(region.centre_energy)
+
+        if self.acquisition_mode == "Fixed Energy":
+            await self.energy_step.set(region.energy_step)
+
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        angle_axis = derived_signal_r(
+            self._calculate_angle_axis,
+            min_angle=self.min_angle_axis,
+            max_angle=self.max_angle_axis,
+            slices=self.slices,
+        )
+        return angle_axis
+
+    def _calculate_angle_axis(
+        self, min_angle: float, max_angle: float, slices: int
+    ) -> Array1D[np.float64]:
+        # SPECS returns the extreme edges of the range, not the centre of the pixels
+        width = (max_angle - min_angle) / slices
+        offset = width / 2
+
+        axis = np.array([min_angle + offset + i * width for i in range(slices)])
+        return axis
+
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        energy_axis = derived_signal_r(
+            self._calculate_energy_axis,
+            "eV",
+            min_energy=self.low_energy,
+            max_energy=self.high_energy,
+            total_points_iterations=self.slices,
+        )
+        return energy_axis
+
+    def _calculate_energy_axis(
+        self, min_energy: float, max_energy: float, total_points_iterations: int
+    ) -> Array1D[np.float64]:
+        # Note: Don't use the energy step because of the case where the step doesn't
+        # exactly fill the range
+        step = (max_energy - min_energy) / (total_points_iterations - 1)
+        axis = np.array([min_energy + i * step for i in range(total_points_iterations)])
+        return axis
+
+    @property
+    def pass_energy_type(self) -> type:
+        return float

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

@@ -1,6 +1,6 @@
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract_region import (
+from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
 )

dodal/devices/electron_analyser/types.py

@@ -0,0 +1,6 @@
+from ophyd_async.core import StrictEnum
+
+
+class EnergyMode(StrictEnum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"

dodal/devices/electron_analyser/util.py

@@ -0,0 +1,13 @@
+from dodal.devices.electron_analyser.types import EnergyMode
+
+
+def to_kinetic_energy(
+    value: float, value_mode: EnergyMode, excitation_energy: float
+) -> float:
+    return value if value_mode == EnergyMode.KINETIC else excitation_energy - value
+
+
+def to_binding_energy(
+    value: float, value_mode: EnergyMode, excitation_energy: float
+) -> float:
+    return value if value_mode == EnergyMode.BINDING else excitation_energy - value

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -0,0 +1,11 @@
+from .detector import VGScientaDetector
+from .driver_io import VGScientaAnalyserDriverIO
+from .region import VGScientaExcitationEnergySource, VGScientaRegion, VGScientaSequence
+
+__all__ = [
+    "VGScientaDetector",
+    "VGScientaAnalyserDriverIO",
+    "VGScientaExcitationEnergySource",
+    "VGScientaRegion",
+    "VGScientaSequence",
+]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -0,0 +1,22 @@
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    ElectronAnalyserDetector,
+)
+from dodal.devices.electron_analyser.vgscienta.driver_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
+    VGScientaRegion,
+    VGScientaSequence,
+)
+
+
+class VGScientaDetector(
+    ElectronAnalyserDetector[
+        VGScientaAnalyserDriverIO,
+        VGScientaSequence,
+        VGScientaRegion,
+    ]
+):
+    def __init__(self, prefix: str, name: str = ""):
+        driver = VGScientaAnalyserDriverIO(prefix)
+        super().__init__(prefix, VGScientaSequence, driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -0,0 +1,67 @@
+import asyncio
+
+import numpy as np
+from ophyd_async.core import (
+    Array1D,
+    AsyncStatus,
+    SignalR,
+    StandardReadableFormat,
+)
+from ophyd_async.epics.adcore import ADImageMode
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.util import to_kinetic_energy
+from dodal.devices.electron_analyser.vgscienta.region import (
+    DetectorMode,
+    VGScientaRegion,
+)
+
+
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
+            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
+            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
+            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
+            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
+            self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
+
+        with self.add_children_as_readables():
+            # Used to read detector data after acqusition.
+            self.external_io = epics_signal_r(Array1D[np.float64], prefix + "EXTIO")
+
+        super().__init__(prefix, name)
+
+    @AsyncStatus.wrap
+    async def set(self, region: VGScientaRegion):
+        await super().set(region)
+
+        excitation_energy = await self.excitation_energy.get_value()
+        centre_energy = to_kinetic_energy(
+            region.fix_energy, region.energy_mode, excitation_energy
+        )
+        await asyncio.gather(
+            self.centre_energy.set(centre_energy),
+            self.energy_step.set(region.energy_step),
+            self.first_x_channel.set(region.first_x_channel),
+            self.first_y_channel.set(region.first_y_channel),
+            self.x_channel_size.set(region.x_channel_size()),
+            self.y_channel_size.set(region.y_channel_size()),
+            self.detector_mode.set(region.detector_mode),
+            self.image_mode.set(ADImageMode.SINGLE),
+        )
+
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        return epics_signal_r(Array1D[np.float64], prefix + "X_SCALE_RBV")
+
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        return epics_signal_r(Array1D[np.float64], prefix + "Y_SCALE_RBV")
+
+    @property
+    def pass_energy_type(self) -> type:
+        return str

dodal/devices/electron_analyser/{vgscienta_region.py → vgscienta/region.py}

@@ -4,7 +4,7 @@ from enum import Enum
 from ophyd_async.core import StrictEnum
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract_region import (
+from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
     JavaToPythonModel,
@@ -40,7 +40,6 @@ class VGScientaRegion(AbstractBaseRegion):
     energy_step: float = Field(default=200.0)
     # Specific to this class
     id: str = Field(default=str(uuid.uuid4()), alias="region_id")
-    excitation_energy_source: str = "source1"
     fix_energy: float = 9.0
     total_steps: float = 13.0
     total_time: float = 13.0

dodal/devices/fast_grid_scan.py

@@ -12,6 +12,7 @@ from ophyd_async.core import (
     Signal,
     SignalRW,
     StandardReadable,
+    derived_signal_r,
     wait_for_value,
 )
 from ophyd_async.epics.core import (
@@ -23,7 +24,6 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -203,8 +203,11 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = create_r_hardware_backed_soft_signal(
-            float, self._calculate_expected_images
+        self.expected_images = derived_signal_r(
+            self._calculate_expected_images,
+            x=self.x_steps,
+            y=self.y_steps,
+            z=self.z_steps,
         )
 
         self.motion_program = MotionProgram(smargon_prefix)
@@ -231,12 +234,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
-    async def _calculate_expected_images(self):
-        x, y, z = await asyncio.gather(
-            self.x_steps.get_value(),
-            self.y_steps.get_value(),
-            self.z_steps.get_value(),
-        )
+    def _calculate_expected_images(self, x: int, y: int, z: int) -> int:
         LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
         first_grid = x * y
         second_grid = x * z

dodal/devices/i03/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+
+__all__ = ["Beamstop", "BeamstopPositions"]

dodal/devices/i04/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+
+__all__ = ["Beamstop", "BeamstopPositions"]

dodal/devices/i04/constants.py

@@ -0,0 +1,9 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RedisConstants:
+    REDIS_HOST = os.environ.get("VALKEY_PROD_SVC_SERVICE_HOST", "test_redis")
+    REDIS_PASSWORD = os.environ.get("VALKEY_PASSWORD", "test_redis_password")
+    MURKO_REDIS_DB = 7