1725 i21 energy devices

src/dodal/beamlines/i09_2.py

@@ -1,18 +1,34 @@
+from pathlib import Path
+
+from daq_config_server.client import ConfigServer
+
 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,
+    BeamEnergy,
+    FullMotionApple2Controller,
+    InsertionDeviceEnergy,
+    InsertionDevicePolarisation,
     UndulatorGap,
     UndulatorPhaseAxes,
 )
 from dodal.devices.i09.enums import Grating
+from dodal.devices.i09_2_shared.i09_apple2 import (
+    J09DefaultLookupTableConfig,
+)
 from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.util.lookup_tables_apple2 import EnergyMotorLookup
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
+J09_CONF_CLIENT = ConfigServer(url="https://daq-config.diamond.ac.uk")
+LOOK_UPTABLE_DIR = "/dls_sw/i09-2/software/gda/workspace_git/gda-diamond.git/configurations/i09-2-shared/lookupTables/"
+GAP_LOOKUP_FILE_NAME = "JIDEnergy2GapCalibrations.csv"
+
 BL = get_beamline_name("i09-2")
 PREFIX = BeamlinePrefix(BL, suffix="J")
 set_log_beamline(BL)
@@ -55,3 +71,33 @@ def jid() -> Apple2:
         id_gap=jid_gap(),
         id_phase=jid_phase(),
     )
+
+
+@device_factory()
+def jid_controller() -> FullMotionApple2Controller:
+    """J09 insertion device controller."""
+    J09DefaultLookupTableConfig.gap_path = Path(LOOK_UPTABLE_DIR, GAP_LOOKUP_FILE_NAME)
+    return FullMotionApple2Controller(
+        apple2=jid(),
+        energy_motor_lut=EnergyMotorLookup(
+            lut_config=J09DefaultLookupTableConfig,
+            config_client=J09_CONF_CLIENT,
+        ),
+        units="keV",
+    )
+
+
+@device_factory()
+def jid_energy() -> InsertionDeviceEnergy:
+    return InsertionDeviceEnergy(id_controller=jid_controller())
+
+
+@device_factory()
+def jid_polarisation() -> InsertionDevicePolarisation:
+    return InsertionDevicePolarisation(id_controller=jid_controller())
+
+
+@device_factory()
+def energy_jid() -> BeamEnergy:
+    """Beam energy."""
+    return BeamEnergy(id_energy=jid_energy(), mono=pgm().energy)

src/dodal/beamlines/i10_optics.py

@@ -50,8 +50,6 @@
 set_utils_beamline(BL)
 PREFIX = BeamlinePrefix(BL)
 
-LOOK_UPTABLE_DIR = "/dls_sw/i10/software/blueapi/scratch/i10-config/lookupTables/"
-
 
 @device_factory()
 def synchrotron() -> Synchrotron:
@@ -125,9 +123,11 @@ def idd_controller() -> I10Apple2Controller:
     """I10 downstream insertion device controller."""
     idd_energy_motor_lut = EnergyMotorLookup(
         config_client=I10_CONF_CLIENT,
-        lut_config=LookupTableConfig(source=("Source", "idd")),
-        gap_path=Path(LOOK_UPTABLE_DIR, DEFAULT_GAP_FILE),
-        phase_path=Path(LOOK_UPTABLE_DIR, DEFAULT_PHASE_FILE),
+        lut_config=LookupTableConfig(
+            source=("Source", "idd"),
+            gap_path=Path(LOOK_UPTABLE_DIR, DEFAULT_GAP_FILE),
+            phase_path=Path(LOOK_UPTABLE_DIR, DEFAULT_PHASE_FILE),
+        ),
     )
     return I10Apple2Controller(apple2=idd(), energy_motor_lut=idd_energy_motor_lut)
 
