mx-bluesky 1.4.3__py3-none-any.whl → 1.4.5__py3-none-any.whl

mx_bluesky/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.4.3'
-__version_tuple__ = version_tuple = (1, 4, 3)
+__version__ = version = '1.4.5'
+__version_tuple__ = version_tuple = (1, 4, 5)

mx_bluesky/beamlines/i24/serial/fixed_target/i24ssx_moveonclick.py

@@ -215,6 +215,6 @@ def start_viewer(oav: OAV, pmac: PMAC, RE: RunEngine, oav1: str = OAV1_CAM):
 if __name__ == "__main__":
     RE = RunEngine(call_returns_result=True)
     # Get devices out of dodal
-    oav: OAV = i24.oav()
-    pmac: PMAC = i24.pmac()
+    oav: OAV = i24.oav(connect_immediately=True)
+    pmac: PMAC = i24.pmac(connect_immediately=True)
     start_viewer(oav, pmac, RE)

mx_bluesky/beamlines/i24/serial/setup_beamline/setup_beamline.py

@@ -21,9 +21,9 @@ from mx_bluesky.beamlines.i24.serial.setup_beamline.ca import caget, caput
 
 def get_beam_center_device(detector_in_use: str) -> DetectorBeamCenter:
     if detector_in_use == "eiger":
-        return i24.eiger_beam_center()
+        return i24.eiger_beam_center(connect_immediately=True)
     else:
-        return i24.pilatus_beam_center()
+        return i24.pilatus_beam_center(connect_immediately=True)
 
 
 def compute_beam_center_position_from_lut(

mx_bluesky/common/device_setup_plans/setup_panda.py

@@ -0,0 +1,9 @@
+from ophyd_async.core import YamlSettingsProvider
+from ophyd_async.fastcs.panda import HDFPanda
+from ophyd_async.plan_stubs import apply_panda_settings, retrieve_settings
+
+
+def load_panda_from_yaml(yaml_directory: str, yaml_file_name: str, panda: HDFPanda):
+    provider = YamlSettingsProvider(yaml_directory)
+    settings = yield from retrieve_settings(provider, yaml_file_name, panda)
+    yield from apply_panda_settings(settings)

mx_bluesky/common/external_interaction/callbacks/common/zocalo_callback.py

@@ -7,7 +7,6 @@ from dodal.devices.zocalo import ZocaloStartInfo, ZocaloTrigger
 
 from mx_bluesky.common.parameters.constants import (
     DocDescriptorNames,
-    TriggerConstants,
 )
 from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMade
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
@@ -30,27 +29,17 @@ class ZocaloCallback(CallbackBase):
 
     def _reset_state(self):
         self.run_uid: str | None = None
-        self.triggering_plan: str | None = None
-        self.zocalo_interactor: ZocaloTrigger | None = None
         self.zocalo_info: list[ZocaloStartInfo] = []
         self.descriptors: dict[str, EventDescriptor] = {}
 
-    def __init__(
-        self,
-    ):
+    def __init__(self, triggering_plan: str, zocalo_environment: str):
         super().__init__()
+        self.triggering_plan = triggering_plan
+        self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
         self._reset_state()
 
     def start(self, doc: RunStart):
         ISPYB_ZOCALO_CALLBACK_LOGGER.info("Zocalo handler received start document.")
-        if triggering_plan := doc.get(TriggerConstants.ZOCALO):
-            self.triggering_plan = triggering_plan
-            assert isinstance(zocalo_environment := doc.get("zocalo_environment"), str)
-            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
-                f"Zocalo environment set to {zocalo_environment}."
-            )
-            self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
-
         if self.triggering_plan and doc.get("subplan_name") == self.triggering_plan:
             self.run_uid = doc.get("uid")
             assert isinstance(scan_points := doc.get("scan_points"), list)
@@ -58,6 +47,7 @@ class ZocaloCallback(CallbackBase):
                 isinstance(ispyb_ids := doc.get("ispyb_dcids"), tuple)
                 and len(ispyb_ids) > 0
             ):
+                ISPYB_ZOCALO_CALLBACK_LOGGER.info(f"Zocalo triggering for {ispyb_ids}")
                 ids_and_shape = list(zip(ispyb_ids, scan_points, strict=False))
                 start_frame = 0
                 self.zocalo_info = []
@@ -82,7 +72,6 @@ class ZocaloCallback(CallbackBase):
             filename = doc["data"]["eiger_odin_file_writer_id"]
             for start_info in self.zocalo_info:
                 start_info.filename = filename
