dls-dodal 1.32.0__py3-none-any.whl → 1.34.1__py3-none-any.whl

dodal/beamlines/i10.py

@@ -0,0 +1,257 @@
+from pathlib import Path
+
+from dodal.common.beamlines.beamline_utils import device_instantiation
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.apple2_undulator import (
+    UndulatorGap,
+    UndulatorJawPhase,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.i10.i10_apple2 import (
+    I10Apple2,
+    I10Apple2PGM,
+    I10Apple2Pol,
+    LinearArbitraryAngle,
+)
+from dodal.devices.i10.i10_setting_data import I10Grating
+from dodal.devices.pgm import PGM
+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)
+
+LOOK_UPTABLE_DIR = "/dls_sw/i10/software/gda/workspace_git/gda-diamond.git/configurations/i10-shared/lookupTables/"
+"""
+I10 has two insertion devices one up(idu) and one down stream(idd).
+It is worth noting that the down stream device is slightly longer,
+ so it can reach Mn edge for linear arbitrary.
+ idd == id1
+ and
+ idu == id2.
+"""
+
+
+def idd_gap(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> UndulatorGap:
+    return device_instantiation(
+        device_factory=UndulatorGap,
+        name="idd_gap",
+        prefix=f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-01:",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def idd_phase_axes(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> UndulatorPhaseAxes:
+    return device_instantiation(
+        device_factory=UndulatorPhaseAxes,
+        name="idd_phase_axes",
+        prefix=f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-01:",
+        top_outer="RPQ1",
+        top_inner="RPQ2",
+        btm_inner="RPQ3",
+        btm_outer="RPQ4",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def idd_jaw(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> UndulatorJawPhase:
+    return device_instantiation(
+        device_factory=UndulatorJawPhase,
+        name="idd_jaw",
+        prefix=f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-01:",
+        move_pv="RPQ1",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def idu_gap(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> UndulatorGap:
+    return device_instantiation(
+        device_factory=UndulatorGap,
+        name="idu_gap",
+        prefix=f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-21:",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def idu_phase_axes(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> UndulatorPhaseAxes:
+    return device_instantiation(
+        device_factory=UndulatorPhaseAxes,
+        name="idu_phase_axes",
+        prefix=f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-21:",
+        top_outer="RPQ1",
+        top_inner="RPQ2",
+        btm_inner="RPQ3",
+        btm_outer="RPQ4",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def idu_jaw(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> UndulatorJawPhase:
+    return device_instantiation(
+        device_factory=UndulatorJawPhase,
+        name="idu_jaw",
+        prefix=f"{BeamlinePrefix(BL).insertion_prefix}-MO-SERVC-21:",
+        move_pv="RPQ1",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+        bl_prefix=False,
+    )
+
+
+def pgm(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) -> PGM:
+    return device_instantiation(
+        device_factory=PGM,
+        name="pgm",
+        prefix="-OP-PGM-01:",
+        grating=I10Grating,
+        gratingPv="NLINES2",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idu_gap_phase(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> I10Apple2:
+    return device_instantiation(
+        device_factory=I10Apple2,
+        id_gap=idu_gap(wait_for_connection, fake_with_ophyd_sim),
+        id_phase=idu_phase_axes(wait_for_connection, fake_with_ophyd_sim),
+        id_jaw_phase=idu_jaw(wait_for_connection, fake_with_ophyd_sim),
+        energy_gap_table_path=Path(
+            LOOK_UPTABLE_DIR + "IDEnergy2GapCalibrations.csv",
+        ),
+        energy_phase_table_path=Path(
+            LOOK_UPTABLE_DIR + "IDEnergy2PhaseCalibrations.csv",
+        ),
+        source=("Source", "idu"),
+        name="idu_gap_phase",
+        prefix="",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idd_gap_phase(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> I10Apple2:
+    return device_instantiation(
+        device_factory=I10Apple2,
+        id_gap=idd_gap(wait_for_connection, fake_with_ophyd_sim),
+        id_phase=idd_phase_axes(wait_for_connection, fake_with_ophyd_sim),
+        id_jaw_phase=idd_jaw(wait_for_connection, fake_with_ophyd_sim),
+        energy_gap_table_path=Path(
+            LOOK_UPTABLE_DIR + "IDEnergy2GapCalibrations.csv",
+        ),
+        energy_phase_table_path=Path(
+            LOOK_UPTABLE_DIR + "IDEnergy2PhaseCalibrations.csv",
+        ),
+        source=("Source", "idd"),
+        name="idd_gap_phase",
+        prefix="",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idu_pol(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> I10Apple2Pol:
+    return device_instantiation(
+        device_factory=I10Apple2Pol,
+        prefix="",
+        id=idu_gap_phase(wait_for_connection, fake_with_ophyd_sim),
+        name="idu_pol",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idd_pol(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> I10Apple2Pol:
+    return device_instantiation(
+        device_factory=I10Apple2Pol,
+        prefix="",
+        id=idd_gap_phase(wait_for_connection, fake_with_ophyd_sim),
+        name="idd_pol",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idu(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> I10Apple2PGM:
+    return device_instantiation(
+        device_factory=I10Apple2PGM,
+        prefix="",
+        id=idu_gap_phase(wait_for_connection, fake_with_ophyd_sim),
+        pgm=pgm(wait_for_connection, fake_with_ophyd_sim),
+        name="idu",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idd(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> I10Apple2PGM:
+    return device_instantiation(
+        device_factory=I10Apple2PGM,
+        prefix="",
+        id=idd_gap_phase(wait_for_connection, fake_with_ophyd_sim),
+        pgm=pgm(wait_for_connection, fake_with_ophyd_sim),
+        name="idd",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idu_la_angle(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> LinearArbitraryAngle:
+    return device_instantiation(
+        device_factory=LinearArbitraryAngle,
+        prefix="",
+        id=idu(wait_for_connection, fake_with_ophyd_sim),
+        name="idu_la_angle",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )
+
+
+def idd_la_angle(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> LinearArbitraryAngle:
+    return device_instantiation(
+        device_factory=LinearArbitraryAngle,
+        prefix="",
+        id=idu(wait_for_connection, fake_with_ophyd_sim),
+        name="idd_la_angle",
+        wait=wait_for_connection,
+        fake=fake_with_ophyd_sim,
+    )

dodal/beamlines/i22.py

@@ -165,11 +165,10 @@ def dcm(
     return device_instantiation(
         DoubleCrystalMonochromator,
         "dcm",
-        "",
+        f"{BeamlinePrefix(BL).beamline_prefix}-MO-DCM-01:",
         wait_for_connection,
         fake_with_ophyd_sim,
         bl_prefix=False,
-        motion_prefix=f"{BeamlinePrefix(BL).beamline_prefix}-MO-DCM-01:",
         temperature_prefix=f"{BeamlinePrefix(BL).beamline_prefix}-DI-DCM-01:",
         crystal_1_metadata=CrystalMetadata(
             usage="Bragg",

dodal/beamlines/i24.py

@@ -1,4 +1,7 @@
-from dodal.common.beamlines.beamline_utils import BL, device_instantiation
+from dodal.common.beamlines.beamline_utils import (
+    BL,
+    device_instantiation,
+)
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.devices.detector import DetectorParams
 from dodal.devices.eiger import EigerDetector
@@ -11,7 +14,7 @@ from dodal.devices.i24.i24_detector_motion import DetectorMotion
 from dodal.devices.i24.i24_vgonio import VGonio
 from dodal.devices.i24.pmac import PMAC
 from dodal.devices.oav.oav_detector import OAV
-from dodal.devices.oav.oav_parameters import OAVConfigParams
+from dodal.devices.oav.oav_parameters import OAVConfig
 from dodal.devices.zebra import Zebra
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import get_beamline_name, skip_device
@@ -138,16 +141,13 @@ def pmac(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) ->
 
 @skip_device(lambda: BL == "s24")
 def oav(wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False) -> OAV:
-    """Get the i24 OAV device, instantiate it if it hasn't already been.
-    If this is called when already instantiated in i24, it will return the existing object.
-    """
     return device_instantiation(
         OAV,
         "oav",
-        "",
+        "-DI-OAV-01:",
         wait_for_connection,
         fake_with_ophyd_sim,
-        params=OAVConfigParams(ZOOM_PARAMS_FILE, DISPLAY_CONFIG),
+        config=OAVConfig(ZOOM_PARAMS_FILE, DISPLAY_CONFIG),
     )
 
 

dodal/beamlines/p38.py

@@ -222,11 +222,10 @@ def dcm(
     return device_instantiation(
         DoubleCrystalMonochromator,
         "dcm",
-        "",
+        f"{BeamlinePrefix(BL).beamline_prefix}-MO-DCM-01:",
         wait_for_connection,
         fake_with_ophyd_sim,
         bl_prefix=False,
-        motion_prefix=f"{BeamlinePrefix(BL).beamline_prefix}-MO-DCM-01:",
         temperature_prefix=f"{BeamlinePrefix(BL).beamline_prefix}-DI-DCM-01:",
         crystal_1_metadata=CrystalMetadata(
             usage="Bragg",

dodal/common/signal_utils.py

@@ -0,0 +1,53 @@
+from collections.abc import Callable, Coroutine
+from typing import Any, TypeVar
+
+from bluesky.protocols import Reading
+from ophyd_async.core import SignalR, SoftSignalBackend
+from ophyd_async.core._soft_signal_backend import SignalMetadata
+
+T = TypeVar("T")
+
+
+class HarwareBackedSoftSignalBackend(SoftSignalBackend[T]):
+    def __init__(
+        self,
+        get_from_hardware_func: Callable[[], Coroutine[Any, Any, T]],
+        *args,
+        **kwargs,
+    ) -> None:
+        self.get_from_hardware_func = get_from_hardware_func
+        super().__init__(*args, **kwargs)
+
+    async def _update_value(self):
+        new_value = await self.get_from_hardware_func()
+        await self.put(new_value)
+
+    async def get_reading(self) -> Reading:
+        await self._update_value()
+        return await super().get_reading()
+
+    async def get_value(self) -> T:
+        await self._update_value()
+        return await super().get_value()
+
+
+def create_hardware_backed_soft_signal(
+    datatype: type[T],
+    get_from_hardware_func: Callable[[], Coroutine[Any, Any, T]],
+    units: str | None = None,
+    precision: int | None = None,
+):
+    """Creates a soft signal that, when read will call the function passed into
+    `get_from_hardware_func` and return this.
+
+    This will allow you to make soft signals derived from arbitrary hardware signals.
+    However, calling subscribe on this signal does not give you a sensible value and
+    the signal is currently read only. See https://github.com/bluesky/ophyd-async/issues/525
+    for a more full solution.
+    """
+    metadata = SignalMetadata(units=units, precision=precision)
+    return SignalR(
+        backend=HarwareBackedSoftSignalBackend(
+            get_from_hardware_func, datatype, metadata=metadata
+        )
+    )

dodal/common/types.py

@@ -1,16 +1,11 @@
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Generator
-from typing import (
-    Any,
-)
+from collections.abc import Callable
 
-from bluesky.utils import Msg
+from bluesky.utils import MsgGenerator
 from ophyd_async.core import PathProvider
 
 # String identifier used by 'wait' or stubs that await
 Group = str
-# A true 'plan', usually the output of a generator function
-MsgGenerator = Generator[Msg, Any, None]
 # A function that generates a plan
 PlanGenerator = Callable[..., MsgGenerator]
 

dodal/devices/aperturescatterguard.py

@@ -8,11 +8,11 @@ from ophyd_async.core import (
     AsyncStatus,
     HintedSignal,
     StandardReadable,
-    soft_signal_rw,
 )
 from pydantic import BaseModel, Field
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
 from dodal.devices.aperture import Aperture
 from dodal.devices.scatterguard import Scatterguard
 
@@ -105,7 +105,9 @@ class ApertureScatterguard(StandardReadable, Movable):
     ) -> None:
         self.aperture = Aperture(prefix + "-MO-MAPT-01:")
         self.scatterguard = Scatterguard(prefix + "-MO-SCAT-01:")
-        self.radius = soft_signal_rw(float, units="µm")
+        self.radius = create_hardware_backed_soft_signal(
+            float, self._get_current_radius, units="µm"
+        )
         self._loaded_positions = loaded_positions
         self._tolerances = tolerances
         self.add_readables(
@@ -119,7 +121,9 @@ class ApertureScatterguard(StandardReadable, Movable):
             ],
         )
         with self.add_children_as_readables(HintedSignal):
-            self.selected_aperture = soft_signal_rw(ApertureValue)
+            self.selected_aperture = create_hardware_backed_soft_signal(
+                ApertureValue, self._get_current_aperture_position
+            )
 
         super().__init__(name)
 
@@ -136,9 +140,6 @@ class ApertureScatterguard(StandardReadable, Movable):
     @AsyncStatus.wrap
     async def _set_raw_unsafe(self, position: AperturePosition):
         """Accept the risks and move in an unsafe way. Collisions possible."""
-        if position.radius is not None:
-            await self.radius.set(position.radius)
-
         aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
             position.values
         )
@@ -150,13 +151,8 @@ class ApertureScatterguard(StandardReadable, Movable):
             self.scatterguard.x.set(scatterguard_x),
             self.scatterguard.y.set(scatterguard_y),
         )
-        try:
-            value = await self.get_current_aperture_position()
-            self.selected_aperture.set(value)
-        except InvalidApertureMove:
-            self.selected_aperture.set(None)  # type: ignore
 
-    async def get_current_aperture_position(self) -> ApertureValue:
+    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
@@ -176,6 +172,10 @@ class ApertureScatterguard(StandardReadable, Movable):
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
 
+    async def _get_current_radius(self) -> float | None:
+        current_value = await self._get_current_aperture_position()
+        return self._loaded_positions[current_value].radius
+
     async def _safe_move_within_datacollection_range(
         self, position: AperturePosition, value: ApertureValue
     ):
@@ -203,8 +203,6 @@ class ApertureScatterguard(StandardReadable, Movable):
             )
 
         current_ap_y = await self.aperture.y.user_readback.get_value()
-        if position.radius is not None:
-            await self.radius.set(position.radius)
 
         aperture_x, aperture_y, aperture_z, scatterguard_x, scatterguard_y = (
             position.values
@@ -231,4 +229,3 @@ class ApertureScatterguard(StandardReadable, Movable):
                 self.scatterguard.x.set(scatterguard_x),
                 self.scatterguard.y.set(scatterguard_y),
             )
-        await self.selected_aperture.set(value)