dls-dodal 1.43.0__py3-none-any.whl → 1.45.0__py3-none-any.whl

dodal/beamlines/i13_1.py

@@ -3,19 +3,20 @@ from pathlib import Path
 from ophyd_async.epics.adaravis import AravisDetector
 
 from dodal.common.beamlines.beamline_utils import (
-    device_instantiation,
+    device_factory,
     get_path_provider,
     set_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
 from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.i13_1.merlin import Merlin
 from dodal.devices.motors import XYZPositioner
 from dodal.log import set_beamline as set_log_beamline
-from dodal.utils import get_beamline_name
+from dodal.utils import BeamlinePrefix, get_beamline_name
 
 BL = get_beamline_name("i13-1")
+PREFIX_BL13I = BeamlinePrefix(BL)  # Can't use this yet as returns BL13I
+PREFIX = "BL13J"
 set_log_beamline(BL)
 set_utils_beamline(BL)
 set_path_provider(
@@ -27,59 +28,32 @@ set_path_provider(
 )
 
 
-def sample_xyz_stage(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> XYZPositioner:
-    return device_instantiation(
-        XYZPositioner,
-        prefix="BL13J-MO-PI-02:",
-        name="sample_xyz_stage",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-        bl_prefix=False,
-    )
+@device_factory()
+def sample_xyz_stage() -> XYZPositioner:
+    return XYZPositioner(prefix=f"{PREFIX}-MO-PI-02:")
 
 
-def sample_xyz_lab_fa_stage(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> XYZPositioner:
-    return device_instantiation(
-        XYZPositioner,
-        prefix="BL13J-MO-PI-02:FIXANG:",
-        name="sample_xyz_lab_fa_stage",
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
-        bl_prefix=False,
-    )
+@device_factory()
+def sample_xyz_lab_fa_stage() -> XYZPositioner:
+    return XYZPositioner(prefix=f"{PREFIX}-MO-PI-02:FIXANG:")
 
 
-def side_camera(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> AravisDetector:
-    return device_instantiation(
-        AravisDetector,
-        prefix="BL13J-OP-FLOAT-03:",
-        name="side_camera",
-        bl_prefix=False,
-        drv_suffix=CAM_SUFFIX,
-        fileio_suffix=HDF5_SUFFIX,
+@device_factory()
+def side_camera() -> AravisDetector:
+    return AravisDetector(
+        prefix=f"{PREFIX}-OP-FLOAT-03:",
+        drv_suffix="CAM:",
+        fileio_suffix="HDF5:",
         path_provider=get_path_provider(),
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
     )
 
 
-def merlin(
-    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> Merlin:
-    return device_instantiation(
-        Merlin,
-        prefix="BL13J-EA-DET-04:",
+@device_factory()
+def merlin() -> Merlin:
+    return Merlin(
+        prefix=f"{PREFIX}-EA-DET-04:",
         name="merlin",
-        bl_prefix=False,
-        drv_suffix=CAM_SUFFIX,
-        fileio_suffix=HDF5_SUFFIX,
+        drv_suffix="CAM:",
+        fileio_suffix="HDF5:",
         path_provider=get_path_provider(),
-        wait=wait_for_connection,
-        fake=fake_with_ophyd_sim,
     )

dodal/beamlines/i19_1.py

@@ -4,7 +4,9 @@ from dodal.common.beamlines.beamline_utils import (
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
-from dodal.devices.i19.shutter import HutchConditionalShutter, HutchState
+from dodal.devices.i19.beamstop import BeamStop
+from dodal.devices.i19.blueapi_device import HutchState
+from dodal.devices.i19.shutter import AccessControlledShutter
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVConfig
 from dodal.devices.synchrotron import Synchrotron
@@ -35,10 +37,20 @@ ZOOM_PARAMS_FILE = (
 DISPLAY_CONFIG = "/dls_sw/i19-1/software/daq_configuration/domain/display.configuration"
 
 
+# Needs to wait until enum is fixed on the beamline
+# See https://github.com/DiamondLightSource/dodal/issues/1150
+@device_factory(skip=True)
+def beamstop() -> BeamStop:
+    """Get the i19-1 beamstop device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i19-1, it will return the existing object.
+    """
+    return BeamStop(prefix=f"{PREFIX.beamline_prefix}-RS-ABSB-01:")
+
+
 @device_factory()
 def oav() -> OAV:
     return OAV(
-        prefix=f"{PREFIX.beamline_prefix}-DI-OAV-01:",
+        prefix=f"{PREFIX.beamline_prefix}-EA-OAV-01:",
         config=OAVConfig(ZOOM_PARAMS_FILE, DISPLAY_CONFIG),
     )
 
@@ -56,11 +68,11 @@ def zebra() -> Zebra:
 
 
 @device_factory()
-def shutter() -> HutchConditionalShutter:
-    """Get the i19-2 hutch shutter device, instantiate it if it hasn't already been.
+def shutter() -> AccessControlledShutter:
+    """Get the i19-1 hutch shutter device, instantiate it if it hasn't already been.
     If this is called when already instantiated, it will return the existing object.
     """
-    return HutchConditionalShutter(
+    return AccessControlledShutter(
         prefix=f"{PREFIX.beamline_prefix}-PS-SHTR-01:",
         hutch=HutchState.EH1,
     )

dodal/beamlines/i19_2.py

@@ -4,7 +4,9 @@ from dodal.common.beamlines.beamline_utils import (
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
-from dodal.devices.i19.shutter import HutchConditionalShutter, HutchState
+from dodal.devices.i19.beamstop import BeamStop
+from dodal.devices.i19.blueapi_device import HutchState
+from dodal.devices.i19.shutter import AccessControlledShutter
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.zebra.zebra import Zebra
 from dodal.devices.zebra.zebra_constants_mapping import (
@@ -30,6 +32,14 @@ I19_2_ZEBRA_MAPPING = ZebraMapping(
 )
 
 
+@device_factory()
+def beamstop() -> BeamStop:
+    """Get the i19-2 beamstop device, instantiate it if it hasn't already been.
+    If this is called when already instantiated in i19-2, it will return the existing object.
+    """
+    return BeamStop(prefix=f"{PREFIX.beamline_prefix}-OP-ABSB-02:")
+
+
 @device_factory()
 def zebra() -> Zebra:
     """Get the i19-2 zebra device, instantiate it if it hasn't already been.
@@ -43,11 +53,11 @@ def zebra() -> Zebra:
 
 
 @device_factory()
-def shutter() -> HutchConditionalShutter:
+def shutter() -> AccessControlledShutter:
     """Get the i19-2 hutch shutter device, instantiate it if it hasn't already been.
     If this is called when already instantiated, it will return the existing object.
     """
-    return HutchConditionalShutter(
+    return AccessControlledShutter(
         prefix=f"{PREFIX.beamline_prefix}-PS-SHTR-01:",
         hutch=HutchState.EH2,
     )

dodal/beamlines/i19_optics.py

@@ -5,7 +5,7 @@ from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
 from dodal.devices.hutch_shutter import HutchShutter
-from dodal.devices.i19.hutch_access import HutchAccessControl
+from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME, HutchAccessControl
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix
 
@@ -31,4 +31,6 @@ def access_control() -> HutchAccessControl:
     """Get a device that checks the active hutch for i19, instantiate it if it hasn't already been.
     If this is called when already instantiated, it will return the existing object.
     """
-    return HutchAccessControl(f"{PREFIX.beamline_prefix}-OP-STAT-01:", "access_control")
+    return HutchAccessControl(
+        f"{PREFIX.beamline_prefix}-OP-STAT-01:", ACCESS_DEVICE_NAME
+    )

dodal/beamlines/i20_1.py

@@ -32,7 +32,8 @@ set_path_provider(
 )
 
 
-@device_factory()
+# NOTE this is mock as we cannot move items on the beamline until we get sign-off to do so
+@device_factory(mock=True)
 def turbo_slit() -> TurboSlit:
     """
     turboslit for selecting energy from the polychromator

dodal/beamlines/i23.py

@@ -1,5 +1,6 @@
 from dodal.common.beamlines.beamline_utils import device_factory
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.motors import SixAxisGonio
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name, get_hostname
@@ -28,3 +29,12 @@ def oav_pin_tip_detection() -> PinTipDetection:
         f"{PREFIX.beamline_prefix}-DI-OAV-01:",
         "pin_tip_detection",
     )
+
+
+@device_factory()
+def gonio() -> SixAxisGonio:
+    """Get the i23 goniometer"""
+
+    return SixAxisGonio(
+        f"{PREFIX.beamline_prefix}-MO-GONIO-01:",
+    )

dodal/beamlines/p60.py

@@ -0,0 +1,21 @@
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.electron_analyser.vgscienta_analyser_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("p60")
+PREFIX = BeamlinePrefix(BL)
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+
+@device_factory()
+def analyser_driver() -> VGScientaAnalyserDriverIO:
+    return VGScientaAnalyserDriverIO(
+        name="analyser_driver", prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:"
+    )

dodal/common/data_util.py

@@ -0,0 +1,20 @@
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+TBaseModel = TypeVar("TBaseModel", bound=BaseModel)
+
+
+def load_json_file_to_class(
+    t: type[TBaseModel],
+    file: str,
+) -> TBaseModel:
+    with open(file) as f:
+        json_obj = f.read()
+    cls = t.model_validate_json(json_obj)
+    return cls
+
+
+def save_class_to_json_file(model: BaseModel, file: str) -> None:
+    with open(file, "w") as f:
+        f.write(model.model_dump_json())

dodal/common/signal_utils.py

@@ -2,22 +2,26 @@ from collections.abc import Callable, Coroutine
 from typing import Any
 
 from bluesky.protocols import Reading
-from ophyd_async.core import SignalDatatypeT, SignalR, SoftSignalBackend
+from ophyd_async.core import SignalDatatypeT, SignalR, SignalRW, SoftSignalBackend
+
+SetHardwareType = Callable[[SignalDatatypeT], Coroutine[Any, Any, None]]
 
 
 class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
     def __init__(
         self,
         get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
+        set_to_hardware_func: SetHardwareType | None = None,
         *args,
         **kwargs,
     ) -> None:
         self.get_from_hardware_func = get_from_hardware_func
+        self.set_to_hardware_func = set_to_hardware_func
         super().__init__(*args, **kwargs)
 
     async def _update_value(self):
         new_value = await self.get_from_hardware_func()
-        await self.put(new_value, True)
+        self.set_value(new_value)
 
     async def get_reading(self) -> Reading:
         await self._update_value()
@@ -27,8 +31,39 @@ class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
         await self._update_value()
         return await super().get_value()
 
+    async def put(self, value: SignalDatatypeT | None, wait: bool) -> None:
+        if self.set_to_hardware_func:
+            write_value = self.initial_value if value is None else value
+            await self.set_to_hardware_func(write_value)
+
+
+def create_rw_hardware_backed_soft_signal(
+    datatype: type[SignalDatatypeT],
+    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
+    set_to_hardware_func: SetHardwareType,
+    units: str | None = None,
+    precision: int | None = None,
+):
+    """Creates a soft signal that, when read will call the function passed into
+    `get_from_hardware_func` and return this. When set it will call `set_to_hardware_func`
+    and send something to the hardware.
+
+    This will allow you to make soft signals derived from arbitrary hardware signals.
+    However, calling subscribe on this signal does not give you a sensible value. See https://github.com/bluesky/ophyd-async/issues/525
+    for a more full solution.
+    """
+    return SignalRW(
+        backend=HardwareBackedSoftSignalBackend(
+            get_from_hardware_func,
+            set_to_hardware_func,
+            datatype,
+            units=units,
+            precision=precision,
+        )
+    )
+
 
-def create_hardware_backed_soft_signal(
+def create_r_hardware_backed_soft_signal(
     datatype: type[SignalDatatypeT],
     get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
     units: str | None = None,
@@ -44,6 +79,10 @@ def create_hardware_backed_soft_signal(
     """
     return SignalR(
         backend=HardwareBackedSoftSignalBackend(
-            get_from_hardware_func, datatype, units=units, precision=precision
+            get_from_hardware_func,
+            None,
+            datatype,
+            units=units,
+            precision=precision,
         )
     )

dodal/common/visit.py

@@ -3,8 +3,7 @@ from pathlib import Path
 from typing import Literal
 
 from aiohttp import ClientSession
-from event_model import RunStart
-from ophyd_async.core import FilenameProvider, PathInfo, PathProvider
+from ophyd_async.core import FilenameProvider, PathInfo
 from pydantic import BaseModel
 
 from dodal.common.types import UpdatingPathProvider
@@ -151,42 +150,3 @@ class StaticVisitPathProvider(UpdatingPathProvider):
         return PathInfo(
             directory_path=self._root, filename=self._filename_provider(device_name)
         )
-
-
-DEFAULT_TEMPLATE = "{device_name}-{instrument}-{scan_id}"
-
-
-class StartDocumentPathProvider(PathProvider):
-    """A PathProvider that sources from metadata in a RunStart document.
-
-    This uses metadata from a RunStart document to determine file names and data session
-    directories. The file naming defaults to "{device_name}-{instrument}-{scan_id}", so
-    the file name is incremented by scan number. A template can be included in the
-    StartDocument to allow for custom naming conventions.
-
-    """
-
-    def __init__(self) -> None:
-        self._doc = {}
-
-    def update_run(self, name: str, start_doc: RunStart) -> None:
-        """Cache a start document.
-
-        This can be plugged into the run engine's subscribe method.
-        """
-        if name == "start":
-            self._doc = start_doc
-
-    def __call__(self, device_name: str | None = None) -> PathInfo:
-        """Returns the directory path and filename for a given data_session.
-
-        The default template for file naming is: "{device_name}-{instrument}-{scan_id}"
-        however, this can be changed by providing a template in the start document. For
-        example: "template": "custom-{device_name}--{scan_id}".
-
-        If you do not provide a data_session_directory it will default to "/tmp".
-        """
-        template = self._doc.get("template", DEFAULT_TEMPLATE)
-        sub_path = template.format_map(self._doc | {"device_name": device_name})
-        data_session_directory = Path(self._doc.get("data_session_directory", "/tmp"))
-        return PathInfo(directory_path=data_session_directory, filename=sub_path)

dodal/devices/aperturescatterguard.py

@@ -12,7 +12,7 @@ from ophyd_async.core import (
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
 
@@ -164,7 +164,7 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.radius = create_hardware_backed_soft_signal(
+        self.radius = create_r_hardware_backed_soft_signal(
             float, self._get_current_radius, units="µm"
         )
         self._loaded_positions = loaded_positions
@@ -181,7 +181,7 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
         )
 
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.selected_aperture = create_hardware_backed_soft_signal(
+            self.selected_aperture = create_r_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )
 

dodal/devices/baton.py

@@ -0,0 +1,17 @@
+from typing import Annotated as A
+
+from ophyd_async.core import (
+    SignalRW,
+    StandardReadable,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import EpicsDevice, PvSuffix
+
+
+class Baton(StandardReadable, EpicsDevice):
+    requested_user: A[
+        SignalRW[str], PvSuffix("REQUESTED_USER"), Format.HINTED_UNCACHED_SIGNAL
+    ]
+    current_user: A[
+        SignalRW[str], PvSuffix("CURRENT_USER"), Format.HINTED_UNCACHED_SIGNAL
+    ]

dodal/devices/current_amplifiers/current_amplifier.py

@@ -23,7 +23,6 @@ class CurrentAmp(ABC, StandardReadable, Movable):
         super().__init__(name)
 
     @abstractmethod
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         """Increase gain, increment by 1 by default.
 
@@ -31,7 +30,6 @@ class CurrentAmp(ABC, StandardReadable, Movable):
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def decrease_gain(self, value: int = 1) -> None:
         """Decrease gain, decrement by 1 by default.
@@ -40,21 +38,18 @@ class CurrentAmp(ABC, StandardReadable, Movable):
             bool: True if success.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
-    async def get_gain(self) -> type[Enum]:
+    async def get_gain(self) -> Enum:
         """Get the current gain setting
 
         Returns:
             Enum: The member name of the current gain setting in gain_conversion_table.
         """
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_upperlimit(self) -> float:
         """Get the upper limit of the current amplifier"""
 
-    @AsyncStatus.wrap
     @abstractmethod
     async def get_lowerlimit(self) -> float:
         """Get the lower limit of the current amplifier"""

dodal/devices/current_amplifiers/current_amplifier_detector.py

@@ -92,8 +92,8 @@ class CurrentAmpDet(StandardReadable, Preparable):
             self.current_amp().get_gain(),
             self.counter().get_voltage_per_sec(),
         )
-        correction_factor = current_gain.value
-        corrected_current = voltage_per_sec / correction_factor
+        assert isinstance(current_gain.value, float)
+        corrected_current = voltage_per_sec / current_gain.value
         return corrected_current
 
     @AsyncStatus.wrap

dodal/devices/current_amplifiers/femto.py

@@ -114,7 +114,6 @@ class FemtoDDPCA(CurrentAmp):
         # wait for current amplifier's bandpass filter to settle.
         await asyncio.sleep(self.raise_timetable[SEN_setting].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -122,7 +121,6 @@ class FemtoDDPCA(CurrentAmp):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -130,14 +128,11 @@ class FemtoDDPCA(CurrentAmp):
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         return self.gain_conversion_table[(await self.gain.get_value()).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

dodal/devices/current_amplifiers/sr570.py

@@ -178,7 +178,6 @@ class SR570(CurrentAmp):
         )
         await asyncio.sleep(self.raise_timetable[coarse_gain.name].value)
 
-    @AsyncStatus.wrap
     async def increase_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain += value
@@ -189,7 +188,6 @@ class SR570(CurrentAmp):
             raise ValueError("Gain at max value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def decrease_gain(self, value=3) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])
         current_gain -= value
@@ -198,17 +196,14 @@ class SR570(CurrentAmp):
             raise ValueError("Gain at min value")
         await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
 
-    @AsyncStatus.wrap
     async def get_gain(self) -> Enum:
         result = await asyncio.gather(
             self.coarse_gain.get_value(), self.fine_gain.get_value()
         )
         return self.gain_conversion_table[self.combined_table(result).name]
 
-    @AsyncStatus.wrap
     async def get_upperlimit(self) -> float:
         return self.upperlimit
 
-    @AsyncStatus.wrap
     async def get_lowerlimit(self) -> float:
         return self.lowerlimit

dodal/devices/detector/det_dist_to_beam_converter.py

@@ -1,6 +1,9 @@
 from enum import Enum
 
-from numpy import interp, loadtxt
+from dodal.devices.util.lookup_tables import (
+    linear_extrapolation_lut,
+    parse_lookup_table,
+)
 
 
 class Axis(Enum):
@@ -11,12 +14,20 @@ class Axis(Enum):
 class DetectorDistanceToBeamXYConverter:
     def __init__(self, lookup_file: str):
         self.lookup_file: str = lookup_file
-        self.lookup_table_values: list = self.parse_table()
+        lookup_table_columns: list = parse_lookup_table(self.lookup_file)
+        self._d_to_x = linear_extrapolation_lut(
+            lookup_table_columns[0], lookup_table_columns[1]
+        )
+        self._d_to_y = linear_extrapolation_lut(
+            lookup_table_columns[0], lookup_table_columns[2]
+        )
 
     def get_beam_xy_from_det_dist(self, det_dist_mm: float, beam_axis: Axis) -> float:
-        beam_axis_values = self.lookup_table_values[beam_axis.value]
-        det_dist_array = self.lookup_table_values[0]
-        return float(interp(det_dist_mm, det_dist_array, beam_axis_values))
+        return (
+            self._d_to_x(det_dist_mm)
+            if beam_axis == Axis.X_AXIS
+            else self._d_to_y(det_dist_mm)
+        )
 
     def get_beam_axis_pixels(
         self,
@@ -41,21 +52,3 @@ class DetectorDistanceToBeamXYConverter:
         return self.get_beam_axis_pixels(
             det_distance, image_size_pixels, det_dim, Axis.X_AXIS
         )
-
-    def reload_lookup_table(self):
-        self.lookup_table_values = self.parse_table()
-
-    def parse_table(self) -> list:
-        rows = loadtxt(self.lookup_file, delimiter=" ", comments=["#", "Units"])
-        columns = list(zip(*rows, strict=False))
-
-        return columns
-
-    def __eq__(self, other):
-        if not isinstance(other, DetectorDistanceToBeamXYConverter):
-            return NotImplemented
-        if self.lookup_file != other.lookup_file:
-            return False
-        if self.lookup_table_values != other.lookup_table_values:
-            return False
-        return True

dodal/devices/detector/detector.py

@@ -1,4 +1,5 @@
 from enum import Enum, auto
+from functools import cached_property
 from pathlib import Path
 
 from pydantic import BaseModel, Field, field_serializer, field_validator
@@ -49,7 +50,7 @@ class DetectorParams(BaseModel):
         False  # Remove in https://github.com/DiamondLightSource/hyperion/issues/1395
     )
 
-    @property
+    @cached_property
     def beam_xy_converter(self) -> DetectorDistanceToBeamXYConverter:
         return DetectorDistanceToBeamXYConverter(self.det_dist_to_beam_converter_path)