ophyd-async 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -1,12 +1,12 @@
 import asyncio
-from typing import Optional, Set
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
     DetectorControl,
     DetectorTrigger,
 )
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 
@@ -14,32 +14,37 @@ class SimController(DetectorControl):
     def __init__(
         self,
         driver: adcore.ADBaseIO,
-        good_states: Set[adcore.DetectorState] = set(adcore.DEFAULT_GOOD_STATES),
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
         self.driver = driver
         self.good_states = good_states
+        self.frame_timeout: float
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.002
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         assert (
-            trigger == DetectorTrigger.internal
+            trigger_info.trigger == DetectorTrigger.internal
         ), "fly scanning (i.e. external triggering) is not supported for this device"
-        frame_timeout = DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        self.frame_timeout = (
+            DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        )
         await asyncio.gather(
-            self.driver.num_images.set(num),
+            self.driver.num_images.set(trigger_info.number),
             self.driver.image_mode.set(adcore.ImageMode.multiple),
         )
-        return await adcore.start_acquiring_driver_and_ensure_status(
-            self.driver, good_states=self.good_states, timeout=frame_timeout
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states, timeout=self.frame_timeout
         )
 
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock

ophyd_async/epics/advimba/_vimba.py

@@ -32,7 +32,7 @@ class VimbaDetector(StandardDetector, HasHints):
                 self.hdf,
                 path_provider,
                 lambda: self.name,
-                adcore.ADBaseShapeProvider(self.drv),
+                adcore.ADBaseDatasetDescriber(self.drv),
             ),
             config_sigs=(self.drv.acquire_time,),
             name=name,

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,7 +1,8 @@
 import asyncio
-from typing import Optional
 
-from ophyd_async.core import AsyncStatus, DetectorControl, DetectorTrigger
+from ophyd_async.core import DetectorControl, DetectorTrigger
+from ophyd_async.core._detector import TriggerInfo
+from ophyd_async.core._status import AsyncStatus
 from ophyd_async.epics import adcore
 
 from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
@@ -27,32 +28,36 @@ class VimbaController(DetectorControl):
         driver: VimbaDriverIO,
     ) -> None:
         self._drv = driver
+        self._arm_status: AsyncStatus | None = None
 
-    def get_deadtime(self, exposure: float) -> float:
+    def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
-    async def arm(
-        self,
-        num: int,
-        trigger: DetectorTrigger = DetectorTrigger.internal,
-        exposure: Optional[float] = None,
-    ) -> AsyncStatus:
+    async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            self._drv.trigger_mode.set(TRIGGER_MODE[trigger]),
-            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger]),
-            self._drv.num_images.set(num),
+            self._drv.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
+            self._drv.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
+            self._drv.num_images.set(trigger_info.number),
             self._drv.image_mode.set(adcore.ImageMode.multiple),
         )
-        if exposure is not None and trigger not in [
+        if trigger_info.livetime is not None and trigger_info.trigger not in [
             DetectorTrigger.variable_gate,
             DetectorTrigger.constant_gate,
         ]:
-            await self._drv.acquire_time.set(exposure)
-        if trigger != DetectorTrigger.internal:
+            await self._drv.acquire_time.set(trigger_info.livetime)
+        if trigger_info.trigger != DetectorTrigger.internal:
             self._drv.trigger_source.set(VimbaTriggerSource.line1)
         else:
             self._drv.trigger_source.set(VimbaTriggerSource.freerun)
-        return await adcore.start_acquiring_driver_and_ensure_status(self._drv)
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self._drv
+        )
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
 
     async def disarm(self):
         await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/demo/_mover.py

@@ -4,10 +4,10 @@ import numpy as np
 from bluesky.protocols import Movable, Stoppable
 
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    CalculateTimeout,
     ConfigSignal,
     Device,
     HintedSignal,
@@ -44,9 +44,8 @@ class Mover(StandardReadable, Movable, Stoppable):
         self.readback.set_name(name)
 
     @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        new_position = value
         self._set_success = True
         old_position, units, precision, velocity = await asyncio.gather(
             self.setpoint.get_value(),
@@ -54,7 +53,7 @@ class Mover(StandardReadable, Movable, Stoppable):
             self.precision.get_value(),
             self.velocity.get_value(),
         )
