1663 i09 energy (#1672)

* add i09 look up table praiser

* move get_poly to lookuptable

* extracted EnergyMotorLookup base class from i10EnergyMotorLookup

* added new make_phase_tables function

* add test for correct table output

* remove_i09

* add docstring

* add test for helper functions

* add test for skipping

* group and reuse fixture, add J09 controller and tests

* there is no reason to set mock value to zero

* spacing fix

* remove print

* add gap tests

* add controller, energy and polarisation to i09_2 configuration

* move path to top

* add model_validation

* remove debug

* Update docstring for energy_jid function

* Update nc parameter and phase calculation logic

Change 'nc' parameter to negative ROW_PHASE_CIRCULAR and adjust phase calculation based on pol.

* Refactor Lookuptable class documentation

Removed outdated docstring from Lookuptable class and updated initialization docstring for I10EnergyMotorLookup class.

* update expected lookup table after sign change

* change lookup table schema to snake case

* replace dictionary with basemodel

* add tying

* add gap and phase

* fat finger correction

* Update ID lookup logic to use type checking

* Fix some tests

* Improve models to not use shared defaults

* undo syntax error

* Fixed test to check for success on loading i10 lut

* Simplified lut logic

* Added back generate_lookup_table function

* Fixed all tests but polarisation

* Updated doc strings

* Moved generic test from i10 to test_lookup_table_apple2

* Renamed lut_column_config to lut_config

* Updated more doc strings

* Fix default phase_file name and thus tests

* Use Pol in LookupTable rather than string

* Updated test_convert_csv_to_lookup_overwrite_name_convert_default to use Pol

* Update tests to use Pol rather str value

* fix tests

* fix i09 controller and test

* reuse fixture

* Improve EnergyCoverageEntry to have a poly serializer and EnergyCoverage to use float as key

* Add type checking to i10Apple2 phase

* Removed commente out code

* Update i10 id tests to use json files rather than pickle files so they are human readable

* Remove comments

* Fixed poly test

* Fixed test_make_phase_tables_multiple_entries

* Added test_lookup_table_is_serialisable

* Update src/dodal/devices/util/lookup_tables_apple2.py

Co-authored-by: Raymond Fan <[email protected]>

* Fixed formatting

* Improved code coverage

* Simplified ID lookup table logic

* Updated doc strings, tidy tests and variable names

* Made default files a constant

* added gap and phase lookup

* Update logging messages

* Removed duplicate test logic

* Decoupled path from LookupTableConfig, updated convert_csv_to_lookup to use file_contents again

* Updated doc strings

* Clean up imports

* fixed test

* update and reuse fixture

* change I09 to use json data

* fix controller

* add test for Path not given

* correct test

* typing

* modify _setpol to go to lh first for i09 id

* Rename class and update comments for clarity

* Remove POLY_DEG list from test_i09_apple2.py

Removed the POLY_DEG list from the test file.

* fix lint

* remove I09EnergyMotorLookup and move phase generation into EnergyMotorlookup

* move lookup table path into lut_config

* revert lookuptable with path

* introduce spacing to data

* Update src/dodal/devices/util/lookup_tables_apple2.py

Co-authored-by: oliwenmandiamond <[email protected]>

* Update src/dodal/devices/util/lookup_tables_apple2.py

Co-authored-by: oliwenmandiamond <[email protected]>

* remove J09defaultlookuptable

* remove default in test

* lint

* update ophyd

* Apply suggestions from code review

Co-authored-by: oliwenmandiamond <[email protected]>

* fix typo

* fix file name and test

* correct pytest_plugin location

* undo unwanted change in i10_optics

---------

Co-authored-by: oliwenmandiamond <[email protected]>
Co-authored-by: Oli Wenman <[email protected]>

Author: Relm-Arrowny

src/dodal/beamlines/i09_2.py

@@ -1,18 +1,35 @@
+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,
+    InsertionDeviceEnergy,
+    InsertionDevicePolarisation,
     UndulatorGap,
     UndulatorPhaseAxes,
 )
 from dodal.devices.i09.enums import Grating
+from dodal.devices.i09_2_shared.i09_apple2 import (
+    J09_POLY_DEG,
+    EnergyMotorLookup,
+    J09Apple2Controller,
+)
 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
 
+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 +72,32 @@ def jid() -> Apple2:
         id_gap=jid_gap(),
         id_phase=jid_phase(),
     )
+
+
+@device_factory()
+def jid_controller() -> J09Apple2Controller:
+    """J09 insertion device controller."""
+    return J09Apple2Controller(
+        apple2=jid(),
+        energy_motor_lut=EnergyMotorLookup(
+            lut_config=LookupTableConfig(poly_deg=J09_POLY_DEG),
+            config_client=J09_CONF_CLIENT,
+            gap_path=Path(LOOK_UPTABLE_DIR, GAP_LOOKUP_FILE_NAME),
+        ),
+    )
+
+
+@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/devices/apple2_undulator.py

@@ -449,6 +449,7 @@ def __init__(
         self,
         apple2: Apple2Type,
         energy_to_motor_converter: EnergyMotorConvertor,
+        units: str = "eV",
         name: str = "",
     ) -> None:
         """
@@ -465,14 +466,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.

src/dodal/devices/i09_2_shared/__init__.py

@@ -0,0 +1,80 @@
+from dodal.devices.apple2_undulator import (
+    MAXIMUM_MOVE_TIME,
+    Apple2,
+    Apple2Controller,
+    Apple2PhasesVal,
+    Apple2Val,
+    Pol,
+)
+from dodal.devices.util.lookup_tables_apple2 import (
+    EnergyMotorLookup,
+)
+from dodal.log import LOGGER
+
+J09_POLY_DEG = [
+    "9th-order",
+    "8th-order",
+    "7th-order",
+    "6th-order",
+    "5th-order",
+    "4th-order",
+    "3rd-order",
+    "2nd-order",
+    "1st-order",
+    "0th-order",
+]
+
+
+class J09Apple2Controller(Apple2Controller[Apple2]):
+    def __init__(
+        self,
+        apple2: Apple2,
+        energy_motor_lut: EnergyMotorLookup,
+        units: str = "keV",
+        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)

src/dodal/devices/i09_2_shared/i09_apple2.py

@@ -46,10 +46,6 @@
 from dodal.devices.apple2_undulator import Pol
 from dodal.log import LOGGER
 
-DEFAULT_GAP_FILE = "IDEnergy2GapCalibrations.csv"
-DEFAULT_PHASE_FILE = "IDEnergy2PhaseCalibrations.csv"
-
-
 DEFAULT_POLY_DEG = [
     "7th-order",
     "6th-order",
@@ -61,7 +57,22 @@
     "b",
 ]
 
-MODE_NAME_CONVERT = {"CR": "pc", "CL": "nc"}
+MODE_NAME_CONVERT = {"cr": "pc", "cl": "nc"}
+DEFAULT_GAP_FILE = "IDEnergy2GapCalibrations.csv"
+DEFAULT_PHASE_FILE = "IDEnergy2PhaseCalibrations.csv"
+
+ROW_PHASE_MOTOR_TOLERANCE = 0.004
+ROW_PHASE_CIRCULAR = 15
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+MAXIMUM_GAP_MOTOR_POSITION = 100
+
+PhASE_POLY1D_PARAMETERS = {
+    Pol.LH: [0],
+    Pol.LV: [MAXIMUM_ROW_PHASE_MOTOR_POSITION],
+    Pol.PC: [ROW_PHASE_CIRCULAR],
+    Pol.NC: [-ROW_PHASE_CIRCULAR],
+    Pol.LH3: [0],
+}
 
 
 class LookupTableConfig(BaseModel):
@@ -216,7 +227,7 @@ def get_poly(
     Parameters:
     -----------
     energy:
-        Energy value in the same units used to create the lookup table (eV).
+        Energy value in the same units used to create the lookup table.
     pol:
         Polarisation mode (Pol enum).
     lookup_table:
@@ -305,8 +316,8 @@ def __init__(
         self,
         config_client: ConfigServer,
         lut_config: LookupTableConfig,
-        gap_path: Path,
-        phase_path: Path,
+        gap_path: Path | None = None,
+        phase_path: Path | None = None,
     ):
         """Initialise the EnergyMotorLookup class with lookup table headers provided.
 
