dls-dodal 1.36.3__py3-none-any.whl → 1.38.0__py3-none-any.whl

dodal/devices/i04/transfocator.py

@@ -1,14 +1,18 @@
+import asyncio
 import math
-from time import sleep, time
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal, EpicsSignalRO, Kind
-from ophyd.status import DeviceStatus
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    observe_value,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.log import LOGGER
 
 
-class Transfocator(Device):
+class Transfocator(StandardReadable):
     """The transfocator is a device that puts a number of lenses in the beam to change
     its shape.
 
@@ -18,34 +22,50 @@ class Transfocator(Device):
         my_transfocator.set(vert_beamsize_microns)
     """
 
-    beamsize_set_microns = Cpt(EpicsSignal, "VERT_REQ", kind=Kind.hinted)
-    predicted_vertical_num_lenses = Cpt(EpicsSignal, "LENS_PRED")
-
-    number_filters_sp = Cpt(EpicsSignal, "NUM_FILTERS")
-
-    start = Cpt(EpicsSignal, "START.PROC")
-    start_rbv = Cpt(EpicsSignalRO, "START_RBV")
-
-    vertical_lens_rbv = Cpt(EpicsSignalRO, "VER", kind=Kind.hinted)
+    def __init__(self, prefix: str, name: str = ""):
+        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")
 
-    TIMEOUT = 120
-    _POLLING_WAIT = 0.01
+        self.TIMEOUT = 120
 
-    def polling_wait_on_start_rbv(self, for_value):
-        # For some reason couldn't get monitors working on START_RBV
-        # (See https://github.com/DiamondLightSource/dodal/issues/152)
-        start_time = time()
-        while time() < start_time + self.TIMEOUT:
-            RBV_value = self.start_rbv.get()
-            if RBV_value == for_value:
-                return
-            sleep(self._POLLING_WAIT)
+        super().__init__(name=name)
 
-        # last try
-        if self.start_rbv.get() != for_value:
-            raise TimeoutError()
+    async def _observe_beamsize_microns(self):
+        is_set_filters_done = False
 
-    def set(self, beamsize_microns: float) -> DeviceStatus:
+        async def set_based_on_prediction(value: float):
+            if not math.isclose(
+                self.latest_pred_vertical_num_lenses, value, abs_tol=1e-8
+            ):
+                # 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
+                nonlocal is_set_filters_done
+                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
+                is_set_filters_done = True
+
+        # The value hasn't changed so assume the device is already set up correctly
+        async for value in observe_value(self.predicted_vertical_num_lenses):
+            await set_based_on_prediction(value)
+            if is_set_filters_done:
+                break
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
         """To set the beamsize on the transfocator we must:
         1. Set the beamsize in the calculator part of the transfocator
         2. Get the predicted number of lenses needed from this calculator
@@ -53,30 +73,24 @@ class Transfocator(Device):
         4. Start the device moving
         5. Wait for the start_rbv goes high and low again
         """
-        subscriber: int
-        status = DeviceStatus(self, timeout=self.TIMEOUT)
+        self.latest_pred_vertical_num_lenses = (
+            await self.predicted_vertical_num_lenses.get_value()
+        )
 
-        def set_based_on_predicition(old_value, value, *args, **kwargs):
-            if not math.isclose(old_value, value, abs_tol=1e-8):
-                self.predicted_vertical_num_lenses.unsubscribe(subscriber)
+        LOGGER.info(f"Transfocator setting {value} beamsize")
 
