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

ophyd_async/epics/eiger/_odin_io.py

@@ -6,6 +6,7 @@ from event_model import DataKey  # type: ignore
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
+    AsyncStatus,
     DetectorWriter,
     Device,
     DeviceVector,
@@ -21,6 +22,7 @@ from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
     epics_signal_rw_rbv,
+    stop_busy_record,
 )
 
 
@@ -68,10 +70,15 @@ class Odin(Device):
 
         self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
         self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
+        self.id = epics_signal_r(str, f"{prefix}AcquisitionID_RBV")
 
         self.num_frames_chunks = epics_signal_rw(int, prefix + "NumFramesChunks")
         self.meta_active = epics_signal_r(str, prefix + "META:AcquisitionActive_RBV")
         self.meta_writing = epics_signal_r(str, prefix + "META:Writing_RBV")
+        self.meta_file_name = epics_signal_r(str, f"{prefix}META:FileName_RBV")
+        self.meta_stop = epics_signal_rw(bool, f"{prefix}META:Stop")
+
+        self.fan_ready = epics_signal_rw(float, f"{prefix}FAN:StateReady_RBV")
 
         self.data_type = epics_signal_rw_rbv(str, f"{prefix}DataType")
 
@@ -88,6 +95,7 @@ class OdinWriter(DetectorWriter):
         self._drv = odin_driver
         self._path_provider = path_provider
         self._eiger_bit_depth = Reference(eiger_bit_depth)
+        self._capture_status: AsyncStatus | None = None
         super().__init__()
 
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
@@ -95,17 +103,23 @@ class OdinWriter(DetectorWriter):
         self._exposures_per_event = exposures_per_event
 
         await asyncio.gather(
-            self._drv.file_path.set(str(info.directory_path)),
-            self._drv.file_name.set(info.filename),
             self._drv.data_type.set(f"UInt{await self._eiger_bit_depth().get_value()}"),
             self._drv.num_to_capture.set(0),
+            self._drv.file_path.set(str(info.directory_path)),
+            self._drv.file_name.set(info.filename),
         )
 
-        await wait_for_value(self._drv.meta_active, "Active", timeout=DEFAULT_TIMEOUT)
+        await asyncio.gather(
+            wait_for_value(
+                self._drv.meta_file_name, info.filename, timeout=DEFAULT_TIMEOUT
+            ),
+            wait_for_value(self._drv.id, info.filename, timeout=DEFAULT_TIMEOUT),
+            wait_for_value(self._drv.meta_active, "Active", timeout=DEFAULT_TIMEOUT),
+        )
 
