ophyd-async 0.10.1__py3-none-any.whl → 0.12__py3-none-any.whl

ophyd_async/epics/motor.py

@@ -14,7 +14,6 @@ from bluesky.protocols import (
     Stoppable,
     Subscribable,
 )
-from pydantic import BaseModel, Field
 
 from ophyd_async.core import (
     CALCULATE_TIMEOUT,
@@ -22,16 +21,18 @@ from ophyd_async.core import (
     AsyncStatus,
     CalculatableTimeout,
     Callback,
+    FlyMotorInfo,
     StandardReadable,
     StrictEnum,
     WatchableAsyncStatus,
     WatcherUpdate,
+    error_if_none,
     observe_value,
 )
 from ophyd_async.core import StandardReadableFormat as Format
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
-__all__ = ["MotorLimitsException", "FlyMotorInfo", "Motor"]
+__all__ = ["MotorLimitsException", "Motor"]
 
 
 class MotorLimitsException(Exception):
@@ -40,26 +41,6 @@ class MotorLimitsException(Exception):
     pass
 
 
-class FlyMotorInfo(BaseModel):
-    """Minimal set of information required to fly a motor."""
-
-    start_position: float = Field(frozen=True)
-    """Absolute position of the motor once it finishes accelerating to desired
-    velocity, in motor EGUs"""
-
-    end_position: float = Field(frozen=True)
-    """Absolute position of the motor once it begins decelerating from desired
-    velocity, in EGUs"""
-
-    time_for_move: float = Field(frozen=True, gt=0)
-    """Time taken for the motor to get from start_position to end_position, excluding
-    run-up and run-down, in seconds."""
-
-    timeout: CalculatableTimeout = Field(frozen=True, default=CALCULATE_TIMEOUT)
-    """Maximum time for the complete motor move, including run up and run down.
-    Defaults to `time_for_move` + run up and run down times + 10s."""
-
-
 class OffsetMode(StrictEnum):
     VARIABLE = "Variable"
     FROZEN = "Frozen"
@@ -111,15 +92,12 @@ class Motor(
         # Whether set() should complete successfully or not
         self._set_success = True
 
-        # end_position of a fly move, with run_up_distance added on.
-        self._fly_completed_position: float | None = None
+        # Currently requested fly info, stored in prepare
+        self._fly_info: FlyMotorInfo | None = None
 
         # Set on kickoff(), complete when motor reaches self._fly_completed_position
         self._fly_status: WatchableAsyncStatus | None = None
 
-        # Set during prepare
-        self._fly_timeout: CalculatableTimeout | None = CALCULATE_TIMEOUT
-
         super().__init__(name=name)
 
     def set_name(self, name: str, *, child_name_separator: str | None = None) -> None:
@@ -130,42 +108,65 @@ class Motor(
 
     @AsyncStatus.wrap
     async def prepare(self, value: FlyMotorInfo):
-        """Move to the beginning of a suitable run-up distance ready for a flyscan."""
-        self._fly_timeout = value.timeout
+        """Move to the beginning of a suitable run-up distance ready for a fly scan."""
+        self._fly_info = value
 
         # Velocity, at which motor travels from start_position to end_position, in motor
         # egu/s.
-        fly_velocity = await self._prepare_velocity(
-            value.start_position,
-            value.end_position,
-            value.time_for_move,
+        max_speed, egu = await asyncio.gather(
+            self.max_velocity.get_value(), self.motor_egu.get_value()
         )
+        if abs(value.velocity) > max_speed:
+            raise MotorLimitsException(
+                f"Velocity {abs(value.velocity)} {egu}/s was requested for a motor "
+                f" with max speed of {max_speed} {egu}/s"
+            )
+
+        acceleration_time = await self.acceleration_time.get_value()
+        ramp_up_start_pos = value.ramp_up_start_pos(acceleration_time)
+        ramp_down_end_pos = value.ramp_down_end_pos(acceleration_time)
 
-        # start_position with run_up_distance added on.
-        fly_prepared_position = await self._prepare_motor_path(
-            abs(fly_velocity), value.start_position, value.end_position
+        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(),
         )
 
-        await self.set(fly_prepared_position)
-        await self.velocity.set(abs(fly_velocity))
+        if (
+            not motor_upper_limit >= ramp_up_start_pos >= motor_lower_limit
+            or not motor_upper_limit >= ramp_down_end_pos >= motor_lower_limit
+        ):
+            raise MotorLimitsException(
+                f"Motor trajectory for requested fly is from "
+                f"{ramp_up_start_pos}{egu} to "
+                f"{ramp_down_end_pos}{egu} but motor limits are "
+                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
+            )
+
+        # move to prepare position at maximum velocity
+        await self.velocity.set(abs(max_speed))
+        await self.set(ramp_up_start_pos)
+
+        # Set velocity we will be using for the fly scan
+        await self.velocity.set(abs(value.velocity))
 
     @AsyncStatus.wrap
     async def kickoff(self):
         """Begin moving motor from prepared position to final position."""
-        if not self._fly_completed_position:
-            msg = "Motor must be prepared before attempting to kickoff"
-            raise RuntimeError(msg)
+        fly_info = error_if_none(
+            self._fly_info, "Motor must be prepared before attempting to kickoff"
+        )
 
+        acceleration_time = await self.acceleration_time.get_value()
         self._fly_status = self.set(
-            self._fly_completed_position, timeout=self._fly_timeout
+            fly_info.ramp_down_end_pos(acceleration_time),
+            timeout=fly_info.timeout,
         )
 
     def complete(self) -> WatchableAsyncStatus:
         """Mark as complete once motor reaches completed position."""
-        if not self._fly_status:
-            msg = "kickoff not called"
-            raise RuntimeError(msg)
-        return self._fly_status
+        fly_status = error_if_none(self._fly_status, "kickoff not called")
+        return fly_status
 
     @WatchableAsyncStatus.wrap
     async def set(  # type: ignore
@@ -220,22 +221,6 @@ class Motor(
         # the move above, so need to pass wait=False
         await self.motor_stop.set(1, wait=False)
 
-    async def _prepare_velocity(
-        self, start_position: float, end_position: float, time_for_move: float
-    ) -> float:
-        fly_velocity = (end_position - start_position) / time_for_move
-        max_speed, egu = await asyncio.gather(
-            self.max_velocity.get_value(), self.motor_egu.get_value()
-        )
-        if abs(fly_velocity) > max_speed:
-            raise MotorLimitsException(
-                f"Motor speed of {abs(fly_velocity)} {egu}/s was requested for a motor "
-                f" with max speed of {max_speed} {egu}/s"
-            )
-        # move to prepare position at maximum velocity
-        await self.velocity.set(abs(max_speed))
-        return fly_velocity
-
     async def locate(self) -> Location[float]:
         """Return the current setpoint and readback of the motor."""
         setpoint, readback = await asyncio.gather(
@@ -250,38 +235,3 @@ class Motor(
     def clear_sub(self, function: Callback[dict[str, Reading[float]]]) -> None:
         """Unsubscribe."""
         self.user_readback.clear_sub(function)
-
-    async def _prepare_motor_path(
-        self, fly_velocity: float, start_position: float, end_position: float
-    ) -> float:
-        # Distance required for motor to accelerate from stationary to fly_velocity, and
-        # distance required for motor to decelerate from fly_velocity to stationary
-        run_up_distance = (
-            (await self.acceleration_time.get_value()) * fly_velocity * 0.5
-        )
-
-        direction = 1 if end_position > start_position else -1
-        self._fly_completed_position = end_position + (run_up_distance * direction)
-
-        # Prepared position not used after prepare, so no need to store in self
-        fly_prepared_position = start_position - (run_up_distance * direction)
-
-        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(),
-        )
-
-        if (
-            not motor_upper_limit >= fly_prepared_position >= motor_lower_limit
-            or not motor_upper_limit
-            >= self._fly_completed_position
-            >= motor_lower_limit
-        ):
-            raise MotorLimitsException(
-                f"Motor trajectory for requested fly is from "
-                f"{fly_prepared_position}{egu} to "
-                f"{self._fly_completed_position}{egu} but motor limits are "
-                f"{motor_lower_limit}{egu} <= x <= {motor_upper_limit}{egu} "
-            )
-        return fly_prepared_position

ophyd_async/epics/pmac/__init__.py

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

ophyd_async/epics/pmac/_pmac_io.py

@@ -0,0 +1,100 @@
+from collections.abc import Sequence
+
+import numpy as np
+
+from ophyd_async.core import Array1D, Device, DeviceVector, StandardReadable
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+CS_LETTERS = "ABCUVWXYZ"
+
+
+class PmacTrajectoryIO(StandardReadable):
+    """Device that moves a PMAC Motor record."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.time_array = epics_signal_rw(
+            Array1D[np.float64], prefix + ":ProfileTimeArray"
+        )
+        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"
+                )
+                for i, letter in enumerate(CS_LETTERS)
+            }
+        )
+        self.use_axis = DeviceVector(
+            {
+                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"
+                )
+                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")
+
+        super().__init__(name=name)
+
+
+class PmacAxisIO(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")
+        super().__init__(name=name)
+
+
+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.cs_axis_setpoint = DeviceVector(
+            {
+                i + 1: epics_signal_rw(
+                    Array1D[np.float64], f"{prefix}:M{i + 1}:DirectDemand"
+                )
+                for i in range(len(CS_LETTERS))
+            }
+        )
+        super().__init__(name=name)
+
+
+class PmacIO(Device):
+    """Device that represents a pmac controller."""
+
+    def __init__(
+        self,
+        prefix: str,
+        axis_nums: Sequence[int],
+        coord_nums: Sequence[int],
+        name: str = "",
+    ) -> None:
+        self.axis = DeviceVector(
+            {axis: PmacAxisIO(f"{prefix}:M{axis}") for axis in axis_nums}
+        )
+        self.coord = DeviceVector(
+            {coord: PmacCoordIO(f"{prefix}:CS{coord}") for coord in coord_nums}
+        )
+        # Trajectory PVs have the same prefix as the pmac device
+        self.trajectory = PmacTrajectoryIO(prefix)
+
+        super().__init__(name=name)

ophyd_async/fastcs/eiger/__init__.py

@@ -1,4 +1,4 @@
-from ._eiger import EigerDetector, EigerTriggerInfo
+from ._eiger import EigerDetector
 from ._eiger_controller import EigerController
 from ._eiger_io import EigerDetectorIO, EigerDriverIO, EigerMonitorIO, EigerStreamIO
 
@@ -6,7 +6,6 @@ __all__ = [
     "EigerDetector",
     "EigerController",
     "EigerDriverIO",
-    "EigerTriggerInfo",
     "EigerDetectorIO",
     "EigerMonitorIO",
     "EigerStreamIO",

ophyd_async/fastcs/eiger/_eiger.py

@@ -1,5 +1,3 @@
-from pydantic import Field
-
 from ophyd_async.core import (
     AsyncStatus,
     PathProvider,
@@ -12,10 +10,6 @@ from ._eiger_controller import EigerController
 from ._eiger_io import EigerDriverIO
 
 
-class EigerTriggerInfo(TriggerInfo):
-    energy_ev: float = Field(gt=0)
-
-
 class EigerDetector(StandardDetector):
     """Ophyd-async implementation of an Eiger Detector."""
 
@@ -28,10 +22,11 @@ class EigerDetector(StandardDetector):
         path_provider: PathProvider,
         drv_suffix="-EA-EIGER-01:",
         hdf_suffix="-EA-EIGER-01:OD:",
+        odin_nodes: int = 4,
         name="",
     ):
         self.drv = EigerDriverIO(prefix + drv_suffix)
-        self.odin = Odin(prefix + hdf_suffix)
+        self.odin = Odin(prefix + hdf_suffix, nodes=odin_nodes)
 
         super().__init__(
             EigerController(self.drv),
@@ -44,6 +39,5 @@ class EigerDetector(StandardDetector):
         )
 
     @AsyncStatus.wrap
-    async def prepare(self, value: EigerTriggerInfo) -> None:  # type: ignore
-        await self._controller.set_energy(value.energy_ev)
+    async def prepare(self, value: TriggerInfo) -> None:
         await super().prepare(value)

ophyd_async/fastcs/panda/_trigger.py

@@ -1,8 +1,8 @@
 import asyncio
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 
-from ophyd_async.core import FlyerController, wait_for_value
+from ophyd_async.core import ConfinedModel, FlyerController, wait_for_value
 
 from ._block import (
     PandaBitMux,
@@ -14,8 +14,8 @@ from ._block import (
 from ._table import SeqTable
 
 
-class SeqTableInfo(BaseModel):
-    """Info for the PandA `SeqTable` for flyscanning."""
+class SeqTableInfo(ConfinedModel):
+    """Info for the PandA `SeqTable` for fly scanning."""
 
     sequence_table: SeqTable = Field(strict=True)
     repeats: int = Field(ge=0)
@@ -23,7 +23,7 @@ class SeqTableInfo(BaseModel):
 
 
 class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
-    """For controlling the PandA `SeqTable` when flyscanning."""
+    """For controlling the PandA `SeqTable` when fly scanning."""
 
     def __init__(self, seq: SeqBlock) -> None:
         self.seq = seq
@@ -51,8 +51,8 @@ class StaticSeqTableTriggerLogic(FlyerController[SeqTableInfo]):
         await wait_for_value(self.seq.active, False, timeout=1)
 
 
-class PcompInfo(BaseModel):
-    """Info for the PandA `PcompBlock` for flyscanning."""
+class PcompInfo(ConfinedModel):
+    """Info for the PandA `PcompBlock` for fly scanning."""
 
     start_postion: int = Field(description="start position in counts")
     pulse_width: int = Field(description="width of a single pulse in counts", gt=0)
@@ -76,7 +76,7 @@ class PcompInfo(BaseModel):
 
 
 class StaticPcompTriggerLogic(FlyerController[PcompInfo]):
-    """For controlling the PandA `PcompBlock` when flyscanning."""
+    """For controlling the PandA `PcompBlock` when fly scanning."""
 
     def __init__(self, pcomp: PcompBlock) -> None:
         self.pcomp = pcomp

ophyd_async/fastcs/panda/_writer.py

@@ -33,12 +33,12 @@ class PandaHDFWriter(DetectorWriter):
 
     # Triggered on PCAP arm
     async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
+        self._composer = None
         """Retrieve and get descriptor of all PandA signals marked for capture."""
         self._exposures_per_event = exposures_per_event
         # Ensure flushes are immediate
         await self.panda_data_block.flush_period.set(0)
 
-        self._composer = None
         info = self._path_provider(device_name=name)
 
         # Set create dir depth first to guarantee that callback when setting
@@ -64,7 +64,15 @@ class PandaHDFWriter(DetectorWriter):
         # Wait for it to start, stashing the status that tells us when it finishes
         await self.panda_data_block.capture.set(True)
 
-        return await self._describe(name)
+        describe = await self._describe(name)
+
+        self._composer = HDFDocumentComposer(
+            Path(await self.panda_data_block.hdf_directory.get_value())
+            / Path(await self.panda_data_block.hdf_file_name.get_value()),
+            self._datasets,
+        )
+
+        return describe
 
     async def _describe(self, name: str) -> dict[str, DataKey]:
         """Return a describe based on the datasets PV."""
@@ -145,17 +153,11 @@ class PandaHDFWriter(DetectorWriter):
         self, name: str, indices_written: int
     ) -> AsyncIterator[StreamAsset]:
         # TODO: fail if we get dropped frames
-        if indices_written:
-            if not self._composer:
-                self._composer = HDFDocumentComposer(
-                    Path(await self.panda_data_block.hdf_directory.get_value())
-                    / Path(await self.panda_data_block.hdf_file_name.get_value()),
-                    self._datasets,
-                )
-                for doc in self._composer.stream_resources():
-                    yield "stream_resource", doc
-            for doc in self._composer.stream_data(indices_written):
-                yield "stream_datum", doc
+        if self._composer is None:
+            msg = f"open() not called on {self}"
+            raise RuntimeError(msg)
+        for doc in self._composer.make_stream_docs(indices_written):
+            yield doc
 
     # Could put this function as default for StandardDetector
     async def close(self):

ophyd_async/plan_stubs/__init__.py

@@ -1,11 +1,6 @@
 """Plan stubs for connecting, setting up and flying devices."""
 
 from ._ensure_connected import ensure_connected
-from ._fly import (
-    fly_and_collect,
-    prepare_static_seq_table_flyer_and_detectors_with_same_trigger,
-    time_resolved_fly_and_collect_with_static_seq_table,
-)
 from ._nd_attributes import setup_ndattributes, setup_ndstats_sum
 from ._panda import apply_panda_settings
 from ._settings import (
@@ -17,9 +12,6 @@ from ._settings import (
 )
 
 __all__ = [
-    "fly_and_collect",
-    "prepare_static_seq_table_flyer_and_detectors_with_same_trigger",
-    "time_resolved_fly_and_collect_with_static_seq_table",
     "ensure_connected",
     "setup_ndattributes",
     "setup_ndstats_sum",