ophyd-async 0.13.0__py3-none-any.whl → 0.13.2__py3-none-any.whl

ophyd_async/epics/testing/_example_ioc.py

@@ -4,8 +4,7 @@ from typing import Annotated as A
 
 import numpy as np
 
-from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, Table
-from ophyd_async.core._utils import SubsetEnum
+from ophyd_async.core import Array1D, SignalR, SignalRW, StrictEnum, SubsetEnum, Table
 from ophyd_async.epics.core import EpicsDevice, PvSuffix
 
 from ._utils import TestingIOC, generate_random_pv_prefix

ophyd_async/fastcs/eiger/_eiger.py

@@ -4,7 +4,7 @@ from ophyd_async.core import (
     StandardDetector,
     TriggerInfo,
 )
-from ophyd_async.epics.eiger import Odin, OdinWriter
+from ophyd_async.epics.odin import Odin, OdinWriter
 
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO

ophyd_async/fastcs/jungfrau/__init__.py

@@ -0,0 +1,29 @@
+from ._controller import JungfrauController
+from ._jungfrau import Jungfrau
+from ._signals import (
+    AcquisitionType,
+    DetectorStatus,
+    GainMode,
+    JungfrauDriverIO,
+    JungfrauTriggerMode,
+    PedestalMode,
+)
+from ._utils import (
+    create_jungfrau_external_triggering_info,
+    create_jungfrau_internal_triggering_info,
+    create_jungfrau_pedestal_triggering_info,
+)
+
+__all__ = [
+    "Jungfrau",
+    "DetectorStatus",
+    "create_jungfrau_external_triggering_info",
+    "create_jungfrau_internal_triggering_info",
+    "create_jungfrau_pedestal_triggering_info",
+    "JungfrauController",
+    "JungfrauDriverIO",
+    "JungfrauTriggerMode",
+    "AcquisitionType",
+    "GainMode",
+    "PedestalMode",
+]

ophyd_async/fastcs/jungfrau/_controller.py

@@ -0,0 +1,139 @@
+import asyncio
+import logging
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorController,
+    DetectorTrigger,
+    TriggerInfo,
+    wait_for_value,
+)
+
+from ._signals import (
+    JUNGFRAU_TRIGGER_MODE_MAP,
+    AcquisitionType,
+    DetectorStatus,
+    JungfrauDriverIO,
+    PedestalMode,
+)
+
+# Deadtime is dependant on a wide combination of settings and on trigger mode
+# but this is safe upper-limit
+JUNGFRAU_DEADTIME_S = 2e-5
+
+logger = logging.getLogger("ophyd_async")
+
+
+class JungfrauController(DetectorController):
+    def __init__(self, driver: JungfrauDriverIO):
+        self._driver = driver
+
+    def get_deadtime(self, exposure: float | None = None) -> float:
+        return JUNGFRAU_DEADTIME_S
+
+    async def prepare(self, trigger_info: TriggerInfo) -> None:
+        # ValueErrors and warnings in this function come from the jungfrau operation
+        # docs: https://rtd.xfel.eu/docs/jungfrau-detector-documentation/en/latest/operation.html
+
+        # Deadtime here is really used as "time between frames"
+
+        acquisition_type = await self._driver.acquisition_type.get_value()
+        logger.info(f"Preparing Jungfrau in {acquisition_type} mode.")
+
+        if trigger_info.trigger not in (
+            DetectorTrigger.INTERNAL,
+            DetectorTrigger.EDGE_TRIGGER,
+        ):
+            raise ValueError(
+                "The trigger method can only be called with internal or edge triggering"
+            )
+        if (
+            acquisition_type == AcquisitionType.PEDESTAL
+            and trigger_info.trigger != DetectorTrigger.INTERNAL
+        ):
+            raise ValueError(
+                "Jungfrau must be triggered internally while in pedestal mode."
+            )
+
+        if not isinstance(trigger_info.number_of_events, int):
+            raise TypeError("Number of events must be an integer")
+
+        if acquisition_type != AcquisitionType.PEDESTAL:
+            if (
+                trigger_info.trigger == DetectorTrigger.INTERNAL
+                and trigger_info.number_of_events != 1
+            ):
+                raise ValueError(
+                    "Number of events must be set to 1 in internal trigger mode during "
+                    "standard acquisitions."
+                )
+
+            if (
+                trigger_info.trigger == DetectorTrigger.EDGE_TRIGGER
+                and trigger_info.exposures_per_event != 1
+            ):
+                raise ValueError(
+                    "Exposures per event must be set to 1 in edge trigger mode "
+                    "during standard acquisitions."
+                )
+
+        if not trigger_info.livetime:
+            raise ValueError("Must set TriggerInfo.livetime")
+
+        if trigger_info.livetime < 2e-6:
+            logger.warning("Exposure time shorter than 2μs is not recommended")
+
+        period_between_frames = trigger_info.livetime + trigger_info.deadtime
+
+        if period_between_frames < self.get_deadtime():
+            raise ValueError(
+                f"Period between frames (exposure time - deadtime) = "
+                f"{period_between_frames}s cannot be lower than minimum detector "
+                f"deadtime {self.get_deadtime()}"
+            )
+
+        coros = [
+            self._driver.trigger_mode.set(
+                JUNGFRAU_TRIGGER_MODE_MAP[trigger_info.trigger]
+            ),
+            self._driver.period_between_frames.set(period_between_frames),
+            self._driver.exposure_time.set(trigger_info.livetime),
+        ]
+
+        match acquisition_type:
+            case AcquisitionType.STANDARD:
+                frames_signal = (
+                    trigger_info.exposures_per_event
+                    if trigger_info.trigger is DetectorTrigger.INTERNAL
+                    else trigger_info.number_of_events
+                )
+                coros.extend(
+                    [
+                        self._driver.frames_per_acq.set(frames_signal),
+                    ]
+                )
+            case AcquisitionType.PEDESTAL:
+                coros.extend(
+                    [
+                        self._driver.pedestal_mode_frames.set(
+                            trigger_info.exposures_per_event
+                        ),
+                        self._driver.pedestal_mode_loops.set(
+                            trigger_info.number_of_events
+                        ),
+                        self._driver.pedestal_mode_state.set(PedestalMode.ON),
+                    ]
+                )
+
+        await asyncio.gather(*coros)
+
+    async def arm(self):
+        await self._driver.acquisition_start.trigger()
+
+    async def wait_for_idle(self):
+        await wait_for_value(
+            self._driver.detector_status, DetectorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+        )
+
+    async def disarm(self):
+        await self._driver.acquisition_stop.trigger()