@@ -190,9 +190,11 @@ def idu_controller() -> I10Apple2Controller:
     """I10 upstream insertion device controller."""
     idu_energy_motor_lut = EnergyMotorLookup(
         config_client=I10_CONF_CLIENT,
-        lut_config=LookupTableConfig(source=("Source", "idu")),
-        gap_path=Path(LOOK_UPTABLE_DIR, DEFAULT_GAP_FILE),
-        phase_path=Path(LOOK_UPTABLE_DIR, DEFAULT_PHASE_FILE),
+        lut_config=LookupTableConfig(
+            source=("Source", "idu"),
+            gap_path=Path(LOOK_UPTABLE_DIR, DEFAULT_GAP_FILE),
+            phase_path=Path(LOOK_UPTABLE_DIR, DEFAULT_PHASE_FILE),
+        ),
     )
     return I10Apple2Controller(apple2=idd(), energy_motor_lut=idu_energy_motor_lut)
 

src/dodal/beamlines/i21.py

@@ -1,18 +1,30 @@
+from pathlib import Path
+
+from daq_config_server.client import ConfigServer
+
 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,
+    BeamEnergy,
+    FullMotionApple2Controller,
+    InsertionDeviceEnergy,
+    InsertionDevicePolarisation,
     UndulatorGap,
     UndulatorPhaseAxes,
 )
-from dodal.devices.i21 import Grating
+from dodal.devices.i21 import Grating, I21EnergyMotorLookup
 from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.util.lookup_tables_apple2 import LookupTableConfig
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
+I21_CONF_CLIENT = ConfigServer(url="https://daq-config.diamond.ac.uk")
+LOOK_UPTABLE_DIR = "/dls_sw/i21/software/gda/workspace_git/gda-diamond.git/configurations/i21-config/lookupTables/"
+GAP_LOOKUP_FILE_NAME = "IDEnergy2GapCalibrations.csv"
 BL = get_beamline_name("i21")
 PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
@@ -55,3 +67,34 @@ def id() -> Apple2:
         id_gap=id_gap(),
         id_phase=id_phase(),
     )
+
+
+@device_factory()
+def id_controller() -> FullMotionApple2Controller:
+    """i21 insertion device controller."""
+    return FullMotionApple2Controller(
+        apple2=id(),
+        energy_motor_lut=I21EnergyMotorLookup(
+            lut_config=LookupTableConfig(
+                grading="Grating", gap_path=Path(LOOK_UPTABLE_DIR, GAP_LOOKUP_FILE_NAME)
+            ),
+            config_client=I21_CONF_CLIENT,
+        ),
+        units="eV",
+    )
+
+
+@device_factory()
+def id_energy() -> InsertionDeviceEnergy:
+    return InsertionDeviceEnergy(id_controller=id_controller())
+
+
+@device_factory()
+def id_polarisation() -> InsertionDevicePolarisation:
+    return InsertionDevicePolarisation(id_controller=id_controller())
+
+
+@device_factory()
+def energy_jid() -> BeamEnergy:
+    """Beam energy."""
+    return BeamEnergy(id_energy=id_energy(), mono=pgm().energy)

src/dodal/devices/apple2_undulator.py

@@ -24,6 +24,7 @@
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.enums import EnabledDisabledUpper
+from dodal.devices.util.lookup_tables_apple2 import EnergyMotorLookup, Pol
 from dodal.log import LOGGER
 
 T = TypeVar("T")
@@ -58,16 +59,6 @@ def extract_phase_val(self):
         return self.phase
 
 
-class Pol(StrictEnum):
-    NONE = "None"
-    LH = "lh"
-    LV = "lv"
-    PC = "pc"
-    NC = "nc"
-    LA = "la"
-    LH3 = "lh3"
-
-
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
 MAXIMUM_GAP_MOTOR_POSITION = 100
