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

dodal/devices/i07/id.py

@@ -0,0 +1,38 @@
+import numpy as np
+
+from dodal.devices.undulator import UndulatorInKeV, UndulatorOrder
+from dodal.devices.util.lookup_tables import energy_distance_table
+
+
+class InsertionDevice(UndulatorInKeV):
+    """
+    Insertion device for i07 including beamline-specific energy-gap lookup behaviour
+    """
+
+    def __init__(
+        self,
+        name: str,
+        prefix: str,
+        harmonic: UndulatorOrder,
+        id_gap_lookup_table_path: str = "/dls_sw/i07/software/gda/config/lookupTables/"
+        + "IIDCalibrationTable.txt",
+    ) -> None:
+        super().__init__(prefix, id_gap_lookup_table_path, name=name)
+        self.harmonic = harmonic
+
+    async def _get_gap_to_match_energy(self, energy_kev: float) -> float:
+        """
+        i07's energy scans remain on a particular harmonic while changing energy.  The
+        calibration table has one row for each harmonic, row contains max and min
+        energies and their corresponding ID gaps.  The requested energy is used to
+        interpolate between these values, assuming a linear relationship on the relevant
+        scale.
+        """
+        energy_to_distance_table: np.ndarray = await energy_distance_table(
+            self.id_gap_lookup_table_path, comments="#", skiprows=2
+        )
+        harmonic_value: int = await self.harmonic.value.get_value()
+
+        row: np.ndarray = energy_to_distance_table[harmonic_value - 1, :]
+        gap = np.interp(energy_kev, [row[1], row[2]], [row[3], row[4]])
+        return gap

dodal/devices/i09_1_shared/__init__.py

@@ -1,3 +1,14 @@
-from .hard_undulator_functions import calculate_gap_i09_hu, get_hu_lut_as_dict
+from .hard_energy import HardEnergy, HardInsertionDeviceEnergy
+from .hard_undulator_functions import (
+    calculate_energy_i09_hu,
+    calculate_gap_i09_hu,
+    get_hu_lut_as_dict,
+)
 
-__all__ = ["calculate_gap_i09_hu", "get_hu_lut_as_dict"]
+__all__ = [
+    "calculate_gap_i09_hu",
+    "get_hu_lut_as_dict",
+    "calculate_energy_i09_hu",
+    "HardInsertionDeviceEnergy",
+    "HardEnergy",
+]

dodal/devices/i09_1_shared/hard_energy.py

@@ -0,0 +1,112 @@
+from asyncio import gather
+from collections.abc import Callable
+
+from bluesky.protocols import Locatable, Location, Movable
+from numpy import ndarray
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_rw,
+    soft_signal_rw,
+)
+
+from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
+from dodal.devices.i09_1_shared.hard_undulator_functions import (
+    MAX_ENERGY_COLUMN,
+    MIN_ENERGY_COLUMN,
+)
+from dodal.devices.undulator import UndulatorInMm, UndulatorOrder
+
+
+class HardInsertionDeviceEnergy(StandardReadable, Movable[float]):
+    """
+    Compound device to link hard x-ray undulator gap and order to photon energy.
+    Setting the energy adjusts the undulator gap accordingly.
+    """
+
+    def __init__(
+        self,
+        undulator_order: UndulatorOrder,
+        undulator: UndulatorInMm,
+        lut: dict[int, ndarray],
+        gap_to_energy_func: Callable[..., float],
+        energy_to_gap_func: Callable[..., float],
+        name: str = "",
+    ) -> None:
+        self._lut = lut
+        self.gap_to_energy_func = gap_to_energy_func
+        self.energy_to_gap_func = energy_to_gap_func
+        self._undulator_order_ref = Reference(undulator_order)
+        self._undulator_ref = Reference(undulator)
+
+        self.add_readables([undulator_order, undulator.current_gap])
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.energy_demand = soft_signal_rw(float)
+            self.energy = derived_signal_rw(
+                raw_to_derived=self._read_energy,
+                set_derived=self._set_energy,
+                current_gap=self._undulator_ref().gap_motor.user_readback,
+                current_order=self._undulator_order_ref().value,
+                derived_units="keV",
+            )
+        super().__init__(name=name)
+
+    def _read_energy(self, current_gap: float, current_order: int) -> float:
+        return self.gap_to_energy_func(
+            gap=current_gap,
+            look_up_table=self._lut,
+            order=current_order,
+        )
+
+    async def _set_energy(self, energy: float) -> None:
+        current_order = await self._undulator_order_ref().value.get_value()
+        min_energy, max_energy = self._lut[current_order][
+            MIN_ENERGY_COLUMN : MAX_ENERGY_COLUMN + 1
+        ]
+        if not (min_energy <= energy <= max_energy):
+            raise ValueError(
+                f"Requested energy {energy} keV is out of range for harmonic {current_order}: "
+                f"[{min_energy}, {max_energy}] keV"
+            )
+
+        target_gap = self.energy_to_gap_func(
+            photon_energy_kev=energy, look_up_table=self._lut, order=current_order
+        )
+        await self._undulator_ref().set(target_gap)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        self.energy_demand.set(value)
+        await self.energy.set(value)
+
+
+class HardEnergy(StandardReadable, Locatable[float]):
+    """
+    Energy compound device that provides combined change of both DCM energy and undulator gap accordingly.
+    """
+
+    def __init__(
+        self,
+        dcm: DoubleCrystalMonochromatorBase,
+        undulator_energy: HardInsertionDeviceEnergy,
+        name: str = "",
+    ) -> None:
+        self._dcm_ref = Reference(dcm)
+        self._undulator_energy_ref = Reference(undulator_energy)
+        self.add_readables([undulator_energy, dcm.energy_in_keV])
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        await gather(
+            self._dcm_ref().energy_in_keV.set(value),
+            self._undulator_energy_ref().set(value),
+        )
+
+    async def locate(self) -> Location[float]:
+        return Location(
+            setpoint=await self._dcm_ref().energy_in_keV.user_setpoint.get_value(),
+            readback=await self._dcm_ref().energy_in_keV.user_readback.get_value(),
+        )