-        if timeout is CalculateTimeout:
+        if timeout == CALCULATE_TIMEOUT:
             assert velocity > 0, "Mover has zero velocity"
             timeout = abs(new_position - old_position) / velocity + DEFAULT_TIMEOUT
         # Make an Event that will be set on completion, and a Status that will

ophyd_async/epics/demo/sensor.db

@@ -17,4 +17,3 @@ record(calc, "$(P)Value") {
     field(EGU,  "$(EGU=cts/s)")
     field(PREC, "$(PREC=3)")
 }
-

ophyd_async/epics/eiger/__init__.py

@@ -0,0 +1,5 @@
+from ._eiger import EigerDetector, EigerTriggerInfo
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDriverIO
+
+__all__ = ["EigerDetector", "EigerController", "EigerDriverIO", "EigerTriggerInfo"]

ophyd_async/epics/eiger/_eiger.py

@@ -0,0 +1,43 @@
+from pydantic import Field
+
+from ophyd_async.core import AsyncStatus, PathProvider, StandardDetector
+from ophyd_async.core._detector import TriggerInfo
+
+from ._eiger_controller import EigerController
+from ._eiger_io import EigerDriverIO
+from ._odin_io import Odin, OdinWriter
+
+
+class EigerTriggerInfo(TriggerInfo):
+    energy_ev: float = Field(gt=0)
+
+
+class EigerDetector(StandardDetector):
+    """
+    Ophyd-async implementation of an Eiger Detector.
+    """
+
+    _controller: EigerController
+    _writer: Odin
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="-EA-EIGER-01:",
+        hdf_suffix="-EA-ODIN-01:",
+        name="",
+    ):
+        self.drv = EigerDriverIO(prefix + drv_suffix)
+        self.odin = Odin(prefix + hdf_suffix + "FP:")
+
+        super().__init__(
+            EigerController(self.drv),
+            OdinWriter(path_provider, lambda: self.name, self.odin),
+            name=name,
+        )
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: EigerTriggerInfo) -> None:  # type: ignore
+        await self._controller.set_energy(value.energy_ev)
+        await super().prepare(value)

ophyd_async/epics/eiger/_eiger_controller.py

@@ -0,0 +1,66 @@
+import asyncio
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorControl,
+    DetectorTrigger,
+    set_and_wait_for_other_value,
+)
+from ophyd_async.core._detector import TriggerInfo
+
+from ._eiger_io import EigerDriverIO, EigerTriggerMode
+
+EIGER_TRIGGER_MODE_MAP = {
+    DetectorTrigger.internal: EigerTriggerMode.internal,
+    DetectorTrigger.constant_gate: EigerTriggerMode.gate,
+    DetectorTrigger.variable_gate: EigerTriggerMode.gate,
+    DetectorTrigger.edge_trigger: EigerTriggerMode.edge,
+}
+
+
+class EigerController(DetectorControl):
+    def __init__(
+        self,
+        driver: EigerDriverIO,
+    ) -> None:
+        self._drv = driver
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        # See https://media.dectris.com/filer_public/30/14/3014704e-5f3b-43ba-8ccf-8ef720e60d2a/240202_usermanual_eiger2.pdf
+        return 0.0001
+
+    async def set_energy(self, energy: float, tolerance: float = 0.1):
+        """Changing photon energy takes some time so only do so if the current energy is
+        outside the tolerance."""
+        current_energy = await self._drv.photon_energy.get_value()
+        if abs(current_energy - energy) > tolerance:
+            await self._drv.photon_energy.set(energy)
+
+    async def prepare(self, trigger_info: TriggerInfo):
+        coros = [
+            self._drv.trigger_mode.set(
+                EIGER_TRIGGER_MODE_MAP[trigger_info.trigger].value
+            ),
+            self._drv.num_images.set(trigger_info.number),
+        ]
+        if trigger_info.livetime is not None:
+            coros.extend(
+                [
+                    self._drv.acquire_time.set(trigger_info.livetime),
+                    self._drv.acquire_period.set(trigger_info.livetime),
+                ]
+            )
+        await asyncio.gather(*coros)
+
+    async def arm(self):
+        # TODO: Detector state should be an enum see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
+        self._arm_status = set_and_wait_for_other_value(
+            self._drv.arm, 1, self._drv.state, "ready", timeout=DEFAULT_TIMEOUT
+        )
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
+    async def disarm(self):
+        await self._drv.disarm.set(1)

