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

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,
@@ -64,9 +67,16 @@ 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.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
 
 
@@ -80,7 +90,7 @@ class CrystalNotFoundException(WarningException):
     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 +119,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 +165,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 +252,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 +273,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,
@@ -314,31 +381,6 @@ def wait_for_gridscan_valid(fgs_motors: FastGridScanCommon, timeout=0.5):
     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()
-
-
 @dataclasses.dataclass
 class _FeatureControlled:
     class _ZebraSetup(Protocol):
@@ -350,7 +392,7 @@ class _FeatureControlled:
         def __call__(
             self,
             fgs_composite: FlyScanXRayCentreComposite,
-            parameters: ThreeDGridScan,
+            parameters: HyperionThreeDGridScan,
             initial_xyz: np.ndarray,
         ) -> MsgGenerator: ...
 
@@ -362,7 +404,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 +453,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 +463,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 +482,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(

mx_bluesky/hyperion/experiment_plans/grid_detect_then_xray_centre_plan.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-import dataclasses
 from pathlib import Path
 
-from blueapi.core import BlueskyContext, MsgGenerator
+import pydantic
+from blueapi.core import BlueskyContext
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
+from bluesky.preprocessors import subs_decorator
+from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.backlight import Backlight, BacklightPosition
@@ -29,17 +31,22 @@ from dodal.devices.zocalo import ZocaloResults
 from ophyd_async.fastcs.panda import HDFPanda
 
 from mx_bluesky.common.parameters.constants import OavConstants
+from mx_bluesky.common.parameters.gridscan import GridScanWithEdgeDetect
 from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
     move_aperture_if_required,
 )
 from mx_bluesky.hyperion.device_setup_plans.utils import (
     start_preparing_data_collection_then_do_plan,
 )
+from mx_bluesky.hyperion.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
 from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
     FlyScanXRayCentreComposite as FlyScanXRayCentreComposite,
 )
 from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
-    flyscan_xray_centre,
+    XRayCentreEventHandler,
+    flyscan_xray_centre_no_move,
 )
 from mx_bluesky.hyperion.experiment_plans.oav_grid_detection_plan import (
     OavGridDetectionComposite,
@@ -55,13 +62,12 @@ from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_callba
 from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.gridscan import (
-    GridScanWithEdgeDetect,
-    ThreeDGridScan,
+    HyperionThreeDGridScan,
 )
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class GridDetectThenXRayCentreComposite:
     """All devices which are directly or indirectly required by this plan"""
 
@@ -87,6 +93,10 @@ class GridDetectThenXRayCentreComposite:
     robot: BartRobot
     sample_shutter: ZebraShutter
 
+    @property
+    def sample_motors(self):
+        return self.smargon
+
 
 def create_devices(context: BlueskyContext) -> GridDetectThenXRayCentreComposite:
     return device_composite_from_context(context, GridDetectThenXRayCentreComposite)
@@ -95,10 +105,10 @@ def create_devices(context: BlueskyContext) -> GridDetectThenXRayCentreComposite
 def create_parameters_for_flyscan_xray_centre(
     grid_scan_with_edge_params: GridScanWithEdgeDetect,
     grid_parameters: GridParamUpdate,
-) -> ThreeDGridScan:
+) -> HyperionThreeDGridScan:
     params_json = grid_scan_with_edge_params.model_dump()
     params_json.update(grid_parameters)
-    flyscan_xray_centre_parameters = ThreeDGridScan(**params_json)
+    flyscan_xray_centre_parameters = HyperionThreeDGridScan(**params_json)
     LOGGER.info(f"Parameters for FGS: {flyscan_xray_centre_parameters}")
     return flyscan_xray_centre_parameters
 
