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

dodal/plan_stubs/electron_analyser/{configure_controller.py → configure_driver.py}

@@ -1,37 +1,44 @@
 from bluesky import plan_stubs as bps
+from bluesky.utils import MsgGenerator, plan
+from ophyd_async.epics.adcore import ADImageMode
 
-from dodal.devices.electron_analyser.abstract_analyser_io import (
+from dodal.common.types import MsgGenerator
+from dodal.devices.electron_analyser.abstract import (
     AbstractAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.abstract_region import (
     AbstractBaseRegion,
 )
-from dodal.devices.electron_analyser.specs_analyser_io import (
-    SpecsAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.specs_region import SpecsRegion
-from dodal.devices.electron_analyser.vgscienta_analyser_io import (
+from dodal.devices.electron_analyser.specs import SpecsAnalyserDriverIO, SpecsRegion
+from dodal.devices.electron_analyser.util import to_kinetic_energy
+from dodal.devices.electron_analyser.vgscienta import (
     VGScientaAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.vgscienta_region import (
     VGScientaRegion,
 )
 from dodal.log import LOGGER
 
 
+@plan
 def configure_analyser(
     analyser: AbstractAnalyserDriverIO,
     region: AbstractBaseRegion,
     excitation_energy: float,
-):
+) -> MsgGenerator:
     LOGGER.info(f'Configuring analyser with region "{region.name}"')
-    low_energy = region.to_kinetic_energy(region.low_energy, excitation_energy)
-    high_energy = region.to_kinetic_energy(region.high_energy, excitation_energy)
+
+    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
+    )
     pass_energy_type = analyser.pass_energy_type
     pass_energy = pass_energy_type(region.pass_energy)
+
     # Set detector settings, wait for them all to have completed
     # fmt: off
     yield from bps.mv(
+        analyser.region_name, region.name,
+        analyser.energy_mode, region.energy_mode,
+        analyser.excitation_energy, excitation_energy,
         analyser.low_energy, low_energy,
         analyser.high_energy, high_energy,
         analyser.slices, region.slices,
@@ -43,13 +50,14 @@ def configure_analyser(
     # fmt: on
 
 
+@plan
 def configure_specs(
     analyser: SpecsAnalyserDriverIO, region: SpecsRegion, excitation_energy: float
-):
+) -> MsgGenerator:
     yield from configure_analyser(analyser, region, excitation_energy)
     # fmt: off
     yield from bps.mv(
-        analyser.values, region.values,
+        analyser.snapshot_values, region.values,
         analyser.psu_mode, region.psu_mode,
     )
     # fmt: on
@@ -60,11 +68,14 @@ def configure_specs(
         yield from bps.mv(analyser.energy_step, region.energy_step)
 
 
+@plan
 def configure_vgscienta(
     analyser: VGScientaAnalyserDriverIO, region: VGScientaRegion, excitation_energy
-):
+) -> MsgGenerator:
     yield from configure_analyser(analyser, region, excitation_energy)
-    centre_energy = region.to_kinetic_energy(region.fix_energy, excitation_energy)
+    centre_energy = to_kinetic_energy(
+        region.fix_energy, region.energy_mode, excitation_energy
+    )
 
     # fmt: off
     yield from bps.mv(
@@ -75,6 +86,7 @@ def configure_vgscienta(
         analyser.x_channel_size, region.x_channel_size(),
         analyser.y_channel_size, region.y_channel_size(),
         analyser.detector_mode, region.detector_mode,
-        analyser.image_mode, "Single",
+        analyser.excitation_energy_source, region.excitation_energy_source,
+        analyser.image_mode, ADImageMode.SINGLE,
     )
     # fmt: on

dodal/plans/verify_undulator_gap.py

@@ -2,14 +2,14 @@ from typing import Protocol, runtime_checkable
 
 from bluesky import plan_stubs as bps
 
-from dodal.devices.dcm import DCM
+from dodal.devices.common_dcm import BaseDCM
 from dodal.devices.undulator import Undulator
 
 
 @runtime_checkable
 class CheckUndulatorDevices(Protocol):
     undulator: Undulator
-    dcm: DCM
+    dcm: BaseDCM
 
 
 def verify_undulator_gap(devices: CheckUndulatorDevices):

dodal/common/signal_utils.py

@@ -1,88 +0,0 @@
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from bluesky.protocols import Reading
-from ophyd_async.core import SignalDatatypeT, SignalR, SignalRW, SoftSignalBackend
-
-SetHardwareType = Callable[[SignalDatatypeT], Coroutine[Any, Any, None]]
-
-
-class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
-    def __init__(
-        self,
-        get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
-        set_to_hardware_func: SetHardwareType | None = None,
-        *args,
-        **kwargs,
-    ) -> None:
-        self.get_from_hardware_func = get_from_hardware_func
-        self.set_to_hardware_func = set_to_hardware_func
-        super().__init__(*args, **kwargs)
-
-    async def _update_value(self):
-        new_value = await self.get_from_hardware_func()
-        self.set_value(new_value)
-
-    async def get_reading(self) -> Reading:
-        await self._update_value()
-        return await super().get_reading()
-
-    async def get_value(self) -> SignalDatatypeT:
-        await self._update_value()
-        return await super().get_value()
-
-    async def put(self, value: SignalDatatypeT | None, wait: bool) -> None:
-        if self.set_to_hardware_func:
-            write_value = self.initial_value if value is None else value
-            await self.set_to_hardware_func(write_value)
-
-
-def create_rw_hardware_backed_soft_signal(
-    datatype: type[SignalDatatypeT],
-    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
-    set_to_hardware_func: SetHardwareType,
-    units: str | None = None,
-    precision: int | None = None,
-):
-    """Creates a soft signal that, when read will call the function passed into
-    `get_from_hardware_func` and return this. When set it will call `set_to_hardware_func`
-    and send something to the hardware.
-
-    This will allow you to make soft signals derived from arbitrary hardware signals.
-    However, calling subscribe on this signal does not give you a sensible value. See https://github.com/bluesky/ophyd-async/issues/525
-    for a more full solution.
-    """
-    return SignalRW(
-        backend=HardwareBackedSoftSignalBackend(
-            get_from_hardware_func,
-            set_to_hardware_func,
-            datatype,
-            units=units,
-            precision=precision,
-        )
-    )
-
-
-def create_r_hardware_backed_soft_signal(
-    datatype: type[SignalDatatypeT],
-    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
-    units: str | None = None,
-    precision: int | None = None,
-):
-    """Creates a soft signal that, when read will call the function passed into
-    `get_from_hardware_func` and return this.
-
-    This will allow you to make soft signals derived from arbitrary hardware signals.
-    However, calling subscribe on this signal does not give you a sensible value and
-    the signal is currently read only. See https://github.com/bluesky/ophyd-async/issues/525
-    for a more full solution.
-    """
-    return SignalR(
-        backend=HardwareBackedSoftSignalBackend(
-            get_from_hardware_func,
-            None,
-            datatype,
-            units=units,
-            precision=precision,
-        )
-    )

dodal/devices/electron_analyser/abstract_analyser_io.py

@@ -1,47 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import TypeVar
-
-from ophyd_async.core import StandardReadable
-from ophyd_async.epics.core import epics_signal_rw
-
-from dodal.devices.electron_analyser.abstract_region import EnergyMode
-
-
-class AbstractAnalyserDriverIO(ABC, StandardReadable):
-    """
-    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.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")
-
-        super().__init__(name)
-
-    def to_kinetic_energy(
-        self, value: float, excitation_energy: float, mode: EnergyMode
-    ) -> float:
-        return excitation_energy - value if mode == EnergyMode.BINDING else value
-
-    @property
-    @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.
-        """
-
-
-TAbstractAnalyserDriverIO = TypeVar(
-    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
-)

dodal/devices/electron_analyser/specs_analyser_io.py

@@ -1,19 +0,0 @@
-from ophyd_async.epics.core import epics_signal_rw
-
-from dodal.devices.electron_analyser.abstract_analyser_io import (
-    AbstractAnalyserDriverIO,
-)
-
-
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
-            self.values = epics_signal_rw(int, prefix + "VALUES")
-            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
-
-        super().__init__(prefix, name)
-
-    @property
-    def pass_energy_type(self) -> type:
-        return float

dodal/devices/electron_analyser/vgscienta_analyser_io.py

@@ -1,26 +0,0 @@
-from ophyd_async.epics.core import epics_signal_rw
-
-from dodal.devices.electron_analyser.abstract_analyser_io import (
-    AbstractAnalyserDriverIO,
-)
-from dodal.devices.electron_analyser.vgscienta_region import (
-    DetectorMode,
-)
-
-
-class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
-    def __init__(self, prefix: str, name: str = "") -> None:
-        with self.add_children_as_readables():
-            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")
-            self.image_mode = epics_signal_rw(str, prefix + "ImageMode")
-
-        super().__init__(prefix, name)
-
-    @property
-    def pass_energy_type(self) -> type:
-        return str

dodal/devices/logging_ophyd_device.py

@@ -1,17 +0,0 @@
-from ophyd import Device
-from ophyd.log import logger as ophyd_logger
-
-
-class InfoLoggingDevice(Device):
-    def wait_for_connection(self, all_signals=False, timeout=2.0):
-        class_name = self.__class__.__name__
-        ophyd_logger.info(
-            f"{class_name} waiting for connection, {'not' if all_signals else ''} waiting for all signals, timeout = {timeout}s.",
-        )
-        try:
-            super().wait_for_connection(all_signals, timeout)
-        except TimeoutError as e:
-            ophyd_logger.error(f"{class_name} failed to connect.", exc_info=True)
-            raise e
-        else:
-            ophyd_logger.info(f"{class_name} connected.")