mx-bluesky 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -3,7 +3,7 @@ from functools import wraps
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
-from blueapi.core import MsgGenerator
+from bluesky.utils import MsgGenerator
 from dodal.devices.zebra import (
     AUTO_SHUTTER_GATE,
     AUTO_SHUTTER_INPUT_1,

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.hyperion.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/exceptions.py

@@ -13,9 +13,21 @@ class WarningException(Exception):
     pass
 
 
+class SampleException(WarningException):
+    """An exception which identifies an issue relating to the sample."""
+
+    pass
+
+
 T = TypeVar("T")
 
 
+class CrystalNotFoundException(SampleException):
+    """Raised if grid detection completed normally but no crystal was found."""
+
+    pass
+
+
 def catch_exception_and_warn(
     exception_to_catch: type[Exception],
     func: Callable[..., Generator[Msg, None, T]],
@@ -36,7 +48,7 @@ def catch_exception_and_warn(
 
     def warn_if_exception_matches(exception: Exception):
         if isinstance(exception, exception_to_catch):
-            raise WarningException(str(exception))
+            raise SampleException(str(exception)) from exception
         yield from null()
 
     return (

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -9,6 +9,9 @@ from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     grid_detect_then_xray_centre,
 )
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    load_centre_collect_full,
+)
 from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
     pin_tip_centre_then_xray_centre,
 )
@@ -27,4 +30,5 @@ __all__ = [
     "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

@@ -0,0 +1,83 @@
+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
+
+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
+
+
+def change_aperture_then_move_to_xtal(
+    best_hit: XRayCentreResult,
+    smargon: Smargon,
+    aperture_scatterguard: ApertureScatterguard,
+    parameters: HyperionThreeDGridScan | None = None,
+):
+    """For the given x-ray centring result,
+    * 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")
+
+    # once we have the results, go to the appropriate position
+    LOGGER.info("Moving to centre of mass.")
+    with TRACER.start_span("move_to_result"):
+        x, y, z = best_hit.centre_of_mass_mm
+        yield from move_x_y_z(smargon, x, y, z, wait=True)
+
+    # TODO support for setting stub offsets in multipin
+    # https://github.com/DiamondLightSource/mx-bluesky/issues/552
+    if parameters and parameters.FGS_params.set_stub_offsets:
+        LOGGER.info("Recentring smargon co-ordinate system to this point.")
+        yield from bps.mv(
+            # See: https://github.com/bluesky/bluesky/issues/1809
+            smargon.stub_offsets,  # type: ignore
+            StubPosition.CURRENT_AS_CENTER,  # type: ignore
+        )
+
+
+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)
+
+
+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
+    )
+    LOGGER.info(
+        f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size}."
+    )
+
+    @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()

mx_bluesky/hyperion/experiment_plans/common/xrc_result.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Callable, Sequence
+from functools import partial
+
+import numpy as np
+
+from mx_bluesky.common.parameters.components import (
+    MultiXtalSelection,
+    TopNByMaxCountSelection,
+)
+
+
+@dataclasses.dataclass
+class XRayCentreResult:
+    """Represents information about a hit from an X-ray centring."""
+
+    centre_of_mass_mm: np.ndarray
+    bounding_box_mm: tuple[np.ndarray, np.ndarray]
+    max_count: int
+    total_count: int
+
+    def __eq__(self, o):
+        return (
+            isinstance(o, XRayCentreResult)
+            and o.max_count == self.max_count
+            and o.total_count == self.total_count
+            and all(o.centre_of_mass_mm == self.centre_of_mass_mm)
+            and all(o.bounding_box_mm[0] == self.bounding_box_mm[0])
+            and all(o.bounding_box_mm[1] == self.bounding_box_mm[1])
+        )
+
+
+def top_n_by_max_count(
+    unfiltered: Sequence[XRayCentreResult], n: int
+) -> Sequence[XRayCentreResult]:
+    sorted_hits = sorted(unfiltered, key=lambda result: result.max_count, reverse=True)
+    return sorted_hits[:n]
+
+
+def resolve_selection_fn(
+    params: MultiXtalSelection,
+) -> Callable[[Sequence[XRayCentreResult]], Sequence[XRayCentreResult]]:
+    if isinstance(params, TopNByMaxCountSelection):
+        return partial(top_n_by_max_count, n=params.n)
+    raise ValueError(f"Invalid selection function {params.name}")

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -5,6 +5,11 @@ from typing import TypedDict
 
 import mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan as flyscan_xray_centre_plan
 import mx_bluesky.hyperion.experiment_plans.rotation_scan_plan as rotation_scan_plan
+from mx_bluesky.common.parameters.gridscan import (
+    GridScanWithEdgeDetect,
+    PinTipCentreThenXrayCentre,
+    RobotLoadThenCentre,
+)
 from mx_bluesky.hyperion.experiment_plans import (
     grid_detect_then_xray_centre_plan,
     load_centre_collect_full_plan,
@@ -18,12 +23,7 @@ from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util imp
     create_robot_load_and_centre_callbacks,
     create_rotation_callbacks,
 )
-from mx_bluesky.hyperion.parameters.gridscan import (
-    GridScanWithEdgeDetect,
-    PinTipCentreThenXrayCentre,
-    RobotLoadThenCentre,
-    ThreeDGridScan,
-)
+from mx_bluesky.hyperion.parameters.gridscan import HyperionThreeDGridScan
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan, RotationScan
 
@@ -39,7 +39,7 @@ def do_nothing():
 class ExperimentRegistryEntry(TypedDict):
     setup: Callable
     param_type: type[
-        ThreeDGridScan
+        HyperionThreeDGridScan
         | GridScanWithEdgeDetect
         | RotationScan
         | MultiRotationScan
@@ -53,7 +53,7 @@ class ExperimentRegistryEntry(TypedDict):
 PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
     "flyscan_xray_centre": {
         "setup": flyscan_xray_centre_plan.create_devices,
-        "param_type": ThreeDGridScan,
+        "param_type": HyperionThreeDGridScan,
         "callbacks_factory": create_gridscan_callbacks,
     },
     "grid_detect_then_xray_centre": {
@@ -81,7 +81,7 @@ PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
         "param_type": MultiRotationScan,
         "callbacks_factory": create_rotation_callbacks,
     },
-    "load_centre_collect_full_plan": {
+    "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

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from functools import partial
 from pathlib import Path
 from typing import Protocol
@@ -9,10 +9,12 @@ from typing import Protocol
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 import numpy as np
-from blueapi.core import BlueskyContext, MsgGenerator
+import pydantic
+from blueapi.core import BlueskyContext
+from bluesky.callbacks import CallbackBase
+from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import (
     ApertureScatterguard,
-    ApertureValue,
 )
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.backlight import Backlight
@@ -29,7 +31,7 @@ from dodal.devices.fast_grid_scan import (
 from dodal.devices.flux import Flux
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
-from dodal.devices.smargon import Smargon, StubPosition
+from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import XBPMFeedback
@@ -38,14 +40,15 @@ from dodal.devices.zebra_controlled_shutter import ZebraShutter
 from dodal.devices.zocalo.zocalo_results import (
     ZOCALO_READING_PLAN_NAME,
     ZOCALO_STAGE_GROUP,
+    XrcResult,
     ZocaloResults,
     get_full_processing_results,
 )
+from event_model import RunStart
 from ophyd_async.fastcs.panda import HDFPanda
 
 from mx_bluesky.common.plans.do_fgs import kickoff_and_complete_gridscan
 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.device_setup_plans.read_hardware_for_setup import (
     read_hardware_during_collection,
     read_hardware_pre_collection,
@@ -63,10 +66,17 @@ from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
 from mx_bluesky.hyperion.device_setup_plans.xbpm_feedback import (
     transmission_and_xbpm_feedback_for_collection_decorator,
 )
-from mx_bluesky.hyperion.exceptions import WarningException
+from mx_bluesky.hyperion.exceptions import CrystalNotFoundException, SampleException
+from mx_bluesky.hyperion.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
+from mx_bluesky.hyperion.experiment_plans.common.xrc_result import XRayCentreResult
+from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_callback import (
+    ispyb_activation_wrapper,
+)
 from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.gridscan import ThreeDGridScan
+from mx_bluesky.hyperion.parameters.gridscan import HyperionThreeDGridScan
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
@@ -74,13 +84,7 @@ class SmargonSpeedException(Exception):
     pass
 
 
-class CrystalNotFoundException(WarningException):
-    """Raised if grid detection completed normally but no crystal was found."""
-
-    pass
-
-
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class FlyScanXRayCentreComposite:
     """All devices which are directly or indirectly required by this plan"""
 
@@ -109,26 +113,29 @@ class FlyScanXRayCentreComposite:
         return self.smargon
 
 
+class XRayCentreEventHandler(CallbackBase):
+    def __init__(self):
+        super().__init__()
+        self.xray_centre_results: Sequence[XRayCentreResult] | None = None
+
+    def start(self, doc: RunStart) -> RunStart | None:
+        if "xray_centre_results" in doc:
+            self.xray_centre_results = [
+                XRayCentreResult(**result_dict)
+                for result_dict in doc["xray_centre_results"]  # type: ignore
+            ]
+        return doc
+
+
 def create_devices(context: BlueskyContext) -> FlyScanXRayCentreComposite:
     """Creates the devices required for the plan and connect to them"""
     return device_composite_from_context(context, FlyScanXRayCentreComposite)
 
 
-def flyscan_xray_centre(
-    composite: FlyScanXRayCentreComposite,
-    parameters: ThreeDGridScan,
+def flyscan_xray_centre_no_move(
+    composite: FlyScanXRayCentreComposite, parameters: HyperionThreeDGridScan
 ) -> MsgGenerator:
-    """Create the plan to run the grid scan based on provided parameters.
-
-    The ispyb handler should be added to the whole gridscan as we want to capture errors
-    at any point in it.
-
-    Args:
-        parameters (ThreeDGridScan): The parameters to run the scan.
-
-    Returns:
-        Generator: The plan for the gridscan
-    """
+    """Perform a flyscan and determine the centres of interest"""
     parameters.features.update_self_from_server()
     composite.eiger.set_detector_parameters(parameters.detector_params)
     composite.zocalo.zocalo_environment = CONST.ZOCALO_ENV
@@ -152,25 +159,66 @@ def flyscan_xray_centre(
         composite.attenuator,
         parameters.transmission_frac,
     )
-    def run_gridscan_and_move_and_tidy(
+    def run_gridscan_and_fetch_and_tidy(
         fgs_composite: FlyScanXRayCentreComposite,
-        params: ThreeDGridScan,
+        params: HyperionThreeDGridScan,
         feature_controlled: _FeatureControlled,
-    ):
-        yield from run_gridscan_and_move(fgs_composite, params, feature_controlled)
+    ) -> MsgGenerator:
+        yield from run_gridscan_and_fetch_results(
+            fgs_composite, params, feature_controlled
+        )
+
+    yield from run_gridscan_and_fetch_and_tidy(
+        composite, parameters, feature_controlled
+    )
+
+
+def flyscan_xray_centre(
+    composite: FlyScanXRayCentreComposite,
+    parameters: HyperionThreeDGridScan,
+) -> MsgGenerator:
+    """Create the plan to run the grid scan based on provided parameters.
+
+    The ispyb handler should be added to the whole gridscan as we want to capture errors
+    at any point in it.
 
-    return run_gridscan_and_move_and_tidy(composite, parameters, feature_controlled)
+    Args:
+        parameters (ThreeDGridScan): The parameters to run the scan.
+
+    Returns:
+        Generator: The plan for the gridscan
+    """
+    xrc_event_handler = XRayCentreEventHandler()
+
+    @bpp.subs_decorator(xrc_event_handler)
+    def flyscan_and_fetch_results() -> MsgGenerator:
+        yield from ispyb_activation_wrapper(
+            flyscan_xray_centre_no_move(composite, parameters), parameters
+        )
+
+    yield from flyscan_and_fetch_results()
+
+    xray_centre_results = xrc_event_handler.xray_centre_results
+    assert (
+        xray_centre_results
+    ), "Flyscan result event not received or no crystal found and exception not raised"
+    yield from change_aperture_then_move_to_xtal(
+        xray_centre_results[0],
+        composite.smargon,
+        composite.aperture_scatterguard,
+        parameters,
+    )
 
 
 @bpp.set_run_key_decorator(CONST.PLAN.GRIDSCAN_AND_MOVE)
 @bpp.run_decorator(md={"subplan_name": CONST.PLAN.GRIDSCAN_AND_MOVE})
-def run_gridscan_and_move(
+def run_gridscan_and_fetch_results(
     fgs_composite: FlyScanXRayCentreComposite,
-    parameters: ThreeDGridScan,
+    parameters: HyperionThreeDGridScan,
     feature_controlled: _FeatureControlled,
 ) -> MsgGenerator:
     """A multi-run plan which runs a gridscan, gets the results from zocalo
-    and moves to the centre of mass determined by zocalo"""
+    and fires an event with the centres of mass determined by zocalo"""
 
     # We get the initial motor positions so we can return to them on zocalo failure
     initial_xyz = np.array(
@@ -198,37 +246,17 @@ def run_gridscan_and_move(
             )
             LOGGER.info("Zocalo triggered and read, interpreting results.")
             xrc_results = yield from get_full_processing_results(fgs_composite.zocalo)
-            LOGGER.info(f"Got xray centring results: {xrc_results}")
+            LOGGER.info(f"Got xray centres, top 5: {xrc_results[:5]}")
             if xrc_results:
-                best_result = xrc_results[0]
-                xrc_centre_grid_coords = best_result["centre_of_mass"]
-                xray_centre = parameters.FGS_params.grid_position_to_motor_position(
-                    np.array(xrc_centre_grid_coords)
-                )
-                with TRACER.start_span("change_aperture"):
-                    bbox_size = np.abs(
-                        np.array(best_result["bounding_box"][1])
-                        - np.array(best_result["bounding_box"][0])
-                    )
-                    yield from set_aperture_for_bbox_size(
-                        fgs_composite.aperture_scatterguard, bbox_size
-                    )
+                flyscan_results = [
+                    _xrc_result_in_boxes_to_result_in_mm(xr, parameters)
+                    for xr in xrc_results
+                ]
             else:
                 LOGGER.warning("No X-ray centre received")
                 raise CrystalNotFoundException()
+            yield from _fire_xray_centre_result_event(flyscan_results)
 
-        # once we have the results, go to the appropriate position
-        LOGGER.info("Moving to centre of mass.")
-        with TRACER.start_span("move_to_result"):
-            x, y, z = xray_centre
-            yield from move_x_y_z(fgs_composite.sample_motors, x, y, z, wait=True)
-
-        if parameters.FGS_params.set_stub_offsets:
-            LOGGER.info("Recentring smargon co-ordinate system to this point.")
-            yield from bps.mv(
-                fgs_composite.sample_motors.stub_offsets,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-                StubPosition.CURRENT_AS_CENTER,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-            )
     finally:
         # Turn off dev/shm streaming to avoid filling disk, see https://github.com/DiamondLightSource/hyperion/issues/1395
         LOGGER.info("Turning off Eiger dev/shm streaming")
@@ -239,11 +267,44 @@ def run_gridscan_and_move(
         yield from bps.wait()
 
 
+def _xrc_result_in_boxes_to_result_in_mm(
+    xrc_result: XrcResult, parameters: HyperionThreeDGridScan
+) -> XRayCentreResult:
+    fgs_params = parameters.FGS_params
+    xray_centre = fgs_params.grid_position_to_motor_position(
+        np.array(xrc_result["centre_of_mass"])
+    )
+    return XRayCentreResult(
+        centre_of_mass_mm=xray_centre,
+        bounding_box_mm=(
+            fgs_params.grid_position_to_motor_position(
+                np.array(xrc_result["bounding_box"][0])
+            ),
+            fgs_params.grid_position_to_motor_position(
+                np.array(xrc_result["bounding_box"][1])
+            ),
+        ),
+        max_count=xrc_result["max_count"],
+        total_count=xrc_result["total_count"],
+    )
+
+
+@bpp.set_run_key_decorator(CONST.PLAN.FLYSCAN_RESULTS)
+def _fire_xray_centre_result_event(results: Sequence[XRayCentreResult]):
+    def empty_plan():
+        return iter([])
+
+    yield from bpp.run_wrapper(
+        empty_plan(),
+        md={"xray_centre_results": [dataclasses.asdict(r) for r in results]},
+    )
+
+
 @bpp.set_run_key_decorator(CONST.PLAN.GRIDSCAN_MAIN)
 @bpp.run_decorator(md={"subplan_name": CONST.PLAN.GRIDSCAN_MAIN})
 def run_gridscan(
     fgs_composite: FlyScanXRayCentreComposite,
-    parameters: ThreeDGridScan,
+    parameters: HyperionThreeDGridScan,
     feature_controlled: _FeatureControlled,
     md={  # noqa
         "plan_name": CONST.PLAN.GRIDSCAN_MAIN,
@@ -311,32 +372,7 @@ def wait_for_gridscan_valid(fgs_motors: FastGridScanCommon, timeout=0.5):
             LOGGER.info("Gridscan scan valid and position counter reset")
             return
         yield from bps.sleep(SLEEP_PER_CHECK)
-    raise WarningException("Scan invalid - pin too long/short/bent and out of range")
-
-
-def set_aperture_for_bbox_size(
-    aperture_device: ApertureScatterguard,
-    bbox_size: list[int] | np.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
-    )
-    LOGGER.info(
-        f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size}."
-    )
-
-    @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()
+    raise SampleException("Scan invalid - pin too long/short/bent and out of range")
 
 
 @dataclasses.dataclass
@@ -350,7 +386,7 @@ class _FeatureControlled:
         def __call__(
             self,
             fgs_composite: FlyScanXRayCentreComposite,
-            parameters: ThreeDGridScan,
+            parameters: HyperionThreeDGridScan,
             initial_xyz: np.ndarray,
         ) -> MsgGenerator: ...
 
@@ -362,7 +398,7 @@ class _FeatureControlled:
 
 def _get_feature_controlled(
     fgs_composite: FlyScanXRayCentreComposite,
-    parameters: ThreeDGridScan,
+    parameters: HyperionThreeDGridScan,
 ):
     if parameters.features.use_panda_for_gridscan:
         return _FeatureControlled(
@@ -411,7 +447,7 @@ def _panda_tidy(fgs_composite: FlyScanXRayCentreComposite):
 
 def _zebra_triggering_setup(
     fgs_composite: FlyScanXRayCentreComposite,
-    parameters: ThreeDGridScan,
+    parameters: HyperionThreeDGridScan,
     initial_xyz: np.ndarray,
 ):
     yield from setup_zebra_for_gridscan(
@@ -421,7 +457,7 @@ def _zebra_triggering_setup(
 
 def _panda_triggering_setup(
     fgs_composite: FlyScanXRayCentreComposite,
-    parameters: ThreeDGridScan,
+    parameters: HyperionThreeDGridScan,
     initial_xyz: np.ndarray,
 ):
     LOGGER.info("Setting up Panda for flyscan")
@@ -440,15 +476,15 @@ def _panda_triggering_setup(
     )
 
     sample_velocity_mm_per_s = (
-        parameters.panda_FGS_params.x_step_size * 1e3 / time_between_x_steps_ms
+        parameters.panda_FGS_params.x_step_size_mm * 1e3 / time_between_x_steps_ms
     )
     if sample_velocity_mm_per_s > smargon_speed_limit_mm_per_s:
         raise SmargonSpeedException(
             f"Smargon speed was calculated from x step size\
-            {parameters.panda_FGS_params.x_step_size} and\
+            {parameters.panda_FGS_params.x_step_size_mm}mm and\
             time_between_x_steps_ms {time_between_x_steps_ms} as\
-            {sample_velocity_mm_per_s}. The smargon's speed limit is\
-            {smargon_speed_limit_mm_per_s} mm/s."
+            {sample_velocity_mm_per_s}mm/s. The smargon's speed limit is\
+            {smargon_speed_limit_mm_per_s}mm/s."
         )
     else:
         LOGGER.info(