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

dodal/devices/beamsize/beamsize.py

@@ -0,0 +1,6 @@
+from ophyd_async.core import SignalR, StandardReadable
+
+
+class BeamsizeBase(StandardReadable):
+    x_um: SignalR[float]
+    y_um: SignalR[float]

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/detector/det_resolution.py

@@ -10,14 +10,16 @@ def _get_detector_radius_mm(detector_params: DetectorParams):
     return 0.5 * _get_detector_max_size_mm(detector_params)
 
 
-def _get_detector_max_size_mm(detector_params):
+def _get_detector_max_size_mm(detector_params: DetectorParams):
     return max(
         detector_params.detector_size_constants.det_dimension.width,
         detector_params.detector_size_constants.det_dimension.height,
     )
 
 
-def _get_beam_xy_accounting_for_roi(detector_params, det_distance_mm):
+def _get_beam_xy_accounting_for_roi(
+    detector_params: DetectorParams, det_distance_mm: float
+):
     beam_x = detector_params.beam_xy_converter.get_beam_xy_from_det_dist(
         det_distance_mm, Axis.X_AXIS
     )

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/fast_grid_scan.py

@@ -1,5 +1,7 @@
 import asyncio
 from abc import ABC, abstractmethod
+from functools import partial
+from math import isclose
 from typing import Generic, TypeVar
 
 import numpy as np
