ophyd-async 0.2.0__py3-none-any.whl → 0.3a2__py3-none-any.whl

ophyd_async/panda/_panda_controller.py

@@ -0,0 +1,37 @@
+import asyncio
+from typing import Optional
+
+from ophyd_async.core import (
+    AsyncStatus,
+    DetectorControl,
+    DetectorTrigger,
+    wait_for_value,
+)
+from ophyd_async.panda import PcapBlock
+
+
+class PandaPcapController(DetectorControl):
+    def __init__(self, pcap: PcapBlock) -> None:
+        self.pcap = pcap
+
+    def get_deadtime(self, exposure: float) -> float:
+        return 0.000000008
+
+    async def arm(
+        self,
+        num: int,
+        trigger: DetectorTrigger = DetectorTrigger.constant_gate,
+        exposure: Optional[float] = None,
+    ) -> AsyncStatus:
+        assert trigger in (
+            DetectorTrigger.constant_gate,
+            trigger == DetectorTrigger.variable_gate,
+        ), "Only constant_gate and variable_gate triggering is supported on the PandA"
+        await asyncio.gather(self.pcap.arm.set(True))
+        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) -> 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/_utils.py

@@ -0,0 +1,15 @@
+from typing import Any, Dict, Sequence
+
+
+def phase_sorter(panda_signal_values: Dict[str, Any]) -> Sequence[Dict[str, Any]]:
+    # Panda has two load phases. If the signal name ends in the string "UNITS",
+    # it needs to be loaded first so put in first phase
+    phase_1, phase_2 = {}, {}
+
+    for key, value in panda_signal_values.items():
+        if key.endswith("units"):
+            phase_1[key] = value
+        else:
+            phase_2[key] = value
+
+    return [phase_1, phase_2]

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"]

ophyd_async/sim/demo/sim_motor.py

@@ -0,0 +1,116 @@
+import asyncio
+import time
+from typing import Callable, List, Optional
+
+from bluesky.protocols import Movable, Stoppable
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.core.async_status import AsyncStatus
+from ophyd_async.core.signal import soft_signal_r_and_backend, soft_signal_rw
+
+
+class SimMotor(StandardReadable, Movable, Stoppable):
+    def __init__(self, name="", instant=True) -> None:
+        """
+        Simulated motor device
+
+        args:
+        - prefix: str: Signal names prefix
+        - name: str: name of device
+        - instant: bool: whether to move instantly, or with a delay
+        """
+        self._instant = instant
+        self._move_task: Optional[asyncio.Task] = None
+
+        # Define some signals
+        self.user_setpoint = soft_signal_rw(float, 0)
+        self.user_readback, self._user_readback = soft_signal_r_and_backend(float, 0)
+        self.velocity = soft_signal_rw(float, 1.0)
+        self.egu = soft_signal_rw(float, "mm")
+
+        # Set name and signals for read() and read_configuration()
+        self.set_readable_signals(
+            read=[self.user_readback],
+            config=[self.velocity, self.egu],
+        )
+        super().__init__(name=name)
+
+        # Whether set() should complete successfully or not
+        self._set_success = True
+
+    def stop(self, success=False):
+        """
+        Stop the motor if it is moving
+        """
+        if self._move_task:
+            self._move_task.cancel()
+            self._move_task = None
+
+        self._set_success = success
+
+    def set(self, new_position: float, timeout: Optional[float] = None) -> AsyncStatus:  # noqa: F821
+        """
+        Asynchronously move the motor to a new position.
+        """
+        watchers: List[Callable] = []
+        coro = asyncio.wait_for(self._move(new_position, watchers), timeout=timeout)
+        return AsyncStatus(coro, watchers)
+
+    async def _move(self, new_position: float, watchers: List[Callable] = []):
+        """
+        Start the motor moving to a new position.
+
+        If the motor is already moving, it will stop first.
+        If this is an instant motor the move will be instantaneous.
+        """
+        self.stop()
+        start = time.monotonic()
+
+        current_position = await self.user_readback.get_value()
+        distance = abs(new_position - current_position)
+        travel_time = 0 if self._instant else distance / await self.velocity.get_value()
+
+        old_position, units = await asyncio.gather(
+            self.user_setpoint.get_value(),
+            self.egu.get_value(),
+        )
+
+        async def update_position():
+            while True:
+                time_elapsed = round(time.monotonic() - start, 2)
+
+                # update position based on time elapsed
+                if time_elapsed >= travel_time:
+                    # successfully reached our target position
+                    await self._user_readback.put(new_position)
+                    self._set_success = True
+                    break
+                else:
+                    current_position = (
+                        old_position + distance * time_elapsed / travel_time
+                    )
+
+                await self._user_readback.put(current_position)
+
+                # notify watchers of the new position
+                for watcher in watchers:
+                    watcher(
+                        name=self.name,
+                        current=current_position,
+                        initial=old_position,
+                        target=new_position,
+                        unit=units,
+                        time_elapsed=time.monotonic() - start,
+                    )
+
+                # 10hz update loop
+                await asyncio.sleep(0.1)
+
+        # set up a task that updates the motor position at 10hz
+        self._move_task = asyncio.create_task(update_position())
+
+        try:
+            await self._move_task
+        finally:
+            if not self._set_success:
+                raise RuntimeError("Motor was stopped")