dls-dodal 1.33.0__py3-none-any.whl → 1.35.0__py3-none-any.whl

dodal/beamlines/i22.py

@@ -11,9 +11,13 @@ from dodal.common.beamlines.beamline_utils import (
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.common.beamlines.device_helpers import numbered_slits
+from dodal.common.crystal_metadata import (
+    MaterialsEnum,
+    make_crystal_metadata_from_material,
+)
 from dodal.common.visit import RemoteDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.focusing_mirror import FocusingMirror
-from dodal.devices.i22.dcm import CrystalMetadata, DoubleCrystalMonochromator
+from dodal.devices.i22.dcm import DoubleCrystalMonochromator
 from dodal.devices.i22.fswitch import FSwitch
 from dodal.devices.i22.nxsas import NXSasMetadataHolder, NXSasOAV, NXSasPilatus
 from dodal.devices.linkam3 import Linkam3
@@ -21,6 +25,7 @@ from dodal.devices.slits import Slits
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.tetramm import TetrammDetector
 from dodal.devices.undulator import Undulator
+from dodal.devices.watsonmarlow323_pump import WatsonMarlow323Pump
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name, skip_device
 
@@ -165,23 +170,17 @@ 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",
-            type="silicon",
-            reflection=(1, 1, 1),
-            d_spacing=(3.13475, "nm"),
+        crystal_1_metadata=make_crystal_metadata_from_material(
+            MaterialsEnum.Si, (1, 1, 1)
         ),
-        crystal_2_metadata=CrystalMetadata(
-            usage="Bragg",
-            type="silicon",
-            reflection=(1, 1, 1),
-            d_spacing=(3.13475, "nm"),
+        crystal_2_metadata=make_crystal_metadata_from_material(
+            MaterialsEnum.Si,
+            (1, 1, 1),
         ),
     )
 
@@ -378,3 +377,16 @@ def linkam(
         wait_for_connection,
         fake_with_ophyd_sim,
     )
+
+
+def ppump(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
+) -> WatsonMarlow323Pump:
+    """Sample Environment Peristaltic Pump"""
+    return device_instantiation(
+        WatsonMarlow323Pump,
+        "ppump",
+        "-EA-PUMP-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )

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
@@ -8,10 +11,10 @@ from dodal.devices.i24.beamstop import Beamstop
 from dodal.devices.i24.dcm import DCM
 from dodal.devices.i24.dual_backlight import DualBacklight
 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.i24.vgonio import VerticalGoniometer
 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,28 +141,25 @@ 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),
     )
 
 
 @skip_device(lambda: BL == "s24")
 def vgonio(
     wait_for_connection: bool = True, fake_with_ophyd_sim: bool = False
-) -> VGonio:
-    """Get the i24 vgonio device, instantiate it if it hasn't already been.
+) -> VerticalGoniometer:
+    """Get the i24 vertical goniometer device, instantiate it if it hasn't already been.
     If this is called when already instantiated, it will return the existing object.
     """
     return device_instantiation(
-        VGonio,
+        VerticalGoniometer,
         "vgonio",
         "-MO-VGON-01:",
         wait_for_connection,

dodal/beamlines/p38.py

@@ -10,14 +10,19 @@ from dodal.common.beamlines.beamline_utils import (
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.common.beamlines.device_helpers import numbered_slits
+from dodal.common.crystal_metadata import (
+    MaterialsEnum,
+    make_crystal_metadata_from_material,
+)
 from dodal.common.visit import LocalDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.focusing_mirror import FocusingMirror
-from dodal.devices.i22.dcm import CrystalMetadata, DoubleCrystalMonochromator
+from dodal.devices.i22.dcm import DoubleCrystalMonochromator
 from dodal.devices.i22.fswitch import FSwitch
 from dodal.devices.linkam3 import Linkam3
 from dodal.devices.slits import Slits
 from dodal.devices.tetramm import TetrammDetector
 from dodal.devices.undulator import Undulator
+from dodal.devices.watsonmarlow323_pump import WatsonMarlow323Pump
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name, skip_device
 
@@ -222,23 +227,16 @@ 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",
-            type="silicon",
-            reflection=(1, 1, 1),
-            d_spacing=(3.13475, "nm"),
+        crystal_1_metadata=make_crystal_metadata_from_material(
+            MaterialsEnum.Si, (1, 1, 1)
         ),
-        crystal_2_metadata=CrystalMetadata(
-            usage="Bragg",
-            type="silicon",
-            reflection=(1, 1, 1),
-            d_spacing=(3.13475, "nm"),
+        crystal_2_metadata=make_crystal_metadata_from_material(
+            MaterialsEnum.Si, (1, 1, 1)
         ),
     )
 
@@ -318,3 +316,16 @@ def linkam(
         wait_for_connection,
         fake_with_ophyd_sim,
     )
+
+
+def ppump(
+    wait_for_connection: bool = True, fake_with_ophyd_sim: bool = True
+) -> WatsonMarlow323Pump:
+    """Peristaltic Pump"""
+    return device_instantiation(
+        WatsonMarlow323Pump,
+        "ppump",
+        "-EA-PUMP-01:",
+        wait_for_connection,
+        fake_with_ophyd_sim,
+    )

dodal/common/beamlines/beamline_utils.py

@@ -90,8 +90,7 @@ def device_instantiation(
         fake: bool                  whether to fake with ophyd.sim
         post_create: Callable       (optional) a function to be run on the device after
                                     creation
-        bl_prefix: bool             if true, add the beamline prefix when instantiating, if
-                                    false the complete PV prefix must be supplied.
+        bl_prefix: bool             if true, add the beamline prefix when instantiating
     Returns:
         The instance of the device.
     """