-                assert self.zocalo_interactor is not None
                 self.zocalo_interactor.run_start(start_info)
         return doc
 

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

@@ -43,7 +43,10 @@ from mx_bluesky.common.parameters.constants import DocDescriptorNames, PlanNameC
 from mx_bluesky.common.parameters.gridscan import (
     GridCommon,
 )
-from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMade
+from mx_bluesky.common.utils.exceptions import (
+    ISPyBDepositionNotMade,
+    SampleException,
+)
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_tag
 
 if TYPE_CHECKING:
@@ -281,5 +284,10 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             )
             if self.ispyb_ids == IspybIds():
                 raise ISPyBDepositionNotMade("ispyb was not initialised at run start")
+            exception_type, message = SampleException.type_and_message_from_reason(
+                doc.get("reason", "")
+            )
+            if exception_type:
+                doc["reason"] = message
             return super().activity_gated_stop(doc)
         return self._tag_doc(doc)

mx_bluesky/common/parameters/components.py

@@ -93,7 +93,6 @@ class IspybExperimentType(StrEnum):
 
 class MxBlueskyParameters(BaseModel):
     model_config = ConfigDict(
-        arbitrary_types_allowed=True,
         extra="allow",
     )
 

mx_bluesky/common/parameters/constants.py

@@ -1,3 +1,4 @@
+import os
 from enum import Enum
 
 from dodal.devices.aperturescatterguard import ApertureValue
@@ -6,6 +7,8 @@ from dodal.devices.zocalo.zocalo_constants import ZOCALO_ENV as ZOCALO_ENV_FROM_
 from dodal.utils import get_beamline_name
 from pydantic.dataclasses import dataclass
 
+from mx_bluesky.definitions import ROOT_DIR
+
 BEAMLINE = get_beamline_name("test")
 TEST_MODE = BEAMLINE == "test"
 
@@ -75,6 +78,10 @@ class HardwareConstants:
     THAWING_TIME = 20
     TIP_OFFSET_UM = 0
 
+    # Value quoted in https://www.dectris.com/en/detectors/x-ray-detectors/eiger2/eiger2-for-synchrotrons/eiger2-x/,
+    # causes dropped frames, so increase value for safety
+    PANDA_FGS_EIGER_DEADTIME_S = 5e-5
+
 
 @dataclass(frozen=True)
 class GridscanParamConstants:
@@ -118,6 +125,15 @@ class PlanGroupCheckpointConstants:
     READY_FOR_OAV = "ready_for_oav"
 
 
+# Eventually replace below with https://github.com/DiamondLightSource/mx-bluesky/issues/798
+@dataclass(frozen=True)
+class DeviceSettingsConstants:
+    PANDA_FLYSCAN_SETTINGS_FILENAME = "panda-gridscan"
+    PANDA_FLYSCAN_SETTINGS_DIR = os.path.abspath(
+        f"{ROOT_DIR}/hyperion/resources/panda/{PANDA_FLYSCAN_SETTINGS_FILENAME}"
+    )
+
+
 @dataclass(frozen=True)
 class SimConstants:
     BEAMLINE = "BL03S"

mx_bluesky/common/parameters/gridscan.py

@@ -29,8 +29,13 @@ class GridCommon(
     DiffractionExperimentWithSample,
     OptionalGonioAngleStarts,
 ):
-    """Parameters used in every MX diffraction experiment using grids. This model should be used by plans which have no knowledge of the grid specifications - i.e before automatic grid detection has completed"""
+    """
+    Parameters used in every MX diffraction experiment using grids. This model should
+    be used by plans which have no knowledge of the grid specifications - i.e before
+    automatic grid detection has completed
+    """
 
+    box_size_um: float = Field(default=GridscanParamConstants.BOX_WIDTH_UM)
     grid_width_um: float = Field(default=GridscanParamConstants.WIDTH_UM)
     exposure_time_s: float = Field(default=GridscanParamConstants.EXPOSURE_TIME_S)
 

mx_bluesky/common/plans/do_fgs.py

@@ -18,9 +18,7 @@ from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
     read_hardware_for_zocalo,
 )
 from mx_bluesky.common.parameters.constants import (
-    EnvironmentConstants,
     PlanNameConstants,
-    TriggerConstants,
 )
 from mx_bluesky.common.utils.tracing import TRACER
 
