ophyd-async 0.13.2__py3-none-any.whl → 0.13.4__py3-none-any.whl

ophyd_async/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.13.2'
-__version_tuple__ = version_tuple = (0, 13, 2)
+__version__ = version = '0.13.4'
+__version_tuple__ = version_tuple = (0, 13, 4)
 
 __commit_id__ = commit_id = None

ophyd_async/core/__init__.py

@@ -78,7 +78,7 @@ from ._signal_backend import (
 )
 from ._soft_signal_backend import SoftSignalBackend
 from ._status import AsyncStatus, WatchableAsyncStatus, completed_status
-from ._table import Table
+from ._table import Table, TableSubclass
 from ._utils import (
     CALCULATE_TIMEOUT,
     DEFAULT_TIMEOUT,
@@ -221,4 +221,5 @@ __all__ = [
     "EnableDisable",
     "InOut",
     "OnOff",
+    "TableSubclass",
 ]

ophyd_async/core/_table.py

@@ -13,6 +13,7 @@ TableSubclass = TypeVar("TableSubclass", bound="Table")
 
 
 def _concat(value1, value2):
+    """Concatenate two values, supports both NumPy arrays and generic types."""
     if isinstance(value1, np.ndarray):
         return np.concatenate((value1, value2))
     else:
@@ -20,6 +21,8 @@ def _concat(value1, value2):
 
 
 def _make_default_factory(dtype: np.dtype) -> Callable[[], np.ndarray]:
+    """Creates a default factory, returns an empty Numpy array of a specified dtype."""
+
     def numpy_array_default_factory() -> np.ndarray:
         return np.array([], dtype)
 
@@ -91,6 +94,11 @@ class Table(ConfinedModel):
                 raise TypeError(f"Cannot use annotation {anno} in a Table")
             cls.__annotations__[k] = new_anno
 
+    @classmethod
+    def empty(cls: type[TableSubclass]) -> TableSubclass:
+        """Makes an empty table with zero length columns."""
+        return cls()  # type: ignore
+
     def __add__(self, right: TableSubclass) -> TableSubclass:
         """Concatenate the arrays in field values."""
         cls = type(right)

ophyd_async/epics/adcore/_core_logic.py

@@ -34,9 +34,11 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         self,
         driver: ADBaseIOT,
         good_states: frozenset[ADState] = DEFAULT_GOOD_STATES,
+        image_mode: ADImageMode = ADImageMode.MULTIPLE,
     ) -> None:
         self.driver: ADBaseIOT = driver
         self.good_states = good_states
+        self.image_mode = image_mode
         self.frame_timeout = DEFAULT_TIMEOUT
         self._arm_status: AsyncStatus | None = None
 
@@ -52,7 +54,7 @@ class ADBaseController(DetectorController, Generic[ADBaseIOT]):
         )
         await asyncio.gather(
             self.driver.num_images.set(trigger_info.total_number_of_exposures),
-            self.driver.image_mode.set(ADImageMode.MULTIPLE),
+            self.driver.image_mode.set(self.image_mode),
         )
 
     async def arm(self):

ophyd_async/epics/motor.py

@@ -107,18 +107,27 @@ class Motor(
         self.user_readback.set_name(name)
 
     async def check_motor_limit(self, abs_start_pos: float, abs_end_pos: float):
-        """Check the motor limit with the absolute positions."""
+        """Check the positions are within limits.
+
+        Will raise a MotorLimitsException if the given absolute positions will be
+        outside the motor soft limits.
+        """
         motor_lower_limit, motor_upper_limit, egu = await asyncio.gather(
             self.low_limit_travel.get_value(),
             self.high_limit_travel.get_value(),
             self.motor_egu.get_value(),
         )
+
+        # EPICS motor record treats limits of 0, 0 as no limit
+        if motor_lower_limit == 0 and motor_upper_limit == 0:
+            return
+
         if (
             not motor_upper_limit >= abs_start_pos >= motor_lower_limit
             or not motor_upper_limit >= abs_end_pos >= motor_lower_limit
         ):
             raise MotorLimitsException(
-                f"Motor trajectory for requested fly/move is from "
+                f"{self.name} motor trajectory for requested fly/move is from "
                 f"{abs_start_pos}{egu} to "
                 f"{abs_end_pos}{egu} but motor limits are "
                 f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "

ophyd_async/epics/pmac/_pmac_io.py

@@ -4,7 +4,7 @@ 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
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
 CS_LETTERS = "ABCUVWXYZ"
 
@@ -40,11 +40,15 @@ class PmacTrajectoryIO(StandardReadable):
                 for i, letter in enumerate(CS_LETTERS)
             }
         )
+        self.total_points = epics_signal_r(int, f"{prefix}TotalPoints_RBV")
         self.points_to_build = epics_signal_rw(int, prefix + "ProfilePointsToBuild")
