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

dodal/beamlines/i10.py

@@ -6,6 +6,8 @@ note:
     idd == id1,    idu == id2.
 """
 
+from daq_config_server.client import ConfigServer
+
 from dodal.common.beamlines.beamline_utils import device_factory
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.devices.current_amplifiers import CurrentAmpDet
@@ -25,6 +27,9 @@ from dodal.devices.i10.rasor.rasor_scaler_cards import RasorScalerCard1
 from dodal.devices.i10.slits import I10Slits, I10SlitsDrainCurrent
 from dodal.devices.motors import XYStage, XYZStage
 from dodal.devices.pgm import PGM
+from dodal.devices.temperture_controller import (
+    Lakeshore340,
+)
 from dodal.log import set_beamline as set_log_beamline
 from dodal.utils import BeamlinePrefix, get_beamline_name
 
@@ -33,8 +38,10 @@ set_log_beamline(BL)
 set_utils_beamline(BL)
 PREFIX = BeamlinePrefix(BL)
 
+I10_CONF_CLIENT = ConfigServer(url="https://daq-config.diamond.ac.uk")
 
-LOOK_UPTABLE_DIR = "/dls_sw/i10/software/blueapi/scratch/i10-config/lookupTables/"
+
+LOOK_UPTABLE_DIR = "/dls_sw/i10/software/gda/workspace_git/gda-diamond.git/configurations/i10-shared/lookupTables/"
 
 
 @device_factory()
@@ -60,6 +67,7 @@ def idd() -> I10Id:
         pgm=pgm(),
         look_up_table_dir=LOOK_UPTABLE_DIR,
         source=("Source", "idd"),
+        config_client=I10_CONF_CLIENT,
     )
 
 
@@ -76,6 +84,7 @@ def idu() -> I10Id:
         pgm=pgm(),
         look_up_table_dir=LOOK_UPTABLE_DIR,
         source=("Source", "idu"),
+        config_client=I10_CONF_CLIENT,
     )
 
 
@@ -153,6 +162,13 @@ def sample_stage() -> XYZStage:
     return XYZStage(prefix="ME01D-MO-CRYO-01:")
 
 
+@device_factory()
+def rasor_temperature_controller() -> Lakeshore340:
+    return Lakeshore340(
+        prefix="ME01D-EA-TCTRL-01:",
+    )
+
+
 @device_factory()
 def rasor_femto() -> RasorFemto:
     return RasorFemto(

dodal/beamlines/i11.py

@@ -1,13 +1,9 @@
-from pathlib import Path
-
 from dodal.common.beamlines.beamline_utils import (
     device_factory,
     get_path_provider,
-    set_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.common.beamlines.device_helpers import DET_SUFFIX
-from dodal.common.visit import RemoteDirectoryServiceClient, StaticVisitPathProvider
 from dodal.devices.cryostream import OxfordCryoStream
 from dodal.devices.eurotherm import (
     EurothermGeneral,
@@ -34,19 +30,6 @@ PREFIX = BeamlinePrefix(BL)
 set_log_beamline(BL)
 set_utils_beamline(BL)
 
-# Currently we must hard-code the visit, determining the visit at runtime requires
-# infrastructure that is still WIP.
-# Communication with GDA is also WIP so for now we determine an arbitrary scan number
-# locally and write the commissioning directory. The scan number is not guaranteed to
-# be unique and the data is at risk - this configuration is for testing only.
-set_path_provider(
-    StaticVisitPathProvider(
-        BL,
-        Path(f"/dls/{BL}/data/2025/cm40625-3/bluesky"),
-        client=RemoteDirectoryServiceClient(f"http://{BL}-control:8088/api"),
-    )
-)
-
 
 @device_factory()
 def mythen3() -> Mythen3:

dodal/beamlines/i19_2.py

@@ -1,5 +1,8 @@
+from ophyd_async.fastcs.panda import HDFPanda
+
 from dodal.common.beamlines.beamline_utils import (
     device_factory,
+    get_path_provider,
 )
 from dodal.common.beamlines.beamline_utils import (
     set_beamline as set_utils_beamline,
@@ -84,3 +87,11 @@ def backlight() -> BacklightPosition:
     If this is called when already instantiated in i19-2, it will return the existing object.
     """
     return BacklightPosition(prefix=f"{PREFIX.beamline_prefix}-EA-IOC-12:")