@@ -134,6 +144,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.abs_set(
+            composite.aperture_scatterguard.aperture_outside_beam,
+            parameters.selected_aperture,
+            group=CONST.WAIT.GRID_READY_FOR_DC,
+        )
+
     yield from run_grid_detection_plan(
         oav_params,
         snapshot_template,
@@ -150,7 +168,7 @@ def detect_grid_and_do_gridscan(
         group=CONST.WAIT.GRID_READY_FOR_DC,
     )
 
-    yield from flyscan_xray_centre(
+    yield from flyscan_xray_centre_no_move(
         FlyScanXRayCentreComposite(
             aperture_scatterguard=composite.aperture_scatterguard,
             attenuator=composite.attenuator,
@@ -193,19 +211,33 @@ def grid_detect_then_xray_centre(
 
     oav_params = OAVParameters("xrayCentring", oav_config)
 
-    plan_to_perform = ispyb_activation_wrapper(
-        detect_grid_and_do_gridscan(
-            composite,
+    flyscan_event_handler = XRayCentreEventHandler()
+
+    @subs_decorator(flyscan_event_handler)
+    def plan_to_perform():
+        yield from ispyb_activation_wrapper(
+            detect_grid_and_do_gridscan(
+                composite,
+                parameters,
+                oav_params,
+            ),
             parameters,
-            oav_params,
-        ),
-        parameters,
-    )
+        )
 
-    return start_preparing_data_collection_then_do_plan(
+    yield from start_preparing_data_collection_then_do_plan(
         eiger,
         composite.detector_motion,
         parameters.detector_params.detector_distance,
-        plan_to_perform,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809 and MsgGenerator should allow for return values
+        plan_to_perform(),
         group=CONST.WAIT.GRID_READY_FOR_DC,
     )
+
+    assert (
+        flyscan_event_handler.xray_centre_results
+    ), "Flyscan result event not received or no crystal found and exception not raised"
+
+    yield from change_aperture_then_move_to_xtal(
+        flyscan_event_handler.xray_centre_results[0],
+        composite.smargon,
+        composite.aperture_scatterguard,
+    )

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -1,25 +1,36 @@
-import dataclasses
+from collections.abc import Sequence
 
-from blueapi.core import BlueskyContext
+import pydantic
+from blueapi.core import BlueskyContext, MsgGenerator
+from bluesky.preprocessors import subs_wrapper
 from dodal.devices.oav.oav_parameters import OAVParameters
+from dodal.devices.smargon import Smargon
 
+import mx_bluesky.hyperion.experiment_plans.common.xrc_result as flyscan_result
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    XRayCentreEventHandler,
+)
 from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
     RobotLoadThenCentreComposite,
-    robot_load_then_centre,
+    robot_load_then_xray_centre,
 )
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
+    MultiRotationScan,
     RotationScanComposite,
     multi_rotation_scan,
 )
+from mx_bluesky.hyperion.log import LOGGER
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class LoadCentreCollectComposite(RobotLoadThenCentreComposite, RotationScanComposite):
     """Composite that provides access to the required devices."""
 
-    pass
+    @property
+    def sample_motors(self) -> Smargon:
+        return self.smargon
 
 
 def create_devices(context: BlueskyContext) -> LoadCentreCollectComposite:
@@ -27,11 +38,11 @@ def create_devices(context: BlueskyContext) -> LoadCentreCollectComposite:
     return device_composite_from_context(context, LoadCentreCollectComposite)
 
 
-def load_centre_collect_full_plan(
+def load_centre_collect_full(
     composite: LoadCentreCollectComposite,
-    params: LoadCentreCollect,
+    parameters: LoadCentreCollect,
     oav_params: OAVParameters | None = None,
-):
+) -> MsgGenerator:
     """Attempt a complete data collection experiment, consisting of the following:
     * Load the sample if necessary
     * Move to the specified goniometer start angles
@@ -41,6 +52,37 @@ def load_centre_collect_full_plan(
     """
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
-    yield from robot_load_then_centre(composite, params.robot_load_then_centre)
 
-    yield from multi_rotation_scan(composite, params.multi_rotation_scan, oav_params)
+    flyscan_event_handler = XRayCentreEventHandler()
+    yield from subs_wrapper(
+        robot_load_then_xray_centre(composite, parameters.robot_load_then_centre),
+        flyscan_event_handler,
+    )
+
+    assert (
+        flyscan_event_handler.xray_centre_results
+    ), "Flyscan result event not received or no crystal found and exception not raised"
+
+    selection_func = flyscan_result.resolve_selection_fn(parameters.selection_params)
+    hits: Sequence[flyscan_result.XRayCentreResult] = selection_func(
+        flyscan_event_handler.xray_centre_results
+    )
+    LOGGER.info(
+        f"Selected hits {hits} using {selection_func}, args={parameters.selection_params}"
+    )
+
+    multi_rotation = parameters.multi_rotation_scan
+    rotation_template = multi_rotation.rotation_scans.copy()
+
+    multi_rotation.rotation_scans.clear()
+
+    for hit in hits:
+        for rot in rotation_template:
+            combination = rot.model_copy()
+            combination.x_start_um, combination.y_start_um, combination.z_start_um = (
+                axis * 1000 for axis in hit.centre_of_mass_mm
+            )
+            multi_rotation.rotation_scans.append(combination)
+    multi_rotation = MultiRotationScan.model_validate(multi_rotation)
+
+    yield from multi_rotation_scan(composite, multi_rotation, oav_params)

mx_bluesky/hyperion/experiment_plans/oav_grid_detection_plan.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-import dataclasses
 import math
 from typing import TYPE_CHECKING
 
 import bluesky.plan_stubs as bps
 import numpy as np
+import pydantic
 from blueapi.core import BlueskyContext
 from dodal.devices.backlight import Backlight
 from dodal.devices.oav.oav_detector import OAV
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
     from dodal.devices.oav.oav_parameters import OAVParameters
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class OavGridDetectionComposite:
     """All devices which are directly or indirectly required by this plan"""
 

mx_bluesky/hyperion/experiment_plans/oav_snapshot_plan.py

@@ -1,9 +1,9 @@
 from datetime import datetime
 from typing import Protocol
 
-from blueapi.core import MsgGenerator
 from bluesky import plan_stubs as bps
-from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+from bluesky.utils import MsgGenerator
+from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.backlight import Backlight, BacklightPosition
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVParameters
@@ -33,22 +33,16 @@ def setup_beamline_for_OAV(
     max_vel = yield from bps.rd(smargon.omega.max_velocity)
     yield from bps.abs_set(smargon.omega.velocity, max_vel, group=group)
     yield from bps.abs_set(backlight, BacklightPosition.IN, group=group)
-    yield from bps.abs_set(
-        aperture_scatterguard,
-        ApertureValue.ROBOT_LOAD,
-        group=group,
-    )
+    yield from bps.trigger(aperture_scatterguard.move_out, group=group)
 
 
 def oav_snapshot_plan(
     composite: OavSnapshotComposite,
     parameters: WithSnapshot,
     oav_parameters: OAVParameters,
-    wait: bool = True,
 ) -> MsgGenerator:
     if not parameters.take_snapshots:
         return
-    yield from bps.wait(group=CONST.WAIT.READY_FOR_OAV)
     yield from _setup_oav(composite, parameters, oav_parameters)
     for omega in parameters.snapshot_omegas_deg or []:
         yield from _take_oav_snapshot(composite, omega)

mx_bluesky/hyperion/experiment_plans/optimise_attenuation_plan.py

@@ -1,9 +1,9 @@
-import dataclasses
 from enum import Enum
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
 import numpy as np
+import pydantic
 from blueapi.core import BlueskyContext
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.xspress3.xspress3 import Xspress3
@@ -22,7 +22,7 @@ class Direction(Enum):
     NEGATIVE = "negative"
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class OptimizeAttenuationComposite:
     """All devices which are directly or indirectly required by this plan"""