dls-dodal 1.69.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

dodal/devices/insertion_device/apple_knot_controller.py

@@ -0,0 +1,222 @@
+from math import isclose
+from typing import Generic
+
+from numpy import sign
+
+from dodal.common import Rectangle2D
+from dodal.devices.insertion_device import (
+    Apple2,
+    Apple2Controller,
+    Apple2Val,
+    EnergyMotorConvertor,
+)
+from dodal.devices.insertion_device.apple2_undulator import (
+    Apple2LockedPhasesVal,
+    PhaseAxesType,
+)
+from dodal.devices.insertion_device.enum import Pol
+from dodal.log import LOGGER
+
+APPLE_KNOT_MAXIMUM_GAP_MOTOR_POSITION = 100.0
+APPLE_KNOT_MAXIMUM_PHASE_MOTOR_POSITION = 70.0
+
+
+class AppleKnotPathFinder:
+    """Class to find a safe path for AppleKnot undulator moves that avoids the exclusion
+    zone around 0-0 gap-phase. We rely on axis-aligned (manhattan) moves and splitting
+    moves that cross zero phase into two segments via an intermediate point at zero
+    phase and a safe gap value. We ASSUME the exclusion zones are rectangles aligned
+    with the axes in a shape of hanoi tower centered at (0,0).
+    Gap and phase motors are NOT moved together but instead are moved sequentially.
+    Sequential move guarantees safe pass avoiding exslusion zones.
+    We can not use asynchronous move of gap and phase because we can not currently rely
+    on gap and phase motors relative speed.
+    See https://confluence.diamond.ac.uk/x/vQENAg for more details.
+    """
+
+    def __init__(
+        self,
+        exclusion_zone: tuple[Rectangle2D, ...],
+    ) -> None:
+        # Define the exclusion zone rectangles around (0,0)
+        self.exclusion_zone = exclusion_zone
+
+    def get_apple_knot_val_path(
+        self, start_val: Apple2Val, end_val: Apple2Val
+    ) -> tuple[Apple2Val, ...]:
+        """Get a list of Apple2Val representing the path from start to end avoiding
+        exclusion zones.
+        """
+        apple_knot_val_path = ()
+        # Defensive checks for no movement
+        if (
+            start_val.gap == end_val.gap
+            and start_val.phase.top_outer == end_val.phase.top_outer
+        ):
+            LOGGER.warning("Start point same as end point, no path calculated.")
+            return apple_knot_val_path
+        for zone in self.exclusion_zone:
+            for value in (start_val, end_val):
+                if zone.contains(value.phase.top_outer, value.gap):
+                    LOGGER.warning(
+                        "Start point is inside exclusion zone, no path calculated."
+                    )
+                    return apple_knot_val_path
+        apple_knot_val_path += (start_val,)
+        # Split the move if start and end are on opposite sides of zero phase
+        # TBD This can be potentially improved to always have max 3 sections in path!
+        # Currently in copies java class logic
+        if (
+            sign(start_val.phase.top_outer) == (-1) * sign(end_val.phase.top_outer)
+            and sign(start_val.phase.top_outer) != 0
+        ):
+            apple_knot_val_path += (
+                self._get_zero_phase_crossing_point(start_val, end_val),
+            )
+        apple_knot_val_path += (end_val,)
+        return self._apple_knot_manhattan_path(apple_knot_val_path)
+
+    def _apple_knot_manhattan_path(
+        self, apple_knot_val_path: tuple[Apple2Val, ...]
+    ) -> tuple[Apple2Val, ...]:
+        """Convert a list of Apple2Val into a manhattan path avoiding exclusion zones.
+        Here all moves are done in axis-aligned steps (gap first then phase or vice
+        versa).
+        List of points is expanded to include intermediate points as needed so each move
+        happens within one sign of gap and phase (including zero phase).
+        For convenience we define:phase increase as West-East axis and gap increase
+        as South-North axis. Only SW move in negative phase region and SE move in
+        positive phase region need a PHASE first then GAP move, the rest needs GAP
+        first then PHASE move or there is no difference in order.
+        """
+        final_path = []
+        for i in range(len(apple_knot_val_path) - 1):
+            start_val = apple_knot_val_path[i]
+            end_val = apple_knot_val_path[i + 1]
+            final_path.append(start_val)
+            # Direct move along one axis, no intermediate point needed
+            if (
+                end_val.phase.top_outer == start_val.phase.top_outer
+                or end_val.gap == start_val.gap
+            ):
+                continue
+            # Determine move order based on quadrant rules
+            if end_val.gap <= start_val.gap and abs(end_val.phase.top_outer) > abs(
+                start_val.phase.top_outer
+            ):
+                # Move PHASE first then GAP (SW move in negative phase or SE move in positive phase)
+                intermediate_val = Apple2Val(gap=start_val.gap, phase=end_val.phase)
+                final_path.append(intermediate_val)
+            else:
+                # Move GAP first then PHASE (other moves)
+                intermediate_val = Apple2Val(gap=end_val.gap, phase=start_val.phase)
+                final_path.append(intermediate_val)
+        final_path.append(apple_knot_val_path[-1])
+        return tuple(final_path)
+
+    def _get_zero_phase_crossing_point(
+        self, start_val: Apple2Val, end_val: Apple2Val
+    ) -> Apple2Val:
+        # Calculate the point where phase crosses zero
+        max_exclusion_gap = (
+            max([zone.get_max_y() for zone in self.exclusion_zone])
+            if self.exclusion_zone
+            else 0.0
+        )
+        return Apple2Val(
+            gap=max(
+                (start_val.gap + end_val.gap) / 2, max_exclusion_gap
+            ),  # Ensure gap is above a minimum value
+            phase=Apple2LockedPhasesVal(
+                top_outer=0.0,
+                btm_inner=0.0,
+            ),
+        )
+
+
+class AppleKnotController(
+    Apple2Controller[Apple2[PhaseAxesType]], Generic[PhaseAxesType]
+):
+    """Controller for Apple Knot undulator with unique feature of calculating a move
+    path through gap and phase space avoiding the exclusion zone around 0-0 gap-phase.
+    See https://confluence.diamond.ac.uk/x/vQENAg for more details.
+    """
+
+    def __init__(
+        self,
+        apple: Apple2[PhaseAxesType],
+        gap_energy_motor_converter: EnergyMotorConvertor,
+        phase_energy_motor_converter: EnergyMotorConvertor,
+        path_finder: AppleKnotPathFinder,
+        maximum_gap_motor_position: float = APPLE_KNOT_MAXIMUM_GAP_MOTOR_POSITION,
+        maximum_phase_motor_position: float = APPLE_KNOT_MAXIMUM_PHASE_MOTOR_POSITION,
+        units: str = "eV",
+        name: str = "",
+    ) -> None:
+        self.path_finder = path_finder
+        super().__init__(
+            apple2=apple,
+            gap_energy_motor_converter=gap_energy_motor_converter,
+            phase_energy_motor_converter=phase_energy_motor_converter,
+            maximum_gap_motor_position=maximum_gap_motor_position,
+            maximum_phase_motor_position=maximum_phase_motor_position,
+            units=units,
+            name=name,
+        )
+
+    async def _set_energy(self, energy: float) -> None:
+        await self.check_top_bottom_phase_match()
+        pol = await self._check_and_get_pol_setpoint()
+        await self._combined_move(energy, pol)
+        self._energy_set(energy)
+
+    async def check_top_bottom_phase_match(self) -> None:
+        """Check that the top and bottom phase motors are in sync.
+        Raise an error if they are not within tolerance.
+        """
+        current_phase_top = float(
+            await self.apple2().phase().top_outer.user_readback.get_value()
+        )
+        current_phase_bottom = float(
+            await self.apple2().phase().btm_inner.user_readback.get_value()
+        )
+        if not isclose(current_phase_top, current_phase_bottom, abs_tol=5e-2):
+            raise RuntimeError(
+                f"Upper phase {current_phase_top} and lower phase {current_phase_bottom} values are not close enough."
+            )
+
+    async def _combined_move(self, energy: float, pol: Pol) -> None:
+        # get current apple2 value
+        current_phase_top = float(
+            await self.apple2().phase().top_outer.user_readback.get_value()
+        )
+        current_gap = float(await self.apple2().gap().user_readback.get_value())
+        current_apple2_val = self._get_apple2_value(
+            current_gap, current_phase_top, Pol.NONE
+        )
+        # get target apple2 value
+        target_gap = self.gap_energy_motor_converter(energy=energy, pol=pol)
+        target_phase = self.phase_energy_motor_converter(energy=energy, pol=pol)
+        target_apple2_val = self._get_apple2_value(target_gap, target_phase, pol)
+        # get path avoiding exclusion zone
+        manhattan_path = self.path_finder.get_apple_knot_val_path(
+            current_apple2_val, target_apple2_val
+        )
+        if manhattan_path == ():
+            raise RuntimeError("No valid path found for move avoiding exclusion zones.")
+        # execute the moves along the path
+        for apple2_val in manhattan_path:
+            LOGGER.info(f"Moving to apple2 values: {apple2_val}")
+            await self.apple2().set(id_motor_values=apple2_val)
+
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        apple2_val = Apple2Val(
+            gap=gap,
+            phase=Apple2LockedPhasesVal(
+                top_outer=phase,
+                btm_inner=phase,
+            ),
+        )
+        LOGGER.info(f"Getting apple2 value for gap={gap}, phase={phase}.")
+        LOGGER.info(f"Apple2 motor values: {apple2_val}.")
+        return apple2_val