+
+
+@device_factory()
+def panda() -> HDFPanda:
+    return HDFPanda(
+        prefix=f"{PREFIX.beamline_prefix}-EA-PANDA-01:",
+        path_provider=get_path_provider(),
+    )

dodal/beamlines/i21.py

@@ -0,0 +1,27 @@
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.i21 import Grating
+from dodal.devices.pgm import PGM
+from dodal.devices.synchrotron import Synchrotron
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("i21")
+PREFIX = BeamlinePrefix(BL, suffix="I")
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+
+@device_factory()
+def synchrotron() -> Synchrotron:
+    return Synchrotron()
+
+
+@device_factory()
+def pgm() -> PGM:
+    return PGM(
+        prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
+        grating=Grating,
+    )

dodal/beamlines/i22.py

@@ -1,7 +1,7 @@
 from pathlib import Path
 
 from ophyd_async.epics.adaravis import AravisDetector
-from ophyd_async.epics.adcore import NDPluginBaseIO
+from ophyd_async.epics.adcore import NDPluginBaseIO, NDPluginStatsIO
 from ophyd_async.epics.adpilatus import PilatusDetector
 from ophyd_async.fastcs.panda import HDFPanda
 
@@ -68,6 +68,11 @@ def saxs() -> PilatusDetector:
         drv_suffix=CAM_SUFFIX,
         fileio_suffix=HDF5_SUFFIX,
         metadata_holder=metadata_holder,
+        plugins={
+            "stats": NDPluginStatsIO(
+                prefix=f"{PREFIX.beamline_prefix}-EA-PILAT-01:STAT:"
+            )
+        },
     )
 
 
@@ -93,6 +98,11 @@ def waxs() -> PilatusDetector:
         drv_suffix=CAM_SUFFIX,
         fileio_suffix=HDF5_SUFFIX,
         metadata_holder=metadata_holder,
+        plugins={
+            "stats": NDPluginStatsIO(
+                prefix=f"{PREFIX.beamline_prefix}-EA-PILAT-03:STAT:"
+            )
+        },
     )
 
 
@@ -272,7 +282,7 @@ def linkam() -> Linkam3:
     return Linkam3(prefix=f"{PREFIX.beamline_prefix}-EA-TEMPC-05:")
 
 
-@device_factory()
+@device_factory(skip=True)
 def ppump() -> WatsonMarlow323Pump:
     """Sample Environment Peristaltic Pump"""
     return WatsonMarlow323Pump(f"{PREFIX.beamline_prefix}-EA-PUMP-01:")

dodal/beamlines/i24.py