dodal/devices/i09_1_shared/hard_undulator_functions.py

@@ -14,11 +14,16 @@ RING_ENERGY_COLUMN = 1
 MAGNET_FIELD_COLUMN = 2
 MIN_ENERGY_COLUMN = 3
 MAX_ENERGY_COLUMN = 4
+MIN_GAP_COLUMN = 5
+MAX_GAP_COLUMN = 6
 GAP_OFFSET_COLUMN = 7
 
+MAGNET_BLOCKS_PER_PERIOD = 4
+MAGNTE_BLOCK_HEIGHT_MM = 16
 
-async def get_hu_lut_as_dict(lut_path: str) -> dict:
-    lut_dict: dict = {}
+
+async def get_hu_lut_as_dict(lut_path: str) -> dict[int, np.ndarray]:
+    lut_dict: dict[int, np.ndarray] = {}
     _lookup_table: np.ndarray = await energy_distance_table(
         lut_path,
         comments=LUT_COMMENTS,
@@ -26,13 +31,44 @@ async def get_hu_lut_as_dict(lut_path: str) -> dict:
     )
     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}")
+    LOGGER.debug(f"Loaded lookup table: {lut_dict}")
     return lut_dict
 
 
+def _validate_order(order: int, look_up_table: dict[int, "np.ndarray"]) -> None:
+    """Validate that the harmonic order exists in the lookup table."""
+    if order not in look_up_table.keys():
+        raise ValueError(f"Order parameter {order} not found in lookup table")
+
+
+def _calculate_gamma(look_up_table: dict[int, "np.ndarray"], order: int) -> float:
+    """Calculate the Lorentz factor gamma from the lookup table."""
+    return 1000 * look_up_table[order][RING_ENERGY_COLUMN] / ELECTRON_REST_ENERGY_MEV
+
+
+def _calculate_undulator_parameter_max(
+    magnet_field: float, undulator_period_mm: int
+) -> float:
+    """
+    Calculate the maximum undulator parameter.
+    """
+    return (
+        (
+            2
+            * 0.0934
+            * undulator_period_mm
+            * magnet_field
+            * MAGNET_BLOCKS_PER_PERIOD
+            / np.pi
+        )
+        * np.sin(np.pi / MAGNET_BLOCKS_PER_PERIOD)
+        * (1 - np.exp(-2 * np.pi * MAGNTE_BLOCK_HEIGHT_MM / undulator_period_mm))
+    )
+
+
 def calculate_gap_i09_hu(
     photon_energy_kev: float,
-    look_up_table: dict[int, "np.ndarray"],
+    look_up_table: dict[int, np.ndarray],
     order: int = 1,
     gap_offset: float = 0.0,
     undulator_period_mm: int = 27,
@@ -52,13 +88,9 @@ def calculate_gap_i09_hu(
     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
+    _validate_order(order, look_up_table)
+    gamma = _calculate_gamma(look_up_table, order)
 
     # 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...
@@ -83,17 +115,8 @@ def calculate_gap_i09_hu(
     # 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))
+    undulator_parameter_max = _calculate_undulator_parameter_max(
+        look_up_table[order][MAGNET_FIELD_COLUMN], undulator_period_mm
     )
 
     # Finnaly, rearranging the equation:
@@ -109,3 +132,44 @@ def calculate_gap_i09_hu(
     )
 
     return gap
+
+
+def calculate_energy_i09_hu(
+    gap: float,
+    look_up_table: dict[int, "np.ndarray"],
+    order: int = 1,
+    gap_offset: float = 0.0,
+    undulator_period_mm: int = 27,
+) -> float:
+    """
+    Calculate the photon energy produced by the undulator at a given gap and harmonic order.
+    Reverse of the calculate_gap_i09_hu function.
+
+    Args:
+        gap (float): Undulator gap in millimeters.
+        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 energy. 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 photon energy in keV.
+    """
+    _validate_order(order, look_up_table)
+
+    gamma = _calculate_gamma(look_up_table, order)
+    undulator_parameter_max = _calculate_undulator_parameter_max(
+        look_up_table[order][MAGNET_FIELD_COLUMN], undulator_period_mm
+    )
+
+    undulator_parameter = undulator_parameter_max / np.exp(
+        (gap - look_up_table[order][GAP_OFFSET_COLUMN] - gap_offset)
+        / (undulator_period_mm / np.pi)
+    )
+    energy_kev = (
+        4.959368e-6
+        * order
+        * np.square(gamma)
+        / (undulator_period_mm * (np.square(undulator_parameter) + 2))
+    )
+    return energy_kev

dodal/devices/i09_2_shared/i09_apple2.py

@@ -0,0 +1,86 @@
+from dodal.devices.insertion_device.apple2_undulator import (
+    MAXIMUM_MOVE_TIME,
+    Apple2,
+    Apple2Controller,
+    Apple2PhasesVal,
+    Apple2Val,
+    Pol,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
+
+J09_GAP_POLY_DEG_COLUMNS = [
+    "9th-order",
+    "8th-order",
+    "7th-order",
+    "6th-order",
+    "5th-order",
+    "4th-order",
+    "3rd-order",
+    "2nd-order",
+    "1st-order",
+    "0th-order",
+]
+
+J09_PHASE_POLY_DEG_COLUMNS = ["0th-order"]
+
+
+class J09Apple2Controller(Apple2Controller[Apple2[UndulatorPhaseAxes]]):
+    def __init__(
+        self,
+        apple2: Apple2[UndulatorPhaseAxes],
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
+        units: str = "keV",
+        name: str = "",
+    ) -> None:
+        """
+        Parameters:
+        -----------
+        apple2 : Apple2
+            An Apple2 device.
+        gap_energy_motor_lut: EnergyMotorLookup
+            The class that handles the gap look up table logic for the insertion device.
+        phase_energy_motor_lut: EnergyMotorLookup
+            The class that handles the phase look up table logic for the insertion device.
+        units:
+            the units of this device. Defaults to eV.
+        name : str, optional
+            New device name.
+        """
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
+        super().__init__(
+            apple2=apple2,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            units=units,
+            name=name,
+        )
+
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        return Apple2Val(
+            gap=f"{gap:.6f}",
+            phase=Apple2PhasesVal(
+                top_outer=f"{phase:.6f}",
+                top_inner=f"{0.0:.6f}",
+                btm_inner=f"{phase:.6f}",
+                btm_outer=f"{0.0:.6f}",
+            ),
+        )
+
+    async def _set_pol(
+        self,
+        value: Pol,
+    ) -> None:
+        # I09 require all palarisation change to go via LH.
+        target_energy = await self.energy.get_value()
+        if value is not Pol.LH:
+            self._polarisation_setpoint_set(Pol.LH)
+            max_lh_energy = self.gap_energy_motor_lut.lut.root[Pol.LH].max_energy
+            lh_setpoint = (
+                max_lh_energy if target_energy > max_lh_energy else target_energy
+            )
+            await self.energy.set(lh_setpoint, timeout=MAXIMUM_MOVE_TIME)
+        self._polarisation_setpoint_set(value)
+        await self.energy.set(target_energy, timeout=MAXIMUM_MOVE_TIME)