dls-dodal 1.36.3__py3-none-any.whl → 1.38.0__py3-none-any.whl

dodal/devices/current_amplifiers/femto.py

@@ -0,0 +1,143 @@
+import asyncio
+from enum import Enum
+
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.current_amplifiers import CurrentAmp
+from dodal.log import LOGGER
+
+
+class Femto3xxGainTable(StrictEnum):
+    """These are the sensitivity setting for Femto 3xx current amplifier"""
+
+    SEN_1 = "10^4"
+    SEN_2 = "10^5"
+    SEN_3 = "10^6"
+    SEN_4 = "10^7"
+    SEN_5 = "10^8"
+    SEN_6 = "10^9"
+    SEN_7 = "10^10"
+    SEN_8 = "10^11"
+    SEN_9 = "10^12"
+    SEN_10 = "10^13"
+
+
+class Femto3xxGainToCurrentTable(float, Enum):
+    """These are the voltage to current setting for Femto 3xx current amplifier"""
+
+    SEN_1 = 1e4
+    SEN_2 = 1e5
+    SEN_3 = 1e6
+    SEN_4 = 1e7
+    SEN_5 = 1e8
+    SEN_6 = 1e9
+    SEN_7 = 1e10
+    SEN_8 = 1e11
+    SEN_9 = 1e12
+    SEN_10 = 1e13
+
+
+class Femto3xxRaiseTime(float, Enum):
+    """These are the gain dependent raise time(s) for Femto 3xx current amplifier"""
+
+    SEN_1 = 0.8e-3
+    SEN_2 = 0.8e-3
+    SEN_3 = 0.8e-3
+    SEN_4 = 0.8e-3
+    SEN_5 = 2.3e-3
+    SEN_6 = 2.3e-3
+    SEN_7 = 17e-3
+    SEN_8 = 17e-3
+    SEN_9 = 350e-3
+    SEN_10 = 350e-3
+
+
+class FemtoDDPCA(CurrentAmp):
+    """
+    Femto current amplifier device, this class should cover all DDPCA Femto current
+      amplifiers, As the main different between all the DDPCA Femto is their gain table
+        and response time table.
+    Attributes:
+        gain (SignalRW): This is the epic signal that control current amplifier gain.
+        gain_table (strictEnum): The table epic use to set gain.
+        upperlimit (float): upperlimit of the current amplifier
+        lowerlimit (float): lowerlimit of the current amplifier
+        timeout (float): Maximum waiting time in second for setting gain.
+        raise_timetable (Enum): Table contain the minimum amount of time to wait after
+         changing gain.
+
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix: str,
+        gain_table: type[StrictEnum],
+        gain_to_current_table: type[Enum],
+        raise_timetable: type[Enum],
+        upperlimit: float = 8.8,
+        lowerlimit: float = 0.68,
+        timeout: float = 1,
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.gain = epics_signal_rw(gain_table, prefix + suffix)
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.gain_table = gain_table
+            self.timeout = timeout
+            self.raise_timetable = raise_timetable
+        self.upperlimit = upperlimit
+        self.lowerlimit = lowerlimit
+        super().__init__(name=name, gain_conversion_table=gain_to_current_table)
+
+    @AsyncStatus.wrap
+    async def set(self, value) -> None:
+        if value not in [item.value for item in self.gain_conversion_table]:
+            raise ValueError(
+                f"Gain value {value} is not within {self.name} range."
+                + "\n Available gain:"
+                + f" {[f'{c.value:.0e}' for c in self.gain_conversion_table]}"
+            )
+        SEN_setting = self.gain_conversion_table(value).name
+        LOGGER.info(f"{self.name} gain change to {SEN_setting}:{value}")
+
+        await self.gain.set(
+            value=self.gain_table[SEN_setting].value,
+            timeout=self.timeout,
+        )
+        # wait for current amplifier's bandpass filter to settle.
+        await asyncio.sleep(self.raise_timetable[SEN_setting].value)
+
+    @AsyncStatus.wrap
+    async def increase_gain(self, value: int = 1) -> None:
+        current_gain = int((await self.get_gain()).name.split("_")[-1])
+        current_gain += value
+        if current_gain > len(self.gain_table):
+            raise ValueError("Gain at max value")
+        await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
+
+    @AsyncStatus.wrap
+    async def decrease_gain(self, value: int = 1) -> None:
+        current_gain = int((await self.get_gain()).name.split("_")[-1])
+        current_gain -= value
+        if current_gain < 1:
+            raise ValueError("Gain at min value")
+        await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
+
+    @AsyncStatus.wrap
+    async def get_gain(self) -> Enum:
+        return self.gain_conversion_table[(await self.gain.get_value()).name]
+
+    @AsyncStatus.wrap
+    async def get_upperlimit(self) -> float:
+        return self.upperlimit
+
+    @AsyncStatus.wrap
+    async def get_lowerlimit(self) -> float:
+        return self.lowerlimit

dodal/devices/current_amplifiers/sr570.py

@@ -0,0 +1,214 @@
+import asyncio
+from enum import Enum
+
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.current_amplifiers.current_amplifier import CurrentAmp
+from dodal.log import LOGGER
+
+
+class SR570GainTable(StrictEnum):
+    """Coarse/unit sensitivity setting for SR570 current amplifier"""
+
+    SEN_1 = "mA/V"
+    SEN_2 = "uA/V"
+    SEN_3 = "nA/V"
+    SEN_4 = "pA/V"
+
+
+class SR570FineGainTable(StrictEnum):
+    """Fine sensitivity setting for SR570 current amplifier"""
+
+    SEN_1 = "1"
+    SEN_2 = "2"
+    SEN_3 = "5"
+    SEN_4 = "10"
+    SEN_5 = "20"
+    SEN_6 = "50"
+    SEN_7 = "100"
+    SEN_8 = "200"
+    SEN_9 = "500"
+
+
+class SR570RaiseTimeTable(float, Enum):
+    """These are the gain dependent raise time(s) for SR570 current amplifier"""
+
+    SEN_1 = 1e-4
+    SEN_2 = 1e-2
+    SEN_3 = 0.15
+    SEN_4 = 0.2
+
+
+class SR570FullGainTable(Enum):
+    """Combined gain table, as each gain step is a combination of both coarse gain and
+    fine gain setting"""
+
+    SEN_1 = [SR570GainTable.SEN_1, SR570FineGainTable.SEN_1]
+    SEN_2 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_9]
+    SEN_3 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_8]
+    SEN_4 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_7]
+    SEN_5 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_6]
+    SEN_6 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_5]
+    SEN_7 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_4]
+    SEN_8 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_3]
+    SEN_9 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_2]
+    SEN_10 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_1]
+    SEN_11 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_9]
+    SEN_12 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_8]
+    SEN_13 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_7]
+    SEN_14 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_6]
+    SEN_15 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_5]
+    SEN_16 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_4]
+    SEN_17 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_3]
+    SEN_18 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_2]
+    SEN_19 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_1]
+    SEN_20 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_9]
+    SEN_21 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_8]
+    SEN_22 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_7]
+    SEN_23 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_6]
+    SEN_24 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_5]
+    SEN_25 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_4]
+    SEN_26 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_3]
+    SEN_27 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_2]
+    SEN_28 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_1]
+
+
+class SR570GainToCurrentTable(float, Enum):
+    """Conversion table for gain(sen) to current"""
+
+    SEN_1 = 1e3
+    SEN_2 = 2e3
+    SEN_3 = 5e3
+    SEN_4 = 1e4
+    SEN_5 = 2e4
+    SEN_6 = 5e4
+    SEN_7 = 1e5
+    SEN_8 = 2e5
+    SEN_9 = 5e5
+    SEN_10 = 1e6
+    SEN_11 = 2e6
+    SEN_12 = 5e6
+    SEN_13 = 1e7
+    SEN_14 = 2e7
+    SEN_15 = 5e7
+    SEN_16 = 1e8
+    SEN_17 = 2e8
+    SEN_18 = 5e8
+    SEN_19 = 1e9
+    SEN_20 = 2e9
+    SEN_21 = 5e9
+    SEN_22 = 1e10
+    SEN_23 = 2e10
+    SEN_24 = 5e10
+    SEN_25 = 1e11
+    SEN_26 = 2e11
+    SEN_27 = 5e11
+    SEN_28 = 1e12
+
+
+class SR570(CurrentAmp):
+    """
+    SR570 current amplifier device. This is similar to Femto with the only different
+     is SR570 has two gain setting fine and coarse, therefore it requires extra
+     gain tables.
+    Attributes:
+        fine_gain (SignalRW): This is the epic signal that control SR570 fine gain.
+        coarse_gain (SignalRW): This is the epic signal that control SR570 coarse gain.
+        fine_gain_table (strictEnum): The table that fine_gain use to set gain.
+        coarse_gain_table (strictEnum): The table that coarse_gain use to set gain.
+        timeout (float): Maximum waiting time in second for setting gain.
+        raise_timetable (Enum): Table contain the amount of time to wait after
+            setting gain.
+        combined_table (Enum): Table that combine fine and coarse table into one.
+        gain (SignalRW([str]): Soft signal to store the member name of the current gain
+            setting in gain_conversion_table.
+        upperlimit (float): upperlimit of the current amplifier
+        lowerlimit (float): lowerlimit of the current amplifier
+
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix: str,
+        fine_gain_table: type[StrictEnum],
+        coarse_gain_table: type[StrictEnum],
+        combined_table: type[Enum],
+        gain_to_current_table: type[Enum],
+        raise_timetable: type[Enum],
+        upperlimit: float = 4.8,
+        lowerlimit: float = 0.4,
+        timeout: float = 1,
+        name: str = "",
+    ) -> None:
+        super().__init__(name=name, gain_conversion_table=gain_to_current_table)
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.fine_gain = epics_signal_rw(fine_gain_table, prefix + suffix + "1")
+            self.coarse_gain = epics_signal_rw(coarse_gain_table, prefix + suffix + "2")
+
+        self.fine_gain_table = fine_gain_table
+        self.coarse_gain_table = coarse_gain_table
+        self.timeout = timeout
+        self.raise_timetable = raise_timetable
+        self.combined_table = combined_table
+        self.upperlimit = upperlimit
+        self.lowerlimit = lowerlimit
+
+    @AsyncStatus.wrap
+    async def set(self, value) -> None:
+        if value not in [item.value for item in self.gain_conversion_table]:
+            raise ValueError(
+                f"Gain value {value} is not within {self.name} range."
+                + "\n Available gain:"
+                + f" {[f'{c.value:.0e}' for c in self.gain_conversion_table]}"
+            )
+        SEN_setting = self.gain_conversion_table(value).name
+        LOGGER.info(f"{self.name} gain change to {value}")
+
+        coarse_gain, fine_gain = self.combined_table[SEN_setting].value
+        await asyncio.gather(
+            self.fine_gain.set(value=fine_gain, timeout=self.timeout),
+            self.coarse_gain.set(value=coarse_gain, timeout=self.timeout),
+        )
+        await asyncio.sleep(self.raise_timetable[coarse_gain.name].value)
+
+    @AsyncStatus.wrap
+    async def increase_gain(self, value=3) -> None:
+        current_gain = int((await self.get_gain()).name.split("_")[-1])
+        current_gain += value
+        if current_gain > len(self.combined_table):
+            await self.set(
+                self.gain_conversion_table[f"SEN_{len(self.combined_table)}"]
+            )
+            raise ValueError("Gain at max value")
+        await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
+
+    @AsyncStatus.wrap
+    async def decrease_gain(self, value=3) -> None:
+        current_gain = int((await self.get_gain()).name.split("_")[-1])
+        current_gain -= value
+        if current_gain < 1:
+            await self.set(self.gain_conversion_table["SEN_1"])
+            raise ValueError("Gain at min value")
+        await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
+
+    @AsyncStatus.wrap
+    async def get_gain(self) -> Enum:
+        result = await asyncio.gather(
+            self.coarse_gain.get_value(), self.fine_gain.get_value()
+        )
+        return self.gain_conversion_table[self.combined_table(result).name]
+
+    @AsyncStatus.wrap
+    async def get_upperlimit(self) -> float:
+        return self.upperlimit
+
+    @AsyncStatus.wrap
+    async def get_lowerlimit(self) -> float:
+        return self.lowerlimit

