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

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,
+        )

dodal/devices/temperture_controller/lakeshore/lakeshore_io.py

@@ -0,0 +1,112 @@
+from ophyd_async.core import Device, DeviceVector, SignalDatatypeT
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+
+class LakeshoreControlChannel(Device):
+    """
+    Single control channel for a Lakeshore temperature controller.
+
+    Provides access to setpoint, ramp rate, ramp enable, heater output, heater output range,
+    PID parameters (P, I, D), and manual output for the channel.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix: str,
+        heater_type: type[SignalDatatypeT],
+        name: str = "",
+    ):
+        """Initialize the LakeshoreControlChannel device.
+        Parameters
+        ----------
+            prefix: str
+                The EPICS prefix for the Lakeshore device.
+            suffix: str
+                Suffix for the channel, used to differentiate multiple channels.
+            heater_type: SignalDatatypeT
+                Type of the heater output range.
+            name: str
+                Optional name for the device.
+        """
+
+        def channel_rw(channel_type, pv_name):
+            return epics_signal_rw(
+                channel_type,
+                f"{prefix}{pv_name}{suffix}",
+                f"{prefix}{pv_name}_S{suffix}",
+            )
+
+        self.user_setpoint = channel_rw(channel_type=float, pv_name="SETP")
+        self.ramp_rate = channel_rw(channel_type=float, pv_name="RAMP")
+        self.ramp_enable = channel_rw(channel_type=int, pv_name="RAMPST")
+        self.heater_output_range = channel_rw(channel_type=heater_type, pv_name="RANGE")
+        self.p = channel_rw(channel_type=float, pv_name="P")
+        self.i = channel_rw(channel_type=float, pv_name="I")
+        self.d = channel_rw(channel_type=float, pv_name="D")
+        self.manual_output = channel_rw(channel_type=float, pv_name="MOUT")
+        self.heater_output = epics_signal_r(float, f"{prefix}{'HTR'}{suffix}")
+
+        super().__init__(name=name)
+
+
+class LakeshoreBaseIO(Device):
+    """Base class for Lakeshore temperature controller IO.
+
+    Provides access to control channels and readback channels for setpoint, ramp rate, heater output,
+    and PID parameters. Supports both single and multiple control channel configurations.
+    Note:
+        Almost all models have a controller for each readback channel but some models
+            only has a single controller for multiple readback channels.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        num_readback_channel: int,
+        heater_setting: type[SignalDatatypeT],
+        name: str = "",
+        single_control_channel: bool = False,
+    ):
+        """Initialize the LakeshoreBaseIO device.
+
+        Parameters
+        -----------
+            prefix: str
+                The EPICS prefix for the Lakeshore device.
+            num_readback_channel: int
+                Number of readback channels to create.
+            heater_setting: SignalDatatypeT
+                Type of the heater setting.
+            name: str
+                Optional name for the device.
+            single_control_channel: bool
+                If True, use a single control channel for all readback.
+        """
+
+        suffixes = (
+            [""]
+            if single_control_channel
+            else map(str, range(1, num_readback_channel + 1))
+        )
+        self.control_channels = DeviceVector(
+            {
+                i: LakeshoreControlChannel(
+                    prefix=prefix, suffix=suffix, heater_type=heater_setting
+                )
+                for i, suffix in enumerate(suffixes, start=1)
+            }
+        )
+
+        self.readback = DeviceVector(
+            {
+                i: epics_signal_r(
+                    float,
+                    read_pv=f"{prefix}KRDG{i - 1}",
+                )
+                for i in range(1, num_readback_channel + 1)
+            }
+        )
+        super().__init__(
+            name=name,
+        )

dodal/devices/tetramm.py

