ophyd-async 0.9.0a1__py3-none-any.whl → 0.10.0a1__py3-none-any.whl

ophyd_async/epics/adpilatus/_pilatus_controller.py

@@ -1,9 +1,8 @@
 import asyncio
+from enum import Enum
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
     wait_for_value,
@@ -13,7 +12,19 @@ from ophyd_async.epics import adcore
 from ._pilatus_io import PilatusDriverIO, PilatusTriggerMode
 
 
-class PilatusController(DetectorController):
+class PilatusReadoutTime(float, Enum):
+    """Pilatus readout time per model in ms."""
+
+    # Cite: https://media.dectris.com/User_Manual-PILATUS2-V1_4.pdf
+    PILATUS2 = 2.28e-3
+
+    # Cite: https://media.dectris.com/user-manual-pilatus3-2020.pdf
+    PILATUS3 = 0.95e-3
+
+
+class PilatusController(adcore.ADBaseController[PilatusDriverIO]):
+    """`DetectorController` for a `PilatusDriverIO`."""
+
     _supported_trigger_types = {
         DetectorTrigger.INTERNAL: PilatusTriggerMode.INTERNAL,
         DetectorTrigger.CONSTANT_GATE: PilatusTriggerMode.EXT_ENABLE,
@@ -23,48 +34,43 @@ class PilatusController(DetectorController):
     def __init__(
         self,
         driver: PilatusDriverIO,
-        readout_time: float,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
+        readout_time: float = PilatusReadoutTime.PILATUS3,
     ) -> None:
-        self._drv = driver
+        super().__init__(driver, good_states=good_states)
         self._readout_time = readout_time
-        self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
         return self._readout_time
 
     async def prepare(self, trigger_info: TriggerInfo):
         if trigger_info.livetime is not None:
-            await adcore.set_exposure_time_and_acquire_period_if_supplied(
-                self, self._drv, trigger_info.livetime
+            await self.set_exposure_time_and_acquire_period_if_supplied(
+                trigger_info.livetime
             )
         await asyncio.gather(
-            self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
-            self._drv.num_images.set(
+            self.driver.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)),
+            self.driver.num_images.set(
                 999_999
                 if trigger_info.total_number_of_triggers == 0
                 else trigger_info.total_number_of_triggers
             ),
-            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
 
     async def arm(self):
         # Standard arm the detector and wait for the acquire PV to be True
-        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
-            self._drv
-        )
+        self._arm_status = await self.start_acquiring_driver_and_ensure_status()
+
         # The pilatus has an additional PV that goes True when the camserver
         # is actually ready. Should wait for that too or we risk dropping
         # a frame
         await wait_for_value(
-            self._drv.armed,
+            self.driver.armed,
             True,
             timeout=DEFAULT_TIMEOUT,
         )
 
-    async def wait_for_idle(self):
-        if self._arm_status:
-            await self._arm_status
-
     @classmethod
     def _get_trigger_mode(cls, trigger: DetectorTrigger) -> PilatusTriggerMode:
         if trigger not in cls._supported_trigger_types.keys():
@@ -74,6 +80,3 @@ class PilatusController(DetectorController):
                 f"use {trigger}"
             )
         return cls._supported_trigger_types[trigger]
-
-    async def disarm(self):
-        await adcore.stop_busy_record(self._drv.acquire, False, timeout=1)

ophyd_async/epics/adpilatus/_pilatus_io.py

@@ -1,9 +1,13 @@
-from ophyd_async.core import StrictEnum
+from typing import Annotated as A
+
+from ophyd_async.core import SignalR, SignalRW, StrictEnum
 from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv
+from ophyd_async.epics.core import PvSuffix
 
 
 class PilatusTriggerMode(StrictEnum):
+    """Trigger modes for ADPilatus detector."""
+
     INTERNAL = "Internal"
     EXT_ENABLE = "Ext. Enable"
     EXT_TRIGGER = "Ext. Trigger"
@@ -12,11 +16,9 @@ class PilatusTriggerMode(StrictEnum):
 
 
 class PilatusDriverIO(adcore.ADBaseIO):
