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

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -3,9 +3,6 @@
 The __all__ list in here are the plans that are externally available from outside Hyperion.
 """
 
-from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
-    flyscan_xray_centre,
-)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     grid_detect_then_xray_centre,
 )
@@ -16,15 +13,12 @@ from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan impor
     pin_tip_centre_then_xray_centre,
 )
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
-    multi_rotation_scan,
     rotation_scan,
 )
 
 __all__ = [
-    "flyscan_xray_centre",
     "grid_detect_then_xray_centre",
-    "rotation_scan",
     "pin_tip_centre_then_xray_centre",
-    "multi_rotation_scan",
+    "rotation_scan",
     "load_centre_collect_full",
 ]

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from collections.abc import Callable
 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.hyperion.experiment_plans import (
     grid_detect_then_xray_centre_plan,
@@ -16,7 +15,7 @@ from mx_bluesky.hyperion.parameters.gridscan import (
     PinTipCentreThenXrayCentre,
 )
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan, RotationScan
+from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
 
 def not_implemented():
@@ -33,32 +32,23 @@ class ExperimentRegistryEntry(TypedDict):
         HyperionSpecifiedThreeDGridScan
         | GridScanWithEdgeDetect
         | RotationScan
-        | MultiRotationScan
         | PinTipCentreThenXrayCentre
         | LoadCentreCollect
     ]
 
 
 PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
-    "flyscan_xray_centre": {
-        "setup": flyscan_xray_centre_plan.create_devices,
-        "param_type": HyperionSpecifiedThreeDGridScan,
-    },
     "grid_detect_then_xray_centre": {
         "setup": grid_detect_then_xray_centre_plan.create_devices,
         "param_type": GridScanWithEdgeDetect,
     },
-    "rotation_scan": {
-        "setup": rotation_scan_plan.create_devices,
-        "param_type": RotationScan,
-    },
     "pin_tip_centre_then_xray_centre": {
         "setup": pin_centre_then_xray_centre_plan.create_devices,
         "param_type": PinTipCentreThenXrayCentre,
     },
-    "multi_rotation_scan": {
+    "rotation_scan": {
         "setup": rotation_scan_plan.create_devices,
-        "param_type": MultiRotationScan,
+        "param_type": RotationScan,
     },
     "load_centre_collect_full": {
         "setup": load_centre_collect_full_plan.create_devices,

mx_bluesky/hyperion/experiment_plans/grid_detect_then_xray_centre_plan.py

@@ -2,35 +2,28 @@ from __future__ import annotations
 
 from pathlib import Path
 
-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.attenuator import BinaryFilterAttenuator
-from dodal.devices.backlight import Backlight, BacklightPosition
-from dodal.devices.dcm import DCM
-from dodal.devices.detector.detector_motion import DetectorMotion
+from dodal.devices.backlight import BacklightPosition
 from dodal.devices.eiger import EigerDetector
-from dodal.devices.fast_grid_scan import PandAFastGridScan, ZebraFastGridScan
-from dodal.devices.flux import Flux
-from dodal.devices.i03.beamstop import Beamstop
-from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVParameters
-from dodal.devices.oav.pin_image_recognition import PinTipDetection
-from dodal.devices.robot import BartRobot
-from dodal.devices.s4_slit_gaps import S4SlitGaps
-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
-from dodal.devices.zebra.zebra import Zebra
-from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
-from dodal.devices.zocalo import ZocaloResults
-from ophyd_async.fastcs.panda import HDFPanda
+from dodal.plans.preprocessors.verify_undulator_gap import (
+    verify_undulator_gap_before_run_decorator,
+)
 
+from mx_bluesky.common.device_setup_plans.manipulate_sample import (
+    move_aperture_if_required,
+)
+from mx_bluesky.common.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
+from mx_bluesky.common.experiment_plans.oav_grid_detection_plan import (
+    OavGridDetectionComposite,
+    grid_detection_plan,
+)
 from mx_bluesky.common.external_interaction.callbacks.common.grid_detection_callback import (
     GridDetectionCallback,
     GridParamUpdate,
@@ -39,27 +32,29 @@ from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback
     ispyb_activation_wrapper,
 )
 from mx_bluesky.common.parameters.constants import OavConstants
+from mx_bluesky.common.parameters.gridscan import GridCommon
+from mx_bluesky.common.plans.common_flyscan_xray_centre_plan import (
+    BeamlineSpecificFGSFeatures,
+    common_flyscan_xray_centre,
+)
+from mx_bluesky.common.preprocessors.preprocessors import (
+    transmission_and_xbpm_feedback_for_collection_decorator,
+)
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.xrc_result import XRayCentreEventHandler
-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 (
-    flyscan_xray_centre_no_move,
+from mx_bluesky.hyperion.experiment_plans.hyperion_flyscan_xray_centre_plan import (
+    construct_hyperion_specific_features,
 )
-from mx_bluesky.hyperion.experiment_plans.oav_grid_detection_plan import (
-    OavGridDetectionComposite,
-    grid_detection_plan,
+from mx_bluesky.hyperion.experiment_plans.oav_snapshot_plan import (
+    setup_beamline_for_OAV,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.device_composites import (
+    GridDetectThenXRayCentreComposite,
     HyperionFlyScanXRayCentreComposite,
 )
 from mx_bluesky.hyperion.parameters.gridscan import (
@@ -68,40 +63,12 @@ from mx_bluesky.hyperion.parameters.gridscan import (
 )
 
 
-@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
-class GridDetectThenXRayCentreComposite:
-    """All devices which are directly or indirectly required by this plan"""
-
-    aperture_scatterguard: ApertureScatterguard
-    attenuator: BinaryFilterAttenuator
-    backlight: Backlight
-    beamstop: Beamstop
-    dcm: DCM
-    detector_motion: DetectorMotion
-    eiger: EigerDetector
-    zebra_fast_grid_scan: ZebraFastGridScan
-    flux: Flux
-    oav: OAV
-    pin_tip_detection: PinTipDetection
-    smargon: Smargon
-    synchrotron: Synchrotron
-    s4_slit_gaps: S4SlitGaps
-    undulator: Undulator
-    xbpm_feedback: XBPMFeedback
-    zebra: Zebra
-    zocalo: ZocaloResults
-    panda: HDFPanda
-    panda_fast_grid_scan: PandAFastGridScan
-    robot: BartRobot
-    sample_shutter: ZebraShutter
-
-
 def create_devices(context: BlueskyContext) -> GridDetectThenXRayCentreComposite:
     return device_composite_from_context(context, GridDetectThenXRayCentreComposite)
 
 
 def create_parameters_for_flyscan_xray_centre(
-    grid_scan_with_edge_params: GridScanWithEdgeDetect,
+    grid_scan_with_edge_params: GridCommon,
     grid_parameters: GridParamUpdate,
 ) -> HyperionSpecifiedThreeDGridScan:
     params_json = grid_scan_with_edge_params.model_dump()
@@ -113,7 +80,7 @@ def create_parameters_for_flyscan_xray_centre(
 
 def detect_grid_and_do_gridscan(
     composite: GridDetectThenXRayCentreComposite,
-    parameters: GridScanWithEdgeDetect,
+    parameters: GridCommon,
     oav_params: OAVParameters,
 ):
     snapshot_template = f"{parameters.detector_params.prefix}_{parameters.detector_params.run_number}_{{angle}}"
@@ -142,12 +109,19 @@ def detect_grid_and_do_gridscan(
             parameters.box_size_um,
         )
 
+    yield from setup_beamline_for_OAV(
+        composite.smargon,
+        composite.backlight,
+        composite.aperture_scatterguard,
+        wait=True,
+    )
+
     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,
+            group=CONST.WAIT.PREPARE_APERTURE,
         )
 
     yield from run_grid_detection_plan(
@@ -160,38 +134,57 @@ def detect_grid_and_do_gridscan(
         composite.backlight, BacklightPosition.OUT, group=CONST.WAIT.GRID_READY_FOR_DC
     )
 
+    yield from bps.wait(CONST.WAIT.PREPARE_APERTURE)
     yield from move_aperture_if_required(
         composite.aperture_scatterguard,
         parameters.selected_aperture,
         group=CONST.WAIT.GRID_READY_FOR_DC,
     )
 
-    yield from flyscan_xray_centre_no_move(
-        HyperionFlyScanXRayCentreComposite(
-            aperture_scatterguard=composite.aperture_scatterguard,
-            attenuator=composite.attenuator,
-            backlight=composite.backlight,
-            eiger=composite.eiger,
-            panda_fast_grid_scan=composite.panda_fast_grid_scan,
-            flux=composite.flux,
-            s4_slit_gaps=composite.s4_slit_gaps,
-            smargon=composite.smargon,
-            undulator=composite.undulator,
-            synchrotron=composite.synchrotron,
-            xbpm_feedback=composite.xbpm_feedback,
-            zebra=composite.zebra,
-            zocalo=composite.zocalo,
-            panda=composite.panda,
-            zebra_fast_grid_scan=composite.zebra_fast_grid_scan,
-            dcm=composite.dcm,
-            robot=composite.robot,
-            sample_shutter=composite.sample_shutter,
-        ),
-        create_parameters_for_flyscan_xray_centre(
-            parameters, grid_params_callback.get_grid_parameters()
-        ),
+    xrc_composite = HyperionFlyScanXRayCentreComposite(
+        aperture_scatterguard=composite.aperture_scatterguard,
+        attenuator=composite.attenuator,
+        backlight=composite.backlight,
+        eiger=composite.eiger,
+        panda_fast_grid_scan=composite.panda_fast_grid_scan,
+        flux=composite.flux,
+        s4_slit_gaps=composite.s4_slit_gaps,
+        smargon=composite.smargon,
+        undulator=composite.undulator,
+        synchrotron=composite.synchrotron,
+        xbpm_feedback=composite.xbpm_feedback,
+        zebra=composite.zebra,
+        zocalo=composite.zocalo,
+        panda=composite.panda,
+        zebra_fast_grid_scan=composite.zebra_fast_grid_scan,
+        dcm=composite.dcm,
+        robot=composite.robot,
+        sample_shutter=composite.sample_shutter,
     )
 
+    params = create_parameters_for_flyscan_xray_centre(
+        parameters, grid_params_callback.get_grid_parameters()
+    )
+
+    beamline_specific = construct_hyperion_specific_features(xrc_composite, params)
+
+    yield from _gridscan_with_undulator_checks(xrc_composite, params, beamline_specific)
+
+
+def _gridscan_with_undulator_checks(
+    composite: HyperionFlyScanXRayCentreComposite,
+    params: HyperionSpecifiedThreeDGridScan,
+    beamline_specific: BeamlineSpecificFGSFeatures,
+):
+    @transmission_and_xbpm_feedback_for_collection_decorator(
+        composite, params.transmission_frac
+    )
+    @verify_undulator_gap_before_run_decorator(composite)
+    def _inner():
+        yield from common_flyscan_xray_centre(composite, params, beamline_specific)
+
+    yield from _inner()
+
 
 def grid_detect_then_xray_centre(
     composite: GridDetectThenXRayCentreComposite,

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from functools import partial
+from pathlib import Path
+
+import bluesky.plan_stubs as bps
+from bluesky.utils import MsgGenerator
+from dodal.devices.fast_grid_scan import (
+    set_fast_grid_scan_params,
+)
+
+from mx_bluesky.common.plans.common_flyscan_xray_centre_plan import (
+    construct_beamline_specific_FGS_features,
+)
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.device_setup_plans.setup_panda import (
+    disarm_panda_for_gridscan,
+    set_panda_directory,
+    setup_panda_for_flyscan,
+)
+from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
+    setup_zebra_for_gridscan,
+    setup_zebra_for_panda_flyscan,
+    tidy_up_zebra_after_gridscan,
+)
+from mx_bluesky.hyperion.parameters.device_composites import (
+    HyperionFlyScanXRayCentreComposite,
+)
+from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
+
+
+class SmargonSpeedException(Exception):
+    pass
+
+
+def construct_hyperion_specific_features(
+    fgs_composite: HyperionFlyScanXRayCentreComposite,
+    parameters: HyperionSpecifiedThreeDGridScan,
+):
+    """
+    Get all the information needed to do the Hyperion-specific parts of the XRC flyscan.
+    """
+
+    signals_to_read_pre_flyscan = [
+        fgs_composite.undulator.current_gap,
+        fgs_composite.synchrotron.synchrotron_mode,
+        fgs_composite.s4_slit_gaps.xgap,
+        fgs_composite.s4_slit_gaps.ygap,
+        fgs_composite.smargon.x,
+        fgs_composite.smargon.y,
+        fgs_composite.smargon.z,
+        fgs_composite.dcm.energy_in_kev,
+    ]
+
+    signals_to_read_during_collection = [
+        fgs_composite.aperture_scatterguard,
+        fgs_composite.attenuator.actual_transmission,
+        fgs_composite.flux.flux_reading,
+        fgs_composite.dcm.energy_in_kev,
+        fgs_composite.eiger.bit_depth,
+    ]
+
+    if parameters.features.use_panda_for_gridscan:
+        setup_trigger_plan = _panda_triggering_setup
+        tidy_plan = _panda_tidy
+        set_flyscan_params_plan = partial(
+            set_fast_grid_scan_params,
+            fgs_composite.panda_fast_grid_scan,
+            parameters.panda_FGS_params,
+        )
+        fgs_motors = fgs_composite.panda_fast_grid_scan
+
+    else:
+        setup_trigger_plan = _zebra_triggering_setup
+        tidy_plan = partial(_generic_tidy, group="flyscan_zebra_tidy", wait=True)
+        set_flyscan_params_plan = partial(
+            set_fast_grid_scan_params,
+            fgs_composite.zebra_fast_grid_scan,
+            parameters.FGS_params,
+        )
+        fgs_motors = fgs_composite.zebra_fast_grid_scan
+    return construct_beamline_specific_FGS_features(
+        setup_trigger_plan,
+        tidy_plan,
+        set_flyscan_params_plan,
+        fgs_motors,
+        signals_to_read_pre_flyscan,
+        signals_to_read_during_collection,
+        get_xrc_results_from_zocalo=True,
+    )
+
+
+def _generic_tidy(
+    fgs_composite: HyperionFlyScanXRayCentreComposite, group, wait=True
+) -> MsgGenerator:
+    LOGGER.info("Tidying up Zebra")
+    yield from tidy_up_zebra_after_gridscan(
+        fgs_composite.zebra, fgs_composite.sample_shutter, group=group, wait=wait
+    )
+    LOGGER.info("Tidying up Zocalo")
+    # make sure we don't consume any other results
+    yield from bps.unstage(fgs_composite.zocalo, group=group, wait=wait)
+
+    # 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")
+    yield from bps.abs_set(fgs_composite.eiger.odin.fan.dev_shm_enable, 0)  # type: ignore # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
+
+
+def _panda_tidy(fgs_composite: HyperionFlyScanXRayCentreComposite):
+    group = "panda_flyscan_tidy"
+    LOGGER.info("Disabling panda blocks")
+    yield from disarm_panda_for_gridscan(fgs_composite.panda, group)
+    yield from _generic_tidy(fgs_composite, group, False)
+    yield from bps.wait(group, timeout=10)
+    yield from bps.unstage(fgs_composite.panda)
+
+
+def _zebra_triggering_setup(
+    fgs_composite: HyperionFlyScanXRayCentreComposite,
+    parameters: HyperionSpecifiedThreeDGridScan,
+) -> MsgGenerator:
+    yield from setup_zebra_for_gridscan(
+        fgs_composite.zebra, fgs_composite.sample_shutter, wait=True
+    )
+
+
+def _panda_triggering_setup(
+    fgs_composite: HyperionFlyScanXRayCentreComposite,
+    parameters: HyperionSpecifiedThreeDGridScan,
+) -> MsgGenerator:
+    LOGGER.info("Setting up Panda for flyscan")
+
+    run_up_distance_mm = yield from bps.rd(
+        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
+
+    smargon_speed_limit_mm_per_s = yield from bps.rd(
+        fgs_composite.smargon.x.max_velocity
+    )
+
+    sample_velocity_mm_per_s = (
+        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_mm}mm and\
+            time_between_x_steps_ms {time_between_x_steps_ms} as\
+            {sample_velocity_mm_per_s}mm/s. The smargon's speed limit is\
+            {smargon_speed_limit_mm_per_s}mm/s."
+        )
+    else:
+        LOGGER.info(
+            f"Panda grid scan: Smargon speed set to {smargon_speed_limit_mm_per_s} mm/s"
+            f" and using a run-up distance of {run_up_distance_mm}"
+        )
+
+    yield from bps.mv(
+        fgs_composite.panda_fast_grid_scan.time_between_x_steps_ms,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        time_between_x_steps_ms,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    )
+
+    directory_provider_root = Path(parameters.storage_directory)
+    yield from set_panda_directory(directory_provider_root)
+
+    yield from setup_panda_for_flyscan(
+        fgs_composite.panda,
+        parameters.panda_FGS_params,
+        fgs_composite.smargon,
+        parameters.exposure_time_s,
+        time_between_x_steps_ms,
+        sample_velocity_mm_per_s,
+    )
+
+    LOGGER.info("Setting up Zebra for panda flyscan")
+    yield from setup_zebra_for_panda_flyscan(
+        fgs_composite.zebra, fgs_composite.sample_shutter, wait=True
+    )

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Generator
+
 import bluesky.plan_stubs as bps
 import numpy as np
 import pydantic
@@ -18,12 +20,13 @@ from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
     robot_load_then_xray_centre,
 )
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
-    MultiRotationScan,
+    RotationScan,
     RotationScanComposite,
-    multi_rotation_scan,
+    rotation_scan_internal,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.parameters.rotation import RotationScanPerSweep
 
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
@@ -48,8 +51,11 @@ def load_centre_collect_full(
     * If X-ray centring finds a diffracting centre then move to that centre and
     * do a collection with the specified parameters.
     """
