dls-dodal 1.66.0__py3-none-any.whl → 1.68.0__py3-none-any.whl

dodal/devices/electron_analyser/vgscienta/vgscienta_detector.py

@@ -0,0 +1,52 @@
+from typing import Generic
+
+from dodal.devices.electron_analyser.base.base_controller import (
+    ElectronAnalyserController,
+)
+from dodal.devices.electron_analyser.base.base_detector import ElectronAnalyserDetector
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.base.energy_sources import (
+    DualEnergySource,
+    EnergySource,
+)
+from dodal.devices.electron_analyser.vgscienta.vgscienta_driver_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
+    TPassEnergyEnum,
+    VGScientaRegion,
+    VGScientaSequence,
+)
+
+
+class VGScientaDetector(
+    ElectronAnalyserDetector[
+        VGScientaSequence[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+        VGScientaRegion[TLensMode, TPassEnergyEnum],
+    ],
+    Generic[TLensMode, TPsuMode, TPassEnergyEnum],
+):
+    def __init__(
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        psu_mode_type: type[TPsuMode],
+        pass_energy_type: type[TPassEnergyEnum],
+        energy_source: DualEnergySource | EnergySource,
+        name: str = "",
+    ):
+        # Save to class so takes part with connect()
+        self.driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](
+            prefix, lens_mode_type, psu_mode_type, pass_energy_type
+        )
+
+        controller = ElectronAnalyserController[
+            VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum],
+            VGScientaRegion[TLensMode, TPassEnergyEnum],
+        ](self.driver, energy_source, 0)
+
+        sequence_class = VGScientaSequence[
+            lens_mode_type, psu_mode_type, pass_energy_type
+        ]
+        super().__init__(sequence_class, controller, name)

dodal/devices/electron_analyser/vgscienta/{driver_io.py → vgscienta_driver_io.py}

