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

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"
+    HIGH_SPEED5 = "10^5 high speed"
+    HIGH_SPEED6 = "10^6 high speed"
+    HIGH_SPEED7 = "10^7 high speed"
+    HIGH_SPEED8 = "10^8 high speed"
+    HIGH_SPEED9 = "10^9 high speed"
+    HIGH_SPEED10 = "10^10 high spd"
+    HIGH_SPEED11 = "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