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

dodal/devices/common_dcm.py

@@ -2,6 +2,7 @@ from typing import Generic, TypeVar
 
 from ophyd_async.core import (
     StandardReadable,
+    derived_signal_r,
 )
 from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
@@ -31,42 +32,39 @@ Xtal_1 = TypeVar("Xtal_1", bound=StationaryCrystal)
 Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
 
 
-class BaseDCM(StandardReadable, Generic[Xtal_1, Xtal_2]):
+class DoubleCrystalMonochromatorBase(StandardReadable, Generic[Xtal_1, Xtal_2]):
     """
-    Common device for the double crystal monochromator (DCM), used to select the energy of the beam.
+    Base device for the double crystal monochromator (DCM), used to select the energy of the beam.
 
     Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
     each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
     This base device accounts for all combinations of this.
 
-    This device should act as a parent for beamline-specific DCM's, in which any other missing signals can be added.
+    This device should act as a parent for beamline-specific DCM's which do not match the standard EPICS interface, it provides
+    only energy and the crystal configuration.  Most beamlines should use DoubleCrystalMonochromator instead
 
     Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan
-    which only requires one crystal which can roll should be typed 'def my_plan(dcm: BaseDCM[RollCrystal, StationaryCrystal])`
+    which only requires one crystal which can roll should be typed
+    'def my_plan(dcm: DoubleCrystalMonochromatorBase[RollCrystal, StationaryCrystal])`
     """
 
     def __init__(
         self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2], name: str = ""
     ) -> None:
         with self.add_children_as_readables():
-            # Virtual motor PV's which set the physical motors so that the DCM produces requested
-            # wavelength/energy
-            self.energy_in_kev = Motor(prefix + "ENERGY")
-            self.wavelength_in_a = Motor(prefix + "WAVELENGTH")
-
-            # Real motors
-            self.bragg_in_degrees = Motor(prefix + "BRAGG")
-            # Offset ensures that the beam exits the DCM at the same point, regardless of energy.
-            self.offset_in_mm = Motor(prefix + "OFFSET")
-
-            self.crystal_metadata_d_spacing_a = epics_signal_r(
-                float, prefix + "DSPACING:RBV"
+            # Virtual motor PV's which set the physical motors so that the DCM produces requested energy
+            self.energy_in_keV = Motor(prefix + "ENERGY")
+            self.energy_in_eV = derived_signal_r(
+                self._convert_keV_to_eV, energy_signal=self.energy_in_keV.user_readback
             )
 
             self._make_crystals(prefix, xtal_1, xtal_2)
 
         super().__init__(name)
 
+    def _convert_keV_to_eV(self, energy_signal: float) -> float:  # noqa: N802
+        return energy_signal * 1000
+
     # Prefix convention is different depending on whether there are one or two controllable crystals
     def _make_crystals(self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2]):
         if StationaryCrystal not in [xtal_1, xtal_2]:
@@ -75,3 +73,52 @@ class BaseDCM(StandardReadable, Generic[Xtal_1, Xtal_2]):
         else:
             self.xtal_1 = xtal_1(prefix)
             self.xtal_2 = xtal_2(prefix)
