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

dodal/devices/electron_analyser/detector.py

@@ -0,0 +1,141 @@
+from typing import Generic, TypeVar
+
+from bluesky.protocols import Preparable
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+)
+from ophyd_async.epics.motor import Motor
+
+from dodal.common.data_util import load_json_file_to_class
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    AbstractElectronAnalyserDetector,
+)
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    TAbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract.base_region import (
+    TAbstractBaseRegion,
+    TAbstractBaseSequence,
+)
+
+
+class ElectronAnalyserRegionDetector(
+    AbstractElectronAnalyserDetector[TAbstractAnalyserDriverIO],
+    Preparable,
+    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.
+    """
+
+    def __init__(
+        self,
+        driver: TAbstractAnalyserDriverIO,
+        region: TAbstractBaseRegion,
+        name: str = "",
+    ):
+        self._driver_ref = Reference(driver)
+        self.region = region
+        super().__init__(driver, name)
+
+    @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 prepare(self, value: Motor) -> None:
+        """
+        Prepare driver with the region stored and energy_source motor.
+
+        Args:
+            value: The excitation energy source that the region has selected.
+        """
+        excitation_energy_source = value
+        await self.driver.prepare(excitation_energy_source)
+        await self.driver.set(self.region)
+
+
+TElectronAnalyserRegionDetector = TypeVar(
+    "TElectronAnalyserRegionDetector",
+    bound=ElectronAnalyserRegionDetector,
+)
+
+
+class ElectronAnalyserDetector(
+    AbstractElectronAnalyserDetector[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,
+        sequence_class: type[TAbstractBaseSequence],
+        driver: TAbstractAnalyserDriverIO,
+        name: str = "",
+    ):
+        # Pass in driver
+        self._driver = driver
+        self._sequence_class = sequence_class
+        super().__init__(self.driver, name)
+
+    @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:
+        """
+        Load the sequence data from a provided json file into a sequence class.
+
+        Args:
+            filename: Path to the sequence file containing the region data.
+
+        Returns:
+            Pydantic model representing the sequence file.
+        """
+        return load_json_file_to_class(self._sequence_class, filename)
+
+    def create_region_detector_list(
+        self, filename: str, enabled_only=True
+    ) -> list[
+        ElectronAnalyserRegionDetector[TAbstractAnalyserDriverIO, TAbstractBaseRegion]
+    ]:
+        """
+        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.
+
+        Returns:
+            List of ElectronAnalyserRegionDetector, equal to the number of regions in
+            the sequence file.
+        """
+        seq = self.load_sequence(filename)
+        regions = seq.get_enabled_regions() if enabled_only else seq.regions
+        return [
+            ElectronAnalyserRegionDetector(self.driver, r, self.name + "_" + r.name)
+            for r in regions
+        ]
+
+
+TElectronAnalyserDetector = TypeVar(
+    "TElectronAnalyserDetector",
+    bound=ElectronAnalyserDetector,
+)

dodal/devices/electron_analyser/enums.py

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

dodal/devices/electron_analyser/specs/__init__.py

@@ -1,11 +1,12 @@
-from .detector import SpecsDetector, SpecsRegionDetector
+from .detector import SpecsDetector
 from .driver_io import SpecsAnalyserDriverIO
+from .enums import AcquisitionMode
 from .region import SpecsRegion, SpecsSequence
 
 __all__ = [
     "SpecsDetector",
-    "SpecsRegionDetector",
     "SpecsAnalyserDriverIO",
+    "AcquisitionMode",
     "SpecsRegion",
     "SpecsSequence",
 ]

dodal/devices/electron_analyser/specs/detector.py

@@ -1,29 +1,13 @@
-from dodal.devices.electron_analyser.abstract.base_detector import (
-    AbstractElectronAnalyserDetector,
-    AbstractElectronAnalyserRegionDetector,
+from dodal.devices.electron_analyser.detector import (
+    ElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
 
 
-class SpecsRegionDetector(
-    AbstractElectronAnalyserRegionDetector[SpecsAnalyserDriverIO, SpecsRegion]
-):
-    def configure_region(self):
-        # ToDo - Need to move configure plans to here and rewrite tests
-        pass
-
-
 class SpecsDetector(
-    AbstractElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+    ElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
 ):
-    def __init__(self, prefix: str, name: str):
-        super().__init__(prefix, name, SpecsSequence)
-
-    def _create_driver(self, prefix: str) -> SpecsAnalyserDriverIO:
-        return SpecsAnalyserDriverIO(prefix, "driver")
-
-    def _create_region_detector(
-        self, driver: SpecsAnalyserDriverIO, region: SpecsRegion
-    ) -> SpecsRegionDetector:
-        return SpecsRegionDetector(self.name, driver, region)
+    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

@@ -1,13 +1,23 @@
+import asyncio
+
 import numpy as np
-from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, derived_signal_r
+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.enums import AcquisitionMode
+from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
 
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+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.
@@ -19,7 +29,21 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
             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)
+        super().__init__(prefix, AcquisitionMode, 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),
+        )
+        if region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
+            await self.centre_energy.set(region.centre_energy)
+
+        if self.acquisition_mode == AcquisitionMode.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(

dodal/devices/electron_analyser/specs/enums.py

@@ -0,0 +1,8 @@
+from ophyd_async.core import StrictEnum
+
+
+class AcquisitionMode(StrictEnum):
+    FIXED_TRANSMISSION = "Fixed Transmission"
+    SNAPSHOT = "Snapshot"
+    FIXED_RETARDING_RATIO = "Fixed Retarding Ratio"
+    FIXED_ENERGY = "Fixed Energy"

dodal/devices/electron_analyser/specs/region.py

@@ -4,13 +4,14 @@ from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
 )
+from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 
 
-class SpecsRegion(AbstractBaseRegion):
+class SpecsRegion(AbstractBaseRegion[AcquisitionMode]):
     # Override base class with defaults
     lens_mode: str = "SmallArea"
     pass_energy: int = 5
-    acquisition_mode: str = "Fixed Transmission"
+    acquisition_mode: AcquisitionMode = AcquisitionMode.FIXED_TRANSMISSION
     low_energy: float = Field(default=800, alias="start_energy")
     high_energy: float = Field(default=850, alias="end_energy")
     step_time: float = Field(default=1.0, alias="exposure_time")

dodal/devices/electron_analyser/types.py

@@ -1,6 +1,32 @@
-from ophyd_async.core import StrictEnum
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract.base_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+)
+from dodal.devices.electron_analyser.detector import (
+    ElectronAnalyserDetector,
+    ElectronAnalyserRegionDetector,
+)
+from dodal.devices.electron_analyser.specs.detector import (
+    SpecsAnalyserDriverIO,
+    SpecsDetector,
+)
+from dodal.devices.electron_analyser.vgscienta.detector import (
+    VGScientaAnalyserDriverIO,
+    VGScientaDetector,
+)
 
+ElectronAnalyserDetectorImpl = VGScientaDetector | SpecsDetector
+ElectronAnalyserDriverImpl = VGScientaAnalyserDriverIO | SpecsAnalyserDriverIO
 
-class EnergyMode(StrictEnum):
-    KINETIC = "Kinetic"
-    BINDING = "Binding"
+GenericElectronAnalyserDetector = ElectronAnalyserDetector[
+    AbstractAnalyserDriverIO[AbstractBaseRegion],
+    AbstractBaseSequence,
+    AbstractBaseRegion,
+]
+
+GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
+    AbstractAnalyserDriverIO[AbstractBaseRegion], AbstractBaseRegion
+]

dodal/devices/electron_analyser/util.py

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

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -1,11 +1,12 @@
-from .detector import VGScientaDetector, VGScientaRegionDetector
+from .detector import VGScientaDetector
 from .driver_io import VGScientaAnalyserDriverIO
+from .enums import AcquisitionMode
 from .region import VGScientaExcitationEnergySource, VGScientaRegion, VGScientaSequence
 
 __all__ = [
     "VGScientaDetector",
-    "VGScientaRegionDetector",
     "VGScientaAnalyserDriverIO",
+    "AcquisitionMode",
     "VGScientaExcitationEnergySource",
     "VGScientaRegion",
     "VGScientaSequence",

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,6 +1,5 @@
-from dodal.devices.electron_analyser.abstract.base_detector import (
-    AbstractElectronAnalyserDetector,
-    AbstractElectronAnalyserRegionDetector,
+from dodal.devices.electron_analyser.detector import (
+    ElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.vgscienta.driver_io import (
     VGScientaAnalyserDriverIO,
@@ -11,26 +10,13 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 )
 
 
-class VGScientaRegionDetector(
-    AbstractElectronAnalyserRegionDetector[VGScientaAnalyserDriverIO, VGScientaRegion]
-):
-    def configure_region(self):
-        # ToDo - Need to move configure plans to here and rewrite tests
-        pass
-
-
 class VGScientaDetector(
-    AbstractElectronAnalyserDetector[
-        VGScientaAnalyserDriverIO, VGScientaSequence, VGScientaRegion
+    ElectronAnalyserDetector[
+        VGScientaAnalyserDriverIO,
+        VGScientaSequence,
+        VGScientaRegion,
     ]
 ):
-    def __init__(self, prefix: str, name: str):
-        super().__init__(prefix, name, VGScientaSequence)
-
-    def _create_driver(self, prefix: str) -> VGScientaAnalyserDriverIO:
-        return VGScientaAnalyserDriverIO(prefix, "driver")
-
-    def _create_region_detector(
-        self, driver: VGScientaAnalyserDriverIO, region: VGScientaRegion
-    ) -> VGScientaRegionDetector:
-        return VGScientaRegionDetector(self.name, driver, region)
+    def __init__(self, prefix: str, name: str = ""):
+        driver = VGScientaAnalyserDriverIO(prefix)
+        super().__init__(prefix, VGScientaSequence, driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -1,19 +1,29 @@
+import asyncio
+
 import numpy as np
-from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, soft_signal_rw
+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.enums import AcquisitionMode
 from dodal.devices.electron_analyser.vgscienta.region import (
     DetectorMode,
+    VGScientaRegion,
 )
 
 
-class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            self.excitation_energy_source = soft_signal_rw(str, initial_value=None)
             # 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")
@@ -26,7 +36,26 @@ class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
             # Used to read detector data after acqusition.
             self.external_io = epics_signal_r(Array1D[np.float64], prefix + "EXTIO")
 
-        super().__init__(prefix, name)
+        super().__init__(prefix, AcquisitionMode, 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")

dodal/devices/electron_analyser/vgscienta/enums.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import StrictEnum
+
+
+class Status(StrictEnum):
+    READY = "Ready"
+    RUNNING = "Running"
+    COMPLETED = "Completed"
+    INVALID = "Invalid"
+    ABORTED = "Aborted"
+
+
+class DetectorMode(StrictEnum):
+    ADC = "ADC"
+    PULSE_COUNTING = "Pulse Counting"
+
+
+class AcquisitionMode(StrictEnum):
+    SWEPT = "Swept"
+    FIXED = "Fixed"

dodal/devices/electron_analyser/vgscienta/region.py

@@ -1,7 +1,5 @@
 import uuid
-from enum import Enum
 
-from ophyd_async.core import StrictEnum
 from pydantic import Field
 
 from dodal.devices.electron_analyser.abstract.base_region import (
@@ -9,38 +7,24 @@ from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseSequence,
     JavaToPythonModel,
 )
+from dodal.devices.electron_analyser.vgscienta.enums import (
+    AcquisitionMode,
+    DetectorMode,
+    Status,
+)
 
 
-class Status(str, Enum):
-    READY = "Ready"
-    RUNNING = "Running"
-    COMPLETED = "Completed"
-    INVALID = "Invalid"
-    ABORTED = "Aborted"
-
-
-class DetectorMode(StrictEnum):
-    ADC = "ADC"
-    PULSE_COUNTING = "Pulse Counting"
-
-
-class AcquisitionMode(str, Enum):
-    SWEPT = "Swept"
-    FIXED = "Fixed"
-
-
-class VGScientaRegion(AbstractBaseRegion):
+class VGScientaRegion(AbstractBaseRegion[AcquisitionMode]):
     # Override defaults of base region class
     lens_mode: str = "Angular45"
     pass_energy: int = 5
-    acquisition_mode: str = AcquisitionMode.SWEPT
+    acquisition_mode: AcquisitionMode = AcquisitionMode.SWEPT
     low_energy: float = 8.0
     high_energy: float = 10.0
     step_time: float = 1.0
     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

@@ -234,7 +234,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
-    def _calculate_expected_images(self, x: float, y: float, z: float) -> float:
+    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