-    """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
+    """Driver for the Pilatus pixel array detectors."""
 
-    def __init__(self, prefix: str, name: str = "") -> None:
-        self.trigger_mode = epics_signal_rw_rbv(
-            PilatusTriggerMode, prefix + "TriggerMode"
-        )
-        self.armed = epics_signal_r(bool, prefix + "Armed")
-        super().__init__(prefix, name)
+    """This mirrors the interface provided by ADPilatus/db/pilatus.template."""
+    """See HTML docs at https://areadetector.github.io/areaDetector/ADPilatus/pilatusDoc.html"""
+    trigger_mode: A[SignalRW[PilatusTriggerMode], PvSuffix.rbv("TriggerMode")]
+    armed: A[SignalR[bool], PvSuffix.rbv("Armed_RBV")]

ophyd_async/epics/adsimdetector/__init__.py

@@ -1,7 +1,14 @@
+"""Support for the ADAravis areaDetector driver.
+
+https://github.com/areaDetector/ADSimDetector
+"""
+
 from ._sim import SimDetector
 from ._sim_controller import SimController
+from ._sim_io import SimDriverIO
 
 __all__ = [
-    "SimDetector",
+    "SimDriverIO",
     "SimController",
+    "SimDetector",
 ]

ophyd_async/epics/adsimdetector/_sim.py

@@ -1,35 +1,41 @@
 from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, SignalR, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._sim_controller import SimController
+from ._sim_io import SimDriverIO
 
 
-class SimDetector(StandardDetector):
-    _controller: SimController
-    _writer: adcore.ADHDFWriter
+class SimDetector(adcore.AreaDetector[SimController]):
+    """Detector for simulated Areadetector."""
 
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
         drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name: str = "",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name="",
         config_sigs: Sequence[SignalR] = (),
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
     ):
-        self.drv = adcore.ADBaseIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = SimDriverIO(prefix + drv_suffix)
+        controller = SimController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            SimController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_period, self.drv.acquire_time, *config_sigs),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )

ophyd_async/epics/adsimdetector/_sim_controller.py

@@ -1,51 +1,17 @@
-import asyncio
-
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
-    DetectorController,
-    DetectorTrigger,
-    TriggerInfo,
-)
 from ophyd_async.epics import adcore
 
+from ._sim_io import SimDriverIO
+
+
+class SimController(adcore.ADBaseController[SimDriverIO]):
+    """Controller for simulated Areadetector."""
 
-class SimController(DetectorController):
     def __init__(
         self,
-        driver: adcore.ADBaseIO,
-        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+        driver: SimDriverIO,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
-        self.driver = driver
-        self.good_states = good_states
-        self.frame_timeout: float
-        self._arm_status: AsyncStatus | None = None
+        super().__init__(driver, good_states=good_states)
 
     def get_deadtime(self, exposure: float | None) -> float:
-        return 0.002
-
-    async def prepare(self, trigger_info: TriggerInfo):
-        assert (
-            trigger_info.trigger == DetectorTrigger.INTERNAL
-        ), "fly scanning (i.e. external triggering) is not supported for this device"
-        self.frame_timeout = (
-            DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
-        )
-        await asyncio.gather(
-            self.driver.num_images.set(trigger_info.total_number_of_triggers),
-            self.driver.image_mode.set(adcore.ImageMode.MULTIPLE),
-        )
-
-    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
-        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)
+        return 0.001

ophyd_async/epics/adsimdetector/_sim_io.py

@@ -0,0 +1,10 @@
+from ophyd_async.epics import adcore
+
+
+class SimDriverIO(adcore.ADBaseIO):
+    """Base class for driving simulated Areadetector IO.
+
+    This mirrors the interface provided by ADSimDetector/db/simDetector.template.
+    """
+
+    pass

ophyd_async/epics/advimba/__init__.py

@@ -1,6 +1,13 @@
 from ._vimba import VimbaDetector
 from ._vimba_controller import VimbaController