-        self.build_profile = epics_signal_rw(bool, prefix + "ProfileBuild")
+        self.build_profile = epics_signal_x(prefix + "ProfileBuild")
+        self.append_profile = epics_signal_x(prefix + "ProfileAppend")
+        # This should be a SignalX, but because it is a Busy record, must
+        # be a SignalRW to be waited on in PmacTrajectoryTriggerLogic.
+        # TODO: Change record type to bo from busy (https://github.com/DiamondLightSource/pmac/issues/154)
         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.abort_profile = epics_signal_x(prefix + "ProfileAbort")
         self.profile_cs_name = epics_signal_rw(str, prefix + "ProfileCsName")
         self.calculate_velocities = epics_signal_rw(bool, prefix + "ProfileCalcVel")
 

ophyd_async/epics/pmac/_pmac_trajectory.py

@@ -1,100 +1,201 @@
 import asyncio
+from dataclasses import dataclass
 
 import numpy as np
-from scanspec.core import Path
+from scanspec.core import Path, Slice
 from scanspec.specs import Spec
 
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
+    AsyncStatus,
     FlyerController,
+    error_if_none,
+    observe_value,
     set_and_wait_for_value,
     wait_for_value,
 )
 from ophyd_async.epics.motor import Motor
 from ophyd_async.epics.pmac import PmacIO
 from ophyd_async.epics.pmac._pmac_io import CS_LETTERS
+from ophyd_async.epics.pmac._pmac_trajectory_generation import PVT, Trajectory
 from ophyd_async.epics.pmac._utils import (
     _PmacMotorInfo,
-    _Trajectory,
     calculate_ramp_position_and_duration,
 )
 
+# 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
+SLICE_SIZE = 4000
+
+
+@dataclass
+class PmacPrepareContext:
+    path: Path
+    motor_info: _PmacMotorInfo
+    ramp_up_time: float
+
 
 class PmacTrajectoryTriggerLogic(FlyerController):
     def __init__(self, pmac: PmacIO) -> None:
         self.pmac = pmac
-        self.scantime: float | None = None
+        self._next_pvt: PVT | None
+        self._loaded: int = 0
+        self._trajectory_status: AsyncStatus | None = None
+        self._prepare_context: PmacPrepareContext | None = None
 
     async def prepare(self, value: Spec[Motor]):
-        slice = Path(value.calculate()).consume()
-        motor_info = await _PmacMotorInfo.from_motors(self.pmac, slice.axes())
+        path = Path(value.calculate())
+        slice = path.consume(SLICE_SIZE)
+        path_length = len(path)
+        motors = slice.axes()
+        motor_info = await _PmacMotorInfo.from_motors(self.pmac, motors)
         ramp_up_pos, ramp_up_time = calculate_ramp_position_and_duration(
             slice, motor_info, True
         )