-        await self._drv.capture.set(
-            Writing.CAPTURE, wait=False
-        )  # TODO: Investigate why we do not get a put callback when setting capture pv https://github.com/bluesky/ophyd-async/issues/866
+        self._capture_status = await set_and_wait_for_value(
+            self._drv.capture, Writing.CAPTURE, wait_for_set_completion=False
+        )
 
         await asyncio.gather(
             wait_for_value(self._drv.capture_rbv, "Capturing", timeout=DEFAULT_TIMEOUT),
@@ -146,4 +160,8 @@ class OdinWriter(DetectorWriter):
         raise NotImplementedError()
 
     async def close(self) -> None:
-        await set_and_wait_for_value(self._drv.capture, Writing.DONE)
+        await stop_busy_record(self._drv.capture, Writing.DONE, timeout=DEFAULT_TIMEOUT)
+        await self._drv.meta_stop.set(True, wait=True)
+        if self._capture_status and not self._capture_status.done:
+            await self._capture_status
+        self._capture_status = None

ophyd_async/epics/pmac/__init__.py

@@ -1,3 +1,8 @@
-from ._pmac_io import PmacAxisIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
+from ._pmac_io import PmacAxisAssignmentIO, PmacCoordIO, PmacIO, PmacTrajectoryIO
 
-__all__ = ["PmacAxisIO", "PmacCoordIO", "PmacIO", "PmacTrajectoryIO"]
+__all__ = [
+    "PmacAxisAssignmentIO",
+    "PmacCoordIO",
+    "PmacIO",
+    "PmacTrajectoryIO",
+]

ophyd_async/epics/pmac/_pmac_io.py

@@ -3,6 +3,7 @@ from collections.abc import Sequence
 import numpy as np
 
 from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
+from ophyd_async.epics import motor
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 CS_LETTERS = "ABCUVWXYZ"
@@ -13,52 +14,53 @@ class PmacTrajectoryIO(StandardReadable):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         self.time_array = epics_signal_rw(
-            Array1D[np.float64], prefix + ":ProfileTimeArray"
+            Array1D[np.float64], prefix + "ProfileTimeArray"
         )
-        self.user_array = epics_signal_rw(Array1D[np.int32], prefix + ":UserArray")
+        self.user_array = epics_signal_rw(Array1D[np.int32], prefix + "UserArray")
         # 1 indexed CS axes so we can index into them from the compound motor input link
         self.positions = DeviceVector(
             {
                 i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}:{letter}:Positions"
+                    Array1D[np.float64], f"{prefix}{letter}:Positions"
                 )
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
         self.use_axis = DeviceVector(
             {
-                i + 1: epics_signal_rw(bool, f"{prefix}:{letter}:UseAxis")
+                i + 1: epics_signal_rw(bool, f"{prefix}{letter}:UseAxis")
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
         self.velocities = DeviceVector(
             {
                 i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}:{letter}:Velocities"
+                    Array1D[np.float64], f"{prefix}{letter}:Velocities"
                 )
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
-        self.points_to_build = epics_signal_rw(int, prefix + ":ProfilePointsToBuild")
-        self.build_profile = epics_signal_rw(bool, prefix + ":ProfileBuild")
-        self.execute_profile = epics_signal_rw(bool, prefix + ":ProfileExecute")
-        self.scan_percent = epics_signal_r(float, prefix + ":TscanPercent_RBV")
-        self.abort_profile = epics_signal_rw(bool, prefix + ":ProfileAbort")
-        self.profile_cs_name = epics_signal_rw(str, prefix + ":ProfileCsName")
-        self.calculate_velocities = epics_signal_rw(bool, prefix + ":ProfileCalcVel")
+        self.points_to_build = epics_signal_rw(int, prefix + "ProfilePointsToBuild")
+        self.build_profile = epics_signal_rw(bool, prefix + "ProfileBuild")
+        self.execute_profile = epics_signal_rw(bool, prefix + "ProfileExecute")
+        self.scan_percent = epics_signal_r(float, prefix + "TscanPercent_RBV")
+        self.abort_profile = epics_signal_rw(bool, prefix + "ProfileAbort")
+        self.profile_cs_name = epics_signal_rw(str, prefix + "ProfileCsName")
+        self.calculate_velocities = epics_signal_rw(bool, prefix + "ProfileCalcVel")
 
         super().__init__(name=name)
 
 
-class PmacAxisIO(Device):
+class PmacAxisAssignmentIO(Device):
     """A Device that (direct) moves a PMAC Coordinate System Motor.
 
     Note that this does not go through a motor record.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.cs_axis_letter = epics_signal_r(str, f"{prefix}:CsAxis_RBV")
-        self.cs_port = epics_signal_r(str, f"{prefix}:CsPort_RBV")
+        self.cs_axis_letter = epics_signal_r(str, f"{prefix}CsAxis_RBV")
+        self.cs_port = epics_signal_r(str, f"{prefix}CsPort_RBV")
+        self.cs_number = epics_signal_r(int, f"{prefix}CsRaw_RBV")
         super().__init__(name=name)
 
 
@@ -66,12 +68,11 @@ class PmacCoordIO(Device):
     """A Device that represents a Pmac Coordinate System."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.defer_moves = epics_signal_r(bool, f"{prefix}:DeferMoves")
+        self.defer_moves = epics_signal_rw(bool, f"{prefix}DeferMoves")
+        self.cs_port = epics_signal_r(str, f"{prefix}Port")
         self.cs_axis_setpoint = DeviceVector(
             {
-                i + 1: epics_signal_rw(
-                    Array1D[np.float64], f"{prefix}:M{i + 1}:DirectDemand"
-                )
+                i + 1: epics_signal_rw(np.float64, f"{prefix}M{i + 1}:DirectDemand")
                 for i in range(len(CS_LETTERS))
             }
         )
@@ -84,15 +85,25 @@ class PmacIO(Device):
     def __init__(
         self,
         prefix: str,
-        axis_nums: Sequence[int],
+        raw_motors: Sequence[motor.Motor],
         coord_nums: Sequence[int],
         name: str = "",
     ) -> None:
-        self.axis = DeviceVector(
-            {axis: PmacAxisIO(f"{prefix}:M{axis}") for axis in axis_nums}
+        motor_prefixes = [motor.motor_egu.source.split(".")[0] for motor in raw_motors]
+
+        self.assignment = DeviceVector(
+            {
+                i: PmacAxisAssignmentIO(motor_prefix)
+                for i, motor_prefix in enumerate(motor_prefixes)
+            }
         )
+
+        # Public Look up for motor to axis assignment DeviceVector index
+
+        self.motor_assignment_index = {motor: i for i, motor in enumerate(raw_motors)}
+
         self.coord = DeviceVector(
-            {coord: PmacCoordIO(f"{prefix}:CS{coord}") for coord in coord_nums}
+            {coord: PmacCoordIO(prefix=f"{prefix}CS{coord}:") for coord in coord_nums}
         )
         # Trajectory PVs have the same prefix as the pmac device
         self.trajectory = PmacTrajectoryIO(prefix)

ophyd_async/epics/pmac/_utils.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+from scanspec.core import Slice
+
+from ophyd_async.core import error_if_none, gather_dict
+from ophyd_async.epics.motor import Motor
+
+from ._pmac_io import CS_LETTERS, PmacIO
+
+# PMAC durations are in milliseconds
+# We must convert from scanspec durations (seconds) to milliseconds
+# PMAC motion program multiples durations by 0.001
+# (see https://github.com/DiamondLightSource/pmac/blob/afe81f8bb9179c3a20eff351f30bc6cfd1539ad9/pmacApp/pmc/trajectory_scan_code_ppmac.pmc#L241)
+# Therefore, we must divide scanspec durations by 10e-6
+TICK_S = 0.000001
+
+
+@dataclass
+class _Trajectory:
+    positions: dict[Motor, np.ndarray]
+    velocities: dict[Motor, np.ndarray]
+    user_programs: npt.NDArray[np.int32]
+    durations: npt.NDArray[np.float64]
+
+    @classmethod
+    def from_slice(cls, slice: Slice[Motor], ramp_up_time: float) -> _Trajectory:
+        """Parse a trajectory with no gaps from a slice.
+
+        :param slice: Information about a series of scan frames along a number of axes
+        :param ramp_up_duration: Time required to ramp up to speed
+        :param ramp_down: Booleon representing if we ramp down or not
+        :returns Trajectory: Data class representing our parsed trajectory
+        :raises RuntimeError: Slice must have no gaps and a duration array
+        """
+        slice_duration = error_if_none(slice.duration, "Slice must have a duration")
+
+        # Check if any gaps other than initial gap.
+        if any(slice.gap[1:]):
+            raise RuntimeError(
+                f"Cannot parse trajectory with gaps. Slice has gaps: {slice.gap}"
+            )
+
+        scan_size = len(slice)
+        motors = slice.axes()
+
+        positions: dict[Motor, npt.NDArray[np.float64]] = {}
+        velocities: dict[Motor, npt.NDArray[np.float64]] = {}
+
+        # Initialise arrays
+        positions = {motor: np.empty(2 * scan_size + 1, float) for motor in motors}
+        velocities = {motor: np.empty(2 * scan_size + 1, float) for motor in motors}
+        durations: npt.NDArray[np.float64] = np.empty(2 * scan_size + 1, float)
+        user_programs: npt.NDArray[np.int32] = np.ones(2 * scan_size + 1, float)
+        user_programs[-1] = 8
+
+        # Ramp up time for start of collection window
+        durations[0] = int(ramp_up_time / TICK_S)
+        # Half the time per point
+        durations[1:] = np.repeat(slice_duration / (2 * TICK_S), 2)
+
+        # Fill profile assuming no gaps
+        # Excluding starting points, we begin at our next frame
+        half_durations = slice_duration / 2
+        for motor in motors:
+            # Set the first position to be lower bound, then
+            # alternate mid and upper as the upper and lower
+            # bounds of neighbouring points are the same as gap is false
+            positions[motor][0] = slice.lower[motor][0]
+            positions[motor][1::2] = slice.midpoints[motor]
+            positions[motor][2::2] = slice.upper[motor]
+            # For velocities we will need the relative distances
+            mid_to_upper_velocities = (
+                slice.upper[motor] - slice.midpoints[motor]
+            ) / half_durations
+            lower_to_mid_velocities = (
+                slice.midpoints[motor] - slice.lower[motor]
+            ) / half_durations
+            # First velocity is the lower -> mid of first point
+            velocities[motor][0] = lower_to_mid_velocities[0]
+            # For the midpoints, we take the average of the
+            # lower -> mid and mid-> upper velocities of the same point
+            velocities[motor][1::2] = (
+                lower_to_mid_velocities + mid_to_upper_velocities
+            ) / 2
+            # For the upper points, we need to take the average of the
+            # mid -> upper velocity of the previous point and
+            # lower -> mid velocity of the current point
+            velocities[motor][2:-1:2] = (
+                mid_to_upper_velocities[:-1] + lower_to_mid_velocities[1:]
+            ) / 2
+            # For the last velocity take the mid to upper velocity
+            velocities[motor][-1] = mid_to_upper_velocities[-1]
+
+        return cls(
+            positions=positions,
+            velocities=velocities,
+            user_programs=user_programs,
+            durations=durations,
+        )
+
+
+@dataclass
+class _PmacMotorInfo:
+    cs_port: str
+    cs_number: int
+    motor_cs_index: dict[Motor, int]
+    motor_acceleration_rate: dict[Motor, float]
+
+    @classmethod
+    async def from_motors(cls, pmac: PmacIO, motors: Sequence[Motor]) -> _PmacMotorInfo:
+        """Creates a _PmacMotorInfo instance based on a  controller and list of motors.
+
+        :param pmac: The PMAC device
+        :param motors: Sequence of motors involved in trajectory
+        :raises RuntimeError:
+            if motors do not share common CS port or CS number, or if
+            motors do not have unique CS index assignments
+        :returns:
+            _PmacMotorInfo instance with motor's common CS port and CS number, and
+            dictionaries of motor's to their unique CS index and accelerate rate
+
+        """
+        assignments = {
+            motor: pmac.assignment[pmac.motor_assignment_index[motor]]
+            for motor in motors
+        }
+
+        cs_ports, cs_numbers, cs_axes, velocities, accls = await asyncio.gather(
+            gather_dict(
+                {motor: assignments[motor].cs_port.get_value() for motor in motors}
+            ),
+            gather_dict(
+                {motor: assignments[motor].cs_number.get_value() for motor in motors}
+            ),
+            gather_dict(
+                {
+                    motor: assignments[motor].cs_axis_letter.get_value()
+                    for motor in motors
+                }
+            ),
+            gather_dict({motor: motor.max_velocity.get_value() for motor in motors}),
+            gather_dict(
+                {motor: motor.acceleration_time.get_value() for motor in motors}
+            ),
+        )
+
+        # check if the values in cs_port and cs_number are the same
+        cs_ports = set(cs_ports.values())
+
+        if len(cs_ports) != 1:
+            raise RuntimeError(
+                "Failed to fetch common CS port."
+                "Motors passed are assigned to multiple CS ports:"
+                f"{list(cs_ports)}"
+            )
+
+        cs_port = cs_ports.pop()
+
+        cs_numbers = set(cs_numbers.values())
+        if len(cs_numbers) != 1:
+            raise RuntimeError(
+                "Failed to fetch common CS number."
+                "Motors passed are assigned to multiple CS numbers:"
+                f"{list(cs_numbers)}"
+            )
+
+        cs_number = cs_numbers.pop()
+
+        motor_cs_index = {}
+        for motor in cs_axes:
+            try:
+                if not cs_axes[motor]:
+                    raise ValueError
+                motor_cs_index[motor] = CS_LETTERS.index(cs_axes[motor])
+            except ValueError as err:
+                raise ValueError(
+                    "Failed to get motor CS index. "
+                    f"Motor {motor.name} assigned to '{cs_axes[motor]}' "
+                    f"but must be assignmed to '{CS_LETTERS}"
+                ) from err
+            if len(set(motor_cs_index.values())) != len(motor_cs_index.items()):
+                raise RuntimeError(
+                    "Failed to fetch distinct CS Axes."
+                    "Motors passed are assigned to the same CS Axis"
+                    f"{list(motor_cs_index)}"
+                )
+
+        motor_acceleration_rate = {
+            motor: float(velocities[motor]) / float(accls[motor])
+            for motor in velocities
+        }
+
+        return _PmacMotorInfo(
+            cs_port, cs_number, motor_cs_index, motor_acceleration_rate
+        )
+
+
+def calculate_ramp_position_and_duration(
+    slice: Slice[Motor], motor_info: _PmacMotorInfo, is_up: bool
+) -> tuple[dict[Motor, float], float]:
+    if slice.duration is None:
+        raise ValueError("Slice must have a duration")
+
+    scan_axes = slice.axes()
+    idx = 0 if is_up else -1
+
+    velocities: dict[Motor, float] = {}
+    ramp_times: list[float] = []
+    for axis in scan_axes:
+        velocity = (slice.upper[axis][idx] - slice.lower[axis][idx]) / slice.duration[
+            idx
+        ]
+        velocities[axis] = velocity
+        ramp_times.append(abs(velocity) / motor_info.motor_acceleration_rate[axis])
+
+    max_ramp_time = max(ramp_times)
+
+    motor_to_ramp_position = {}
+    sign = -1 if is_up else 1
+    for axis, v in velocities.items():
+        ref_pos = slice.lower[axis][0] if is_up else slice.upper[axis][-1]
+        displacement = 0.5 * v * max_ramp_time
+        motor_to_ramp_position[axis] = ref_pos + sign * displacement
+
+    return (motor_to_ramp_position, max_ramp_time)

ophyd_async/fastcs/eiger/_eiger.py

@@ -33,7 +33,7 @@ class EigerDetector(StandardDetector):
             OdinWriter(
                 path_provider,
                 self.odin,
-                self.drv.detector.bit_depth_readout,
+                self.drv.detector.bit_depth_image,
             ),
             name=name,
         )

ophyd_async/fastcs/eiger/_eiger_io.py

@@ -23,11 +23,12 @@ class EigerStreamIO(Device):
 
 
 class EigerDetectorIO(Device):
-    bit_depth_readout: SignalR[int]
+    bit_depth_image: SignalR[int]
     state: SignalR[str]
     count_time: SignalRW[float]
     frame_time: SignalRW[float]
     nimages: SignalRW[int]
+    ntrigger: SignalRW[int]
     nexpi: SignalRW[int]
     trigger_mode: SignalRW[str]
     roi_mode: SignalRW[str]

ophyd_async/plan_stubs/_nd_attributes.py

@@ -1,57 +1,31 @@
 from collections.abc import Sequence
-from xml.etree import ElementTree as ET
 
 import bluesky.plan_stubs as bps
 
-from ophyd_async.core import Device
 from ophyd_async.epics.adcore import (
+    AreaDetector,
     NDArrayBaseIO,
     NDAttributeDataType,
     NDAttributeParam,
     NDAttributePv,
     NDFileHDFIO,
+    ndattributes_to_xml,
 )
 
 
 def setup_ndattributes(
-    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributePv | NDAttributeParam]
+    device: NDArrayBaseIO, ndattributes: Sequence[NDAttributeParam | NDAttributePv]
 ):
-    """Set up attributes on NdArray devices."""
-    root = ET.Element("Attributes")
-
-    for ndattribute in ndattributes:
-        if isinstance(ndattribute, NDAttributeParam):
-            ET.SubElement(
-                root,
-                "Attribute",
-                name=ndattribute.name,
-                type="PARAM",
-                source=ndattribute.param,
-                addr=str(ndattribute.addr),
-                datatype=ndattribute.datatype.value,
-                description=ndattribute.description,
-            )
-        elif isinstance(ndattribute, NDAttributePv):
-            ET.SubElement(
-                root,
-                "Attribute",
-                name=ndattribute.name,
-                type="EPICS_PV",
-                source=ndattribute.signal.source.split("ca://")[-1],
-                dbrtype=ndattribute.dbrtype.value,
-                description=ndattribute.description,
-            )
-        else:
-            raise ValueError(
-                f"Invalid type for ndattributes: {type(ndattribute)}. "
-                "Expected NDAttributePv or NDAttributeParam."
-            )
-    xml_text = ET.tostring(root, encoding="unicode")
-    yield from bps.abs_set(device.nd_attributes_file, xml_text, wait=True)
+    xml = ndattributes_to_xml(ndattributes)
+    yield from bps.abs_set(
+        device.nd_attributes_file,
+        xml,
+        wait=True,
+    )
 
 
-def setup_ndstats_sum(detector: Device):
-    """Set up nd stats for a detector."""
+def setup_ndstats_sum(detector: AreaDetector):
+    """Set up nd stats sum nd attribute for a detector."""
     hdf = getattr(detector, "fileio", None)
     if not isinstance(hdf, NDFileHDFIO):
         msg = (

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ophyd-async
-Version: 0.12.2
+Version: 0.13.0
 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
@@ -49,10 +49,11 @@ Requires-Dist: colorlog
 Requires-Dist: pydantic>=2.0
 Requires-Dist: pydantic-numpy
 Requires-Dist: stamina>=23.1.0
+Requires-Dist: scanspec>=1.0a1
 Provides-Extra: sim
 Requires-Dist: h5py; extra == "sim"
 Provides-Extra: ca
-Requires-Dist: aioca>=1.6; extra == "ca"
+Requires-Dist: aioca>=2.0a4; extra == "ca"
 Provides-Extra: pva
 Requires-Dist: p4p>=4.2.0; extra == "pva"
 Provides-Extra: tango