-from ._vimba_io import VimbaDriverIO, VimbaExposeOutMode, VimbaOnOff, VimbaTriggerSource
+from ._vimba_io import (
+    VimbaConvertFormat,
+    VimbaDriverIO,
+    VimbaExposeOutMode,
+    VimbaOnOff,
+    VimbaOverlap,
+    VimbaTriggerSource,
+)
 
 __all__ = [
     "VimbaDetector",
@@ -9,4 +16,6 @@ __all__ = [
     "VimbaExposeOutMode",
     "VimbaOnOff",
     "VimbaTriggerSource",
+    "VimbaOverlap",
+    "VimbaConvertFormat",
 ]

ophyd_async/epics/advimba/_vimba.py

@@ -1,43 +1,44 @@
-from bluesky.protocols import HasHints, Hints
+from collections.abc import Sequence
 
-from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.core import PathProvider, SignalR
 from ophyd_async.epics import adcore
 
 from ._vimba_controller import VimbaController
 from ._vimba_io import VimbaDriverIO
 
 
-class VimbaDetector(StandardDetector, HasHints):
-    """
-    Ophyd-async implementation of an ADVimba Detector.
-    """
+class VimbaDetector(adcore.AreaDetector[VimbaController]):
+    """Ophyd-async implementation of an ADVimba Detector.
 
-    _controller: VimbaController
-    _writer: adcore.ADHDFWriter
+    https://github.com/areaDetector/ADVimba
+    """
 
     def __init__(
         self,
         prefix: str,
         path_provider: PathProvider,
-        drv_suffix="cam1:",
-        hdf_suffix="HDF1:",
-        name="",
+        drv_suffix: str = "cam1:",
+        writer_cls: type[adcore.ADWriter] = adcore.ADHDFWriter,
+        fileio_suffix: str | None = None,
+        name: str = "",
+        plugins: dict[str, adcore.NDPluginBaseIO] | None = None,
+        config_sigs: Sequence[SignalR] = (),
     ):
-        self.drv = VimbaDriverIO(prefix + drv_suffix)
-        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+        driver = VimbaDriverIO(prefix + drv_suffix)
+        controller = VimbaController(driver)
+
+        writer = writer_cls.with_io(
+            prefix,
+            path_provider,
+            dataset_source=driver,
+            fileio_suffix=fileio_suffix,
+            plugins=plugins,
+        )
 
         super().__init__(
-            VimbaController(self.drv),
-            adcore.ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                adcore.ADBaseDatasetDescriber(self.drv),
-            ),
-            config_sigs=(self.drv.acquire_time,),
+            controller=controller,
+            writer=writer,
+            plugins=plugins,
             name=name,
+            config_sigs=config_sigs,
         )
-
-    @property
-    def hints(self) -> Hints:
-        return self._writer.hints

ophyd_async/epics/advimba/_vimba_controller.py

@@ -1,8 +1,6 @@
 import asyncio
 
 from ophyd_async.core import (
-    AsyncStatus,
-    DetectorController,
     DetectorTrigger,
     TriggerInfo,
 )
@@ -25,42 +23,32 @@ EXPOSE_OUT_MODE = {
 }
 
 
-class VimbaController(DetectorController):
+class VimbaController(adcore.ADBaseController[VimbaDriverIO]):
+    """Controller for the Vimba detector."""
+
     def __init__(
         self,
         driver: VimbaDriverIO,
+        good_states: frozenset[adcore.ADState] = adcore.DEFAULT_GOOD_STATES,
     ) -> None:
-        self._drv = driver
-        self._arm_status: AsyncStatus | None = None
+        super().__init__(driver, good_states=good_states)
 
     def get_deadtime(self, exposure: float | None) -> float:
         return 0.001
 
     async def prepare(self, trigger_info: TriggerInfo):
         await asyncio.gather(
-            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.total_number_of_triggers),
-            self._drv.image_mode.set(adcore.ImageMode.MULTIPLE),
+            self.driver.trigger_mode.set(TRIGGER_MODE[trigger_info.trigger]),
+            self.driver.exposure_mode.set(EXPOSE_OUT_MODE[trigger_info.trigger]),
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(adcore.ADImageMode.MULTIPLE),
         )
         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(trigger_info.livetime)
+            await self.driver.acquire_time.set(trigger_info.livetime)
         if trigger_info.trigger != DetectorTrigger.INTERNAL:
-            self._drv.trigger_source.set(VimbaTriggerSource.LINE1)
+            self.driver.trigger_source.set(VimbaTriggerSource.LINE1)
         else:
-            self._drv.trigger_source.set(VimbaTriggerSource.FREERUN)
-
-    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)
+            self.driver.trigger_source.set(VimbaTriggerSource.FREERUN)

ophyd_async/epics/advimba/_vimba_io.py

@@ -1,17 +1,13 @@
-from ophyd_async.core import StrictEnum
-from ophyd_async.epics import adcore
-from ophyd_async.epics.core import epics_signal_rw_rbv
-
+from typing import Annotated as A
 
-class VimbaPixelFormat(StrictEnum):
-    INTERNAL = "Mono8"
-    EXT_ENABLE = "Mono12"
-    EXT_TRIGGER = "Ext. Trigger"
-    MULT_TRIGGER = "Mult. Trigger"
-    ALIGNMENT = "Alignment"
+from ophyd_async.core import SignalRW, StrictEnum
+from ophyd_async.epics import adcore
+from ophyd_async.epics.core import PvSuffix
 
 
 class VimbaConvertFormat(StrictEnum):
+    """Convert pixel format for the Vimba detector."""
+
     NONE = "None"
     MONO8 = "Mono8"
     MONO16 = "Mono16"
@@ -20,6 +16,8 @@ class VimbaConvertFormat(StrictEnum):
 
 
 class VimbaTriggerSource(StrictEnum):
+    """Mode for the source of triggers on the Vimbda."""
+
     FREERUN = "Freerun"
     LINE1 = "Line1"
     LINE2 = "Line2"
@@ -30,36 +28,33 @@ class VimbaTriggerSource(StrictEnum):
 
 
 class VimbaOverlap(StrictEnum):
+    """Overlap modes for the Vimba detector."""
+
     OFF = "Off"
     PREV_FRAME = "PreviousFrame"
 
 
 class VimbaOnOff(StrictEnum):
+    """On/Off modes on the Vimba detector."""
+
     ON = "On"
     OFF = "Off"
 
 
 class VimbaExposeOutMode(StrictEnum):
+    """Exposure control modes for Vimba detectors."""
+
     TIMED = "Timed"  # Use ExposureTime PV
     TRIGGER_WIDTH = "TriggerWidth"  # Expose for length of high signal
 
 
 class VimbaDriverIO(adcore.ADBaseIO):
-    """This mirrors the interface provided by ADVimba/db/vimba.template."""
-
-    def __init__(self, prefix: str, name: str = "") -> None:
-        # self.pixel_format = epics_signal_rw_rbv(PixelFormat, prefix + "PixelFormat")
-        self.convert_pixel_format = epics_signal_rw_rbv(
-            VimbaConvertFormat, prefix + "ConvertPixelFormat"
-        )  # Pixel format of data outputted to AD
-        self.trigger_source = epics_signal_rw_rbv(
-            VimbaTriggerSource, prefix + "TriggerSource"
-        )
-        self.trigger_mode = epics_signal_rw_rbv(VimbaOnOff, prefix + "TriggerMode")
-        self.trigger_overlap = epics_signal_rw_rbv(
-            VimbaOverlap, prefix + "TriggerOverlap"
-        )
-        self.exposure_mode = epics_signal_rw_rbv(
-            VimbaExposeOutMode, prefix + "ExposureMode"
-        )
-        super().__init__(prefix, name)
+    """Mirrors the interface provided by ADVimba/db/vimba.template."""
+
+    convert_pixel_format: A[
+        SignalRW[VimbaConvertFormat], PvSuffix("ConvertPixelFormat")
+    ]
+    trigger_source: A[SignalRW[VimbaTriggerSource], PvSuffix("TriggerSource")]
+    trigger_mode: A[SignalRW[VimbaOnOff], PvSuffix("TriggerMode")]
+    trigger_overlap: A[SignalRW[VimbaOverlap], PvSuffix("TriggerOverlap")]
+    exposure_mode: A[SignalRW[VimbaExposeOutMode], PvSuffix("ExposureMode")]