dodal/devices/insertion_device/energy.py

@@ -1,18 +1,25 @@
 import abc
 import asyncio
 
-from bluesky.protocols import Movable
+from bluesky.protocols import Flyable, Movable, Preparable
 from ophyd_async.core import (
     AsyncStatus,
+    FlyMotorInfo,
     Reference,
     SignalRW,
     StandardReadable,
     StandardReadableFormat,
+    WatchableAsyncStatus,
+    error_if_none,
     soft_signal_rw,
 )
 from ophyd_async.epics.motor import Motor
 
-from dodal.devices.insertion_device import MAXIMUM_MOVE_TIME, Apple2Controller
+from dodal.devices.insertion_device import (
+    MAXIMUM_MOVE_TIME,
+    Apple2Controller,
+    Apple2Type,
+)
 from dodal.log import LOGGER
 
 
@@ -28,26 +35,76 @@ class InsertionDeviceEnergyBase(abc.ABC, StandardReadable, Movable):
     async def set(self, energy: float) -> None: ...
 
 
-class BeamEnergy(StandardReadable, Movable[float]):
-    """
-    Compound device to set both ID and energy motor at the same time with an option to add an offset.
-    """
+class InsertionDeviceEnergy(InsertionDeviceEnergyBase, Preparable, Flyable):
+    """Apple2 ID energy movable device."""
 
     def __init__(
-        self, id_energy: InsertionDeviceEnergyBase, mono: Motor, name: str = ""
+        self, id_controller: Apple2Controller[Apple2Type], name: str = ""
     ) -> None:
-        """
-        Parameters
-        ----------
-
-        id_energy: InsertionDeviceEnergy
-            An InsertionDeviceEnergy device.
-        mono: Motor
-            A Motor(energy) device.
-        name:
-            New device name.
-        """
+        self.energy = Reference(id_controller.energy)
+        self._id_controller = Reference(id_controller)
         super().__init__(name=name)
+
+        self.add_readables([self.energy()], StandardReadableFormat.HINTED_SIGNAL)
+
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None:
+        LOGGER.info(f"Setting insertion device energy to {energy}.")
+        await self.energy().set(energy, timeout=MAXIMUM_MOVE_TIME)
+
+    @AsyncStatus.wrap
+    async def prepare(self, value: FlyMotorInfo) -> None:
+        """Convert FlyMotorInfo from energy to gap motion and move phase motor to mid point."""
+        mid_energy = (value.start_position + value.end_position) / 2.0
+        LOGGER.info(
+            f"Preparing for fly energy scan, move {self._id_controller().apple2().phase} to {mid_energy}"
+        )
+        await self.set(energy=mid_energy)
+        current_pol = await self._id_controller().polarisation_setpoint.get_value()
+        start_position = self._id_controller().gap_energy_motor_converter(
+            energy=value.start_position,
+            pol=current_pol,
+        )
+        end_position = self._id_controller().gap_energy_motor_converter(
+            energy=value.end_position, pol=current_pol
+        )
+
+        gap_fly_motor_info = FlyMotorInfo(
+            start_position=start_position,
+            end_position=end_position,
+            time_for_move=value.time_for_move,
+        )
+
+        LOGGER.info(
+            f"Flyscan info in energy: {value}. "
+            + f"Flyscan info in gap: {gap_fly_motor_info}. "
+            + f"Speed: {gap_fly_motor_info.velocity}."
+        )
+        await self._id_controller().apple2().gap().prepare(value=gap_fly_motor_info)
+
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        await self._id_controller().apple2().gap().kickoff()
+
+    def complete(self) -> WatchableAsyncStatus:
+        return self._id_controller().apple2().gap().complete()
+
+    async def get_id_acceleration_time(self) -> float:
+        return await self._id_controller().apple2().gap().acceleration_time.get_value()
+
+
+class BeamEnergy(StandardReadable, Movable[float], Preparable, Flyable):
+    """Compound device to set both ID and energy motor at the same time with an option to add an offset.
+
+    Args:
+        id_energy (InsertionDeviceEnergy): An InsertionDeviceEnergy device.
+        mono (Motor): A Motor(energy) device.
+        name: New device name.
+    """
+
+    def __init__(
+        self, id_energy: InsertionDeviceEnergy, mono: Motor, name: str = ""
+    ) -> None:
         self._id_energy = Reference(id_energy)
         self._mono_energy = Reference(mono)
 
