dls-dodal 1.53.0__py3-none-any.whl → 1.55.0__py3-none-any.whl

dodal/devices/electron_analyser/abstract/types.py

@@ -0,0 +1,12 @@
+from typing import TypeVar
+
+from ophyd_async.core import StrictEnum, SupersetEnum
+
+TAcquisitionMode = TypeVar("TAcquisitionMode", bound=StrictEnum)
+# Allow SupersetEnum. Specs analysers can connect to Lens and Psu mode separately to the
+# analyser which leaves the enum to either be "Not connected" OR the available enums
+# when connected.
+TLensMode = TypeVar("TLensMode", bound=SupersetEnum | StrictEnum)
+TPsuMode = TypeVar("TPsuMode", bound=SupersetEnum | StrictEnum)
+TPassEnergy = TypeVar("TPassEnergy", bound=StrictEnum | float)
+TPassEnergyEnum = TypeVar("TPassEnergyEnum", bound=StrictEnum)

dodal/devices/electron_analyser/specs/detector.py

@@ -3,7 +3,7 @@ from typing import Generic
 
 from ophyd_async.core import SignalR
 
-from dodal.devices.electron_analyser.abstract.base_driver_io import TLensMode
+from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -13,21 +13,21 @@ from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSeque
 
 class SpecsDetector(
     ElectronAnalyserDetector[
-        SpecsAnalyserDriverIO[TLensMode],
-        SpecsSequence[TLensMode],
-        SpecsRegion[TLensMode],
+        SpecsAnalyserDriverIO[TLensMode, TPsuMode],
+        SpecsSequence[TLensMode, TPsuMode],
+        SpecsRegion[TLensMode, TPsuMode],
     ],
-    Generic[TLensMode],
+    Generic[TLensMode, TPsuMode],
 ):
     def __init__(
         self,
         prefix: str,
         lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
         energy_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ):
