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

dodal/devices/undulator.py

@@ -2,7 +2,7 @@ import os
 
 import numpy as np
 from bluesky.protocols import Movable
-from numpy import argmin, ndarray
+from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
@@ -38,12 +38,12 @@ class UndulatorGapAccess(StrictEnum):
     DISABLED = "DISABLED"
 
 
-def _get_closest_gap_for_energy(
+def _get_gap_for_energy(
     dcm_energy_ev: float, energy_to_distance_table: ndarray
 ) -> float:
-    table = energy_to_distance_table.transpose()
-    idx = argmin(np.abs(table[0] - dcm_energy_ev))
-    return table[1][idx]
+    return np.interp(
+        dcm_energy_ev, energy_to_distance_table[:, 0], energy_to_distance_table[:, 1]
+    )
 
 
 class Undulator(StandardReadable, Movable[float]):
@@ -115,8 +115,10 @@ class Undulator(StandardReadable, Movable[float]):
 
     async def _set_undulator_gap(self, energy_kev: float) -> None:
         await self.raise_if_not_enabled()
-        LOGGER.info(f"Setting undulator gap to {energy_kev:.2f} kev")
         target_gap = await self._get_gap_to_match_energy(energy_kev)
+        LOGGER.info(
+            f"Setting undulator gap to {target_gap:.3f}mm based on {energy_kev:.2f}kev"
+        )
 
         # Check if undulator gap is close enough to the value from the DCM
         current_gap = await self.current_gap.get_value()
@@ -152,7 +154,7 @@ class Undulator(StandardReadable, Movable[float]):
         )
 
         # Use the lookup table to get the undulator gap associated with this dcm energy