@@ -16,6 +16,7 @@ from ophyd_async.core import (
     TriggerInfo,
     set_and_wait_for_value,
     soft_signal_r_and_setter,
+    wait_for_value,
 )
 from ophyd_async.epics.adcore import (
     ADHDFWriter,
@@ -23,7 +24,7 @@ from ophyd_async.epics.adcore import (
     NDFileHDFIO,
     NDPluginBaseIO,
 )
-from ophyd_async.epics.core import PvSuffix, stop_busy_record
+from ophyd_async.epics.core import PvSuffix, epics_signal_r
 
 
 class TetrammRange(StrictEnum):
@@ -77,6 +78,7 @@ class TetrammController(DetectorController):
     _supported_trigger_types = {
         DetectorTrigger.EDGE_TRIGGER: TetrammTrigger.EXT_TRIGGER,
         DetectorTrigger.CONSTANT_GATE: TetrammTrigger.EXT_TRIGGER,
+        DetectorTrigger.VARIABLE_GATE: TetrammTrigger.EXT_TRIGGER,
     }
     """"On the TetrAMM ASCII mode requires a minimum value of ValuesPerRead of 500,
     [...] binary mode the minimum value of ValuesPerRead is 5."
@@ -86,11 +88,9 @@ class TetrammController(DetectorController):
     """The TetrAMM always digitizes at 100 kHz"""
     _base_sample_rate: int = 100_000
 
-    def __init__(
-        self,
-        driver: TetrammDriver,
-    ) -> None:
+    def __init__(self, driver: TetrammDriver, file_io: NDFileHDFIO) -> None:
         self.driver = driver
+        self._file_io = file_io
         self._arm_status: AsyncStatus | None = None
 
     def get_deadtime(self, exposure: float | None) -> float:
@@ -107,13 +107,19 @@ class TetrammController(DetectorController):
         if trigger_info.livetime is None:
             raise ValueError(f"{self.__class__.__name__} requires that livetime is set")
 
+        current_trig_status = await self.driver.trigger_mode.get_value()
+
+        if current_trig_status == TetrammTrigger.FREE_RUN:  # if freerun turn off first
+            await self.disarm()
+
         # trigger mode must be set first and on its own!
         await self.driver.trigger_mode.set(
             self._supported_trigger_types[trigger_info.trigger]
         )
+
         await asyncio.gather(
-            self.driver.averaging_time.set(trigger_info.livetime),
             self.set_exposure(trigger_info.livetime),
+            self._file_io.num_capture.set(trigger_info.total_number_of_exposures),
         )
 
         # raise an error if asked to trigger faster than the max.
@@ -133,14 +139,18 @@ class TetrammController(DetectorController):
         self._arm_status = await self.start_acquiring_driver_and_ensure_status()
 
     async def wait_for_idle(self):
-        if self._arm_status and not self._arm_status.done:
-            await self._arm_status
-        self._arm_status = None
+        # tetramm never goes idle really, actually it is always acquiring
+        # so need to wait for the capture to finish instead
+        await wait_for_value(self._file_io.acquire, False, timeout=None)
+
+    async def unstage(self):
+        await self.disarm()
+        await self._file_io.acquire.set(False)
 
     async def disarm(self):
         # We can't use caput callback as we already used it in arm() and we can't have
         # 2 or they will deadlock
-        await stop_busy_record(self.driver.acquire, False, timeout=1)
+        await set_and_wait_for_value(self.driver.acquire, False, timeout=1)
 
     async def set_exposure(self, exposure: float) -> None:
         """Set the exposure time and acquire period.
@@ -164,7 +174,9 @@ class TetrammController(DetectorController):
                 "Tetramm exposure time must be at least "
                 f"{minimum_samples * sample_time}s, asked to set it to {exposure}s"
             )