dodal/devices/current_amplifiers/struck_scaler_counter.py

@@ -0,0 +1,79 @@
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadableFormat,
+    StrictEnum,
+    set_and_wait_for_other_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.current_amplifiers import (
+    CurrentAmpCounter,
+)
+
+
+class CountMode(StrictEnum):
+    AUTO = "AutoCount"
+    ONE_SHOT = "OneShot"
+
+
+class CountState(StrictEnum):
+    DONE = "Done"
+    COUNT = "Count"  # type: ignore
+
+
+COUNT_PER_VOLTAGE = 100000
+
+
+class StruckScaler(CurrentAmpCounter):
+    """
+    StruckScaler is a counting card that record the output signal from a wide
+      range of detectors. This class contains the basic control to run the struckscaler
+      card together with a current amplifier. It has functions that provide conversion
+      between count and voltage.
+    Attributes:
+        readout(SignalR): Scaler card output.
+        count_mode (SignalR[CountMode]): Counting card setting.
+        count_time (SignalRW([float]): Count time.
+    """
+
+    def __init__(
+        self, prefix: str, suffix: str, count_per_volt=COUNT_PER_VOLTAGE, name: str = ""
+    ):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.readout = epics_signal_r(float, prefix + suffix)
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.count_mode = epics_signal_rw(CountMode, prefix + ":AutoCount")
+            self.count_time = epics_signal_rw(float, prefix + ".TP")
+        self.trigger_start = epics_signal_rw(CountState, prefix + ".CNT")
+        super().__init__(count_per_volt=count_per_volt, name=name)
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        await self.count_mode.set(CountMode.ONE_SHOT)
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        await self.count_mode.set(CountMode.AUTO)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        await set_and_wait_for_other_value(
+            set_signal=self.trigger_start,
+            set_value=CountState.COUNT,
+            match_signal=self.trigger_start,
+            match_value=CountState.COUNT,
+        )
+
+    @AsyncStatus.wrap
+    async def prepare(self, value) -> None:
+        await self.count_time.set(value)
+
+    async def get_count(self) -> float:
+        await self.trigger()
+        return await self.readout.get_value()
+
+    async def get_count_per_sec(self) -> float:
+        return await self.get_count() / await self.count_time.get_value()
+
+    async def get_voltage_per_sec(self) -> float:
+        return await self.get_count_per_sec() / self.count_per_volt

