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

dodal/beamlines/i10_1.py

@@ -0,0 +1,35 @@
+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.i10 import I10JDiagnostic, I10JSlits, PiezoMirror
+from dodal.devices.temperture_controller.lakeshore.lakeshore import Lakeshore336
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("i10-1")
+set_log_beamline(BL)
+set_utils_beamline(BL)
+PREFIX = BeamlinePrefix("i10", "J")
+
+
+@device_factory()
+def em_temperature_controller() -> Lakeshore336:
+    return Lakeshore336(
+        prefix=f"{PREFIX.beamline_prefix}-EA-TCTRL-41:",
+    )
+
+
+@device_factory()
+def slits() -> I10JSlits:
+    return I10JSlits(prefix=f"{PREFIX.beamline_prefix}-AL-SLITS-")
+
+
+@device_factory()
+def diagnostic() -> I10JDiagnostic:
+    return I10JDiagnostic(
+        prefix=f"{PREFIX.beamline_prefix}-DI-",
+    )
+
+
+@device_factory()
+def focusing_mirror() -> PiezoMirror:
+    return PiezoMirror(prefix=f"{PREFIX.beamline_prefix}-OP-FOCA-01:")

dodal/beamlines/i10_optics.py

@@ -0,0 +1,205 @@
+"""
+note:
+    I10 has two insertion devices one up(idu) and one down stream(idd).
+    It is worth noting that the downstream device is slightly longer,
+    so it can reach Mn edge for linear arbitrary.
+    idd == id1,    idu == id2.
+"""
+
+from daq_config_server.client import ConfigServer
+
+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.apple2_undulator import (
+    BeamEnergy,
+    InsertionDeviceEnergy,
+    InsertionDevicePolarisation,
+    UndulatorGap,
+    UndulatorJawPhase,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.i10 import (
+    I10SharedDiagnostic,
+    I10SharedSlits,
+    I10SharedSlitsDrainCurrent,
+    PiezoMirror,
+)
+from dodal.devices.i10.i10_apple2 import (
+    I10Apple2,
+    I10Apple2Controller,
+    LinearArbitraryAngle,
+)
+
+# Imports taken from i10 while we work out how to deal with split end stations
+from dodal.devices.i10.i10_setting_data import I10Grating
+from dodal.devices.pgm import PGM
+from dodal.devices.synchrotron import Synchrotron
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("i10")
+set_log_beamline(BL)
+set_utils_beamline(BL)
+PREFIX = BeamlinePrefix(BL)
+
+LOOK_UPTABLE_DIR = "/dls_sw/i10/software/blueapi/scratch/i10-config/lookupTables/"
+
+
+@device_factory()
+def synchrotron() -> Synchrotron:
+    return Synchrotron()
+
+
+"""Mirrors"""
+
+
+@device_factory()
+def first_mirror() -> PiezoMirror:
+    return PiezoMirror(prefix=f"{PREFIX.beamline_prefix}-OP-COL-01:")
+
+
+@device_factory()
+def pgm() -> PGM:
+    "I10 Plane Grating Monochromator, it can change energy via pgm.energy.set(<energy>)"
+    return PGM(
+        prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
+        grating=I10Grating,
+        grating_pv="NLINES2",
+    )
+
+
+@device_factory()
+def switching_mirror() -> PiezoMirror:
+    return PiezoMirror(prefix=f"{PREFIX.beamline_prefix}-OP-SWTCH-01:")
+
+
+"""ID"""
+
+I10_CONF_CLIENT = ConfigServer(url="https://daq-config.diamond.ac.uk")
+
+LOOK_UPTABLE_DIR = "/dls_sw/i10/software/gda/workspace_git/gda-diamond.git/configurations/i10-shared/lookupTables/"
+
+
+@device_factory()
+def idd() -> I10Apple2:
+    """i10 downstream insertion device:"""
+    return I10Apple2(
+        id_gap=UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:"),
+        id_phase=UndulatorPhaseAxes(
+            prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
+            top_outer="RPQ1",
+            top_inner="RPQ2",
+            btm_inner="RPQ3",
+            btm_outer="RPQ4",
+        ),
+        id_jaw_phase=UndulatorJawPhase(
+            prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
+            move_pv="RPQ1",
+        ),
+    )
+
+
+@device_factory()
+def idd_controller() -> I10Apple2Controller:
+    """I10 downstream insertion device controller."""
+    return I10Apple2Controller(
+        apple2=idd(),
+        lookuptable_dir=LOOK_UPTABLE_DIR,
+        source=("Source", "idd"),
+        config_client=I10_CONF_CLIENT,
+    )
+
+
+@device_factory()
+def idd_energy() -> InsertionDeviceEnergy:
+    return InsertionDeviceEnergy(id_controller=idd_controller())
+
+
+@device_factory()
+def idd_polarisation() -> InsertionDevicePolarisation:
+    return InsertionDevicePolarisation(id_controller=idd_controller())
+
+
+@device_factory()
+def idd_laa() -> LinearArbitraryAngle:
+    return LinearArbitraryAngle(id_controller=idd_controller())
+
+
+@device_factory()
+def energy_dd() -> BeamEnergy:
+    """Beam energy from down energy devices."""
+    return BeamEnergy(id_energy=idd_energy(), mono=pgm().energy)
+
+
+@device_factory()
+def idu() -> I10Apple2:
+    """i10 upstream insertion device"""
+    return I10Apple2(
+        id_gap=UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-21:"),
+        id_phase=UndulatorPhaseAxes(
+            prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-21:",
+            top_outer="RPQ1",
+            top_inner="RPQ2",
+            btm_inner="RPQ3",
+            btm_outer="RPQ4",
+        ),
+        id_jaw_phase=UndulatorJawPhase(
+            prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-21:",
+            move_pv="RPQ1",
+        ),
+    )
+
+
+@device_factory()
+def idu_controller() -> I10Apple2Controller:
+    """I10 upstream insertion device controller."""
+    return I10Apple2Controller(
+        apple2=idu(),
+        lookuptable_dir=LOOK_UPTABLE_DIR,
+        source=("Source", "idu"),
+        config_client=I10_CONF_CLIENT,
+    )
+
+
+@device_factory()
+def idu_energy() -> InsertionDeviceEnergy:
+    return InsertionDeviceEnergy(id_controller=idu_controller())
+
+
+@device_factory()
+def idu_polarisation() -> InsertionDevicePolarisation:
+    return InsertionDevicePolarisation(id_controller=idu_controller())
+
+
+@device_factory()
+def idu_laa() -> LinearArbitraryAngle:
+    return LinearArbitraryAngle(id_controller=idu_controller())
+
+
+@device_factory()
+def energy_ud() -> BeamEnergy:
+    """Beam energy from down energy devices."""
+    return BeamEnergy(id_energy=idu_energy(), mono=pgm().energy)
+
+
+"""Slits"""
+
+
+@device_factory()
+def optics_slits() -> I10SharedSlits:
+    return I10SharedSlits(prefix=f"{PREFIX.beamline_prefix}-AL-SLITS-")
+
+
+"""Diagnostics"""
+
+
+@device_factory()
+def optics_diagnostics() -> I10SharedDiagnostic:
+    return I10SharedDiagnostic(
+        prefix=f"{PREFIX.beamline_prefix}-DI-",
+    )
+
+
+@device_factory()
+def optics_slits_current() -> I10SharedSlitsDrainCurrent:
+    return I10SharedSlitsDrainCurrent(prefix=f"{PREFIX.beamline_prefix}-")

dodal/beamlines/i15_1.py

@@ -25,7 +25,7 @@ to one or more Bluesky Protocols.
 
 
 @device_factory()
-def attY() -> NumberedTripleAxisStage:
+def att_y() -> NumberedTripleAxisStage:
     return NumberedTripleAxisStage(
         f"{PREFIX.beamline_prefix}-OP-ATTN-01:",
         axis1_infix="STICK1",
@@ -35,18 +35,18 @@ def attY() -> NumberedTripleAxisStage:
 
 
 @device_factory()
-def baseY() -> Motor:
+def base_y() -> Motor:
     return Motor(f"{PREFIX.beamline_prefix}-MO-TABLE-01:Y")
 
 
 @device_factory()
-def blowerY() -> Motor:
+def blower_y() -> Motor:
     """Same motor as blowerZ"""
     return Motor(f"{PREFIX.beamline_prefix}-EA-BLOWR-01:TLATE")
 
 
 @device_factory()
-def blowerZ() -> Motor:
+def blower_z() -> Motor:
     """Same motor as blowerY"""
     return Motor(f"{PREFIX.beamline_prefix}-EA-BLOWR-01:TLATE")
 
@@ -67,7 +67,7 @@ def det2() -> YZStage:
 
 
 @device_factory()
-def envX() -> Motor:
+def env_x() -> Motor:
     return Motor(f"{PREFIX.beamline_prefix}-MO-TABLE-01:ENV:X")
 
 

dodal/beamlines/i17.py

@@ -7,6 +7,16 @@ 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.apple2_undulator import (
+    Apple2,
+    Apple2Controller,
+    BeamEnergy,
+    InsertionDeviceEnergy,
+    InsertionDevicePolarisation,
+    UndulatorGap,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.i17.i17_apple2 import I17Apple2Controller
 from dodal.devices.pgm import PGM
 from dodal.devices.synchrotron import Synchrotron
 from dodal.log import set_beamline as set_log_beamline
@@ -33,5 +43,44 @@ def pgm() -> PGM:
     return PGM(
         prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
         grating=I17Grating,
-        gratingPv="NLINES2",
+        grating_pv="NLINES2",
+    )
+
+
+@device_factory(skip=True)
+def id() -> Apple2:
+    """I17 insertion device:"""
+    return Apple2(
+        id_gap=UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:"),
+        id_phase=UndulatorPhaseAxes(
+            prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:",
+            top_outer="RPQ1",
+            top_inner="RPQ2",
+            btm_inner="RPQ3",
+            btm_outer="RPQ4",
+        ),
+    )
+
+
+@device_factory(skip=True)
+def id_controller() -> Apple2Controller:
+    """I17 insertion device controller with dummy energy to motor_converter."""
+    return I17Apple2Controller(
+        apple2=id(), energy_to_motor_converter=lambda energy, pol: (0.0, 0.0)
     )
+
+
+@device_factory(skip=True)
+def id_energy() -> InsertionDeviceEnergy:
+    return InsertionDeviceEnergy(id_controller=id_controller())
+
+
+@device_factory(skip=True)
+def id_polarisation() -> InsertionDevicePolarisation:
+    return InsertionDevicePolarisation(id_controller=id_controller())
+
+
+@device_factory(skip=True)
+def energy() -> BeamEnergy:
+    """Beam energy."""
+    return BeamEnergy(id_energy=id_energy(), mono=pgm().energy)

dodal/beamlines/i18.py

@@ -12,9 +12,13 @@ from dodal.common.visit import (
     LocalDirectoryServiceClient,
     StaticVisitPathProvider,
 )
-from dodal.devices.common_dcm import BaseDCM, PitchAndRollCrystal, RollCrystal
+from dodal.devices.common_dcm import (
+    DoubleCrystalMonochromatorWithDSpacing,
+    PitchAndRollCrystal,
+    RollCrystal,
+)
 from dodal.devices.i18.diode import Diode
-from dodal.devices.i18.KBMirror import KBMirror
+from dodal.devices.i18.kb_mirror import KBMirror
 from dodal.devices.motors import XYStage, XYZThetaStage
 from dodal.devices.slits import Slits
 from dodal.devices.synchrotron import Synchrotron
@@ -55,13 +59,15 @@ def undulator() -> Undulator:
 
 # 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 BaseDCM(
-        prefix=f"{PREFIX.beamline_prefix}-MO-DCM-01:",
-        xtal_1=RollCrystal,
-        xtal_2=PitchAndRollCrystal,
+def dcm() -> DoubleCrystalMonochromatorWithDSpacing:
+    """
+    A double crystal monocromator device, used to select the beam energy.
+
+    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 DoubleCrystalMonochromatorWithDSpacing(
+        f"{PREFIX.beamline_prefix}-MO-DCM-01:", RollCrystal, PitchAndRollCrystal
     )
 
 

dodal/beamlines/i19_1.py

@@ -4,12 +4,12 @@ from dodal.common.beamlines.beamline_utils import (
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
-from dodal.devices.i19.beamstop import BeamStop
-from dodal.devices.i19.blueapi_device import HutchState
-from dodal.devices.i19.shutter import (
+from dodal.devices.i19.access_controlled.blueapi_device import HutchState
+from dodal.devices.i19.access_controlled.shutter import (
     AccessControlledShutter,
     HutchState,
 )
+from dodal.devices.i19.beamstop import BeamStop
 from dodal.devices.oav.oav_detector import OAVBeamCentreFile
 from dodal.devices.oav.oav_parameters import OAVConfigBeamCentre
 from dodal.devices.synchrotron import Synchrotron

dodal/beamlines/i19_2.py

@@ -7,12 +7,12 @@ from dodal.common.beamlines.beamline_utils import (
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
+from dodal.devices.i19.access_controlled.blueapi_device import HutchState
+from dodal.devices.i19.access_controlled.shutter import AccessControlledShutter
 from dodal.devices.i19.backlight import BacklightPosition
 from dodal.devices.i19.beamstop import BeamStop
-from dodal.devices.i19.blueapi_device import HutchState
 from dodal.devices.i19.diffractometer import FourCircleDiffractometer
 from dodal.devices.i19.pin_col_stages import PinholeCollimatorControl
-from dodal.devices.i19.shutter import AccessControlledShutter
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.zebra.zebra import Zebra
 from dodal.devices.zebra.zebra_constants_mapping import (

dodal/beamlines/i19_optics.py

@@ -5,7 +5,10 @@ from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
 )
 from dodal.devices.hutch_shutter import HutchShutter
-from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME, HutchAccessControl
+from dodal.devices.i19.access_controlled.hutch_access import (
+    ACCESS_DEVICE_NAME,
+    HutchAccessControl,
+)
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix
 

dodal/beamlines/i24.py

@@ -9,8 +9,8 @@ from dodal.common.beamlines.beamline_utils import (
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.devices.attenuator.attenuator import EnumFilterAttenuator
 from dodal.devices.attenuator.filter_selections import (
-    I24_FilterOneSelections,
-    I24_FilterTwoSelections,
+    I24FilterOneSelections,
+    I24FilterTwoSelections,
 )
 from dodal.devices.hutch_shutter import HutchShutter
 from dodal.devices.i24.aperture import Aperture
@@ -59,7 +59,7 @@ def attenuator() -> EnumFilterAttenuator:
     existing object."""
     return EnumFilterAttenuator(
         f"{PREFIX.beamline_prefix}-OP-ATTN-01:",
-        filter_selection=(I24_FilterOneSelections, I24_FilterTwoSelections),
+        filter_selection=(I24FilterOneSelections, I24FilterTwoSelections),
     )
 
 

dodal/cli.py

@@ -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)
@@ -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,7 +112,7 @@ def _connect_devices(
 
     # Connect ophyd-async devices
     try:
-        RE(ensure_connected(*ophyd_async_devices.values(), mock=sim_backend))
+        run_engine(ensure_connected(*ophyd_async_devices.values(), mock=sim_backend))
     except NotConnected as ex:
         exceptions = {**exceptions, **ex.sub_errors}
 

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):
         """