@@ -61,6 +118,7 @@ class BeamEnergy(StandardReadable, Movable[float]):
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             self.id_energy_offset = soft_signal_rw(float, initial_value=0)
+        super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, energy: float) -> None:
@@ -72,17 +130,32 @@ class BeamEnergy(StandardReadable, Movable[float]):
             self._mono_energy().set(energy),
         )
 
+    @AsyncStatus.wrap
+    async def prepare(self, value: FlyMotorInfo) -> None:
+        await asyncio.gather(
+            self._id_energy().prepare(value), self._mono_energy().prepare(value)
+        )
 
-class InsertionDeviceEnergy(InsertionDeviceEnergyBase):
-    """Apple2 ID energy movable device."""
+    @AsyncStatus.wrap
+    async def kickoff(self):
+        pgm_acceleration_time, gap_acceleration_time = await asyncio.gather(
+            self._mono_energy().acceleration_time.get_value(),
+            self._id_energy().get_id_acceleration_time(),
+        )
+        start_offset_time = pgm_acceleration_time - gap_acceleration_time
 
-    def __init__(self, id_controller: Apple2Controller, name: str = "") -> None:
-        self.energy = Reference(id_controller.energy)
-        super().__init__(name=name)
+        await self._mono_energy().kickoff()
+        await asyncio.sleep(start_offset_time)
+        await self._id_energy().kickoff()
+        self._fly_status = self._combined_fly_status()
 
-        self.add_readables([self.energy()], StandardReadableFormat.HINTED_SIGNAL)
+    def complete(self) -> AsyncStatus:
+        """Stop when both pgm and id is done moving."""
+        fly_status = error_if_none(self._fly_status, "kickoff not called")
+        return fly_status
 
     @AsyncStatus.wrap
-    async def set(self, energy: float) -> None:
-        LOGGER.info(f"Setting insertion device energy to {energy}.")
-        await self.energy().set(energy, timeout=MAXIMUM_MOVE_TIME)
+    async def _combined_fly_status(self):
+        status_pgm = self._mono_energy().complete()
+        status_id = self._id_energy().complete()
+        await asyncio.gather(status_pgm, status_id)

dodal/devices/insertion_device/energy_motor_lookup.py