dodal/devices/detector/det_dim_constants.py

@@ -26,6 +26,21 @@ class DetectorSizeConstants:
         ALL_DETECTORS[self.det_type_string] = self
 
 
+PILATUS_TYPE_6M = "PILATUS_6M"
+PILATUS_6M_DIMENSION_X = 423.636
+PILATUS_6M_DIMENSION_Y = 434.644
+PILATUS_6M_DIMENSION = DetectorSize(PILATUS_6M_DIMENSION_X, PILATUS_6M_DIMENSION_Y)
+PIXELS_X_PILATUS_6M = 2463
+PIXELS_Y_PILATUS_6M = 2527
+PIXELS_PILATUS_6M = DetectorSize(PIXELS_X_PILATUS_6M, PIXELS_Y_PILATUS_6M)
+PILATUS_6M_SIZE = DetectorSizeConstants(
+    PILATUS_TYPE_6M,
+    PILATUS_6M_DIMENSION,
+    PIXELS_PILATUS_6M,
+    PILATUS_6M_DIMENSION,
+    PIXELS_PILATUS_6M,
+)
+
 EIGER_TYPE_EIGER2_X_4M = "EIGER2_X_4M"
 EIGER2_X_4M_DIMENSION_X = 155.1
 EIGER2_X_4M_DIMENSION_Y = 162.15