@@ -70,7 +68,6 @@ def kickoff_and_complete_gridscan(
     scan_points: list[AxesPoints[Axis]],
     scan_start_indices: list[int],
     plan_during_collection: Callable[[], MsgGenerator] | None = None,
-    zocalo_environment: str = EnvironmentConstants.ZOCALO_ENV,
 ):
     """Triggers a grid scan motion program and waits for completion, accounting for synchrotron topup.
     If the RunEngine is subscribed to ZocaloCallback, this plan will also trigger Zocalo.
@@ -86,7 +83,6 @@ def kickoff_and_complete_gridscan(
         scan_start_indices (list[int]):         Contains the first index of each grid scan
         plan_during_collection (Optional, MsgGenerator): Generic plan called in between kickoff and completion,
                                                 eg waiting on zocalo.
-        zocalo_environment (Optional, str)      Used for zocalo connection
     """
 
     assert len(scan_points) == len(scan_start_indices), (
@@ -100,10 +96,8 @@ def kickoff_and_complete_gridscan(
     @bpp.run_decorator(
         md={
             "subplan_name": plan_name,
-            TriggerConstants.ZOCALO: plan_name,
             "scan_points": scan_points,
             "scan_start_indices": scan_start_indices,
-            "zocalo_environment": zocalo_environment,
         }
     )
     @bpp.contingency_decorator(

mx_bluesky/common/utils/exceptions.py

@@ -39,7 +39,8 @@ T = TypeVar("T")
 class CrystalNotFoundException(SampleException):
     """Raised if grid detection completed normally but no crystal was found."""
 
-    pass
+    def __init__(self, *args):
+        super().__init__("Diffraction not found, skipping sample.")
 
 
 def catch_exception_and_warn(

mx_bluesky/definitions.py

@@ -0,0 +1,4 @@
+import os
+
+# Change once Python<3.12 is dropped - see https://github.com/DiamondLightSource/mx-bluesky/issues/798
+ROOT_DIR = os.path.dirname(os.path.abspath(__file__))

mx_bluesky/hyperion/__main__.py

@@ -4,6 +4,7 @@ import threading
 from collections.abc import Callable
 from dataclasses import asdict
 from queue import Queue
+from sys import argv
 from traceback import format_exception
 from typing import Any
 
@@ -37,12 +38,6 @@ from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
     PlanNotFound,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.__main__ import (
-    setup_logging as setup_callback_logging,
-)
-from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util import (
-    CallbacksFactory,
-)
 from mx_bluesky.hyperion.parameters.cli import parse_cli_args
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.utils.context import setup_context
@@ -56,7 +51,6 @@ class Command:
     devices: Any | None = None
     experiment: Callable[[Any, Any], MsgGenerator] | None = None
     parameters: MxBlueskyParameters | None = None
-    callbacks: CallbacksFactory | None = None
 
 
 @dataclass
@@ -88,7 +82,6 @@ class BlueskyRunner:
         RE: RunEngine,
         context: BlueskyContext,
         skip_startup_connection=False,
-        use_external_callbacks: bool = False,
     ) -> None:
         self.command_queue: Queue[Command] = Queue()
         self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
@@ -99,15 +92,12 @@ class BlueskyRunner:
 
         self.RE = RE
         self.context = context
-        self.subscribed_per_plan_callbacks: list[int] = []
         RE.subscribe(self.aperture_change_callback)
         RE.subscribe(self.logging_uid_tag_callback)
 
-        self.use_external_callbacks = use_external_callbacks
-        if self.use_external_callbacks:
-            LOGGER.info("Connecting to external callback ZMQ proxy...")
-            self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
-            RE.subscribe(self.publisher)
+        LOGGER.info("Connecting to external callback ZMQ proxy...")
+        self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
+        RE.subscribe(self.publisher)
 
         if VERBOSE_EVENT_LOGGING:
             RE.subscribe(VerbosePlanExecutionLoggingCallback())
@@ -123,7 +113,6 @@ class BlueskyRunner:
         experiment: Callable,
         parameters: MxBlueskyParameters,
         plan_name: str,
-        callbacks: CallbacksFactory | None,
     ) -> StatusAndMessage:
         LOGGER.info(f"Started with parameters: {parameters.model_dump_json(indent=2)}")
 
@@ -142,7 +131,6 @@ class BlueskyRunner:
                     devices=devices,
                     experiment=experiment,
                     parameters=parameters,
-                    callbacks=callbacks,
                 )
             )
             return StatusAndMessage(Status.SUCCESS)
@@ -181,17 +169,6 @@ class BlueskyRunner:
                 if command.experiment is None:
                     raise ValueError("No experiment provided for START")
                 try:
-                    if (
-                        not self.use_external_callbacks
-                        and command.callbacks
-                        and (cbs := command.callbacks())
-                    ):
-                        LOGGER.info(
-                            f"Using callbacks for this plan: {not self.use_external_callbacks} - {cbs}"
-                        )
-                        self.subscribed_per_plan_callbacks += [
-                            self.RE.subscribe(cb) for cb in cbs
-                        ]
                     with TRACER.start_span("do_run"):
                         self.RE(command.experiment(command.devices, command.parameters))
 
@@ -212,11 +189,6 @@ class BlueskyRunner:
                         self.last_run_aborted = False
                     else:
                         self.current_status = make_error_status_and_message(exception)
-                finally:
-                    [
-                        self.RE.unsubscribe(cb)
-                        for cb in self.subscribed_per_plan_callbacks
-                    ]
 
 
 def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
@@ -225,7 +197,6 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
         raise PlanNotFound(f"Experiment plan '{plan_name}' not found in registry.")
 
     experiment_internal_param_type = experiment_registry_entry.get("param_type")
-    callback_type = experiment_registry_entry.get("callback_collection_type")
     plan = context.plan_functions.get(plan_name)
     if experiment_internal_param_type is None:
         raise PlanNotFound(
@@ -243,7 +214,7 @@ def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions)
         raise ValueError(
             f"Supplied parameters don't match the plan for this endpoint {request.data}, for plan {plan_name}"
         ) from e
-    return plan, parameters, plan_name, callback_type
+    return plan, parameters, plan_name
 
 
 class RunExperiment(Resource):
@@ -256,12 +227,10 @@ class RunExperiment(Resource):
         status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
         if action == Actions.START.value:
             try:
-                plan, params, plan_name, callback_type = compose_start_args(
+                plan, params, plan_name = compose_start_args(
                     self.context, plan_name, action
                 )
-                status_and_message = self.runner.start(
-                    plan, params, plan_name, callback_type
-                )
+                status_and_message = self.runner.start(plan, params, plan_name)
             except Exception as e:
                 status_and_message = make_error_status_and_message(e)
                 LOGGER.error(format_exception(e))
@@ -312,7 +281,6 @@ def create_app(
     test_config=None,
     RE: RunEngine = RunEngine({}),
     skip_startup_connection: bool = False,
-    use_external_callbacks: bool = False,
 ) -> tuple[Flask, BlueskyRunner]:
     context = setup_context(
         wait_for_connection=not skip_startup_connection,
@@ -320,7 +288,6 @@ def create_app(
     runner = BlueskyRunner(
         RE,
         context=context,
-        use_external_callbacks=use_external_callbacks,
         skip_startup_connection=skip_startup_connection,
     )
     app = Flask(__name__)
@@ -350,11 +317,9 @@ def create_targets():
     do_default_logging_setup(
         CONST.LOG_FILE_NAME, CONST.GRAYLOG_PORT, dev_mode=args.dev_mode
     )
-    if not args.use_external_callbacks:
-        setup_callback_logging(args.dev_mode)
+    LOGGER.info(f"Hyperion launched with args:{argv}")
     app, runner = create_app(
         skip_startup_connection=args.skip_startup_connection,
-        use_external_callbacks=args.use_external_callbacks,
     )
     return app, runner, hyperion_port, args.dev_mode
 

mx_bluesky/hyperion/device_setup_plans/setup_panda.py

@@ -1,6 +1,5 @@
 from datetime import datetime
 from enum import Enum
-from importlib import resources
 from pathlib import Path
 
 import bluesky.plan_stubs as bps
@@ -8,15 +7,15 @@ 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,
     SeqTable,
     SeqTrigger,
 )
 
-import mx_bluesky.hyperion.resources.panda as panda_resource
+from mx_bluesky.common.device_setup_plans.setup_panda import load_panda_from_yaml
 from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.parameters.constants import DeviceSettingsConstants
 
 MM_TO_ENCODER_COUNTS = 200000
 GENERAL_TIMEOUT = 60
@@ -76,7 +75,8 @@ def _get_seq_table(
 
     num_pulses = parameters.x_steps
 
-    delay_between_pulses = time_between_steps_ms * TICKS_PER_MS
+    # Integer precision here is 1e-6s, so casting is safe
+    delay_between_pulses = int(time_between_steps_ms * TICKS_PER_MS)
 
     assert delay_between_pulses > PULSE_WIDTH_US
 
@@ -145,10 +145,11 @@ def setup_panda_for_flyscan(
 
     yield from bps.stage(panda, group="panda-config")
 
-    with resources.as_file(
-        resources.files(panda_resource) / "panda-gridscan.yaml"
-    ) as config_yaml_path:
-        yield from load_device(panda, str(config_yaml_path))
+    yield from load_panda_from_yaml(
+        DeviceSettingsConstants.PANDA_FLYSCAN_SETTINGS_DIR,
+        DeviceSettingsConstants.PANDA_FLYSCAN_SETTINGS_FILENAME,
+        panda,
+    )
 
     initial_x = yield from bps.rd(smargon.x.user_readback)
     initial_y = yield from bps.rd(smargon.y.user_readback)

mx_bluesky/hyperion/device_setup_plans/xbpm_feedback.py

@@ -2,6 +2,8 @@ from bluesky import plan_stubs as bps
 from bluesky.preprocessors import finalize_wrapper
 from bluesky.utils import make_decorator
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.dcm import DCM
+from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import Pause, XBPMFeedback
 
 from mx_bluesky.common.utils.log import LOGGER
@@ -49,8 +51,10 @@ def _unpause_xbpm_feedback_and_set_transmission_to_1(
 
 def transmission_and_xbpm_feedback_for_collection_wrapper(
     plan,
+    undulator: Undulator,
     xbpm_feedback: XBPMFeedback,
     attenuator: BinaryFilterAttenuator,
+    dcm: DCM,
     desired_transmission_fraction: float,
 ):
     """Sets the transmission for the data collection, ensuring the xbpm feedback is valid
@@ -66,6 +70,9 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
     mostly accounts for slow thermal drift so it is safe to assume that the beam is
     stable during a collection.
 
+    In the case of a beam dump, undulator gap may not return. Therefore, we check here
+    that the undulator gap is correct after XBPM is stable, and before collection.
+
     Args:
         plan: The plan performing the data collection
         xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
@@ -78,6 +85,9 @@ def transmission_and_xbpm_feedback_for_collection_wrapper(
         yield from _check_and_pause_feedback(
             xbpm_feedback, attenuator, desired_transmission_fraction
         )
+        # Verify Undulator gap is correct, as may not be after a beam dump
+        energy_in_kev = yield from bps.rd(dcm.energy_in_kev.user_readback)
+        yield from bps.abs_set(undulator, energy_in_kev, wait=True)
         return (yield from plan)
 
     return (

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -11,13 +11,6 @@ from mx_bluesky.hyperion.experiment_plans import (
     pin_centre_then_xray_centre_plan,
     robot_load_then_centre_plan,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util import (
-    CallbacksFactory,
-    create_gridscan_callbacks,
-    create_load_centre_collect_callbacks,
-    create_robot_load_and_centre_callbacks,
-    create_rotation_callbacks,
-)
 from mx_bluesky.hyperion.parameters.gridscan import (
     GridScanWithEdgeDetect,
     HyperionSpecifiedThreeDGridScan,
@@ -47,44 +40,36 @@ class ExperimentRegistryEntry(TypedDict):
         | LoadCentreCollect
         | RobotLoadThenCentre
     ]
-    callbacks_factory: CallbacksFactory
 
 
 PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
     "flyscan_xray_centre": {
         "setup": flyscan_xray_centre_plan.create_devices,
         "param_type": HyperionSpecifiedThreeDGridScan,
-        "callbacks_factory": create_gridscan_callbacks,
     },
     "grid_detect_then_xray_centre": {
         "setup": grid_detect_then_xray_centre_plan.create_devices,
         "param_type": GridScanWithEdgeDetect,
-        "callbacks_factory": create_gridscan_callbacks,
     },
     "rotation_scan": {
         "setup": rotation_scan_plan.create_devices,
         "param_type": RotationScan,
-        "callbacks_factory": create_rotation_callbacks,
     },
     "pin_tip_centre_then_xray_centre": {
         "setup": pin_centre_then_xray_centre_plan.create_devices,
         "param_type": PinTipCentreThenXrayCentre,
-        "callbacks_factory": create_gridscan_callbacks,
     },
     "robot_load_then_centre": {
         "setup": robot_load_then_centre_plan.create_devices,
         "param_type": RobotLoadThenCentre,
-        "callbacks_factory": create_robot_load_and_centre_callbacks,
     },
     "multi_rotation_scan": {
         "setup": rotation_scan_plan.create_devices,
         "param_type": MultiRotationScan,
-        "callbacks_factory": create_rotation_callbacks,
     },
     "load_centre_collect_full": {
         "setup": load_centre_collect_full_plan.create_devices,
         "param_type": LoadCentreCollect,
-        "callbacks_factory": create_load_centre_collect_callbacks,
     },
 }
 

mx_bluesky/hyperion/experiment_plans/flyscan_xray_centre_plan.py

@@ -50,6 +50,7 @@ from ophyd_async.fastcs.panda import HDFPanda
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback import (
     ispyb_activation_wrapper,
 )
+from mx_bluesky.common.parameters.constants import HardwareConstants
 from mx_bluesky.common.plans.do_fgs import kickoff_and_complete_gridscan
 from mx_bluesky.common.utils.exceptions import (
     CrystalNotFoundException,
@@ -119,10 +120,10 @@ class XRayCentreEventHandler(CallbackBase):
         self.xray_centre_results: Sequence[XRayCentreResult] | None = None
 
     def start(self, doc: RunStart) -> RunStart | None:
-        if "xray_centre_results" in doc:
+        if CONST.PLAN.FLYSCAN_RESULTS in doc:
             self.xray_centre_results = [
                 XRayCentreResult(**result_dict)
-                for result_dict in doc["xray_centre_results"]  # type: ignore
+                for result_dict in doc[CONST.PLAN.FLYSCAN_RESULTS]  # type: ignore
             ]
         return doc
 
@@ -140,6 +141,7 @@ def flyscan_xray_centre_no_move(
     composite.eiger.set_detector_parameters(parameters.detector_params)
     composite.zocalo.zocalo_environment = CONST.ZOCALO_ENV
     composite.zocalo.use_cpu_and_gpu = parameters.features.compare_cpu_and_gpu_zocalo
+    composite.zocalo.use_gpu = parameters.features.use_gpu_results
 
     feature_controlled = _get_feature_controlled(composite, parameters)
 
@@ -155,8 +157,10 @@ def flyscan_xray_centre_no_move(
     )
     @bpp.finalize_decorator(lambda: feature_controlled.tidy_plan(composite))
     @transmission_and_xbpm_feedback_for_collection_decorator(
+        composite.undulator,
         composite.xbpm_feedback,
         composite.attenuator,
+        composite.dcm,
         parameters.transmission_frac,
     )
     def run_gridscan_and_fetch_and_tidy(
@@ -303,7 +307,7 @@ def _fire_xray_centre_result_event(results: Sequence[XRayCentreResult]):
 
     yield from bpp.run_wrapper(
         empty_plan(),
-        md={"xray_centre_results": [dataclasses.asdict(r) for r in results]},
+        md={CONST.PLAN.FLYSCAN_RESULTS: [dataclasses.asdict(r) for r in results]},
     )
 
 
@@ -468,10 +472,9 @@ def _panda_triggering_setup(
         fgs_composite.panda_fast_grid_scan.run_up_distance_mm
     )
 
-    # Set the time between x steps pv
-    DEADTIME_S = 1e-6  # according to https://www.dectris.com/en/detectors/x-ray-detectors/eiger2/eiger2-for-synchrotrons/eiger2-x/
-
-    time_between_x_steps_ms = (DEADTIME_S + parameters.exposure_time_s) * 1e3
+    time_between_x_steps_ms = (
+        HardwareConstants.PANDA_FGS_EIGER_DEADTIME_S + parameters.exposure_time_s
+    ) * 1e3
 
     smargon_speed_limit_mm_per_s = yield from bps.rd(
         fgs_composite.smargon.x.max_velocity
@@ -490,7 +493,7 @@ def _panda_triggering_setup(
         )
     else:
         LOGGER.info(
-            f"Panda grid scan: Smargon speed set to {smargon_speed_limit_mm_per_s} mm/s"
+            f"Panda grid scan: Smargon speed set to {sample_velocity_mm_per_s} mm/s"
             f" and using a run-up distance of {run_up_distance_mm}"
         )
 

mx_bluesky/hyperion/experiment_plans/grid_detect_then_xray_centre_plan.py

@@ -142,6 +142,14 @@ def detect_grid_and_do_gridscan(
             parameters.box_size_um,
         )
 
+    if parameters.selected_aperture:
+        # Start moving the aperture/scatterguard into position without moving it in
+        yield from bps.prepare(
+            composite.aperture_scatterguard,
+            parameters.selected_aperture,
+            group=CONST.WAIT.GRID_READY_FOR_DC,
+        )
+
     yield from run_grid_detection_plan(
         oav_params,
         snapshot_template,