@@ -1,13 +1,22 @@
+from pathlib import PurePath
+
+from ophyd_async.core import AutoIncrementingPathProvider, StaticFilenameProvider
+
 from dodal.common.beamlines.beamline_utils import (
     BL,
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.attenuator.attenuator import ReadOnlyAttenuator
+from dodal.devices.attenuator.attenuator import EnumFilterAttenuator
+from dodal.devices.attenuator.filter_selections import (
+    I24_FilterOneSelections,
+    I24_FilterTwoSelections,
+)
 from dodal.devices.hutch_shutter import HutchShutter
 from dodal.devices.i24.aperture import Aperture
 from dodal.devices.i24.beam_center import DetectorBeamCenter
 from dodal.devices.i24.beamstop import Beamstop
+from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
 from dodal.devices.i24.dcm import DCM
 from dodal.devices.i24.dual_backlight import DualBacklight
 from dodal.devices.i24.focus_mirrors import FocusMirrorsMode
@@ -44,12 +53,13 @@ PREFIX = BeamlinePrefix(BL)
 
 
 @device_factory()
-def attenuator() -> ReadOnlyAttenuator:
+def attenuator() -> EnumFilterAttenuator:
     """Get a read-only attenuator device for i24, instantiate it if it hasn't already
     been. If this is called when already instantiated in i24, it will return the
     existing object."""
-    return ReadOnlyAttenuator(
+    return EnumFilterAttenuator(
         f"{PREFIX.beamline_prefix}-OP-ATTN-01:",
+        filter_selection=(I24_FilterOneSelections, I24_FilterTwoSelections),
     )
 
 
@@ -187,3 +197,22 @@ def eiger_beam_center() -> DetectorBeamCenter:
         f"{PREFIX.beamline_prefix}-EA-EIGER-01:CAM:",
         "eiger_bc",
     )
+
+
+@device_factory()
+def commissioning_jungfrau(
+    path_to_dir: str = "/tmp/jf",  # Device factory doesn't allow for required args,
+    filename: str = "jf_output",  # but these should be manually entered when commissioning
+) -> CommissioningJungfrau:
+    """Get the commissionning Jungfrau 9M device, which uses a temporary filewriter
+    device in place of Odin while the detector is in commissioning.
+    Instantiates the device if it hasn't already been.
+    If this is called when already instantiated, it will return the existing object."""
+
+    return CommissioningJungfrau(
+        f"{PREFIX.beamline_prefix}-EA-JFRAU-01:",
+        f"{PREFIX.beamline_prefix}-JUNGFRAU-META:FD:",
+        AutoIncrementingPathProvider(
+            StaticFilenameProvider(filename), PurePath(path_to_dir)
+        ),
+    )

dodal/beamlines/k07.py

@@ -0,0 +1,31 @@
+from ophyd_async.core import StrictEnum
+
+from dodal.common.beamlines.beamline_utils import (
+    device_factory,
+)
+from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
+from dodal.devices.pgm import PGM
+from dodal.devices.synchrotron import Synchrotron
+from dodal.log import set_beamline as set_log_beamline
+from dodal.utils import BeamlinePrefix, get_beamline_name
+
+BL = get_beamline_name("k07")
+PREFIX = BeamlinePrefix(BL)
+set_log_beamline(BL)
+set_utils_beamline(BL)
+
+
+@device_factory()
+def synchrotron() -> Synchrotron:
+    return Synchrotron()
+
+
+# Grating does not exist yet - this class is a placeholder for when it does
+class Grating(StrictEnum):
+    NO_GRATING = "No Grating"
+
+
+# Grating does not exist yet - this class is a placeholder for when it does
+@device_factory(skip=True)
+def pgm() -> PGM:
+    return PGM(prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:", grating=Grating)

dodal/beamlines/p60.py

@@ -2,8 +2,8 @@ from dodal.common.beamlines.beamline_utils import (
     device_factory,
 )
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
-from dodal.devices.electron_analyser import SelectedSource
-from dodal.devices.electron_analyser.vgscienta import VGScientaAnalyserDriverIO
+from dodal.devices.electron_analyser import DualEnergySource
+from dodal.devices.electron_analyser.vgscienta import VGScientaDetector
 from dodal.devices.p60 import (
     LabXraySource,
     LabXraySourceReadable,
@@ -30,18 +30,19 @@ def mg_kalpha_source() -> LabXraySourceReadable:
     return LabXraySourceReadable(LabXraySource.MG_KALPHA)
 
 
+@device_factory()
+def energy_source() -> DualEnergySource:
+    return DualEnergySource(al_kalpha_source().energy_ev, mg_kalpha_source().energy_ev)
+
+
 # Connect will work again after this work completed
 # https://jira.diamond.ac.uk/browse/P60-13
 @device_factory()
-def analyser_driver() -> VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy]:
-    energy_sources = {
-        SelectedSource.SOURCE1: al_kalpha_source().energy_ev,
-        SelectedSource.SOURCE2: mg_kalpha_source().energy_ev,
-    }
-    return VGScientaAnalyserDriverIO[LensMode, PsuMode, PassEnergy](
+def r4000() -> VGScientaDetector[LensMode, PsuMode, PassEnergy]:
+    return VGScientaDetector[LensMode, PsuMode, PassEnergy](
         prefix=f"{PREFIX.beamline_prefix}-EA-DET-01:CAM:",
         lens_mode_type=LensMode,
         psu_mode_type=PsuMode,
         pass_energy_type=PassEnergy,
-        energy_sources=energy_sources,
+        energy_source=energy_source(),
     )

dodal/common/watcher_utils.py

@@ -12,7 +12,6 @@ class _LogOnPercentageProgressWatcher(Watcher[Number]):
         message_prefix: str,
         percent_interval: Number = 25,
     ):
-        status.watch(self)
         self.percent_interval = percent_interval
         self._current_percent_interval = 0
         self.message_prefix = message_prefix
@@ -20,6 +19,7 @@ class _LogOnPercentageProgressWatcher(Watcher[Number]):
             raise ValueError(
                 f"Percent interval on class _LogOnPercentageProgressWatcher must be a positive number, but received {self.percent_interval}"
             )
+        status.watch(self)
 
     def __call__(
         self,

dodal/devices/apple2_undulator.py

@@ -2,7 +2,7 @@ import abc
 import asyncio
 from dataclasses import dataclass
 from math import isclose
-from typing import Any, Generic, TypeVar
+from typing import Generic, Protocol, TypeVar
 
 import numpy as np
 from bluesky.protocols import Movable
@@ -18,7 +18,6 @@ from ophyd_async.core import (
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
-from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.log import LOGGER
 
@@ -49,46 +48,6 @@ class Apple2Val:
     btm_outer: str
 
 
-class EnergyMinMax(BaseModel):
-    Minimum: float
-    Maximum: float
-
-
-class EnergyCoverageEntry(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    Low: float
-    High: float
-    Poly: np.poly1d
-
-
-class EnergyCoverage(RootModel):
-    root: dict[str, EnergyCoverageEntry]
-
-
-class LookupTableEntries(BaseModel):
-    Energies: EnergyCoverage
-    Limit: EnergyMinMax
-
-
-class Lookuptable(RootModel):
-    """BaseModel class for the lookup table.
-    Apple2 lookup table should be in this format.
-
-    {mode: {'Energies': {Any: {'Low': float,
-                            'High': float,
-                            'Poly':np.poly1d
-                            }
-                        }
-            'Limit': {'Minimum': float,
-                    'Maximum': float
-                    }
-        }
-    }
-    """
-
-    root: dict[str, LookupTableEntries]
-
-
 class Pol(StrictEnum):
     NONE = "None"
     LH = "lh"
@@ -342,6 +301,12 @@ class UndulatorJawPhase(SafeUndulatorMover[float]):
         )
 
 
+class EnergyMotorConvertor(Protocol):
+    def __call__(self, energy: float, pol: Pol) -> tuple[float, float]:
+        """Protocol to provide energy to motor position convertion"""
+        ...
+
+
 class Apple2(abc.ABC, StandardReadable, Movable):
     """
     Apple2 Undulator Device
@@ -353,9 +318,8 @@ class Apple2(abc.ABC, StandardReadable, Movable):
     The class is designed to manage the undulator's gap, phase motors, and polarisation settings, while
     abstracting hardware interactions and providing a high-level interface for beamline operations.
 
-
-    A pair of look up tables are needed to provide the conversion between motor position
-    and energy.
+    The class is abstract and requires beamline-specific implementations for set motor
+     positions based on energy and polarisation.
 
     Attributes
     ----------
@@ -371,27 +335,22 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         A hardware-backed signal for polarisation readback and control.
     lookup_tables : dict
         A dictionary storing lookup tables for gap and phase motor positions, used for energy and polarisation conversion.
-    _available_pol : list
-        A list of available polarisations supported by the device.
+    energy_to_motor : EnergyMotorConvertor
+        A callable that converts energy and polarisation to motor positions.
 
     Abstract Methods
     ----------------
     set(value: float) -> None
         Abstract method to set motor positions for a given energy and polarisation.
-    update_lookuptable() -> None
-        Abstract method to load and validate lookup tables from external sources.
 
     Methods
     -------
-    _set_pol_setpoint(pol: Pol) -> None
-        Sets the polarisation setpoint without moving hardware.
     determine_phase_from_hardware(...) -> tuple[Pol, float]
         Determines the polarisation and phase value based on motor positions.
 
     Notes
     -----
     - This class requires beamline-specific implementations of the abstract methods.
-    - The lookup tables must follow the `Lookuptable` format and be validated before use.
     - The device supports multiple polarisation modes, including linear horizontal (LH), linear vertical (LV),
       positive circular (PC), negative circular (NC), and linear arbitrary (LA).
 
@@ -406,6 +365,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self,
         id_gap: UndulatorGap,
         id_phase: UndulatorPhaseAxes,
+        energy_motor_convertor: EnergyMotorConvertor,
         name: str = "",
     ) -> None:
         """
@@ -414,16 +374,13 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         ----------
         id_gap: An UndulatorGap device.
         id_phase: An UndulatorPhaseAxes device.
-        prefix: Not in use but needed for device_instantiation.
+        energy_motor_convertor: A callable that converts energy and polarisation to motor positions.
         name: Name of the device.
         """
-        super().__init__(name)
 
-        # Attributes are set after super call so they are not renamed to
-        # <name>-undulator, etc.
         self.gap = id_gap
         self.phase = id_phase
-
+        self.energy_to_motor = energy_motor_convertor
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             # Store the set energy for readback.
             self.energy, self._set_energy_rbv = soft_signal_r_and_setter(
@@ -435,11 +392,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         self.polarisation_setpoint, self._polarisation_setpoint_set = (
             soft_signal_r_and_setter(Pol)
         )
-        # This store two lookup tables, Gap and Phase in the Lookuptable format
-        self.lookup_tables: dict[str, dict[str | None, dict[str, dict[str, Any]]]] = {
-            "Gap": {},
-            "Phase": {},
-        }
+
         # Hardware backed read/write for polarisation.
         self.polarisation = derived_signal_rw(
             raw_to_derived=self._read_pol,
@@ -451,13 +404,7 @@ class Apple2(abc.ABC, StandardReadable, Movable):
             btm_outer=self.phase.btm_outer.user_readback,
             gap=id_gap.user_readback,
         )
-
-        self._available_pol = []
-        """
-        Abstract method that run at start up to load lookup tables into  self.lookup_tables
-        and set available_pol.
-        """
-        self.update_lookuptable()
+        super().__init__(name)
 
     def _set_pol_setpoint(self, pol: Pol) -> None:
         """Set the polarisation setpoint without moving hardware. The polarisation
@@ -488,8 +435,8 @@ class Apple2(abc.ABC, StandardReadable, Movable):
 
         Examples
         --------
-        >>> RE( id.set(888.0)) # This will set the ID to 888 eV
-        >>> RE(scan([detector], id,600,700,100)) # This will scan the ID from 600 to 700 eV in 100 steps.
+        RE( id.set(888.0)) # This will set the ID to 888 eV
+        RE(scan([detector], id,600,700,100)) # This will scan the ID from 600 to 700 eV in 100 steps.
         """
 
     def _read_pol(
@@ -551,77 +498,6 @@ class Apple2(abc.ABC, StandardReadable, Movable):
         await wait_for_value(self.gap.gate, UndulatorGateStatus.CLOSE, timeout=timeout)
         self._set_energy_rbv(energy)  # Update energy after move for readback.
 
-    async def _get_id_gap_phase(self, energy: float) -> tuple[float, float]:
-        """
-        Converts energy and polarisation to gap and phase.
-        """
-        gap_poly = await self._get_poly(
-            lookup_table=self.lookup_tables["Gap"], new_energy=energy
-        )
-        phase_poly = await self._get_poly(
-            lookup_table=self.lookup_tables["Phase"], new_energy=energy
-        )
-        return gap_poly(energy), phase_poly(energy)
-
-    async def _get_poly(
-        self,
-        new_energy: float,
-        lookup_table: dict[str | None, dict[str, dict[str, Any]]],
-    ) -> np.poly1d:
-        """
-        Get the correct polynomial for a given energy form lookuptable
-        for the current polarisation setpoint.
-        Parameters
-        ----------
-        new_energy : float
-            The energy in eV for which the polynomial is requested.
-        lookup_table : dict[str | None, dict[str, dict[str, Any]]]
-            The lookup table containing polynomial coefficients for different energies
-            and polarisations.
-        Returns
-        -------
-        np.poly1d
-            The polynomial coefficients for the requested energy and polarisation.
-        Raises
-        ------
-        ValueError
-            If the requested energy is outside the limits defined in the lookup table
-            or if no polynomial coefficients are found for the requested energy.
-        """
-        pol = await self.polarisation_setpoint.get_value()
-        if (
-            new_energy < lookup_table[pol]["Limit"]["Minimum"]
-            or new_energy > lookup_table[pol]["Limit"]["Maximum"]
-        ):
-            raise ValueError(
-                "Demanding energy must lie between {} and {} eV!".format(
-                    lookup_table[pol]["Limit"]["Minimum"],
-                    lookup_table[pol]["Limit"]["Maximum"],
-                )
-            )
-        else:
-            for energy_range in lookup_table[pol]["Energies"].values():
-                if (
-                    new_energy >= energy_range["Low"]
-                    and new_energy < energy_range["High"]
-                ):
-                    return energy_range["Poly"]
-
-        raise ValueError(
-            """Cannot find polynomial coefficients for your requested energy.
-        There might be gap in the calibration lookup table."""
-        )
-
-    @abc.abstractmethod
-    def update_lookuptable(self) -> None:
-        """
-        Abstract method to update the stored lookup tabled from file.
-        This function should include check to ensure the lookuptable is in the correct format:
-            # ensure the importing lookup table is the correct format
-            Lookuptable.model_validate(<loockuptable>)
-
-        """
-
     def determine_phase_from_hardware(
         self,
         top_outer: float,

dodal/devices/attenuator/attenuator.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     DeviceVector,
     SignalR,
     StandardReadable,
+    StrictEnum,
     SubsetEnum,
     wait_for_value,
 )
@@ -26,6 +27,9 @@ class ReadOnlyAttenuator(StandardReadable):
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
+            # Closest obtainable transmission to the current desired transmission given the specific
+            # set of filters in the attenuator. This value updates immediately after setting desired
+            # transmission, before the motors may have finished moving. It is not a readback value.
             self.actual_transmission = epics_signal_r(float, prefix + "MATCH")
 
         super().__init__(name)
@@ -92,7 +96,18 @@ class BinaryFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
         )
 
 
-class EnumFilterAttenuator(ReadOnlyAttenuator):
+# Replace with ophyd async enum after https://github.com/bluesky/ophyd-async/pull/1067
+class YesNo(StrictEnum):
+    YES = "YES"
+    NO = "NO"
+
+
+# Time given to allow for motors to begin moving after the desired transmission has been set,
+# so that we can work out when the set is complete.
+ENUM_ATTENUATOR_SETTLE_TIME_S = 0.15
+
+
+class EnumFilterAttenuator(ReadOnlyAttenuator, Movable[float]):
     """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
@@ -107,11 +122,42 @@ class EnumFilterAttenuator(ReadOnlyAttenuator):
         filter_selection: tuple[type[SubsetEnum], ...],
         name: str = "",
     ):
+        self._auto_move_on_desired_transmission_set = epics_signal_rw(
+            YesNo, prefix + "AUTOMOVE"
+        )
+        self._desired_transmission = epics_signal_rw(float, prefix + "T2A:SETVAL1")
+        self._use_current_energy = epics_signal_x(prefix + "E2WL:USECURRENTENERGY.PROC")
+
         with self.add_children_as_readables():
-            self.filters: DeviceVector[FilterMotor] = DeviceVector(
+            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)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """Set the transmission to the fractional (0-1) value given.
+
+        The attenuator IOC will then insert filters to reach the desired transmission for
+        the current beamline energy, the set will only complete when they have all been
+        applied.
+        """
+
+        # auto move should normally be on, but check here incase it was manually turned off
+        await self._auto_move_on_desired_transmission_set.set(YesNo.YES)
+
+        # Currently uncertain if _use_current_energy correctly waits for completion: https://github.com/DiamondLightSource/dodal/issues/1588
+        await self._use_current_energy.trigger()
+        await self._desired_transmission.set(value)
+
+        # Give EPICS a chance to start moving the filter motors. Not needed after
+        # a transmission readback PV is added at the controls level: https://jira.diamond.ac.uk/browse/I24-725
+        await asyncio.sleep(ENUM_ATTENUATOR_SETTLE_TIME_S)
+        coros = [
+            wait_for_value(self._filters[i].done_move, 1, timeout=DEFAULT_TIMEOUT)
+            for i in self._filters
+        ]
+        await asyncio.gather(*coros)

dodal/devices/attenuator/filter.py

@@ -8,4 +8,7 @@ class FilterMotor(StandardReadable):
     ):
         with self.add_children_as_readables():
             self.user_setpoint = epics_signal_rw(filter_selections, f"{prefix}SELECT")
+            self.done_move = epics_signal_rw(
+                int, f"{prefix}DMOV"
+            )  # 1 for yes, 0 for no
         super().__init__(name=name)