ophyd-async 0.3a1__py3-none-any.whl → 0.3a2__py3-none-any.whl

ophyd_async/panda/_common_blocks.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from ophyd_async.core import Device, DeviceVector, SignalR, SignalRW
+from ophyd_async.panda._table import SeqTable
+
+
+class DataBlock(Device):
+    # In future we may decide to make hdf_* optional
+    hdf_directory: SignalRW[str]
+    hdf_file_name: SignalRW[str]
+    num_capture: SignalRW[int]
+    num_captured: SignalR[int]
+    capture: SignalRW[bool]
+    flush_period: SignalRW[float]
+
+
+class PulseBlock(Device):
+    delay: SignalRW[float]
+    width: SignalRW[float]
+
+
+class TimeUnits(str, Enum):
+    min = "min"
+    s = "s"
+    ms = "ms"
+    us = "us"
+
+
+class SeqBlock(Device):
+    table: SignalRW[SeqTable]
+    active: SignalRW[bool]
+    repeats: SignalRW[int]
+    prescale: SignalRW[float]
+    prescale_units: SignalRW[TimeUnits]
+    enable: SignalRW[str]
+
+
+class PcapBlock(Device):
+    active: SignalR[bool]
+    arm: SignalRW[bool]
+
+
+class CommonPandaBlocks(Device):
+    pulse: DeviceVector[PulseBlock]
+    seq: DeviceVector[SeqBlock]
+    pcap: PcapBlock
+    data: DataBlock

ophyd_async/panda/_hdf_panda.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Sequence
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DirectoryProvider,
+    SignalR,
+    StandardDetector,
+)
+from ophyd_async.epics.pvi import create_children_from_annotations, fill_pvi_entries
+
+from ._common_blocks import CommonPandaBlocks
+from ._panda_controller import PandaPcapController
+from .writers._hdf_writer import PandaHDFWriter
+
+
+class HDFPanda(CommonPandaBlocks, StandardDetector):
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        config_sigs: Sequence[SignalR] = (),
+        name: str = "",
+    ):
+        self._prefix = prefix
+
+        create_children_from_annotations(self)
+        controller = PandaPcapController(pcap=self.pcap)
+        writer = PandaHDFWriter(
+            prefix=prefix,
+            directory_provider=directory_provider,
+            name_provider=lambda: name,
+            panda_device=self,
+        )
+        super().__init__(
+            controller=controller,
+            writer=writer,
+            config_sigs=config_sigs,
+            name=name,
+            writer_timeout=DEFAULT_TIMEOUT,
+        )
+
+    async def connect(
+        self, sim: bool = False, timeout: float = DEFAULT_TIMEOUT
+    ) -> None:
+        await fill_pvi_entries(self, self._prefix + "PVI", timeout=timeout, sim=sim)
+        await super().connect(sim=sim, timeout=timeout)

ophyd_async/panda/{panda_controller.py → _panda_controller.py}

@@ -7,15 +7,11 @@ from ophyd_async.core import (
     DetectorTrigger,
     wait_for_value,
 )
-
-from .panda import PcapBlock
+from ophyd_async.panda import PcapBlock
 
 
 class PandaPcapController(DetectorControl):
-    def __init__(
-        self,
-        pcap: PcapBlock,
-    ) -> None:
+    def __init__(self, pcap: PcapBlock) -> None:
         self.pcap = pcap
 
     def get_deadtime(self, exposure: float) -> float:
@@ -35,7 +31,7 @@ class PandaPcapController(DetectorControl):
         await wait_for_value(self.pcap.active, True, timeout=1)
         return AsyncStatus(wait_for_value(self.pcap.active, False, timeout=None))
 
-    async def disarm(self):
+    async def disarm(self) -> AsyncStatus:
         await asyncio.gather(self.pcap.arm.set(False))
         await wait_for_value(self.pcap.active, False, timeout=1)
         return AsyncStatus(wait_for_value(self.pcap.active, False, timeout=None))

ophyd_async/panda/_trigger.py