ophyd_async/fastcs/jungfrau/_jungfrau.py

@@ -0,0 +1,30 @@
+from ophyd_async.core import (
+    PathProvider,
+    StandardDetector,
+)
+from ophyd_async.epics.odin import Odin, OdinWriter
+from ophyd_async.fastcs.jungfrau._controller import JungfrauController
+from ophyd_async.fastcs.jungfrau._signals import JungfrauDriverIO
+
+
+class Jungfrau(StandardDetector[JungfrauController, OdinWriter]):
+    """Ophyd-async implementation of a Jungfrau Detector."""
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix: str,
+        hdf_suffix: str,
+        odin_nodes: int,
+        name="",
+    ):
+        self.drv = JungfrauDriverIO(prefix + drv_suffix)
+        self.odin = Odin(prefix + hdf_suffix, nodes=odin_nodes)
+        writer = OdinWriter(
+            path_provider,
+            self.odin,
+            self.drv.bit_depth,
+        )
+        controller = JungfrauController(self.drv)
+        super().__init__(controller, writer, name=name)

ophyd_async/fastcs/jungfrau/_signals.py

@@ -0,0 +1,94 @@
+from pydantic import NonNegativeInt
+
+from ophyd_async.core import (
+    DetectorTrigger,
+    Device,
+    SignalR,
+    SignalRW,
+    SignalX,
+    StrictEnum,
+    soft_signal_rw,
+)
+from ophyd_async.fastcs.core import fastcs_connector
+
+
+class JungfrauTriggerMode(StrictEnum):
+    INTERNAL = "Internal"
+
+    # Detector waits for external trigger to start frame series, but still
+    # controls exposure time and frame period internally
+    EXTERNAL = "External"
+
+
+class DetectorStatus(StrictEnum):
+    IDLE = "Idle"
+    ERROR = "Error"
+    WAITING = "Waiting"
+    RUN_FINISHED = "RunFinished"
+    TRANSMITTING = "Transmitting"
+    RUNNING = "Running"
+    STOPPED = "Stopped"
+
+
+class GainMode(StrictEnum):
+    DYNAMIC = "Dynamic"
+    FORCE_SWITCH_G1 = "ForceSwitchG1"
+    FORCE_SWITCH_G2 = "ForceSwitchG2"
+    FIX_G1 = "FixG1"
+    FIX_G2 = "FixG2"
+
+    # Use with caution - this may damage the detector
+    FIX_G0 = "FixG0"
+
+
+class PedestalMode(StrictEnum):
+    ON = "On"
+    OFF = "Off"
+
+
+class AcquisitionType(StrictEnum):
+    STANDARD = "Standard"
+    PEDESTAL = "Pedestal"
+
+
+JUNGFRAU_TRIGGER_MODE_MAP = {
+    DetectorTrigger.EDGE_TRIGGER: JungfrauTriggerMode.EXTERNAL,
+    DetectorTrigger.INTERNAL: JungfrauTriggerMode.INTERNAL,
+}
+
+
+class JungfrauDriverIO(Device):
+    """Contains signals for handling IO on the Jungfrau detector."""
+
+    exposure_time: SignalRW[float]  # in s
+
+    # Includes deadtime
+    period_between_frames: SignalRW[float]  # in s
+
+    # Sets the delay for the beginning of the exposure time after
+    # trigger input
+    delay_after_trigger: SignalRW[float]  # in s
+
+    # In internal trigger mode, this is frames per trigger. In external trigger mode,
+    # this is frames per overall acquisition. In pedestal mode, this signal is not set.
+    frames_per_acq: SignalRW[NonNegativeInt]
+
+    pedestal_mode_state: SignalRW[PedestalMode]
+    pedestal_mode_frames: SignalRW[NonNegativeInt]
+    pedestal_mode_loops: SignalRW[NonNegativeInt]
+
+    gain_mode: SignalRW[GainMode]
+
+    acquisition_start: SignalX
+
+    acquisition_stop: SignalX
+    bit_depth: SignalR[int]
+    trigger_mode: SignalRW[JungfrauTriggerMode]
+    detector_status: SignalR[DetectorStatus]
+
+    def __init__(self, uri: str, name: str = ""):
+        # Determines how the TriggerInfo gets mapped to the Jungfrau during prepare
+        self.acquisition_type = soft_signal_rw(
+            AcquisitionType, AcquisitionType.STANDARD
+        )
+        super().__init__(name=name, connector=fastcs_connector(self, uri))

