dls-dodal 1.58.0__py3-none-any.whl → 1.60.0__py3-none-any.whl

dodal/devices/i15/jack.py

@@ -0,0 +1,39 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class JackX(StandardReadable):
+    """Focusing Mirror"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.rotation = Motor(prefix + "Ry")
+            self.transx = Motor(prefix + "X")
+            self.y1 = Motor(prefix + "Y1")
+            self.y2 = Motor(prefix + "Y2")
+            self.y3 = Motor(prefix + "Y3")
+
+        super().__init__(name)
+
+
+class JackY(StandardReadable):
+    """Focusing Mirror"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.j1 = Motor(prefix + "J1")
+            self.j2 = Motor(prefix + "J2")
+            self.j3 = Motor(prefix + "J3")
+            self.pitch = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.y = Motor(prefix + "Y")
+
+        super().__init__(name)

dodal/devices/i15/laue.py

@@ -0,0 +1,18 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class LaueMonochrometer(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.bend = Motor(prefix + "BENDER")
+            self.bragg = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.yaw = Motor(prefix + "YAW")
+            self.y = Motor(prefix + "Y")
+
+        super().__init__(name)

dodal/devices/i15/motors.py

@@ -0,0 +1,27 @@
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import Stage
+
+
+class UpstreamDownstreamPair(Stage):
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.upstream = Motor(prefix + "US")
+            self.downstream = Motor(prefix + "DS")
+        super().__init__(name=name)
+
+
+class NumberedTripleAxisStage(Stage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        axis1_infix: str = "AXIS1",
+        axis2_infix: str = "AXIS2",
+        axis3_infix: str = "AXIS3",
+    ):
+        with self.add_children_as_readables():
+            self.axis1 = Motor(prefix + axis1_infix)
+            self.axis2 = Motor(prefix + axis2_infix)
+            self.axis3 = Motor(prefix + axis3_infix)
+        super().__init__(name=name)

dodal/devices/i15/multilayer_mirror.py

@@ -0,0 +1,25 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class MultiLayerMirror(StandardReadable):
+    """Multilayer Mirror"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.ds_x = Motor(prefix + "X2")
+            self.ds_y = Motor(prefix + "J3")
+            self.ib_y = Motor(prefix + "J1")
+            self.ob_y = Motor(prefix + "J2")
+            self.pitch = Motor(prefix + "PITCH")
+            self.roll = Motor(prefix + "ROLL")
+            self.us_x = Motor(prefix + "X1")
+            self.x = Motor(prefix + "X")
+            self.y = Motor(prefix + "Y")
+            self.yaw = Motor(prefix + "YAW")
+
+        super().__init__(name)

dodal/devices/i15/rail.py

@@ -0,0 +1,17 @@
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.motor import Motor
+
+
+class Rail(StandardReadable):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + "PITCH")
+            self.y = Motor(prefix + "Y")
+            self.y1 = Motor(prefix + "Y1")
+            self.y2 = Motor(prefix + "Y2")
+
+        super().__init__(name)

dodal/devices/i21/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.i21.enums import Grating
+
+__all__ = ["Grating"]

dodal/devices/i21/enums.py

@@ -0,0 +1,8 @@
+from ophyd_async.core import StrictEnum
+
+
+class Grating(StrictEnum):
+    VPG1 = "VPG1"
+    VPG2 = "VPG2"
+    VPG3 = "VPG3"
+    VPG4 = "VPG4"

dodal/devices/i22/nxsas.py

@@ -7,6 +7,7 @@ from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import PathProvider
 from ophyd_async.epics.adaravis import AravisDetector
+from ophyd_async.epics.adcore import NDPluginBaseIO
 from ophyd_async.epics.adpilatus import PilatusDetector
 
 ValueAndUnits = tuple[float, str]
@@ -106,6 +107,7 @@ class NXSasPilatus(PilatusDetector):
         fileio_suffix: str,
         metadata_holder: NXSasMetadataHolder,
         name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
     ):
         """Extends detector with configuration metadata required or desired
         to comply with the NXsas application definition.

dodal/devices/i24/commissioning_jungfrau.py

@@ -0,0 +1,114 @@
+import asyncio
+from collections.abc import AsyncGenerator, AsyncIterator
+from pathlib import Path
+
+from bluesky.protocols import StreamAsset
+from event_model import DataKey  # type: ignore
+from ophyd_async.core import (
+    AutoIncrementingPathProvider,
+    DetectorWriter,
+    StandardDetector,
+    StandardReadable,
+    StaticPathProvider,
+    observe_value,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+from ophyd_async.fastcs.jungfrau._controller import JungfrauController
+from ophyd_async.fastcs.jungfrau._signals import JungfrauDriverIO
+
+from dodal.log import LOGGER
+
+
+class JunfrauCommissioningWriter(DetectorWriter, StandardReadable):
+    """Implementation of the temporary filewriter used for Jungfrau commissioning on i24.
+
+    The PVs on this device are responsible for writing files of a specified name
+    to a specified path, marking itself as "ready to write", and having a counter of
+    frames written, which must be zero'd at the ophyd level
+    """
+
+    def __init__(
+        self,
+        prefix,
+        path_provider: AutoIncrementingPathProvider | StaticPathProvider,
+        name="",
+    ) -> None:
+        with self.add_children_as_readables():
+            self._path_info = path_provider
+            self.frame_counter = epics_signal_rw(int, f"{prefix}NumCaptured")
+            self.file_name = epics_signal_rw_rbv(str, f"{prefix}FileName")
+            self.file_path = epics_signal_rw_rbv(str, f"{prefix}FilePath")
+            self.writer_ready = epics_signal_r(int, f"{prefix}Ready_RBV")
+        super().__init__(name)
+
+    async def open(self, name: str, exposures_per_event: int = 1) -> dict[str, DataKey]:
+        self._exposures_per_event = exposures_per_event
+        _path_info = self._path_info()
+
+        # Commissioning Jungfrau plans allow you to override path, so check to see if file exists
+        requested_filepath = Path(_path_info.directory_path) / _path_info.filename
+        if requested_filepath.exists():
+            raise FileExistsError(
+                f"Jungfrau was requested to write to {requested_filepath}, but this file already exists!"
+            )
+
+        await asyncio.gather(
+            self.file_name.set(_path_info.filename),
+            self.file_path.set(str(_path_info.directory_path)),
+            self.frame_counter.set(0),
+        )
+        LOGGER.info(
+            f"Jungfrau writing to folder {_path_info.directory_path} with filename {_path_info.filename}"
+        )
+        await wait_for_value(self.writer_ready, 1, timeout=10)
+        return await self._describe()
+
+    async def _describe(self) -> dict[str, DataKey]:
+        # Dummy function, doesn't actually describe the dataset
+
+        return {
+            "data": DataKey(
+                source="Commissioning writer",
+                shape=[-1],
+                dtype="array",
+                dtype_numpy="<u2",
+                external="STREAM:",
+            )
+        }
+
+    async def observe_indices_written(
+        self, timeout: float
+    ) -> AsyncGenerator[int, None]:
+        timeout = timeout * 2  # This filewriter is slow
+        async for num_captured in observe_value(self.frame_counter, timeout):
+            yield num_captured // (self._exposures_per_event)
+
+    async def get_indices_written(self) -> int:
+        return await self.frame_counter.get_value() // self._exposures_per_event
+
+    def collect_stream_docs(
+        self, name: str, indices_written: int
+    ) -> AsyncIterator[StreamAsset]:
+        raise NotImplementedError()
+
+    async def close(self) -> None: ...
+
+
+class CommissioningJungfrau(
+    StandardDetector[JungfrauController, JunfrauCommissioningWriter]
+):
+    """Ophyd-async implementation of a Jungfrau 9M Detector, using a temporary
+    filewriter in place of Odin"""
+
+    def __init__(
+        self,
+        prefix: str,
+        writer_prefix: str,
+        path_provider: AutoIncrementingPathProvider | StaticPathProvider,
+        name="",
+    ):
+        self.drv = JungfrauDriverIO(prefix)
+        writer = JunfrauCommissioningWriter(writer_prefix, path_provider)
+        controller = JungfrauController(self.drv)
+        super().__init__(controller, writer, name=name)

dodal/devices/motors.py

@@ -70,13 +70,27 @@ class XYZThetaStage(XYZStage):
         x_infix: str = _X,
         y_infix: str = _Y,
         z_infix: str = _Z,
-        theta_infix: str = _Z,
+        theta_infix: str = "THETA",
     ) -> None:
         with self.add_children_as_readables():
             self.theta = Motor(prefix + theta_infix)
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
+class XYPhiStage(XYStage):
+    def __init__(
+        self,
+        prefix: str,
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        phi_infix: str = "PHI",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.phi = Motor(prefix + phi_infix)
+        super().__init__(prefix, name, x_infix, y_infix)
+
+
 class XYPitchStage(XYStage):
     def __init__(
         self,
@@ -91,6 +105,23 @@ class XYPitchStage(XYStage):
         super().__init__(prefix, name, x_infix, y_infix)
 
 
+class XYZPitchYawStage(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        pitch_infix="PITCH",
+        yaw_infix="YAW",
+    ):
+        with self.add_children_as_readables():
+            self.pitch = Motor(prefix + pitch_infix)
+            self.yaw = Motor(prefix + yaw_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class XYZPitchYawRollStage(XYZStage):
     def __init__(
         self,
@@ -136,6 +167,26 @@ class SixAxisGonio(XYZStage):
         )
 
 
+class SixAxisGonioKappaPhi(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        kappa_infix: str = "KAPPA",
+        phi_infix: str = "PHI",
+    ):
+        """Six-axis goniometer with a standard xyz stage and two axes of rotation:
+        kappa and phi.
+        """
+        with self.add_children_as_readables():
+            self.kappa = Motor(prefix + kappa_infix)
+            self.phi = Motor(prefix + phi_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class YZStage(Stage):
     def __init__(
         self, prefix: str, name: str = "", y_infix: str = _Y, z_infix: str = _Z

dodal/devices/slits.py

@@ -37,3 +37,21 @@ class Slits(MinimalSlits):
             self.x_centre = Motor(prefix + x_centre)
             self.y_centre = Motor(prefix + y_centre)
         super().__init__(prefix=prefix, x_gap=x_gap, y_gap=y_gap, name=name)
+
+
+class SlitsY(StandardReadable):
+    """
+    Representation of a 2-blade slits.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        y_gap: str = "Y:SIZE",
+        y_centre: str = "Y:CENTRE",
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables():
+            self.y_gap = Motor(prefix + y_gap)
+            self.y_centre = Motor(prefix + y_centre)
+        super().__init__(name=name)

dodal/devices/smargon.py

@@ -1,13 +1,9 @@
 import asyncio
-from collections.abc import Collection, Generator
-from dataclasses import dataclass
 from enum import Enum
 from math import isclose
 from typing import TypedDict, cast
 
-from bluesky import plan_stubs as bps
 from bluesky.protocols import Movable
-from bluesky.utils import Msg
 from ophyd_async.core import (
     AsyncStatus,
     Device,
@@ -66,40 +62,6 @@ class StubOffsets(Device):
             await self.to_robot_load.set(1)
 
 
-@dataclass
-class AxisLimit:
-    """Represents the minimum and maximum allowable values on an axis"""
-
-    min_value: float
-    max_value: float
-
-    def contains(self, pos: float):
-        """Determine if the specified value is within limits.
-
-        Args:
-            pos: the value to check
-
-        Returns:
-            True if the value does not exceed the limits
-        """
-        return self.min_value <= pos <= self.max_value
-
-
-@dataclass
-class XYZLimits:
-    """The limits of the smargon x, y, z axes."""
-
-    x: AxisLimit
-    y: AxisLimit
-    z: AxisLimit
-
-    def position_valid(self, pos: Collection[float]) -> bool:
-        return all(
-            axis_limits.contains(value)
-            for axis_limits, value in zip([self.x, self.y, self.z], pos, strict=False)
-        )
-
-
 class DeferMoves(StrictEnum):
     ON = "Defer On"
     OFF = "Defer Off"
@@ -144,24 +106,6 @@ class Smargon(XYZStage, Movable):
 
         super().__init__(prefix, name)
 
-    def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
-        """Obtain a plan stub that returns the smargon XYZ axis limits
-
-        Yields:
-            Bluesky messages
-
-        Returns:
-            the axis limits
-        """
-        limits = {}
-        for name, pv in [
-            (attr_name, getattr(self, attr_name)) for attr_name in ["x", "y", "z"]
-        ]:
-            min_value = yield from bps.rd(pv.low_limit_travel)
-            max_value = yield from bps.rd(pv.high_limit_travel)
-            limits[name] = AxisLimit(min_value, max_value)
-        return XYZLimits(**limits)
-
     @AsyncStatus.wrap
     async def set(self, value: CombinedMove):
         """This will move all motion together in a deferred move.

dodal/devices/temperture_controller/__init__.py

@@ -0,0 +1,3 @@
+from .lakeshore.lakeshore import Lakeshore, Lakeshore336, Lakeshore340
+
+__all__ = ["Lakeshore336", "Lakeshore340", "Lakeshore"]

dodal/devices/temperture_controller/lakeshore/lakeshore.py

@@ -0,0 +1,204 @@
+from asyncio import gather
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    SignalDatatypeT,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+    derived_signal_rw,
+    soft_signal_rw,
+)
+
+from .lakeshore_io import (
+    LakeshoreBaseIO,
+)
+
+
+class Heater336Settings(StrictEnum):
+    OFF = "Off"
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+
+
+class Lakeshore(LakeshoreBaseIO, StandardReadable, Movable[float]):
+    """
+    Device for controlling and reading from a Lakeshore temperature controller.
+    It supports multiple channels and PID control.
+
+    Attributes
+    ----------
+    temperature : LakeshoreBaseIO
+        Temperature IO interface.
+    PID : PIDBaseIO
+        PID IO interface.
+    control_channel : derived_signal_rw
+        Signal for selecting the control channel,
+        optional readback as hinted signal
+        (default readback channel is the same as control channel).
+
+    temperature_high_limit: soft_signal_rw
+        Signal to store the soft high temperature limit.
+    temperature_low_limit: soft_signal_rw
+        Signal to store the soft low temperature limit.
+
+
+    Methods
+    -------
+    set(value: float)
+        Set the temperature setpoint for the selected control channel.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        num_readback_channel: int,
+        heater_setting: type[SignalDatatypeT],
+        control_channel: int = 1,
+        single_control_channel: bool = False,
+        name: str = "",
+    ):
+        """
+        Parameters
+        ----------
+        prefix : str
+            The EPICS prefix for the device.
+        no_channels : int
+            Number of temperature channels.
+        heater_setting : type[SignalDatatypeT]
+            Enum type for heater settings.
+        control_channel : int, optional
+            The initial control channel (default is 1).
+        single_control_channel : bool, optional
+            Whether to use a single control channel (default is False).
+        name : str, optional
+            Name of the device.
+        """
+        self._control_channel = soft_signal_rw(int, initial_value=control_channel)
+        self.temperature_high_limit = soft_signal_rw(float, initial_value=400)
+        self.temperature_low_limit = soft_signal_rw(float, initial_value=0)
+
+        self.control_channel = derived_signal_rw(
+            raw_to_derived=self._get_control_channel,
+            set_derived=self._set_control_channel,
+            current_channel=self._control_channel,
+        )
+        super().__init__(
+            prefix=prefix,
+            num_readback_channel=num_readback_channel,
+            heater_setting=heater_setting,
+            name=name,
+            single_control_channel=single_control_channel,
+        )
+
+        self.add_readables(
+            [setpoint.user_setpoint for setpoint in self.control_channels.values()]
+        )
+        self.add_readables(
+            list(self.readback.values()), format=StandardReadableFormat.HINTED_SIGNAL
+        )
+
+        self.add_readables(
+            [
+                self._control_channel,
+                self.control_channels[control_channel].p,
+                self.control_channels[control_channel].i,
+                self.control_channels[control_channel].d,
+                self.control_channels[control_channel].heater_output_range,
+            ],
+            StandardReadableFormat.CONFIG_SIGNAL,
+        )
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        """
+        Set the temperature setpoint for the active control channel.
+        """
+        high, low = await gather(
+            self.temperature_high_limit.get_value(),
+            self.temperature_low_limit.get_value(),
+        )
+        if high >= value >= low:
+            await self.control_channels[
+                await self.control_channel.get_value()
+            ].user_setpoint.set(value)
+        else:
+            raise ValueError(
+                f"{self.name} requested temperature {value} is outside limits: {low}, {high}"
+            )
+
+    def _get_control_channel(self, current_channel: int) -> int:
+        return current_channel
+
+    async def _set_control_channel(self, value: int) -> None:
+        if value < 1 or value > len(self.control_channels):
+            raise ValueError(
+                f"Control channel must be between 1 and {len(self.control_channels)}."
+            )
+        await self._control_channel.set(value)
+        self._read_config_funcs = (
+            self._control_channel.read,
+            self.control_channels[value].user_setpoint.read,
+            self.control_channels[value].p.read,
+            self.control_channels[value].i.read,
+            self.control_channels[value].d.read,
+            self.control_channels[value].heater_output_range.read,
+        )
+
+
+class Lakeshore336(Lakeshore):
+    def __init__(
+        self,
+        prefix: str,
+        control_channel: int = 1,
+        name: str = "",
+    ):
+        """
+        Lakeshore 336 temperature controller. With 4 readback and control channels.
+        Heater settings are: Off, Low, Medium, High.
+        Parameters
+        ----------
+        prefix : str
+            The EPICS prefix for the device.
+        control_channel : int, optional
+            The initial control channel (default is 1).
+        """
+        super().__init__(
+            prefix=prefix,
+            num_readback_channel=4,
+            heater_setting=Heater336Settings,
+            control_channel=control_channel,
+            single_control_channel=False,
+            name=name,
+        )
+
+
+class Lakeshore340(Lakeshore):
+    def __init__(
+        self,
+        prefix: str,
+        control_channel: int = 1,
+        name: str = "",
+    ):
+        """Lakeshore 340 temperature controller. With 4 readback channels and a single
+        control channel.
+        Heater settings are in power from 0 to 5. 0 is 0 watt, 5 is 50 watt.
+
+        Parameters
+        ----------
+        prefix : str
+            The EPICS prefix for the device.
+        control_channel : int, optional
+            The initial control channel (default is 1).
+        """
+
+        super().__init__(
+            prefix=prefix,
+            num_readback_channel=4,
+            heater_setting=float,
+            control_channel=control_channel,
+            single_control_channel=True,
+            name=name,
+        )