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

dodal/beamlines/i17.py

@@ -17,7 +17,7 @@ from dodal.devices.apple2_undulator import (
     UndulatorPhaseAxes,
 )
 from dodal.devices.i17.i17_apple2 import I17Apple2Controller
-from dodal.devices.pgm import PGM
+from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
@@ -39,26 +39,36 @@ def synchrotron() -> Synchrotron:
 
 
 @device_factory(skip=True)
-def pgm() -> PGM:
-    return PGM(
+def pgm() -> PlaneGratingMonochromator:
+    return PlaneGratingMonochromator(
         prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
         grating=I17Grating,
         grating_pv="NLINES2",
     )
 
 
+@device_factory()
+def id_gap() -> UndulatorGap:
+    return UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:")
+
+
+@device_factory()
+def id_phase() -> UndulatorPhaseAxes:
+    return UndulatorPhaseAxes(
+        prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
+        top_outer="RPQ1",
+        top_inner="RPQ2",
+        btm_inner="RPQ3",
+        btm_outer="RPQ4",
+    )
+
+
 @device_factory(skip=True)
 def id() -> Apple2:
     """I17 insertion device:"""
     return Apple2(
-        id_gap=UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:"),
-        id_phase=UndulatorPhaseAxes(
-            prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
-            top_outer="RPQ1",
-            top_inner="RPQ2",
-            btm_inner="RPQ3",
-            btm_outer="RPQ4",
-        ),
+        id_gap=id_gap(),
+        id_phase=id_phase(),
     )
 
 

dodal/beamlines/i19_2.py

@@ -1,12 +1,17 @@
+from pathlib import Path
+
+from ophyd_async.fastcs.eiger import EigerDetector
 from ophyd_async.fastcs.panda import HDFPanda
 
 from dodal.common.beamlines.beamline_utils import (
     device_factory,
     get_path_provider,
+    set_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
+from dodal.common.visit import StaticVisitPathProvider
 from dodal.devices.i19.access_controlled.blueapi_device import HutchState
 from dodal.devices.i19.access_controlled.shutter import AccessControlledShutter
 from dodal.devices.i19.backlight import BacklightPosition
@@ -31,6 +36,13 @@ PREFIX = BeamlinePrefix("i19", "I")
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/dls/i19-2/data/2025/cm40639-4/"),
+    )
+)
+
 
 I19_2_ZEBRA_MAPPING = ZebraMapping(
     outputs=ZebraTTLOutputs(),
@@ -105,3 +117,13 @@ def panda() -> HDFPanda:
         prefix=f"{PREFIX.beamline_prefix}-EA-PANDA-01:",
         path_provider=get_path_provider(),
     )
+
+
+@device_factory()
+def eiger() -> EigerDetector:
+    return EigerDetector(
+        prefix=PREFIX.beamline_prefix,
+        path_provider=get_path_provider(),
+        drv_suffix="-EA-EIGER-01:",
+        hdf_suffix="-EA-EIGER-01:OD:",
+    )

dodal/beamlines/i21.py

@@ -2,14 +2,19 @@ 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.apple2_undulator import (
+    Apple2,
+    UndulatorGap,
+    UndulatorPhaseAxes,
+)
 from dodal.devices.i21 import Grating
-from dodal.devices.pgm import PGM
+from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
 BL = get_beamline_name("i21")
-PREFIX = BeamlinePrefix(BL, suffix="I")
+PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
@@ -20,8 +25,33 @@ def synchrotron() -> Synchrotron:
 
 
 @device_factory()