ophyd_async/fastcs/jungfrau/_utils.py

@@ -0,0 +1,79 @@
+from pydantic import PositiveInt
+
+from ophyd_async.core import DetectorTrigger, TriggerInfo
+
+
+def create_jungfrau_external_triggering_info(
+    total_triggers: PositiveInt,
+    exposure_time_s: float,
+) -> TriggerInfo:
+    """Create safe Jungfrau TriggerInfo for external triggering.
+
+    Uses parameters which more closely-align with Jungfrau terminology
+    to create TriggerInfo. This device currently only supports one frame per trigger
+    when being externally triggered, but support for this can be added if needed
+
+    Args:
+        total_triggers: Total external triggers expected before ending acquisition.
+        exposure_time_s: How long to expose the detector for each of its frames.
+
+    Returns:
+        `TriggerInfo`
+    """
+    return TriggerInfo(
+        number_of_events=total_triggers,
+        trigger=DetectorTrigger.EDGE_TRIGGER,
+        livetime=exposure_time_s,
+    )
+
+
+def create_jungfrau_internal_triggering_info(
+    number_of_frames: PositiveInt, exposure_time_s: float
+) -> TriggerInfo:
+    """Create safe Jungfrau TriggerInfo for internal triggering.
+
+    Uses parameters which more closely-align with Jungfrau terminology
+    to create TriggerInfo.
+
+    Args:
+        number_of_frames: Total frames taken after starting acquisition.
+        exposure_time_s: How long to expose the detector for each of its frames.
+
+    Returns:
+        `TriggerInfo`
+    """
+    return TriggerInfo(
+        number_of_events=1,
+        trigger=DetectorTrigger.INTERNAL,
+        livetime=exposure_time_s,
+        exposures_per_event=number_of_frames,
+    )
+
+
+def create_jungfrau_pedestal_triggering_info(
+    exposure_time_s: float,
+    pedestal_frames: PositiveInt,
+    pedestal_loops: PositiveInt,
+):
+    """Create safe Jungfrau TriggerInfo for pedestal triggering.
+
+    Uses parameters which more closely-align with Jungfrau terminology
+    to create TriggerInfo.
+
+    NOTE: To trigger the jungfrau in pedestal mode, you must first set the
+    jungfrau acquisition_type signal to AcquisitionType.PEDESTAL!
+
+    Args:
+        exposure_time_s: How long to expose the detector for each of its frames.
+        pedestal_frames: Number of frames taken once triggering begins
+        pedestal_loops: Number of repeats of the pedestal scan before detector disarms.
+
+    Returns:
+        `TriggerInfo`
+    """
+    return TriggerInfo(
+        number_of_events=pedestal_loops,
+        exposures_per_event=pedestal_frames,
+        trigger=DetectorTrigger.INTERNAL,
+        livetime=exposure_time_s,
+    )

