dls-dodal 1.62.0__py3-none-any.whl → 1.64.0__py3-none-any.whl

dodal/cli.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 import click
 from bluesky.run_engine import RunEngine
-from ophyd_async.core import NotConnected, StaticPathProvider, UUIDFilenameProvider
+from ophyd_async.core import NotConnectedError, StaticPathProvider, UUIDFilenameProvider
 from ophyd_async.plan_stubs import ensure_connected
 
 from dodal.beamlines import all_beamline_names, module_name_for_beamline
@@ -58,7 +58,7 @@ def connect(beamline: str, all: bool, sim_backend: bool) -> None:
 
     # We need to make a RunEngine to allow ophyd-async devices to connect.
     # See https://blueskyproject.io/ophyd-async/main/explanations/event-loop-choice.html
-    RE = RunEngine(call_returns_result=True)
+    run_engine = RunEngine(call_returns_result=True)
 
     print(f"Attempting connection to {beamline} (using {full_module_path})")
 
@@ -71,7 +71,7 @@ def connect(beamline: str, all: bool, sim_backend: bool) -> None:
         fake_with_ophyd_sim=sim_backend,
         wait_for_connection=False,
     )
-    devices, connect_exceptions = _connect_devices(RE, devices, sim_backend)
+    devices, connect_exceptions = _connect_devices(run_engine, devices, sim_backend)
 
     # Inform user of successful connections
     _report_successful_devices(devices, sim_backend)
@@ -79,7 +79,7 @@ def connect(beamline: str, all: bool, sim_backend: bool) -> None:
     # If exceptions have occurred, this will print details of the relevant PVs
     exceptions = {**instance_exceptions, **connect_exceptions}
     if len(exceptions) > 0:
