dls-dodal 1.66.0__py3-none-any.whl → 1.67.0__py3-none-any.whl

dodal/devices/cryostream.py

@@ -1,5 +1,4 @@
 from ophyd_async.core import (
-    EnabledDisabled,
     InOut,
     StandardReadable,
     StandardReadableFormat,
@@ -12,20 +11,6 @@ from ophyd_async.epics.core import (
 )
 
 
-class CryoStream(StandardReadable):
-    MAX_TEMP_K = 110
-    MAX_PRESSURE_BAR = 0.1
-
-    def __init__(self, prefix: str, name: str = ""):
-        self.course = epics_signal_rw(InOut, f"{prefix}-EA-CJET-01:COARSE:CTRL")
-        self.fine = epics_signal_rw(InOut, f"{prefix}-EA-CJET-01:FINE:CTRL")
-        self.temperature_k = epics_signal_r(float, f"{prefix}-EA-CSTRM-01:TEMP")
-        self.back_pressure_bar = epics_signal_r(
-            float, f"{prefix}-EA-CSTRM-01:BACKPRESS"
-        )
-        super().__init__(name)
-
-
 class TurboEnum(StrictEnum):
     OFF = "Off"
     ON = "On"
@@ -37,59 +22,33 @@ class CryoStreamSelection(StrictEnum):
     HC1 = "HC1"
 
 
-class OxfordCryoStreamController(StandardReadable):
+class OxfordCryoStream(StandardReadable):
     def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.temp = epics_signal_r(float, f"{prefix}TEMP")
+
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Any signals that should be read once at the start of the scan
+
             self.turbo = epics_signal_rw(str, f"{prefix}TURBO")
             self.turbo_mode = epics_signal_rw(TurboEnum, f"{prefix}TURBOMODE")
-
-            self.serial_comms = epics_signal_rw(EnabledDisabled, f"{prefix}DISABLE")
             self.status = epics_signal_r(str, f"{prefix}STATUS.SEVR")
-
-        with self.add_children_as_readables():
-            # Any signals that should be read at every point in the scan
-
-            self.purge = epics_signal_x(f"{prefix}PURGE.PROC")
-            self.hold = epics_signal_x(f"{prefix}HOLD.PROC")
-            self.start = epics_signal_x(f"{prefix}RESTART.PROC")
-            self.pause = epics_signal_x(f"{prefix}PAUSE.PROC")
-            self.resume = epics_signal_x(f"{prefix}RESUME.PROC")
-            self.end = epics_signal_x(f"{prefix}END.PROC")
-            self.stop = epics_signal_x(f"{prefix}STOP.PROC")
-
-            self.ramp_rate = epics_signal_rw(float, f"{prefix}RRATE")
-            self.ramp_temp = epics_signal_rw(float, f"{prefix}RTEMP")
-            self.ramp = epics_signal_x(f"{prefix}RAMP.PROC")
-
-            self.plat_time = epics_signal_rw(float, f"{prefix}PTIME")
-            self.plat = epics_signal_x(f"{prefix}PLAT.PROC")
-
-            self.cool_temp = epics_signal_rw(float, f"{prefix}CTEMP")
-            self.cool = epics_signal_x(f"{prefix}COOL.PROC")
-
-            self.end_rate = epics_signal_rw(float, f"{prefix}ERATE")
-
-        super().__init__(name)
-
-
-class OxfordCryoStreamStatus(StandardReadable):
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            # Any signals that should be read once at the start of the scan
-
             self.pump_uptime = epics_signal_r(float, f"{prefix}RUNTIME")
             self.controller_number = epics_signal_r(float, f"{prefix}CTRLNUM")
             self.software_version = epics_signal_r(float, f"{prefix}VER")
             self.evap_adjust = epics_signal_r(float, f"{prefix}EVAPADJUST")
             self.series = epics_signal_r(str, f"{prefix}SERIES")
+            self.error = epics_signal_r(float, f"{prefix}ERROR")
+            self.mode = epics_signal_r(str, f"{prefix}RUNMODE")
 
         with self.add_children_as_readables():
             # Any signals that should be read at every point in the scan
+            self.ramp_rate = epics_signal_rw(float, f"{prefix}RRATE")
+            self.ramp_temp = epics_signal_rw(float, f"{prefix}RTEMP")
+            self.plat_time = epics_signal_rw(float, f"{prefix}PTIME")
+            self.cool_temp = epics_signal_rw(float, f"{prefix}CTEMP")
+            self.end_rate = epics_signal_rw(float, f"{prefix}ERATE")
             self.setpoint = epics_signal_r(float, f"{prefix}SETPOINT")
-            self.temp = epics_signal_r(float, f"{prefix}TEMP")
-            self.error = epics_signal_r(float, f"{prefix}ERROR")
-            self.mode = epics_signal_r(str, f"{prefix}RUNMODE")
             self.phase = epics_signal_r(str, f"{prefix}PHASE")
             self.ramp_rate_setpoint = epics_signal_r(float, f"{prefix}RAMPRATE")
             self.target_temp = epics_signal_r(float, f"{prefix}TARGETTEMP")
@@ -102,14 +61,27 @@ class OxfordCryoStreamStatus(StandardReadable):
             self.suct_heat = epics_signal_r(float, f"{prefix}SUCTHEAT")
             self.back_pressure = epics_signal_r(float, f"{prefix}BACKPRESS")
 
+        self.purge = epics_signal_x(f"{prefix}PURGE.PROC")
+        self.hold = epics_signal_x(f"{prefix}HOLD.PROC")
+        self.start = epics_signal_x(f"{prefix}RESTART.PROC")
+        self.pause = epics_signal_x(f"{prefix}PAUSE.PROC")
+        self.resume = epics_signal_x(f"{prefix}RESUME.PROC")
+        self.end = epics_signal_x(f"{prefix}END.PROC")
+        self.stop = epics_signal_x(f"{prefix}STOP.PROC")
+        self.plat = epics_signal_x(f"{prefix}PLAT.PROC")
+        self.cool = epics_signal_x(f"{prefix}COOL.PROC")
+        self.ramp = epics_signal_x(f"{prefix}RAMP.PROC")
+
         super().__init__(name)
 
 
-class OxfordCryoStream(StandardReadable):
+class OxfordCryoJet(StandardReadable):
+    # TODO: https://github.com/DiamondLightSource/dodal/issues/1486
+    # This is a placeholder implementation to get it working with I03, the actual cryojet has many more PVs
     def __init__(self, prefix: str, name=""):
         with self.add_children_as_readables():
-            self.controller = OxfordCryoStreamController(prefix=prefix)
-            self.status = OxfordCryoStreamStatus(prefix=prefix)
+            self.coarse = epics_signal_rw(InOut, f"{prefix}COARSE:CTRL")
+            self.fine = epics_signal_rw(InOut, f"{prefix}FINE:CTRL")
 
         super().__init__(name)
 
@@ -126,5 +98,4 @@ class CryoStreamGantry(StandardReadable):
             self.cryostream_selected = epics_signal_r(
                 int, f"{prefix}-MO-STEP-02:GPIO_INP_BITS.B3"
             )
-
         super().__init__(name)

dodal/devices/eiger.py

@@ -64,14 +64,12 @@ class EigerDetector(Device, Stageable):
     arming_status = Status()
     arming_status.set_finished()
 
-    disarming_status = Status()
-    disarming_status.set_finished()
-
     def __init__(self, beamline: str = "i03", *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.beamline = beamline
         # using i03 timeouts as default
         self.timeouts = AVAILABLE_TIMEOUTS.get(beamline, AVAILABLE_TIMEOUTS["i03"])
+        self.disarming_status = None
 
     @classmethod
     def with_params(
@@ -106,6 +104,7 @@ class EigerDetector(Device, Stageable):
             raise Exception("\n".join(errors))
 
     def async_stage(self):
+        self.disarming_status = None
         self.odin.nodes.clear_odin_errors()
         status_ok, error_message = self.odin.wait_for_odin_initialised(
             self.timeouts.general_status_timeout
@@ -170,22 +169,31 @@ class EigerDetector(Device, Stageable):
     def stop(self, *args):
         """Emergency stop the device, mainly used to clean up after error."""
         LOGGER.info("Eiger stop() called - cleaning up...")
-        if not self.disarming_status.done:
+        if self.disarming_status and not self.disarming_status.done:
             LOGGER.info("Eiger still disarming, waiting on disarm")
             self.disarming_status.wait(self.timeouts.arming_timeout)
+        elif not self.disarming_status:
+            self.disarming_status = Status()
+            try:
+                self.wait_on_arming_if_started()
+                stop_status = self.odin.stop()
+                self.odin.file_writer.start_timeout.set(1).wait(
+                    self.timeouts.general_status_timeout
+                )
+                self.disarm_detector()
+                stop_status &= self.disable_roi_mode()
+                LOGGER.info("Waiting on stop status")
+                stop_status.wait(self.timeouts.general_status_timeout)
+                # See https://github.com/DiamondLightSource/hyperion/issues/1395
+                LOGGER.info("Turning off Eiger dev/shm streaming")
+                self.odin.fan.dev_shm_enable.set(0).wait(
+                    self.timeouts.general_status_timeout
+                )
+                LOGGER.info("Eiger has successfully been stopped")
+            finally:
+                self.disarming_status.set_finished()
         else:
-            self.wait_on_arming_if_started()
-            stop_status = self.odin.stop()
-            self.odin.file_writer.start_timeout.set(1).wait(
-                self.timeouts.general_status_timeout
-            )
-            self.disarm_detector()
-            stop_status &= self.disable_roi_mode()
-            stop_status.wait(self.timeouts.general_status_timeout)
-            # See https://github.com/DiamondLightSource/hyperion/issues/1395
-            LOGGER.info("Turning off Eiger dev/shm streaming")
-            self.odin.fan.dev_shm_enable.set(0).wait()
-            LOGGER.info("Eiger has successfully been stopped")
+            LOGGER.info("Already disarmed, doing nothing")
 
     def disable_roi_mode(self):
         return self.change_roi_mode(False)
@@ -194,13 +202,13 @@ class EigerDetector(Device, Stageable):
         return self.change_roi_mode(True)
 
     def change_roi_mode(self, enable: bool) -> StatusBase:
+        LOGGER.info(f"Changing ROI mode to {enable}")
         assert self.detector_params is not None
         detector_dimensions = (
             self.detector_params.detector_size_constants.roi_size_pixels
             if enable
             else self.detector_params.detector_size_constants.det_size_pixels
         )
-
         status = self.cam.roi_mode.set(
             1 if enable else 0, timeout=self.timeouts.general_status_timeout
         )
@@ -216,7 +224,6 @@ class EigerDetector(Device, Stageable):
         status &= self.odin.file_writer.num_col_chunks.set(
             detector_dimensions.width, timeout=self.timeouts.general_status_timeout
         )
-
         return status
 
     def set_cam_pvs(self) -> AndStatus:
@@ -296,6 +303,7 @@ class EigerDetector(Device, Stageable):
             self.detector_params.omega_increment,
             timeout=self.timeouts.general_status_timeout,
         )
+
         return status
 
     def set_detector_threshold(self, energy: float, tolerance: float = 0.1) -> Status:

dodal/devices/i04/max_pixel.py

@@ -0,0 +1,38 @@
+import cv2
+import numpy as np
+from bluesky.protocols import Triggerable
+from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.epics.core import (
+    epics_signal_r,
+)
+
+# kernal size describes how many of the neigbouring pixels are used for the blur,
+# higher kernal size means more of a blur effect
+KERNAL_SIZE = (7, 7)
+
+
+class MaxPixel(StandardReadable, Triggerable):
+    """Gets the max pixel (brightest pixel) from the image after some image processing."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.array_data = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+        self.max_pixel_val, self._max_val_setter = soft_signal_r_and_setter(float)
+        super().__init__(name)
+
+    async def _convert_to_gray_and_blur(self):
+        """
+        Preprocess the image array data (convert to grayscale and apply a gaussian blur)
+        Image is converted to grayscale (using a weighted mean as green contributes more to brightness)
+        as we aren't interested in data relating to colour. A blur is then applied to mitigate
+        errors due to rogue hot pixels.
+        """
+        data = await self.array_data.get_value()
+        gray_arr = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY)
+        return cv2.GaussianBlur(gray_arr, KERNAL_SIZE, 0)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        arr = await self._convert_to_gray_and_blur()
+        max_val = float(np.max(arr))  # np.int64
+        assert isinstance(max_val, float)
+        self._max_val_setter(max_val)

dodal/devices/i09_1_shared/__init__.py

@@ -1,7 +1,14 @@
+from .hard_energy import HardEnergy, HardInsertionDeviceEnergy
 from .hard_undulator_functions import (
     calculate_energy_i09_hu,
     calculate_gap_i09_hu,
     get_hu_lut_as_dict,
 )
 
-__all__ = ["calculate_gap_i09_hu", "get_hu_lut_as_dict", "calculate_energy_i09_hu"]
+__all__ = [
+    "calculate_gap_i09_hu",
+    "get_hu_lut_as_dict",
+    "calculate_energy_i09_hu",
+    "HardInsertionDeviceEnergy",
+    "HardEnergy",
+]

dodal/devices/i09_1_shared/hard_energy.py

@@ -0,0 +1,112 @@
+from asyncio import gather
+from collections.abc import Callable
+
+from bluesky.protocols import Locatable, Location, Movable
+from numpy import ndarray
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_rw,
+    soft_signal_rw,
+)
+
+from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
+from dodal.devices.i09_1_shared.hard_undulator_functions import (
+    MAX_ENERGY_COLUMN,
+    MIN_ENERGY_COLUMN,
+)
+from dodal.devices.undulator import UndulatorInMm, UndulatorOrder
+
+
+class HardInsertionDeviceEnergy(StandardReadable, Movable[float]):
+    """
+    Compound device to link hard x-ray undulator gap and order to photon energy.
+    Setting the energy adjusts the undulator gap accordingly.
+    """
+
+    def __init__(
+        self,
+        undulator_order: UndulatorOrder,
+        undulator: UndulatorInMm,
+        lut: dict[int, ndarray],
+        gap_to_energy_func: Callable[..., float],
+        energy_to_gap_func: Callable[..., float],
+        name: str = "",
+    ) -> None:
+        self._lut = lut
+        self.gap_to_energy_func = gap_to_energy_func
+        self.energy_to_gap_func = energy_to_gap_func
+        self._undulator_order_ref = Reference(undulator_order)
+        self._undulator_ref = Reference(undulator)
+
+        self.add_readables([undulator_order, undulator.current_gap])
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.energy_demand = soft_signal_rw(float)
+            self.energy = derived_signal_rw(
+                raw_to_derived=self._read_energy,
+                set_derived=self._set_energy,
+                current_gap=self._undulator_ref().gap_motor.user_readback,
+                current_order=self._undulator_order_ref().value,
+                derived_units="keV",
+            )
+        super().__init__(name=name)
+
+    def _read_energy(self, current_gap: float, current_order: int) -> float:
+        return self.gap_to_energy_func(
+            gap=current_gap,
+            look_up_table=self._lut,
+            order=current_order,
+        )
+
+    async def _set_energy(self, energy: float) -> None:
+        current_order = await self._undulator_order_ref().value.get_value()
+        min_energy, max_energy = self._lut[current_order][
+            MIN_ENERGY_COLUMN : MAX_ENERGY_COLUMN + 1
+        ]
+        if not (min_energy <= energy <= max_energy):
+            raise ValueError(
+                f"Requested energy {energy} keV is out of range for harmonic {current_order}: "
+                f"[{min_energy}, {max_energy}] keV"
+            )
+
+        target_gap = self.energy_to_gap_func(
+            photon_energy_kev=energy, look_up_table=self._lut, order=current_order
+        )
+        await self._undulator_ref().set(target_gap)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        self.energy_demand.set(value)
+        await self.energy.set(value)
+
+
+class HardEnergy(StandardReadable, Locatable[float]):
+    """
+    Energy compound device that provides combined change of both DCM energy and undulator gap accordingly.
+    """
+
+    def __init__(
+        self,
+        dcm: DoubleCrystalMonochromatorBase,
+        undulator_energy: HardInsertionDeviceEnergy,
+        name: str = "",
+    ) -> None:
+        self._dcm_ref = Reference(dcm)
+        self._undulator_energy_ref = Reference(undulator_energy)
+        self.add_readables([undulator_energy, dcm.energy_in_keV])
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        await gather(
+            self._dcm_ref().energy_in_keV.set(value),
+            self._undulator_energy_ref().set(value),
+        )
+
+    async def locate(self) -> Location[float]:
+        return Location(
+            setpoint=await self._dcm_ref().energy_in_keV.user_setpoint.get_value(),
+            readback=await self._dcm_ref().energy_in_keV.user_readback.get_value(),
+        )

dodal/devices/i09_2_shared/i09_apple2.py

@@ -0,0 +1,86 @@
+from dodal.devices.insertion_device.apple2_undulator import (
+    MAXIMUM_MOVE_TIME,
+    Apple2,
+    Apple2Controller,
+    Apple2PhasesVal,
+    Apple2Val,
+    Pol,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
+
+J09_GAP_POLY_DEG_COLUMNS = [
+    "9th-order",
+    "8th-order",
+    "7th-order",
+    "6th-order",
+    "5th-order",
+    "4th-order",
+    "3rd-order",
+    "2nd-order",
+    "1st-order",
+    "0th-order",
+]
+
+J09_PHASE_POLY_DEG_COLUMNS = ["0th-order"]
+
+
+class J09Apple2Controller(Apple2Controller[Apple2[UndulatorPhaseAxes]]):
+    def __init__(
+        self,
+        apple2: Apple2[UndulatorPhaseAxes],
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
+        units: str = "keV",
+        name: str = "",
+    ) -> None:
+        """
+        Parameters:
+        -----------
+        apple2 : Apple2
+            An Apple2 device.
+        gap_energy_motor_lut: EnergyMotorLookup
+            The class that handles the gap look up table logic for the insertion device.
+        phase_energy_motor_lut: EnergyMotorLookup
+            The class that handles the phase look up table logic for the insertion device.
+        units:
+            the units of this device. Defaults to eV.
+        name : str, optional
+            New device name.
+        """
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
+        super().__init__(
+            apple2=apple2,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            units=units,
+            name=name,
+        )
+
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        return Apple2Val(
+            gap=f"{gap:.6f}",
+            phase=Apple2PhasesVal(
+                top_outer=f"{phase:.6f}",
+                top_inner=f"{0.0:.6f}",
+                btm_inner=f"{phase:.6f}",
+                btm_outer=f"{0.0:.6f}",
+            ),
+        )
+
+    async def _set_pol(
+        self,
+        value: Pol,
+    ) -> None:
+        # I09 require all palarisation change to go via LH.
+        target_energy = await self.energy.get_value()
+        if value is not Pol.LH:
+            self._polarisation_setpoint_set(Pol.LH)
+            max_lh_energy = self.gap_energy_motor_lut.lut.root[Pol.LH].max_energy
+            lh_setpoint = (
+                max_lh_energy if target_energy > max_lh_energy else target_energy
+            )
+            await self.energy.set(lh_setpoint, timeout=MAXIMUM_MOVE_TIME)
+        self._polarisation_setpoint_set(value)
+        await self.energy.set(target_energy, timeout=MAXIMUM_MOVE_TIME)

dodal/devices/i10/i10_apple2.py

@@ -11,7 +11,7 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 
-from dodal.devices.apple2_undulator import (
+from dodal.devices.insertion_device.apple2_undulator import (
     MAXIMUM_MOVE_TIME,
     Apple2,
     Apple2Controller,
@@ -22,8 +22,7 @@ from dodal.devices.apple2_undulator import (
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
-from dodal.devices.util.lookup_tables_apple2 import EnergyMotorLookup
-from dodal.log import LOGGER
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
@@ -62,16 +61,18 @@ class I10Apple2(Apple2[UndulatorPhaseAxes]):
 class I10Apple2Controller(Apple2Controller[I10Apple2]):
     """
     I10Apple2Controller is a extension of Apple2Controller which provide linear
-     arbitrary angle control.
+    arbitrary angle control.
     """
 
     def __init__(
         self,
         apple2: I10Apple2,
-        energy_motor_lut: EnergyMotorLookup,
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
         jaw_phase_limit: float = 12.0,
         jaw_phase_poly_param: list[float] = DEFAULT_JAW_PHASE_POLY_PARAMS,
         angle_threshold_deg=30.0,
+        units: str = "eV",
         name: str = "",
     ) -> None:
         """
@@ -79,25 +80,30 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
         -----------
         apple2 : I10Apple2
             An I10Apple2 device.
-        energy_motor_lut: EnergyMotorLookup
-            The class that handles the look up table logic for the insertion device.
+        gap_energy_motor_lut: EnergyMotorLookup
+            The class that handles the gap look up table logic for the insertion device.
+        phase_energy_motor_lut: EnergyMotorLookup
+            The class that handles the phase look up table logic for the insertion device.
         jaw_phase_limit : float, optional
             The maximum allowed jaw_phase movement., by default 12.0
         jaw_phase_poly_param : list[float], optional
             polynomial parameters highest power first., by default DEFAULT_JAW_PHASE_POLY_PARAMS
         angle_threshold_deg : float, optional
             The angle threshold to switch between 0-180 and 180-360 range., by default 30.0
+        units:
+            the units of this device. Defaults to eV.
         name : str, optional
             New device name.
         """
-
-        self.energy_motor_lut = energy_motor_lut
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
         super().__init__(
             apple2=apple2,
-            energy_to_motor_converter=self.energy_motor_lut.get_motor_from_energy,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            units=units,
             name=name,
         )
-
         self.jaw_phase_from_angle = np.poly1d(jaw_phase_poly_param)
         self.angle_threshold_deg = angle_threshold_deg
         self.jaw_phase_limit = jaw_phase_limit
@@ -132,15 +138,9 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
         await self.apple2().jaw_phase().set(jaw_phase)
         await self._linear_arbitrary_angle.set(pol_angle)
 
-    async def _set_motors_from_energy(self, value: float) -> None:
-        """
-        Set the undulator motors for a given energy and polarisation.
-        """
-
-        pol = await self._check_and_get_pol_setpoint()
-        gap, phase = self.energy_to_motor(energy=value, pol=pol)
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
         phase3 = phase * (-1 if pol == Pol.LA else 1)
-        id_set_val = Apple2Val(
+        return Apple2Val(
             gap=f"{gap:.6f}",
             phase=Apple2PhasesVal(
                 top_outer=f"{phase:.6f}",
@@ -150,8 +150,10 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
             ),
         )
 
-        LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self.apple2().set(id_motor_values=id_set_val)
+    async def _set_motors_from_energy_and_polarisation(
+        self, energy: float, pol: Pol
+    ) -> None:
+        await super()._set_motors_from_energy_and_polarisation(energy, pol)
         if pol != Pol.LA:
             await self.apple2().jaw_phase().set(0)
             await self.apple2().jaw_phase().set_move.set(1)

dodal/devices/i17/i17_apple2.py

@@ -1,11 +1,12 @@
-from dodal.devices.apple2_undulator import (
+from dodal.devices.insertion_device.apple2_undulator import (
     Apple2,
     Apple2Controller,
     Apple2PhasesVal,
     Apple2Val,
-    EnergyMotorConvertor,
+    Pol,
+    UndulatorPhaseAxes,
 )
-from dodal.log import LOGGER
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
@@ -15,7 +16,7 @@ ALPHA_OFFSET = 180
 MAXIMUM_MOVE_TIME = 550  # There is no useful movements take longer than this.
 
 
-class I17Apple2Controller(Apple2Controller[Apple2]):
+class I17Apple2Controller(Apple2Controller[Apple2[UndulatorPhaseAxes]]):
     """
     I10Apple2Controller is a extension of Apple2Controller which provide linear
     arbitrary angle control.
@@ -23,32 +24,43 @@ class I17Apple2Controller(Apple2Controller[Apple2]):
 
     def __init__(
         self,
-        apple2: Apple2,
-        energy_to_motor_converter: EnergyMotorConvertor,
+        apple2: Apple2[UndulatorPhaseAxes],
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
+        units: str = "eV",
         name: str = "",
     ) -> None:
+        """
+        Parameters:
+        -----------
+        apple2 : Apple2
+            An Apple2 device.
+        gap_energy_motor_lut: EnergyMotorLookup
+            The class that handles the gap look up table logic for the insertion device.
+        phase_energy_motor_lut: EnergyMotorLookup
+            The class that handles the phase look up table logic for the insertion device.
+        units:
+            the units of this device. Defaults to eV.
+        name : str, optional
+            New device name.
+        """
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
         super().__init__(
             apple2=apple2,
-            energy_to_motor_converter=energy_to_motor_converter,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            units=units,
             name=name,
         )
 
-    async def _set_motors_from_energy(self, value: float) -> None:
-        """
-        Set the undulator motors for a given energy and polarisation.
-        """
-
-        pol = await self._check_and_get_pol_setpoint()
-        gap, phase = self.energy_to_motor(energy=value, pol=pol)
-        id_set_val = Apple2Val(
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        return Apple2Val(
             gap=f"{gap:.6f}",
             phase=Apple2PhasesVal(
                 top_outer=f"{phase:.6f}",
-                top_inner="0.0",
+                top_inner=f"{0.0:.6f}",
                 btm_inner=f"{phase:.6f}",
-                btm_outer="0.0",
+                btm_outer=f"{0.0:.6f}",
             ),
         )
-
-        LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self.apple2().set(id_motor_values=id_set_val)