-        await self.driver.averaging_time.set(samples_per_reading * sample_time)
+        await self.driver.averaging_time.set(
+            samples_per_reading * sample_time
+        )  # correct
 
     async def start_acquiring_driver_and_ensure_status(self) -> AsyncStatus:
         """Start acquiring driver, raising ValueError if the detector is in a bad state.
@@ -202,10 +214,7 @@ class TetrammDatasetDescriber(DatasetDescriber):
     async def shape(self) -> tuple[int, int]:
         return (
             int(await self._driver.num_channels.get_value()),
-            int(
-                await self._driver.averaging_time.get_value()
-                / await self._driver.sample_time.get_value(),
-            ),
+            int(await self._driver.to_average.get_value()),
         )
 
 
@@ -223,7 +232,20 @@ class TetrammDetector(StandardDetector):
     ):
         self.driver = TetrammDriver(prefix + drv_suffix)
         self.file_io = NDFileHDFIO(prefix + fileio_suffix)
-        controller = TetrammController(self.driver)
+        controller = TetrammController(self.driver, self.file_io)
+
+        self.current1 = epics_signal_r(float, prefix + "Cur1:MeanValue_RBV")
+        self.current2 = epics_signal_r(float, prefix + "Cur2:MeanValue_RBV")
+        self.current3 = epics_signal_r(float, prefix + "Cur3:MeanValue_RBV")
+        self.current4 = epics_signal_r(float, prefix + "Cur4:MeanValue_RBV")
+
+        self.sum_x = epics_signal_r(float, prefix + "SumX:MeanValue_RBV")
+        self.sum_y = epics_signal_r(float, prefix + "SumY:MeanValue_RBV")
+        self.sum_all = epics_signal_r(float, prefix + "SumAll:MeanValue_RBV")
+        self.diff_x = epics_signal_r(float, prefix + "DiffX:MeanValue_RBV")
+        self.diff_y = epics_signal_r(float, prefix + "DiffY:MeanValue_RBV")
+        self.pos_x = epics_signal_r(float, prefix + "PosX:MeanValue_RBV")
+        self.pos_y = epics_signal_r(float, prefix + "PosY:MeanValue_RBV")
 
         writer = ADHDFWriter(
             fileio=self.file_io,

dodal/devices/v2f.py

@@ -0,0 +1,39 @@
+from ophyd_async.core import StandardReadable, StandardReadableFormat, StrictEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+
+class V2FGain(StrictEnum):
+    LOW_NOISE3 = "10^3 low noise"
+    LOW_NOISE4 = "10^4 low noise"
+    LOW_NOISE5 = "10^5 low noise"
+    LOW_NOISE6 = "10^6 low noise"
+    LOW_NOISE7 = "10^7 low noise"
+    LOW_NOISE8 = "10^8 low noise"
+    LOW_NOISE9 = "10^9 low noise"
+    HIGHSPEED5 = "10^5 high speed"
+    HIGHSPEED6 = "10^6 high speed"
+    HIGHSPEED7 = "10^7 high speed"
+    HIGHSPEED8 = "10^8 high speed"
+    HIGHSPEED9 = "10^9 high speed"
+    HIGHSPEED10 = "10^10 high spd"
+    HIGHSPEED11 = "10^11 high spd"
+
+
+class QDV2F(StandardReadable):
+    """
+    A Quantum Detectors V2F low noise voltage to frequency converter.
+    Two channel V2F - 50mHz
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        I_suffix="I",
+    ) -> None:
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.intensity = epics_signal_r(float, f"{prefix}{I_suffix}")
+        with self.add_children_as_readables():
+            self.gain = epics_signal_rw(V2FGain, f"{prefix}GAIN")
+
+        super().__init__(name)

dodal/devices/zebra/zebra.py

@@ -82,6 +82,7 @@ class ArmDemand(Enum):
     DISARM = 0
 
 
+# Replace with ophyd-async enum after https://github.com/bluesky/ophyd-async/pull/1067
 class SoftInState(StrictEnum):
     YES = "Yes"
     NO = "No"

dodal/devices/zebra/zebra_constants_mapping.py

@@ -77,7 +77,7 @@ class ZebraMapping(ZebraMappingValidations):
     Zebra's hardware configuration and wiring.
     """
 
-    # Zebra ophyd signal for connection can be accessed
+    # Zebra ophyd signal for output can be accessed
     # with, eg, zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR]
     outputs: ZebraTTLOutputs = ZebraTTLOutputs()
 

dodal/parameters/experiment_parameter_base.py

@@ -1,4 +1,4 @@
-from abc import ABC, abstractmethod
+from abc import ABC
 
 from pydantic import BaseModel
 
@@ -9,7 +9,3 @@ class AbstractExperimentParameterBase(BaseModel, ABC):
 
 class AbstractExperimentWithBeamParams(AbstractExperimentParameterBase):
     transmission_fraction: float
-
-    @abstractmethod
-    def get_num_images(self) -> int:
-        pass