-        driver = SpecsAnalyserDriverIO[TLensMode](
-            prefix, lens_mode_type, energy_sources
+        driver = SpecsAnalyserDriverIO[TLensMode, TPsuMode](
+            prefix, lens_mode_type, psu_mode_type, energy_sources
         )
-        seq = SpecsSequence[lens_mode_type]
-        super().__init__(seq, driver, name)
+        super().__init__(SpecsSequence[lens_mode_type, psu_mode_type], driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -15,51 +15,88 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.base_region import TLensMode
+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.region import SpecsRegion
+from dodal.devices.electron_analyser.util import to_kinetic_energy
 
 
 class SpecsAnalyserDriverIO(
-    AbstractAnalyserDriverIO[SpecsRegion, AcquisitionMode, TLensMode],
-    Generic[TLensMode],
+    AbstractAnalyserDriverIO[
+        SpecsRegion[TLensMode, TPsuMode],
+        AcquisitionMode,
+        TLensMode,
+        TPsuMode,
+        float,
+    ],
+    Generic[TLensMode, TPsuMode],
 ):
     def __init__(
         self,
         prefix: str,
         lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
         energy_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
-            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
             self.snapshot_values = epics_signal_rw(int, prefix + "VALUES")
-            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
 
-            # Used to read detector data after acqusition.
-            self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
-            self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
-            self.energy_channels = epics_signal_r(
-                int, prefix + "TOTAL_POINTS_ITERATION_RBV"
-            )
+        # Used to calculate the angle axis.
+        self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
+        self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
 
-        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
+        # Used to calculate the energy axis.
+        self.energy_channels = epics_signal_r(
+            int, prefix + "TOTAL_POINTS_ITERATION_RBV"
+        )
+
+        super().__init__(
+            prefix=prefix,
+            acquisition_mode_type=AcquisitionMode,
+            lens_mode_type=lens_mode_type,
+            psu_mode_type=psu_mode_type,
+            pass_energy_type=float,
+            energy_sources=energy_sources,
+            name=name,
+        )
 
     @AsyncStatus.wrap
-    async def set(self, region: SpecsRegion[TLensMode]):
-        await super().set(region)
+    async def set(self, region: SpecsRegion[TLensMode, TPsuMode]):
+        source = self._get_energy_source(region.excitation_energy_source)
+        excitation_energy = await source.get_value()  # eV
 
+        low_energy = to_kinetic_energy(
+            region.low_energy, region.energy_mode, excitation_energy
+        )
+        centre_energy = to_kinetic_energy(
+            region.centre_energy, region.energy_mode, excitation_energy
+        )
+        high_energy = to_kinetic_energy(
+            region.high_energy, region.energy_mode, excitation_energy
+        )
         await asyncio.gather(
+            self.region_name.set(region.name),
+            self.energy_mode.set(region.energy_mode),
+            self.low_energy.set(low_energy),
+            self.high_energy.set(high_energy),
+            self.slices.set(region.slices),
+            self.lens_mode.set(region.lens_mode),
+            self.pass_energy.set(region.pass_energy),
+            self.iterations.set(region.iterations),
+            self.acquisition_mode.set(region.acquisition_mode),
+            self.excitation_energy.set(excitation_energy),
+            self.excitation_energy_source.set(source.name),
             self.snapshot_values.set(region.values),
             self.psu_mode.set(region.psu_mode),
         )
         if region.acquisition_mode == AcquisitionMode.FIXED_TRANSMISSION:
-            await self.centre_energy.set(region.centre_energy)
-
-        if self.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
             await self.energy_step.set(region.energy_step)
 
+        if region.acquisition_mode == AcquisitionMode.FIXED_ENERGY:
+            await self.centre_energy.set(centre_energy)
+
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         angle_axis = derived_signal_r(
             self._calculate_angle_axis,
@@ -97,7 +134,3 @@ class SpecsAnalyserDriverIO(
         step = (max_energy - min_energy) / (total_points_iterations - 1)
         axis = np.array([min_energy + i * step for i in range(total_points_iterations)])
         return axis
-
-    @property
-    def pass_energy_type(self) -> type:
-        return float

dodal/devices/electron_analyser/specs/region.py

@@ -5,27 +5,32 @@ from pydantic import Field
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
-    TLensMode,
 )
+from dodal.devices.electron_analyser.abstract.types import TLensMode, TPsuMode
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 
 
-class SpecsRegion(AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]):
+class SpecsRegion(
+    AbstractBaseRegion[AcquisitionMode, TLensMode, float],
+    Generic[TLensMode, TPsuMode],
+):
     # Override base class with defaults
     lens_mode: TLensMode
-    pass_energy: int = 5
+    pass_energy: float = 5
     acquisition_mode: AcquisitionMode = AcquisitionMode.FIXED_TRANSMISSION
     low_energy: float = Field(default=800, alias="start_energy")
+    centre_energy: float = 0
     high_energy: float = Field(default=850, alias="end_energy")
     step_time: float = Field(default=1.0, alias="exposure_time")
     energy_step: float = Field(default=0.1, alias="step_energy")
+
     # Specific to this class
     values: int = 1
-    centre_energy: float = 0
-    # ToDo - Update to an enum https://github.com/DiamondLightSource/dodal/issues/1328
-    psu_mode: str = "1.5kV"
+    psu_mode: TPsuMode
     estimated_time_in_ms: float = 0
 
 
-class SpecsSequence(AbstractBaseSequence[SpecsRegion, TLensMode], Generic[TLensMode]):
-    regions: list[SpecsRegion[TLensMode]] = Field(default_factory=lambda: [])
+class SpecsSequence(
+    AbstractBaseSequence[SpecsRegion[TLensMode, TPsuMode]], Generic[TLensMode, TPsuMode]
+):
+    regions: list[SpecsRegion[TLensMode, TPsuMode]] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/types.py

@@ -22,27 +22,36 @@ from dodal.devices.electron_analyser.vgscienta.detector import (
 
 AnyAcqMode = StrictEnum
 AnyLensMode = SupersetEnum | StrictEnum
+AnyPsuMode = SupersetEnum | StrictEnum
+AnyPassEnergy = StrictEnum | float
+AnyPassEnergyEnum = StrictEnum
 
 # Electron analyser types that encompasses all implementations, useful for tests and
 # plans
 ElectronAnalyserDetectorImpl = (
-    VGScientaDetector[AnyLensMode] | SpecsDetector[AnyLensMode]
+    VGScientaDetector[AnyLensMode, AnyPsuMode, AnyPassEnergyEnum]
+    | SpecsDetector[AnyLensMode, AnyPsuMode]
 )
 ElectronAnalyserDriverImpl = (
-    VGScientaAnalyserDriverIO[AnyLensMode] | SpecsAnalyserDriverIO[AnyLensMode]
+    VGScientaAnalyserDriverIO[AnyLensMode, AnyPsuMode, AnyPassEnergyEnum]
+    | SpecsAnalyserDriverIO[AnyLensMode, AnyPsuMode]
 )
 
 # Short hand the type so less verbose
-AbstractBaseRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode]
+AbstractBaseRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode, AnyPassEnergy]
 
 # Generic electron analyser types that supports full typing with the abstract classes.
 GenericElectronAnalyserDetector = ElectronAnalyserDetector[
-    AbstractAnalyserDriverIO[AbstractBaseRegion, AnyAcqMode, AnyLensMode],
-    AbstractBaseSequence[AbstractBaseRegion, AnyLensMode],
+    AbstractAnalyserDriverIO[
+        AbstractBaseRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
+    ],
+    AbstractBaseSequence[AbstractBaseRegion],
     AbstractBaseRegion,
 ]
 
 GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
-    AbstractAnalyserDriverIO[AbstractBaseRegion, AnyAcqMode, AnyLensMode],
+    AbstractAnalyserDriverIO[
+        AbstractBaseRegion, AnyAcqMode, AnyLensMode, AnyPsuMode, AnyPassEnergy
+    ],
     AbstractBaseRegion,
 ]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -3,7 +3,11 @@ from typing import Generic
 
 from ophyd_async.core import SignalR
 
-from dodal.devices.electron_analyser.abstract.base_region import TLensMode
+from dodal.devices.electron_analyser.abstract.types import (
+    TLensMode,
+    TPassEnergyEnum,
+    TPsuMode,
+)
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -18,20 +22,26 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 
 class VGScientaDetector(
     ElectronAnalyserDetector[
-        VGScientaAnalyserDriverIO[TLensMode],
-        VGScientaSequence[TLensMode],
-        VGScientaRegion[TLensMode],
+        VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaSequence[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
     ],
-    Generic[TLensMode],
+    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_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ):
-        driver = VGScientaAnalyserDriverIO[TLensMode](
-            prefix, lens_mode_type, energy_sources
+        driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type, energy_sources
+        )
+        super().__init__(
+            VGScientaSequence[lens_mode_type, psu_mode_type, pass_energy_type],
+            driver,
+            name,
         )
-        super().__init__(VGScientaSequence[lens_mode_type], driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -15,54 +15,96 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.base_region import TLensMode
+from dodal.devices.electron_analyser.abstract.types import (
+    TLensMode,
+    TPassEnergyEnum,
+    TPsuMode,
+)
 from dodal.devices.electron_analyser.util import to_kinetic_energy
-from dodal.devices.electron_analyser.vgscienta.enums import AcquisitionMode
-from dodal.devices.electron_analyser.vgscienta.region import (
+from dodal.devices.electron_analyser.vgscienta.enums import (
+    AcquisitionMode,
     DetectorMode,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
     VGScientaRegion,
 )
 
 
 class VGScientaAnalyserDriverIO(
-    AbstractAnalyserDriverIO[VGScientaRegion, AcquisitionMode, TLensMode],
-    Generic[TLensMode],
+    AbstractAnalyserDriverIO[
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
+        AcquisitionMode,
+        TLensMode,
+        TPsuMode,
+        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_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
-            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
-            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
-            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
-            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
-            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
             self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
 
-        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
+            self.region_min_x = epics_signal_rw(int, prefix + "MinX")
+            self.region_size_x = epics_signal_rw(int, prefix + "SizeX")
+            self.sensor_max_size_x = epics_signal_rw(int, prefix + "MaxSizeX")
+
+            self.region_min_y = epics_signal_rw(int, prefix + "MinY")
+            self.region_size_y = epics_signal_rw(int, prefix + "SizeY")
+            self.sensor_max_size_y = epics_signal_rw(int, prefix + "MaxSizeY")
+
+        super().__init__(
+            prefix,
+            AcquisitionMode,
+            lens_mode_type,
+            psu_mode_type,
+            pass_energy_type,
+            energy_sources,
+            name,
+        )
 
     @AsyncStatus.wrap
-    async def set(self, region: VGScientaRegion[TLensMode]):
-        await super().set(region)
+    async def set(self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
+        source = self._get_energy_source(region.excitation_energy_source)
+        excitation_energy = await source.get_value()  # eV
 
-        excitation_energy = await self.excitation_energy.get_value()
+        low_energy = to_kinetic_energy(
+            region.low_energy, region.energy_mode, excitation_energy
+        )
         centre_energy = to_kinetic_energy(
-            region.fix_energy, region.energy_mode, excitation_energy
+            region.centre_energy, region.energy_mode, excitation_energy
+        )
+        high_energy = to_kinetic_energy(
+            region.high_energy, region.energy_mode, excitation_energy
         )
         await asyncio.gather(
+            self.region_name.set(region.name),
+            self.energy_mode.set(region.energy_mode),
+            self.low_energy.set(low_energy),
             self.centre_energy.set(centre_energy),
+            self.high_energy.set(high_energy),
+            self.slices.set(region.slices),
+            self.lens_mode.set(region.lens_mode),
+            self.pass_energy.set(region.pass_energy),
+            self.iterations.set(region.iterations),
+            self.acquisition_mode.set(region.acquisition_mode),
+            self.excitation_energy.set(excitation_energy),
+            self.excitation_energy_source.set(source.name),
             self.energy_step.set(region.energy_step),
-            self.first_x_channel.set(region.first_x_channel),
-            self.first_y_channel.set(region.first_y_channel),
-            self.x_channel_size.set(region.x_channel_size()),
-            self.y_channel_size.set(region.y_channel_size()),
-            self.detector_mode.set(region.detector_mode),
             self.image_mode.set(ADImageMode.SINGLE),
+            self.detector_mode.set(region.detector_mode),
+            self.region_min_x.set(region.min_x),
+            self.region_size_x.set(region.size_x),
+            self.region_min_y.set(region.min_y),
+            self.region_size_y.set(region.size_y),
         )
 
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
@@ -70,7 +112,3 @@ class VGScientaAnalyserDriverIO(
 
     def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
         return epics_signal_r(Array1D[np.float64], prefix + "Y_SCALE_RBV")
-
-    @property
-    def pass_energy_type(self) -> type:
-        return str

dodal/devices/electron_analyser/vgscienta/region.py

@@ -1,13 +1,17 @@
 import uuid
 from typing import Generic
 
-from pydantic import Field
+from pydantic import Field, field_validator
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
     JavaToPythonModel,
+)
+from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
+    TPassEnergyEnum,
+    TPsuMode,
 )
 from dodal.devices.electron_analyser.vgscienta.enums import (
     AcquisitionMode,
@@ -17,33 +21,43 @@ from dodal.devices.electron_analyser.vgscienta.enums import (
 
 
 class VGScientaRegion(
-    AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]
+    AbstractBaseRegion[AcquisitionMode, TLensMode, TPassEnergyEnum],
+    Generic[TLensMode, TPassEnergyEnum],
 ):
     # Override defaults of base region class
     lens_mode: TLensMode
-    pass_energy: int = 5
+    pass_energy: TPassEnergyEnum
     acquisition_mode: AcquisitionMode = AcquisitionMode.SWEPT
     low_energy: float = 8.0
     high_energy: float = 10.0
     step_time: float = 1.0
     energy_step: float = Field(default=200.0)
+    centre_energy: float = Field(alias="fix_energy", default=9)
     # Specific to this class
     id: str = Field(default=str(uuid.uuid4()), alias="region_id")
-    fix_energy: float = 9.0
     total_steps: float = 13.0
     total_time: float = 13.0
-    first_x_channel: int = 1
-    last_x_channel: int = 1000
-    first_y_channel: int = 101
-    last_y_channel: int = 800
+    min_x: int = Field(alias="first_x_channel", default=1)
+    sensor_max_size_x: int = Field(alias="last_x_channel", default=1000)
+    min_y: int = Field(alias="first_y_channel", default=101)
+    sensor_max_size_y: int = Field(alias="last_y_channel", default=800)
     detector_mode: DetectorMode = DetectorMode.ADC
     status: Status = Status.READY
 
-    def x_channel_size(self) -> int:
-        return self.last_x_channel - self.first_x_channel + 1
+    @property
+    def size_x(self) -> int:
+        return self.sensor_max_size_x - self.min_x + 1
+
+    @property
+    def size_y(self) -> int:
+        return self.sensor_max_size_y - self.min_y + 1
 
-    def y_channel_size(self) -> int:
-        return self.last_y_channel - self.first_y_channel + 1
+    @field_validator("pass_energy", mode="before")
+    @classmethod
+    def validate_pass_energy(cls, val):
+        # This is needed because if the value is a number, it can't be casted to the
+        # enum correctly.
+        return str(val)
 
 
 class VGScientaExcitationEnergySource(JavaToPythonModel):
@@ -53,16 +67,19 @@ class VGScientaExcitationEnergySource(JavaToPythonModel):
 
 
 class VGScientaSequence(
-    AbstractBaseSequence[VGScientaRegion, TLensMode], Generic[TLensMode]
+    AbstractBaseSequence[VGScientaRegion[TLensMode, TPassEnergyEnum]],
+    Generic[TLensMode, TPsuMode, TPassEnergyEnum],
 ):
-    element_set: str = Field(default="Unknown")
+    psu_mode: TPsuMode = Field(alias="element_set")
     excitation_energy_sources: list[VGScientaExcitationEnergySource] = Field(
         default_factory=lambda: []
     )
-    regions: list[VGScientaRegion[TLensMode]] = Field(default_factory=lambda: [])
+    regions: list[VGScientaRegion[TLensMode, TPassEnergyEnum]] = Field(
+        default_factory=lambda: []
+    )
 
     def get_excitation_energy_source_by_region(
-        self, region: VGScientaRegion[TLensMode]
+        self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]
     ) -> VGScientaExcitationEnergySource:
         value = next(
             (

dodal/devices/focusing_mirror.py

@@ -113,7 +113,7 @@ class SingleMirrorVoltage(Device):
 
 class MirrorVoltages(StandardReadable):
     def __init__(
-        self, name: str, prefix: str, *args, daq_configuration_path: str, **kwargs
+        self, prefix: str, name: str = "", *args, daq_configuration_path: str, **kwargs
     ):
         self.voltage_lookup_table_path = (
             daq_configuration_path + "/json/mirrorFocus.json"

dodal/devices/i03/undulator_dcm.py

@@ -27,6 +27,8 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     instead. See https://github.com/DiamondLightSource/dodal/issues/1092
     """
 
+    DCM_PERP_TOLERANCE = 0.01
+
     def __init__(
         self,
         undulator: Undulator,
@@ -60,6 +62,9 @@ class UndulatorDCM(StandardReadable, Movable[float]):
             self.dcm_ref().energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator_ref().set(value),
         )
-        # DCM Perp pitch
-        LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
-        await self.dcm_ref().offset_in_mm.set(self.dcm_fixed_offset_mm)
+
+        # The DCM perp is under vacuum so for heat management it's best to only change it when required
+        current_offset = await self.dcm_ref().offset_in_mm.user_readback.get_value()
+        if abs(current_offset - self.dcm_fixed_offset_mm) > self.DCM_PERP_TOLERANCE:
+            LOGGER.info(f"Adjusting DCM offset to {self.dcm_fixed_offset_mm} mm")
+            await self.dcm_ref().offset_in_mm.set(self.dcm_fixed_offset_mm)

dodal/devices/i05/__init__.py

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

dodal/devices/i05/enums.py

@@ -0,0 +1,8 @@
+from ophyd_async.core import StrictEnum
+
+
+class Grating(StrictEnum):
+    PT_400 = "400 lines/mm"
+    C_1600 = "C 1600 lines/mm"
+    RH_1600 = "Rh 1600 lines/mm"
+    PT_800 = "B 800 lines/mm"

dodal/devices/i09/__init__.py

@@ -1,4 +1,4 @@
 from dodal.devices.i09.dcm import DCM
-from dodal.devices.i09.enums import Grating, LensMode
+from dodal.devices.i09.enums import Grating, LensMode, PassEnergy, PsuMode
 
-__all__ = ["DCM", "Grating", "LensMode"]
+__all__ = ["DCM", "Grating", "LensMode", "PsuMode", "PassEnergy"]

dodal/devices/i09/enums.py

@@ -13,3 +13,19 @@ class LensMode(StrictEnum):
     ANGULAR60 = "Angular60"
     ANGULAR56 = "Angular56"
     ANGULAR45VUV = "Angular45VUV"
+
+
+class PsuMode(StrictEnum):
+    HIGH = "High"
+    LOW = "Low"
+
+
+class PassEnergy(StrictEnum):
+    E5 = 5
+    E10 = 10
+    E20 = 20
+    E50 = 50
+    E70 = 70
+    E100 = 100
+    E200 = 200
+    E500 = 500

dodal/devices/i09_1/__init__.py

@@ -1,3 +1,3 @@
-from .enums import LensMode
+from .enums import LensMode, PsuMode
 
-__all__ = ["LensMode"]
+__all__ = ["LensMode", "PsuMode"]

dodal/devices/i09_1/enums.py

@@ -16,4 +16,17 @@ class LensMode(SupersetEnum):
     LOW_MAGNIFICATION = "LowMagnification"
     HIGH_MAGNIFICATION2 = "HighMagnification2"
     RAMP_MODE = "RampMode"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
+    NOT_CONNECTED = "Not connected"
+
+
+class PsuMode(SupersetEnum):
+    V3500 = "3.5kV"
+    V1500 = "1.5kV"
+    V400 = "400V"
+    # This is connected to the device separately and will only have "Not connected" as
+    # option if disconnected. Once it is connected, "Not connected" is replaced with the
+    # options above. This is also why this must be a SupersetEnum.
     NOT_CONNECTED = "Not connected"

dodal/devices/i10/mirrors.py

@@ -1,19 +1,15 @@
 from ophyd_async.epics.core import epics_signal_rw
-from ophyd_async.epics.motor import Motor
 
-from dodal.devices.motors import XYZStage
+from dodal.devices.motors import XYZPitchYawRollStage
 
 
-class PiezoMirror(XYZStage):
+class PiezoMirror(XYZPitchYawRollStage):
     def __init__(
         self,
         prefix: str,
         name: str = "",
     ):
         with self.add_children_as_readables():
-            self.yaw = Motor(prefix + "YAW")
-            self.pitch = Motor(prefix + "PITCH")
-            self.roll = Motor(prefix + "ROLL")
             self.fine_pitch = epics_signal_rw(
                 float,
                 read_pv=prefix + "FPITCH:RBV:AI",

dodal/devices/i13_1/merlin_controller.py

@@ -12,8 +12,8 @@ from ophyd_async.epics.adcore import (
     ADBaseIO,
     ADImageMode,
     ADState,
-    stop_busy_record,
 )
+from ophyd_async.epics.core import stop_busy_record
 
 
 class MerlinController(ADBaseController):