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

dodal/devices/attenuator/filter_selections.py

@@ -0,0 +1,72 @@
+from ophyd_async.core import SubsetEnum
+
+
+class P99FilterSelections(SubsetEnum):
+    EMPTY = "Empty"
+    MN5UM = "Mn 5um"
+    FE = "Fe (empty)"
+    CO5UM = "Co 5um"
+    NI5UM = "Ni 5um"
+    CU5UM = "Cu 5um"
+    ZN5UM = "Zn 5um"
+    ZR = "Zr (empty)"
+    MO = "Mo (empty)"
+    RH = "Rh (empty)"
+    PD = "Pd (empty)"
+    AG = "Ag (empty)"
+    CD25UM = "Cd 25um"
+    W = "W (empty)"
+    PT = "Pt (empty)"
+    USER = "User"
+
+
+class I02_1FilterOneSelections(SubsetEnum):
+    EMPTY = "Empty"
+    AL8 = "Al8"
+    AL15 = "Al15"
+    AL25 = "Al25"
+    AL1000 = "Al1000"
+    TI50 = "Ti50"
+    TI100 = "Ti100"
+    TI200 = "Ti200"
+    TI400 = "Ti400"
+    TWO_TIMES_TI500 = "2xTi500"
+
+
+class I02_1FilterTwoSelections(SubsetEnum):
+    EMPTY = "Empty"
+    AL50 = "Al50"
+    AL100 = "Al100"
+    AL125 = "Al125"
+    AL250 = "Al250"
+    AL500 = "Al500"
+    AL1000 = "Al1000"
+    TI50 = "Ti50"
+    TI100 = "Ti100"
+    TWO_TIMES_TI500 = "2xTi500"
+
+
+class I02_1FilterThreeSelections(SubsetEnum):
+    EMPTY = "Empty"
+    AL15 = "Al15"
+    AL25 = "Al25"
+    AL50 = "Al50"
+    AL100 = "Al100"
+    AL250 = "Al250"
+    AL1000 = "Al1000"
+    TI50 = "Ti50"
+    TI100 = "Ti100"
+    TI200 = "Ti200"
+
+
+class I02_1FilterFourSelections(SubsetEnum):
+    EMPTY = "Empty"
+    AL15 = "Al15"
+    AL25 = "Al25"
+    AL50 = "Al50"
+    AL100 = "Al100"
+    AL250 = "Al250"
+    AL500 = "Al500"
+    TI300 = "Ti300"
+    TI400 = "Ti400"
+    TI500 = "Ti500"

dodal/devices/bimorph_mirror.py