ophyd_async/plan_stubs/_settings.py

@@ -13,10 +13,10 @@ from ophyd_async.core import (
     Settings,
     SettingsProvider,
     SignalRW,
+    Table,
     walk_config_signals,
     walk_rw_signals,
 )
-from ophyd_async.core._table import Table
 
 from ._utils import T
 from ._wait_for_awaitable import wait_for_awaitable

ophyd_async/sim/_motor.py

@@ -23,11 +23,19 @@ from ophyd_async.core import StandardReadableFormat as Format
 class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float]):
     """For usage when simulating a motor."""
 
-    def __init__(self, name="", instant=True) -> None:
+    def __init__(
+        self,
+        name: str = "",
+        instant: bool = True,
+        initial_value: float = 0.0,
+        units: str = "mm",
+    ) -> None:
         """Simulate a motor, with optional velocity.
 
         :param name: name of device
         :param instant: whether to move instantly or calculate move time using velocity
+        :param initial_value: initial position of the motor
+        :param units: units of the motor position
         """
         # Define some signals
         with self.add_children_as_readables(Format.HINTED_SIGNAL):
@@ -37,8 +45,8 @@ class SimMotor(StandardReadable, Stoppable, Subscribable[float], Locatable[float
         with self.add_children_as_readables(Format.CONFIG_SIGNAL):
             self.velocity = soft_signal_rw(float, 0 if instant else 1.0)
             self.acceleration_time = soft_signal_rw(float, 0.5)
-            self.units = soft_signal_rw(str, "mm")
-        self.user_setpoint = soft_signal_rw(float, 0)
+            self.units = soft_signal_rw(str, units)
+        self.user_setpoint = soft_signal_rw(float, initial_value)
 
         # Whether set() should complete successfully or not
         self._set_success = True

ophyd_async/sim/_point_detector.py

@@ -41,9 +41,12 @@ class SimPointDetector(StandardReadable):
     """Simalutes a point detector with multiple channels."""
 
     def __init__(
-        self, generator: PatternGenerator, num_channels: int = 3, name: str = ""
+        self,
+        pattern_generator: PatternGenerator | None,
+        num_channels: int = 3,
+        name: str = "",
     ) -> None:
-        self._generator = generator
+        self.pattern_generator = pattern_generator or PatternGenerator()
         self.acquire_time = soft_signal_rw(float, 0.1)
         self.acquiring, self._set_acquiring = soft_signal_r_and_setter(bool)
         self._value_signals = dict(
@@ -75,7 +78,7 @@ class SimPointDetector(StandardReadable):
             # Update the channel value
             for i, channel in self.channel.items():
                 high_energy = modes[channel] == EnergyMode.HIGH
-                point = self._generator.generate_point(i, high_energy)
+                point = self.pattern_generator.generate_point(i, high_energy)
                 setter = self._value_signals[channel.value]
                 setter(int(point * 10000 * update_time))
 

ophyd_async/sim/_stage.py

@@ -8,12 +8,23 @@ class SimStage(StandardReadable):
     """A simulated sample stage with X and Y movables."""
 
     def __init__(self, pattern_generator: PatternGenerator, name="") -> None:
+        self.pattern_generator = pattern_generator
         # Define some child Devices
         with self.add_children_as_readables():
             self.x = SimMotor(instant=False)
             self.y = SimMotor(instant=False)
-        # Tell the pattern generator about the motor positions
-        self.x.user_readback.subscribe_value(pattern_generator.set_x)
-        self.y.user_readback.subscribe_value(pattern_generator.set_y)
         # Set name of device and child devices
         super().__init__(name=name)
+
+    def stage(self):
+        """Stage the motors and report the position to the pattern generator."""
+        # Tell the pattern generator about the motor positions
+        self.x.user_readback.subscribe_value(self.pattern_generator.set_x)
+        self.y.user_readback.subscribe_value(self.pattern_generator.set_y)
+        return super().stage()
+
+    def unstage(self):
+        """Unstage the motors and remove the position subscription."""
+        self.x.user_readback.clear_sub(self.pattern_generator.set_x)
+        self.y.user_readback.clear_sub(self.pattern_generator.set_y)
+        return super().unstage()

ophyd_async/tango/core/_tango_transport.py

@@ -212,7 +212,7 @@ class AttributeProxy(TangoProxy):
 
                 task = asyncio.create_task(_write())
                 await asyncio.wait_for(task, timeout)
-            except asyncio.TimeoutError as te:
+            except TimeoutError as te:
                 raise TimeoutError(f"{self._name} attr put failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(
@@ -451,7 +451,7 @@ class CommandProxy(TangoProxy):
                     timestamp=time.time(),
                     alarm_severity=0,
                 )
-            except asyncio.TimeoutError as te:
+            except TimeoutError as te:
                 raise TimeoutError(f"{self._name} command failed: Timeout") from te
             except DevFailed as de:
                 raise RuntimeError(

ophyd_async/testing/_assert.py

@@ -21,11 +21,11 @@ from ophyd_async.core import (
 from ._utils import T
 
 
-def partial_reading(val: Any) -> dict[str, Any]:
-    """Helper function for building expected reading or configuration dicts.
+def partial_reading(val: Any) -> Mapping[str, Any]:
+    """Helper function for building expected reading or configuration mapping.
 
-    :param val: Value to be wrapped in dict with "value" as the key.
-    :return: The dict that has wrapped the val with key "value".
+    :param val: Value to be wrapped in mapping with "value" as the key.
+    :return: The mapping that has wrapped the val with key "value".
     """
     return {"value": val}
 
@@ -100,7 +100,7 @@ def _assert_readings_approx_equal(
 
 async def assert_configuration(
     configurable: AsyncConfigurable,
-    expected_configuration: dict[str, dict[str, Any]],
+    expected_configuration: Mapping[str, Mapping[str, Any]],
     full_match: bool = True,
 ) -> None:
     """Assert that a configurable Device has the given configuration.
@@ -108,7 +108,7 @@ async def assert_configuration(
     :param configurable:
         Device with an async ``read_configuration()`` method to get the
         configuration from.
-    :param configuration: The expected configuration from the configurable.
+    :param expected_configuration: The expected configuration from the configurable.
     :param full_match: if expected_reading keys set is same as actual keys set.
         true: exact match
         false: expected_reading keys is subset of actual reading keys

ophyd_async/testing/_one_of_everything.py

@@ -6,6 +6,7 @@ import numpy as np
 from ophyd_async.core import (
     Array1D,
     Device,
+    DeviceVector,
     DTypeScalar_co,
     SignalRW,
     StandardReadable,
@@ -15,7 +16,6 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.core._device import DeviceVector
 
 
 class ExampleEnum(StrictEnum):

{ophyd_async-0.13.0.dist-info → ophyd_async-0.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.13.0
+Version: 0.13.2
 Summary: Asynchronous Bluesky hardware abstraction code, compatible with control systems like EPICS and Tango
 Author-email: Tom Cobb <tom.cobb@diamond.ac.uk>
 License: BSD 3-Clause License
@@ -35,10 +35,10 @@ License: BSD 3-Clause License
 Project-URL: GitHub, https://github.com/bluesky/ophyd-async
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
@@ -50,6 +50,7 @@ Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
 Requires-Dist: scanspec>=1.0a1
+Requires-Dist: velocity-profile
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
@@ -57,7 +58,7 @@ Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango
-Requires-Dist: pytango==10.0.0; extra == "tango"
+Requires-Dist: pytango==10.0.2; extra == "tango"
 Provides-Extra: demo
 Requires-Dist: ipython; extra == "demo"
 Requires-Dist: matplotlib; extra == "demo"