-        ramp_down_pos, ramp_down_time = calculate_ramp_position_and_duration(
-            slice, motor_info, False
+        self._prepare_context = PmacPrepareContext(
+            path=path, motor_info=motor_info, ramp_up_time=ramp_up_time
         )
-        trajectory = _Trajectory.from_slice(slice, ramp_up_time, motor_info)
         await asyncio.gather(
-            self._build_trajectory(
-                trajectory, motor_info, ramp_down_pos, ramp_down_time
-            ),
+            self._build_trajectory(motor_info, slice, path_length, ramp_up_time),
             self._move_to_start(motor_info, ramp_up_pos),
         )
 
     async def kickoff(self):
-        if not self.scantime:
-            raise RuntimeError("Cannot kickoff. Must call prepare first.")
-        self.status = await self.pmac.trajectory.execute_profile.set(
-            True, timeout=self.scantime + 1
+        prepare_context = error_if_none(
+            self._prepare_context, "Cannot kickoff. Must call prepare first."
+        )
+        self._prepare_context = None
+        self._trajectory_status = self._execute_trajectory(
+            prepare_context.path, prepare_context.motor_info
+        )
+        # Wait for the ramp up to happen
+        await wait_for_value(
+            self.pmac.trajectory.total_points,
+            lambda v: v >= 1,
+            prepare_context.ramp_up_time + DEFAULT_TIMEOUT,
         )
 
     async def complete(self):
-        if not self.scantime:
-            raise RuntimeError("Cannot complete. Must call prepare first.")
-        await wait_for_value(
-            self.pmac.trajectory.execute_profile,
-            False,
-            timeout=self.scantime + DEFAULT_TIMEOUT,
+        trajectory_status = error_if_none(
+            self._trajectory_status, "Cannot complete. Must call kickoff first."
         )
+        await trajectory_status
+        # Reset trajectory status and number of loaded points
+        self._trajectory_status = None
+        self._loaded = 0
 
     async def stop(self):
-        await self.pmac.trajectory.abort_profile.set(True)
+        await self.pmac.trajectory.abort_profile.trigger()
+
+    @AsyncStatus.wrap
+    async def _execute_trajectory(self, path: Path, motor_info: _PmacMotorInfo):
+        execute_status = self.pmac.trajectory.execute_profile.set(
+            True, wait=True, timeout=None
+        )
+        # We consume SLICE_SIZE from self.path and parse a trajectory
+        # containing at least 2 * SLICE_SIZE, as a gapless trajectory
+        # will contain 2 points per slice frame. If gaps are present,
+        # additional points are inserted, overfilling the buffer.
+        min_buffer_size = SLICE_SIZE * 2
+        async for current_point in observe_value(
+            self.pmac.trajectory.total_points,
+            done_status=execute_status,
+            timeout=DEFAULT_TIMEOUT,
+        ):
+            # Ensure we maintain a minimum buffer size, if we have more points to append
+            if len(path) != 0 and self._loaded - current_point < min_buffer_size:
+                # We have less than SLICE_SIZE * 2 points in the buffer, so refill
+                next_slice = path.consume(SLICE_SIZE)
+                path_length = len(path)
+                await self._append_trajectory(next_slice, path_length, motor_info)
+
+    async def _append_trajectory(
+        self, slice: Slice, path_length: int, motor_info: _PmacMotorInfo
+    ):
+        trajectory = await self._parse_trajectory(slice, path_length, motor_info)
+        await self._set_trajectory_arrays(trajectory, motor_info)
+        await self.pmac.trajectory.append_profile.trigger()
 
     async def _build_trajectory(
         self,
-        trajectory: _Trajectory,
         motor_info: _PmacMotorInfo,
-        ramp_down_pos: dict[Motor, np.float64],
-        ramp_down_time: float,
+        slice: Slice,
+        path_length: int,
+        ramp_up_time: float,
     ):
-        trajectory = trajectory.append_ramp_down(ramp_down_pos, ramp_down_time, 0)
-        self.scantime = np.sum(trajectory.durations)
-        use_axis = {axis + 1: False for axis in range(len(CS_LETTERS))}
-
-        size = 0
-        for motor, number in motor_info.motor_cs_index.items():
-            use_axis[number + 1] = True
-            await self.pmac.trajectory.positions[number + 1].set(
-                trajectory.positions[motor]
-            )
-            await self.pmac.trajectory.velocities[number + 1].set(
-                trajectory.velocities[motor]
-            )
-            size += len(trajectory.positions[motor])
+        trajectory = await self._parse_trajectory(
+            slice, path_length, motor_info, ramp_up_time
+        )
+        use_axis = {
+            axis + 1: (axis in motor_info.motor_cs_index.values())
+            for axis in range(len(CS_LETTERS))
+        }
 
         coros = [
             self.pmac.trajectory.profile_cs_name.set(motor_info.cs_port),
-            self.pmac.trajectory.time_array.set(trajectory.durations),
-            self.pmac.trajectory.user_array.set(trajectory.user_programs),
-            self.pmac.trajectory.points_to_build.set(size),
             self.pmac.trajectory.calculate_velocities.set(False),
+            self._set_trajectory_arrays(trajectory, motor_info),
         ] + [
             self.pmac.trajectory.use_axis[number].set(use)
             for number, use in use_axis.items()
         ]
+
+        await asyncio.gather(*coros)
+        await self.pmac.trajectory.build_profile.trigger()
+
+    async def _parse_trajectory(
+        self,
+        slice: Slice,
+        path_length: int,
+        motor_info: _PmacMotorInfo,
+        ramp_up_time: float | None = None,
+    ) -> Trajectory:
+        trajectory, exit_pvt = Trajectory.from_slice(
+            slice,
+            motor_info,
+            None if ramp_up_time else self._next_pvt,
+            ramp_up_time=ramp_up_time,
+        )
+
+        if path_length == 0:
+            ramp_down_pos, ramp_down_time = calculate_ramp_position_and_duration(
+                slice, motor_info, False
+            )
+            trajectory = trajectory.with_ramp_down(
+                exit_pvt, ramp_down_pos, ramp_down_time, 0
+            )
+        self._next_pvt = exit_pvt
+        self._loaded += len(trajectory)
+
+        return trajectory
+
+    async def _set_trajectory_arrays(
+        self, trajectory: Trajectory, motor_info: _PmacMotorInfo
+    ):
+        coros = []
+        for motor, number in motor_info.motor_cs_index.items():
+            coros.append(
+                self.pmac.trajectory.positions[number + 1].set(
+                    trajectory.positions[motor]
+                )
+            )
+            coros.append(
+                self.pmac.trajectory.velocities[number + 1].set(
+                    trajectory.velocities[motor]
+                )
+            )
+        coros.extend(
+            [
+                self.pmac.trajectory.time_array.set(trajectory.durations / TICK_S),
+                self.pmac.trajectory.user_array.set(trajectory.user_programs),
+                self.pmac.trajectory.points_to_build.set(len(trajectory.durations)),
+            ]
+        )
         await asyncio.gather(*coros)
-        await self.pmac.trajectory.build_profile.set(True)
 
     async def _move_to_start(
         self, motor_info: _PmacMotorInfo, ramp_up_position: dict[Motor, np.float64]