+
+
+class DoubleCrystalMonochromator(
+    DoubleCrystalMonochromatorBase, Generic[Xtal_1, Xtal_2]
+):
+    """
+    Common device for the double crystal monochromator (DCM), used to select the energy of the beam.
+
+    Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
+    each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
+    This base device accounts for all combinations of this.
+
+    This device should act as a parent for beamline-specific DCM's, in which any other missing signals can be added.
+
+    Bluesky plans using DCM's should be typed to specify which types of crystals are required. For example, a plan which only
+    requires one crystal which can roll should be typed 'def my_plan(dcm: DoubleCrystalMonochromator[RollCrystal, StationaryCrystal])`
+    """
+
+    def __init__(
+        self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2], name: str = ""
+    ) -> None:
+        super().__init__(prefix, xtal_1, xtal_2, name)
+        with self.add_children_as_readables():
+            # Virtual motor PV's which set the physical motors so that the DCM produces requested
+            # wavelength
+            self.wavelength_in_a = Motor(prefix + "WAVELENGTH")
+
+            # Real motors
+            self.bragg_in_degrees = Motor(prefix + "BRAGG")
+            # Offset ensures that the beam exits the DCM at the same point, regardless of energy.
+            self.offset_in_mm = Motor(prefix + "OFFSET")
+
+
+class DoubleCrystalMonochromatorWithDSpacing(
+    DoubleCrystalMonochromator, Generic[Xtal_1, Xtal_2]
+):
+    """
+    Adds crystal D-spacing metadata to the DoubleCrystalMonochromator class.  This should be used in preference to the
+    DoubleCrystalMonochromator on beamlines which have a "DSPACING:RBV" pv on their DCM.
+    """
+
+    def __init__(
+        self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2], name: str = ""
+    ) -> None:
+        super().__init__(prefix, xtal_1, xtal_2, name)
+        with self.add_children_as_readables():
+            self.crystal_metadata_d_spacing_a = epics_signal_r(
+                float, prefix + "DSPACING:RBV"
+            )

dodal/devices/current_amplifiers/femto.py

@@ -104,15 +104,15 @@ class FemtoDDPCA(CurrentAmp):
                 + "\n Available gain:"
                 + f" {[f'{c.value:.0e}' for c in self.gain_conversion_table]}"
             )
-        SEN_setting = self.gain_conversion_table(value).name
-        LOGGER.info(f"{self.name} gain change to {SEN_setting}:{value}")
+        sensitivity_setting = self.gain_conversion_table(value).name
+        LOGGER.info(f"{self.name} gain change to {sensitivity_setting}:{value}")
 
         await self.gain.set(
-            value=self.gain_table[SEN_setting],
+            value=self.gain_table[sensitivity_setting],
             timeout=self.timeout,
         )
         # wait for current amplifier's bandpass filter to settle.
-        await asyncio.sleep(self.raise_timetable[SEN_setting].value)
+        await asyncio.sleep(self.raise_timetable[sensitivity_setting].value)
 
     async def increase_gain(self, value: int = 1) -> None:
         current_gain = int((await self.get_gain()).name.split("_")[-1])

dodal/devices/current_amplifiers/sr570.py

@@ -79,7 +79,7 @@ class SR570FullGainTable(Enum):
 
 
 class SR570GainToCurrentTable(float, Enum):
-    """Conversion table for gain(sen) to current"""
+    """Conversion table for gain (sensitivity) to current"""
 
     SEN_1 = 1e3
     SEN_2 = 2e3
@@ -168,10 +168,10 @@ class SR570(CurrentAmp):
                 + "\n Available gain:"
                 + f" {[f'{c.value:.0e}' for c in self.gain_conversion_table]}"
             )
-        SEN_setting = self.gain_conversion_table(value).name
+        sensitivity_setting = self.gain_conversion_table(value).name
         LOGGER.info(f"{self.name} gain change to {value}")
 