@@ -4,28 +4,22 @@ from typing import Generic
 import numpy as np
 from ophyd_async.core import (
     Array1D,
+    AsyncStatus,
     SignalR,
     StandardReadableFormat,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.devices.electron_analyser.abstract.base_driver_io import (
+from dodal.devices.electron_analyser.base.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
-from dodal.devices.electron_analyser.abstract.types import (
-    TLensMode,
-    TPassEnergyEnum,
-    TPsuMode,
-)
-from dodal.devices.electron_analyser.energy_sources import (
-    DualEnergySource,
-    EnergySource,
-)
-from dodal.devices.electron_analyser.vgscienta.enums import (
+from dodal.devices.electron_analyser.base.base_region import TLensMode, TPsuMode
+from dodal.devices.electron_analyser.vgscienta.vgscienta_enums import (
     AcquisitionMode,
     DetectorMode,
 )
-from dodal.devices.electron_analyser.vgscienta.region import (
+from dodal.devices.electron_analyser.vgscienta.vgscienta_region import (
+    TPassEnergyEnum,
     VGScientaRegion,
 )
 
@@ -46,7 +40,6 @@ class VGScientaAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_source: EnergySource | DualEnergySource,
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -67,28 +60,29 @@ class VGScientaAnalyserDriverIO(
             lens_mode_type,
             psu_mode_type,
             pass_energy_type,
-            energy_source,
             name,
         )
 
-    async def _set_region(self, ke_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
+    @AsyncStatus.wrap
+    async def set(self, epics_region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         await asyncio.gather(
-            self.region_name.set(ke_region.name),
-            self.low_energy.set(ke_region.low_energy),
-            self.centre_energy.set(ke_region.centre_energy),
-            self.high_energy.set(ke_region.high_energy),
-            self.slices.set(ke_region.slices),
-            self.lens_mode.set(ke_region.lens_mode),
-            self.pass_energy.set(ke_region.pass_energy),
-            self.iterations.set(ke_region.iterations),
-            self.acquire_time.set(ke_region.acquire_time),
-            self.acquisition_mode.set(ke_region.acquisition_mode),
-            self.energy_step.set(ke_region.energy_step),
-            self.detector_mode.set(ke_region.detector_mode),
-            self.region_min_x.set(ke_region.min_x),
-            self.region_size_x.set(ke_region.size_x),
-            self.region_min_y.set(ke_region.min_y),
-            self.region_size_y.set(ke_region.size_y),
+            self.region_name.set(epics_region.name),
+            self.low_energy.set(epics_region.low_energy),
+            self.centre_energy.set(epics_region.centre_energy),
+            self.high_energy.set(epics_region.high_energy),
+            self.slices.set(epics_region.slices),
+            self.lens_mode.set(epics_region.lens_mode),
+            self.pass_energy.set(epics_region.pass_energy),
+            self.iterations.set(epics_region.iterations),
+            self.acquire_time.set(epics_region.acquire_time),
+            self.acquisition_mode.set(epics_region.acquisition_mode),
+            self.energy_step.set(epics_region.energy_step),
+            self.detector_mode.set(epics_region.detector_mode),
+            self.region_min_x.set(epics_region.min_x),
+            self.region_size_x.set(epics_region.size_x),
+            self.region_min_y.set(epics_region.min_y),
+            self.region_size_y.set(epics_region.size_y),
+            self.energy_mode.set(epics_region.energy_mode),
         )
 
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:

dodal/devices/electron_analyser/vgscienta/{region.py → vgscienta_region.py}

@@ -1,22 +1,22 @@
 import uuid
-from typing import Generic
+from typing import Generic, TypeVar
 
+from ophyd_async.core import StrictEnum
 from pydantic import Field, field_validator
 
-from dodal.devices.electron_analyser.abstract.base_region import (
+from dodal.devices.electron_analyser.base.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
-)
-from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
-    TPassEnergyEnum,
     TPsuMode,
 )
-from dodal.devices.electron_analyser.vgscienta.enums import (
+from dodal.devices.electron_analyser.vgscienta.vgscienta_enums import (
     AcquisitionMode,
     DetectorMode,
 )
 
+TPassEnergyEnum = TypeVar("TPassEnergyEnum", bound=StrictEnum)
+
 
 class VGScientaRegion(
     AbstractBaseRegion[AcquisitionMode, TLensMode, TPassEnergyEnum],

dodal/devices/i04/max_pixel.py

@@ -0,0 +1,38 @@
+import cv2
+import numpy as np
+from bluesky.protocols import Triggerable
+from ophyd_async.core import AsyncStatus, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.epics.core import (
+    epics_signal_r,
+)
+
+# kernal size describes how many of the neigbouring pixels are used for the blur,
+# higher kernal size means more of a blur effect
+KERNAL_SIZE = (7, 7)
+
+
+class MaxPixel(StandardReadable, Triggerable):
+    """Gets the max pixel (brightest pixel) from the image after some image processing."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.array_data = epics_signal_r(np.ndarray, f"pva://{prefix}PVA:ARRAY")
+        self.max_pixel_val, self._max_val_setter = soft_signal_r_and_setter(float)
+        super().__init__(name)
+
+    async def _convert_to_gray_and_blur(self):
+        """
+        Preprocess the image array data (convert to grayscale and apply a gaussian blur)
+        Image is converted to grayscale (using a weighted mean as green contributes more to brightness)
+        as we aren't interested in data relating to colour. A blur is then applied to mitigate
+        errors due to rogue hot pixels.
+        """
+        data = await self.array_data.get_value()
+        gray_arr = cv2.cvtColor(data, cv2.COLOR_BGR2GRAY)
+        return cv2.GaussianBlur(gray_arr, KERNAL_SIZE, 0)
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        arr = await self._convert_to_gray_and_blur()
+        max_val = float(np.max(arr))  # np.int64
+        assert isinstance(max_val, float)
+        self._max_val_setter(max_val)

dodal/devices/i09_1_shared/__init__.py

@@ -1,7 +1,14 @@
+from .hard_energy import HardEnergy, HardInsertionDeviceEnergy
 from .hard_undulator_functions import (
     calculate_energy_i09_hu,
     calculate_gap_i09_hu,
     get_hu_lut_as_dict,
 )
 
-__all__ = ["calculate_gap_i09_hu", "get_hu_lut_as_dict", "calculate_energy_i09_hu"]
+__all__ = [
+    "calculate_gap_i09_hu",
+    "get_hu_lut_as_dict",
+    "calculate_energy_i09_hu",
+    "HardInsertionDeviceEnergy",
+    "HardEnergy",
+]

dodal/devices/i09_1_shared/hard_energy.py

@@ -0,0 +1,112 @@
+from asyncio import gather
+from collections.abc import Callable
+
+from bluesky.protocols import Locatable, Location, Movable
+from numpy import ndarray
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_rw,
+    soft_signal_rw,
+)
+
+from dodal.devices.common_dcm import DoubleCrystalMonochromatorBase
+from dodal.devices.i09_1_shared.hard_undulator_functions import (
+    MAX_ENERGY_COLUMN,
+    MIN_ENERGY_COLUMN,
+)
+from dodal.devices.undulator import UndulatorInMm, UndulatorOrder
+
+
+class HardInsertionDeviceEnergy(StandardReadable, Movable[float]):
+    """
+    Compound device to link hard x-ray undulator gap and order to photon energy.
+    Setting the energy adjusts the undulator gap accordingly.
+    """
+
+    def __init__(
+        self,
+        undulator_order: UndulatorOrder,
+        undulator: UndulatorInMm,
+        lut: dict[int, ndarray],
+        gap_to_energy_func: Callable[..., float],
+        energy_to_gap_func: Callable[..., float],
+        name: str = "",
+    ) -> None:
+        self._lut = lut
+        self.gap_to_energy_func = gap_to_energy_func
+        self.energy_to_gap_func = energy_to_gap_func
+        self._undulator_order_ref = Reference(undulator_order)
+        self._undulator_ref = Reference(undulator)
+
+        self.add_readables([undulator_order, undulator.current_gap])
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.energy_demand = soft_signal_rw(float)
+            self.energy = derived_signal_rw(
+                raw_to_derived=self._read_energy,
+                set_derived=self._set_energy,
+                current_gap=self._undulator_ref().gap_motor.user_readback,
+                current_order=self._undulator_order_ref().value,
+                derived_units="keV",
+            )
+        super().__init__(name=name)
+
+    def _read_energy(self, current_gap: float, current_order: int) -> float:
+        return self.gap_to_energy_func(
+            gap=current_gap,
+            look_up_table=self._lut,
+            order=current_order,
+        )
+
+    async def _set_energy(self, energy: float) -> None:
+        current_order = await self._undulator_order_ref().value.get_value()
+        min_energy, max_energy = self._lut[current_order][
+            MIN_ENERGY_COLUMN : MAX_ENERGY_COLUMN + 1
+        ]
+        if not (min_energy <= energy <= max_energy):
+            raise ValueError(
+                f"Requested energy {energy} keV is out of range for harmonic {current_order}: "
+                f"[{min_energy}, {max_energy}] keV"
+            )
+
+        target_gap = self.energy_to_gap_func(
+            photon_energy_kev=energy, look_up_table=self._lut, order=current_order
+        )
+        await self._undulator_ref().set(target_gap)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        self.energy_demand.set(value)
+        await self.energy.set(value)
+
+
+class HardEnergy(StandardReadable, Locatable[float]):
+    """
+    Energy compound device that provides combined change of both DCM energy and undulator gap accordingly.
+    """
+
+    def __init__(
+        self,
+        dcm: DoubleCrystalMonochromatorBase,
+        undulator_energy: HardInsertionDeviceEnergy,
+        name: str = "",
+    ) -> None:
+        self._dcm_ref = Reference(dcm)
+        self._undulator_energy_ref = Reference(undulator_energy)
+        self.add_readables([undulator_energy, dcm.energy_in_keV])
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        await gather(
+            self._dcm_ref().energy_in_keV.set(value),
+            self._undulator_energy_ref().set(value),
+        )
+
+    async def locate(self) -> Location[float]:
+        return Location(
+            setpoint=await self._dcm_ref().energy_in_keV.user_setpoint.get_value(),
+            readback=await self._dcm_ref().energy_in_keV.user_readback.get_value(),
+        )

dodal/devices/i09_2_shared/i09_apple2.py

@@ -0,0 +1,14 @@
+J09_GAP_POLY_DEG_COLUMNS = [
+    "9th-order",
+    "8th-order",
+    "7th-order",
+    "6th-order",
+    "5th-order",
+    "4th-order",
+    "3rd-order",
+    "2nd-order",
+    "1st-order",
+    "0th-order",
+]
+
+J09_PHASE_POLY_DEG_COLUMNS = ["0th-order"]

dodal/devices/i10/i10_apple2.py

@@ -11,19 +11,18 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 
-from dodal.devices.apple2_undulator import (
+from dodal.devices.insertion_device import (
     MAXIMUM_MOVE_TIME,
     Apple2,
     Apple2Controller,
     Apple2PhasesVal,
     Apple2Val,
-    Pol,
     UndulatorGap,
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
-from dodal.devices.util.lookup_tables_apple2 import EnergyMotorLookup
-from dodal.log import LOGGER
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
+from dodal.devices.insertion_device.id_enum import Pol
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
@@ -62,16 +61,18 @@ class I10Apple2(Apple2[UndulatorPhaseAxes]):
 class I10Apple2Controller(Apple2Controller[I10Apple2]):
     """
     I10Apple2Controller is a extension of Apple2Controller which provide linear
-     arbitrary angle control.
+    arbitrary angle control.
     """
 
     def __init__(
         self,
         apple2: I10Apple2,
-        energy_motor_lut: EnergyMotorLookup,
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
         jaw_phase_limit: float = 12.0,
         jaw_phase_poly_param: list[float] = DEFAULT_JAW_PHASE_POLY_PARAMS,
         angle_threshold_deg=30.0,
+        units: str = "eV",
         name: str = "",
     ) -> None:
         """
@@ -79,25 +80,30 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
         -----------
         apple2 : I10Apple2
             An I10Apple2 device.
-        energy_motor_lut: EnergyMotorLookup
-            The class that handles the look up table logic for the insertion device.
+        gap_energy_motor_lut: EnergyMotorLookup
+            The class that handles the gap look up table logic for the insertion device.
+        phase_energy_motor_lut: EnergyMotorLookup
+            The class that handles the phase look up table logic for the insertion device.
         jaw_phase_limit : float, optional
             The maximum allowed jaw_phase movement., by default 12.0
         jaw_phase_poly_param : list[float], optional
             polynomial parameters highest power first., by default DEFAULT_JAW_PHASE_POLY_PARAMS
         angle_threshold_deg : float, optional
             The angle threshold to switch between 0-180 and 180-360 range., by default 30.0
+        units:
+            the units of this device. Defaults to eV.
         name : str, optional
             New device name.
         """
-
-        self.energy_motor_lut = energy_motor_lut
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
         super().__init__(
             apple2=apple2,
-            energy_to_motor_converter=self.energy_motor_lut.get_motor_from_energy,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            units=units,
             name=name,
         )
-
         self.jaw_phase_from_angle = np.poly1d(jaw_phase_poly_param)
         self.angle_threshold_deg = angle_threshold_deg
         self.jaw_phase_limit = jaw_phase_limit
@@ -132,15 +138,9 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
         await self.apple2().jaw_phase().set(jaw_phase)
         await self._linear_arbitrary_angle.set(pol_angle)
 
-    async def _set_motors_from_energy(self, value: float) -> None:
-        """
-        Set the undulator motors for a given energy and polarisation.
-        """
-
-        pol = await self._check_and_get_pol_setpoint()
-        gap, phase = self.energy_to_motor(energy=value, pol=pol)
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
         phase3 = phase * (-1 if pol == Pol.LA else 1)
-        id_set_val = Apple2Val(
+        return Apple2Val(
             gap=f"{gap:.6f}",
             phase=Apple2PhasesVal(
                 top_outer=f"{phase:.6f}",
@@ -150,8 +150,10 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
             ),
         )
 
-        LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self.apple2().set(id_motor_values=id_set_val)
+    async def _set_motors_from_energy_and_polarisation(
+        self, energy: float, pol: Pol
+    ) -> None:
+        await super()._set_motors_from_energy_and_polarisation(energy, pol)
         if pol != Pol.LA:
             await self.apple2().jaw_phase().set(0)
             await self.apple2().jaw_phase().set_move.set(1)

dodal/devices/i17/i17_apple2.py

@@ -1,11 +1,12 @@
-from dodal.devices.apple2_undulator import (
+from dodal.devices.insertion_device.apple2_undulator import (
     Apple2,
     Apple2Controller,
     Apple2PhasesVal,
     Apple2Val,
-    EnergyMotorConvertor,
+    Pol,
+    UndulatorPhaseAxes,
 )
-from dodal.log import LOGGER
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
@@ -15,7 +16,7 @@ ALPHA_OFFSET = 180
 MAXIMUM_MOVE_TIME = 550  # There is no useful movements take longer than this.
 
 
-class I17Apple2Controller(Apple2Controller[Apple2]):
+class I17Apple2Controller(Apple2Controller[Apple2[UndulatorPhaseAxes]]):
     """
     I10Apple2Controller is a extension of Apple2Controller which provide linear
     arbitrary angle control.
@@ -23,32 +24,43 @@ class I17Apple2Controller(Apple2Controller[Apple2]):
 
     def __init__(
         self,
-        apple2: Apple2,
-        energy_to_motor_converter: EnergyMotorConvertor,
+        apple2: Apple2[UndulatorPhaseAxes],
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
+        units: str = "eV",
         name: str = "",
     ) -> None:
+        """
+        Parameters:
+        -----------
+        apple2 : Apple2
+            An Apple2 device.
+        gap_energy_motor_lut: EnergyMotorLookup
+            The class that handles the gap look up table logic for the insertion device.
+        phase_energy_motor_lut: EnergyMotorLookup
+            The class that handles the phase look up table logic for the insertion device.
+        units:
+            the units of this device. Defaults to eV.
+        name : str, optional
+            New device name.
+        """
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
         super().__init__(
             apple2=apple2,
-            energy_to_motor_converter=energy_to_motor_converter,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            units=units,
             name=name,
         )
 
-    async def _set_motors_from_energy(self, value: float) -> None:
-        """
-        Set the undulator motors for a given energy and polarisation.
-        """
-
-        pol = await self._check_and_get_pol_setpoint()
-        gap, phase = self.energy_to_motor(energy=value, pol=pol)
-        id_set_val = Apple2Val(
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        return Apple2Val(
             gap=f"{gap:.6f}",
             phase=Apple2PhasesVal(
                 top_outer=f"{phase:.6f}",
-                top_inner="0.0",
+                top_inner=f"{0.0:.6f}",
                 btm_inner=f"{phase:.6f}",
-                btm_outer="0.0",
+                btm_outer=f"{0.0:.6f}",
             ),
         )
-
-        LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self.apple2().set(id_motor_values=id_set_val)

dodal/devices/i19/access_controlled/attenuator_motor_squad.py

@@ -0,0 +1,61 @@
+from typing import Annotated, Any, Self
+
+from ophyd_async.core import AsyncStatus
+from pydantic import BaseModel, model_validator
+from pydantic.types import PositiveInt, StringConstraints
+
+from dodal.devices.i19.access_controlled.blueapi_device import (
+    OpticsBlueAPIDevice,
+)
+from dodal.devices.i19.access_controlled.hutch_access import ACCESS_DEVICE_NAME
+
+PermittedKeyStr = Annotated[str, StringConstraints(pattern="^[A-Za-z0-9-_]*$")]
+
+
+class AttenuatorMotorPositionDemands(BaseModel):
+    continuous_demands: dict[PermittedKeyStr, float] = {}
+    indexed_demands: dict[PermittedKeyStr, PositiveInt] = {}
+
+    @model_validator(mode="after")
+    def no_keys_clash(self) -> Self:
+        common_keys = set(self.continuous_demands).intersection(self.indexed_demands)
+        common_key_count = sum(1 for _ in common_keys)
+        if common_key_count < 1:
+            return self
+        else:
+            ks: str = "key" if common_key_count == 1 else "keys"
+            error_msg = f"Common {ks} found in distinct motor demands: {common_keys}"
+            raise ValueError(error_msg)
+
+    def validated_complete_demand(self) -> dict[PermittedKeyStr, Any]:
+        return self.continuous_demands | self.indexed_demands
+
+
+class AttenuatorMotorSquad(OpticsBlueAPIDevice):
+    """ I19-specific proxy device which requests absorber position changes in the x-ray attenuator.
+
+    Sends REST call to blueapi controlling optics on the I19 cluster.
+     The hutch in use is compared against the hutch which sent the REST call.
+    Only the hutch in use will be permitted to execute a plan (requesting motor moves).
+    As the two hutches are located in series, checking the hutch in use is necessary to \
+    avoid accidentally operating optics devices from one hutch while the other has beam time.
+
+    The name of the hutch that wants to operate the optics device is passed to the \
+    access controlled device upon instantiation of the latter.
+
+    For details see the architecture described in \
+    https://github.com/DiamondLightSource/i19-bluesky/issues/30.
+    """
+
+    @AsyncStatus.wrap
+    async def set(self, value: AttenuatorMotorPositionDemands):
+        request_params = {
+            "name": "operate_motor_squad_plan",
+            "params": {
+                "experiment_hutch": self._invoking_hutch,
+                "access_device": ACCESS_DEVICE_NAME,
+                "attenuator_demands": value.validated_complete_demand(),
+            },
+            "instrument_session": self.instrument_session,
+        }
+        await super().set(request_params)

dodal/devices/i19/access_controlled/blueapi_device.py

@@ -29,11 +29,19 @@ class OpticsBlueAPIDevice(StandardReadable, Movable[D]):
     https://github.com/DiamondLightSource/i19-bluesky/issues/30.
     """
 
-    def __init__(self, name: str = "") -> None:
+    def __init__(
+        self, hutch: HutchState, instrument_session: str = "", name: str = ""
+    ) -> None:
+        self.hutch_request = hutch
+        self.instrument_session = instrument_session
         self.url = OPTICS_BLUEAPI_URL
         self.headers = HEADERS
         super().__init__(name)
 
+    @property
+    def _invoking_hutch(self) -> str:
+        return self.hutch_request.value
+
     @AsyncStatus.wrap
     async def set(self, value: D):
         """ On set send a POST request to the optics blueapi with the name and \

dodal/devices/i19/access_controlled/shutter.py

@@ -36,16 +36,14 @@ class AccessControlledShutter(OpticsBlueAPIDevice):
         # see https://github.com/DiamondLightSource/blueapi/issues/1187
         with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
             self.shutter_status = epics_signal_r(ShutterState, f"{prefix}STA")
-        self.hutch_request = hutch
-        self.instrument_session = instrument_session
-        super().__init__(name)
+        super().__init__(hutch=hutch, instrument_session=instrument_session, name=name)
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
         request_params = {
             "name": "operate_shutter_plan",
             "params": {
-                "experiment_hutch": self.hutch_request.value,
+                "experiment_hutch": self._invoking_hutch,
                 "access_device": ACCESS_DEVICE_NAME,
                 "shutter_demand": value.value,
             },

dodal/devices/i21/__init__.py

@@ -1,3 +1,5 @@
 from dodal.devices.i21.enums import Grating
 
-__all__ = ["Grating"]
+__all__ = [
+    "Grating",
+]