@@ -321,11 +332,11 @@ def __init__(
         phase_path:
             File path to the phase lookup table.
         """
+        self.gap_path = gap_path
+        self.phase_path = phase_path
         self.lookup_tables = GapPhaseLookupTables()
         self.config_client = config_client
         self.lut_config = lut_config
-        self.gap_path = gap_path
-        self.phase_path = phase_path
         self._available_pol = []
 
     @property
@@ -337,6 +348,8 @@ def available_pol(self, value: list[Pol]) -> None:
         self._available_pol = value
 
     def _update_gap_lut(self) -> None:
+        if self.gap_path is None:
+            raise RuntimeError("Gap path is not provided!")
         file_contents = self.config_client.get_file_contents(
             self.gap_path, reset_cached_result=True
         )
@@ -346,6 +359,8 @@ def _update_gap_lut(self) -> None:
         self.available_pol = list(self.lookup_tables.gap.root.keys())
 
     def _update_phase_lut(self) -> None:
+        if self.phase_path is None:
+            raise RuntimeError("Phase path is not provided!")
         file_contents = self.config_client.get_file_contents(
             self.phase_path, reset_cached_result=True
         )
@@ -357,10 +372,24 @@ def update_lookuptables(self):
         """
         Update lookup tables from files and validate their format.
         """
-        LOGGER.info("Updating lookup table from file for gap.")
+        LOGGER.info("Updating lookup table for gap.")
         self._update_gap_lut()
-        LOGGER.info("Updating lookup table from file for phase.")
-        self._update_phase_lut()
+        if self.phase_path is None:
+            LOGGER.info("Generating lookup table for phase.")
+            self._generate_phase_lut()
+
+        else:
+            LOGGER.info("Updating lookup table for phase.")
+            self._update_phase_lut()
+
+    def _generate_phase_lut(self):
+        for key in self.lookup_tables.gap.root.keys():
+            if key is not None:
+                self.lookup_tables.phase.root[key] = generate_lookup_table_entry(
+                    min_energy=self.lookup_tables.gap.root[key].limit.minimum,
+                    max_energy=self.lookup_tables.gap.root[key].limit.maximum,
+                    poly1d_param=(PhASE_POLY1D_PARAMETERS[key]),
+                )
 
     def get_motor_from_energy(self, energy: float, pol: Pol) -> tuple[float, float]:
         """

src/dodal/devices/util/lookup_tables_apple2.py

@@ -0,0 +1,78 @@
+from unittest.mock import MagicMock
+
+import pytest
+from daq_config_server.client import ConfigServer
+from ophyd_async.core import (
+    init_devices,
+    set_mock_value,
+)
+
+from dodal.devices.apple2_undulator import (
+    EnabledDisabledUpper,
+    UndulatorGap,
+    UndulatorGateStatus,
+    UndulatorJawPhase,
+    UndulatorPhaseAxes,
+)
+
+
+@pytest.fixture
+def mock_config_client() -> ConfigServer:
+    mock_config_client = ConfigServer()
+
+    mock_config_client.get_file_contents = MagicMock(spec=["get_file_contents"])
+
+    def my_side_effect(file_path, reset_cached_result) -> str:
+        assert reset_cached_result is True
+        with open(file_path) as f:
+            return f.read()
+
+    mock_config_client.get_file_contents.side_effect = my_side_effect
+    return mock_config_client
+
+
+@pytest.fixture
+async def mock_id_gap(prefix: str = "BLXX-EA-DET-007:") -> UndulatorGap:
+    async with init_devices(mock=True):
+        mock_id_gap = UndulatorGap(prefix, "mock_id_gap")
+    assert mock_id_gap.name == "mock_id_gap"
+    set_mock_value(mock_id_gap.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_id_gap.velocity, 1)
+    set_mock_value(mock_id_gap.user_readback, 1)
+    set_mock_value(mock_id_gap.user_setpoint, "1")
+    set_mock_value(mock_id_gap.status, EnabledDisabledUpper.ENABLED)
+    return mock_id_gap
+
+
+@pytest.fixture
+async def mock_phase_axes(prefix: str = "BLXX-EA-DET-007:") -> UndulatorPhaseAxes:
+    async with init_devices(mock=True):
+        mock_phase_axes = UndulatorPhaseAxes(
+            prefix=prefix,
+            top_outer="RPQ1",
+            top_inner="RPQ2",
+            btm_outer="RPQ3",
+            btm_inner="RPQ4",
+        )
+    assert mock_phase_axes.name == "mock_phase_axes"
+    set_mock_value(mock_phase_axes.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_phase_axes.top_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.top_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_outer.velocity, 2)
+    set_mock_value(mock_phase_axes.btm_inner.velocity, 2)
+    set_mock_value(mock_phase_axes.status, EnabledDisabledUpper.ENABLED)
+    return mock_phase_axes
+
+
+@pytest.fixture
+async def mock_jaw_phase(prefix: str = "BLXX-EA-DET-007:") -> UndulatorJawPhase:
+    async with init_devices(mock=True):
+        mock_jaw_phase = UndulatorJawPhase(
+            prefix=prefix, move_pv="RPQ1", jaw_phase="JAW"
+        )
+    set_mock_value(mock_jaw_phase.gate, UndulatorGateStatus.CLOSE)
+    set_mock_value(mock_jaw_phase.jaw_phase.velocity, 2)
+    set_mock_value(mock_jaw_phase.jaw_phase.user_readback, 0)
+    set_mock_value(mock_jaw_phase.jaw_phase.user_setpoint_readback, 0)
+    set_mock_value(mock_jaw_phase.status, EnabledDisabledUpper.ENABLED)
+    return mock_jaw_phase