@@ -0,0 +1,151 @@
+import asyncio
+from collections.abc import Mapping
+from typing import Annotated as A
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    DEFAULT_TIMEOUT,
+    AsyncStatus,
+    DeviceVector,
+    SignalR,
+    SignalRW,
+    SignalW,
+    StandardReadable,
+    StrictEnum,
+    wait_for_value,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.epics.core import (
+    EpicsDevice,
+    PvSuffix,
+    epics_signal_r,
+    epics_signal_w,
+    epics_signal_x,
+)
+
+
+class BimorphMirrorOnOff(StrictEnum):
+    ON = "ON"
+    OFF = "OFF"
+
+
+class BimorphMirrorMode(StrictEnum):
+    HI = "HI"
+    NORMAL = "NORMAL"
+    FAST = "FAST"
+
+
+class BimorphMirrorStatus(StrictEnum):
+    IDLE = "Idle"
+    BUSY = "Busy"
+    ERROR = "Error"
+
+
+class BimorphMirrorChannel(StandardReadable, Movable, EpicsDevice):
+    """Collection of PVs comprising a single bimorph channel.
+
+    Attributes:
+        target_voltage: Float RW_RBV for target voltage, which can be set using parent mirror's all target proc
+        output_voltage: Float RW_RBV for current voltage on bimorph
+        status: BimorphMirrorOnOff readable for ON/OFF status of channel
+        shift: Float writeable shifting channel voltage
+    """
+
+    target_voltage: A[SignalRW[float], PvSuffix.rbv("VTRGT"), Format.CONFIG_SIGNAL]
+    output_voltage: A[SignalRW[float], PvSuffix.rbv("VOUT"), Format.HINTED_SIGNAL]
+    status: A[SignalR[BimorphMirrorOnOff], PvSuffix("STATUS"), Format.CONFIG_SIGNAL]
+    shift: A[SignalW[float], PvSuffix("SHIFT")]
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """Sets channel's VOUT to given value.
+
+        Args:
+            value: float to set VOUT to
+        """
+        await self.output_voltage.set(value)
+
+
+class BimorphMirror(StandardReadable, Movable):
+    """Class to represent CAENels Bimorph Mirrors.
+
+    Attributes:
+        channels: DeviceVector of BimorphMirrorChannel, indexed from 1, for each channel
+        enabled: Writeable BimorphOnOff
+        commit_target_voltages: Procable signal that writes values in each channel's VTRGT to VOUT
+        status: Readable BimorphMirrorStatus Busy/Idle status
+        err: Alarm status"""
+
+    def __init__(self, prefix: str, number_of_channels: int, name=""):
+        """
+        Args:
+            prefix: str PV prefix
+            number_of_channels: int number of channels on bimorph mirror (can be zero)
+            name: str name of device
+
+        Raises:
+            ValueError: number_of_channels is less than zero"""
+
+        if number_of_channels < 0:
+            raise ValueError(f"Number of channels is below zero: {number_of_channels}")
+
+        with self.add_children_as_readables():
+            self.channels = DeviceVector(
+                {
+                    i: BimorphMirrorChannel(f"{prefix}C{i}:")
+                    for i in range(1, number_of_channels + 1)
+                }
+            )
+        self.enabled = epics_signal_w(BimorphMirrorOnOff, f"{prefix}ONOFF")
+        self.commit_target_voltages = epics_signal_x(f"{prefix}ALLTRGT.PROC")
+        self.status = epics_signal_r(BimorphMirrorStatus, f"{prefix}STATUS")
+        self.err = epics_signal_r(str, f"{prefix}ERR")
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: Mapping[int, float], tolerance: float = 0.0001) -> None:
+        """Sets bimorph voltages in parrallel via target voltage and all proc.
+
+        Args:
+            value: Dict of channel numbers to target voltages
+
+        Raises:
+            ValueError: On set to non-existent channel"""
+
+        if any(key not in self.channels for key in value):
+            raise ValueError(
+                f"Attempting to put to non-existent channels: {[key for key in value if (key not in self.channels)]}"
+            )
+
+        # Write target voltages:
+        await asyncio.gather(
+            *[
+                self.channels[i].target_voltage.set(target, wait=True)
+                for i, target in value.items()
+            ]
+        )
+
+        # Trigger set target voltages:
+        await self.commit_target_voltages.trigger()
+
+        # Wait for values to propogate to voltage out rbv:
+        await asyncio.gather(
+            *[
+                wait_for_value(
+                    self.channels[i].output_voltage,
+                    tolerance_func_builder(tolerance, target),
+                    timeout=DEFAULT_TIMEOUT,
+                )
+                for i, target in value.items()
+            ],
+            wait_for_value(
+                self.status, BimorphMirrorStatus.IDLE, timeout=DEFAULT_TIMEOUT
+            ),
+        )
+
+
+def tolerance_func_builder(tolerance: float, target_value: float):
+    def is_within_value(x):
+        return abs(x - target_value) <= tolerance
+
+    return is_within_value

dodal/devices/current_amplifiers/__init__.py

@@ -0,0 +1,34 @@
+from .current_amplifier import CurrentAmp
+from .current_amplifier_detector import CurrentAmpCounter, CurrentAmpDet
+from .femto import (
+    Femto3xxGainTable,
+    Femto3xxGainToCurrentTable,
+    Femto3xxRaiseTime,
+    FemtoDDPCA,
+)
+from .sr570 import (
+    SR570,
+    SR570FineGainTable,
+    SR570FullGainTable,
+    SR570GainTable,
+    SR570GainToCurrentTable,
+    SR570RaiseTimeTable,
+)
+from .struck_scaler_counter import StruckScaler
+
+__all__ = [
+    "FemtoDDPCA",
+    "Femto3xxGainTable",
+    "Femto3xxRaiseTime",
+    "CurrentAmp",
+    "Femto3xxGainToCurrentTable",
+    "CurrentAmpCounter",
+    "CurrentAmpDet",
+    "SR570",
+    "SR570GainTable",
+    "SR570FineGainTable",
+    "SR570FullGainTable",
+    "SR570GainToCurrentTable",
+    "SR570RaiseTimeTable",
+    "StruckScaler",
+]

dodal/devices/current_amplifiers/current_amplifier.py