@@ -307,13 +309,23 @@ class FastGridScanCommon(
         set_statuses = []
 
         LOGGER.info("Applying gridscan parameters...")
+
         # Create arguments for bps.mv
         for key, signal in self._movable_params.items():
             param_value = value.__dict__[key]
-            set_statuses.append(await set_and_wait_for_value(signal, param_value))  # type: ignore
+
+            matcher = partial(isclose, param_value, abs_tol=0.001)
+
+            set_statuses.append(
+                set_and_wait_for_value(
+                    signal,  # type: ignore
+                    param_value,
+                    match_value=matcher,
+                )
+            )
 
         # Counter should always start at 0
-        set_statuses.append(await set_and_wait_for_value(self.position_counter, 0))
+        set_statuses.append(set_and_wait_for_value(self.position_counter, 0))
 
         LOGGER.info("Gridscan parameters applied, waiting for sets to complete...")
 

dodal/devices/i03/beamsize.py

@@ -0,0 +1,35 @@
+from ophyd_async.core import Reference, derived_signal_r
+
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamsize.beamsize import BeamsizeBase
+from dodal.devices.i03.constants import BeamsizeConstants
+
+
+class Beamsize(BeamsizeBase):
+    def __init__(self, aperture_scatterguard: ApertureScatterguard, name=""):
+        super().__init__(name=name)
+        self._aperture_scatterguard_ref = Reference(aperture_scatterguard)
+
+        with self.add_children_as_readables():
+            self.x_um = derived_signal_r(
+                self._get_beamsize_x,
+                aperture_radius=self._aperture_scatterguard_ref().radius,
+                derived_units="µm",
+            )
+            self.y_um = derived_signal_r(
+                self._get_beamsize_y,
+                aperture_radius=self._aperture_scatterguard_ref().radius,
+                derived_units="µm",
+            )
+
+    def _get_beamsize_x(
+        self,
+        aperture_radius: float,
+    ) -> float:
+        return min(aperture_radius, BeamsizeConstants.BEAM_WIDTH_UM)
+
+    def _get_beamsize_y(
+        self,
+        aperture_radius: float,
+    ) -> float:
+        return min(aperture_radius, BeamsizeConstants.BEAM_HEIGHT_UM)

dodal/devices/i03/constants.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class BeamsizeConstants:
+    BEAM_WIDTH_UM = 80.0
+    BEAM_HEIGHT_UM = 20.0

dodal/devices/i03/undulator_dcm.py

@@ -5,7 +5,7 @@ from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 from dodal.devices.i03.dcm import DCM
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.log import LOGGER
 
 ENERGY_TIMEOUT_S: float = 30.0
@@ -31,7 +31,7 @@ class UndulatorDCM(StandardReadable, Movable[float]):
 
     def __init__(
         self,
-        undulator: Undulator,
+        undulator: UndulatorInKeV,
         dcm: DCM,
         daq_configuration_path: str,
         name: str = "",

dodal/devices/i04/beamsize.py

@@ -0,0 +1,45 @@
+from ophyd_async.core import Reference, derived_signal_r
+
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.beamsize.beamsize import BeamsizeBase
+from dodal.devices.i04.transfocator import Transfocator
+
+
+class Beamsize(BeamsizeBase):
+    def __init__(
+        self,
+        transfocator: Transfocator,
+        aperture_scatterguard: ApertureScatterguard,
+        name="",
+    ):
+        super().__init__(name=name)
+        self._transfocator_ref = Reference(transfocator)
+        self._aperture_scatterguard_ref = Reference(aperture_scatterguard)
+
+        with self.add_children_as_readables():
+            self.x_um = derived_signal_r(
+                self._get_beamsize_x,
+                transfocator_size_x=self._transfocator_ref().current_horizontal_size_rbv,
+                aperture_radius=self._aperture_scatterguard_ref().radius,
+                derived_units="µm",
+            )
+            self.y_um = derived_signal_r(
+                self._get_beamsize_y,
+                transfocator_size_y=self._transfocator_ref().current_vertical_size_rbv,
+                aperture_radius=self._aperture_scatterguard_ref().radius,
+                derived_units="µm",
+            )
+
+    def _get_beamsize_x(
+        self,
+        transfocator_size_x: float,
+        aperture_radius: float,
+    ) -> float:
+        return min(transfocator_size_x, aperture_radius)
+
+    def _get_beamsize_y(
+        self,
+        transfocator_size_y: float,
+        aperture_radius: float,
+    ) -> float:
+        return min(transfocator_size_y, aperture_radius)

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/i04/murko_results.py

@@ -1,5 +1,6 @@
 import json
 import pickle
+import time
 from dataclasses import dataclass
 from enum import Enum
 from typing import TypedDict
@@ -21,6 +22,7 @@ from dodal.devices.oav.oav_calculations import (
 from dodal.log import LOGGER
 
 NO_MURKO_RESULT = (-1, -1)
+RESULTS_COMPLETE_MESSAGE = "murko_results_complete"
 
 
 class MurkoMetadata(TypedDict):
@@ -71,7 +73,8 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
     solutions for y and z can be calculated using numpy's linear algebra library.
     """
 
-    TIMEOUT_S = 2
+    GET_MESSAGE_TIMEOUT_S = 2
+    RESULTS_COMPLETE_TIMEOUT_S = 5
     PERCENTAGE_TO_USE = 25
     LEFTMOST_PIXEL_TO_USE = 10
     NUMBER_OF_WRONG_RESULTS_TO_LOG = 5
@@ -82,7 +85,6 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         redis_password=RedisConstants.REDIS_PASSWORD,
         redis_db=RedisConstants.MURKO_REDIS_DB,
         name="",
-        stop_angle=350,
     ):
         self.redis_client = StrictRedis(
             host=redis_host,
@@ -91,7 +93,6 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         )
         self.pubsub = self.redis_client.pubsub()
         self.sample_id = soft_signal_rw(str)  # Should get from redis
-        self.stop_angle = stop_angle
 
         self._reset()
 
@@ -103,7 +104,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         super().__init__(name=name)
 
     def _reset(self):
-        self._last_omega = 0
+        self._last_omega = None
         self._results: list[MurkoResult] = []
 
     @AsyncStatus.wrap
@@ -120,14 +121,27 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
     @AsyncStatus.wrap
     async def trigger(self):
-        # Wait for results
         sample_id = await self.sample_id.get_value()
-        while self._last_omega < self.stop_angle:
+        t_last_result = time.time()
+        while True:
+            if time.time() - t_last_result > self.RESULTS_COMPLETE_TIMEOUT_S:
+                LOGGER.warning(
+                    f"Time since last result > {self.RESULTS_COMPLETE_TIMEOUT_S}, expected to receive {RESULTS_COMPLETE_MESSAGE}"
+                )
+                break
             # waits here for next batch to be received
-            message = await self.pubsub.get_message(timeout=self.TIMEOUT_S)
-            if message is None:
-                continue
-            await self.process_batch(message, sample_id)
+            message = await self.pubsub.get_message(timeout=self.GET_MESSAGE_TIMEOUT_S)
+            if message and message["type"] == "message":
+                t_last_result = time.time()
+                data = pickle.loads(message["data"])
+
+                if data == RESULTS_COMPLETE_MESSAGE:
+                    LOGGER.info(
+                        f"Received results complete message: {RESULTS_COMPLETE_MESSAGE}"
+                    )
+                    break
+
+                await self.process_batch(data, sample_id)
 
         if not self._results:
             raise NoResultsFoundError("No results retrieved from Murko")
@@ -155,22 +169,18 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
                 f"murko:{sample_id}:metadata", result.uuid, json.dumps(result.metadata)
             )
 
-    async def process_batch(self, message: dict | None, sample_id: str):
-        if message and message["type"] == "message":
-            batch_results: list[dict] = pickle.loads(message["data"])
-            for results in batch_results:
-                for uuid, result in results.items():
-                    if metadata_str := await self.redis_client.hget(  # type: ignore
-                        f"murko:{sample_id}:metadata", uuid
-                    ):
-                        LOGGER.info(
-                            f"Found metadata for uuid {uuid}, processing result"
-                        )
-                        self.process_result(
-                            result, MurkoMetadata(json.loads(metadata_str))
-                        )
-                    else:
-                        LOGGER.info(f"Found no metadata for uuid {uuid}")
+    async def process_batch(
+        self, batch_results: list[tuple[str, dict]], sample_id: str
+    ):
+        for result_with_uuid in batch_results:
+            uuid, result = result_with_uuid
+            if metadata_str := await self.redis_client.hget(  # type: ignore
+                f"murko:{sample_id}:metadata", uuid
+            ):
+                LOGGER.info(f"Found metadata for uuid {uuid}, processing result")
+                self.process_result(result, MurkoMetadata(json.loads(metadata_str)))
+            else:
+                LOGGER.info(f"Found no metadata for uuid {uuid}")
 
     def process_result(self, result: dict, metadata: MurkoMetadata):
         """Uses the 'most_likely_click' coordinates from Murko to calculate the

dodal/devices/i04/transfocator.py

@@ -1,5 +1,4 @@
 import asyncio
-import math
 
 from ophyd_async.core import (
     AsyncStatus,
@@ -9,6 +8,7 @@ from ophyd_async.core import (
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
+from dodal.common.device_utils import periodic_reminder
 from dodal.log import LOGGER
 
 
@@ -23,15 +23,15 @@ class Transfocator(StandardReadable):
     """
 
     def __init__(self, prefix: str, name: str = ""):
+        self._vert_size_calc_sp = epics_signal_rw(float, prefix + "VERT_REQ")
+        self._num_lenses_calc_rbv = epics_signal_r(float, prefix + "LENS_PRED")
+        self.start = epics_signal_rw(int, prefix + "START.PROC")
+        self.start_rbv = epics_signal_r(int, prefix + "START_RBV")
+
         with self.add_children_as_readables():
-            self.beamsize_set_microns = epics_signal_rw(float, prefix + "VERT_REQ")
-            self.predicted_vertical_num_lenses = epics_signal_rw(
-                float, prefix + "LENS_PRED"
-            )
             self.number_filters_sp = epics_signal_rw(int, prefix + "NUM_FILTERS")
-            self.start = epics_signal_rw(int, prefix + "START.PROC")
-            self.start_rbv = epics_signal_r(int, prefix + "START_RBV")
-            self.vertical_lens_rbv = epics_signal_r(float, prefix + "VER")
+            self.current_horizontal_size_rbv = epics_signal_r(float, prefix + "HOR")
+            self.current_vertical_size_rbv = epics_signal_r(float, prefix + "VER")
 
         self.TIMEOUT = 120
 
@@ -41,14 +41,10 @@ class Transfocator(StandardReadable):
         # We can only put an integer number of lenses in the beam but the
         # calculation in the IOC returns the theoretical float number of lenses
         value = round(value)
-        LOGGER.info(f"Transfocator setting {value} filters")
         await self.number_filters_sp.set(value)
         await self.start.set(1)
-        LOGGER.info("Waiting for start_rbv to change to 1")
         await wait_for_value(self.start_rbv, 1, self.TIMEOUT)
-        LOGGER.info("Waiting for start_rbv to change to 0")
         await wait_for_value(self.start_rbv, 0, self.TIMEOUT)
-        self.latest_pred_vertical_num_lenses = value
 
     @AsyncStatus.wrap
     async def set(self, value: float):
@@ -59,29 +55,27 @@ class Transfocator(StandardReadable):
         4. Start the device moving
         5. Wait for the start_rbv goes high and low again
         """
-        self.latest_pred_vertical_num_lenses = (
-            await self.predicted_vertical_num_lenses.get_value()
-        )
-
         LOGGER.info(f"Transfocator setting {value} beamsize")
 
-        if await self.beamsize_set_microns.get_value() != value:
-            # Logic in the IOC calculates predicted_vertical_num_lenses when beam_set_microns changes
+        # Logic in the IOC calculates _num_lenses_calc_rbv when _vert_size_calc_sp changes
+
+        # Register an observer before setting _vert_size_calc_sp to ensure we don't miss changes
+        num_lenses_calc_iterator = observe_value(
+            self._num_lenses_calc_rbv, timeout=self.TIMEOUT
+        )
+
+        await anext(num_lenses_calc_iterator)
+        await self._vert_size_calc_sp.set(value)
+        calc_lenses = await anext(num_lenses_calc_iterator)
 
-            # Register an observer before setting beamsize_set_microns to ensure we don't miss changes
-            predicted_vertical_num_lenses_iterator = observe_value(
-                self.predicted_vertical_num_lenses, timeout=self.TIMEOUT
-            )
-            # Keep initial prediction before setting to later compare with change after setting
-            current_prediction = await anext(predicted_vertical_num_lenses_iterator)
-            await self.beamsize_set_microns.set(value)
-            accepted_prediction = await anext(predicted_vertical_num_lenses_iterator)
-            if not math.isclose(current_prediction, accepted_prediction, abs_tol=1e-8):
-                await self.set_based_on_prediction(accepted_prediction)
+        async with periodic_reminder(
+            f"Waiting for transfocator to insert {calc_lenses} into beam"
+        ):
+            await self.set_based_on_prediction(calc_lenses)
 
         number_filters_rbv, vertical_lens_size_rbv = await asyncio.gather(
             self.number_filters_sp.get_value(),
-            self.vertical_lens_rbv.get_value(),
+            self.current_vertical_size_rbv.get_value(),
         )
 
         LOGGER.info(