-        return _get_closest_gap_for_energy(
+        return _get_gap_for_energy(
             energy_kev * 1000,
             energy_to_distance_table,
         )

dodal/devices/util/adjuster_plans.py

@@ -7,14 +7,13 @@ from collections.abc import Callable, Generator
 
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
-from ophyd.epics_motor import EpicsMotor
 from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 
 
 def lookup_table_adjuster(
-    lookup_table: Callable[[float], float], output_device: EpicsMotor | Motor, input
+    lookup_table: Callable[[float], float], output_device: Motor, input
 ):
     """Returns a callable that adjusts a value according to a lookup table"""
 

dodal/devices/util/lookup_tables.py

@@ -64,3 +64,41 @@ def linear_interpolation_lut(
         return float(interp(s, s_values, t_values))
 
     return s_to_t2
+
+
+def linear_extrapolation_lut(
+    s_values: Sequence[float], t_values: Sequence[float]
+) -> Callable[[float], float]:
+    """
+    Return a callable that implements f(s) = t according to the conversion table data
+    supplied, with linear extrapolation outside that range. Inside the range of the table,
+    the function is equivalent to that returned by linear_interpolation_lut
+
+    Args:
+        s_values:  Values of the independent axis
+        t_values:  Values of the dependent axis
+
+    Returns:
+        A callable that returns t for the given s
+    """
+    assert len(s_values) == len(t_values), (
+        "Lookup table does not have the same number of values for each axis"
+    )
+    assert len(s_values) > 1, "Need at least 2 points in the lookup table"
+    interp = linear_interpolation_lut(s_values, t_values)
+    s_min = s_values[0]
+    s_max = s_values[-1]
+
+    def s_to_t(s: float) -> float:
+        if s < s_min:
+            return t_values[0] + (s - s_min) * (t_values[1] - t_values[0]) / (
+                s_values[1] - s_values[0]
+            )
+        elif s > s_max:
+            return t_values[-1] + (s - s_max) * (t_values[-1] - t_values[-2]) / (
+                s_values[-1] - s_values[-2]
+            )
+        else:
+            return interp(s)
+
+    return s_to_t

dodal/devices/util/test_utils.py

@@ -11,6 +11,7 @@ def patch_motor(motor: Motor, initial_position=0):
     set_mock_value(motor.deadband, 0.001)
     set_mock_value(motor.motor_done_move, 1)
     set_mock_value(motor.velocity, 3)
+    set_mock_value(motor.max_velocity, 5)
     return callback_on_mock_put(
         motor.user_setpoint,
         lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),

dodal/plan_stubs/electron_analyser/configure_controller.py

@@ -0,0 +1,80 @@
+from bluesky import plan_stubs as bps
+
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract_region import (
+    AbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.specs_analyser_io import (
+    SpecsAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.specs_region import SpecsRegion
+from dodal.devices.electron_analyser.vgscienta_analyser_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta_region import (
+    VGScientaRegion,
+)
+from dodal.log import LOGGER
+
+
+def configure_analyser(
+    analyser: AbstractAnalyserDriverIO,
+    region: AbstractBaseRegion,
+    excitation_energy: float,
+):
+    LOGGER.info(f'Configuring analyser with region "{region.name}"')
+    low_energy = region.to_kinetic_energy(region.low_energy, excitation_energy)
+    high_energy = region.to_kinetic_energy(region.high_energy, excitation_energy)
+    pass_energy_type = analyser.pass_energy_type
+    pass_energy = pass_energy_type(region.pass_energy)
+    # Set detector settings, wait for them all to have completed
+    # fmt: off
+    yield from bps.mv(
+        analyser.low_energy, low_energy,
+        analyser.high_energy, high_energy,
+        analyser.slices, region.slices,
+        analyser.lens_mode, region.lens_mode,
+        analyser.pass_energy, pass_energy,
+        analyser.iterations, region.iterations,
+        analyser.acquisition_mode, region.acquisition_mode,
+    )
+    # fmt: on
+
+
+def configure_specs(
+    analyser: SpecsAnalyserDriverIO, region: SpecsRegion, excitation_energy: float
+):
+    yield from configure_analyser(analyser, region, excitation_energy)
+    # fmt: off
+    yield from bps.mv(
+        analyser.values, region.values,
+        analyser.psu_mode, region.psu_mode,
+    )
+    # fmt: on
+    if region.acquisition_mode == "Fixed Transmission":
+        yield from bps.mv(analyser.centre_energy, region.centre_energy)
+
+    if region.acquisition_mode == "Fixed Energy":
+        yield from bps.mv(analyser.energy_step, region.energy_step)
+
+
+def configure_vgscienta(
+    analyser: VGScientaAnalyserDriverIO, region: VGScientaRegion, excitation_energy
+):
+    yield from configure_analyser(analyser, region, excitation_energy)
+    centre_energy = region.to_kinetic_energy(region.fix_energy, excitation_energy)
+
+    # fmt: off
+    yield from bps.mv(
+        analyser.centre_energy, centre_energy,
+        analyser.energy_step, region.energy_step,
+        analyser.first_x_channel, region.first_x_channel,
+        analyser.first_y_channel, region.first_y_channel,
+        analyser.x_channel_size, region.x_channel_size(),
+        analyser.y_channel_size, region.y_channel_size(),
+        analyser.detector_mode, region.detector_mode,
+        analyser.image_mode, "Single",
+    )
+    # fmt: on

dodal/plan_stubs/motor_utils.py

@@ -1,6 +1,6 @@
 import uuid
 from collections.abc import Generator
-from typing import Any, TypeVar, cast
+from typing import Any
 
 from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper, pchain
@@ -8,14 +8,14 @@ from bluesky.utils import Msg, MsgGenerator, make_decorator
 from ophyd_async.core import Device
 from ophyd_async.epics.motor import Motor
 
-from dodal.utils import MovableReadable
-
-MovableReadableDevice = TypeVar("MovableReadableDevice", bound=MovableReadable)
-
 
 class MoveTooLarge(Exception):
     def __init__(
-        self, axis: MovableReadable, maximum_move: float, position: float, *args: object
+        self,
+        axis: Motor,
+        maximum_move: float,
+        position: float,
+        *args: object,
     ) -> None:
         self.axis = axis
         self.maximum_move = maximum_move
@@ -24,10 +24,10 @@ class MoveTooLarge(Exception):
 
 
 def check_and_cache_values(
-    devices_and_positions: dict[MovableReadableDevice, float],
+    devices_and_positions: dict[Motor, float],
     smallest_move: float,
     maximum_move: float,
-) -> Generator[Msg, Any, dict[MovableReadableDevice, float]]:
+) -> Generator[Msg, Any, dict[Motor, float]]:
     """Caches the positions of all Motors on specified device if they are within
     smallest_move of home_position. Throws MoveTooLarge if they are outside maximum_move
     of the home_position
@@ -51,9 +51,7 @@ def home_and_reset_wrapper(
     wait_for_all: bool = True,
 ) -> MsgGenerator:
     home_positions = {
-        cast(MovableReadable, axis): 0.0
-        for _, axis in device.children()
-        if isinstance(axis, Motor)
+        axis: 0.0 for _, axis in device.children() if isinstance(axis, Motor)
     }
     return move_and_reset_wrapper(
         plan, home_positions, smallest_move, maximum_move, group, wait_for_all
@@ -62,7 +60,7 @@ def home_and_reset_wrapper(
 
 def move_and_reset_wrapper(
     plan: MsgGenerator,
-    device_and_positions: dict[MovableReadable, float],
+    device_and_positions: dict[Motor, float],
     smallest_move: float,
     maximum_move: float,
     group: str | None = None,

dodal/utils.py

@@ -15,11 +15,9 @@ from types import ModuleType
 from typing import (
     Any,
     Generic,
-    Protocol,
     TypeAlias,
     TypeGuard,
     TypeVar,
-    runtime_checkable,
 )
 
 from bluesky.protocols import (
@@ -62,11 +60,6 @@ BLUESKY_PROTOCOLS = [
     Triggerable,
 ]
 
-
-@runtime_checkable
-class MovableReadable(Movable, Readable, Protocol): ...
-
-
 AnyDevice: TypeAlias = OphydV1Device | OphydV2Device
 V1DeviceFactory: TypeAlias = Callable[..., OphydV1Device]
 V2DeviceFactory: TypeAlias = Callable[..., OphydV2Device]

dodal/devices/i13_1/merlin_io.py

@@ -1,17 +0,0 @@
-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/oav/microns_for_zoom_levels.json

@@ -1,55 +0,0 @@
-{
-    "XRatio": 0.485,
-    "YRatio": 0.353,
-    "tolerance": 1.0,
-    "1.0": {
-        "position": 1.0,
-        "micronsPerXPixel": 2.309,
-        "micronsPerYPixel": 3.266
-    },
-    "2.0": {
-        "position": 2.0,
-        "micronsPerXPixel": 1.775,
-        "micronsPerYPixel": 2.493
-    },
-    "3.0": {
-        "position": 3.0,
-        "micronsPerXPixel": 1.334,
-        "micronsPerYPixel": 1.856
-    },
-    "4.0": {
-        "position": 4.0,
-        "micronsPerXPixel": 1.037,
-        "micronsPerYPixel": 1.425
-    },
-    "5.0": {
-        "position": 5.0,
-        "micronsPerXPixel": 0.798,
-        "micronsPerYPixel": 1.091
-    },
-    "6.0": {
-        "position": 6.0,
-        "micronsPerXPixel": 0.627,
-        "micronsPerYPixel": 0.870
-    },
-    "7.0": {
-        "position": 7.0,
-        "micronsPerXPixel": 0.487,
-        "micronsPerYPixel": 0.666
-    },
-    "8.0": {
-        "position": 8.0,
-        "micronsPerXPixel": 0.379,
-        "micronsPerYPixel": 0.516
-    },
-    "9.0": {
-        "position": 9.0,
-        "micronsPerXPixel": 0.289,
-        "micronsPerYPixel": 0.405
-    },
-    "10.0": {
-        "position": 10.0,
-        "micronsPerXPixel": 0.227,
-        "micronsPerYPixel": 0.314
-    }
-}

dodal/devices/oav/snapshots/snapshot_with_beam_centre.py

@@ -1,64 +0,0 @@
-from ophyd_async.core import Reference, SignalR
-from PIL import Image, ImageDraw
-
-from dodal.devices.areadetector.plugins.MJPG import MJPG
-
-CROSSHAIR_LENGTH_PX = 20
-CROSSHAIR_OUTLINE_COLOUR = "Black"
-CROSSHAIR_FILL_COLOUR = "White"
-
-
-def draw_crosshair(image: Image.Image, beam_x: int, beam_y: int):
-    draw = ImageDraw.Draw(image)
-    OUTLINE_WIDTH = 1
-    HALF_LEN = CROSSHAIR_LENGTH_PX / 2
-    draw.rectangle(
-        [
-            beam_x - OUTLINE_WIDTH,
-            beam_y - HALF_LEN - OUTLINE_WIDTH,
-            beam_x + OUTLINE_WIDTH,
-            beam_y + HALF_LEN + OUTLINE_WIDTH,
-        ],
-        fill=CROSSHAIR_OUTLINE_COLOUR,
-    )
-    draw.rectangle(
-        [
-            beam_x - HALF_LEN - OUTLINE_WIDTH,
-            beam_y - OUTLINE_WIDTH,
-            beam_x + HALF_LEN + OUTLINE_WIDTH,
-            beam_y + OUTLINE_WIDTH,
-        ],
-        fill=CROSSHAIR_OUTLINE_COLOUR,
-    )
-    draw.line(
-        ((beam_x, beam_y - HALF_LEN), (beam_x, beam_y + HALF_LEN)),
-        fill=CROSSHAIR_FILL_COLOUR,
-    )
-    draw.line(
-        ((beam_x - HALF_LEN, beam_y), (beam_x + HALF_LEN, beam_y)),
-        fill=CROSSHAIR_FILL_COLOUR,
-    )
-
-
-class SnapshotWithBeamCentre(MJPG):
-    """A child of MJPG which, when triggered, draws an outlined crosshair at the beam
-    centre in the image and saves the image to disk."""
-
-    def __init__(
-        self,
-        prefix: str,
-        beam_x_signal: SignalR,
-        beam_y_signal: SignalR,
-        name: str = "",
-    ) -> None:
-        with self.add_children_as_readables():
-            self._beam_centre_i_ref = Reference(beam_x_signal)
-            self._beam_centre_j_ref = Reference(beam_y_signal)
-        super().__init__(prefix, name)
-
-    async def post_processing(self, image: Image.Image):
-        beam_x = await self._beam_centre_i_ref().get_value()
-        beam_y = await self._beam_centre_j_ref().get_value()
-        draw_crosshair(image, beam_x, beam_y)
-
-        await self._save_image(image)

dodal/devices/util/motor_utils.py

@@ -1,6 +0,0 @@
-from ophyd import Component, EpicsMotor, EpicsSignalRO
-
-
-class ExtendedEpicsMotor(EpicsMotor):
-    motor_resolution: Component[EpicsSignalRO] = Component(EpicsSignalRO, ".MRES")
-    max_velocity: Component[EpicsSignalRO] = Component(EpicsSignalRO, ".VMAX")