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

dodal/devices/electron_analyser/specs/{region.py → specs_region.py}

@@ -2,12 +2,13 @@ from typing import Generic
 
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
+    TLensMode,
+    TPsuMode,
 )
-from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
-from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
+from dodal.devices.electron_analyser.specs.specs_enums import AcquisitionMode
 
 
 class SpecsRegion(

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -1,7 +1,7 @@
-from .detector import VGScientaDetector
-from .driver_io import VGScientaAnalyserDriverIO
-from .enums import AcquisitionMode, DetectorMode
-from .region import VGScientaRegion, VGScientaSequence
+from .vgscienta_detector import VGScientaDetector
+from .vgscienta_driver_io import VGScientaAnalyserDriverIO
+from .vgscienta_enums import AcquisitionMode, DetectorMode
+from .vgscienta_region import VGScientaRegion, VGScientaSequence
 
 __all__ = [
     "VGScientaDetector",

dodal/devices/electron_analyser/vgscienta/vgscienta_detector.py

@@ -0,0 +1,52 @@
+from typing import Generic
+
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.base.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
+from dodal.devices.electron_analyser.vgscienta.vgscienta_driver_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
+    TPassEnergyEnum,
+    VGScientaRegion,
+    VGScientaSequence,
+)
+
+
+class VGScientaDetector(
+    ElectronAnalyserDetector[
+        VGScientaSequence[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
+    ],
+    Generic[TLensMode, TPsuMode, TPassEnergyEnum],
+):
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
+        pass_energy_type: type[TPassEnergyEnum],
+        energy_source: DualEnergySource | EnergySource,
+        name: str = "",
+    ):
+        # Save to class so takes part with connect()
+        self.driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type
+        )
+
+        controller = ElectronAnalyserController[
+            VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+            VGScientaRegion[TLensMode, TPassEnergyEnum],
+        ](self.driver, energy_source, 0)
+
+        sequence_class = VGScientaSequence[
+            lens_mode_type, psu_mode_type, pass_energy_type
+        ]
+        super().__init__(sequence_class, controller, name)

dodal/devices/electron_analyser/vgscienta/{driver_io.py → vgscienta_driver_io.py}

@@ -4,28 +4,22 @@ from typing import Generic
 import numpy as np
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadableFormat,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
+from dodal.devices.electron_analyser.base.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.types import (
-    TLensMode,
-    TPassEnergyEnum,
-    TPsuMode,
-)
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.vgscienta.enums import (
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.vgscienta.vgscienta_enums import (
     AcquisitionMode,
     DetectorMode,
 )
-from dodal.devices.electron_analyser.vgscienta.region import (
+from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
+    TPassEnergyEnum,
     VGScientaRegion,
 )
 
@@ -46,7 +40,6 @@ class VGScientaAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -67,28 +60,29 @@ class VGScientaAnalyserDriverIO(
             lens_mode_type,
             psu_mode_type,
             pass_energy_type,
-            energy_source,
             name,
         )
 
-    async def _set_region(self, ke_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         await asyncio.gather(
-            self.region_name.set(ke_region.name),
-            self.low_energy.set(ke_region.low_energy),
-            self.centre_energy.set(ke_region.centre_energy),
-            self.high_energy.set(ke_region.high_energy),
-            self.slices.set(ke_region.slices),
-            self.lens_mode.set(ke_region.lens_mode),
-            self.pass_energy.set(ke_region.pass_energy),
-            self.iterations.set(ke_region.iterations),
-            self.acquire_time.set(ke_region.acquire_time),
-            self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.energy_step.set(ke_region.energy_step),
-            self.detector_mode.set(ke_region.detector_mode),
-            self.region_min_x.set(ke_region.min_x),
-            self.region_size_x.set(ke_region.size_x),
-            self.region_min_y.set(ke_region.min_y),
-            self.region_size_y.set(ke_region.size_y),
+            self.region_name.set(epics_region.name),
+            self.low_energy.set(epics_region.low_energy),
+            self.centre_energy.set(epics_region.centre_energy),
+            self.high_energy.set(epics_region.high_energy),
+            self.slices.set(epics_region.slices),
+            self.lens_mode.set(epics_region.lens_mode),
+            self.pass_energy.set(epics_region.pass_energy),
+            self.iterations.set(epics_region.iterations),
+            self.acquire_time.set(epics_region.acquire_time),
+            self.acquisition_mode.set(epics_region.acquisition_mode),
+            self.energy_step.set(epics_region.energy_step),
+            self.detector_mode.set(epics_region.detector_mode),
+            self.region_min_x.set(epics_region.min_x),
+            self.region_size_x.set(epics_region.size_x),
+            self.region_min_y.set(epics_region.min_y),
+            self.region_size_y.set(epics_region.size_y),
+            self.energy_mode.set(epics_region.energy_mode),
         )
 
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:

dodal/devices/electron_analyser/vgscienta/{region.py → vgscienta_region.py}

@@ -1,22 +1,22 @@
 import uuid
-from typing import Generic
+from typing import Generic, TypeVar
 
+from ophyd_async.core import StrictEnum
 from pydantic import Field, field_validator
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
-)
-from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
-    TPassEnergyEnum,
     TPsuMode,
 )