-        coarse_gain, fine_gain = self.combined_table[SEN_setting].value
+        coarse_gain, fine_gain = self.combined_table[sensitivity_setting].value
         await asyncio.gather(
             self.fine_gain.set(value=fine_gain, timeout=self.timeout),
             self.coarse_gain.set(value=coarse_gain, timeout=self.timeout),

dodal/devices/fast_grid_scan.py

@@ -31,7 +31,7 @@ from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
 
-class GridScanInvalidException(RuntimeError):
+class GridScanInvalidError(RuntimeError):
     """Raised when the gridscan parameters are not valid."""
 
 
@@ -302,7 +302,7 @@ class FastGridScanCommon(
             value: the gridscan parameters
 
         Raises:
-            GridScanInvalidException: if the gridscan parameters were not valid
+            GridScanInvalidError: if the gridscan parameters were not valid
         """
         set_statuses = []
 
@@ -326,7 +326,7 @@ class FastGridScanCommon(
                 self.scan_invalid, 0.0, timeout=self.VALIDITY_CHECK_TIMEOUT
             )
         except TimeoutError as e:
-            raise GridScanInvalidException(
+            raise GridScanInvalidError(
                 f"Gridscan parameters not validated after {self.VALIDITY_CHECK_TIMEOUT}s"
             ) from e
 
@@ -470,6 +470,6 @@ def set_fast_grid_scan_params(scan: FastGridScanCommon[ParamType], params: Param
         params: The parameters to set
 
     Raises:
-        GridScanInvalidException: if the grid scan parameters are not valid
+        GridScanInvalidError: if the grid scan parameters are not valid
     """
     yield from prepare(scan, params, wait=True)

dodal/devices/fast_shutter.py

@@ -21,27 +21,27 @@ class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
         await shutter.set(shutter.open_state)
         await shutter.set(shutter.close_state)
     OR
-        RE(bps.mv(shutter, shutter.open_state))
-        RE(bps.mv(shutter, shutter.close_state))
+        run_engine(bps.mv(shutter, shutter.open_state))
+        run_engine(bps.mv(shutter, shutter.close_state))
     """
 
     def __init__(
         self,
-        prefix: str,
+        pv: str,
         open_state: StrictEnumT,
         close_state: StrictEnumT,
         name: str = "",
     ):
         """
         Arguments:
-            prefix: The prefix for the shutter device.
+            pv: The pv to connect to the shutter device.
             open_state: The enum value that corresponds with opening the shutter.
             close_state: The enum value that corresponds with closing the shutter.
         """
         self.open_state = open_state
         self.close_state = close_state
         with self.add_children_as_readables():
-            self.state = epics_signal_rw(type(self.open_state), prefix)
+            self.state = epics_signal_rw(type(self.open_state), pv)
         super().__init__(name)
 
     @AsyncStatus.wrap
@@ -49,9 +49,21 @@ class GenericFastShutter(StandardReadable, Movable[StrictEnumT]):
         await self.state.set(value)
 
     async def is_open(self) -> bool:
-        """Checks to see if shutter is currently open"""
+        """
+        Checks to see if shutter is in open_state. Should not be used directly inside a
+        plan. A user should use the following instead in a plan:
+
+            from bluesky import plan_stubs as bps
+            is_open = yield from bps.rd(shutter.state) == shutter.open_state
+        """
         return await self.state.get_value() == self.open_state
 
     async def is_closed(self) -> bool:
-        """Checks to see if shutter is currently closed"""
+        """
+        Checks to see if shutter is in close_state. Should not be used directly inside a
+        plan. A user should use the following instead in a plan:
+
+            from bluesky import plan_stubs as bps
+            is_closed = yield from bps.rd(shutter.state) == shutter.close_state
+        """
         return await self.state.get_value() == self.close_state

dodal/devices/i03/dcm.py

@@ -9,13 +9,15 @@ from dodal.common.crystal_metadata import (
     make_crystal_metadata_from_material,
 )
 from dodal.devices.common_dcm import (
-    BaseDCM,
+    DoubleCrystalMonochromatorWithDSpacing,
     PitchAndRollCrystal,
     StationaryCrystal,
 )
 
 
-class DCM(BaseDCM[PitchAndRollCrystal, StationaryCrystal]):
+class DCM(
+    DoubleCrystalMonochromatorWithDSpacing[PitchAndRollCrystal, StationaryCrystal]
+):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 

dodal/devices/i03/undulator_dcm.py

@@ -58,7 +58,7 @@ class UndulatorDCM(StandardReadable, Movable[float]):
     async def set(self, value: float):
         await self.undulator_ref().raise_if_not_enabled()
         await asyncio.gather(
-            self.dcm_ref().energy_in_kev.set(value, timeout=ENERGY_TIMEOUT_S),
+            self.dcm_ref().energy_in_keV.set(value, timeout=ENERGY_TIMEOUT_S),
             self.undulator_ref().set(value),
         )
 

dodal/devices/i04/murko_results.py

@@ -43,7 +43,7 @@ class Coord(Enum):
 
 @dataclass
 class MurkoResult:
-    centre_px: tuple
+    chosen_point_px: tuple[int, int]
     x_dist_mm: float
     y_dist_mm: float
     omega: float
@@ -51,7 +51,7 @@ class MurkoResult:
     metadata: MurkoMetadata
 
 
-class NoResultsFound(ValueError):
+class NoResultsFoundError(ValueError):
     pass
 
 
@@ -73,6 +73,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
 
     TIMEOUT_S = 2
     PERCENTAGE_TO_USE = 25
+    LEFTMOST_PIXEL_TO_USE = 10
     NUMBER_OF_WRONG_RESULTS_TO_LOG = 5
 
     def __init__(
@@ -129,7 +130,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
             await self.process_batch(message, sample_id)
 
         if not self._results:
-            raise NoResultsFound("No results retrieved from Murko")
+            raise NoResultsFoundError("No results retrieved from Murko")
 
         for result in self._results:
             LOGGER.debug(result)
@@ -186,16 +187,16 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         else:
             shape = result["original_shape"]  # Dimensions of image in pixels
             # Murko returns coords as y, x
-            centre_px = (coords[1] * shape[1], coords[0] * shape[0])
+            chosen_point_px = (coords[1] * shape[1], coords[0] * shape[0])
 
             beam_dist_px = calculate_beam_distance(
                 (metadata["beam_centre_i"], metadata["beam_centre_j"]),
-                centre_px[0],
-                centre_px[1],
+                chosen_point_px[0],
+                chosen_point_px[1],
             )
             self._results.append(
                 MurkoResult(
-                    centre_px=centre_px,
+                    chosen_point_px=chosen_point_px,
                     x_dist_mm=beam_dist_px[0] * metadata["microns_per_x_pixel"] / 1000,
                     y_dist_mm=beam_dist_px[1] * metadata["microns_per_y_pixel"] / 1000,
                     omega=omega,
@@ -209,10 +210,27 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         """Whilst murko is not fully trained it often gives us poor results.
         When it is wrong it usually picks up the base of the pin, rather than the tip,
         meaning that by keeping only a percentage of the results with the smallest X we
-        remove many of the outliers.
+        remove many of the outliers. Murko also occasionally picks a point in the bottom
+        left corner, which can be removed by filtering results with a small x pixel.
         """
+
         LOGGER.info(f"Number of results before filtering: {len(self._results)}")
-        sorted_results = sorted(self._results, key=lambda item: item.centre_px[0])
+        sorted_results = sorted(self._results, key=lambda item: item.chosen_point_px[0])
+
+        results_without_tiny_x = [
+            result
+            for result in sorted_results
+            if result.chosen_point_px[0] >= self.LEFTMOST_PIXEL_TO_USE
+        ]
+        result_uuids_with_tiny_x = [
+            result.uuid
+            for result in sorted_results
+            if result not in results_without_tiny_x
+        ]
+
+        LOGGER.info(
+            f"Results with tiny x have been removed: {result_uuids_with_tiny_x}"
+        )
 
         worst_results = [
             r.uuid for r in sorted_results[-self.NUMBER_OF_WRONG_RESULTS_TO_LOG :]
@@ -221,14 +239,17 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         LOGGER.info(
             f"Worst {self.NUMBER_OF_WRONG_RESULTS_TO_LOG} murko results were {worst_results}"
         )
+
         cutoff = max(1, int(len(sorted_results) * self.PERCENTAGE_TO_USE / 100))
-        for i, result in enumerate(sorted_results):
-            result.metadata["used_for_centring"] = i < cutoff
+        cutoff = min(cutoff, len(results_without_tiny_x))
+
+        best_x = results_without_tiny_x[:cutoff]
 
-        smallest_x = sorted_results[:cutoff]
+        for result in sorted_results:
+            result.metadata["used_for_centring"] = result in best_x
 
-        LOGGER.info(f"Number of results after filtering: {len(smallest_x)}")
-        return smallest_x
+        LOGGER.info(f"Number of results after filtering: {len(best_x)}")
+        return best_x
 
 
 def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:

dodal/devices/i07/dcm.py

@@ -0,0 +1,33 @@
+from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.common_dcm import (
+    DoubleCrystalMonochromator,
+    PitchAndRollCrystal,
+    StationaryCrystal,
+)
+
+
+class DCM(DoubleCrystalMonochromator[PitchAndRollCrystal, StationaryCrystal]):
+    """
+    Device for i07's DCM, including temperature monitors and vertical motor which were
+    included in GDA.
+    """
+
+    def __init__(
+        self,
+        motor_prefix: str,
+        xtal_prefix: str,
+        name: str = "",
+    ) -> None:
+        super().__init__(motor_prefix, PitchAndRollCrystal, StationaryCrystal, name)
+        with self.add_children_as_readables():
+            self.vertical_in_mm = Motor(motor_prefix + "PERP")
+
+            # temperatures
+            self.xtal1_temp = epics_signal_r(float, xtal_prefix + "PT100-2")
+            self.xtal2_temp = epics_signal_r(float, xtal_prefix + "PT100-3")
+            self.xtal1_holder_temp = epics_signal_r(float, xtal_prefix + "PT100-1")
+            self.xtal2_holder_temp = epics_signal_r(float, xtal_prefix + "PT100-4")
+            self.gap_motor = epics_signal_r(float, xtal_prefix + "TC-1")
+            self.white_beam_stop_temp = epics_signal_r(float, xtal_prefix + "WBS:TEMP")

dodal/devices/i09/__init__.py

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

dodal/devices/i09_1_shared/__init__.py

@@ -0,0 +1,3 @@
+from .hard_undulator_functions import calculate_gap_i09_hu, get_hu_lut_as_dict
+
+__all__ = ["calculate_gap_i09_hu", "get_hu_lut_as_dict"]

dodal/devices/i09_1_shared/hard_undulator_functions.py

@@ -0,0 +1,111 @@
+import numpy as np
+
+from dodal.devices.util.lookup_tables import energy_distance_table
+from dodal.log import LOGGER
+
+LUT_COMMENTS = ["#"]
+HU_SKIP_ROWS = 3
+
+# Physics constants
+ELECTRON_REST_ENERGY_MEV = 0.510999
+
+# Columns in the lookup table
+RING_ENERGY_COLUMN = 1
+MAGNET_FIELD_COLUMN = 2
+MIN_ENERGY_COLUMN = 3
+MAX_ENERGY_COLUMN = 4
+GAP_OFFSET_COLUMN = 7
+
+
+async def get_hu_lut_as_dict(lut_path: str) -> dict:
+    lut_dict: dict = {}
+    _lookup_table: np.ndarray = await energy_distance_table(
+        lut_path,
+        comments=LUT_COMMENTS,
+        skiprows=HU_SKIP_ROWS,
+    )
+    for i in range(_lookup_table.shape[0]):
+        lut_dict[_lookup_table[i][0]] = _lookup_table[i]
+        LOGGER.debug(f"Loaded lookup table:\n {lut_dict}")
+    return lut_dict
+
+
+def calculate_gap_i09_hu(
+    photon_energy_kev: float,
+    look_up_table: dict[int, "np.ndarray"],
+    order: int = 1,
+    gap_offset: float = 0.0,
+    undulator_period_mm: int = 27,
+) -> float:
+    """
+    Calculate the undulator gap required to produce a given energy at a given harmonic order.
+    This algorithm was provided by the I09 beamline scientists, and is based on the physics of undulator radiation.
+    https://cxro.lbl.gov//PDF/X-Ray-Data-Booklet.pdf
+
+    Args:
+        photon_energy_kev (float): Requested photon energy in keV.
+        look_up_table (dict[int, np.ndarray]): Lookup table containing undulator and beamline parameters for each harmonic order.
+        order (int, optional): Harmonic order for which to calculate the gap. Defaults to 1.
+        gap_offset (float, optional): Additional gap offset to apply (in mm). Defaults to 0.0.
+        undulator_period_mm (int, optional): Undulator period in mm. Defaults to 27.
+
+    Returns:
+        float: Calculated undulator gap in millimeters.
+    """
+    magnet_blocks_per_period = 4
+    magnet_block_height_mm = 16
+
+    if order not in look_up_table.keys():
+        raise ValueError(f"Order parameter {order} not found in lookup table")
+
+    gamma = 1000 * look_up_table[order][RING_ENERGY_COLUMN] / ELECTRON_REST_ENERGY_MEV
+
+    # Constructive interference of radiation emitted at different poles
+    # lamda = (lambda_u/2*gamma^2)*(1+K^2/2 + gamma^2*theta^2)/n for n=1,2,3...
+    # theta is the observation angle, assumed to be 0 here.
+    # Rearranging for K (the undulator parameter, related to magnetic field and gap)
+    # gives K^2 = 2*((2*n*gamma^2*lamda/lambda_u)-1)
+
+    undulator_parameter_sqr = (
+        4.959368e-6
+        * (order * gamma * gamma / (undulator_period_mm * photon_energy_kev))
+        - 2
+    )
+    if undulator_parameter_sqr < 0:
+        raise ValueError(
+            f"Diffraction parameter squared must be positive! Calculated value {undulator_parameter_sqr}."
+        )
+    undulator_parameter = np.sqrt(undulator_parameter_sqr)
+
+    # Undulator_parameter K is also defined as K = 0.934*B0[T]*lambda_u[cm],
+    # where B0[T] is a peak magnetic field that must depend on gap,
+    # but in our LUT it is does not depend on gap, so it's a factor,
+    # leading to K = 0.934*B0[T]*lambda_u[cm]*exp(-pi*gap/lambda_u) or
+    # K = undulator_parameter_max*exp(-pi*gap/lambda_u)
+    # Calculating undulator_parameter_max gives:
+    undulator_parameter_max = (
+        (
+            2
+            * 0.0934
+            * undulator_period_mm
+            * look_up_table[order][MAGNET_FIELD_COLUMN]
+            * magnet_blocks_per_period
+            / np.pi
+        )
+        * np.sin(np.pi / magnet_blocks_per_period)
+        * (1 - np.exp(-2 * np.pi * magnet_block_height_mm / undulator_period_mm))
+    )
+
+    # Finnaly, rearranging the equation:
+    # undulator_parameter = undulator_parameter_max*exp(-pi*gap/lambda_u) for gap gives
+    gap = (
+        (undulator_period_mm / np.pi)
+        * np.log(undulator_parameter_max / undulator_parameter)
+        + look_up_table[order][GAP_OFFSET_COLUMN]
+        + gap_offset
+    )
+    LOGGER.debug(
+        f"Calculated gap is {gap}mm for energy {photon_energy_kev}keV at order {order}"
+    )
+
+    return gap

dodal/devices/i10/__init__.py

@@ -0,0 +1,29 @@
+from .diagnostics import (
+    I10Diagnostic,
+    I10Diagnostic5ADet,
+    I10JDiagnostic,
+    I10PneumaticStage,
+    I10SharedDiagnostic,
+)
+from .mirrors import PiezoMirror
+from .slits import (
+    I10JSlits,
+    I10SharedSlits,
+    I10SharedSlitsDrainCurrent,
+    I10Slits,
+    I10SlitsDrainCurrent,
+)
+
+__all__ = [
+    "I10Diagnostic",
+    "I10Diagnostic5ADet",
+    "I10PneumaticStage",
+    "PiezoMirror",
+    "I10Slits",
+    "I10SlitsDrainCurrent",
+    "I10SharedDiagnostic",
+    "I10SharedSlits",
+    "I10JSlits",
+    "I10SharedSlitsDrainCurrent",
+    "I10JDiagnostic",
+]

dodal/devices/i10/diagnostics.py

@@ -28,7 +28,7 @@ class D3Position(StrictEnum):
     GRID = "Grid"
 
 
-class D5Position(StrictEnum):
+class CellPosition(StrictEnum):
     CELL_IN = "Cell In"
     CELL_OUT = "Cell Out"
 
@@ -68,6 +68,21 @@ class InStateReadBackTable(StrictEnum):
     OUT_OF_BEAM = "Out of Beam"
 
 
+class D2jPosition(StrictEnum):
+    OUT_OF_THE_BEAM = "Out of the beam"
+    DIODE = "Diode"
+    BLADE = "Blade"
+    LA = "La ref"
+    GD = "Gd ref"
+    YB = "Yb ref"
+
+
+class D3jPosition(StrictEnum):
+    OUT_OF_THE_BEAM = "Out of the beam"
+    DIODE_IN = "Diode In"
+    DIAMOND_WINDOW = "Diamond window"
+
+
 class I10PneumaticStage(StandardReadable):
     """Pneumatic stage only has two real positions in or out.
     Use for fluorescent screen which can be insert into the x-ray beam.
@@ -138,9 +153,7 @@ class FullDiagnostic(Device):
         super().__init__(name)
 
 
-class I10Diagnostic(Device):
-    """Collection of all the diagnostic stage on i10."""
-
+class I10SharedDiagnostic(Device):
     def __init__(self, prefix, name: str = "") -> None:
         self.d1 = ScreenCam(prefix=prefix + "PHDGN-01:")
         self.d2 = ScreenCam(prefix=prefix + "PHDGN-02:")
@@ -149,8 +162,15 @@ class I10Diagnostic(Device):
             positioner_enum=D3Position,
             positioner_suffix="DET:X",
         )
+        super().__init__(name)
+
+
+class I10Diagnostic(Device):
+    """Collection of all the diagnostic stage on i10."""
+
+    def __init__(self, prefix, name: str = "") -> None:
         self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
-        self.d5 = create_positioner(D5Position, f"{prefix}IONC-01:Y")
+        self.d5 = create_positioner(CellPosition, f"{prefix}IONC-01:Y")
         self.d5A = create_positioner(D5APosition, f"{prefix}PHDGN-06:DET:X")
         self.d6 = FullDiagnostic(f"{prefix}PHDGN-05:", D6Position, "DET:X")
         self.d7 = create_positioner(D7Position, f"{prefix}PHDGN-07:Y")
@@ -158,6 +178,18 @@ class I10Diagnostic(Device):
         super().__init__(name)
 
 
+class I10JDiagnostic(Device):
+    """Collection of all the diagnostic stage on i10-1."""
+
+    def __init__(self, prefix, name: str = "") -> None:
+        self.dj1 = ScreenCam(prefix=prefix + "PHDGN-01:")
+        self.dj2 = create_positioner(CellPosition, f"{prefix}IONC-01:Y")
+        self.dj2A = create_positioner(D2jPosition, f"{prefix}PHDGN-03:DET:X")
+        self.dj3 = FullDiagnostic(f"{prefix}PHDGN-02:", D3jPosition, "DET:X")
+
+        super().__init__(name)
+
+
 class I10Diagnostic5ADet(Device):
     """Diagnostic 5a detection with drain current and photo diode"""