dodal/common/crystal_metadata.py

@@ -0,0 +1,61 @@
+import math
+from dataclasses import dataclass
+from enum import Enum
+from typing import Literal
+
+
+@dataclass(frozen=True)
+class Material:
+    """
+    Class representing a crystalline material with a specific lattice parameter.
+    """
+
+    name: str
+    lattice_parameter: float  # Lattice parameter in meters
+
+
+class MaterialsEnum(Enum):
+    Si = Material(name="silicon", lattice_parameter=5.4310205e-10)
+    Ge = Material(name="germanium", lattice_parameter=5.6575e-10)
+
+
+@dataclass(frozen=True)
+class CrystalMetadata:
+    """
+    Metadata used in the NeXus format,
+    see https://manual.nexusformat.org/classes/base_classes/NXcrystal.html
+    """
+
+    usage: Literal["Bragg", "Laue"]
+    type: str
+    reflection: tuple[int, int, int]
+    d_spacing: tuple[float, str]
+
+    @staticmethod
+    def calculate_default_d_spacing(
+        lattice_parameter: float, reflection: tuple[int, int, int]
+    ) -> tuple[float, str]:
+        """
+        Calculates the d-spacing value in nanometers based on the given lattice parameter and reflection indices.
+        """
+        h_index, k_index, l_index = reflection
+        d_spacing_m = lattice_parameter / math.sqrt(
+            h_index**2 + k_index**2 + l_index**2
+        )
+        d_spacing_nm = d_spacing_m * 1e9  # Convert meters to nanometers
+        return round(d_spacing_nm, 5), "nm"
+
+
+def make_crystal_metadata_from_material(
+    material: MaterialsEnum,
+    reflection_plane: tuple[int, int, int],
+    usage: Literal["Bragg", "Laue"] = "Bragg",
+    d_spacing_param: tuple[float, str] | None = None,
+):
+    d_spacing = d_spacing_param or CrystalMetadata.calculate_default_d_spacing(
+        material.value.lattice_parameter, reflection_plane
+    )
+    assert all(
+        isinstance(i, int) and i > 0 for i in reflection_plane
+    ), "Reflection plane indices must be positive integers"
+    return CrystalMetadata(usage, material.value.name, reflection_plane, d_spacing)

dodal/common/signal_utils.py

@@ -1,17 +1,14 @@
 from collections.abc import Callable, Coroutine
-from typing import Any, TypeVar
+from typing import Any
 
 from bluesky.protocols import Reading
-from ophyd_async.core import SignalR, SoftSignalBackend
-from ophyd_async.core._soft_signal_backend import SignalMetadata
+from ophyd_async.core import SignalDatatypeT, SignalR, SoftSignalBackend
 
-T = TypeVar("T")
 