@@ -0,0 +1,103 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+from bluesky.protocols import (
+    Movable,
+    Preparable,
+)
+from ophyd_async.core import AsyncStatus, StandardReadable
+
+
+class CurrentAmp(ABC, StandardReadable, Movable):
+    """
+    Base class for current amplifier, it contains the minimal functionality
+     a current amplifier needs:
+
+    Attributes:
+        gain_conversion_table (Enum): The conversion table between current
+        and gain setting.
+    """
+
+    def __init__(self, gain_conversion_table: type[Enum], name: str = "") -> None:
+        self.gain_conversion_table = gain_conversion_table
+        super().__init__(name)
+
+    @abstractmethod
+    @AsyncStatus.wrap
+    async def increase_gain(self, value: int = 1) -> None:
+        """Increase gain, increment by 1 by default.
+
+        Returns:
+            bool: True if success.
+        """
+
+    @AsyncStatus.wrap
+    @abstractmethod
+    async def decrease_gain(self, value: int = 1) -> None:
+        """Decrease gain, decrement by 1 by default.
+
+        Returns:
+            bool: True if success.
+        """
+
+    @AsyncStatus.wrap
+    @abstractmethod
+    async def get_gain(self) -> type[Enum]:
+        """Get the current gain setting
+
+        Returns:
+            Enum: The member name of the current gain setting in gain_conversion_table.
+        """
+
+    @AsyncStatus.wrap
+    @abstractmethod
+    async def get_upperlimit(self) -> float:
+        """Get the upper limit of the current amplifier"""
+
+    @AsyncStatus.wrap
+    @abstractmethod
+    async def get_lowerlimit(self) -> float:
+        """Get the lower limit of the current amplifier"""
+
+
+class CurrentAmpCounter(ABC, StandardReadable, Preparable):
+    """
+    Base class for current amplifier counter, it contain the minimal implementations
+      required for a counter/detector to function with CurrentAmpDet:
+
+    Attributes:
+        count_per_volt (float): The conversion factor between counter output and voltage.
+    """
+
+    def __init__(self, count_per_volt: float, name: str = ""):
+        self.count_per_volt = count_per_volt
+        super().__init__(name)
+
+    @abstractmethod
+    async def get_count(self) -> float:
+        """ "Get count
+
+        Returns:
+            float: Current count
+        """
+
+    @abstractmethod
+    async def get_count_per_sec(self) -> float:
+        """Get count per second
+
+        Returns:
+            float: Current count per second
+        """
+
+    @abstractmethod
+    async def get_voltage_per_sec(self) -> float:
+        """Get count per second in voltage
+
+        Returns:
+            float: Current count in volt per second
+        """
+
+    @abstractmethod
+    @AsyncStatus.wrap
+    async def prepare(self, value: float) -> None:
+        """Prepare method for setting up the counter"""

dodal/devices/current_amplifiers/current_amplifier_detector.py

@@ -0,0 +1,109 @@
+import asyncio
+
+from bluesky.protocols import Preparable, Reading
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+
+from dodal.devices.current_amplifiers.current_amplifier import (
+    CurrentAmp,
+    CurrentAmpCounter,
+)
+from dodal.log import LOGGER
+
+
+class CurrentAmpDet(StandardReadable, Preparable):
+    """
+    CurrentAmpDet composed of a CurrentAmp and a CurrentAmpCounter. It provides
+      the option for automatically changing the CurrentAmp gain to within the optimal
+      range. It also converts the currentAmp/counter output back into the detector
+      current output in Amp.
+    Attributes:
+        current_amp (currentAmp): Current amplifier type device.
+        counter (CurrentAmpCounter): Counter that capture the current amplifier output.
+        current (SignalRW([float]): Soft signal to store the corrected current.
+        auto_mode (signalR([bool])): Soft signal to store the flag for auto gain.
+        name (str): Name of the device.
+    """
+
+    def __init__(
+        self,
+        current_amp: CurrentAmp,
+        counter: CurrentAmpCounter,
+        name: str = "",
+    ) -> None:
+        self.current_amp = Reference(current_amp)
+        self.counter = Reference(counter)
+        with self.add_children_as_readables():
+            self.current, self._set_current = soft_signal_r_and_setter(
+                float, initial_value=None, units="Amp"
+            )
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.auto_mode = soft_signal_rw(bool, initial_value=True)
+        super().__init__(name)
+
+    async def read(self) -> dict[str, Reading]:
+        """
+        Read is modified so that if auto_mode is true it will optimise gain before
+         taking the final reading
+        """
+        if await self.auto_mode.get_value():
+            LOGGER.info(f"{self.name}-Attempting auto-gain")
+            status = self.auto_gain()
+            try:
+                await status
+                LOGGER.info(
+                    f"{self.name} new gain = {await self.current_amp().get_gain()}."
+                )
+            except ValueError as ex:
+                LOGGER.warning(f"{self.name} gain went outside limits")
+                # Further details are provided to the user in the logged exception
+                LOGGER.exception(ex)
+        current = await self.get_corrected_current()
+        self._set_current(current)
+        return await super().read()
+
+    @AsyncStatus.wrap
+    async def auto_gain(self) -> None:
+        within_limits = False
+        while not within_limits:
+            reading = abs(await self.counter().get_voltage_per_sec())
+            upper_limit, lower_limit = await asyncio.gather(
+                self.current_amp().get_upperlimit(),
+                self.current_amp().get_lowerlimit(),
+            )
+            if reading > upper_limit:
+                await self.current_amp().decrease_gain()
+            elif reading < lower_limit:
+                await self.current_amp().increase_gain()
+            else:
+                within_limits = True
+
+    async def get_corrected_current(self) -> float:
+        """
+        Convert the output(count and gain) back into the read detector output in Amp.
+        """
+        current_gain, voltage_per_sec = await asyncio.gather(
+            self.current_amp().get_gain(),
+            self.counter().get_voltage_per_sec(),
+        )
+        correction_factor = current_gain.value
+        corrected_current = voltage_per_sec / correction_factor
+        return corrected_current
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        await self.counter().stage()
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        await self.counter().unstage()
+
+    @AsyncStatus.wrap
+    async def prepare(self, value) -> None:
+        await self.counter().prepare(value=value)

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