+    parameters.features.update_self_from_server()
+
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
+    oav_config_file = oav_params.oav_config_json
 
     @set_run_key_decorator(CONST.PLAN.LOAD_CENTRE_COLLECT)
     @run_decorator(
@@ -64,7 +70,9 @@ def load_centre_collect_full(
     def plan_with_callback_subs():
         flyscan_event_handler = XRayCentreEventHandler()
         yield from subs_wrapper(
-            robot_load_then_xray_centre(composite, parameters.robot_load_then_centre),
+            robot_load_then_xray_centre(
+                composite, parameters.robot_load_then_centre, oav_config_file
+            ),
             flyscan_event_handler,
         )
 
@@ -83,32 +91,59 @@ def load_centre_collect_full(
         else:
             # If the xray centring hasn't found a result but has not thrown an error it
             # means that we do not need to recentre and can collect where we are
-            initial_x = yield from bps.rd(composite.smargon.x.user_readback)
-            initial_y = yield from bps.rd(composite.smargon.y.user_readback)
-            initial_z = yield from bps.rd(composite.smargon.z.user_readback)
+            initial_x_mm = yield from bps.rd(composite.smargon.x.user_readback)
+            initial_y_mm = yield from bps.rd(composite.smargon.y.user_readback)
+            initial_z_mm = yield from bps.rd(composite.smargon.z.user_readback)
 
-            locations_to_collect_um = [np.array([initial_x, initial_y, initial_z])]
+            locations_to_collect_um = [
+                np.array([initial_x_mm, initial_y_mm, initial_z_mm]) * 1000
+            ]
 
         multi_rotation = parameters.multi_rotation_scan
         rotation_template = multi_rotation.rotation_scans.copy()
 
         multi_rotation.rotation_scans.clear()
 
+        is_alternating = parameters.features.alternate_rotation_direction
+
+        generator = rotation_scan_generator(is_alternating)
+        next(generator)
         for location in locations_to_collect_um:
             for rot in rotation_template:
-                combination = rot.model_copy()
-                (
-                    combination.x_start_um,
-                    combination.y_start_um,
-                    combination.z_start_um,
-                ) = location
+                combination = generator.send((rot, location))
                 multi_rotation.rotation_scans.append(combination)
-        multi_rotation = MultiRotationScan.model_validate(multi_rotation)
+        multi_rotation = RotationScan.model_validate(multi_rotation)
 
         assert (
             multi_rotation.demand_energy_ev
             == parameters.robot_load_then_centre.demand_energy_ev
         ), "Setting a different energy for gridscan and rotation is not supported"
-        yield from multi_rotation_scan(composite, multi_rotation, oav_params)
+        yield from rotation_scan_internal(composite, multi_rotation, oav_params)
 
     yield from plan_with_callback_subs()
+
+
+def rotation_scan_generator(
+    is_alternating: bool,
+) -> Generator[RotationScanPerSweep, tuple[RotationScanPerSweep, np.ndarray], None]:
+    scan_template, location = yield  # type: ignore
+    next_rotation_direction = scan_template.rotation_direction
+    while True:
+        scan = scan_template.model_copy()
+        (
+            scan.x_start_um,
+            scan.y_start_um,
+            scan.z_start_um,
+        ) = location
+        if is_alternating:
+            if next_rotation_direction != scan.rotation_direction:
+                # If originally specified direction of the current scan is different
+                # from that required, swap the start and ends.
+                start = scan.omega_start_deg
+                rotation_sign = scan.rotation_direction.multiplier
+                end = start + rotation_sign * scan.scan_width_deg
+                scan.omega_start_deg = end
+                scan.rotation_direction = next_rotation_direction
+            next_rotation_direction = next_rotation_direction.opposite
+
+        scan_template, location = yield scan