-def pgm() -> PGM:
-    return PGM(
+def pgm() -> PlaneGratingMonochromator:
+    return PlaneGratingMonochromator(
         prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
         grating=Grating,
     )
+
+
+@device_factory()
+def id_gap() -> UndulatorGap:
+    return UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:")
+
+
+@device_factory()
+def id_phase() -> UndulatorPhaseAxes:
+    return UndulatorPhaseAxes(
+        prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
+        top_outer="PUO",
+        top_inner="PUI",
+        btm_inner="PLI",
+        btm_outer="PLO",
+    )
+
+
+@device_factory()
+def id() -> Apple2:
+    """I21 insertion device."""
+    return Apple2(
+        id_gap=id_gap(),
+        id_phase=id_phase(),
+    )

dodal/beamlines/i22.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 from ophyd_async.epics.adaravis import AravisDetector
 from ophyd_async.epics.adcore import NDPluginBaseIO, NDPluginStatsIO
 from ophyd_async.epics.adpilatus import PilatusDetector
@@ -8,7 +6,6 @@ from ophyd_async.fastcs.panda import HDFPanda
 from dodal.common.beamlines.beamline_utils import (
     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, DET_SUFFIX, HDF5_SUFFIX
@@ -16,7 +13,6 @@ from dodal.common.crystal_metadata import (
     MaterialsEnum,
     make_crystal_metadata_from_material,
 )
-from dodal.common.visit import RemoteDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.bimorph_mirror import BimorphMirror
 from dodal.devices.focusing_mirror import FocusingMirror
 from dodal.devices.i22.dcm import DCM
@@ -37,19 +33,6 @@ PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
-# Currently we must hard-code the visit, determining the visit at runtime requires
-# infrastructure that is still WIP.
-# Communication with GDA is also WIP so for now we determine an arbitrary scan number
-# locally and write the commissioning directory. The scan number is not guaranteed to
-# be unique and the data is at risk - this configuration is for testing only.
-set_path_provider(
-    StaticVisitPathProvider(
-        BL,
-        Path("/dls/i22/data/2025/cm40643-4/"),
-        client=RemoteDirectoryServiceClient("http://i22-control:8088/api"),
-    )
-)
-
 
 @device_factory()
 def saxs() -> PilatusDetector:

dodal/beamlines/k07.py

@@ -4,7 +4,7 @@ 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.pgm import PGM
+from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
@@ -27,5 +27,8 @@ class Grating(StrictEnum):
 
 # Grating does not exist yet - this class is a placeholder for when it does
 @device_factory(skip=True)
-def pgm() -> PGM:
-    return PGM(prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:", grating=Grating)
+def pgm() -> PlaneGratingMonochromator:
+    return PlaneGratingMonochromator(
+        prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
+        grating=Grating,
+    )

dodal/cli.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import click
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import NotConnected, StaticPathProvider, UUIDFilenameProvider
+from ophyd_async.core import NotConnectedError, StaticPathProvider, UUIDFilenameProvider
 from ophyd_async.plan_stubs import ensure_connected
 
 from dodal.beamlines import all_beamline_names, module_name_for_beamline
@@ -79,7 +79,7 @@ def connect(beamline: str, all: bool, sim_backend: bool) -> None:
     # If exceptions have occurred, this will print details of the relevant PVs
     exceptions = {**instance_exceptions, **connect_exceptions}
     if len(exceptions) > 0:
-        raise NotConnected(exceptions)
+        raise NotConnectedError(exceptions)
 
 
 def _report_successful_devices(
@@ -113,7 +113,7 @@ def _connect_devices(
     # Connect ophyd-async devices
     try:
         run_engine(ensure_connected(*ophyd_async_devices.values(), mock=sim_backend))
-    except NotConnected as ex:
+    except NotConnectedError as ex:
         exceptions = {**exceptions, **ex.sub_errors}
 
     # Only return the subset of devices that haven't raised an exception

dodal/devices/apple2_undulator.py

@@ -326,8 +326,8 @@ class Apple2(StandardReadable, Movable):
             Name of the device.
         """
         with self.add_children_as_readables():
-            self.gap = id_gap
-            self.phase = id_phase
+            self.gap = Reference(id_gap)
+            self.phase = Reference(id_phase)
         super().__init__(name=name)
 
     @AsyncStatus.wrap
@@ -338,25 +338,27 @@ class Apple2(StandardReadable, Movable):
         """
 
         # Only need to check gap as the phase motors share both fault and gate with gap.
-        await self.gap.raise_if_cannot_move()
+        await self.gap().raise_if_cannot_move()
         await asyncio.gather(
-            self.phase.top_outer.user_setpoint.set(value=id_motor_values.top_outer),
-            self.phase.top_inner.user_setpoint.set(value=id_motor_values.top_inner),
-            self.phase.btm_inner.user_setpoint.set(value=id_motor_values.btm_inner),
-            self.phase.btm_outer.user_setpoint.set(value=id_motor_values.btm_outer),
-            self.gap.user_setpoint.set(value=id_motor_values.gap),
+            self.phase().top_outer.user_setpoint.set(value=id_motor_values.top_outer),
+            self.phase().top_inner.user_setpoint.set(value=id_motor_values.top_inner),
+            self.phase().btm_inner.user_setpoint.set(value=id_motor_values.btm_inner),
+            self.phase().btm_outer.user_setpoint.set(value=id_motor_values.btm_outer),
+            self.gap().user_setpoint.set(value=id_motor_values.gap),
         )
         timeout = np.max(
-            await asyncio.gather(self.gap.get_timeout(), self.phase.get_timeout())
+            await asyncio.gather(self.gap().get_timeout(), self.phase().get_timeout())
         )
         LOGGER.info(
             f"Moving f{self.name} apple2 motors to {id_motor_values}, timeout = {timeout}"
         )
         await asyncio.gather(
-            self.gap.set_move.set(value=1, wait=False, timeout=timeout),
-            self.phase.set_move.set(value=1, wait=False, timeout=timeout),
+            self.gap().set_move.set(value=1, wait=False, timeout=timeout),
+            self.phase().set_move.set(value=1, wait=False, timeout=timeout),
+        )
+        await wait_for_value(
+            self.gap().gate, UndulatorGateStatus.CLOSE, timeout=timeout
         )
-        await wait_for_value(self.gap.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
 
 class EnergyMotorConvertor(Protocol):
@@ -448,11 +450,11 @@ class Apple2Controller(abc.ABC, StandardReadable, Generic[Apple2Type]):
                 raw_to_derived=self._read_pol,
                 set_derived=self._set_pol,
                 pol=self.polarisation_setpoint,
-                top_outer=self.apple2().phase.top_outer.user_readback,
-                top_inner=self.apple2().phase.top_inner.user_readback,
-                btm_inner=self.apple2().phase.btm_inner.user_readback,
-                btm_outer=self.apple2().phase.btm_outer.user_readback,
-                gap=self.apple2().gap.user_readback,
+                top_outer=self.apple2().phase().top_outer.user_readback,
+                top_inner=self.apple2().phase().top_inner.user_readback,
+                btm_inner=self.apple2().phase().btm_inner.user_readback,
+                btm_outer=self.apple2().phase().btm_outer.user_readback,
+                gap=self.apple2().gap().user_readback,
             )
         super().__init__(name)
 

dodal/devices/b07_1/ccmc.py

@@ -62,7 +62,7 @@ class ChannelCutMonochromator(
             )
 
         # energy derived signal as property
-        self.energy_in_ev = derived_signal_r(
+        self.energy_in_eV = derived_signal_r(
             self._convert_pos_to_ev, pos_signal=self.crystal
         )
         super().__init__(name=name)

dodal/devices/common_dcm.py

@@ -53,9 +53,9 @@ class DoubleCrystalMonochromatorBase(StandardReadable, Generic[Xtal_1, Xtal_2]):
     ) -> None:
         with self.add_children_as_readables():
             # Virtual motor PV's which set the physical motors so that the DCM produces requested energy
-            self.energy_in_kev = Motor(prefix + "ENERGY")
-            self.energy_in_ev = derived_signal_r(
-                self._convert_keV_to_eV, energy_signal=self.energy_in_kev.user_readback
+            self.energy_in_keV = Motor(prefix + "ENERGY")
+            self.energy_in_eV = derived_signal_r(
+                self._convert_keV_to_eV, energy_signal=self.energy_in_keV.user_readback
             )
 
             self._make_crystals(prefix, xtal_1, xtal_2)

dodal/devices/cryostream.py

@@ -32,6 +32,11 @@ class TurboEnum(StrictEnum):
     AUTO = "Auto"
 
 
+class CryoStreamSelection(StrictEnum):
+    CRYOJET = "CryoJet"
+    HC1 = "HC1"
+
+
 class OxfordCryoStreamController(StandardReadable):
     def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -107,3 +112,19 @@ class OxfordCryoStream(StandardReadable):
             self.status = OxfordCryoStreamStatus(prefix=prefix)
 
         super().__init__(name)
+
+
+class CryoStreamGantry(StandardReadable):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.cryostream_selector = epics_signal_r(
+                CryoStreamSelection, f"{prefix}-EA-GANT-01:CTRL"
+            )
+            self.hc1_selected = epics_signal_r(
+                int, f"{prefix}-MO-STEP-02:GPIO_INP_BITS.B2"
+            )
+            self.cryostream_selected = epics_signal_r(
+                int, f"{prefix}-MO-STEP-02:GPIO_INP_BITS.B3"
+            )
+
+        super().__init__(name)

dodal/devices/i03/undulator_dcm.py

@@ -58,7 +58,7 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     async def set(self, value: float):
         await self.undulator_ref().raise_if_not_enabled()
         await asyncio.gather(
-            self.dcm_ref().energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
+            self.dcm_ref().energy_in_keV.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator_ref().set(value),
         )
 

dodal/devices/i07/dcm.py

@@ -0,0 +1,33 @@
+from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.common_dcm import (
+    DoubleCrystalMonochromator,
+    PitchAndRollCrystal,
+    StationaryCrystal,
+)
+
+
+class DCM(DoubleCrystalMonochromator[PitchAndRollCrystal, StationaryCrystal]):
+    """
+    Device for i07's DCM, including temperature monitors and vertical motor which were
+    included in GDA.
+    """
+
+    def __init__(
+        self,
+        motor_prefix: str,
+        xtal_prefix: str,
+        name: str = "",
+    ) -> None:
+        super().__init__(motor_prefix, PitchAndRollCrystal, StationaryCrystal, name)
+        with self.add_children_as_readables():
+            self.vertical_in_mm = Motor(motor_prefix + "PERP")
+
+            # temperatures
+            self.xtal1_temp = epics_signal_r(float, xtal_prefix + "PT100-2")
+            self.xtal2_temp = epics_signal_r(float, xtal_prefix + "PT100-3")
+            self.xtal1_holder_temp = epics_signal_r(float, xtal_prefix + "PT100-1")
+            self.xtal2_holder_temp = epics_signal_r(float, xtal_prefix + "PT100-4")
+            self.gap_motor = epics_signal_r(float, xtal_prefix + "TC-1")
+            self.white_beam_stop_temp = epics_signal_r(float, xtal_prefix + "WBS:TEMP")

dodal/devices/i09_1_shared/__init__.py

@@ -0,0 +1,3 @@
+from .hard_undulator_functions import calculate_gap_i09_hu, get_hu_lut_as_dict
+
+__all__ = ["calculate_gap_i09_hu", "get_hu_lut_as_dict"]

dodal/devices/i09_1_shared/hard_undulator_functions.py

@@ -0,0 +1,111 @@
+import numpy as np
+
+from dodal.devices.util.lookup_tables import energy_distance_table
+from dodal.log import LOGGER
+
+LUT_COMMENTS = ["#"]
+HU_SKIP_ROWS = 3
+
+# Physics constants
+ELECTRON_REST_ENERGY_MEV = 0.510999
+
+# Columns in the lookup table
+RING_ENERGY_COLUMN = 1
+MAGNET_FIELD_COLUMN = 2
+MIN_ENERGY_COLUMN = 3
+MAX_ENERGY_COLUMN = 4
+GAP_OFFSET_COLUMN = 7
+
+
+async def get_hu_lut_as_dict(lut_path: str) -> dict:
+    lut_dict: dict = {}
+    _lookup_table: np.ndarray = await energy_distance_table(
+        lut_path,
+        comments=LUT_COMMENTS,
+        skiprows=HU_SKIP_ROWS,
+    )
+    for i in range(_lookup_table.shape[0]):
+        lut_dict[_lookup_table[i][0]] = _lookup_table[i]
+        LOGGER.debug(f"Loaded lookup table:\n {lut_dict}")
+    return lut_dict
+
+
+def calculate_gap_i09_hu(
+    photon_energy_kev: float,
+    look_up_table: dict[int, "np.ndarray"],
+    order: int = 1,
+    gap_offset: float = 0.0,
+    undulator_period_mm: int = 27,
+) -> float:
+    """
+    Calculate the undulator gap required to produce a given energy at a given harmonic order.
+    This algorithm was provided by the I09 beamline scientists, and is based on the physics of undulator radiation.
+    https://cxro.lbl.gov//PDF/X-Ray-Data-Booklet.pdf
+
+    Args:
+        photon_energy_kev (float): Requested photon energy in keV.
+        look_up_table (dict[int, np.ndarray]): Lookup table containing undulator and beamline parameters for each harmonic order.
+        order (int, optional): Harmonic order for which to calculate the gap. Defaults to 1.
+        gap_offset (float, optional): Additional gap offset to apply (in mm). Defaults to 0.0.
+        undulator_period_mm (int, optional): Undulator period in mm. Defaults to 27.
+
+    Returns:
+        float: Calculated undulator gap in millimeters.
+    """
+    magnet_blocks_per_period = 4
+    magnet_block_height_mm = 16
+
+    if order not in look_up_table.keys():
+        raise ValueError(f"Order parameter {order} not found in lookup table")
+
+    gamma = 1000 * look_up_table[order][RING_ENERGY_COLUMN] / ELECTRON_REST_ENERGY_MEV
+
+    # Constructive interference of radiation emitted at different poles
+    # lamda = (lambda_u/2*gamma^2)*(1+K^2/2 + gamma^2*theta^2)/n for n=1,2,3...
+    # theta is the observation angle, assumed to be 0 here.
+    # Rearranging for K (the undulator parameter, related to magnetic field and gap)
+    # gives K^2 = 2*((2*n*gamma^2*lamda/lambda_u)-1)
+
+    undulator_parameter_sqr = (
+        4.959368e-6
+        * (order * gamma * gamma / (undulator_period_mm * photon_energy_kev))
+        - 2
+    )
+    if undulator_parameter_sqr < 0:
+        raise ValueError(
+            f"Diffraction parameter squared must be positive! Calculated value {undulator_parameter_sqr}."
+        )
+    undulator_parameter = np.sqrt(undulator_parameter_sqr)
+
+    # Undulator_parameter K is also defined as K = 0.934*B0[T]*lambda_u[cm],
+    # where B0[T] is a peak magnetic field that must depend on gap,
+    # but in our LUT it is does not depend on gap, so it's a factor,
+    # leading to K = 0.934*B0[T]*lambda_u[cm]*exp(-pi*gap/lambda_u) or
+    # K = undulator_parameter_max*exp(-pi*gap/lambda_u)
+    # Calculating undulator_parameter_max gives:
+    undulator_parameter_max = (
+        (
+            2
+            * 0.0934
+            * undulator_period_mm
+            * look_up_table[order][MAGNET_FIELD_COLUMN]
+            * magnet_blocks_per_period
+            / np.pi
+        )
+        * np.sin(np.pi / magnet_blocks_per_period)
+        * (1 - np.exp(-2 * np.pi * magnet_block_height_mm / undulator_period_mm))
+    )
+
+    # Finnaly, rearranging the equation:
+    # undulator_parameter = undulator_parameter_max*exp(-pi*gap/lambda_u) for gap gives
+    gap = (
+        (undulator_period_mm / np.pi)
+        * np.log(undulator_parameter_max / undulator_parameter)
+        + look_up_table[order][GAP_OFFSET_COLUMN]
+        + gap_offset
+    )
+    LOGGER.debug(
+        f"Calculated gap is {gap}mm for energy {photon_energy_kev}keV at order {order}"
+    )
+
+    return gap

dodal/devices/i10/i10_apple2.py

@@ -340,7 +340,7 @@ class I10Apple2(Apple2):
             The name of the device, by default "".
         """
         with self.add_children_as_readables():
-            self.jaw_phase = id_jaw_phase
+            self.jaw_phase = Reference(id_jaw_phase)
         super().__init__(id_gap=id_gap, id_phase=id_phase, name=name)
 
 
@@ -425,7 +425,7 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
                 f"jaw_phase position for angle ({pol_angle}) is outside permitted range"
                 f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
             )
-        await self.apple2().jaw_phase.set(jaw_phase)
+        await self.apple2().jaw_phase().set(jaw_phase)
         await self._linear_arbitrary_angle.set(pol_angle)
 
     async def _set_motors_from_energy(self, value: float) -> None:
@@ -447,8 +447,8 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
         LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
         await self.apple2().set(id_motor_values=id_set_val)
         if pol != Pol.LA:
-            await self.apple2().jaw_phase.set(0)
-            await self.apple2().jaw_phase.set_move.set(1)
+            await self.apple2().jaw_phase().set(0)
+            await self.apple2().jaw_phase().set_move.set(1)
 
     def _raise_if_not_la(self, pol: Pol) -> None:
         if pol != Pol.LA:

dodal/devices/i15/dcm.py

@@ -33,7 +33,7 @@ class DCM(DoubleCrystalMonochromatorBase[ThetaRollYZCrystal, ThetaYCrystal]):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            self.calibrated_energy_in_kev = Motor(prefix + "CAL")
+            self.calibrated_energy_in_keV = Motor(prefix + "CAL")
             self.x1 = Motor(prefix + "X1")
 
         super().__init__(prefix, ThetaRollYZCrystal, ThetaYCrystal, name)

dodal/devices/i22/dcm.py

@@ -107,7 +107,7 @@ class DCM(DoubleCrystalMonochromatorWithDSpacing[RollCrystal, PitchAndRollCrysta
 
     async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
-        energy: float = default_reading[f"{self.name}-energy_in_kev"]["value"]
+        energy: float = default_reading[f"{self.name}-energy_in_keV"]["value"]
         if energy > 0.0:
             wavelength = _CONVERSION_CONSTANT / energy
         else:

dodal/devices/i22/nxsas.py

@@ -1,11 +1,9 @@
-import asyncio
-from collections.abc import Awaitable, Iterable
 from dataclasses import dataclass, fields
 from typing import TypeVar
 
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
-from ophyd_async.core import PathProvider
+from ophyd_async.core import PathProvider, merge_gathered_dicts
 from ophyd_async.epics.adaravis import AravisDetector
 from ophyd_async.epics.adcore import NDPluginBaseIO
 from ophyd_async.epics.adpilatus import PilatusDetector
@@ -14,23 +12,6 @@ ValueAndUnits = tuple[float, str]
 T = TypeVar("T")
 
 
-# TODO: Remove this file as part of github.com/DiamondLightSource/dodal/issues/595
-# Until which, temporarily duplicated non-public method from ophyd_async
-async def _merge_gathered_dicts(
-    coros: Iterable[Awaitable[dict[str, T]]],
-) -> dict[str, T]:
-    """Merge dictionaries produced by a sequence of coroutines.
-
-    Can be used for merging ``read()`` or ``describe``. For instance::
-
-        combined_read = await merge_gathered_dicts(s.read() for s in signals)
-    """
-    ret: dict[str, T] = {}
-    for result in await asyncio.gather(*coros):
-        ret.update(result)
-    return ret
-
-
 @dataclass
 class MetadataHolder:
     # TODO: just in case this is useful more widely...
@@ -124,7 +105,7 @@ class NXSasPilatus(PilatusDetector):
         self._metadata_holder = metadata_holder
 
     async def read_configuration(self) -> dict[str, Reading]:
-        return await _merge_gathered_dicts(
+        return await merge_gathered_dicts(
             r
             for r in (
                 super().read_configuration(),
@@ -133,7 +114,7 @@ class NXSasPilatus(PilatusDetector):
         )
 
     async def describe_configuration(self) -> dict[str, DataKey]:
-        return await _merge_gathered_dicts(
+        return await merge_gathered_dicts(
             r
             for r in (
                 super().describe_configuration(),
@@ -167,7 +148,7 @@ class NXSasOAV(AravisDetector):
         self._metadata_holder = metadata_holder
 
     async def read_configuration(self) -> dict[str, Reading]:
-        return await _merge_gathered_dicts(
+        return await merge_gathered_dicts(
             r
             for r in (
                 super().read_configuration(),
@@ -176,7 +157,7 @@ class NXSasOAV(AravisDetector):
         )
 
     async def describe_configuration(self) -> dict[str, DataKey]:
-        return await _merge_gathered_dicts(
+        return await merge_gathered_dicts(
             r
             for r in (
                 super().describe_configuration(),

dodal/devices/pgm.py

@@ -7,7 +7,7 @@ from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
 
 
-class PGM(StandardReadable):
+class PlaneGratingMonochromator(StandardReadable):
     """
     Plane grating monochromator, it is use in soft x-ray beamline to generate monochromic beam.
     """