@@ -0,0 +1,39 @@
+import asyncio
+from dataclasses import dataclass
+
+from ophyd_async.core import TriggerLogic, wait_for_value
+from ophyd_async.panda import SeqBlock, SeqTable, TimeUnits
+
+
+@dataclass
+class SeqTableInfo:
+    sequence_table: SeqTable
+    repeats: int
+    prescale_as_us: float = 1  # microseconds
+
+
+class StaticSeqTableTriggerLogic(TriggerLogic[SeqTableInfo]):
+    def __init__(self, seq: SeqBlock) -> None:
+        self.seq = seq
+
+    async def prepare(self, value: SeqTableInfo):
+        await asyncio.gather(
+            self.seq.prescale_units.set(TimeUnits.us),
+            self.seq.enable.set("ZERO"),
+        )
+        await asyncio.gather(
+            self.seq.prescale.set(value.prescale_as_us),
+            self.seq.repeats.set(value.repeats),
+            self.seq.table.set(value.sequence_table),
+        )
+
+    async def kickoff(self) -> None:
+        await self.seq.enable.set("ONE")
+        await wait_for_value(self.seq.active, True, timeout=1)
+
+    async def complete(self) -> None:
+        await wait_for_value(self.seq.active, False, timeout=None)
+
+    async def stop(self):
+        await self.seq.enable.set("ZERO")
+        await wait_for_value(self.seq.active, False, timeout=1)

ophyd_async/panda/writers/__init__.py

@@ -0,0 +1,3 @@
+from ._hdf_writer import PandaHDFWriter
+
+__all__ = ["PandaHDFWriter"]

ophyd_async/panda/writers/_hdf_writer.py