-                # 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")
-                self.number_filters_sp.set(value).wait()
-                self.start.set(1).wait()
-                self.polling_wait_on_start_rbv(1)
-                self.polling_wait_on_start_rbv(0)
-            # The value hasn't changed so assume the device is already set up correctly
-            status.set_finished()
-
-        LOGGER.info(f"Transfocator setting {beamsize_microns} beamsize")
-        if self.beamsize_set_microns.get() != beamsize_microns:
-            subscriber = self.predicted_vertical_num_lenses.subscribe(
-                set_based_on_predicition, run=False
+        if await self.beamsize_set_microns.get_value() != value:
+            # Logic in the IOC calculates predicted_vertical_num_lenses when beam_set_microns changes
+            await asyncio.gather(
+                self.beamsize_set_microns.set(value),
+                self._observe_beamsize_microns(),
             )
-            self.beamsize_set_microns.set(beamsize_microns)
-        else:
-            status.set_finished()
-        return status
+
+        number_filters_rbv, vertical_lens_size_rbv = await asyncio.gather(
+            self.number_filters_sp.get_value(),
+            self.vertical_lens_rbv.get_value(),
+        )
+
+        LOGGER.info(
+            f"Transfocator set complete. Number of filters is: {number_filters_rbv} and Vertical beam size is: {vertical_lens_size_rbv}"
+        )

dodal/devices/i10/rasor/rasor_current_amp.py

@@ -0,0 +1,72 @@
+from ophyd_async.core import Device
+
+from dodal.devices.current_amplifiers import (
+    SR570,
+    Femto3xxGainTable,
+    Femto3xxGainToCurrentTable,
+    Femto3xxRaiseTime,
+    FemtoDDPCA,
+    SR570FineGainTable,
+    SR570FullGainTable,
+    SR570GainTable,
+    SR570GainToCurrentTable,
+    SR570RaiseTimeTable,
+)
+
+
+class RasorFemto(Device):
+    def __init__(self, prefix: str, suffix: str = "GAIN", name: str = "") -> None:
+        self.ca1 = FemtoDDPCA(
+            prefix + "-01:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        self.ca2 = FemtoDDPCA(
+            prefix + "-02:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        self.ca3 = FemtoDDPCA(
+            prefix + "-03:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        super().__init__(name)
+
+
+class RasorSR570(Device):
+    def __init__(self, prefix: str, suffix: str = "SENS:SEL", name: str = "") -> None:
+        self.ca1 = SR570(
+            prefix + "-04:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        self.ca2 = SR570(
+            prefix + "-05:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        self.ca3 = SR570(
+            prefix + "-06:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        super().__init__(name)

dodal/devices/i10/rasor/rasor_motors.py

@@ -0,0 +1,62 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class PinHole(StandardReadable):
+    "Two motors stage for rasor pinhole"
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+        super().__init__(name=name)
+
+
+class Diffractometer(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.tth = Motor(prefix + "TWOTHETA")
+            self.th = Motor(prefix + "THETA")
+            self.chi = Motor(prefix + "CHI")
+            self.chamber_x = Motor(prefix + "X")
+            self.alpha = Motor(prefix + "ALPHA")
+        super().__init__(name=name)
+
+
+class DetSlits(StandardReadable):
+    "Detector slits"
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.upstream = Motor(prefix + "1:TRANS")
+            self.downstream = Motor(prefix + "2:TRANS")
+        super().__init__(name=name)
+
+
+class PaStage(StandardReadable):
+    "Rasor detector stage"
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.ttp = Motor(prefix + "TWOTHETA")
+            self.thp = Motor(prefix + "THETA")
+            self.py = Motor(prefix + "Y")
+            self.pz = Motor(prefix + "Z")
+            self.eta = Motor(prefix + "ETA")
+        super().__init__(name=name)

dodal/devices/i10/rasor/rasor_scaler_cards.py

@@ -0,0 +1,12 @@
+from ophyd_async.core import Device
+
+from dodal.devices.current_amplifiers import StruckScaler
+
+
+class RasorScalerCard1(Device):
+    def __init__(self, prefix, name: str = "") -> None:
+        self.mon = StruckScaler(prefix=prefix, suffix=".16")
+        self.det = StruckScaler(prefix=prefix, suffix=".17")
+        self.fluo = StruckScaler(prefix=prefix, suffix=".18")
+        self.drain = StruckScaler(prefix=prefix, suffix=".19")
+        super().__init__(name)

dodal/devices/i13_1/merlin.py

@@ -0,0 +1,33 @@
+from ophyd_async.core import PathProvider, StandardDetector
+from ophyd_async.epics import adcore
+
+from dodal.devices.i13_1.merlin_controller import MerlinController
+from dodal.devices.i13_1.merlin_io import MerlinDriverIO
+
+
+class Merlin(StandardDetector):
+    _controller: MerlinController
+    _writer: adcore.ADHDFWriter
+
+    def __init__(
+        self,
+        prefix: str,
+        path_provider: PathProvider,
+        drv_suffix="CAM:",
+        hdf_suffix="HDF:",
+        name: str = "",
+    ):
+        self.drv = MerlinDriverIO(prefix + drv_suffix)
+        self.hdf = adcore.NDFileHDFIO(prefix + hdf_suffix)
+
+        super().__init__(
+            MerlinController(self.drv),
+            adcore.ADHDFWriter(
+                self.hdf,
+                path_provider,
+                lambda: self.name,
+                adcore.ADBaseDatasetDescriber(self.drv),
+            ),
+            config_sigs=(self.drv.acquire_period, self.drv.acquire_time),
+            name=name,
+        )

dodal/devices/i13_1/merlin_controller.py

@@ -0,0 +1,52 @@
+import asyncio
+import logging
+
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DetectorController,
+    TriggerInfo,
+)
+from ophyd_async.epics import adcore
+
+from dodal.devices.i13_1.merlin_io import MerlinDriverIO, MerlinImageMode
+
+
+class MerlinController(DetectorController):
+    def __init__(
+        self,
+        driver: MerlinDriverIO,
+        good_states: frozenset[adcore.DetectorState] = adcore.DEFAULT_GOOD_STATES,
+    ) -> None:
+        self.driver = driver
+        self.good_states = good_states
+        self.frame_timeout: float = 0
+        self._arm_status: AsyncStatus | None = None
+        for drv_child in self.driver.children():
+            logging.debug(drv_child)
+
+    def get_deadtime(self, exposure: float | None) -> float:
+        return 0.002
+
+    async def prepare(self, trigger_info: TriggerInfo):
+        self.frame_timeout = (
+            DEFAULT_TIMEOUT + await self.driver.acquire_time.get_value()
+        )
+        await asyncio.gather(
+            self.driver.num_images.set(trigger_info.total_number_of_triggers),
+            self.driver.image_mode.set(MerlinImageMode.MULTIPLE),
+        )
+
+    async def arm(self):
+        self._arm_status = await adcore.start_acquiring_driver_and_ensure_status(
+            self.driver, good_states=self.good_states, timeout=self.frame_timeout
+        )
+
+    async def wait_for_idle(self):
+        if self._arm_status:
+            await self._arm_status
+
+    async def disarm(self):
+        # We can't use caput callback as we already used it in arm() and we can't have
+        # 2 or they will deadlock
+        await adcore.stop_busy_record(self.driver.acquire, False, timeout=1)

dodal/devices/i13_1/merlin_io.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import StrictEnum
+from ophyd_async.epics import adcore
+from ophyd_async.epics.core import epics_signal_rw_rbv
+
+
+class MerlinImageMode(StrictEnum):
+    SINGLE = "Single"
+    MULTIPLE = "Multiple"
+    CONTINUOUS = "Continuous"
+    THRESHOLD = "Threshold"
+    BACKGROUND = "Background"
+
+
+class MerlinDriverIO(adcore.ADBaseIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        super().__init__(prefix, name)
+        self.image_mode = epics_signal_rw_rbv(MerlinImageMode, prefix + "ImageMode")

dodal/devices/i24/beam_center.py

@@ -7,6 +7,6 @@ from ophyd_async.epics.core import epics_signal_rw
 
 class DetectorBeamCenter(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:
-        self.beam_x = epics_signal_rw(float, prefix + "BeamX")
+        self.beam_x = epics_signal_rw(float, prefix + "BeamX")  # in pixels
         self.beam_y = epics_signal_rw(float, prefix + "BeamY")
         super().__init__(name)

dodal/devices/p45.py

@@ -1,44 +1,55 @@
-from ophyd import Component as Cpt
-from ophyd import EpicsMotor, MotorBundle
-from ophyd.areadetector.base import ADComponent as Cpt
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
 
 
-class SampleY(MotorBundle):
+class SampleY(StandardReadable):
     """
     Motors for controlling the sample's y position and stretch in the y axis.
     """
 
-    base = Cpt(EpicsMotor, "CS:Y")
-    stretch = Cpt(EpicsMotor, "CS:Y:STRETCH")
-    top = Cpt(EpicsMotor, "Y:TOP")
-    bottom = Cpt(EpicsMotor, "Y:BOT")
+    def __init__(self, prefix: str, name="") -> None:
+        with self.add_children_as_readables():
+            self.base = Motor(prefix + "CS:Y")
+            self.stretch = Motor(prefix + "CS:Y:STRETCH")
+            self.top = Motor(prefix + "Y:TOP")
+            self.bottom = Motor(prefix + "Y:BOT")
+            super().__init__(name=name)
 
 
-class SampleTheta(MotorBundle):
+class SampleTheta(StandardReadable):
     """
     Motors for controlling the sample's theta position and skew
     """
 
-    base = Cpt(EpicsMotor, "THETA:POS")
-    skew = Cpt(EpicsMotor, "THETA:SKEW")
-    top = Cpt(EpicsMotor, "THETA:TOP")
-    bottom = Cpt(EpicsMotor, "THETA:BOT")
+    def __init__(self, prefix: str, name="") -> None:
+        with self.add_children_as_readables():
+            self.base = Motor(prefix + "THETA:POS")
+            self.skew = Motor(prefix + "THETA:SKEW")
+            self.top = Motor(prefix + "THETA:TOP")
+            self.bottom = Motor(prefix + "THETA:BOT")
+            super().__init__(name=name)
 
 
-class TomoStageWithStretchAndSkew(MotorBundle):
+class TomoStageWithStretchAndSkew(StandardReadable):
     """
     Grouping of motors for the P45 tomography stage
     """
 
-    x = Cpt(EpicsMotor, "X")
-    y = Cpt(SampleY, "")
-    theta = Cpt(SampleTheta, "")
+    def __init__(self, prefix: str, name="") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "X")
+            self.y = SampleY(prefix)
+            self.theta = SampleTheta(prefix)
+            super().__init__(name=name)
 
 
-class Choppers(MotorBundle):
+class Choppers(StandardReadable):
     """
     Grouping for the P45 chopper motors
     """
 
-    x = Cpt(EpicsMotor, "ENDAT")
-    y = Cpt(EpicsMotor, "BISS")
+    def __init__(self, prefix: str, name="") -> None:
+        with self.add_children_as_readables():
+            self.x = Motor(prefix + "ENDAT")
+            self.y = Motor(prefix + "BISS")
+            super().__init__(name=name)

dodal/devices/p99/sample_stage.py

@@ -1,5 +1,5 @@
-from ophyd_async.core import StandardReadable, SubsetEnum
-from ophyd_async.epics.core import epics_signal_rw, epics_signal_rw_rbv
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw_rbv
 
 
 class SampleAngleStage(StandardReadable):
@@ -9,29 +9,3 @@ class SampleAngleStage(StandardReadable):
             self.roll = epics_signal_rw_rbv(float, prefix + "WRITEROLL", ":RBV")
             self.pitch = epics_signal_rw_rbv(float, prefix + "WRITEPITCH", ":RBV")
         super().__init__(name=name)
-
-
-class p99StageSelections(SubsetEnum):
-    EMPTY = "Empty"
-    MN5UM = "Mn 5um"
-    FE = "Fe (empty)"
-    CO5UM = "Co 5um"
-    NI5UM = "Ni 5um"
-    CU5UM = "Cu 5um"
-    ZN5UM = "Zn 5um"
-    ZR = "Zr (empty)"
-    MO = "Mo (empty)"
-    RH = "Rh (empty)"
-    PD = "Pd (empty)"
-    AG = "Ag (empty)"
-    CD25UM = "Cd 25um"
-    W = "W (empty)"
-    PT = "Pt (empty)"
-    USER = "User"
-
-
-class FilterMotor(StandardReadable):
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables():
-            self.user_setpoint = epics_signal_rw(p99StageSelections, prefix)
-        super().__init__(name=name)

dodal/devices/robot.py

@@ -70,8 +70,8 @@ class BartRobot(StandardReadable, Movable):
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
         self.error_str = epics_signal_r(str, prefix + "PRG_ERR_MSG")
-        # Change error_code to int type when https://github.com/bluesky/ophyd-async/issues/280 released
-        self.error_code = epics_signal_r(float, prefix + "PRG_ERR_CODE")
+        self.error_code = epics_signal_r(int, prefix + "PRG_ERR_CODE")
+        self.reset = epics_signal_x(prefix + "RESET.PROC")
         super().__init__(name=name)
 
     async def pin_mounted_or_no_pin_found(self):

dodal/devices/s4_slit_gaps.py

@@ -1,8 +1,12 @@
-from ophyd import Component, Device, EpicsMotor
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
 
 
-class S4SlitGaps(Device):
+class S4SlitGaps(StandardReadable):
     """Note that the S4 slits have a different PV fromat to other beamline slits"""
 
-    xgap = Component(EpicsMotor, "XGAP")
-    ygap = Component(EpicsMotor, "YGAP")
+    def __init__(self, prefix: str, name="") -> None:
+        with self.add_children_as_readables():
+            self.xgap = Motor(prefix + "XGAP")
+            self.ygap = Motor(prefix + "YGAP")
+            super().__init__(name=name)

dodal/devices/undulator_dcm.py

@@ -1,7 +1,7 @@
 import asyncio
 
 from bluesky.protocols import Movable
-from ophyd_async.core import AsyncStatus, StandardReadable
+from ophyd_async.core import AsyncStatus, Reference, StandardReadable
 
 from dodal.common.beamlines.beamline_parameters import get_beamline_parameters
 
@@ -33,12 +33,8 @@ class UndulatorDCM(StandardReadable, Movable):
         prefix: str = "",
         name: str = "",
     ):
-        super().__init__(name)
-
-        # Attributes are set after super call so they are not renamed to
-        # <name>-undulator, etc.
-        self.undulator = undulator
-        self.dcm = dcm
+        self.undulator_ref = Reference(undulator)
+        self.dcm_ref = Reference(dcm)
 
         # These attributes are just used by hyperion for lookup purposes
         self.pitch_energy_table_path = (
@@ -53,13 +49,15 @@ class UndulatorDCM(StandardReadable, Movable):
             daq_configuration_path + "/domain/beamlineParameters"
         )["DCM_Perp_Offset_FIXED"]
 
+        super().__init__(name)
+
     @AsyncStatus.wrap
     async def set(self, value: float):
-        await self.undulator.raise_if_not_enabled()
+        await self.undulator_ref().raise_if_not_enabled()
         await asyncio.gather(
-            self.dcm.energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
-            self.undulator.set(value),
+            self.dcm_ref().energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
+            self.undulator_ref().set(value),
         )
         # DCM Perp pitch
         LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
-        await self.dcm.offset_in_mm.set(self.dcm_fixed_offset_mm)
+        await self.dcm_ref().offset_in_mm.set(self.dcm_fixed_offset_mm)

dodal/devices/util/lookup_tables.py

@@ -32,28 +32,32 @@ async def energy_distance_table(lookup_table_path: str) -> np.ndarray:
     return loadtxt(StringIO(raw_table), comments=["#", "Units"])
 
 
-def linear_interpolation_lut(filename: str) -> Callable[[float], float]:
+def parse_lookup_table(filename: str) -> list[Sequence]:
+    """Parse a generic lookup table with a number of columns >= 2 and return a list \
+        in column major order of the values in it."""
+    LOGGER.info(f"Parsing lookup table file {filename}")
+
+    lut_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
+    return list(lut_vals)
+
+
+def linear_interpolation_lut(
+    s_values: Sequence, t_values: Sequence
+) -> Callable[[float], float]:
     """Returns a callable that converts values by linear interpolation of lookup table
     values.
 
     If the value falls outside the lookup table then the closest value will be used."""
-    LOGGER.info(f"Using lookup table {filename}")
-    s_and_t_vals = zip(*loadtxt(filename, comments=["#", "Units"]), strict=False)
-
-    s_values: Sequence
-    t_values: Sequence
-    s_values, t_values = s_and_t_vals
-
     # numpy interp expects x-values to be increasing
     if not np.all(np.diff(s_values) > 0):
         LOGGER.info(
-            f"Configuration file {filename} values are not ascending, trying reverse order..."
+            "Configuration values in the lookup table are not ascending, trying reverse order..."
         )
         s_values = list(reversed(s_values))
         t_values = list(reversed(t_values))
         if not np.all(np.diff(s_values) > 0):
             raise AssertionError(
-                f"Configuration file {filename} lookup table does not monotonically increase or decrease."
+                "Configuration lookup table does not monotonically increase or decrease."
             )
 
     def s_to_t2(s: float) -> float: