Source code for dodal.devices.beamlines.i05_shared.poly_compound_movable

import asyncio
from dataclasses import dataclass
from functools import cached_property

from ophyd_async.core import (
    DeviceMock,
    MovableLogic,
    Reference,
    SignalR,
    StandardMovable,
    StandardReadable,
    StandardReadableFormat,
    TimeoutCalculator,
    default_mock_class,
    derived_signal_r,
    soft_signal_r_and_setter,
    soft_signal_rw,
)


@dataclass
class PolynomialCompoundMovableLogic(MovableLogic[float]):
    master: StandardMovable[float]
    slave: StandardMovable[float]
    offset: SignalR[float]
    step: SignalR[float]
    square: SignalR[float]

    def _calc_slave_pos(
        self, new_pos: float, offset: float, step: float, square: float
    ) -> float:
        return offset + step * new_pos + square * new_pos**2

    async def move(self, new_position: float, timeout: TimeoutCalculator) -> None:
        offset, step, square = await asyncio.gather(
            self.offset.get_value(),
            self.step.get_value(),
            self.square.get_value(),
        )
        slave_pos = self._calc_slave_pos(
            new_pos=new_position, offset=offset, step=step, square=square
        )
        # Timeout will be calculated directly by master and slave as they are
        # standard movables so safe to ignore.
        await asyncio.gather(self.master.set(new_position), self.slave.set(slave_pos))

    async def stop(self) -> None:
        await asyncio.gather(self.master.stop(), self.slave.stop())


[docs] @default_mock_class(DeviceMock) class PolynomialCompoundMovable( StandardMovable[float], StandardReadable, ): """Compound device that moves a slave device according to a polynomial of the master. The slave position is calculated as: slave_position = offset + step * master_position + square * master_position**2 The polynomial coefficients (offset, step, and square) are exposed as writable soft signals and can be configured or changed at runtime. """ def __init__( self, master: StandardMovable[float], slave: StandardMovable[float], offset: float = 0.0, step: float = 0.0, square: float = 0.0, name: str = "", ) -> None: with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL): # Writable soft signals for configuring the polynomial. self.offset = soft_signal_rw(float, initial_value=offset) self.step = soft_signal_rw(float, initial_value=step) self.square = soft_signal_rw(float, initial_value=square) # Allow user to see what the master and slaves devices are configured as. self.master_name, _ = soft_signal_r_and_setter(str, master.name) self.slave_name, _ = soft_signal_r_and_setter(str, slave.name) with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL): # This is needed so that StandardMovable doesn't rename the master readback # signal to this device name. self.readback = derived_signal_r( self._readback_read, readback=master.movable_logic.readback ) # Expose readbacks as readables self.add_readables( [master.movable_logic.readback, slave.movable_logic.readback] ) self._master_ref = Reference(master) self._slave_ref = Reference(slave) super().__init__(name=name) def _readback_read(self, readback: float) -> float: return readback @cached_property def movable_logic(self) -> MovableLogic: return PolynomialCompoundMovableLogic( readback=self.readback, setpoint=self._master_ref().movable_logic.setpoint, master=self._master_ref(), slave=self._slave_ref(), offset=self.offset, step=self.step, square=self.square, )