-from dodal.devices.electron_analyser.vgscienta.enums import (
+from dodal.devices.electron_analyser.vgscienta.vgscienta_enums import (
     AcquisitionMode,
     DetectorMode,
 )
 
+TPassEnergyEnum = TypeVar("TPassEnergyEnum", bound=StrictEnum)
+
 
 class VGScientaRegion(
     AbstractBaseRegion[AcquisitionMode, TLensMode, TPassEnergyEnum],

dodal/devices/i09_2_shared/i09_apple2.py

@@ -1,14 +1,3 @@
-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",
@@ -23,64 +12,3 @@ J09_GAP_POLY_DEG_COLUMNS = [
 ]
 
 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)

dodal/devices/i10/i10_apple2.py

@@ -11,18 +11,18 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 
-from dodal.devices.insertion_device.apple2_undulator import (
+from dodal.devices.insertion_device import (
     MAXIMUM_MOVE_TIME,
     Apple2,
     Apple2Controller,
     Apple2PhasesVal,
     Apple2Val,
-    Pol,
     UndulatorGap,
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
 from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
+from dodal.devices.insertion_device.id_enum import Pol
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0

dodal/devices/i21/__init__.py

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

dodal/devices/insertion_device/__init__.py

@@ -0,0 +1,58 @@
+from .apple2_undulator import (
+    DEFAULT_MOTOR_MIN_TIMEOUT,
+    MAXIMUM_MOVE_TIME,
+    Apple2,
+    Apple2Controller,
+    Apple2EnforceLHMoveController,
+    Apple2LockedPhasesVal,
+    Apple2PhasesVal,
+    Apple2Val,
+    BeamEnergy,
+    EnabledDisabledUpper,
+    EnergyMotorConvertor,
+    InsertionDeviceEnergy,
+    InsertionDevicePolarisation,
+    UndulatorGap,
+    UndulatorJawPhase,
+    UndulatorLockedPhaseAxes,
+    UndulatorPhaseAxes,
+)
+from .energy_motor_lookup import (
+    ConfigServerEnergyMotorLookup,
+    EnergyMotorLookup,
+)
+from .id_enum import Pol, UndulatorGateStatus
+from .lookup_table_models import (
+    EnergyCoverage,
+    LookupTable,
+    LookupTableColumnConfig,
+    convert_csv_to_lookup,
+)
+
+__all__ = [
+    "Apple2",
+    "Apple2Controller",
+    "Apple2EnforceLHMoveController",
+    "UndulatorGap",
+    "UndulatorPhaseAxes",
+    "UndulatorJawPhase",
+    "Apple2Val",
+    "Apple2PhasesVal",
+    "MAXIMUM_MOVE_TIME",
+    "LookupTable",
+    "LookupTableColumnConfig",
+    "convert_csv_to_lookup",
+    "InsertionDeviceEnergy",
+    "InsertionDevicePolarisation",
+    "BeamEnergy",
+    "UndulatorLockedPhaseAxes",
+    "EnergyCoverage",
+    "Pol",
+    "DEFAULT_MOTOR_MIN_TIMEOUT",
+    "EnabledDisabledUpper",
+    "UndulatorGateStatus",
+    "Apple2LockedPhasesVal",
+    "EnergyMotorLookup",
+    "ConfigServerEnergyMotorLookup",
+    "EnergyMotorConvertor",
+]

dodal/devices/insertion_device/apple2_undulator.py

@@ -14,7 +14,6 @@ from ophyd_async.core import (
     SignalW,
     StandardReadable,
     StandardReadableFormat,
-    StrictEnum,
     derived_signal_rw,
     soft_signal_r_and_setter,
     soft_signal_rw,
@@ -24,6 +23,8 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.enums import EnabledDisabledUpper
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
+from dodal.devices.insertion_device.id_enum import Pol, UndulatorGateStatus
 from dodal.log import LOGGER
 
 T = TypeVar("T")
@@ -32,11 +33,6 @@ DEFAULT_MOTOR_MIN_TIMEOUT = 10
 MAXIMUM_MOVE_TIME = 550  # There is no useful movements take longer than this.
 
 
-class UndulatorGateStatus(StrictEnum):
-    OPEN = "Open"
-    CLOSE = "Closed"
-
-
 @dataclass
 class Apple2LockedPhasesVal:
     top_outer: str
@@ -58,16 +54,6 @@ class Apple2Val:
         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
@@ -666,6 +652,70 @@ class Apple2Controller(abc.ABC, StandardReadable, Generic[Apple2Type]):
         return Pol.NONE, 0.0
 
 
+class Apple2EnforceLHMoveController(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,
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
+        units: str = "eV",
+        name: str = "",
+    ) -> None:
+        self.gap_energy_motor_lu = gap_energy_motor_lut
+        self.phase_energy_motor_lu = 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:
+        apple2_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"Getting apple2 value for pol={pol}, gap={gap}, phase={phase}.")
+        LOGGER.info(f"Apple2 motor values: {apple2_val}.")
+
+        return apple2_val
+
+    async def _set_pol(
+        self,
+        value: Pol,
+    ) -> None:
+        # I09/I21 require all polarisation change to go via LH.
+        current_pol = await self.polarisation.get_value()
+        if current_pol == value:
+            LOGGER.info(f"Polarisation already at {value}")
+        else:
+            target_energy = await self.energy.get_value()
+            if (value is not Pol.LH) and (current_pol is not Pol.LH):
+                self._polarisation_setpoint_set(Pol.LH)
+                max_lh_energy = float(
+                    self.gap_energy_motor_lu.lut.root[Pol("lh")].max_energy
+                )
+                lh_setpoint = (
+                    max_lh_energy if target_energy > max_lh_energy else target_energy
+                )
+                LOGGER.info(f"Changing polarisation to {value} via {Pol.LH}")
+                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."""
 

dodal/devices/insertion_device/energy_motor_lookup.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from daq_config_server.client import ConfigServer
 
-from dodal.devices.insertion_device.apple2_undulator import Pol
+from dodal.devices.insertion_device.id_enum import Pol
 from dodal.devices.insertion_device.lookup_table_models import (
     LookupTable,
     LookupTableColumnConfig,

dodal/devices/insertion_device/id_enum.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import StrictEnum
+
+
+class Pol(StrictEnum):
+    NONE = "None"
+    LH = "lh"
+    LV = "lv"
+    PC = "pc"
+    NC = "nc"
+    LA = "la"
+    LH3 = "lh3"
+    LV3 = "lv3"
+
+
+class UndulatorGateStatus(StrictEnum):
+    OPEN = "Open"
+    CLOSE = "Closed"