mx-bluesky 1.4.6__py3-none-any.whl → 1.4.7__py3-none-any.whl

mx_bluesky/common/external_interaction/callbacks/xray_centre/ispyb_callback.py

@@ -29,6 +29,7 @@ from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_mapping
 )
 from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGridInfo,
+    DataCollectionGroupInfo,
     DataCollectionInfo,
     DataCollectionPositionInfo,
     Orientation,
@@ -52,6 +53,9 @@ from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_
 if TYPE_CHECKING:
     from event_model import Event, RunStart, RunStop
 
+T = TypeVar("T", bound="GridCommon")
+ASSERT_START_BEFORE_EVENT_DOC_MESSAGE = f"No data collection group info - event document has been emitted before a {PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN} start document"
+
 
 def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
     return bpp.set_run_key_wrapper(
@@ -67,9 +71,6 @@ def ispyb_activation_wrapper(plan_generator: MsgGenerator, parameters):
     )
 
 
-T = TypeVar("T", bound="GridCommon")
-
-
 class GridscanISPyBCallback(BaseISPyBCallback):
     """Callback class to handle the deposition of experiment parameters into the ISPyB
     database. Listens for 'event' and 'descriptor' documents. Creates the ISpyB entry on
@@ -97,6 +98,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         self.param_type = param_type
         self._start_of_fgs_uid: str | None = None
         self._processing_start_time: float | None = None
+        self.data_collection_group_info: DataCollectionGroupInfo | None
 
     def activity_gated_start(self, doc: RunStart):
         if doc.get("subplan_name") == PlanNameConstants.DO_FGS:
@@ -111,7 +113,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             assert isinstance(mx_bluesky_parameters, str)
             self.params = self.param_type.model_validate_json(mx_bluesky_parameters)
             self.ispyb = StoreInIspyb(self.ispyb_config)
-            data_collection_group_info = populate_data_collection_group(self.params)
+            self.data_collection_group_info = populate_data_collection_group(
+                self.params
+            )
 
             scan_data_infos = [
                 ScanDataInfo(
@@ -135,12 +139,13 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             ]
 
             self.ispyb_ids = self.ispyb.begin_deposition(
-                data_collection_group_info, scan_data_infos
+                self.data_collection_group_info, scan_data_infos
             )
             set_dcgid_tag(self.ispyb_ids.data_collection_group_id)
         return super().activity_gated_start(doc)
 
     def activity_gated_event(self, doc: Event):
+        assert self.data_collection_group_info, ASSERT_START_BEFORE_EVENT_DOC_MESSAGE
         doc = super().activity_gated_event(doc)
 
         descriptor_name = self.descriptors[doc["descriptor"]].get("name")
@@ -151,10 +156,14 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             self.ispyb_ids = self.ispyb.update_deposition(
                 self.ispyb_ids, scan_data_infos
             )
+        self.ispyb.update_data_collection_group_table(
+            self.data_collection_group_info, self.ispyb_ids.data_collection_group_id
+        )
 
         return doc
 
     def _handle_zocalo_read_event(self, doc):
+        assert self.data_collection_group_info, ASSERT_START_BEFORE_EVENT_DOC_MESSAGE
         crystal_summary = ""
         if self._processing_start_time is not None:
             proc_time = time() - self._processing_start_time
@@ -185,6 +194,11 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         assert self.ispyb_ids.data_collection_ids, (
             "No data collection to add results to"
         )
+
+        self.data_collection_group_info.comments = (
+            self.data_collection_group_info.comments or ""
+        ) + crystal_summary
+
         self.ispyb.append_to_comment(
             self.ispyb_ids.data_collection_ids[0], crystal_summary
         )
@@ -192,6 +206,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
     def _handle_oav_grid_snapshot_triggered(self, doc) -> Sequence[ScanDataInfo]:
         assert self.ispyb_ids.data_collection_ids, "No current data collection"
         assert self.params, "ISPyB handler didn't receive parameters!"
+        assert self.data_collection_group_info, "No data collection group"
         data = doc["data"]
         data_collection_id = None
         data_collection_info = DataCollectionInfo(
@@ -220,6 +235,18 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         data_collection_info.comments = construct_comment_for_gridscan(
             data_collection_grid_info
         )
+
+        if self.data_collection_group_info.comments:
+            self.data_collection_group_info.comments += (
+                f"by {data_collection_grid_info.steps_y}."
+            )
+        else:
+            self.data_collection_group_info.comments = (
+                f"Diffraction grid scan of "
+                f"{data_collection_grid_info.steps_x} "
+                f"by {data_collection_grid_info.steps_y} "
+            )
+
         if len(self.ispyb_ids.data_collection_ids) > self._oav_snapshot_event_idx:
             data_collection_id = self.ispyb_ids.data_collection_ids[
                 self._oav_snapshot_event_idx
@@ -275,6 +302,9 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         return scan_data_infos
 
     def activity_gated_stop(self, doc: RunStop) -> RunStop:
+        assert self.data_collection_group_info, (
+            f"No data collection group info - stop document has been emitted before a {PlanNameConstants.GRID_DETECT_AND_DO_GRIDSCAN} start document"
+        )
         if doc.get("run_start") == self._start_of_fgs_uid:
             self._processing_start_time = time()
         if doc.get("run_start") == self.uid_to_finalize_on:
@@ -289,5 +319,11 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             )
             if exception_type:
                 doc["reason"] = message
+                self.data_collection_group_info.comments = message
+                self.ispyb.update_data_collection_group_table(
+                    self.data_collection_group_info,
+                    self.ispyb_ids.data_collection_group_id,
+                )
+            self.data_collection_group_info = None
             return super().activity_gated_stop(doc)
         return self._tag_doc(doc)

mx_bluesky/common/external_interaction/callbacks/xray_centre/nexus_callback.py

@@ -79,7 +79,8 @@ class GridscanNexusFileCallback(PlanReactiveCallback):
         self.descriptors[doc["uid"]] = doc
 
     def activity_gated_event(self, doc: Event) -> Event | None:
-        assert (event_descriptor := self.descriptors.get(doc["descriptor"])) is not None
+        event_descriptor = self.descriptors.get(doc["descriptor"])
+        assert event_descriptor is not None
         if event_descriptor.get("name") == DocDescriptorNames.HARDWARE_READ_DURING:
             data = doc["data"]
             for nexus_writer in [self.nexus_writer_1, self.nexus_writer_2]:

mx_bluesky/common/external_interaction/ispyb/data_model.py

@@ -13,6 +13,7 @@ class DataCollectionGroupInfo:
     experiment_type: str
     sample_id: int | None
     sample_barcode: str | None = None
+    comments: str | None = None
 
 
 @dataclass(kw_only=True)

mx_bluesky/common/external_interaction/ispyb/ispyb_store.py

@@ -77,7 +77,7 @@ class StoreInIspyb:
         scan_data_infos,
     ) -> IspybIds:
         with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
-            assert conn is not None, "Failed to connect to ISPyB"
+            assert conn, "Failed to connect to ISPyB"
             if data_collection_group_info:
                 ispyb_ids.data_collection_group_id = (
                     self._store_data_collection_group_table(
@@ -152,6 +152,19 @@ class StoreInIspyb:
                 data_collection_id, comment, delimiter
             )
 
+    def update_data_collection_group_table(
+        self,
+        dcg_info: DataCollectionGroupInfo,
+        data_collection_group_id: int | None = None,
+    ) -> None:
+        with ispyb.open(self.ISPYB_CONFIG_PATH) as conn:
+            assert conn is not None, "Failed to connect to ISPyB!"
+            self._store_data_collection_group_table(
+                conn,
+                dcg_info,
+                data_collection_group_id,
+            )
+
     def _update_scan_with_end_time_and_status(
         self,
         end_time: str,

mx_bluesky/common/external_interaction/nexus/nexus_utils.py

@@ -144,7 +144,7 @@ def create_detector_parameters(detector_params: DetectorParams) -> Detector:
         list(
             detector_params.get_beam_position_pixels(detector_params.detector_distance)
         ),
-        detector_params.exposure_time,
+        detector_params.exposure_time_s,
         [(-1.0, 0.0, 0.0), (0.0, -1.0, 0.0)],
     )
 

mx_bluesky/common/parameters/constants.py

@@ -58,6 +58,8 @@ class PlanNameConstants:
     ROTATION_OUTER = "rotation_scan_with_cleanup"
     ROTATION_MAIN = "rotation_scan_main"
     FLYSCAN_RESULTS = "xray_centre_results"
+    SET_ENERGY = "set_energy"
+    UNNAMED_RUN = "unnamed_run"
 
 
 @dataclass(frozen=True)

mx_bluesky/common/parameters/gridscan.py

@@ -168,7 +168,7 @@ class SpecifiedThreeDGridScan(
                 get_beamline_name("dev")
             ],
             expected_energy_ev=self.demand_energy_ev,
-            exposure_time=self.exposure_time_s,
+            exposure_time_s=self.exposure_time_s,
             directory=self.storage_directory,
             prefix=self.file_name,
             detector_distance=self.detector_distance_mm,

mx_bluesky/common/plans/write_sample_status.py

@@ -0,0 +1,46 @@
+from enum import StrEnum
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+
+from mx_bluesky.common.external_interaction.callbacks.sample_handling.sample_handling_callback import (
+    SampleHandlingCallback,
+)
+from mx_bluesky.common.utils.exceptions import SampleException
+
+
+class SampleStatusExceptionType(StrEnum):
+    BEAMLINE = "Beamline"
+    SAMPLE = "Sample"
+
+
+@bpp.subs_decorator(SampleHandlingCallback())
+def deposit_sample_error(exception_type: SampleStatusExceptionType, sample_id: int):
+    @bpp.run_decorator(
+        md={
+            "metadata": {"sample_id": sample_id},
+            "activate_callbacks": ["SampleHandlingCallback"],
+        }
+    )
+    def _inner():
+        yield from bps.null()
+        if exception_type == SampleStatusExceptionType.BEAMLINE:
+            raise AssertionError()
+        elif exception_type == SampleStatusExceptionType.SAMPLE:
+            raise SampleException
+
+    yield from _inner()
+
+
+@bpp.subs_decorator(SampleHandlingCallback(record_loaded_on_success=True))
+def deposit_loaded_sample(sample_id: int):
+    @bpp.run_decorator(
+        md={
+            "metadata": {"sample_id": sample_id},
+            "activate_callbacks": ["SampleHandlingCallback"],
+        }
+    )
+    def _inner():
+        yield from bps.null()
+
+    yield from _inner()

mx_bluesky/common/preprocessors/preprocessors.py

@@ -0,0 +1,105 @@
+from bluesky import preprocessors as bpp
+from bluesky.preprocessors import plan_mutator
+from bluesky.utils import Msg, MsgGenerator, make_decorator
+
+from mx_bluesky.common.device_setup_plans.xbpm_feedback import (
+    check_and_pause_feedback,
+    unpause_xbpm_feedback_and_set_transmission_to_1,
+)
+from mx_bluesky.common.parameters.constants import PlanNameConstants
+from mx_bluesky.common.protocols.protocols import (
+    XBPMPauseDevices,
+)
+
+
+def transmission_and_xbpm_feedback_for_collection_wrapper(
+    plan: MsgGenerator,
+    devices: XBPMPauseDevices,
+    desired_transmission_fraction: float,
+    run_key_to_wrap: PlanNameConstants | None = None,
+):
+    """
+    Sets the transmission for the data collection, ensuring the xbpm feedback is valid, then resets it immediately after
+    the run has finished.
+
+    This wrapper should be attached to the entry point of any beamline-specific plan that may disrupt the XBPM feedback,
+    such as a data collection or an x-ray center grid scan.
+    This wrapper will do nothing if no runs are seen.
+
+    XBPM feedback isn't reliable during collections due to:
+     * Objects (e.g. attenuator) crossing the beam can cause large (incorrect) feedback movements
+     * Lower transmissions/higher energies are less reliable for the xbpm
+
+    So we need to keep the transmission at 100% and the feedback on when not collecting
+    and then turn it off and set the correct transmission for collection. The feedback
+    mostly accounts for slow thermal drift so it is safe to assume that the beam is
+    stable during a collection.
+
+    Args:
+        plan: The plan performing the data collection.
+        devices (XBPMPauseDevices): Composite device including The XBPM device that is responsible for keeping
+                                                        the beam in position, and attenuator
+        desired_transmission_fraction (float): The desired transmission for the collection
+        run_key_to_wrap: (str | None): Pausing XBPM and setting transmission is inserted after the 'open_run' message is seen with
+        the matching run key, and unpausing and resetting transmission is inserted after the corresponding 'close_run' message is
+        seen. If not specified, instead wrap the first run encountered.
+    """
+
+    _wrapped_run_name: None | str = None
+
+    def head(msg: Msg):
+        yield from check_and_pause_feedback(
+            devices.xbpm_feedback,
+            devices.attenuator,
+            desired_transmission_fraction,
+        )
+
+        # Allow 'open_run' message to pass through
+        yield msg
+
+    def tail():
+        yield from unpause_xbpm_feedback_and_set_transmission_to_1(
+            devices.xbpm_feedback, devices.attenuator
+        )
+
+    def insert_plans(msg: Msg):
+        # Wrap the specified run, or, if none specified, wrap the first run encountered
+        nonlocal _wrapped_run_name
+
+        match msg.command:
+            case "open_run":
+                # If we specified a run key, did we encounter it
+                # If we didn't specify, then insert the plans and track the name of the run
+                if (
+                    not (run_key_to_wrap or _wrapped_run_name)
+                    or run_key_to_wrap is msg.run
+                ):
+                    _wrapped_run_name = msg.run if msg.run else "unnamed_run"
+                    return head(msg), None
+            case "close_run":
+                # Check if the run tracked from above was closed
+                # An exception is raised in the RunEngine if two unnamed runs are opened
+                # at the same time, so we are safe from unpausing on the wrong run
+                if (_wrapped_run_name == "unnamed_run" and not msg.run) or (
+                    msg.run and _wrapped_run_name and _wrapped_run_name is msg.run
+                ):
+                    return None, tail()
+
+        return None, None
+
+    # Contingency wrapper can cause unpausing to occur on exception and again on close_run.
+    # Not needed after https://github.com/bluesky/bluesky/issues/1891
+    return (
+        yield from bpp.contingency_wrapper(
+            plan_mutator(plan, insert_plans),
+            except_plan=lambda _: unpause_xbpm_feedback_and_set_transmission_to_1(
+                devices.xbpm_feedback,
+                devices.attenuator,
+            ),
+        )
+    )
+
+
+transmission_and_xbpm_feedback_for_collection_decorator = make_decorator(
+    transmission_and_xbpm_feedback_for_collection_wrapper
+)

mx_bluesky/common/protocols/protocols.py

@@ -0,0 +1,10 @@
+from typing import Protocol, runtime_checkable
+
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.xbpm_feedback import XBPMFeedback
+
+
+@runtime_checkable
+class XBPMPauseDevices(Protocol):
+    xbpm_feedback: XBPMFeedback
+    attenuator: BinaryFilterAttenuator

mx_bluesky/hyperion/__main__.py

@@ -16,9 +16,6 @@ from flask import Flask, request
 from flask_restful import Api, Resource
 from pydantic.dataclasses import dataclass
 
-from mx_bluesky.common.external_interaction.callbacks.common.aperture_change_callback import (
-    ApertureChangeCallback,
-)
 from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callback import (
     LogUidTaggingCallback,
 )
@@ -39,6 +36,7 @@ from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PlanNotFound,
 )
 from mx_bluesky.hyperion.external_interaction.agamemnon import (
+    compare_params,
     update_params_from_agamemnon,
 )
 from mx_bluesky.hyperion.parameters.cli import parse_cli_args
@@ -89,13 +87,11 @@ class BlueskyRunner:
         self.command_queue: Queue[Command] = Queue()
         self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
         self.last_run_aborted: bool = False
-        self.aperture_change_callback = ApertureChangeCallback()
         self.logging_uid_tag_callback = LogUidTaggingCallback()
         self.context: BlueskyContext
 
         self.RE = RE
         self.context = context
-        RE.subscribe(self.aperture_change_callback)
         RE.subscribe(self.logging_uid_tag_callback)
 
         LOGGER.info("Connecting to external callback ZMQ proxy...")
@@ -175,10 +171,7 @@ class BlueskyRunner:
                     with TRACER.start_span("do_run"):
                         self.RE(command.experiment(command.devices, command.parameters))
 
-                    self.current_status = StatusAndMessage(
-                        Status.IDLE,
-                        self.aperture_change_callback.last_selected_aperture,
-                    )
+                    self.current_status = StatusAndMessage(Status.IDLE)
 
                     self.last_run_aborted = False
                 except WarningException as exception:
@@ -212,6 +205,7 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
     try:
         parameters = experiment_internal_param_type(**json.loads(request.data))
         parameters = update_params_from_agamemnon(parameters)
+        compare_params(parameters)
         if parameters.model_extra:
             raise ValueError(f"Extra fields not allowed {parameters.model_extra}")
     except Exception as e:

mx_bluesky/hyperion/baton_handler.py

@@ -0,0 +1,84 @@
+from bluesky import plan_stubs as bps
+from bluesky import preprocessors as bpp
+from dodal.devices.baton import Baton
+
+from mx_bluesky.common.utils.exceptions import WarningException
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    LoadCentreCollectComposite,
+    load_centre_collect_full,
+)
+from mx_bluesky.hyperion.external_interaction.agamemnon import (
+    create_parameters_from_agamemnon,
+)
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+
+HYPERION_USER = "Hyperion"
+NO_USER = "None"
+
+
+def wait_for_hyperion_requested(baton: Baton):
+    SLEEP_PER_CHECK = 0.1
+    while True:
+        requested_user = yield from bps.rd(baton.requested_user)
+        if requested_user == HYPERION_USER:
+            break
+        yield from bps.sleep(SLEEP_PER_CHECK)
+
+
+def ignore_sample_errors(exception: Exception):
+    yield from bps.null()
+    # For sample errors we want to continue the loop
+    if not isinstance(exception, WarningException):
+        raise exception
+
+
+def main_hyperion_loop(baton: Baton, composite: LoadCentreCollectComposite):
+    requested_user = yield from bps.rd(baton.requested_user)
+    while requested_user == HYPERION_USER:
+
+        def inner_loop():
+            parameters: LoadCentreCollect | None = create_parameters_from_agamemnon()  # type: ignore # not complete until https://github.com/DiamondLightSource/mx-bluesky/issues/773
+            if parameters:
+                yield from load_centre_collect_full(composite, parameters)
+            else:
+                yield from bps.mv(baton.requested_user, NO_USER)
+
+        yield from bpp.contingency_wrapper(
+            inner_loop(), except_plan=ignore_sample_errors, auto_raise=False
+        )
+        requested_user = yield from bps.rd(baton.requested_user)
+
+
+def move_to_default_state():
+    # To be filled in in https://github.com/DiamondLightSource/mx-bluesky/issues/396
+    yield from bps.null()
+
+
+def run_udc_when_requested(baton: Baton, composite: LoadCentreCollectComposite):
+    """This will wait for the baton to be handed to hyperion and then run through the
+    UDC queue from agamemnon until:
+      1. There are no more instructions from agamemnon
+      2. There is an error on the beamline
+      3. The baton is requested by another party
+
+    In the case of 1. or 2. hyperion will immediately release the baton. In the case of
+    3. the baton will be released after the next collection has finished."""
+
+    yield from wait_for_hyperion_requested(baton)
+    yield from bps.abs_set(baton.current_user, HYPERION_USER)
+
+    def default_state_then_collect():
+        yield from move_to_default_state()
+        yield from main_hyperion_loop(baton, composite)
+
+    def release_baton():
+        # If hyperion has given up the baton itself we need to also release requested
+        # user so that hyperion doesn't think we're requested again
+        requested_user = yield from bps.rd(baton.requested_user)
+        if requested_user == HYPERION_USER:
+            yield from bps.abs_set(baton.requested_user, NO_USER)
+        yield from bps.abs_set(baton.current_user, NO_USER)
+
+    yield from bpp.contingency_wrapper(
+        default_state_then_collect(), final_plan=release_baton
+    )

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -1,10 +1,12 @@
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
+from typing import cast
 
 import bluesky.plan_stubs as bps
 from bluesky.utils import MsgGenerator
 from dodal.common.beamlines.beamline_utils import get_path_provider
+from dodal.common.types import UpdatingPathProvider
 from dodal.devices.fast_grid_scan import PandAGridScanParams
 from dodal.devices.smargon import Smargon
 from ophyd_async.fastcs.panda import (
@@ -222,6 +224,8 @@ def set_panda_directory(panda_directory: Path) -> MsgGenerator:
     suffix = datetime.now().strftime("_%Y%m%d%H%M%S")
 
     async def set_panda_dir():
-        await get_path_provider().update(directory=panda_directory, suffix=suffix)
+        await cast(UpdatingPathProvider, get_path_provider()).update(
+            directory=panda_directory, suffix=suffix
+        )
 
     yield from bps.wait_for([set_panda_dir])

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -15,9 +15,6 @@ from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
 from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
     pin_tip_centre_then_xray_centre,
 )
-from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
-    robot_load_then_centre,
-)
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     multi_rotation_scan,
     rotation_scan,
@@ -29,6 +26,5 @@ __all__ = [
     "rotation_scan",
     "pin_tip_centre_then_xray_centre",
     "multi_rotation_scan",
-    "robot_load_then_centre",
     "load_centre_collect_full",
 ]

mx_bluesky/hyperion/experiment_plans/change_aperture_then_move_plan.py

@@ -1,5 +1,4 @@
 import bluesky.plan_stubs as bps
-import bluesky.preprocessors as bpp
 import numpy
 from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.smargon import Smargon, StubPosition
@@ -21,17 +20,13 @@ def change_aperture_then_move_to_xtal(
     * Change the aperture so that the beam size is comparable to the crystal size
     * Centre on the centre-of-mass
     * Reset the stub offsets if specified by params"""