ophyd_async/epics/eiger/_eiger_io.py

@@ -0,0 +1,42 @@
+from enum import Enum
+
+from ophyd_async.core import Device
+from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw_rbv, epics_signal_w
+
+
+class EigerTriggerMode(str, Enum):
+    internal = "ints"
+    edge = "exts"
+    gate = "exte"
+
+
+class EigerDriverIO(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.bit_depth = epics_signal_r(int, f"{prefix}BitDepthReadout")
+        self.stale_parameters = epics_signal_r(bool, f"{prefix}StaleParameters")
+        self.state = epics_signal_r(str, f"{prefix}DetectorState")
+        self.roi_mode = epics_signal_rw_rbv(str, f"{prefix}RoiMode")
+
+        self.acquire_time = epics_signal_rw_rbv(float, f"{prefix}CountTime")
+        self.acquire_period = epics_signal_rw_rbv(float, f"{prefix}FrameTime")
+
+        self.num_images = epics_signal_rw_rbv(int, f"{prefix}Nimages")
+        self.num_triggers = epics_signal_rw_rbv(int, f"{prefix}Ntrigger")
+
+        # TODO: Should be EigerTriggerMode enum, see https://github.com/DiamondLightSource/eiger-fastcs/issues/43
+        self.trigger_mode = epics_signal_rw_rbv(str, f"{prefix}TriggerMode")
+
+        self.arm = epics_signal_w(int, f"{prefix}Arm")
+        self.disarm = epics_signal_w(int, f"{prefix}Disarm")
+        self.abort = epics_signal_w(int, f"{prefix}Abort")
+
+        self.beam_centre_x = epics_signal_rw_rbv(float, f"{prefix}BeamCenterX")
+        self.beam_centre_y = epics_signal_rw_rbv(float, f"{prefix}BeamCenterY")
+
+        self.det_distance = epics_signal_rw_rbv(float, f"{prefix}DetectorDistance")
+        self.omega_start = epics_signal_rw_rbv(float, f"{prefix}OmegaStart")
+        self.omega_increment = epics_signal_rw_rbv(float, f"{prefix}OmegaIncrement")
+
+        self.photon_energy = epics_signal_rw_rbv(float, f"{prefix}PhotonEnergy")
+
+        super().__init__(name)

ophyd_async/epics/eiger/_odin_io.py

@@ -0,0 +1,126 @@
+import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
+from enum import Enum
+
+from bluesky.protocols import StreamAsset
+from event_model import DataKey
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorWriter,
+    Device,
+    DeviceVector,
+    NameProvider,
+    PathProvider,
+    observe_value,
+    set_and_wait_for_value,
+)
+from ophyd_async.epics.signal import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+)
+
+
+class Writing(str, Enum):
+    ON = "ON"
+    OFF = "OFF"
+
+
+class OdinNode(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.writing = epics_signal_r(Writing, f"{prefix}HDF:Writing")
+        self.connected = epics_signal_r(bool, f"{prefix}Connected")
+
+        super().__init__(name)
+
+
+class Odin(Device):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.nodes = DeviceVector({i: OdinNode(f"{prefix}FP{i}:") for i in range(4)})
+
+        self.capture = epics_signal_rw(
+            Writing, f"{prefix}Writing", f"{prefix}ConfigHdfWrite"
+        )
+        self.num_captured = epics_signal_r(int, f"{prefix}FramesWritten")
+        self.num_to_capture = epics_signal_rw_rbv(int, f"{prefix}ConfigHdfFrames")
+
+        self.start_timeout = epics_signal_rw_rbv(int, f"{prefix}TimeoutTimerPeriod")
+
+        self.image_height = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims0")
+        self.image_width = epics_signal_rw_rbv(int, f"{prefix}DatasetDataDims1")
+
+        self.num_row_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks1")
+        self.num_col_chunks = epics_signal_rw_rbv(int, f"{prefix}DatasetDataChunks2")
+
+        self.file_path = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePath")
+        self.file_name = epics_signal_rw_rbv(str, f"{prefix}ConfigHdfFilePrefix")
+
+        self.acquisition_id = epics_signal_rw_rbv(
+            str, f"{prefix}ConfigHdfAcquisitionId"
+        )
+
+        self.data_type = epics_signal_rw_rbv(str, f"{prefix}DatasetDataDatatype")
+
+        super().__init__(name)
+
+
+class OdinWriter(DetectorWriter):
+    def __init__(
+        self,
+        path_provider: PathProvider,
+        name_provider: NameProvider,
+        odin_driver: Odin,
+    ) -> None:
+        self._drv = odin_driver
+        self._path_provider = path_provider
+        self._name_provider = name_provider
+        super().__init__()
+
+    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
+        info = self._path_provider(device_name=self._name_provider())
+
+        await asyncio.gather(
+            self._drv.file_path.set(str(info.directory_path)),
+            self._drv.file_name.set(info.filename),
+            self._drv.data_type.set(
+                "uint16"
+            ),  # TODO: Get from eiger https://github.com/bluesky/ophyd-async/issues/529
+            self._drv.num_to_capture.set(0),
+        )
+
+        await self._drv.capture.set(Writing.ON)
+
+        return await self._describe()
+
+    async def _describe(self) -> dict[str, DataKey]:
+        data_shape = await asyncio.gather(
+            self._drv.image_height.get_value(), self._drv.image_width.get_value()
+        )
+
+        return {
+            "data": DataKey(
+                source=self._drv.file_name.source,
+                shape=data_shape,
+                dtype="array",
+                # TODO: Use correct type based on eiger https://github.com/bluesky/ophyd-async/issues/529
+                dtype_numpy="<u2",  # type: ignore
+                external="STREAM:",
+            )
+        }
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        async for num_captured in observe_value(self._drv.num_captured, timeout):
+            yield num_captured
+
+    async def get_indices_written(self) -> int:
+        return await self._drv.num_captured.get_value()
+
+    def collect_stream_docs(self, indices_written: int) -> AsyncIterator[StreamAsset]:
+        # TODO: Correctly return stream https://github.com/bluesky/ophyd-async/issues/530
+        raise NotImplementedError()
+
+    async def close(self) -> None:
+        await set_and_wait_for_value(self._drv.capture, Writing.OFF)

ophyd_async/epics/motor.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import Optional
 
 from bluesky.protocols import (
     Flyable,
@@ -11,10 +10,10 @@ from bluesky.protocols import (
 from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
+    CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
     AsyncStatus,
     CalculatableTimeout,
-    CalculateTimeout,
     ConfigSignal,
     HintedSignal,
     StandardReadable,
@@ -54,7 +53,7 @@ class FlyMotorInfo(BaseModel):
 
     #: Maximum time for the complete motor move, including run up and run down.
     #: Defaults to `time_for_move` + run up and run down times + 10s.
-    timeout: CalculatableTimeout = Field(frozen=True, default=CalculateTimeout)
+    timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
 
 
 class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
@@ -83,13 +82,13 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         self._set_success = True
 
         # end_position of a fly move, with run_up_distance added on.
-        self._fly_completed_position: Optional[float] = None
+        self._fly_completed_position: float | None = None
 
         # Set on kickoff(), complete when motor reaches self._fly_completed_position
-        self._fly_status: Optional[WatchableAsyncStatus] = None
+        self._fly_status: WatchableAsyncStatus | None = None
 
         # Set during prepare
-        self._fly_timeout: Optional[CalculatableTimeout] = CalculateTimeout
+        self._fly_timeout: CalculatableTimeout | None = CALCULATE_TIMEOUT
 
         super().__init__(name=name)
 
@@ -119,7 +118,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         )
 
         await self.set(fly_prepared_position)
-        await self.velocity.set(fly_velocity)
+        await self.velocity.set(abs(fly_velocity))
 
     @AsyncStatus.wrap
     async def kickoff(self):
@@ -138,9 +137,8 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
         return self._fly_status
 
     @WatchableAsyncStatus.wrap
-    async def set(
-        self, new_position: float, timeout: CalculatableTimeout = CalculateTimeout
-    ):
+    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
+        new_position = value
         self._set_success = True
         (
             old_position,
@@ -155,7 +153,7 @@ class Motor(StandardReadable, Locatable, Stoppable, Flyable, Preparable):
             self.velocity.get_value(),
             self.acceleration_time.get_value(),
         )
-        if timeout is CalculateTimeout:
+        if timeout is CALCULATE_TIMEOUT:
             assert velocity > 0, "Motor has zero velocity"
             timeout = (
                 abs(new_position - old_position) / velocity