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

dodal/devices/electron_analyser/base/base_controller.py

@@ -12,10 +12,9 @@ from dodal.devices.electron_analyser.base.base_region import (
     GenericRegion,
     TAbstractBaseRegion,
 )
-from dodal.devices.electron_analyser.base.energy_sources import (
-    AbstractEnergySource,
-    DualEnergySource,
-)
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
 
 
 class ElectronAnalyserController(
@@ -32,7 +31,9 @@ class ElectronAnalyserController(
         self,
         driver: TAbstractAnalyserDriverIO,
         energy_source: AbstractEnergySource,
-        deadtime: float,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
+        deadtime: float = 0,
         image_mode: ADImageMode = ADImageMode.SINGLE,
     ):
         """
@@ -45,13 +46,19 @@ class ElectronAnalyserController(
             image_mode: The image mode to configure the driver with before measuring.
         """
         self.energy_source = energy_source
+        self.shutter = shutter
+        self.source_selector = source_selector
         super().__init__(driver, deadtime, image_mode)
 
-    async def setup_with_region(self, region: TAbstractBaseRegion):
+    async def setup_with_region(self, region: TAbstractBaseRegion) -> None:
         """Logic to set the driver with a region."""
+        if self.source_selector is not None:
+            await self.source_selector.set(region.excitation_energy_source)
+
+        # Should this be moved to a VGScientController only?
+        if self.shutter is not None:
+            await self.shutter.set(self.shutter.close_state)
 
-        if isinstance(self.energy_source, DualEnergySource):
-            self.energy_source.selected_source.set(region.excitation_energy_source)
         excitation_energy = await self.energy_source.energy.get_value()
         epics_region = region.prepare_for_epics(excitation_energy)
         await self.driver.set(epics_region)
@@ -62,6 +69,10 @@ class ElectronAnalyserController(
         # axis calculation.
         excitation_energy = await self.energy_source.energy.get_value()
         await self.driver.cached_excitation_energy.set(excitation_energy)
+
+        if self.shutter is not None:
+            await self.shutter.set(self.shutter.open_state)
+
         await super().prepare(trigger_info)
 
 

dodal/devices/electron_analyser/base/base_enums.py

@@ -4,8 +4,3 @@ from ophyd_async.core import StrictEnum
 class EnergyMode(StrictEnum):
     KINETIC = "Kinetic"
     BINDING = "Binding"
-
-
-class SelectedSource(StrictEnum):
-    SOURCE1 = "source1"
-    SOURCE2 = "source2"

dodal/devices/electron_analyser/base/base_region.py

@@ -6,11 +6,12 @@ from typing import Generic, Self, TypeAlias, TypeVar
 from ophyd_async.core import StrictEnum, SupersetEnum
 from pydantic import BaseModel, Field, model_validator
 
-from dodal.devices.electron_analyser.base.base_enums import EnergyMode, SelectedSource
+from dodal.devices.electron_analyser.base.base_enums import EnergyMode
 from dodal.devices.electron_analyser.base.base_util import (
     to_binding_energy,
     to_kinetic_energy,
 )
+from dodal.devices.selectable_source import SelectedSource
 
 AnyAcqMode: TypeAlias = StrictEnum
 AnyLensMode: TypeAlias = SupersetEnum | StrictEnum

dodal/devices/electron_analyser/base/energy_sources.py

@@ -3,14 +3,14 @@ from abc import abstractmethod
 from ophyd_async.core import (
     Reference,
     SignalR,
+    SignalRW,
     StandardReadable,
     StandardReadableFormat,
     derived_signal_r,
     soft_signal_r_and_setter,
-    soft_signal_rw,
 )
 
-from dodal.devices.electron_analyser.base.base_enums import SelectedSource
+from dodal.devices.selectable_source import SelectedSource, get_obj_from_selected_source
 
 
 class AbstractEnergySource(StandardReadable):
@@ -51,51 +51,52 @@ class EnergySource(AbstractEnergySource):
         return self._source_ref()
 
 
+def get_float_from_selected_source(
+    selected: SelectedSource, s1: float, s2: float
+) -> float:
+    """Wrapper function to provide type hints for derived signal."""
+    return get_obj_from_selected_source(selected, s1, s2)
+
+
 class DualEnergySource(AbstractEnergySource):
     """
     Holds two EnergySource devices and provides a signal to read energy depending on
-    which source is selected. This is controlled by a selected_source signal which can
-    switch source using SelectedSource enum. Both sources energy is recorded in the
-    read, the energy signal is used as a helper signal to know which source is being
-    used.
+    which source is selected. The energy is the one that corrosponds to the
+    selected_source signal. For example, selected_source is source1 if selected_source
+    is at SelectedSource.SOURCE1 and vise versa for source2 and SelectedSource.SOURCE2.
     """
 
     def __init__(
-        self, source1: SignalR[float], source2: SignalR[float], name: str = ""
+        self,
+        source1: SignalR[float],
+        source2: SignalR[float],
+        selected_source: SignalRW[SelectedSource],
+        name: str = "",
     ):
         """
         Args:
-            source1: Default energy signal to select.
-            source2: Secondary energy signal to select.
-            name: name of this device.
+            source1: Energy source that corrosponds to SelectedSource.SOURCE1.
+            source2: Energy source that corrosponds to SelectedSource.SOURCE2.
+            selected_source: Signal that decides the active energy source.
+            name: Name of this device.
         """
 
+        self.selected_source_ref = Reference(selected_source)
         with self.add_children_as_readables():
-            self.selected_source = soft_signal_rw(
-                SelectedSource, initial_value=SelectedSource.SOURCE1
-            )
             self.source1 = EnergySource(source1)
             self.source2 = EnergySource(source2)
 
         self._selected_energy = derived_signal_r(
-            self._get_excitation_energy,
+            get_float_from_selected_source,
             "eV",
-            selected_source=self.selected_source,
-            source1=self.source1.energy,
-            source2=self.source2.energy,
+            selected=self.selected_source_ref(),
+            s1=self.source1.energy,
+            s2=self.source2.energy,
         )
+        self.add_readables([selected_source])
 
         super().__init__(name)
 
-    def _get_excitation_energy(
-        self, selected_source: SelectedSource, source1: float, source2: float
-    ) -> float:
-        match selected_source:
-            case SelectedSource.SOURCE1:
-                return source1
-            case SelectedSource.SOURCE2:
-                return source2
-
     @property
     def energy(self) -> SignalR[float]:
         return self._selected_energy

dodal/devices/electron_analyser/specs/specs_detector.py

@@ -5,15 +5,14 @@ from dodal.devices.electron_analyser.base.base_controller import (
 )
 from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
 from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.base.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
 from dodal.devices.electron_analyser.specs.specs_driver_io import SpecsAnalyserDriverIO
 from dodal.devices.electron_analyser.specs.specs_region import (
     SpecsRegion,
     SpecsSequence,
 )
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
 
 
 class SpecsDetector(
@@ -29,7 +28,9 @@ class SpecsDetector(
         prefix: str,
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
-        energy_source: DualEnergySource | EnergySource,
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
         name: str = "",
     ):
         # Save to class so takes part with connect()
@@ -39,7 +40,7 @@ class SpecsDetector(
 
         controller = ElectronAnalyserController[
             SpecsAnalyserDriverIO[TLensMode, TPsuMode], SpecsRegion[TLensMode, TPsuMode]
-        ](self.driver, energy_source, 0)
+        ](self.driver, energy_source, shutter, source_selector)
 
         sequence_class = SpecsSequence[lens_mode_type, psu_mode_type]
 

dodal/devices/electron_analyser/vgscienta/vgscienta_detector.py

@@ -5,10 +5,7 @@ from dodal.devices.electron_analyser.base.base_controller import (
 )
 from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
 from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.base.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
+from dodal.devices.electron_analyser.base.energy_sources import AbstractEnergySource
 from dodal.devices.electron_analyser.vgscienta.vgscienta_driver_io import (
     VGScientaAnalyserDriverIO,
 )
@@ -17,6 +14,8 @@ from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
     VGScientaRegion,
     VGScientaSequence,
 )
+from dodal.devices.fast_shutter import FastShutter
+from dodal.devices.selectable_source import SourceSelector
 
 
 class VGScientaDetector(
@@ -33,7 +32,9 @@ class VGScientaDetector(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_source: DualEnergySource | EnergySource,
+        energy_source: AbstractEnergySource,
+        shutter: FastShutter | None = None,
+        source_selector: SourceSelector | None = None,
         name: str = "",
     ):
         # Save to class so takes part with connect()
@@ -44,7 +45,7 @@ class VGScientaDetector(
         controller = ElectronAnalyserController[
             VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
             VGScientaRegion[TLensMode, TPassEnergyEnum],
-        ](self.driver, energy_source, 0)
+        ](self.driver, energy_source, shutter, source_selector)
 
         sequence_class = VGScientaSequence[
             lens_mode_type, psu_mode_type, pass_energy_type

dodal/devices/fast_shutter.py

@@ -1,19 +1,26 @@
-from typing import TypeVar
+from typing import Generic, Protocol, TypeVar
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
     EnumTypes,
+    Reference,
+    SignalRW,
     StandardReadable,
+    StandardReadableFormat,
+    derived_signal_rw,
+    soft_signal_r_and_setter,
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-StrictEnumT = TypeVar("StrictEnumT", bound=EnumTypes)
+from dodal.devices.selectable_source import SelectedSource, get_obj_from_selected_source
 
+EnumTypesT = TypeVar("EnumTypesT", bound=EnumTypes)
 
-class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
+
+class FastShutter(Movable[EnumTypesT], Protocol, Generic[EnumTypesT]):
     """
-    Basic enum device specialised for a fast shutter with configured open_state and
+    Enum device specialised for a fast shutter with configured open_state and
     close_state so it is generic enough to be used with any device or plan without
     knowing the specific enum to use.
 
@@ -25,11 +32,28 @@ class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
         run_engine(bps.mv(shutter, shutter.close_state))
     """
 
+    open_state: EnumTypesT
+    close_state: EnumTypesT
+    shutter_state: SignalRW[EnumTypesT]
+
+    @AsyncStatus.wrap
+    async def set(self, state: EnumTypesT):
+        await self.shutter_state.set(state)
+
+
+class GenericFastShutter(
+    StandardReadable, FastShutter[EnumTypesT], Generic[EnumTypesT]
+):
+    """
+    Implementation of fast shutter that connects to an epics pv. This pv is an enum that
+    controls the open and close state of the shutter.
+    """
+
     def __init__(
         self,
         pv: str,
-        open_state: StrictEnumT,
-        close_state: StrictEnumT,
+        open_state: EnumTypesT,
+        close_state: EnumTypesT,
         name: str = "",
     ):
         """
@@ -41,29 +65,88 @@ class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
         self.open_state = open_state
         self.close_state = close_state
         with self.add_children_as_readables():
-            self.state = epics_signal_rw(type(self.open_state), pv)
+            self.shutter_state = epics_signal_rw(type(self.open_state), pv)
         super().__init__(name)
 
-    @AsyncStatus.wrap
-    async def set(self, value: StrictEnumT) -> None:
-        await self.state.set(value)
 
-    async def is_open(self) -> bool:
-        """
-        Checks to see if shutter is in open_state. Should not be used directly inside a
-        plan. A user should use the following instead in a plan:
+class DualFastShutter(StandardReadable, FastShutter[EnumTypesT], Generic[EnumTypesT]):
+    """
+    A fast shutter device that handles the positions of two other fast shutters. The
+    "active" shutter is the one that corrosponds to the selected_shutter signal. For
+    example, active shutter is shutter1 if selected_source is at SelectedSource.SOURCE1
+    and vise versa for shutter2 and SelectedSource.SOURCE2. Whenever a move is done on
+    this device, the inactive shutter is always set to the close_state.
+    """
 
-            from bluesky import plan_stubs as bps
-            is_open = yield from bps.rd(shutter.state) == shutter.open_state
+    def __init__(
+        self,
+        shutter1: GenericFastShutter[EnumTypesT],
+        shutter2: GenericFastShutter[EnumTypesT],
+        selected_source: SignalRW[SelectedSource],
+        name: str = "",
+    ):
         """
-        return await self.state.get_value() == self.open_state
-
-    async def is_closed(self) -> bool:
+        Arguments:
+            shutter1: Active shutter that corrosponds to SelectedSource.SOURCE1.
+            shutter2: Active shutter that corrosponds to SelectedSource.SOURCE2.
+            selected_source: Signal that decides the active shutter.
+            name: Name of this device.
         """
-        Checks to see if shutter is in close_state. Should not be used directly inside a
-        plan. A user should use the following instead in a plan:
+        self._validate_shutter_states(shutter1.open_state, shutter2.open_state)
+        self._validate_shutter_states(shutter1.close_state, shutter2.close_state)
+        self.open_state = shutter1.open_state
+        self.close_state = shutter1.close_state
 
-            from bluesky import plan_stubs as bps
-            is_closed = yield from bps.rd(shutter.state) == shutter.close_state
-        """
-        return await self.state.get_value() == self.close_state
+        self._shutter1_ref = Reference(shutter1)
+        self._shutter2_ref = Reference(shutter2)
+        self._selected_shutter_ref = Reference(selected_source)
+
+        with self.add_children_as_readables():
+            self.shutter_state = derived_signal_rw(
+                self._read_shutter_state,
+                self._set_shutter_state,
+                selected_shutter=selected_source,
+                shutter1=shutter1.shutter_state,
+                shutter2=shutter2.shutter_state,
+            )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.shutter1_device_name, _ = soft_signal_r_and_setter(
+                str, initial_value=shutter1.name
+            )
+            self.shutter2_device_name, _ = soft_signal_r_and_setter(
+                str, initial_value=shutter2.name
+            )
+
+        self.add_readables([shutter1, shutter2, selected_source])
+
+        super().__init__(name)
+
+    def _validate_shutter_states(self, state1: EnumTypesT, state2: EnumTypesT) -> None:
+        if state1 is not state2:
+            raise ValueError(
+                f"{state1} is not same value as {state2}. They must be the same to be compatible."
+            )
+
+    def _read_shutter_state(
+        self,
+        selected_shutter: SelectedSource,
+        shutter1: EnumTypesT,
+        shutter2: EnumTypesT,
+    ) -> EnumTypesT:
+        return get_obj_from_selected_source(selected_shutter, shutter1, shutter2)
+
+    async def _set_shutter_state(self, value: EnumTypesT):
+        selected_shutter = await self._selected_shutter_ref().get_value()
+        active_shutter = get_obj_from_selected_source(
+            selected_shutter,
+            self._shutter1_ref(),
+            self._shutter2_ref(),
+        )
+        inactive_shutter = get_obj_from_selected_source(
+            selected_shutter,
+            self._shutter2_ref(),
+            self._shutter1_ref(),
+        )
+        await inactive_shutter.set(inactive_shutter.close_state)
+        await active_shutter.set(value)

dodal/devices/i04/beam_centre.py

@@ -0,0 +1,84 @@
+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,
+)
+
+from dodal.devices.oav.utils import convert_to_gray_and_blur
+from dodal.log import LOGGER
+
+# Constant was chosen from trial and error with test images
+ADDITIONAL_BINARY_THRESH = 20
+
+
+def convert_image_to_binary(image: np.ndarray):
+    """
+     Creates a binary image from OAV image array data.
+
+    Pixels of the input image are converted to one of two values (a high and a low value).
+    Otsu's method is used for automatic thresholding.
+    See https://docs.opencv.org/4.x/d7/d4d/tutorial_py_thresholding.html.
+    The threshold is increased by ADDITIONAL_BINARY_THRESH in order to get more of
+    the centre of the beam.
+    """
+    max_pixel_value = 255
+
+    blurred_image = convert_to_gray_and_blur(image)
+
+    threshold_value, _ = cv2.threshold(
+        blurred_image, 0, max_pixel_value, cv2.THRESH_BINARY + cv2.THRESH_OTSU
+    )
+
+    # Adjusting because the inner beam is less noisy compared to the outer
+    threshold_value += ADDITIONAL_BINARY_THRESH
+
+    _, thresholded_image = cv2.threshold(
+        blurred_image, threshold_value, max_pixel_value, cv2.THRESH_BINARY
+    )
+
+    LOGGER.info(f"Image binarised with threshold of {threshold_value}")
+    return thresholded_image
+
+
+class CentreEllipseMethod(StandardReadable, Triggerable):
+    """
+    Upon triggering, fits an ellipse to a binary image from the area detector defined by
+    the prefix.
+
+    This is used, in conjunction with a scintillator, to determine the centre of the beam
+    on the image.
+    """
+
+    def __init__(self, prefix: str, name: str = ""):
+        self.oav_array_signal = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+
+        self.center_x_val, self._center_x_val_setter = soft_signal_r_and_setter(float)
+        self.center_y_val, self._center_y_val_setter = soft_signal_r_and_setter(float)
+        super().__init__(name)
+
+    def _fit_ellipse(self, binary_img: cv2.typing.MatLike) -> cv2.typing.RotatedRect:
+        contours, _ = cv2.findContours(
+            binary_img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
+        )
+        if not contours:
+            raise ValueError("No contours found in image.")
+
+        largest_contour = max(contours, key=cv2.contourArea)
+        if len(largest_contour) < 5:
+            raise ValueError(
+                f"Not enough points to fit an ellipse. Found {largest_contour} points and need at least 5."
+            )
+
+        return cv2.fitEllipse(largest_contour)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        array_data = await self.oav_array_signal.get_value()
+        binary = convert_image_to_binary(array_data)
+        ellipse_fit = self._fit_ellipse(binary)
+        centre_x = ellipse_fit[0][0]
+        centre_y = ellipse_fit[0][1]
+        self._center_x_val_setter(centre_x)
+        self._center_y_val_setter(centre_y)

dodal/devices/i04/max_pixel.py

@@ -1,4 +1,3 @@
-import cv2
 import numpy as np
 from bluesky.protocols import Triggerable
 from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_r_and_setter
@@ -6,9 +5,7 @@ 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)
+from dodal.devices.oav.utils import convert_to_gray_and_blur
 
 
 class MaxPixel(StandardReadable, Triggerable):
@@ -19,20 +16,10 @@ class MaxPixel(StandardReadable, Triggerable):
         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
+        img_data = await self.array_data.get_value()
+        arr = convert_to_gray_and_blur(img_data)
+        max_val = float(np.max(arr))
         assert isinstance(max_val, float)
         self._max_val_setter(max_val)

dodal/devices/i04/murko_results.py

@@ -13,7 +13,7 @@ from ophyd_async.core import (
     soft_signal_r_and_setter,
     soft_signal_rw,
 )
-from redis.asyncio import StrictRedis
+from redis.asyncio import ConnectionError, StrictRedis
 
 from dodal.devices.i04.constants import RedisConstants
 from dodal.devices.oav.oav_calculations import (
@@ -103,13 +103,25 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             self.z_mm, self._z_mm_setter = soft_signal_r_and_setter(float)
         super().__init__(name=name)
 
+    async def _check_redis_connection(self):
+        try:
+            await self.redis_client.ping()  # type: ignore
+            return True
+        except ConnectionError:
+            LOGGER.warning(
+                f"Failed to connect to redis: {self.redis_client}. Murko results device will not trigger"
+            )
+            return False
+
     def _reset(self):
         self._last_omega = None
         self._results: list[MurkoResult] = []
 
     @AsyncStatus.wrap
     async def stage(self):
-        await self.pubsub.subscribe("murko-results")
+        self.redis_connected = await self._check_redis_connection()
+        if self.redis_connected:
+            await self.pubsub.subscribe("murko-results")
         self._x_mm_setter(0)
         self._y_mm_setter(0)
         self._z_mm_setter(0)
@@ -117,10 +129,13 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
     @AsyncStatus.wrap
     async def unstage(self):
         self._reset()
-        await self.pubsub.unsubscribe()
+        if self.redis_connected:
+            await self.pubsub.unsubscribe()
 
     @AsyncStatus.wrap
     async def trigger(self):
+        if not self.redis_connected:
+            return
         sample_id = await self.sample_id.get_value()
         t_last_result = time.time()
         while True:

dodal/devices/i10/i10_apple2.py

@@ -22,7 +22,7 @@ from dodal.devices.insertion_device import (
     UndulatorPhaseAxes,
 )
 from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
-from dodal.devices.insertion_device.id_enum import Pol
+from dodal.devices.insertion_device.enum import Pol
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
@@ -141,12 +141,12 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
     def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
         phase3 = phase * (-1 if pol == Pol.LA else 1)
         return Apple2Val(
-            gap=f"{gap:.6f}",
+            gap=gap,
             phase=Apple2PhasesVal(
-                top_outer=f"{phase:.6f}",
-                top_inner="0.0",
-                btm_inner=f"{phase3:.6f}",
-                btm_outer="0.0",
+                top_outer=phase,
+                top_inner=0.0,
+                btm_inner=phase3,
+                btm_outer=0.0,
             ),
         )
 

dodal/devices/i17/i17_apple2.py

@@ -1,4 +1,4 @@
-from dodal.devices.insertion_device.apple2_undulator import (
+from dodal.devices.insertion_device import (
     Apple2,
     Apple2Controller,
     Apple2PhasesVal,
@@ -56,11 +56,11 @@ class I17Apple2Controller(Apple2Controller[Apple2[UndulatorPhaseAxes]]):
 
     def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
         return Apple2Val(
-            gap=f"{gap:.6f}",
+            gap=gap,
             phase=Apple2PhasesVal(
-                top_outer=f"{phase:.6f}",
-                top_inner=f"{0.0:.6f}",
-                btm_inner=f"{phase:.6f}",
-                btm_outer=f"{0.0:.6f}",
+                top_outer=phase,
+                top_inner=0.0,
+                btm_inner=phase,
+                btm_outer=0.0,
             ),
         )