-        raise NotConnected(exceptions)
+        raise NotConnectedError(exceptions)
 
 
 def _report_successful_devices(
@@ -96,7 +96,7 @@ def _report_successful_devices(
 
 
 def _connect_devices(
-    RE: RunEngine,
+    run_engine: RunEngine,
     devices: Mapping[str, AnyDevice],
     sim_backend: bool,
 ) -> tuple[Mapping[str, AnyDevice], Mapping[str, Exception]]:
@@ -112,8 +112,8 @@ def _connect_devices(
 
     # Connect ophyd-async devices
     try:
-        RE(ensure_connected(*ophyd_async_devices.values(), mock=sim_backend))
-    except NotConnected as ex:
+        run_engine(ensure_connected(*ophyd_async_devices.values(), mock=sim_backend))
+    except NotConnectedError as ex:
         exceptions = {**exceptions, **ex.sub_errors}
 
     # Only return the subset of devices that haven't raised an exception

dodal/common/visit.py

@@ -4,7 +4,7 @@ from typing import Literal
 
 from aiohttp import ClientSession
 from ophyd_async.core import FilenameProvider, PathInfo
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from dodal.common.types import UpdatingPathProvider
 from dodal.log import LOGGER
@@ -20,7 +20,7 @@ class DataCollectionIdentifier(BaseModel):
     Should be always incrementing, unique per-visit, co-ordinated with any other scan engines.
     """
 
-    collectionNumber: int
+    collection_number: int = Field(alias="collectionNumber")
 
 
 class DirectoryServiceClient(ABC):
@@ -46,7 +46,7 @@ class DiamondFilenameProvider(FilenameProvider):
     def __call__(self, device_name: str | None = None):
         assert device_name, "Diamond filename requires device_name to be passed"
         assert self.collectionId is not None
-        return f"{self._beamline}-{self.collectionId.collectionNumber}-{device_name}"
+        return f"{self._beamline}-{self.collectionId.collection_number}-{device_name}"
 
 
 class RemoteDirectoryServiceClient(DirectoryServiceClient):
@@ -143,7 +143,7 @@ class StaticVisitPathProvider(UpdatingPathProvider):
 
     async def data_session(self) -> str:
         collection = await self._client.get_current_collection()
-        return f"{self._beamline}-{collection.collectionNumber}"
+        return f"{self._beamline}-{collection.collection_number}"
 
     def __call__(self, device_name: str | None = None) -> PathInfo:
         assert device_name, "Must call PathProvider with device_name"

dodal/devices/aperturescatterguard.py

@@ -18,7 +18,7 @@ from dodal.devices.aperture import Aperture
 from dodal.devices.motors import XYStage
 
 
-class InvalidApertureMove(Exception):
+class InvalidApertureMoveError(Exception):
     pass
 
 
@@ -242,7 +242,7 @@ class ApertureScatterguard(StandardReadable, Preparable):
         diff_on_z = abs(current_ap_z - expected_z_position)
         aperture_z_tolerance = self._tolerances.aperture_z
         if diff_on_z > aperture_z_tolerance:
-            raise InvalidApertureMove(
+            raise InvalidApertureMoveError(
                 f"Current aperture z ({current_ap_z}), outside of tolerance ({aperture_z_tolerance}) from target ({expected_z_position})."
             )
 
@@ -256,7 +256,7 @@ class ApertureScatterguard(StandardReadable, Preparable):
         for axis in all_axes:
             axis_stationary = await axis.motor_done_move.get_value()
             if not axis_stationary:
-                raise InvalidApertureMove(
+                raise InvalidApertureMoveError(
                     f"{axis.name} is still moving. Wait for it to finish before"
                     "triggering another move."
                 )
@@ -294,7 +294,9 @@ class ApertureScatterguard(StandardReadable, Preparable):
         ):
             return ApertureValue.OUT_OF_BEAM
 
-        raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
+        raise InvalidApertureMoveError(
+            "Current aperture/scatterguard state unrecognised"
+        )
 
     async def _safe_move_whilst_in_beam(self, position: AperturePosition):
         """

dodal/devices/apple2_undulator.py

@@ -5,19 +5,23 @@ from math import isclose
 from typing import Generic, Protocol, TypeVar
 
 import numpy as np
-from bluesky.protocols import Movable
+from bluesky.protocols import Locatable, Location, Movable
 from ophyd_async.core import (
     AsyncStatus,
+    Reference,
     SignalR,
+    SignalRW,
     SignalW,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
     derived_signal_rw,
     soft_signal_r_and_setter,
+    soft_signal_rw,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
+from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 
@@ -40,12 +44,8 @@ class Apple2PhasesVal:
 
 
 @dataclass
-class Apple2Val:
+class Apple2Val(Apple2PhasesVal):
     gap: str
-    top_outer: str
-    top_inner: str
-    btm_inner: str
-    btm_outer: str
 
 
 class Pol(StrictEnum):
@@ -185,24 +185,24 @@ class UndulatorPhaseMotor(StandardReadable):
         name : str
             Name of the Id phase device
         """
-        fullPV = f"{prefix}BL{infix}"
-        self.user_setpoint = epics_signal_w(str, fullPV + "SET")
-        self.user_setpoint_readback = epics_signal_r(float, fullPV + "DMD")
-        fullPV = fullPV + "MTR"
+        full_pv = f"{prefix}BL{infix}"
+        self.user_setpoint = epics_signal_w(str, full_pv + "SET")
+        self.user_setpoint_readback = epics_signal_r(float, full_pv + "DMD")
+        full_pv = full_pv + "MTR"
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.user_readback = epics_signal_r(float, fullPV + ".RBV")
+            self.user_readback = epics_signal_r(float, full_pv + ".RBV")
 
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            self.motor_egu = epics_signal_r(str, fullPV + ".EGU")
-            self.velocity = epics_signal_rw(float, fullPV + ".VELO")
-
-        self.max_velocity = epics_signal_r(float, fullPV + ".VMAX")
-        self.acceleration_time = epics_signal_rw(float, fullPV + ".ACCL")
-        self.precision = epics_signal_r(int, fullPV + ".PREC")
-        self.deadband = epics_signal_r(float, fullPV + ".RDBD")
-        self.motor_done_move = epics_signal_r(int, fullPV + ".DMOV")
-        self.low_limit_travel = epics_signal_rw(float, fullPV + ".LLM")
-        self.high_limit_travel = epics_signal_rw(float, fullPV + ".HLM")
+            self.motor_egu = epics_signal_r(str, full_pv + ".EGU")
+            self.velocity = epics_signal_rw(float, full_pv + ".VELO")
+
+        self.max_velocity = epics_signal_r(float, full_pv + ".VMAX")
+        self.acceleration_time = epics_signal_rw(float, full_pv + ".ACCL")
+        self.precision = epics_signal_r(int, full_pv + ".PREC")
+        self.deadband = epics_signal_r(float, full_pv + ".RDBD")
+        self.motor_done_move = epics_signal_r(int, full_pv + ".DMOV")
+        self.low_limit_travel = epics_signal_rw(float, full_pv + ".LLM")
+        self.high_limit_travel = epics_signal_rw(float, full_pv + ".HLM")
         super().__init__(name=name)
 
 
@@ -301,7 +301,7 @@ class UndulatorJawPhase(SafeUndulatorMover[float]):
         )
 
 
-class Apple2Motors(StandardReadable, Movable):
+class Apple2(StandardReadable, Movable):
     """
     Device representing the combined motor controls for an Apple2 undulator.
 
@@ -326,38 +326,39 @@ class Apple2Motors(StandardReadable, Movable):
             Name of the device.
         """
         with self.add_children_as_readables():
-            self.gap = id_gap
-            self.phase = id_phase
+            self.gap = Reference(id_gap)
+            self.phase = Reference(id_phase)
         super().__init__(name=name)
 
     @AsyncStatus.wrap
     async def set(self, id_motor_values: Apple2Val) -> None:
         """
         Check ID is in a movable state and set all the demand value before moving them
-        all at the same time. This should be modified by the beamline specific ID
-        class, if the ID motors has to move in a specific order.
+        all at the same time.
         """
 
         # Only need to check gap as the phase motors share both fault and gate with gap.
-        await self.gap.raise_if_cannot_move()
+        await self.gap().raise_if_cannot_move()
         await asyncio.gather(
-            self.phase.top_outer.user_setpoint.set(value=id_motor_values.top_outer),
-            self.phase.top_inner.user_setpoint.set(value=id_motor_values.top_inner),
-            self.phase.btm_inner.user_setpoint.set(value=id_motor_values.btm_inner),
-            self.phase.btm_outer.user_setpoint.set(value=id_motor_values.btm_outer),
-            self.gap.user_setpoint.set(value=id_motor_values.gap),
+            self.phase().top_outer.user_setpoint.set(value=id_motor_values.top_outer),
+            self.phase().top_inner.user_setpoint.set(value=id_motor_values.top_inner),
+            self.phase().btm_inner.user_setpoint.set(value=id_motor_values.btm_inner),
+            self.phase().btm_outer.user_setpoint.set(value=id_motor_values.btm_outer),
+            self.gap().user_setpoint.set(value=id_motor_values.gap),
         )
         timeout = np.max(
-            await asyncio.gather(self.gap.get_timeout(), self.phase.get_timeout())
+            await asyncio.gather(self.gap().get_timeout(), self.phase().get_timeout())
         )
         LOGGER.info(
             f"Moving f{self.name} apple2 motors to {id_motor_values}, timeout = {timeout}"
         )
         await asyncio.gather(
-            self.gap.set_move.set(value=1, wait=False, timeout=timeout),
-            self.phase.set_move.set(value=1, wait=False, timeout=timeout),
+            self.gap().set_move.set(value=1, wait=False, timeout=timeout),
+            self.phase().set_move.set(value=1, wait=False, timeout=timeout),
+        )
+        await wait_for_value(
+            self.gap().gate, UndulatorGateStatus.CLOSE, timeout=timeout
         )
-        await wait_for_value(self.gap.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
 
 class EnergyMotorConvertor(Protocol):
@@ -366,80 +367,76 @@ class EnergyMotorConvertor(Protocol):
         ...
 
 
-class Apple2(abc.ABC, StandardReadable, Movable):
-    """
-    Apple2 Undulator Device
+Apple2Type = TypeVar("Apple2Type", bound="Apple2")
 
-    The `Apple2` class represents an Apple 2 insertion device (undulator) used in synchrotron beamlines.
-    This device provides additional degrees of freedom compared to standard undulators, allowing independent
-    movement of magnet banks to produce X-rays with various polarisations and energies.
 
-    The class is designed to manage the undulator's gap, phase motors, and polarisation settings, while
-    abstracting hardware interactions and providing a high-level interface for beamline operations.
+class Apple2Controller(abc.ABC, StandardReadable, Generic[Apple2Type]):
+    """
+
+    Abstract base class for controlling an Apple2 undulator device.
 
-    The class is abstract and requires beamline-specific implementations for _set motor
-     positions based on energy and polarisation.
+    This class manages the undulator's gap and phase motors, and provides an interface
+    for controlling polarisation and energy settings. It exposes derived signals for
+    energy and polarisation, and handles conversion between energy/polarisation and
+    motor positions via a user-supplied conversion callable.
 
     Attributes
     ----------
-    apple2_motors : Apple2Motors
-        A collection of gap and phase motor devices.
-    energy : SignalR
-        A soft signal for the current energy readback.
+    apple2 : Reference[Apple2Type]
+        Reference to the Apple2 device containing gap and phase motors.
+    energy : derived_signal_rw
+        Derived signal for moving and reading back energy.
     polarisation_setpoint : SignalR
-        A soft signal for the polarisation setpoint.
-    polarisation : SignalRW
-        A hardware-backed signal for polarisation readback and control.
-    lookup_tables : dict
-        A dictionary storing lookup tables for gap and phase motor positions, used for energy and polarisation conversion.
+        Soft signal for the polarisation setpoint.
+    polarisation : derived_signal_rw
+        Hardware-backed signal for polarisation readback and control.
     energy_to_motor : EnergyMotorConvertor
-        A callable that converts energy and polarisation to motor positions.
+        Callable that converts energy and polarisation to motor positions.
 
     Abstract Methods
     ----------------
-    _set(value: float) -> None
+    _set_motors_from_energy(value: float) -> None
         Abstract method to set motor positions for a given energy and polarisation.
-
-    Methods
-    -------
-    determine_phase_from_hardware(...) -> tuple[Pol, float]
-        Determines the polarisation and phase value based on motor positions.
+    energy_to_motor : EnergyMotorConvertor
+        A callable that converts energy and polarisation to motor positions.
 
     Notes
     -----
-    - This class requires beamline-specific implementations of the abstract methods.
-    - The device supports multiple polarisation modes, including linear horizontal (LH), linear vertical (LV),
+    - Subclasses must implement `_set_motors_from_energy` for beamline-specific logic.
+    - LH3 polarisation is indistinguishable from LH in hardware; special handling is provided.
+    - Supports multiple polarisation modes, including linear horizontal (LH), linear vertical (LV),
       positive circular (PC), negative circular (NC), and linear arbitrary (LA).
 
-    For more detail see
-    `UML </_images/apple2_design.png>`__ for detail.
-
-    .. figure:: /explanations/umls/apple2_design.png
-
     """
 
     def __init__(
         self,
-        apple2_motors: Apple2Motors,
-        energy_motor_convertor: EnergyMotorConvertor,
+        apple2: Apple2Type,
+        energy_to_motor_converter: EnergyMotorConvertor,
         name: str = "",
     ) -> None:
         """
 
         Parameters
         ----------
-        id_gap: An UndulatorGap device.
-        id_phase: An UndulatorPhaseAxes device.
-        energy_motor_convertor: A callable that converts energy and polarisation to motor positions.
-        name: Name of the device.
+        apple2: Apple2
+            An Apple2 device.
+        name: str
+            Name of the device.
         """
+        self.energy_to_motor = energy_to_motor_converter
+        self.apple2 = Reference(apple2)
 
-        self.motors = apple2_motors
-        self.energy_to_motor = energy_motor_convertor
+        # Store the set energy for readback.
+        self._energy, self._energy_set = soft_signal_r_and_setter(
+            float, initial_value=None, units="eV"
+        )
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            # Store the set energy for readback.
-            self.energy, self._set_energy_rbv = soft_signal_r_and_setter(
-                float, initial_value=None
+            self.energy = derived_signal_rw(
+                raw_to_derived=self._read_energy,
+                set_derived=self._set_energy,
+                energy=self._energy,
+                derived_units="eV",
             )
 
         # Store the polarisation for setpoint. And provide readback for LH3.
@@ -447,61 +444,65 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self.polarisation_setpoint, self._polarisation_setpoint_set = (
             soft_signal_r_and_setter(Pol)
         )
-
-        # Hardware backed read/write for polarisation.
-        self.polarisation = derived_signal_rw(
-            raw_to_derived=self._read_pol,
-            set_derived=self._set_pol,
-            pol=self.polarisation_setpoint,
-            top_outer=self.motors.phase.top_outer.user_readback,
-            top_inner=self.motors.phase.top_inner.user_readback,
-            btm_inner=self.motors.phase.btm_inner.user_readback,
-            btm_outer=self.motors.phase.btm_outer.user_readback,
-            gap=self.motors.gap.user_readback,
-        )
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            # Hardware backed read/write for polarisation.
+            self.polarisation = derived_signal_rw(
+                raw_to_derived=self._read_pol,
+                set_derived=self._set_pol,
+                pol=self.polarisation_setpoint,
+                top_outer=self.apple2().phase().top_outer.user_readback,
+                top_inner=self.apple2().phase().top_inner.user_readback,
+                btm_inner=self.apple2().phase().btm_inner.user_readback,
+                btm_outer=self.apple2().phase().btm_outer.user_readback,
+                gap=self.apple2().gap().user_readback,
+            )
         super().__init__(name)
 
-    def _set_pol_setpoint(self, pol: Pol) -> None:
-        """Set the polarisation setpoint without moving hardware. The polarisation
-        setpoint is used to determine the gap and phase motor positions when
-        setting the energy/polarisation of the undulator."""
-        self._polarisation_setpoint_set(pol)
-
-    async def _set_pol(
-        self,
-        value: Pol,
-    ) -> None:
-        # This changes the pol setpoint and then changes polarisation via set energy.
-        self._set_pol_setpoint(value)
-        await self.set(await self.energy.get_value())
-
-    @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
+    @abc.abstractmethod
+    async def _set_motors_from_energy(self, value: float) -> None:
+        """
+        This method should be implemented by the beamline specific ID class as the
+        motor positions will be different for each beamline depending on the
+        undulator design and the lookup table used.
         """
-        Set should be in energy units, this will set the energy of the ID by setting the
-        gap and phase motors to the correct position for the given energy
-        and polarisation.
 
+    async def _set_energy(self, energy: float) -> None:
+        await self._set_motors_from_energy(energy)
+        self._energy_set(energy)
 
-        Examples
-        --------
-        RE( id.set(888.0)) # This will set the ID to 888 eV
-        RE(scan([detector], id,600,700,100)) # This will scan the ID from 600 to 700 eV in 100 steps.
-        """
-        await self._set(value)
-        self._set_energy_rbv(value)  # Update energy after move for readback.
-        LOGGER.info(f"Energy set to {value} eV successfully.")
+    def _read_energy(self, energy: float) -> float:
+        """Readback for energy is just the set value."""
+        return energy
 
-    @abc.abstractmethod
-    async def _set(self, value: float) -> None:
+    async def _check_and_get_pol_setpoint(self) -> Pol:
         """
-        This method should be implemented by the beamline specific ID class as the
-        motor positions will be different for each beamline depending on the
-        undulator design and the lookup table used. The set method can be
-        used to set the motor positions for the given energy and polarisation
-        provided that all motors can be moved at the same time.
+        Check the polarisation setpoint and if it is NONE try to read it from
+        hardware.
         """
 
+        pol = await self.polarisation_setpoint.get_value()
+
+        if pol == Pol.NONE:
+            LOGGER.warning(
+                "Found no setpoint for polarisation. Attempting to"
+                " determine polarisation from hardware..."
+            )
+            pol = await self.polarisation.get_value()
+            if pol == Pol.NONE:
+                raise ValueError(
+                    f"Polarisation cannot be determined from hardware for {self.name}"
+                )
+            self._polarisation_setpoint_set(pol)
+        return pol
+
+    async def _set_pol(
+        self,
+        value: Pol,
+    ) -> None:
+        # This changes the pol setpoint and then changes polarisation via set energy.
+        self._polarisation_setpoint_set(value)
+        await self.energy.set(await self.energy.get_value())
+
     def _read_pol(
         self,
         pol: Pol,
@@ -605,3 +606,101 @@ class Apple2(abc.ABC, StandardReadable, Movable):
 
         LOGGER.warning("Unable to determine polarisation. Defaulting to NONE.")
         return Pol.NONE, 0.0
+
+
+class InsertionDeviceEnergyBase(abc.ABC, StandardReadable, Movable):
+    """Base class for ID energy movable device."""
+
+    def __init__(self, name: str = "") -> None:
+        self.energy: Reference[SignalRW[float]]
+        super().__init__(name=name)
+
+    @abc.abstractmethod
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None: ...
+
+
+class BeamEnergy(StandardReadable, Movable[float]):
+    """
+    Compound device to set both ID and energy motor at the same time with an option to add an offset.
+    """
+
+    def __init__(
+        self, id_energy: InsertionDeviceEnergyBase, mono: Motor, name: str = ""
+    ) -> None:
+        """
+        Parameters
+        ----------
+
+        id_energy: InsertionDeviceEnergy
+            An InsertionDeviceEnergy device.
+        mono: Motor
+            A Motor(energy) device.
+        name:
+            New device name.
+        """
+        super().__init__(name=name)
+        self._id_energy = Reference(id_energy)
+        self._mono_energy = Reference(mono)
+
+        self.add_readables(
+            [
+                self._id_energy().energy(),
+                self._mono_energy().user_readback,
+            ],
+            StandardReadableFormat.HINTED_SIGNAL,
+        )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.id_energy_offset = soft_signal_rw(float, initial_value=0)
+
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None:
+        LOGGER.info(f"Moving f{self.name} energy to {energy}.")
+        await asyncio.gather(
+            self._id_energy().set(
+                energy=energy + await self.id_energy_offset.get_value()
+            ),
+            self._mono_energy().set(energy),
+        )
+
+
+class InsertionDeviceEnergy(InsertionDeviceEnergyBase):
+    """Apple2 ID energy movable device."""
+
+    def __init__(self, id_controller: Apple2Controller, name: str = "") -> None:
+        self.energy = Reference(id_controller.energy)
+        super().__init__(name=name)
+
+        self.add_readables(
+            [
+                self.energy(),
+            ],
+            StandardReadableFormat.HINTED_SIGNAL,
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, energy: float) -> None:
+        await self.energy().set(energy)
+
+
+class InsertionDevicePolarisation(StandardReadable, Locatable[Pol]):
+    """Apple2 ID polarisation movable device."""
+
+    def __init__(self, id_controller: Apple2Controller, name: str = "") -> None:
+        self.polarisation = Reference(id_controller.polarisation)
+        self.polarisation_setpoint = Reference(id_controller.polarisation_setpoint)
+        super().__init__(name=name)
+
+        self.add_readables([self.polarisation()], StandardReadableFormat.HINTED_SIGNAL)
+
+    @AsyncStatus.wrap
+    async def set(self, pol: Pol) -> None:
+        await self.polarisation().set(pol)
+
+    async def locate(self) -> Location[Pol]:
+        """Return the current polarisation"""
+        setpoint, readback = await asyncio.gather(
+            self.polarisation_setpoint().get_value(), self.polarisation().get_value()
+        )
+        return Location(setpoint=setpoint, readback=readback)

dodal/devices/attenuator/filter_selections.py

@@ -20,7 +20,7 @@ class P99FilterSelections(SubsetEnum):
     USER = "User"
 
 
-class I02_1FilterOneSelections(SubsetEnum):
+class I02_1FilterOneSelections(SubsetEnum):  # noqa: N801
     EMPTY = "Empty"
     AL8 = "Al8"
     AL15 = "Al15"
@@ -33,7 +33,7 @@ class I02_1FilterOneSelections(SubsetEnum):
     TWO_TIMES_TI500 = "2xTi500"
 
 
-class I02_1FilterTwoSelections(SubsetEnum):
+class I02_1FilterTwoSelections(SubsetEnum):  # noqa: N801
     EMPTY = "Empty"
     AL50 = "Al50"
     AL100 = "Al100"
@@ -46,7 +46,7 @@ class I02_1FilterTwoSelections(SubsetEnum):
     TWO_TIMES_TI500 = "2xTi500"
 
 
-class I02_1FilterThreeSelections(SubsetEnum):
+class I02_1FilterThreeSelections(SubsetEnum):  # noqa: N801
     EMPTY = "Empty"
     AL15 = "Al15"
     AL25 = "Al25"
@@ -59,7 +59,7 @@ class I02_1FilterThreeSelections(SubsetEnum):
     TI200 = "Ti200"
 
 
-class I02_1FilterFourSelections(SubsetEnum):
+class I02_1FilterFourSelections(SubsetEnum):  # noqa: N801
     EMPTY = "Empty"
     AL15 = "Al15"
     AL25 = "Al25"
@@ -72,7 +72,7 @@ class I02_1FilterFourSelections(SubsetEnum):
     TI500 = "Ti500"
 
 
-class I24_FilterOneSelections(SubsetEnum):
+class I24FilterOneSelections(SubsetEnum):
     EMPTY = "Empty"
     AL12_5 = "Al12.5"
     AL25 = "Al25"
@@ -85,7 +85,7 @@ class I24_FilterOneSelections(SubsetEnum):
     TI500 = "Ti500"
 
 
-class I24_FilterTwoSelections(SubsetEnum):
+class I24FilterTwoSelections(SubsetEnum):
     EMPTY = "Empty"
     AL100 = "Al100"
     AL200 = "Al200"

dodal/devices/b07_1/ccmc.py

@@ -62,7 +62,7 @@ class ChannelCutMonochromator(
             )
 
         # energy derived signal as property
-        self.energy_in_ev = derived_signal_r(
+        self.energy_in_eV = derived_signal_r(
             self._convert_pos_to_ev, pos_signal=self.crystal
         )
         super().__init__(name=name)