@@ -449,6 +440,7 @@ def __init__(
         self,
         apple2: Apple2Type,
         energy_to_motor_converter: EnergyMotorConvertor,
+        units: str = "eV",
         name: str = "",
     ) -> None:
         """
@@ -465,14 +457,14 @@ def __init__(
 
         # Store the set energy for readback.
         self._energy, self._energy_set = soft_signal_r_and_setter(
-            float, initial_value=None, units="eV"
+            float, initial_value=None, units=units
         )
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.energy = derived_signal_rw(
                 raw_to_derived=self._read_energy,
                 set_derived=self._set_energy,
                 energy=self._energy,
-                derived_units="eV",
+                derived_units=units,
             )
 
         # Store the polarisation for setpoint. And provide readback for LH3.
@@ -653,6 +645,67 @@ def determine_phase_from_hardware(
         return Pol.NONE, 0.0
 
 
+class FullMotionApple2Controller(Apple2Controller[Apple2]):
+    """The latest Apple2 version allows unrestricted motor movement.
+    However, because of the high forces involved in polarization changes,
+    all movements must be performed using the Linear Horizontal (LH) mode.
+    A look-up table must also be used to determine the highest energy that can
+    be reached in LH mode."""
+
+    def __init__(
+        self,
+        apple2: Apple2,
+        energy_motor_lut: EnergyMotorLookup,
+        units: str = "eV",
+        name: str = "",
+    ) -> None:
+        self.lookup_table_client = energy_motor_lut
+        super().__init__(
+            apple2=apple2,
+            energy_to_motor_converter=self.lookup_table_client.get_motor_from_energy,
+            units=units,
+            name=name,
+        )
+
+    async def _set_motors_from_energy(self, value: float) -> None:
+        """
+        Set the undulator motors for a given energy and polarisation.
+        """
+
+        pol = await self._check_and_get_pol_setpoint()
+        gap, phase = self.energy_to_motor(energy=value, pol=pol)
+        id_set_val = 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}",
+            ),
+        )
+
+        LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
+        await self.apple2().set(id_motor_values=id_set_val)
+
+    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 = float(
+                self.lookup_table_client.lookup_tables.gap.root[Pol("lh")].limit.maximum
+            )
+            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)
+
+
 class InsertionDeviceEnergyBase(abc.ABC, StandardReadable, Movable):
     """Base class for ID energy movable device."""
 

src/dodal/devices/i09_2_shared/i09_apple2.py

@@ -0,0 +1,22 @@
+from dodal.devices.util.lookup_tables_apple2 import (
+    LookupTableConfig,
+)
+
+J09DefaultLookupTableConfig = LookupTableConfig(
+    mode="Mode",
+    min_energy="MinEnergy",
+    max_energy="MaxEnergy",
+    poly_deg=[
+        "9th-order",
+        "8th-order",
+        "7th-order",
+        "6th-order",
+        "5th-order",
+        "4th-order",
+        "3rd-order",
+        "2nd-order",
+        "1st-order",
+        "0th-order",
+    ],
+    mode_name_convert={"cr": "pc", "cl": "nc"},
+)

src/dodal/devices/i21/__init__.py

@@ -1,3 +1,4 @@
 from dodal.devices.i21.enums import Grating
+from dodal.devices.i21.i21_apple2 import I21EnergyMotorLookup
 
-__all__ = ["Grating"]
+__all__ = ["Grating", "I21EnergyMotorLookup"]

src/dodal/devices/i21/i21_apple2.py

@@ -0,0 +1,26 @@
+from dodal.devices.i21.enums import Grating
+from dodal.devices.util.lookup_tables_apple2 import (
+    EnergyMotorLookup,
+    Pol,
+)
+
+
+class I21EnergyMotorLookup(EnergyMotorLookup):
+    """Add an helper function to get the correct grading from lookup table"""
+
+    def get_grating_from_energy(self, energy: float, pol: Pol) -> Grating:
+        if (
+            energy < self.lookup_tables.gap.root[pol].limit.minimum
+            or energy > self.lookup_tables.gap.root[pol].limit.maximum
+        ):
+            raise ValueError(
+                "Demanding energy must lie between"
+                + f" {self.lookup_tables.gap.root[pol].limit.minimum}"
+                + f" and {self.lookup_tables.gap.root[pol].limit.maximum} eV!"
+            )
+        else:
+            for energy_range in self.lookup_tables.gap.root[pol].energies.root.values():
+                if energy >= energy_range.low and energy < energy_range.high:
+                    if energy_range.grading is not None:
+                        return Grating[energy_range.grading]
+        raise ValueError("Grading undefine in lookup table")