-    if best_hit.bounding_box_mm is not None:
-        bounding_box_size = numpy.abs(
-            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,
-            )
-    else:
-        LOGGER.warning("No bounding box size received")
+    bounding_box_size = numpy.abs(
+        best_hit.bounding_box_mm[1] - best_hit.bounding_box_mm[0]
+    )
+    yield from set_aperture_for_bbox_mm(
+        aperture_scatterguard,
+        bounding_box_size,
+    )
 
     # once we have the results, go to the appropriate position
     LOGGER.info("Moving to centre of mass.")
@@ -52,12 +47,12 @@ def set_aperture_for_bbox_mm(
 ):
     """Sets aperture size based on bbox_size.
 
-    This function determines the aperture size needed to accomodate the bounding box
+    This function determines the aperture size needed to accommodate 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.
+        aperture_device: The aperture scatter guard 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
@@ -77,14 +72,4 @@ def set_aperture_for_bbox_mm(
         f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size_mm}."
     )
 
-    @bpp.set_run_key_decorator("change_aperture")
-    @bpp.run_decorator(
-        md={
-            "subplan_name": "change_aperture",
-            "aperture_size": new_selected_aperture.value,
-        }
-    )
-    def set_aperture():
-        yield from bps.abs_set(aperture_device, new_selected_aperture)
-
-    yield from set_aperture()
+    yield from bps.abs_set(aperture_device, new_selected_aperture)

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -9,7 +9,6 @@ from mx_bluesky.hyperion.experiment_plans import (
     grid_detect_then_xray_centre_plan,
     load_centre_collect_full_plan,
     pin_centre_then_xray_centre_plan,
-    robot_load_then_centre_plan,
 )
 from mx_bluesky.hyperion.parameters.gridscan import (
     GridScanWithEdgeDetect,
@@ -17,7 +16,6 @@ from mx_bluesky.hyperion.parameters.gridscan import (
     PinTipCentreThenXrayCentre,
 )
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.parameters.robot_load import RobotLoadThenCentre
 from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan, RotationScan
 
 
@@ -38,7 +36,6 @@ class ExperimentRegistryEntry(TypedDict):
         | MultiRotationScan
         | PinTipCentreThenXrayCentre
         | LoadCentreCollect
-        | RobotLoadThenCentre
     ]
 
 
@@ -59,10 +56,6 @@ PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
         "setup": pin_centre_then_xray_centre_plan.create_devices,
         "param_type": PinTipCentreThenXrayCentre,
     },
-    "robot_load_then_centre": {
-        "setup": robot_load_then_centre_plan.create_devices,
-        "param_type": RobotLoadThenCentre,
-    },
     "multi_rotation_scan": {
         "setup": rotation_scan_plan.create_devices,
         "param_type": MultiRotationScan,