dls-dodal 1.45.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

dodal/beamlines/i09_1.py

@@ -2,9 +2,7 @@ from dodal.common.beamlines.beamline_utils import (
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.electron_analyser.specs_analyser_io import (
-    SpecsAnalyserDriverIO,
-)
+from dodal.devices.electron_analyser.specs import SpecsAnalyserDriverIO
 from dodal.devices.synchrotron import Synchrotron
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name

dodal/beamlines/i18.py

@@ -12,7 +12,7 @@ from dodal.common.visit import (
     LocalDirectoryServiceClient,
     StaticVisitPathProvider,
 )
-from dodal.devices.dcm import DCM
+from dodal.devices.common_dcm import BaseDCM, PitchAndRollCrystal, RollCrystal
 from dodal.devices.i18.diode import Diode
 from dodal.devices.i18.KBMirror import KBMirror
 from dodal.devices.i18.table import Table
@@ -54,12 +54,15 @@ def undulator() -> Undulator:
     return Undulator(f"{PREFIX.insertion_prefix}-MO-SERVC-01:")
 
 
-@device_factory()
-def dcm() -> DCM:
+# See https://github.com/DiamondLightSource/dodal/issues/1180
+@device_factory(skip=True)
+def dcm() -> BaseDCM[RollCrystal, PitchAndRollCrystal]:
     # once spacing is added Si111 d-spacing is 3.135 angsterm , and Si311 is 1.637
     # calculations are in gda/config/lookupTables/Si111/eV_Deg_converter.xml
-    return DCM(
+    return BaseDCM(
         prefix=f"{PREFIX.beamline_prefix}-MO-DCM-01:",
+        xtal_1=RollCrystal,
+        xtal_2=PitchAndRollCrystal,
     )
 
 

dodal/beamlines/i22.py

@@ -18,7 +18,7 @@ from dodal.common.crystal_metadata import (
 from dodal.common.visit import RemoteDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.bimorph_mirror import BimorphMirror
 from dodal.devices.focusing_mirror import FocusingMirror
-from dodal.devices.i22.dcm import DoubleCrystalMonochromator
+from dodal.devices.i22.dcm import DCM
 from dodal.devices.i22.fswitch import FSwitch
 from dodal.devices.i22.nxsas import NXSasMetadataHolder, NXSasOAV, NXSasPilatus
 from dodal.devices.linkam3 import Linkam3
@@ -141,8 +141,8 @@ def bimorph_vfm() -> BimorphMirror:
 
 
 @device_factory()
-def dcm() -> DoubleCrystalMonochromator:
-    return DoubleCrystalMonochromator(
+def dcm() -> DCM:
+    return DCM(
         prefix=f"{PREFIX.beamline_prefix}-MO-DCM-01:",
         temperature_prefix=f"{PREFIX.beamline_prefix}-DI-DCM-01:",
         crystal_1_metadata=make_crystal_metadata_from_material(

dodal/beamlines/i23.py

@@ -1,7 +1,26 @@
-from dodal.common.beamlines.beamline_utils import device_factory
+from pathlib import Path
+
+from ophyd_async.core import StrictEnum
+from ophyd_async.epics.adpilatus import PilatusDetector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+    get_path_provider,
+    set_path_provider,
+)
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.common.beamlines.device_helpers import HDF5_SUFFIX
+from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.motors import SixAxisGonio
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.positioner import Positioner1D
+from dodal.devices.zebra.zebra import Zebra
+from dodal.devices.zebra.zebra_constants_mapping import (
+    ZebraMapping,
+    ZebraSources,
+    ZebraTTLOutputs,
+)
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name, get_hostname
 
@@ -9,8 +28,27 @@ BL = get_beamline_name("i23")
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/tmp"),
+        client=LocalDirectoryServiceClient(),
+    )
+)
+
 PREFIX = BeamlinePrefix(BL)
 
+I23_ZEBRA_MAPPING = ZebraMapping(
+    outputs=ZebraTTLOutputs(TTL_DETECTOR=1, TTL_SHUTTER=4),
+    sources=ZebraSources(),
+)
+
+
+class I23DetectorPositions(StrictEnum):
+    IN = "In"
+    OUT = "Out"
+    SAMPLE_CHANGE = "sample change"
+
 
 def _is_i23_machine():
     """
@@ -23,7 +61,7 @@ def _is_i23_machine():
 
 @device_factory(skip=lambda: not _is_i23_machine())
 def oav_pin_tip_detection() -> PinTipDetection:
-    """Get the i23 OAV pin-tip detection device"""
+    """Get the i23 OAV pin-tip detection device."""
 
     return PinTipDetection(
         f"{PREFIX.beamline_prefix}-DI-OAV-01:",
@@ -31,10 +69,43 @@ def oav_pin_tip_detection() -> PinTipDetection:
     )
 
 
+@device_factory()
+def shutter() -> ZebraShutter:
+    """Get the i23 zebra controlled shutter."""
+    return ZebraShutter(f"{PREFIX.beamline_prefix}-EA-SHTR-01:", "shutter")
+
+
 @device_factory()
 def gonio() -> SixAxisGonio:
     """Get the i23 goniometer"""
+    return SixAxisGonio(f"{PREFIX.beamline_prefix}-MO-GONIO-01:")
 
-    return SixAxisGonio(
-        f"{PREFIX.beamline_prefix}-MO-GONIO-01:",
+
+@device_factory()
+def zebra() -> Zebra:
+    """Get the i23 zebra"""
+    return Zebra(
+        name="zebra",
+        prefix=f"{PREFIX.beamline_prefix}-EA-ZEBRA-01:ZEBRA:",
+        mapping=I23_ZEBRA_MAPPING,
+    )
+
+
+@device_factory()
+def pilatus() -> PilatusDetector:
+    """Get the i23 pilatus"""
+    return PilatusDetector(
+        prefix=f"{PREFIX.beamline_prefix}-EA-PILAT-01:",
+        path_provider=get_path_provider(),
+        drv_suffix="cam1:",
+        fileio_suffix=HDF5_SUFFIX,
+    )
+
+
+@device_factory()
+def detector_motion() -> Positioner1D[I23DetectorPositions]:
+    """Get the i23 detector"""
+    return Positioner1D[I23DetectorPositions](
+        f"{PREFIX.beamline_prefix}-EA-DET-01:Z",
+        datatype=I23DetectorPositions,
     )

dodal/beamlines/p38.py

@@ -16,7 +16,7 @@ from dodal.common.crystal_metadata import (
 )
 from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.focusing_mirror import FocusingMirror
-from dodal.devices.i22.dcm import DoubleCrystalMonochromator
+from dodal.devices.i22.dcm import DCM
 from dodal.devices.i22.fswitch import FSwitch
 from dodal.devices.linkam3 import Linkam3
 from dodal.devices.pressure_jump_cell import PressureJumpCell
@@ -40,7 +40,7 @@ set_utils_beamline(BL)
 set_path_provider(
     StaticVisitPathProvider(
         BL,
-        Path("/dls/p38/data/2024/cm37282-2/bluesky"),
+        Path("/dls/p38/data/2025/cm40650-2/bluesky"),
         client=LocalDirectoryServiceClient(),
     )
 )
@@ -143,8 +143,8 @@ def hfm() -> FocusingMirror:
 
 
 @device_factory(mock=True)
-def dcm() -> DoubleCrystalMonochromator:
-    return DoubleCrystalMonochromator(
+def dcm() -> DCM:
+    return DCM(
         temperature_prefix=f"{PREFIX.beamline_prefix}-DI-DCM-01:",
         crystal_1_metadata=make_crystal_metadata_from_material(
             MaterialsEnum.Si, (1, 1, 1)

dodal/beamlines/p60.py

@@ -2,9 +2,7 @@ from dodal.common.beamlines.beamline_utils import (
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.electron_analyser.vgscienta_analyser_io import (
-    VGScientaAnalyserDriverIO,
-)
+from dodal.devices.electron_analyser.vgscienta import VGScientaAnalyserDriverIO
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -16,6 +14,4 @@ set_utils_beamline(BL)
 
 @device_factory()
 def analyser_driver() -> VGScientaAnalyserDriverIO:
-    return VGScientaAnalyserDriverIO(
-        name="analyser_driver", prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:"
-    )
+    return VGScientaAnalyserDriverIO(prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:")

dodal/beamlines/p99.py

@@ -1,7 +1,22 @@
-from dodal.common.beamlines.beamline_utils import device_factory, set_beamline
+from pathlib import Path
+
+from ophyd_async.epics.adandor import Andor2Detector
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+    get_path_provider,
+    set_beamline,
+    set_path_provider,
+)
+from dodal.common.beamlines.device_helpers import CAM_SUFFIX, HDF5_SUFFIX
+from dodal.common.visit import (
+    LocalDirectoryServiceClient,
+    StaticVisitPathProvider,
+)
 from dodal.devices.attenuator.filter import FilterMotor
 from dodal.devices.attenuator.filter_selections import P99FilterSelections
 from dodal.devices.motors import XYZPositioner
+from dodal.devices.p99.andor2_point import Andor2Point
 from dodal.devices.p99.sample_stage import SampleAngleStage
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
@@ -19,9 +34,7 @@ def angle_stage() -> SampleAngleStage:
 
 @device_factory()
 def filter() -> FilterMotor:
-    return FilterMotor(
-        f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:SELECT", P99FilterSelections
-    )
+    return FilterMotor(f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:", P99FilterSelections)
 
 
 @device_factory()
@@ -32,3 +45,34 @@ def sample_stage() -> XYZPositioner:
 @device_factory()
 def lab_stage() -> XYZPositioner:
     return XYZPositioner(f"{PREFIX.beamline_prefix}-MO-STAGE-02:LAB:")
+
+
+set_path_provider(
+    StaticVisitPathProvider(
+        BL,
+        Path("/dls/p99/data/2024/cm37284-2/processing/writenData"),
+        client=LocalDirectoryServiceClient(),  # RemoteDirectoryServiceClient("http://p99-control:8088/api"),
+    )
+)
+
+
+@device_factory()
+def andor2_det() -> Andor2Detector:
+    """Andor model:DU897_BV."""
+    return Andor2Detector(
+        prefix=f"{PREFIX.beamline_prefix}-EA-DET-03:",
+        path_provider=get_path_provider(),
+        drv_suffix=CAM_SUFFIX,
+        fileio_suffix=HDF5_SUFFIX,
+    )
+
+
+@device_factory()
+def andor2_point() -> Andor2Point:
+    """Using the andor2 as if it is a massive point detector, read the meanValue and total after
+    a picture is taken."""
+    return Andor2Point(
+        prefix=f"{PREFIX.beamline_prefix}-EA-DET-03:",
+        drv_suffix=CAM_SUFFIX,
+        read_uncached={"mean": "STAT:MeanValue_RBV", "total": "STAT:Total_RBV"},
+    )

dodal/common/beamlines/beamline_parameters.py

@@ -8,7 +8,6 @@ BEAMLINE_PARAMETER_KEYWORDS = ["FB", "FULL", "deadtime"]
 BEAMLINE_PARAMETER_PATHS = {
     "i03": "/dls_sw/i03/software/daq_configuration/domain/beamlineParameters",
     "i04": "/dls_sw/i04/software/gda_versions/gda_9_34/workspace_git/gda-mx.git/configurations/i04-config/scripts/beamlineParameters",
-    "s03": "tests/test_data/test_beamline_parameters.txt",
 }
 
 
@@ -92,7 +91,7 @@ def get_beamline_parameters(beamline_param_path: str | None = None):
     """Loads the beamline parameters from the specified path, or according to the
     environment variable if none is given"""
     if not beamline_param_path:
-        beamline_name = get_beamline_name("s03")
+        beamline_name = get_beamline_name("i03")
         beamline_param_path = BEAMLINE_PARAMETER_PATHS.get(beamline_name)
         if beamline_param_path is None:
             raise KeyError(

dodal/common/beamlines/beamline_utils.py

@@ -162,3 +162,8 @@ def set_path_provider(provider: PathProvider):
 
 def get_path_provider() -> PathProvider:
     return PATH_PROVIDER
+
+
+def clear_path_provider() -> None:
+    global PATH_PROVIDER
+    del PATH_PROVIDER

dodal/common/data_util.py

@@ -1,3 +1,4 @@
+import os
 from typing import TypeVar
 
 from pydantic import BaseModel
@@ -9,6 +10,9 @@ def load_json_file_to_class(
     t: type[TBaseModel],
     file: str,
 ) -> TBaseModel:
+    if not os.path.isfile(file):
+        raise FileNotFoundError(f"Cannot find file {file}")
+
     with open(file) as f:
         json_obj = f.read()
     cls = t.model_validate_json(json_obj)

dodal/devices/aperturescatterguard.py

@@ -2,17 +2,18 @@ from __future__ import annotations
 
 import asyncio
 
-from bluesky.protocols import Movable, Preparable
+from bluesky.protocols import Preparable
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
+    derived_signal_r,
+    derived_signal_rw,
 )
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
 
@@ -123,21 +124,21 @@ def load_positions_from_beamline_parameters(
     }
 
 
-class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable):
+class ApertureScatterguard(StandardReadable, Preparable):
     """Move the aperture and scatterguard assembly in a safe way. There are two ways to
     interact with the device depending on if you want simplicity or move flexibility.
 
     Examples:
         The simple interface is using::
 
-            await aperture_scatterguard.set(ApertureValue.LARGE)
+            await aperture_scatterguard.selected_aperture.set(ApertureValue.LARGE)
 
         This will move the assembly so that the large aperture is in the beam, regardless
         of where the assembly currently is.
 
         We may also want to move the assembly out of the beam with::
 
-            await aperture_scatterguard.set(ApertureValue.OUT_OF_BEAM)
+            await aperture_scatterguard.selected_aperture.set(ApertureValue.OUT_OF_BEAM)
 
         Note, to make sure we do this as quickly as possible, the scatterguard will stay
         in the same position relative to the aperture.
@@ -149,7 +150,7 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
 
         Then, at a later time, move back into the beam::
 
-            await aperture_scatterguard.set(ApertureValue.LARGE)
+            await  aperture_scatterguard.selected_aperture.set(ApertureValue.LARGE)
 
         Given the prepare has been done this move will now be faster as only the y is
         left to move.
@@ -164,11 +165,24 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.radius = create_r_hardware_backed_soft_signal(
-            float, self._get_current_radius, units="µm"
-        )
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.selected_aperture = derived_signal_rw(
+                self._get_current_aperture_position,
+                self._set_current_aperture_position,
+                large=self.aperture.large,
+                medium=self.aperture.medium,
+                small=self.aperture.small,
+                current_ap_y=self.aperture.y.user_readback,
+            )
+
+        self.radius = derived_signal_r(
+            self._get_current_radius,
+            current_aperture=self.selected_aperture,
+            derived_units="µm",
+        )
+
         self.add_readables(
             [
                 self.aperture.x.user_readback,
@@ -180,17 +194,9 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
             ],
         )
 
-        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.selected_aperture = create_r_hardware_backed_soft_signal(
-                ApertureValue, self._get_current_aperture_position
-            )
-
         super().__init__(name)
 
-    @AsyncStatus.wrap
-    async def set(self, value: ApertureValue):
-        """This set will move the aperture into the beam or move the whole assembly out"""
-
+    async def _set_current_aperture_position(self, value: ApertureValue) -> None:
         position = self._loaded_positions[value]
         await self._check_safe_to_move(position.aperture_z)
 
@@ -231,6 +237,27 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
                     "triggering another move."
                 )
 
+    def _get_current_radius(self, current_aperture: ApertureValue) -> float:
+        return self._loaded_positions[current_aperture].radius
+
+    def _is_out_of_beam(self, current_ap_y: float) -> bool:
+        out_ap_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
+        return current_ap_y <= out_ap_y + self._tolerances.aperture_y
+
+    def _get_current_aperture_position(
+        self, large: float, medium: float, small: float, current_ap_y: float
+    ) -> ApertureValue:
+        if large == 1:
+            return ApertureValue.LARGE
+        elif medium == 1:
+            return ApertureValue.MEDIUM
+        elif small == 1:
+            return ApertureValue.SMALL
+        elif self._is_out_of_beam(current_ap_y):
+            return ApertureValue.OUT_OF_BEAM
+
+        raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
+
     async def _safe_move_whilst_in_beam(self, position: AperturePosition):
         """
         Move the aperture and scatterguard combo safely to a new position.
@@ -282,33 +309,6 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
             self.scatterguard.y.set(scatterguard_y),
         )
 
-    async def _is_out_of_beam(self) -> bool:
-        current_ap_y = await self.aperture.y.user_readback.get_value()
-        out_ap_y = self._loaded_positions[ApertureValue.OUT_OF_BEAM].aperture_y
-        return current_ap_y <= out_ap_y + self._tolerances.aperture_y
-
-    async def _get_current_aperture_position(self) -> ApertureValue:
-        """
-        Returns the current aperture position using readback values
-        for SMALL, MEDIUM, LARGE. ROBOT_LOAD position defined when
-        mini aperture y <= ROBOT_LOAD.location.aperture_y + tolerance.
-        If no position is found then raises InvalidApertureMove.
-        """
-        if await self.aperture.large.get_value(cached=False) == 1:
-            return ApertureValue.LARGE
-        elif await self.aperture.medium.get_value(cached=False) == 1:
-            return ApertureValue.MEDIUM
-        elif await self.aperture.small.get_value(cached=False) == 1:
-            return ApertureValue.SMALL
-        elif await self._is_out_of_beam():
-            return ApertureValue.OUT_OF_BEAM
-
-        raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
-
-    async def _get_current_radius(self) -> float:
-        current_value = await self._get_current_aperture_position()
-        return self._loaded_positions[current_value].radius
-
     @AsyncStatus.wrap
     async def prepare(self, value: ApertureValue):
         """Moves the assembly to the position for the specified aperture, whilst keeping
@@ -317,7 +317,7 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
         Moving the assembly whilst out of the beam has no collision risk so we can just
         move all the motors together.
         """
-        if await self._is_out_of_beam():
+        if self._is_out_of_beam(await self.aperture.y.user_readback.get_value()):
             aperture_x, _, aperture_z, scatterguard_x, scatterguard_y = (
                 self._loaded_positions[value].values
             )
@@ -329,4 +329,4 @@ class ApertureScatterguard(StandardReadable, Movable[ApertureValue], Preparable)
                 self.scatterguard.y.set(scatterguard_y),
             )
         else:
-            await self.set(value)
+            await self.selected_aperture.set(value)

dodal/devices/common_dcm.py

@@ -0,0 +1,77 @@
+from typing import Generic, TypeVar
+
+from ophyd_async.core import (
+    StandardReadable,
+)
+from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.epics.motor import Motor
+
+
+class StationaryCrystal(StandardReadable):
+    def __init__(self, prefix):
+        super().__init__(prefix)
+
+
+class RollCrystal(StationaryCrystal):
+    def __init__(self, prefix):
+        with self.add_children_as_readables():
+            self.roll_in_mrad = Motor(prefix + "ROLL")
+        super().__init__(prefix)
+
+
+class PitchAndRollCrystal(StationaryCrystal):
+    def __init__(self, prefix):
+        with self.add_children_as_readables():
+            self.pitch_in_mrad = Motor(prefix + "PITCH")
+            self.roll_in_mrad = Motor(prefix + "ROLL")
+        super().__init__(prefix)
+
+
+Xtal_1 = TypeVar("Xtal_1", bound=StationaryCrystal)
+Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
+
+
+class BaseDCM(StandardReadable, 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: BaseDCM[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"
+            )
+
+            self._make_crystals(prefix, xtal_1, xtal_2)
+
+        super().__init__(name)
+
+    # 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]:
+            self.xtal_1 = xtal_1(f"{prefix}XTAL1:")
+            self.xtal_2 = xtal_2(f"{prefix}XTAL2:")
+        else:
+            self.xtal_1 = xtal_1(prefix)
+            self.xtal_2 = xtal_2(prefix)

dodal/devices/current_amplifiers/struck_scaler_counter.py

@@ -18,7 +18,7 @@ class CountMode(StrictEnum):
 
 class CountState(StrictEnum):
     DONE = "Done"
-    COUNT = "Count"  # type: ignore
+    COUNT = "Count"
 
 
 COUNT_PER_VOLTAGE = 100000

dodal/devices/diamond_filter.py

@@ -1,8 +1,8 @@
-from typing import Generic, TypeVar
+from typing import TypeVar
 
-from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.core import epics_signal_rw
-from ophyd_async.epics.motor import Motor
+from ophyd_async.core import StrictEnum
+
+from dodal.devices.positioner import Positioner1D
 
 
 class _Filters(StrictEnum):
@@ -25,22 +25,10 @@ class I04Filters(_Filters):
 T = TypeVar("T", bound=_Filters)
 
 
-class DiamondFilter(StandardReadable, Generic[T]):
+class DiamondFilter(Positioner1D[T]):
     """
     A filter set that is used to reduce the heat load on the monochromator.
 
     It has 4 slots that can contain filters of different thickness. Changing the thickness
     signal will move the filter set to select this filter.
     """
-
-    def __init__(
-        self,
-        prefix: str,
-        data_type: type[T],
-        name: str = "",
-    ) -> None:
-        with self.add_children_as_readables():
-            self.y_motor = Motor(prefix + "Y")
-            self.thickness = epics_signal_rw(data_type, f"{prefix}Y:MP:SELECT")
-
-        super().__init__(name)

dodal/devices/eiger.py

@@ -35,7 +35,7 @@ class InternalEigerTriggerMode(Enum):
 AVAILABLE_TIMEOUTS = {
     "i03": EigerTimeouts(
         stale_params_timeout=60,
-        general_status_timeout=10,
+        general_status_timeout=20,
         meta_file_ready_timeout=30,
         all_frames_timeout=120,  # Long timeout for meta file to compensate for filesystem issues
         arming_timeout=60,

dodal/devices/electron_analyser/__init__.py

@@ -0,0 +1,8 @@
+from .types import EnergyMode
+from .util import to_binding_energy, to_kinetic_energy
+
+__all__ = [
+    "to_binding_energy",
+    "to_kinetic_energy",
+    "EnergyMode",
+]