mx-bluesky 1.4.1a0__py3-none-any.whl → 1.4.3__py3-none-any.whl

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -10,15 +10,17 @@ from dodal.devices.undulator_dcm import UndulatorDCM
 from dodal.devices.util.adjuster_plans import lookup_table_adjuster
 from dodal.devices.util.lookup_tables import (
     linear_interpolation_lut,
+    parse_lookup_table,
 )
 
-from mx_bluesky.hyperion.log import LOGGER
-from mx_bluesky.hyperion.utils.utils import (
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.common.utils.utils import (
     energy_to_bragg_angle,
 )
 
 MIRROR_VOLTAGE_GROUP = "MIRROR_VOLTAGE_GROUP"
 DCM_GROUP = "DCM_GROUP"
+YAW_LAT_TIMEOUT_S = 30
 
 
 def _apply_and_wait_for_voltages_to_settle(
@@ -46,31 +48,42 @@ def _apply_and_wait_for_voltages_to_settle(
         for voltage_channel, required_voltage in zip(
             channels.values(), required_voltages, strict=True
         ):
-            LOGGER.debug(
+            LOGGER.info(
                 f"Applying and waiting for voltage {voltage_channel.name} = {required_voltage}"
             )
             yield from bps.abs_set(
-                voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP
+                voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP, wait=True
             )
 
-    yield from bps.wait(group=MIRROR_VOLTAGE_GROUP)
-
 
 def adjust_mirror_stripe(
     energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: MirrorVoltages
 ):
     """Feedback should be OFF prior to entry, in order to prevent
     feedback from making unnecessary corrections while beam is being adjusted."""
-    stripe = mirror.energy_to_stripe(energy_kev)
+    mirror_config = mirror.energy_to_stripe(energy_kev)
 
     LOGGER.info(
-        f"Adjusting mirror stripe for {energy_kev}keV selecting {stripe} stripe"
+        f"Adjusting mirror stripe for {energy_kev}keV selecting {mirror_config['stripe']} stripe"
     )
-    yield from bps.abs_set(mirror.stripe, stripe, wait=True)
+    yield from bps.abs_set(mirror.stripe, mirror_config["stripe"], wait=True)
     yield from bps.trigger(mirror.apply_stripe)
 
+    # yaw, lat cannot be done simultaneously
+    LOGGER.info(f"Adjusting {mirror.name} lat to {mirror_config['lat_mm']}")
+    yield from bps.abs_set(
+        mirror.x_mm, mirror_config["lat_mm"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+    )
+
+    LOGGER.info(f"Adjusting {mirror.name} yaw to {mirror_config['yaw_mrad']}")
+    yield from bps.abs_set(
+        mirror.yaw_mrad, mirror_config["yaw_mrad"], wait=True, timeout=YAW_LAT_TIMEOUT_S
+    )
+
     LOGGER.info("Adjusting mirror voltages...")
-    yield from _apply_and_wait_for_voltages_to_settle(stripe, mirror_voltages)
+    yield from _apply_and_wait_for_voltages_to_settle(
+        mirror_config["stripe"], mirror_voltages
+    )
 
 
 def adjust_dcm_pitch_roll_vfm_from_lut(
@@ -86,13 +99,17 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     feedback from making unnecessary corrections while beam is being adjusted."""
 
     # Adjust DCM Pitch
-    dcm = undulator_dcm.dcm
+    dcm = undulator_dcm.dcm_ref()
     LOGGER.info(f"Adjusting DCM and VFM for {energy_kev} keV")
-    d_spacing_a: float = yield from bps.rd(undulator_dcm.dcm.crystal_metadata_d_spacing)
+    d_spacing_a: float = yield from bps.rd(
+        undulator_dcm.dcm_ref().crystal_metadata_d_spacing
+    )
     bragg_deg = energy_to_bragg_angle(energy_kev, d_spacing_a)
     LOGGER.info(f"Target Bragg angle = {bragg_deg} degrees")
     dcm_pitch_adjuster = lookup_table_adjuster(
-        linear_interpolation_lut(undulator_dcm.pitch_energy_table_path),
+        linear_interpolation_lut(
+            *parse_lookup_table(undulator_dcm.pitch_energy_table_path)
+        ),
         dcm.pitch_in_mrad,
         bragg_deg,
     )
@@ -102,38 +119,18 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
 
     # DCM Roll
     dcm_roll_adjuster = lookup_table_adjuster(
-        linear_interpolation_lut(undulator_dcm.roll_energy_table_path),
+        linear_interpolation_lut(
+            *parse_lookup_table(undulator_dcm.roll_energy_table_path)
+        ),
         dcm.roll_in_mrad,
         bragg_deg,
     )
     yield from dcm_roll_adjuster(DCM_GROUP)
     LOGGER.info("Waiting for DCM roll adjust to complete...")
 
-    # DCM Perp pitch
-    offset_mm = undulator_dcm.dcm_fixed_offset_mm
-    LOGGER.info(f"Adjusting DCM offset to {offset_mm} mm")
-    yield from bps.abs_set(dcm.offset_in_mm, offset_mm, group=DCM_GROUP)
-
     #
-    # Adjust mirrors
+    # Adjust vfm mirror stripe and mirror voltages
     #
 
-    # No need to change HFM
-
-    # Assumption is focus mode is already set to "sample"
-    # not sure how we check this
-
     # VFM Stripe selection
     yield from adjust_mirror_stripe(energy_kev, vfm, mirror_voltages)
-    yield from bps.wait(DCM_GROUP)
-
-    # VFM Adjust - for I03 this table always returns the same value
-    vfm_lut = vfm.bragg_to_lat_lookup_table_path
-    assert vfm_lut is not None
-    vfm_x_adjuster = lookup_table_adjuster(
-        linear_interpolation_lut(vfm_lut),
-        vfm.x_mm,
-        bragg_deg,
-    )
-    LOGGER.info("Waiting for VFM Lat (Horizontal Translation) to complete...")
-    yield from vfm_x_adjuster()

mx_bluesky/hyperion/device_setup_plans/manipulate_sample.py

@@ -9,7 +9,7 @@ from dodal.devices.backlight import Backlight, BacklightPosition
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.smargon import Smargon
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 LOWER_DETECTOR_SHUTTER_AFTER_SCAN = True
 
@@ -78,11 +78,11 @@ def move_x_y_z(
     axes are optional."""
 
     LOGGER.info(f"Moving smargon to x, y, z: {(x_mm, y_mm, z_mm)}")
-    if x_mm:
+    if x_mm is not None:
         yield from bps.abs_set(smargon.x, x_mm, group=group)
-    if y_mm:
+    if y_mm is not None:
         yield from bps.abs_set(smargon.y, y_mm, group=group)
-    if z_mm:
+    if z_mm is not None:
         yield from bps.abs_set(smargon.z, z_mm, group=group)
     if wait:
         yield from bps.wait(group)
@@ -100,11 +100,11 @@ def move_phi_chi_omega(
     axes are optional."""
 
     LOGGER.info(f"Moving smargon to phi, chi, omega: {(phi, chi, omega)}")
-    if phi:
+    if phi is not None:
         yield from bps.abs_set(smargon.phi, phi, group=group)
-    if chi:
+    if chi is not None:
         yield from bps.abs_set(smargon.chi, chi, group=group)
-    if omega:
+    if omega is not None:
         yield from bps.abs_set(smargon.omega, omega, group=group)
     if wait:
         yield from bps.wait(group)

mx_bluesky/hyperion/device_setup_plans/position_detector.py

@@ -1,7 +1,7 @@
 from bluesky import plan_stubs as bps
 from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 
 def set_detector_z_position(

mx_bluesky/hyperion/device_setup_plans/read_hardware_for_setup.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import bluesky.plan_stubs as bps
 from dodal.devices.aperturescatterguard import ApertureScatterguard
-from dodal.devices.attenuator import Attenuator
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.dcm import DCM
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
@@ -11,7 +11,7 @@ from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.undulator import Undulator
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 
 
@@ -39,7 +39,7 @@ def read_hardware_pre_collection(
 
 def read_hardware_during_collection(
     aperture_scatterguard: ApertureScatterguard,
-    attenuator: Attenuator,
+    attenuator: BinaryFilterAttenuator,
     flux: Flux,
     dcm: DCM,
     detector: EigerDetector,

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -7,6 +7,7 @@ import bluesky.plan_stubs as bps
 from bluesky.utils import MsgGenerator
 from dodal.common.beamlines.beamline_utils import get_path_provider
 from dodal.devices.fast_grid_scan import PandAGridScanParams
+from dodal.devices.smargon import Smargon
 from ophyd_async.core import load_device
 from ophyd_async.fastcs.panda import (
     HDFPanda,
@@ -15,7 +16,7 @@ from ophyd_async.fastcs.panda import (
 )
 
 import mx_bluesky.hyperion.resources.panda as panda_resource
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 MM_TO_ENCODER_COUNTS = 200000
 GENERAL_TIMEOUT = 60
@@ -114,7 +115,7 @@ def _get_seq_table(
 def setup_panda_for_flyscan(
     panda: HDFPanda,
     parameters: PandAGridScanParams,
-    initial_x: float,
+    smargon: Smargon,
     exposure_time_s: float,
     time_between_x_steps_ms: float,
     sample_velocity_mm_per_s: float,
@@ -127,7 +128,7 @@ def setup_panda_for_flyscan(
     Args:
         panda (HDFPanda): The PandA Ophyd device
         parameters (PandAGridScanParams): Grid parameters
-        initial_x (float): Motor positions at time of PandA setup
+        smargon (Smargon): The Smargon Ophyd device
         exposure_time_s (float): Detector exposure time per trigger
         time_between_x_steps_ms (float): Time, in ms, between each trigger. Equal to deadtime + exposure time
         sample_velocity_mm_per_s (float): Velocity of the sample in mm/s = x_step_size_mm * 1000 /
@@ -149,13 +150,29 @@ def setup_panda_for_flyscan(
     ) as config_yaml_path:
         yield from load_device(panda, str(config_yaml_path))
 
-    # Home the PandA X encoder using current motor position
+    initial_x = yield from bps.rd(smargon.x.user_readback)
+    initial_y = yield from bps.rd(smargon.y.user_readback)
+    initial_z = yield from bps.rd(smargon.z.user_readback)
+
+    # Home the PandA X, Y, and Z encoders using current motor position
     yield from bps.abs_set(
         panda.inenc[1].setp,  # type: ignore
         initial_x * MM_TO_ENCODER_COUNTS,
         wait=True,
     )
 
+    yield from bps.abs_set(
+        panda.inenc[2].setp,  # type: ignore
+        initial_y * MM_TO_ENCODER_COUNTS,
+        wait=True,
+    )
+
+    yield from bps.abs_set(
+        panda.inenc[3].setp,  # type: ignore
+        initial_z * MM_TO_ENCODER_COUNTS,
+        wait=True,
+    )
+
     yield from bps.abs_set(panda.pulse[1].width, exposure_time_s, group="panda-config")
 
     exposure_distance_mm = sample_velocity_mm_per_s * exposure_time_s

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -4,29 +4,19 @@ from functools import wraps
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 from bluesky.utils import MsgGenerator
-from dodal.devices.zebra import (
-    AUTO_SHUTTER_GATE,
-    AUTO_SHUTTER_INPUT_1,
-    AUTO_SHUTTER_INPUT_2,
-    DISCONNECT,
-    IN1_TTL,
-    IN3_TTL,
-    IN4_TTL,
-    PC_GATE,
-    PC_PULSE,
-    SOFT_IN1,
-    TTL_DETECTOR,
-    TTL_PANDA,
-    TTL_XSPRESS3,
+from dodal.devices.zebra.zebra import (
     ArmDemand,
     EncEnum,
     I03Axes,
     RotationDirection,
     Zebra,
 )
-from dodal.devices.zebra_controlled_shutter import ZebraShutter, ZebraShutterControl
+from dodal.devices.zebra.zebra_controlled_shutter import (
+    ZebraShutter,
+    ZebraShutterControl,
+)
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 ZEBRA_STATUS_TIMEOUT = 30
 
@@ -79,10 +69,9 @@ def set_shutter_auto_input(zebra: Zebra, input: int, group="set_shutter_trigger"
     Zebra's AND2 gate for this input. ZebraShutter control mode must be in auto for this input to take control
 
     For more details see the ZebraShutter device."""
-    auto_shutter_control = zebra.logic_gates.and_gates[AUTO_SHUTTER_GATE]
-    yield from bps.abs_set(
-        auto_shutter_control.sources[AUTO_SHUTTER_INPUT_2], input, group
-    )
+    auto_gate = zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER
+    auto_shutter_control = zebra.logic_gates.and_gates[auto_gate]
+    yield from bps.abs_set(auto_shutter_control.sources[2], input, group)
 
 
 def configure_zebra_and_shutter_for_auto_shutter(
@@ -102,11 +91,13 @@ def configure_zebra_and_shutter_for_auto_shutter(
         zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
     )
 
+    auto_gate = zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER
+
     # Set first input of AND2 gate to SOFT_IN1, which is high when shutter is in auto mode
     # Note the Zebra should ALWAYS be setup this way. See https://github.com/DiamondLightSource/mx-bluesky/issues/551
     yield from bps.abs_set(
-        zebra.logic_gates.and_gates[AUTO_SHUTTER_GATE].sources[AUTO_SHUTTER_INPUT_1],
-        SOFT_IN1,
+        zebra.logic_gates.and_gates[auto_gate].sources[1],
+        zebra.mapping.sources.SOFT_IN1,
         group=group,
     )
 
@@ -147,6 +138,7 @@ def setup_zebra_for_rotation(
         group:              A name for the group of statuses generated
         wait:               Block until all the settings have completed
     """
+
     if not isinstance(direction, RotationDirection):
         raise ValueError(
             "Disallowed rotation direction provided to Zebra setup plan. "
@@ -171,13 +163,23 @@ def setup_zebra_for_rotation(
     yield from bps.abs_set(zebra.pc.gate_trigger, axis.value, group=group)
     # Set shutter to automatic and to trigger via PC_GATE
     yield from configure_zebra_and_shutter_for_auto_shutter(
-        zebra, zebra_shutter, PC_GATE, group=group
+        zebra, zebra_shutter, zebra.mapping.sources.PC_GATE, group=group
     )
     # Trigger the detector with a pulse
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], PC_PULSE, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR],
+        zebra.mapping.sources.PC_PULSE,
+        group=group,
+    )
     # Don't use the fluorescence detector
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_XSPRESS3], DISCONNECT, group=group)
-    yield from bps.abs_set(zebra.output.pulse_1.input, DISCONNECT, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_XSPRESS3],
+        zebra.mapping.sources.DISCONNECT,
+        group=group,
+    )
+    yield from bps.abs_set(
+        zebra.output.pulse_1.input, zebra.mapping.sources.DISCONNECT, group=group
+    )
     LOGGER.info(f"ZEBRA SETUP: END - {'' if wait else 'not'} waiting for completion")
     if wait:
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
@@ -192,12 +194,22 @@ def setup_zebra_for_gridscan(
 ):
     # Set shutter to automatic and to trigger via motion controller GPIO signal (IN4_TTL)
     yield from configure_zebra_and_shutter_for_auto_shutter(
-        zebra, zebra_shutter, IN4_TTL, group=group
+        zebra, zebra_shutter, zebra.mapping.sources.IN4_TTL, group=group
     )
 
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], IN3_TTL, group=group)
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_XSPRESS3], DISCONNECT, group=group)
-    yield from bps.abs_set(zebra.output.pulse_1.input, DISCONNECT, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR],
+        zebra.mapping.sources.IN3_TTL,
+        group=group,
+    )
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_XSPRESS3],
+        zebra.mapping.sources.DISCONNECT,
+        group=group,
+    )
+    yield from bps.abs_set(
+        zebra.output.pulse_1.input, zebra.mapping.sources.DISCONNECT, group=group
+    )
 
     if wait:
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
@@ -210,11 +222,15 @@ def tidy_up_zebra_after_gridscan(
     group="tidy_up_zebra_after_gridscan",
     wait=True,
 ) -> MsgGenerator:
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], PC_PULSE, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR],
+        zebra.mapping.sources.PC_PULSE,
+        group=group,
+    )
     yield from bps.abs_set(
         zebra_shutter.control_mode, ZebraShutterControl.MANUAL, group=group
     )
-    yield from set_shutter_auto_input(zebra, PC_GATE, group=group)
+    yield from set_shutter_auto_input(zebra, zebra.mapping.sources.PC_GATE, group=group)
 
     if wait:
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
@@ -228,17 +244,27 @@ def setup_zebra_for_panda_flyscan(
     wait=True,
 ):
     # Forwards eiger trigger signal from panda
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_DETECTOR], IN1_TTL, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR],
+        zebra.mapping.sources.IN1_TTL,
+        group=group,
+    )
 
     # Set shutter to automatic and to trigger via motion controller GPIO signal (IN4_TTL)
     yield from configure_zebra_and_shutter_for_auto_shutter(
-        zebra, zebra_shutter, IN4_TTL, group=group
+        zebra, zebra_shutter, zebra.mapping.sources.IN4_TTL, group=group
     )
 
-    yield from bps.abs_set(zebra.output.out_pvs[TTL_XSPRESS3], DISCONNECT, group=group)
+    yield from bps.abs_set(
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_XSPRESS3],
+        zebra.mapping.sources.DISCONNECT,
+        group=group,
+    )
 
     yield from bps.abs_set(
-        zebra.output.out_pvs[TTL_PANDA], IN3_TTL, group=group
+        zebra.output.out_pvs[zebra.mapping.outputs.TTL_PANDA],
+        zebra.mapping.sources.IN3_TTL,
+        group=group,
     )  # Tells panda that motion is beginning/changing direction
 
     if wait:

mx_bluesky/hyperion/device_setup_plans/smargon.py

@@ -2,17 +2,17 @@ import numpy as np
 from bluesky import plan_stubs as bps
 from dodal.devices.smargon import Smargon
 
-from mx_bluesky.hyperion.exceptions import WarningException
+from mx_bluesky.common.utils.exceptions import SampleException
 
 
 def move_smargon_warn_on_out_of_range(
     smargon: Smargon, position: np.ndarray | list[float] | tuple[float, float, float]
 ):
-    """Throws a WarningException if the specified position is out of range for the
+    """Throws a SampleException if the specified position is out of range for the
     smargon. Otherwise moves to that position."""
     limits = yield from smargon.get_xyz_limits()
     if not limits.position_valid(position):
-        raise WarningException(
+        raise SampleException(
             "Pin tip centring failed - pin too long/short/bent and out of range"
         )
     yield from bps.mv(

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -9,7 +9,9 @@ from dodal.devices.detector import (
 )
 from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 from dodal.devices.eiger import EigerDetector
+from dodal.devices.i03.beamstop import Beamstop
 
+from mx_bluesky.hyperion.device_setup_plans.check_beamstop import check_beamstop
 from mx_bluesky.hyperion.device_setup_plans.position_detector import (
     set_detector_z_position,
     set_shutter,
@@ -24,6 +26,7 @@ def fill_in_energy_if_not_supplied(dcm: DCM, detector_params: DetectorParams):
 
 
 def start_preparing_data_collection_then_do_plan(
+    beamstop: Beamstop,
     eiger: EigerDetector,
     detector_motion: DetectorMotion,
     detector_distance_mm: float | None,
@@ -49,6 +52,7 @@ def start_preparing_data_collection_then_do_plan(
         yield from set_shutter(detector_motion, ShutterState.OPEN, group)
         yield from plan_to_run
 
+    yield from check_beamstop(beamstop)
     yield from bpp.contingency_wrapper(
         wrapped_plan(),
         except_plan=lambda e: (yield from bps.stop(eiger)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809

mx_bluesky/hyperion/device_setup_plans/xbpm_feedback.py

@@ -1,15 +1,15 @@
 from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper
 from bluesky.utils import make_decorator
-from dodal.devices.attenuator import Attenuator
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.xbpm_feedback import Pause, XBPMFeedback
 
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 
 
 def _check_and_pause_feedback(
     xbpm_feedback: XBPMFeedback,
-    attenuator: Attenuator,
+    attenuator: BinaryFilterAttenuator,
     desired_transmission_fraction: float,
 ):
     """Checks that the xbpm is in position before then turning it off and setting a new
@@ -18,7 +18,7 @@ def _check_and_pause_feedback(
     Args:
         xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
                                       the beam in position
-        attenuator (Attenuator): The attenuator used to set transmission
+        attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
         desired_transmission_fraction (float): The desired transmission to set after
                                                turning XBPM feedback off.
 
@@ -34,7 +34,7 @@ def _check_and_pause_feedback(
 
 
 def _unpause_xbpm_feedback_and_set_transmission_to_1(
-    xbpm_feedback: XBPMFeedback, attenuator: Attenuator
+    xbpm_feedback: XBPMFeedback, attenuator: BinaryFilterAttenuator
 ):
     """Turns the XBPM feedback back on and sets transmission to 1 so that it keeps the
     beam aligned whilst not collecting.
@@ -42,7 +42,7 @@ def _unpause_xbpm_feedback_and_set_transmission_to_1(
     Args:
         xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
                                       the beam in position
-        attenuator (Attenuator): The attenuator used to set transmission
+        attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
     """
     yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
@@ -50,7 +50,7 @@ def _unpause_xbpm_feedback_and_set_transmission_to_1(
 def transmission_and_xbpm_feedback_for_collection_wrapper(
     plan,
     xbpm_feedback: XBPMFeedback,
-    attenuator: Attenuator,
+    attenuator: BinaryFilterAttenuator,
     desired_transmission_fraction: float,
 ):
     """Sets the transmission for the data collection, ensuring the xbpm feedback is valid
@@ -70,7 +70,7 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
         plan: The plan performing the data collection
         xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
                                       the beam in position
-        attenuator (Attenuator): The attenuator used to set transmission
+        attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
         desired_transmission_fraction (float): The desired transmission for the collection
     """
 

mx_bluesky/hyperion/experiment_plans/change_aperture_then_move_plan.py

@@ -4,18 +4,18 @@ import numpy
 from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.smargon import Smargon, StubPosition
 
+from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.tracing import TRACER
 from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import move_x_y_z
 from mx_bluesky.hyperion.experiment_plans.common.xrc_result import XRayCentreResult
-from mx_bluesky.hyperion.log import LOGGER
-from mx_bluesky.hyperion.parameters.gridscan import HyperionThreeDGridScan
+from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
 
 
 def change_aperture_then_move_to_xtal(
     best_hit: XRayCentreResult,
     smargon: Smargon,
     aperture_scatterguard: ApertureScatterguard,
-    parameters: HyperionThreeDGridScan | None = None,
+    parameters: HyperionSpecifiedThreeDGridScan | None = None,
 ):
     """For the given x-ray centring result,
     * Change the aperture so that the beam size is comparable to the crystal size
@@ -26,8 +26,9 @@ def change_aperture_then_move_to_xtal(
             best_hit.bounding_box_mm[1] - best_hit.bounding_box_mm[0]
         )
         with TRACER.start_span("change_aperture"):
-            yield from _set_aperture_for_bbox_mm(
-                aperture_scatterguard, bounding_box_size
+            yield from set_aperture_for_bbox_mm(
+                aperture_scatterguard,
+                bounding_box_size,
             )
     else:
         LOGGER.warning("No bounding box size received")
@@ -49,25 +50,35 @@ def change_aperture_then_move_to_xtal(
         )
 
 
-def _set_aperture_for_bbox_mm(
-    aperture_device: ApertureScatterguard, bbox_size_mm: list[float] | numpy.ndarray
+def set_aperture_for_bbox_mm(
+    aperture_device: ApertureScatterguard,
+    bbox_size_mm: list[float] | numpy.ndarray,
 ):
-    # TODO confirm correction factor see https://github.com/DiamondLightSource/mx-bluesky/issues/618
-    ASSUMED_BOX_SIZE_MM = 0.020
-    bbox_size_boxes = [round(mm / ASSUMED_BOX_SIZE_MM) for mm in bbox_size_mm]
-    yield from set_aperture_for_bbox_size(aperture_device, bbox_size_boxes)
+    """Sets aperture size based on bbox_size.
 
+    This function determines the aperture size needed to accomodate the bounding box
+    of a crystal. The x-axis length of the bounding box is used, setting the aperture
+    to Medium if this is less than 50um, and Large otherwise.
+
+    Args:
+        aperture_device: The aperture scatter gaurd device we are controlling.
+        bbox_size_mm: The [x,y,z] lengths, in mm, of a bounding box
+        containing a crystal. This describes (in no particular order):
+        * The maximum width a crystal occupies
+        * The maximum height a crystal occupies
+        * The maximum depth a crystal occupies
+        constructing a three dimensional cuboid, completely encapsulating the crystal.
+
+    Yields:
+        Iterator[MsgGenerator]
+    """
 
-def set_aperture_for_bbox_size(
-    aperture_device: ApertureScatterguard,
-    bbox_size: list[int] | numpy.ndarray,
-):
     # bbox_size is [x,y,z], for i03 we only care about x
     new_selected_aperture = (
-        ApertureValue.MEDIUM if bbox_size[0] < 2 else ApertureValue.LARGE
+        ApertureValue.MEDIUM if bbox_size_mm[0] < 0.05 else ApertureValue.LARGE
     )
     LOGGER.info(
-        f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size}."
+        f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size_mm}."
     )
 
     @bpp.set_run_key_decorator("change_aperture")

mx_bluesky/hyperion/experiment_plans/common/xrc_result.py

@@ -14,7 +14,16 @@ from mx_bluesky.common.parameters.components import (
 
 @dataclasses.dataclass
 class XRayCentreResult:
-    """Represents information about a hit from an X-ray centring."""
+    """
+    Represents information about a hit from an X-ray centring.
+
+    Attributes:
+        centre_of_mass_mm: coordinates in mm of the centre of mass
+        bounding_box_mm: coordinates in mm of opposite corners of the bounding box
+            containing the crystal
+        max_count: The maximum spot count encountered in any one grid box in the crystal
+        total_count: The total count across all boxes in the crystal.
+    """
 
     centre_of_mass_mm: np.ndarray
     bounding_box_mm: tuple[np.ndarray, np.ndarray]