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

dodal/beamlines/p99.py

@@ -1,6 +1,8 @@
 from dodal.common.beamlines.beamline_utils import device_factory, set_beamline
+from dodal.devices.attenuator.filter import FilterMotor
+from dodal.devices.attenuator.filter_selections import P99FilterSelections
 from dodal.devices.motors import XYZPositioner
-from dodal.devices.p99.sample_stage import FilterMotor, SampleAngleStage
+from dodal.devices.p99.sample_stage import SampleAngleStage
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -17,7 +19,9 @@ def angle_stage() -> SampleAngleStage:
 
 @device_factory()
 def filter() -> FilterMotor:
-    return FilterMotor(f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:SELECT")
+    return FilterMotor(
+        f"{PREFIX.beamline_prefix}-MO-STAGE-02:MP:SELECT", P99FilterSelections
+    )
 
 
 @device_factory()

dodal/common/crystal_metadata.py

@@ -55,7 +55,7 @@ def make_crystal_metadata_from_material(
     d_spacing = d_spacing_param or CrystalMetadata.calculate_default_d_spacing(
         material.value.lattice_parameter, reflection_plane
     )
-    assert all(
-        isinstance(i, int) and i > 0 for i in reflection_plane
-    ), "Reflection plane indices must be positive integers"
+    assert all(isinstance(i, int) and i > 0 for i in reflection_plane), (
+        "Reflection plane indices must be positive integers"
+    )
     return CrystalMetadata(usage, material.value.name, reflection_plane, d_spacing)

dodal/common/udc_directory_provider.py

@@ -46,7 +46,9 @@ class PandASubpathProvider(UpdatingPathProvider):
         self._filename_provider.suffix = suffix
 
     def __call__(self, device_name: str | None = None) -> PathInfo:
-        assert self._output_directory, "Directory unknown for PandA to write into, update() needs to be called at least once"
+        assert self._output_directory, (
+            "Directory unknown for PandA to write into, update() needs to be called at least once"
+        )
         return PathInfo(
             directory_path=self._output_directory,
             filename=self._filename_provider(device_name),

dodal/devices/aperturescatterguard.py

@@ -87,6 +87,9 @@ class ApertureValue(StrictEnum):
     MEDIUM = "MEDIUM_APERTURE"
     LARGE = "LARGE_APERTURE"
 
+    def __str__(self):
+        return self.name.capitalize()
+
 
 def load_positions_from_beamline_parameters(
     params: GDABeamlineParameters,

dodal/devices/apple2_undulator.py

@@ -21,8 +21,8 @@ from dodal.log import LOGGER
 
 
 class UndulatorGateStatus(StrictEnum):
-    open = "Open"
-    close = "Closed"
+    OPEN = "Open"
+    CLOSE = "Closed"
 
 
 @dataclass
@@ -146,7 +146,7 @@ class UndulatorGap(StandardReadable, Movable):
         timeout = await self._cal_timeout()
         LOGGER.info(f"Moving {self.name} to {value} with timeout = {timeout}")
         await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.close, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     async def _cal_timeout(self) -> float:
         vel = await self.velocity.get_value()
@@ -157,7 +157,7 @@ class UndulatorGap(StandardReadable, Movable):
     async def check_id_status(self) -> None:
         if await self.fault.get_value() != 0:
             raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.open:
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
     async def get_timeout(self) -> float:
@@ -251,7 +251,7 @@ class UndulatorPhaseAxes(StandardReadable, Movable):
         )
         timeout = await self._cal_timeout()
         await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.close, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     async def _cal_timeout(self) -> float:
         """
@@ -283,7 +283,7 @@ class UndulatorPhaseAxes(StandardReadable, Movable):
     async def check_id_status(self) -> None:
         if await self.fault.get_value() != 0:
             raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.open:
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
     async def get_timeout(self) -> float:
@@ -325,7 +325,7 @@ class UndulatorJawPhase(StandardReadable, Movable):
         )
         timeout = await self._cal_timeout()
         await self.set_move.set(value=1, timeout=timeout)
-        await wait_for_value(self.gate, UndulatorGateStatus.close, timeout=timeout)
+        await wait_for_value(self.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
 
     async def _cal_timeout(self) -> float:
         """
@@ -345,7 +345,7 @@ class UndulatorJawPhase(StandardReadable, Movable):
     async def check_id_status(self) -> None:
         if await self.fault.get_value() != 0:
             raise RuntimeError(f"{self.name} is in fault state")
-        if await self.gate.get_value() == UndulatorGateStatus.open:
+        if await self.gate.get_value() == UndulatorGateStatus.OPEN:
             raise RuntimeError(f"{self.name} is already in motion.")
 
     async def get_timeout(self) -> float:
@@ -458,7 +458,7 @@ class Apple2(StandardReadable, Movable):
             self.phase().set_move.set(value=1, timeout=timeout),
         )
         await wait_for_value(
-            self.gap().gate, UndulatorGateStatus.close, timeout=timeout
+            self.gap().gate, UndulatorGateStatus.CLOSE, timeout=timeout
         )
         self._energy_set(energy)  # Update energy for after move for readback.
 

dodal/devices/{attenuator.py → attenuator/attenuator.py}

@@ -7,10 +7,12 @@ from ophyd_async.core import (
     DeviceVector,
     SignalR,
     StandardReadable,
+    SubsetEnum,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
 
+from dodal.devices.attenuator.filter import FilterMotor
 from dodal.log import LOGGER
 
 
@@ -27,8 +29,9 @@ class ReadOnlyAttenuator(StandardReadable):
         super().__init__(name)
 
 
-class Attenuator(ReadOnlyAttenuator, Movable):
+class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable):
     """The attenuator will insert filters into the beam to reduce its transmission.
+    In this attenuator, each filter can be in one of two states: IN or OUT
 
     This device should be set with:
         yield from bps.set(attenuator, desired_transmission)
@@ -83,3 +86,28 @@ class Attenuator(ReadOnlyAttenuator, Movable):
                 for i in range(16)
             ]
         )
+
+
+class EnumFilterAttenuator(ReadOnlyAttenuator):
+    """The attenuator will insert filters into the beam to reduce its transmission.
+
+    This device is currently working, but feature incomplete. See https://github.com/DiamondLightSource/dodal/issues/972
+
+    In this attenuator, the state of a filter corresponds to the selected material,
+    e.g Ag50, in contrast to being either 'IN' or 'OUT'; see BinaryFilterAttenuator.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        filter_selection: tuple[type[SubsetEnum], ...],
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.filters: DeviceVector[FilterMotor] = DeviceVector(
+                {
+                    index: FilterMotor(f"{prefix}MP{index + 1}:", filter, name)
+                    for index, filter in enumerate(filter_selection)
+                }
+            )
+        super().__init__(prefix, name=name)

dodal/devices/attenuator/filter.py

@@ -0,0 +1,11 @@
+from ophyd_async.core import StandardReadable, SubsetEnum
+from ophyd_async.epics.core import epics_signal_rw
+
+
+class FilterMotor(StandardReadable):
+    def __init__(
+        self, prefix: str, filter_selections: type[SubsetEnum], name: str = ""
+    ):
+        with self.add_children_as_readables():
+            self.user_setpoint = epics_signal_rw(filter_selections, f"{prefix}SELECT")
+        super().__init__(name=name)

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)