@@ -11,12 +11,12 @@ from dodal.devices.insertion_device.lookup_table_models import (
 
 
 class EnergyMotorLookup:
-    """
-    Handles a lookup table for Apple2 ID, converting energy/polarisation to a motor
+    """Handles a lookup table for Apple2 ID, converting energy/polarisation to a motor
     position.
 
-    After update_lookup_table() has populated the lookup table, `find_value_in_lookup_table()`
-    can be used to compute gap / phase for a requested energy / polarisation pair.
+    After update_lookup_table() has populated the lookup table,
+    `find_value_in_lookup_table()` can be used to compute gap / phase for a requested
+    energy / polarisation pair.
     """
 
     def __init__(self, lut: LookupTable | None = None):
@@ -26,24 +26,19 @@ class EnergyMotorLookup:
 
     def update_lookup_table(self) -> None:
         """Do nothing by default. Sub classes may override this method to provide logic
-        on what updating lookup table does."""
+        on what updating lookup table does.
+        """
         pass
 
     def find_value_in_lookup_table(self, energy: float, pol: Pol) -> float:
-        """
-        Convert energy and polarisation to a value from the lookup table.
+        """Convert energy and polarisation to a value from the lookup table.
 
-        Parameters:
-        -----------
-        energy : float
-            Desired energy.
-        pol : Pol
-            Polarisation mode.
+        Args:
+            energy (float): Desired energy.
+            pol (Pol): Polarisation mode.
 
         Returns:
-        ----------
-        float
-            gap / phase motor position from the lookup table.
+            float: gap / phase motor position from the lookup table.
         """
         # if lut is empty, force an update to pull updated lut incase subclasses have
         # implemented it.
@@ -55,7 +50,15 @@ class EnergyMotorLookup:
 
 class ConfigServerEnergyMotorLookup(EnergyMotorLookup):
     """Fetches and parses lookup table (csv) from a config server, supports dynamic
-    updates, and validates input."""
+    updates, and validates input.
+
+    Args:
+        config_client (ConfigServer): The config server client to fetch the look up
+            table data.
+        lut_config (LookupTableColumnConfig): Configuration that defines how to
+            process file contents into a LookupTable.
+        path (Path): File path to the lookup table.
+    """
 
     def __init__(
         self,
@@ -63,16 +66,6 @@ class ConfigServerEnergyMotorLookup(EnergyMotorLookup):
         lut_config: LookupTableColumnConfig,
         path: Path,
     ):
-        """
-        Parameters:
-        -----------
-        config_client:
-            The config server client to fetch the look up table data.
-        lut_config:
-            Configuration that defines how to process file contents into a LookupTable
-        path:
-            File path to the lookup table.
-        """
         self.path = path
         self.config_client = config_client
         self.lut_config = lut_config

dodal/devices/insertion_device/lookup_table_models.py

@@ -6,21 +6,21 @@ in-memory dictionary format used by the Apple2 controllers.
 
 Data format produced
 The lookup-table dictionary created by convert_csv_to_lookup() follows this
-structure:
-
-{
-  "POL_MODE": {
-    "energy_entries": [
-        {
-            "low": <float>,
-            "high": <float>,
-            "poly": <numpy.poly1d>
-        },
-      ...
-    ]
-  },
-  ...
-}
+structure::
+
+    {
+    "POL_MODE": {
+        "energy_entries": [
+            {
+                "low": <float>,
+                "high": <float>,
+                "poly": <numpy.poly1d>
+            },
+        ...
+        ]
+    },
+    ...
+    }
 """
 
 import csv
@@ -76,7 +76,9 @@ class Source(NamedTuple):
 
 
 class LookupTableColumnConfig(BaseModel):
-    """Configuration on how to process a csv file columns into a LookupTable data model."""
+    """Configuration on how to process a csv file columns into a LookupTable data
+    model.
+    """
 
     source: A[
         Source | None,
@@ -113,7 +115,9 @@ class EnergyCoverageEntry(BaseModel):
     def validate_and_convert_poly(
         cls: type[Self], value: np.poly1d | list
     ) -> np.poly1d:
-        """If reading from serialized data, it will be using a list. Convert to np.poly1d"""
+        """If reading from serialized data, it will be using a list. Convert to
+        np.poly1d.
+        """
         if isinstance(value, list):
             return np.poly1d(value)
         return value
@@ -164,15 +168,12 @@ class EnergyCoverage(BaseModel):
         return self.energy_entries[-1].max_energy
 
     def get_poly(self, energy: float) -> np.poly1d:
-        """
-        Return the numpy.poly1d polynomial applicable for the given energy.
+        """Return the numpy.poly1d polynomial applicable for the given energy.
 
-        Parameters:
-        -----------
-        energy:
-            Energy value in the same units used to create the lookup table.
+        Args:
+            energy (float): Energy value in the same units used to create the lookup
+                table.
         """
-
         if not self.min_energy <= energy <= self.max_energy:
             raise ValueError(
                 f"Demanding energy must lie between {self.min_energy} and {self.max_energy}!"
@@ -188,7 +189,8 @@ class EnergyCoverage(BaseModel):
 
     def get_energy_index(self, energy: float) -> int | None:
         """Binary search assumes self.energy_entries is sorted by min_energy.
-        Return index or None if not found."""
+        Return index or None if not found.
+        """
         max_index = len(self.energy_entries) - 1
         min_index = 0
         while min_index <= max_index:
@@ -204,9 +206,8 @@ class EnergyCoverage(BaseModel):
 
 
 class LookupTable(RootModel[dict[Pol, EnergyCoverage]]):
-    """
-    Specialised lookup table for insertion devices to relate the energy and polarisation
-    values to Apple2 motor positions.
+    """Specialised lookup table for insertion devices to relate the energy and
+    polarisation values to Apple2 motor positions.
     """
 
     model_config = ConfigDict(frozen=True)
@@ -222,7 +223,8 @@ class LookupTable(RootModel[dict[Pol, EnergyCoverage]]):
         energy_coverage: list[EnergyCoverage],
     ) -> Self:
         """Generate a LookupTable containing multiple EnergyCoverage
-        for provided polarisations."""
+        for provided polarisations.
+        """
         root_data = dict(zip(pols, energy_coverage, strict=False))
         return cls(root=root_data)
 
@@ -231,15 +233,12 @@ class LookupTable(RootModel[dict[Pol, EnergyCoverage]]):
         energy: float,
         pol: Pol,
     ) -> np.poly1d:
-        """
-        Return the numpy.poly1d polynomial applicable for the given energy and polarisation.
-
-        Parameters:
-        -----------
-        energy:
-            Energy value in the same units used to create the lookup table.
-        pol:
-            Polarisation mode (Pol enum).
+        """Return the numpy.poly1d polynomial applicable for the given energy and
+        polarisation.
+
+        Args:
+            energy (float): Energy value in the same units used to create the lookup table.
+            pol (Pol): Polarisation mode enum.
         """
         return self.root[pol].get_poly(energy)
 
@@ -249,21 +248,17 @@ def convert_csv_to_lookup(
     lut_config: LookupTableColumnConfig,
     skip_line_start_with: str = "#",
 ) -> LookupTable:
-    """
-    Convert CSV content into the Apple2 lookup-table dictionary.
+    """Convert CSV content into the Apple2 lookup-table dictionary.
 
-    Parameters:
-    -----------
-    file_contents:
-        The CSV file contents as string.
-    lut_config:
-        The configuration that how to process the file_contents into a LookupTable.
-    skip_line_start_with
-        Lines beginning with this prefix are skipped (default "#").
+    Args:
+        file_contents (str): The CSV file contents as string.
+        lut_config (LookupTableColumnConfig): The configuration that how to process the
+            file_contents into a LookupTable.
+        skip_line_start_with (str, optional): Lines beginning with this prefix are
+            skipped (default "#").
 
     Returns:
-    -----------
-    LookupTable
+        LookupTable
     """
     temp_mode_entries: dict[Pol, list[EnergyCoverageEntry]] = {}
 

dodal/devices/insertion_device/polarisation.py

@@ -29,7 +29,7 @@ class InsertionDevicePolarisation(StandardReadable, Locatable[Pol]):
         await self.polarisation().set(pol, timeout=MAXIMUM_MOVE_TIME)
 
     async def locate(self) -> Location[Pol]:
-        """Return the current polarisation"""
+        """Return the current polarisation."""
         setpoint, readback = await asyncio.gather(
             self.polarisation_setpoint().get_value(), self.polarisation().get_value()
         )

dodal/devices/ipin.py

@@ -20,7 +20,7 @@ class IPinGain(SubsetEnum):
 
 
 class IPin(StandardReadable):
-    """Simple device to get the ipin reading"""
+    """Simple device to get the ipin reading."""
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables(

dodal/devices/linkam3.py

@@ -14,15 +14,17 @@ class PumpControl(StrictEnum):
 # TODO: Make use of Status PV:
 # https://github.com/DiamondLightSource/dodal/issues/338
 class Linkam3(StandardReadable):
-    """Device to represent a Linkam3 temperature controller
+    """Device to represent a Linkam3 temperature controller.
 
     Attributes:
-        tolerance (float): Deadband around the setpoint within which the position is assumed to have been reached
-        settle_time (int): The delay between reaching the setpoint and the move being considered complete
+        tolerance (float): Deadband around the setpoint within which the position is
+            assumed to have been reached.
+        settle_time (int): The delay between reaching the setpoint and the move being
+            considered complete.
 
     Args:
-        prefix (str): PV prefix for this device
-        name (str): unique name for this device
+        prefix (str): PV prefix for this device.
+        name (str): Unique name for this device.
     """
 
     tolerance: float = 0.5