dls-dodal 1.62.0__py3-none-any.whl → 1.63.0__py3-none-any.whl

dodal/devices/i10/i10_apple2.py

@@ -1,4 +1,3 @@
-import asyncio
 import csv
 import io
 from dataclasses import dataclass
@@ -10,20 +9,18 @@ from bluesky.protocols import Movable
 from daq_config_server.client import ConfigServer
 from ophyd_async.core import (
     AsyncStatus,
-    Device,
     Reference,
     StandardReadable,
     StandardReadableFormat,
-    soft_signal_r_and_setter,
+    derived_signal_rw,
     soft_signal_rw,
 )
 from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.devices.apple2_undulator import (
     Apple2,
-    Apple2Motors,
+    Apple2Controller,
     Apple2Val,
-    EnergyMotorConvertor,
     Pol,
     UndulatorGap,
     UndulatorJawPhase,
@@ -31,8 +28,6 @@ from dodal.devices.apple2_undulator import (
 )
 from dodal.log import LOGGER
 
-from ..pgm import PGM
-
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
 MAXIMUM_GAP_MOTOR_POSITION = 100
@@ -107,7 +102,7 @@ class I10EnergyMotorLookup:
 
     def __init__(
         self,
-        look_up_table_dir: str,
+        lookuptable_dir: str,
         source: tuple[str, str],
         config_client: ConfigServer,
         mode: str = "Mode",
@@ -141,8 +136,8 @@ class I10EnergyMotorLookup:
             "Gap": {},
             "Phase": {},
         }
-        energy_gap_table_path = Path(look_up_table_dir, gap_file_name)
-        energy_phase_table_path = Path(look_up_table_dir, phase_file_name)
+        energy_gap_table_path = Path(lookuptable_dir, gap_file_name)
+        energy_phase_table_path = Path(lookuptable_dir, phase_file_name)
         self.lookup_table_config = LookupTableConfig(
             path=LookupPath(Gap=energy_gap_table_path, Phase=energy_phase_table_path),
             source=source,
@@ -322,82 +317,123 @@ class I10EnergyMotorLookup:
 
 
 class I10Apple2(Apple2):
-    """I10Apple2 is the i10 version of Apple2 ID, set and energy_motor_convertor
-     should be the only part that is I10 specific.
+    def __init__(
+        self,
+        id_gap: UndulatorGap,
+        id_phase: UndulatorPhaseAxes,
+        id_jaw_phase: UndulatorJawPhase,
+        name: str = "",
+    ) -> None:
+        """
+        I10Apple2 device is an apple2 with extra jaw phase motor.
 
-    A EnergyMotorConvertor function is needed to provide the conversion between
-     x-ray motor position and energy.
+        Parameters
+        ----------
 
-    Set is in energy(eV).
+        id_gap : UndulatorJawPhase
+            The gap motor of the undulator.
+        id_phase : UndulatorJawPhase
+            The phase motors of the undulator.
+        id_jaw_phase : UndulatorJawPhase
+            The jaw phase motor of the undulator.
+        name : str, optional
+            The name of the device, by default "".
+        """
+        with self.add_children_as_readables():
+            self.jaw_phase = id_jaw_phase
+        super().__init__(id_gap=id_gap, id_phase=id_phase, name=name)
+
+
+class I10Apple2Controller(Apple2Controller[I10Apple2]):
+    """
+    I10Apple2Controller is a extension of Apple2Controller which provide linear
+     arbitrary angle control.
     """
 
     def __init__(
         self,
-        prefix: str,
-        energy_motor_convertor: EnergyMotorConvertor,
+        apple2: I10Apple2,
+        lookuptable_dir: str,
+        source: tuple[str, str],
+        config_client: ConfigServer,
+        jaw_phase_limit: float = 12.0,
+        jaw_phase_poly_param: list[float] = DEFAULT_JAW_PHASE_POLY_PARAMS,
+        angle_threshold_deg=30.0,
         name: str = "",
     ) -> None:
         """
-        Parameters
+
+        parameters
         ----------
-        look_up_table_dir:
+        apple2 : I10Apple2
+            An I10Apple2 device.
+        lookuptable_dir : str
             The path to look up table.
-        source:
-            The column name and the name of the source in look up table. e.g. ("source", "idu")
-        mode:
-            The column name of the mode in look up table.
-        min_energy:
-            The column name that contain the maximum energy in look up table.
-        max_energy:
-            The column name that contain the maximum energy in look up table.
-        poly_deg:
-            The column names for the parameters for the energy conversion polynomial, starting with the least significant.
-        prefix:
-            epic pv for id
-        Name:
-            Name of the device
+        source : tuple[str, str]
+            The column name and the name of the source in look up table. e.g. ( "source", "idu")
+        config_client : ConfigServer
+            The config server client to fetch the look up table.
+        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
+        name : str, optional
+            New device name.
         """
 
-        with self.add_children_as_readables():
-            super().__init__(
-                apple2_motors=Apple2Motors(
-                    id_gap=UndulatorGap(prefix=prefix),
-                    id_phase=UndulatorPhaseAxes(
-                        prefix=prefix,
-                        top_outer="RPQ1",
-                        top_inner="RPQ2",
-                        btm_inner="RPQ3",
-                        btm_outer="RPQ4",
-                    ),
-                ),
-                energy_motor_convertor=energy_motor_convertor,
-                name=name,
-            )
-            self.id_jaw_phase = UndulatorJawPhase(
-                prefix=prefix,
-                move_pv="RPQ1",
-            )
+        self.lookup_table_client = I10EnergyMotorLookup(
+            lookuptable_dir=lookuptable_dir,
+            source=source,
+            config_client=config_client,
+        )
+        super().__init__(
+            apple2=apple2,
+            energy_to_motor_converter=self.lookup_table_client.get_motor_from_energy,
+            name=name,
+        )
 
-    async def _set(self, value: float) -> None:
-        """
-        Check polarisation state and use it together with the energy(value)
-        to calculate the required gap and phases before setting it.
-        """
+        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
+        self._linear_arbitrary_angle = soft_signal_rw(float, initial_value=None)
 
-        pol = await self.polarisation_setpoint.get_value()
+        self.linear_arbitrary_angle = derived_signal_rw(
+            raw_to_derived=self._read_linear_arbitrary_angle,
+            set_derived=self._set_linear_arbitrary_angle,
+            pol_angle=self._linear_arbitrary_angle,
+            pol=self.polarisation,
+        )
+
+    def _read_linear_arbitrary_angle(self, pol_angle: float, pol: Pol) -> float:
+        self._raise_if_not_la(pol)
+        return pol_angle
 
-        if pol == Pol.NONE:
-            LOGGER.warning(
-                "Found no setpoint for polarisation. Attempting to"
-                " determine polarisation from hardware..."
+    async def _set_linear_arbitrary_angle(self, pol_angle: float) -> None:
+        pol = await self.polarisation.get_value()
+        self._raise_if_not_la(pol)
+        # Moving to real angle which is 210 to 30.
+        alpha_real = (
+            pol_angle
+            if pol_angle > self.angle_threshold_deg
+            else pol_angle + ALPHA_OFFSET
+        )
+        jaw_phase = self.jaw_phase_from_angle(alpha_real)
+        if abs(jaw_phase) > self.jaw_phase_limit:
+            raise RuntimeError(
+                f"jaw_phase position for angle ({pol_angle}) is outside permitted range"
+                f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
             )
-            pol = await self.polarisation.get_value()
-            if pol == Pol.NONE:
-                raise ValueError(
-                    f"Polarisation cannot be determined from hardware for {self.name}"
-                )
+        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.
+        """
 
-            self._set_pol_setpoint(pol)
+        pol = await self._check_and_get_pol_setpoint()
         gap, phase = self.energy_to_motor(energy=value, pol=pol)
         phase3 = phase * (-1 if pol == Pol.LA else 1)
         id_set_val = Apple2Val(
@@ -409,185 +445,45 @@ class I10Apple2(Apple2):
         )
 
         LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
-        await self.motors.set(id_motor_values=id_set_val)
+        await self.apple2().set(id_motor_values=id_set_val)
         if pol != Pol.LA:
-            await self.id_jaw_phase.set(0)
-            await self.id_jaw_phase.set_move.set(1)
-
-
-class EnergySetter(StandardReadable, Movable[float]):
-    """
-    Compound device to set both ID and PGM energy at the same time.
-
-    """
-
-    def __init__(self, id: I10Apple2, pgm: PGM, name: str = "") -> None:
-        """
-        Parameters
-        ----------
-        id:
-            An Apple2 device.
-        pgm:
-            A PGM/mono device.
-        name:
-            New device name.
-        """
-        super().__init__(name=name)
-        self.id = id
-        self.pgm_ref = Reference(pgm)
-
-        self.add_readables(
-            [self.id.energy, self.pgm_ref().energy.user_readback],
-            StandardReadableFormat.HINTED_SIGNAL,
-        )
-
-        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
-            self.energy_offset = soft_signal_rw(float, initial_value=0)
-
-    @AsyncStatus.wrap
-    async def set(self, value: float) -> None:
-        LOGGER.info(f"Moving f{self.name} energy to {value}.")
-        await asyncio.gather(
-            self.id.set(value=value + await self.energy_offset.get_value()),
-            self.pgm_ref().energy.set(value),
-        )
-
-
-class I10Apple2Pol(StandardReadable, Movable[Pol]):
-    """
-    Compound device to set polorisation of ID.
-    """
-
-    def __init__(self, id: I10Apple2, name: str = "") -> None:
-        """
-        Parameters
-        ----------
-        id:
-            An I10Apple2 device.
-        name:
-            New device name.
-        """
-        super().__init__(name=name)
-        self.id_ref = Reference(id)
-        self.add_readables([self.id_ref().polarisation])
+            await self.apple2().jaw_phase.set(0)
+            await self.apple2().jaw_phase.set_move.set(1)
 
-    @AsyncStatus.wrap
-    async def set(self, value: Pol) -> None:
-        LOGGER.info(f"Changing f{self.name} polarisation to {value}.")
-        # Timeout is determined internally by the set method later, so we set it to max here.
-        await self.id_ref().polarisation.set(value, timeout=MAXIMUM_MOVE_TIME)
+    def _raise_if_not_la(self, pol: Pol) -> None:
+        if pol != Pol.LA:
+            raise RuntimeError(
+                "Angle control is not available in polarisation"
+                + f" {pol} with {self.name}"
+            )
 
 
 class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
     """
-    Device to set polorisation angle of the ID. Linear Arbitrary Angle (laa)
-     is the direction of the magnetic field which can be change by varying the jaw_phase
-     in (linear arbitrary (la) mode,
-     The angle of 0 is equivalent to linear horizontal "lh" (sigma) and
-      90 is linear vertical "lv" (pi).
-    This device require a jaw_phase to angle conversion which is done via a polynomial.
+    Device to set the polarisation angle of the Apple2 undulator in Linear Arbitrary (LA) mode.
     """
 
     def __init__(
         self,
-        id: I10Apple2,
+        id_controller: I10Apple2Controller,
         name: str = "",
-        jaw_phase_limit: float = 12.0,
-        jaw_phase_poly_param: list[float] = DEFAULT_JAW_PHASE_POLY_PARAMS,
-        angle_threshold_deg=30.0,
     ) -> None:
         """
         Parameters
         ----------
-        id: I10Apple2
-            An I10Apple2 device.
-        name: str
+        id_controller : I10Apple2Controller
+            The I10Apple2Controller which control the ID.
+        name : str, optional
             New device name.
-        jaw_phase_limit: float
-            The maximum allowed jaw_phase movement.
-        jaw_phase_poly_param: list
-            polynomial parameters highest power first.
         """
         super().__init__(name=name)
-        self.id_ref = Reference(id)
-        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
-        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.angle, self._angle_set = soft_signal_r_and_setter(
-                float, initial_value=None
-            )
+        self.linear_arbitrary_angle = Reference(id_controller.linear_arbitrary_angle)
 
-    @AsyncStatus.wrap
-    async def set(self, value: SupportsFloat) -> None:
-        value = float(value)
-        pol = await self.id_ref().polarisation.get_value()
-        if pol != Pol.LA:
-            raise RuntimeError(
-                f"Angle control is not available in polarisation {pol} with {self.id_ref().name}"
-            )
-        # Moving to real angle which is 210 to 30.
-        alpha_real = value if value > self.angle_threshold_deg else value + ALPHA_OFFSET
-        jaw_phase = self.jaw_phase_from_angle(alpha_real)
-        if abs(jaw_phase) > self.jaw_phase_limit:
-            raise RuntimeError(
-                f"jaw_phase position for angle ({value}) is outside permitted range"
-                f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
-            )
-        await self.id_ref().id_jaw_phase.set(jaw_phase)
-        self._angle_set(value)
-
-
-class I10Id(Device):
-    def __init__(
-        self,
-        pgm: PGM,
-        prefix: str,
-        look_up_table_dir: str,
-        source: tuple[str, str],
-        config_client: ConfigServer,
-        jaw_phase_limit=12.0,
-        jaw_phase_poly_param=DEFAULT_JAW_PHASE_POLY_PARAMS,
-        angle_threshold_deg=30.0,
-        name: str = "",
-    ) -> None:
-        """I10Id is a compound device that combines the I10-specific Apple2 undulator,
-        energy setter, and polarization control.
-        This class provides a high-level interface for controlling the undulator's
-        energy, polarization, and linear arbitrary angle.
-
-        Attributes
-        ----------
-        id : I10Apple2
-            The I10-specific Apple2 undulator device.
-        energy_setter : EnergySetter
-            A device for synchronizing the undulator and monochromator energy.
-        pol : I10Apple2Pol
-            A device for controlling the polarization of the undulator.
-        linear_arbitrary_angle : LinearArbitraryAngle
-            A device for controlling the linear arbitrary polarization angle.
-        """
-        self.lookup_table_client = I10EnergyMotorLookup(
-            look_up_table_dir=look_up_table_dir,
-            source=source,
-            config_client=config_client,
-        )
-        self.energy = EnergySetter(
-            id=I10Apple2(
-                prefix=prefix,
-                energy_motor_convertor=self.lookup_table_client.get_motor_from_energy,
-                name="id_energy",
-            ),
-            pgm=pgm,
-            name="energy",
-        )
-        self.pol = I10Apple2Pol(id=self.energy.id, name="pol")
-        self.laa = LinearArbitraryAngle(
-            id=self.energy.id,
-            name="laa",
-            jaw_phase_limit=jaw_phase_limit,
-            jaw_phase_poly_param=jaw_phase_poly_param,
-            angle_threshold_deg=angle_threshold_deg,
+        self.add_readables(
+            [self.linear_arbitrary_angle()],
+            StandardReadableFormat.HINTED_SIGNAL,
         )
 
-        super().__init__(name=name)
+    @AsyncStatus.wrap
+    async def set(self, angle: float) -> None:
+        await self.linear_arbitrary_angle().set(angle)

dodal/devices/i10/slits.py

@@ -77,9 +77,7 @@ class I10PrimarySlits(Slits):
         )
 
 
-class I10Slits(Device):
-    """Collection of all the i10 slits before end station."""
-
+class I10SharedSlits(Device):
     def __init__(self, prefix: str, name: str = "") -> None:
         self.s1 = I10PrimarySlits(
             prefix=prefix + "01:",
@@ -90,6 +88,13 @@ class I10Slits(Device):
         self.s3 = I10SlitsBlades(
             prefix=prefix + "03:",
         )
+        super().__init__(name=name)
+
+
+class I10Slits(Device):
+    """Collection of all the i10 slits before end station."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
         self.s4 = MinimalSlits(
             prefix=prefix + "04:",
             x_gap="XSIZE",
@@ -104,9 +109,39 @@ class I10Slits(Device):
         super().__init__(name=name)
 
 
+class I10JSlits(Device):
+    """Collection of all the i10-1 slits before end station."""
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        self.s7 = MinimalSlits(
+            prefix=prefix + "01:",
+            x_gap="XSIZE",
+            y_gap="YSIZE",
+        )
+        self.s8 = I10SlitsBlades(
+            prefix=prefix + "02:",
+        )
+        self.s9 = I10SlitsBlades(
+            prefix=prefix + "03:",
+        )
+        super().__init__(name=name)
+
+
 class I10SlitsDrainCurrent(Device):
     """Collection of all the drain current from i10 slits."""
 
+    def __init__(
+        self, prefix: str, name: str = "", connector: DeviceConnector | None = None
+    ) -> None:
+        self.s4 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-02:")
+        self.s5 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-03:")
+        self.s6 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-04:")
+        super().__init__(name, connector)
+
+
+class I10SharedSlitsDrainCurrent(Device):
+    """Collection of all the drain current from i10 and i10-1 slits."""
+
     def __init__(
         self, prefix: str, name: str = "", connector: DeviceConnector | None = None
     ) -> None:
@@ -118,7 +153,4 @@ class I10SlitsDrainCurrent(Device):
             suffix_bot_blade="YMINUS:I",
         )
         self.s3 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-01:")
-        self.s4 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-02:")
-        self.s5 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-03:")
-        self.s6 = BladeDrainCurrents(prefix=prefix + "DI-IAMP-04:")
         super().__init__(name, connector)

dodal/devices/i15/dcm.py

@@ -1,9 +1,7 @@
-from typing import Generic, TypeVar
-
-from ophyd_async.core import StandardReadable
 from ophyd_async.epics.motor import Motor
 
 from dodal.devices.common_dcm import (
+    DoubleCrystalMonochromatorBase,
     StationaryCrystal,
 )
 
@@ -24,50 +22,13 @@ class ThetaRollYZCrystal(ThetaYCrystal):
         super().__init__(prefix)
 
 
-Xtal_1 = TypeVar("Xtal_1", bound=StationaryCrystal)
-Xtal_2 = TypeVar("Xtal_2", bound=StationaryCrystal)
-
-
-class BaseDCMforI15(StandardReadable, Generic[Xtal_1, Xtal_2]):
-    """
-    Device for double crystal monochromators (DCM), which only allow energy of the beam to be selected.
-
-    Features common across all DCM's should include virtual motors to set energy/wavelength and contain two crystals,
-    each of which can be movable. Some DCM's contain crystals with roll motors, and some contain crystals with roll and pitch motors.
-    This device only accounts for combinations of energy plus two crystals.
-
-    This device is designed to be a drop in replacement for BaseDCM for i15, which doesn't require WAVELENGTH, BRAGG and OFFSET to
-    be available. Once the i15 DCM supports all of the PVs required by BaseDCM, the i15 DCM device can switch to inheriting from
-    BaseDCM and this class can be removed.
-    """
-
-    def __init__(
-        self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2], name: str = ""
-    ) -> None:
-        with self.add_children_as_readables():
-            # Virtual motor PV's which set the physical motors so that the DCM produces requested
-            # wavelength/energy
-            self.energy_in_kev = Motor(prefix + "ENERGY")
-            self._make_crystals(prefix, xtal_1, xtal_2)
-
-        super().__init__(name)
-
-    # Prefix convention is different depending on whether there are one or two controllable crystals
-    def _make_crystals(self, prefix: str, xtal_1: type[Xtal_1], xtal_2: type[Xtal_2]):
-        if StationaryCrystal not in [xtal_1, xtal_2]:
-            self.xtal_1 = xtal_1(f"{prefix}XTAL1:")
-            self.xtal_2 = xtal_2(f"{prefix}XTAL2:")
-        else:
-            self.xtal_1 = xtal_1(prefix)
-            self.xtal_2 = xtal_2(prefix)
-
-
-class DCM(BaseDCMforI15[ThetaRollYZCrystal, ThetaYCrystal]):
+class DCM(DoubleCrystalMonochromatorBase[ThetaRollYZCrystal, ThetaYCrystal]):
     """
-    A double crystal monocromator device, used to select the beam energy.
+    A double crystal monochromator device, used to select the beam energy.
 
-    Once the i15 DCM supports all of the PVs required by BaseDCM, this class can be
-    changed to inherit from BaseDCM and BaseDCMforI15 can be removed.
+    Once the i15 DCM supports all of the PVs required by DoubleCrystalMonochromator or
+    DoubleCrystalMonochromatorWithDSpacing this class can be changed to inherit from it,
+    see https://jira.diamond.ac.uk/browse/I15-1053 for more info.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:

dodal/devices/i17/i17_apple2.py

@@ -0,0 +1,51 @@
+from dodal.devices.apple2_undulator import (
+    Apple2,
+    Apple2Controller,
+    Apple2Val,
+    EnergyMotorConvertor,
+)
+from dodal.log import LOGGER
+
+ROW_PHASE_MOTOR_TOLERANCE = 0.004
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+MAXIMUM_GAP_MOTOR_POSITION = 100
+DEFAULT_JAW_PHASE_POLY_PARAMS = [1.0 / 7.5, -120.0 / 7.5]
+ALPHA_OFFSET = 180
+MAXIMUM_MOVE_TIME = 550  # There is no useful movements take longer than this.
+
+
+class I17Apple2Controller(Apple2Controller[Apple2]):
+    """
+    I10Apple2Controller is a extension of Apple2Controller which provide linear
+    arbitrary angle control.
+    """
+
+    def __init__(
+        self,
+        apple2: Apple2,
+        energy_to_motor_converter: EnergyMotorConvertor,
+        name: str = "",
+    ) -> None:
+        super().__init__(
+            apple2=apple2,
+            energy_to_motor_converter=energy_to_motor_converter,
+            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(
+            top_outer=f"{phase:.6f}",
+            top_inner="0.0",
+            btm_inner=f"{phase:.6f}",
+            btm_outer="0.0",
+            gap=f"{gap:.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/{shutter.py → access_controlled/shutter.py}

@@ -2,8 +2,11 @@ from ophyd_async.core import AsyncStatus, StandardReadableFormat
 from ophyd_async.epics.core import epics_signal_r
 
 from dodal.devices.hutch_shutter import ShutterDemand, ShutterState
-from dodal.devices.i19.blueapi_device import HutchState, OpticsBlueAPIDevice
-from dodal.devices.i19.hutch_access import ACCESS_DEVICE_NAME
+from dodal.devices.i19.access_controlled.blueapi_device import (
+    HutchState,
+    OpticsBlueAPIDevice,
+)
+from dodal.devices.i19.access_controlled.hutch_access import ACCESS_DEVICE_NAME
 
 
 class AccessControlledShutter(OpticsBlueAPIDevice):
@@ -39,7 +42,7 @@ class AccessControlledShutter(OpticsBlueAPIDevice):
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
-        REQUEST_PARAMS = {
+        request_params = {
             "name": "operate_shutter_plan",
             "params": {
                 "experiment_hutch": self.hutch_request.value,
@@ -48,4 +51,4 @@ class AccessControlledShutter(OpticsBlueAPIDevice):
             },
             "instrument_session": self.instrument_session,
         }
-        await super().set(REQUEST_PARAMS)
+        await super().set(request_params)