-
-class HarwareBackedSoftSignalBackend(SoftSignalBackend[T]):
+class HardwareBackedSoftSignalBackend(SoftSignalBackend[SignalDatatypeT]):
     def __init__(
         self,
-        get_from_hardware_func: Callable[[], Coroutine[Any, Any, T]],
+        get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
         *args,
         **kwargs,
     ) -> None:
@@ -20,20 +17,20 @@ class HarwareBackedSoftSignalBackend(SoftSignalBackend[T]):
 
     async def _update_value(self):
         new_value = await self.get_from_hardware_func()
-        await self.put(new_value)
+        await self.put(new_value, True)
 
     async def get_reading(self) -> Reading:
         await self._update_value()
         return await super().get_reading()
 
-    async def get_value(self) -> T:
+    async def get_value(self) -> SignalDatatypeT:
         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]],
+    datatype: type[SignalDatatypeT],
+    get_from_hardware_func: Callable[[], Coroutine[Any, Any, SignalDatatypeT]],
     units: str | None = None,
     precision: int | None = None,
 ):
@@ -45,9 +42,8 @@ def create_hardware_backed_soft_signal(
     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
+        backend=HardwareBackedSoftSignalBackend(
+            get_from_hardware_func, datatype, units=units, precision=precision
         )
     )

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/CTAB.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 
 class CTAB(StandardReadable):

dodal/devices/aperture.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 
 class Aperture(StandardReadable):

dodal/devices/aperturescatterguard.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
 import asyncio
-from enum import Enum
 
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
 )
 from pydantic import BaseModel, Field
 
@@ -22,12 +22,24 @@ class InvalidApertureMove(Exception):
 
 
 class AperturePosition(BaseModel):
+    """
+    Represents one of the available positions for the Aperture-Scatterguard.
+    Attributes:
+        aperture_x: The x position of the aperture component in mm
+        aperture_y: The y position of the aperture component in mm
+        aperture_z: The z position of the aperture component in mm
+        scatterguard_x: The x position of the scatterguard component in mm
+        scatterguard_y: The y position of the scatterguard component in mm
+        radius: Radius of the selected aperture. When in the Robot Load position, the
+            radius is defined to be 0
+    """
+
     aperture_x: float
     aperture_y: float
     aperture_z: float
     scatterguard_x: float
     scatterguard_y: float
-    radius: float | None = Field(json_schema_extra={"units": "µm"}, default=None)
+    radius: float = Field(json_schema_extra={"units": "µm"}, default=0.0)
 
     @property
     def values(self) -> tuple[float, float, float, float, float]:
@@ -54,7 +66,7 @@ class AperturePosition(BaseModel):
     @staticmethod
     def from_gda_params(
         name: ApertureValue,
-        radius: float | None,
+        radius: float,
         params: GDABeamlineParameters,
     ) -> AperturePosition:
         return AperturePosition(
@@ -67,7 +79,7 @@ class AperturePosition(BaseModel):
         )
 
 
-class ApertureValue(str, Enum):
+class ApertureValue(StrictEnum):
     """Maps from a short usable name to the value name in the GDA Beamline parameters"""
 
     ROBOT_LOAD = "ROBOT_LOAD"
@@ -81,7 +93,7 @@ def load_positions_from_beamline_parameters(
 ) -> dict[ApertureValue, AperturePosition]:
     return {
         ApertureValue.ROBOT_LOAD: AperturePosition.from_gda_params(
-            ApertureValue.ROBOT_LOAD, None, params
+            ApertureValue.ROBOT_LOAD, 0, params
         ),
         ApertureValue.SMALL: AperturePosition.from_gda_params(
             ApertureValue.SMALL, 20, params
@@ -120,7 +132,7 @@ class ApertureScatterguard(StandardReadable, Movable):
                 self.radius,
             ],
         )
-        with self.add_children_as_readables(HintedSignal):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.selected_aperture = create_hardware_backed_soft_signal(
                 ApertureValue, self._get_current_aperture_position
             )
@@ -172,7 +184,7 @@ class ApertureScatterguard(StandardReadable, Movable):
 
         raise InvalidApertureMove("Current aperture/scatterguard state unrecognised")
 
-    async def _get_current_radius(self) -> float | None:
+    async def _get_current_radius(self) -> float:
         current_value = await self._get_current_aperture_position()
         return self._loaded_positions[current_value].radius