dodal/devices/eiger_odin.py

@@ -91,10 +91,10 @@ class OdinNodesStatus(Device):
     def wait_for_no_errors(self, timeout) -> dict[SubscriptionStatus, str]:
         errors = {}
         for node_number, node_pv in enumerate(self.nodes):
-            errors[
-                await_value(node_pv.error_status, False, timeout)
-            ] = f"Filewriter {node_number} is in an error state with error message\
+            errors[await_value(node_pv.error_status, False, timeout)] = (
+                f"Filewriter {node_number} is in an error state with error message\
                      - {node_pv.error_message.get()}"
+            )
 
         return errors
 

dodal/devices/fast_grid_scan.py

@@ -97,9 +97,14 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         """Converts a grid position, given as steps in the x, y, z grid,
         to a real motor position.
 
-        :param grid_position: The x, y, z position in grid steps
-        :return: The motor position this corresponds to.
-        :raises: IndexError if the desired position is outside the grid."""
+        Args:
+            grid_position: The x, y, z position in grid steps. The origin is at the
+                centre of the first grid box
+        Returns:
+            The motor position this corresponds to.
+        Raises:
+            IndexError if the desired position is outside the grid.
+        """
         for position, axis in zip(
             grid_position, [self.x_axis, self.y_axis, self.z_axis], strict=False
         ):

dodal/devices/flux.py

@@ -1,7 +1,14 @@
-from ophyd import Component, Device, EpicsSignalRO, Kind
+from ophyd_async.core import (
+    StandardReadable,
+    StandardReadableFormat,
+)
+from ophyd_async.epics.core import epics_signal_r
 
 
-class Flux(Device):
+class Flux(StandardReadable):
     """Simple device to get the flux reading"""
 
-    flux_reading = Component(EpicsSignalRO, "SAMP", kind=Kind.hinted)
+    def __init__(self, prefix: str, name="") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.flux_reading = epics_signal_r(float, prefix + "SAMP")
+            super().__init__(name=name)

dodal/devices/i03/beamstop.py

@@ -0,0 +1,85 @@
+from asyncio import gather
+from math import isclose
+
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.motor import Motor
+
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+
+
+class BeamstopPositions(StrictEnum):
+    """
+    Beamstop positions.
+    GDA supports Standard/High/Low resolution positions, as well as parked and
+    robot load however all 3 resolution positions are the same. We also
+    do not use the robot load position in Hyperion.
+
+    Until we support moving the beamstop it is only necessary to check whether the
+    beamstop is in beam or not.
+
+    See Also:
+        https://github.com/DiamondLightSource/mx-bluesky/issues/484
+
+    Attributes:
+        DATA_COLLECTION: The beamstop is in beam ready for data collection
+        UNKNOWN: The beamstop is in some other position, check the device motor
+            positions to determine it.
+    """
+
+    DATA_COLLECTION = "Data Collection"
+    UNKNOWN = "Unknown"
+
+
+class Beamstop(StandardReadable):
+    """
+    Beamstop for I03.
+
+    Attributes:
+        x: beamstop x position in mm
+        y: beamstop y position in mm
+        z: beamstop z position in mm
+        selected_pos: Get the current position of the beamstop as an enum. Currently this
+            is read-only.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        beamline_parameters: GDABeamlineParameters,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.x_mm = Motor(prefix + "X")
+            self.y_mm = Motor(prefix + "Y")
+            self.z_mm = Motor(prefix + "Z")
+            self.selected_pos = create_hardware_backed_soft_signal(
+                BeamstopPositions, self._get_selected_position
+            )
+
+        self._in_beam_xyz_mm = [
+            float(beamline_parameters[f"in_beam_{axis}_STANDARD"])
+            for axis in ("x", "y", "z")
+        ]
+        self._xyz_tolerance_mm = [
+            float(beamline_parameters[f"bs_{axis}_tolerance"])
+            for axis in ("x", "y", "z")
+        ]
+
+        super().__init__(name)
+
+    async def _get_selected_position(self) -> BeamstopPositions:
+        current_pos = await gather(
+            self.x_mm.user_readback.get_value(),
+            self.y_mm.user_readback.get_value(),
+            self.z_mm.user_readback.get_value(),
+        )
+        if all(
+            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
+            for axis_pos, axis_in_beam, axis_tolerance in zip(
+                current_pos, self._in_beam_xyz_mm, self._xyz_tolerance_mm, strict=False
+            )
+        ):
+            return BeamstopPositions.DATA_COLLECTION
+        else:
+            return BeamstopPositions.UNKNOWN