@@ -0,0 +1,220 @@
+import asyncio
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any, AsyncGenerator, AsyncIterator, Dict, List, Optional
+
+from bluesky.protocols import Descriptor, StreamAsset
+from p4p.client.thread import Context
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    DetectorWriter,
+    Device,
+    DirectoryProvider,
+    NameProvider,
+    SignalR,
+    wait_for_value,
+)
+from ophyd_async.core.signal import observe_value
+from ophyd_async.panda import CommonPandaBlocks
+
+from ._panda_hdf_file import _HDFDataset, _HDFFile
+
+
+class Capture(str, Enum):
+    # Capture signals for the HDF Panda
+    No = "No"
+    Value = "Value"
+    Diff = "Diff"
+    Sum = "Sum"
+    Mean = "Mean"
+    Min = "Min"
+    Max = "Max"
+    MinMax = "Min Max"
+    MinMaxMean = "Min Max Mean"
+
+
+def get_capture_signals(
+    block: Device, path_prefix: Optional[str] = ""
+) -> Dict[str, SignalR]:
+    """Get dict mapping a capture signal's name to the signal itself"""
+    if not path_prefix:
+        path_prefix = ""
+    signals: Dict[str, SignalR[Any]] = {}
+    for attr_name, attr in block.children():
+        # Capture signals end in _capture, but num_capture is a red herring
+        if attr_name == "num_capture":
+            continue
+        dot_path = f"{path_prefix}{attr_name}"
+        if isinstance(attr, SignalR) and attr_name.endswith("_capture"):
+            signals[dot_path] = attr
+        attr_signals = get_capture_signals(attr, path_prefix=dot_path + ".")
+        signals.update(attr_signals)
+    return signals
+
+
+@dataclass
+class CaptureSignalWrapper:
+    signal: SignalR
+    capture_type: Capture
+
+
+# This should return a dictionary which contains a dict, containing the Capture
+# signal object, and the value of that signal
+async def get_signals_marked_for_capture(
+    capture_signals: Dict[str, SignalR],
+) -> Dict[str, CaptureSignalWrapper]:
+    # Read signals to see if they should be captured
+    do_read = [signal.get_value() for signal in capture_signals.values()]
+
+    signal_values = await asyncio.gather(*do_read)
+
+    assert len(signal_values) == len(
+        capture_signals
+    ), "Length of read signals are different to length of signals"
+
+    signals_to_capture: Dict[str, CaptureSignalWrapper] = {}
+    for signal_path, signal_object, signal_value in zip(
+        capture_signals.keys(), capture_signals.values(), signal_values
+    ):
+        signal_path = signal_path.replace("_capture", "")
+        if (signal_value.value in iter(Capture)) and (signal_value.value != Capture.No):
+            signals_to_capture[signal_path] = CaptureSignalWrapper(
+                signal_object,
+                signal_value.value,
+            )
+
+    return signals_to_capture
+
+
+class PandaHDFWriter(DetectorWriter):
+    _ctxt: Optional[Context] = None
+
+    def __init__(
+        self,
+        prefix: str,
+        directory_provider: DirectoryProvider,
+        name_provider: NameProvider,
+        panda_device: CommonPandaBlocks,
+    ) -> None:
+        self.panda_device = panda_device
+        self._prefix = prefix
+        self._directory_provider = directory_provider
+        self._name_provider = name_provider
+        self._datasets: List[_HDFDataset] = []
+        self._file: Optional[_HDFFile] = None
+        self._multiplier = 1
+
+    # Triggered on PCAP arm
+    async def open(self, multiplier: int = 1) -> Dict[str, Descriptor]:
+        """Retrieve and get descriptor of all PandA signals marked for capture"""
+
+        # Get capture PVs by looking at panda. Gives mapping of dotted attribute path
+        # to Signal object
+        self.capture_signals = get_capture_signals(self.panda_device)
+
+        # Ensure flushes are immediate
+        await self.panda_device.data.flush_period.set(0)
+
+        to_capture = await get_signals_marked_for_capture(self.capture_signals)
+        self._file = None
+        info = self._directory_provider()
+        # Set the initial values
+        await asyncio.gather(
+            self.panda_device.data.hdf_directory.set(
+                str(info.root / info.resource_dir)
+            ),
+            self.panda_device.data.hdf_file_name.set(
+                f"{info.prefix}{self.panda_device.name}{info.suffix}",
+            ),
+            self.panda_device.data.num_capture.set(0),
+        )
+
+        # Wait for it to start, stashing the status that tells us when it finishes
+        await self.panda_device.data.capture.set(True)
+        name = self._name_provider()
+        if multiplier > 1:
+            raise ValueError(
+                "All PandA datasets should be scalar, multiplier should be 1"
+            )
+        self._datasets = []
+        for attribute_path, capture_signal in to_capture.items():
+            split_path = attribute_path.split(".")
+            signal_name = split_path[-1]
+            # Get block names from numbered blocks, eg INENC[1]
+            block_name = (
+                f"{split_path[-3]}{split_path[-2]}"
+                if split_path[-2].isnumeric()
+                else split_path[-2]
+            )
+
+            for suffix in str(capture_signal.capture_type).split(" "):
+                self._datasets.append(
+                    _HDFDataset(
+                        name,
+                        block_name,
+                        f"{name}-{block_name}-{signal_name}-{suffix}",
+                        f"{block_name}-{signal_name}".upper() + f"-{suffix}",
+                        [1],
+                        multiplier=1,
+                    )
+                )
+
+        describe = {
+            ds.name: Descriptor(
+                source=self.panda_device.data.hdf_directory.source,
+                shape=ds.shape,
+                dtype="array" if ds.shape != [1] else "number",
+                external="STREAM:",
+            )
+            for ds in self._datasets
+        }
+        return describe
+
+    # Next few functions are exactly the same as AD writer. Could move as default
+    # StandardDetector behavior
+    async def wait_for_index(
+        self, index: int, timeout: Optional[float] = DEFAULT_TIMEOUT
+    ):
+        def matcher(value: int) -> bool:
+            return value >= index
+
+        matcher.__name__ = f"index_at_least_{index}"
+        await wait_for_value(
+            self.panda_device.data.num_captured, matcher, timeout=timeout
+        )
+
+    async def get_indices_written(self) -> int:
+        return await self.panda_device.data.num_captured.get_value()
+
+    async def observe_indices_written(
+        self, timeout=DEFAULT_TIMEOUT
+    ) -> AsyncGenerator[int, None]:
+        """Wait until a specific index is ready to be collected"""
+        async for num_captured in observe_value(
+            self.panda_device.data.num_captured, timeout
+        ):
+            yield num_captured // self._multiplier
+
+    async def collect_stream_docs(
+        self, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
+        # TODO: fail if we get dropped frames
+        if indices_written:
+            if not self._file:
+                self._file = _HDFFile(
+                    self._directory_provider(),
+                    Path(await self.panda_device.data.hdf_file_name.get_value()),
+                    self._datasets,
+                )
+                for doc in self._file.stream_resources():
+                    yield "stream_resource", doc
+            for doc in self._file.stream_data(indices_written):
+                yield "stream_datum", doc
+
+    # Could put this function as default for StandardDetector
+    async def close(self):
+        await self.panda_device.data.capture.set(
+            False, wait=True, timeout=DEFAULT_TIMEOUT
+        )

ophyd_async/panda/writers/_panda_hdf_file.py

@@ -0,0 +1,58 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator, List
+
+from event_model import StreamDatum, StreamResource, compose_stream_resource
+
+from ophyd_async.core import DirectoryInfo
+
+
+@dataclass
+class _HDFDataset:
+    device_name: str
+    block: str
+    name: str
+    path: str
+    shape: List[int]
+    multiplier: int
+
+
+class _HDFFile:
+    def __init__(
+        self,
+        directory_info: DirectoryInfo,
+        full_file_name: Path,
+        datasets: List[_HDFDataset],
+    ) -> None:
+        self._last_emitted = 0
+        self._bundles = [
+            compose_stream_resource(
+                spec="AD_HDF5_SWMR_SLICE",
+                root=str(directory_info.root),
+                data_key=ds.name,
+                resource_path=(f"{str(directory_info.root)}/{full_file_name}"),
+                resource_kwargs={
+                    "name": ds.name,
+                    "block": ds.block,
+                    "path": ds.path,
+                    "multiplier": ds.multiplier,
+                    "timestamps": "/entry/instrument/NDAttributes/NDArrayTimeStamp",
+                },
+            )
+            for ds in datasets
+        ]
+
+    def stream_resources(self) -> Iterator[StreamResource]:
+        for bundle in self._bundles:
+            yield bundle.stream_resource_doc
+
+    def stream_data(self, indices_written: int) -> Iterator[StreamDatum]:
+        # Indices are relative to resource
+        if indices_written > self._last_emitted:
+            indices = {
+                "start": self._last_emitted,
+                "stop": indices_written,
+            }
+            self._last_emitted = indices_written
+            for bundle in self._bundles:
+                yield bundle.compose_stream_datum(indices)

ophyd_async/planstubs/__init__.py

@@ -0,0 +1,5 @@
+from .prepare_trigger_and_dets import (
+    prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
+)
+
+__all__ = ["prepare_static_seq_table_flyer_and_detectors_with_same_trigger"]

ophyd_async/planstubs/prepare_trigger_and_dets.py

@@ -0,0 +1,57 @@
+from typing import List
+
+import bluesky.plan_stubs as bps
+
+from ophyd_async.core.detector import DetectorTrigger, StandardDetector, TriggerInfo
+from ophyd_async.core.flyer import HardwareTriggeredFlyable
+from ophyd_async.core.utils import in_micros
+from ophyd_async.panda._table import SeqTable, SeqTableRow, seq_table_from_rows
+from ophyd_async.panda._trigger import SeqTableInfo
+
+
+def prepare_static_seq_table_flyer_and_detectors_with_same_trigger(
+    flyer: HardwareTriggeredFlyable[SeqTableInfo],
+    detectors: List[StandardDetector],
+    num: int,
+    width: float,
+    deadtime: float,
+    shutter_time: float,
+    repeats: int = 1,
+    period: float = 0.0,
+):
+    trigger_info = TriggerInfo(
+        num=num * repeats,
+        trigger=DetectorTrigger.constant_gate,
+        deadtime=deadtime,
+        livetime=width,
+    )
+
+    trigger_time = num * (width + deadtime)
+    pre_delay = max(period - 2 * shutter_time - trigger_time, 0)
+
+    table: SeqTable = seq_table_from_rows(
+        # Wait for pre-delay then open shutter
+        SeqTableRow(
+            time1=in_micros(pre_delay),
+            time2=in_micros(shutter_time),
+            outa2=True,
+        ),
+        # Keeping shutter open, do N triggers
+        SeqTableRow(
+            repeats=num,
+            time1=in_micros(width),
+            outa1=True,
+            outb1=True,
+            time2=in_micros(deadtime),
+            outa2=True,
+        ),
+        # Add the shutter close
+        SeqTableRow(time2=in_micros(shutter_time)),
+    )
+
+    table_info = SeqTableInfo(table, repeats)
+
+    for det in detectors:
+        yield from bps.prepare(det, trigger_info, wait=False, group="prep")
+    yield from bps.prepare(flyer, table_info, wait=False, group="prep")
+    yield from bps.wait(group="prep")

ophyd_async/protocols.py

@@ -0,0 +1,73 @@
+from abc import abstractmethod
+from typing import Dict, Protocol, runtime_checkable
+
+from bluesky.protocols import Descriptor, HasName, Reading
+
+
+@runtime_checkable
+class AsyncReadable(HasName, Protocol):
+    @abstractmethod
+    async def read(self) -> Dict[str, Reading]:
+        """Return an OrderedDict mapping string field name(s) to dictionaries
+        of values and timestamps and optional per-point metadata.
+
+        Example return value:
+
+        .. code-block:: python
+
+            OrderedDict(('channel1',
+                         {'value': 5, 'timestamp': 1472493713.271991}),
+                         ('channel2',
+                         {'value': 16, 'timestamp': 1472493713.539238}))
+        """
+        ...
+
+    @abstractmethod
+    async def describe(self) -> Dict[str, Descriptor]:
+        """Return an OrderedDict with exactly the same keys as the ``read``
+        method, here mapped to per-scan metadata about each field.
+
+        Example return value:
+
+        .. code-block:: python
+
+            OrderedDict(('channel1',
+                         {'source': 'XF23-ID:SOME_PV_NAME',
+                          'dtype': 'number',
+                          'shape': []}),
+                        ('channel2',
+                         {'source': 'XF23-ID:SOME_PV_NAME',
+                          'dtype': 'number',
+                          'shape': []}))
+        """
+        ...
+
+
+@runtime_checkable
+class AsyncConfigurable(Protocol):
+    @abstractmethod
+    async def read_configuration(self) -> Dict[str, Reading]:
+        """Same API as ``read`` but for slow-changing fields related to configuration.
+        e.g., exposure time. These will typically be read only once per run.
+        """
+        ...
+
+    @abstractmethod
+    async def describe_configuration(self) -> Dict[str, Descriptor]:
+        """Same API as ``describe``, but corresponding to the keys in
+        ``read_configuration``.
+        """
+        ...
+
+
+@runtime_checkable
+class AsyncPausable(Protocol):
+    @abstractmethod
+    async def pause(self) -> None:
+        """Perform device-specific work when the RunEngine pauses."""
+        ...
+
+    @abstractmethod
+    async def resume(self) -> None:
+        """Perform device-specific work when the RunEngine resumes after a pause."""
+        ...

ophyd_async/sim/__init__.py

@@ -0,0 +1,11 @@
+from .pattern_generator import PatternGenerator
+from .sim_pattern_detector_control import SimPatternDetectorControl
+from .sim_pattern_detector_writer import SimPatternDetectorWriter
+from .sim_pattern_generator import SimPatternDetector
+
+__all__ = [
+    "PatternGenerator",
+    "SimPatternDetectorControl",
+    "SimPatternDetectorWriter",
+    "SimPatternDetector",
+]

ophyd_async/sim/demo/__init__.py

@@ -0,0 +1,3 @@
+from .sim_motor import SimMotor
+
+__all__ = ["SimMotor"]