mx-bluesky 1.4.8__py3-none-any.whl → 1.5.0__py3-none-any.whl

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -19,7 +19,7 @@ from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVParameters
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
-from dodal.devices.smargon import Smargon
+from dodal.devices.smargon import CombinedMove, Smargon
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import XBPMFeedback
@@ -32,16 +32,22 @@ from dodal.plans.preprocessors.verify_undulator_gap import (
 
 from mx_bluesky.common.device_setup_plans.manipulate_sample import (
     cleanup_sample_environment,
-    move_phi_chi_omega,
-    move_x_y_z,
     setup_sample_environment,
 )
-from mx_bluesky.common.parameters.components import WithSnapshot
-from mx_bluesky.common.plans.read_hardware import (
+from mx_bluesky.common.device_setup_plans.utils import (
+    start_preparing_data_collection_then_do_plan,
+)
+from mx_bluesky.common.experiment_plans.oav_snapshot_plan import (
+    OavSnapshotComposite,
+    oav_snapshot_plan,
+    setup_beamline_for_OAV,
+)
+from mx_bluesky.common.experiment_plans.read_hardware import (
     read_hardware_for_zocalo,
     standard_read_hardware_during_collection,
     standard_read_hardware_pre_collection,
 )
+from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.preprocessors.preprocessors import (
     transmission_and_xbpm_feedback_for_collection_decorator,
 )
@@ -52,18 +58,10 @@ from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
     setup_zebra_for_rotation,
     tidy_up_zebra_after_rotation_scan,
 )
-from mx_bluesky.hyperion.device_setup_plans.utils import (
-    start_preparing_data_collection_then_do_plan,
-)
-from mx_bluesky.hyperion.experiment_plans.oav_snapshot_plan import (
-    OavSnapshotComposite,
-    oav_snapshot_plan,
-    setup_beamline_for_OAV,
-)
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.rotation import (
-    MultiRotationScan,
     RotationScan,
+    SingleRotationScan,
 )
 
 
@@ -118,7 +116,7 @@ class RotationMotionProfile:
 
 
 def calculate_motion_profile(
-    params: RotationScan,
+    params: SingleRotationScan,
     motor_time_to_speed_s: float,
     max_velocity_deg_s: float,
 ) -> RotationMotionProfile:
@@ -212,7 +210,7 @@ def calculate_motion_profile(
 
 def rotation_scan_plan(
     composite: RotationScanComposite,
-    params: RotationScan,
+    params: SingleRotationScan,
     motion_values: RotationMotionProfile,
 ):
     """A stub plan to collect diffraction images from a sample continuously rotating
@@ -319,7 +317,7 @@ def _cleanup_plan(composite: RotationScanComposite, **kwargs):
 
 def _move_and_rotation(
     composite: RotationScanComposite,
-    params: RotationScan,
+    params: SingleRotationScan,
     oav_params: OAVParameters,
 ):
     motor_time_to_speed = yield from bps.rd(composite.smargon.omega.acceleration_time)
@@ -330,19 +328,18 @@ def _move_and_rotation(
         return num / 1000 if num else num
 
     LOGGER.info("moving to position (if specified)")
-    yield from move_x_y_z(
+    yield from bps.abs_set(
         composite.smargon,
-        _div_by_1000_if_not_none(params.x_start_um),
-        _div_by_1000_if_not_none(params.y_start_um),
-        _div_by_1000_if_not_none(params.z_start_um),
-        group=CONST.WAIT.MOVE_GONIO_TO_START,
-    )
-    yield from move_phi_chi_omega(
-        composite.smargon,
-        params.phi_start_deg,
-        params.chi_start_deg,
+        CombinedMove(
+            x=_div_by_1000_if_not_none(params.x_start_um),
+            y=_div_by_1000_if_not_none(params.y_start_um),
+            z=_div_by_1000_if_not_none(params.z_start_um),
+            phi=params.phi_start_deg,
+            chi=params.chi_start_deg,
+        ),
         group=CONST.WAIT.MOVE_GONIO_TO_START,
     )
+
     if params.take_snapshots:
         yield from bps.wait(CONST.WAIT.MOVE_GONIO_TO_START)
         yield from setup_beamline_for_OAV(
@@ -353,15 +350,15 @@ def _move_and_rotation(
             yield from bps.prepare(
                 composite.aperture_scatterguard,
                 params.selected_aperture,
-                group=CONST.WAIT.ROTATION_READY_FOR_DC,
+                group=CONST.WAIT.PREPARE_APERTURE,
             )
         yield from oav_snapshot_plan(composite, params, oav_params)
     yield from rotation_scan_plan(composite, params, motion_values)
 
 
-def multi_rotation_scan(
+def rotation_scan(
     composite: RotationScanComposite,
-    parameters: MultiRotationScan,
+    parameters: RotationScan,
     oav_params: OAVParameters | None = None,
 ) -> MsgGenerator:
     @bpp.set_run_key_decorator(CONST.PLAN.ROTATION_MULTI_OUTER)
@@ -373,15 +370,15 @@ def multi_rotation_scan(
             ),
         }
     )
-    def _wrapped_multi_rotation_scan():
-        yield from multi_rotation_scan_internal(composite, parameters, oav_params)
+    def _wrapped_rotation_scan():
+        yield from rotation_scan_internal(composite, parameters, oav_params)
 
-    yield from _wrapped_multi_rotation_scan()
+    yield from _wrapped_rotation_scan()
 
 
-def multi_rotation_scan_internal(
+def rotation_scan_internal(
     composite: RotationScanComposite,
-    parameters: MultiRotationScan,
+    parameters: RotationScan,
     oav_params: OAVParameters | None = None,
 ) -> MsgGenerator:
     parameters.features.update_self_from_server()
@@ -419,7 +416,7 @@ def multi_rotation_scan_internal(
                 }
             )
             def rotation_scan_core(
-                params: RotationScan,
+                params: SingleRotationScan,
             ):
                 yield from _move_and_rotation(composite, params, oav_params)
 

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -2,6 +2,7 @@ import dataclasses
 import json
 import re
 import traceback
+from collections.abc import Sequence
 from os import path
 from typing import Any, TypeVar
 
@@ -127,83 +128,88 @@ def get_param_version() -> SemanticVersion:
     return SemanticVersion.validate_from_str(str(PARAMETER_VERSION))
 
 
-def populate_parameters_from_agamemnon(agamemnon_params):
+def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreCollect]:
     visit, detector_distance = get_withvisit_parameters_from_agamemnon(agamemnon_params)
     with_energy_params = get_withenergy_parameters_from_agamemnon(agamemnon_params)
     pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
-    first_collection = agamemnon_params["collection"][0]
+    collections = agamemnon_params["collection"]
     visit_directory, file_name = path.split(agamemnon_params["prefix"])
-    return LoadCentreCollect.model_validate(
-        {
-            "parameter_model_version": get_param_version(),
-            "visit": visit,
-            "detector_distance_mm": detector_distance,
-            "sample_id": agamemnon_params["sample"]["id"],
-            "sample_puck": agamemnon_params["sample"]["container"],
-            "sample_pin": agamemnon_params["sample"]["position"],
-            "select_centres": {
-                "name": "TopNByMaxCount",
-                "n": pin_type.expected_number_of_crystals,
-            },
-            "robot_load_then_centre": {
-                "storage_directory": str(visit_directory) + "/xraycentring",
-                "file_name": file_name,
-                "tip_offset_um": pin_type.full_width / 2,
-                "grid_width_um": pin_type.full_width,
-                "omega_start_deg": 0.0,
-                "chi_start_deg": first_collection["chi"],
-                "transmission_frac": 1.0,
-                "features": {"use_gpu_results": True},
-                **with_energy_params,
-            },
-            "multi_rotation_scan": {
-                "comment": first_collection["comment"],
-                "storage_directory": str(visit_directory),
-                "exposure_time_s": first_collection["exposure_time"],
-                "file_name": file_name,
-                "transmission_frac": first_collection["transmission"],
-                "rotation_increment_deg": first_collection["omega_increment"],
-                "ispyb_experiment_type": first_collection["experiment_type"],
-                "snapshot_omegas_deg": [0.0, 90.0, 180.0, 270.0],
-                "rotation_scans": [
-                    {
-                        "scan_width_deg": (
-                            first_collection["number_of_images"]
-                            * first_collection["omega_increment"]
-                        ),
-                        "omega_start_deg": first_collection["omega_start"],
-                        "phi_start_deg": first_collection["phi_start"],
-                        "chi_start_deg": first_collection["chi"],
-                        "rotation_direction": "Positive",
-                    }
-                ],
-                **with_energy_params,
-            },
-        }
-    )
+
+    return [
+        LoadCentreCollect.model_validate(
+            {
+                "parameter_model_version": get_param_version(),
+                "visit": visit,
+                "detector_distance_mm": detector_distance,
+                "sample_id": agamemnon_params["sample"]["id"],
+                "sample_puck": agamemnon_params["sample"]["container"],
+                "sample_pin": agamemnon_params["sample"]["position"],
+                "select_centres": {
+                    "name": "TopNByMaxCount",
+                    "n": pin_type.expected_number_of_crystals,
+                },
+                "robot_load_then_centre": {
+                    "storage_directory": str(visit_directory) + "/xraycentring",
+                    "file_name": file_name,
+                    "tip_offset_um": pin_type.full_width / 2,
+                    "grid_width_um": pin_type.full_width,
+                    "omega_start_deg": 0.0,
+                    "chi_start_deg": collection["chi"],
+                    "transmission_frac": 1.0,
+                    "features": {"use_gpu_results": True},
+                    **with_energy_params,
+                },
+                "multi_rotation_scan": {
+                    "comment": collection["comment"],
+                    "storage_directory": str(visit_directory),
+                    "exposure_time_s": collection["exposure_time"],
+                    "file_name": file_name,
+                    "transmission_frac": collection["transmission"],
+                    "rotation_increment_deg": collection["omega_increment"],
+                    "ispyb_experiment_type": collection["experiment_type"],
+                    "snapshot_omegas_deg": [0.0, 90.0, 180.0, 270.0],
+                    "rotation_scans": [
+                        {
+                            "scan_width_deg": (
+                                collection["number_of_images"]
+                                * collection["omega_increment"]
+                            ),
+                            "omega_start_deg": collection["omega_start"],
+                            "phi_start_deg": collection["phi_start"],
+                            "chi_start_deg": collection["chi"],
+                            "rotation_direction": "Positive",
+                        }
+                    ],
+                    **with_energy_params,
+                },
+            }
+        )
+        for collection in collections
+    ]
 
 
-def create_parameters_from_agamemnon() -> LoadCentreCollect | None:
+def create_parameters_from_agamemnon() -> Sequence[LoadCentreCollect]:
     beamline_name = get_beamline_name("i03")
     agamemnon_params = get_next_instruction(beamline_name)
     return (
-        populate_parameters_from_agamemnon(agamemnon_params)
-        if agamemnon_params
-        else None
+        populate_parameters_from_agamemnon(agamemnon_params) if agamemnon_params else []
     )
 
 
-def compare_params(load_centre_collect_params):
+def compare_params(load_centre_collect_params: LoadCentreCollect):
     try:
-        parameters = create_parameters_from_agamemnon()
+        lcc_requests = create_parameters_from_agamemnon()
         # Log differences against GDA populated parameters
-        differences = DeepDiff(
-            parameters, load_centre_collect_params, math_epsilon=1e-5
-        )
-        if differences:
-            LOGGER.info(
-                f"Different parameters found when directly reading from Hyperion: {differences}"
+        if not lcc_requests:
+            LOGGER.info("Agamemnon returned no instructions")
+        else:
+            differences = DeepDiff(
+                lcc_requests[0], load_centre_collect_params, math_epsilon=1e-5
             )
+            if differences:
+                LOGGER.info(
+                    f"Different parameters found when directly reading from Hyperion: {differences}"
+                )
     except (ValueError, KeyError):
         LOGGER.warning(f"Failed to compare parameters: {traceback.format_exc()}")
     except Exception:

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -93,7 +93,7 @@ def setup_logging(dev_mode: bool):
         (ISPYB_ZOCALO_CALLBACK_LOGGER, "hyperion_ispyb_callback.log"),
         (NEXUS_LOGGER, "hyperion_nexus_callback.log"),
     ]:
-        logging_path, debug_logging_path = _get_logging_dirs()
+        logging_path, debug_logging_path = _get_logging_dirs(dev_mode)
         if logger.handlers == []:
             handlers = set_up_all_logging_handlers(
                 logger,

mx_bluesky/hyperion/external_interaction/callbacks/rotation/ispyb_callback.py

@@ -25,7 +25,7 @@ from mx_bluesky.hyperion.external_interaction.callbacks.rotation.ispyb_mapping i
     populate_data_collection_info_for_rotation,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.rotation import RotationScan
+from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 if TYPE_CHECKING:
     from event_model.documents import Event, RunStart, RunStop
@@ -62,7 +62,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             )
             hyperion_params = doc.get("mx_bluesky_parameters")
             assert isinstance(hyperion_params, str)
-            self.params = RotationScan.model_validate_json(hyperion_params)
+            self.params = SingleRotationScan.model_validate_json(hyperion_params)
             dcgid = (
                 self.ispyb_ids.data_collection_group_id
                 if (self.params.sample_id == self.last_sample_id)
@@ -86,7 +86,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             ISPYB_ZOCALO_CALLBACK_LOGGER.info("Beginning ispyb deposition")
             data_collection_group_info = populate_data_collection_group(self.params)
             data_collection_info = populate_data_collection_info_for_rotation(
-                cast(RotationScan, self.params)
+                cast(SingleRotationScan, self.params)
             )
             data_collection_info = populate_remaining_data_collection_info(
                 self.params.comment,

mx_bluesky/hyperion/external_interaction/callbacks/rotation/ispyb_mapping.py

@@ -1,17 +1,20 @@
 from __future__ import annotations
 
 from mx_bluesky.common.external_interaction.ispyb.data_model import DataCollectionInfo
-from mx_bluesky.hyperion.parameters.rotation import RotationScan
+from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 
-def populate_data_collection_info_for_rotation(params: RotationScan):
+def populate_data_collection_info_for_rotation(params: SingleRotationScan):
     info = DataCollectionInfo(
         omega_start=params.omega_start_deg,
         data_collection_number=params.detector_params.run_number,  # type:ignore # the validator always makes this int
         n_images=params.num_images,
         axis_range=params.rotation_increment_deg,
         axis_start=params.omega_start_deg,
-        axis_end=(params.omega_start_deg + params.scan_width_deg),
+        axis_end=(
+            params.omega_start_deg
+            + params.scan_width_deg * params.rotation_direction.multiplier
+        ),
         kappa_start=params.kappa_start_deg,
     )
     return info

mx_bluesky/hyperion/external_interaction/callbacks/rotation/nexus_callback.py

@@ -16,7 +16,7 @@ from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
 from mx_bluesky.common.external_interaction.nexus.write_nexus import NexusWriter
 from mx_bluesky.common.utils.log import NEXUS_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.rotation import RotationScan
+from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart
@@ -85,7 +85,7 @@ class RotationNexusFileCallback(PlanReactiveCallback):
             NEXUS_LOGGER.info(
                 f"Nexus writer received start document with experiment parameters {hyperion_params}"
             )
-            parameters = RotationScan.model_validate_json(hyperion_params)
+            parameters = SingleRotationScan.model_validate_json(hyperion_params)
             NEXUS_LOGGER.info("Setting up nexus file...")
 
             det_size = (

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -21,7 +21,9 @@ class HyperionFeatureFlags(FeatureFlags):
         set_stub_offsets:               If True then set the stub offsets after moving to the crystal (ignored for
             multi-centre)
         omega_flip:                     If True then invert the smargon omega motor rotation commands with respect to
-         the hyperion request.
+         the hyperion request. See "Hyperion Coordinate Systems" in the documentation.
+        alternate_rotation_direction:   If True then the for multi-sample pins the rotation direction of
+         successive rotation scans is alternated between positive and negative.
     """
 
     @staticmethod
@@ -41,3 +43,4 @@ class HyperionFeatureFlags(FeatureFlags):
     use_gpu_results: bool = CONST.I03.USE_GPU_RESULTS
     set_stub_offsets: bool = CONST.I03.SET_STUB_OFFSETS
     omega_flip: bool = CONST.I03.OMEGA_FLIP
+    alternate_rotation_direction: bool = CONST.I03.ALTERNATE_ROTATION_DIRECTION

mx_bluesky/hyperion/parameters/cli.py

@@ -8,7 +8,6 @@ from mx_bluesky._version import version
 @dataclass
 class HyperionArgs:
     dev_mode: bool = False
-    verbose_event_logging: bool = False
 
 
 def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
@@ -29,16 +28,11 @@ def parse_callback_dev_mode_arg() -> bool:
 
 
 def parse_cli_args() -> HyperionArgs:
-    """Parses all arguments relevant to hyperion. Returns an HyperionArgs dataclass with
-    the fields: (verbose_event_logging: bool,
-                 dev_mode: bool)"""
+    """Parses all arguments relevant to hyperion.
+    Returns:
+         an HyperionArgs dataclass with the fields: (dev_mode: bool)"""
     parser = argparse.ArgumentParser()
     _add_callback_relevant_args(parser)
-    parser.add_argument(
-        "--verbose-event-logging",
-        action="store_true",
-        help="Log all bluesky event documents to graylog",
-    )
     parser.add_argument(
         "--version",
         help="Print hyperion version string",
@@ -47,6 +41,5 @@ def parse_cli_args() -> HyperionArgs:
     )
     args = parser.parse_args()
     return HyperionArgs(
-        verbose_event_logging=args.verbose_event_logging or False,
         dev_mode=args.dev or False,
     )

mx_bluesky/hyperion/parameters/constants.py

@@ -19,7 +19,6 @@ TEST_MODE = os.environ.get("HYPERION_TEST_MODE")
 
 @dataclass(frozen=True)
 class I03Constants:
-    BASE_DATA_DIR = "/tmp/dls/i03/data/" if TEST_MODE else "/dls/i03/data/"
     BEAMLINE = "BL03S" if TEST_MODE else "BL03I"
     DETECTOR = EIGER2_X_16M_SIZE
     INSERTION_PREFIX = "SR03S" if TEST_MODE else "SR03I"
@@ -28,6 +27,7 @@ class I03Constants:
     USE_PANDA_FOR_GRIDSCAN = False
     SET_STUB_OFFSETS = False
     OMEGA_FLIP = True
+    ALTERNATE_ROTATION_DIRECTION = True
 
     # Turns on GPU processing for zocalo and logs a comparison between GPU and CPU-
     # processed results.

mx_bluesky/hyperion/parameters/device_composites.py

@@ -7,19 +7,14 @@ from dodal.devices.aperturescatterguard import (
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
 from dodal.devices.common_dcm import BaseDCM
-from dodal.devices.detector.detector_motion import DetectorMotion
 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 import Beamstop
-from dodal.devices.oav.oav_detector import OAV
-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
@@ -28,9 +23,12 @@ from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
 from dodal.devices.zocalo import ZocaloResults
 from ophyd_async.fastcs.panda import HDFPanda
 
-from mx_bluesky.common.plans.common_flyscan_xray_centre_plan import (
+from mx_bluesky.common.experiment_plans.common_flyscan_xray_centre_plan import (
     FlyScanEssentialDevices,
 )
+from mx_bluesky.common.parameters.device_composites import (
+    GridDetectThenXRayCentreComposite,
+)
 
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
@@ -57,28 +55,8 @@ class HyperionFlyScanXRayCentreComposite(FlyScanEssentialDevices):
 
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
-class GridDetectThenXRayCentreComposite:
+class HyperionGridDetectThenXRayCentreComposite(GridDetectThenXRayCentreComposite):
     """All devices which are directly or indirectly required by this plan"""
 
-    aperture_scatterguard: ApertureScatterguard
-    attenuator: BinaryFilterAttenuator
-    backlight: Backlight
-    beamstop: Beamstop
-    dcm: BaseDCM
-    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

mx_bluesky/hyperion/parameters/load_centre_collect.py

@@ -12,7 +12,7 @@ from mx_bluesky.hyperion.parameters.components import WithHyperionUDCFeatures
 from mx_bluesky.hyperion.parameters.robot_load import (
     RobotLoadThenCentre,
 )
-from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan
+from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
 T = TypeVar("T", bound=BaseModel)
 
@@ -34,7 +34,7 @@ class LoadCentreCollect(
     pin-tip centre and rotation scan operations."""
 
     robot_load_then_centre: RobotLoadThenCentre
-    multi_rotation_scan: MultiRotationScan
+    multi_rotation_scan: RotationScan
 
     @model_validator(mode="before")
     @classmethod
@@ -42,7 +42,7 @@ class LoadCentreCollect(
         allowed_keys = (
             LoadCentreCollect.model_fields.keys()
             | RobotLoadThenCentre.model_fields.keys()
-            | MultiRotationScan.model_fields.keys()
+            | RotationScan.model_fields.keys()
         )
 
         disallowed_keys = values.keys() - allowed_keys
@@ -74,7 +74,7 @@ class LoadCentreCollect(
             values, values["robot_load_then_centre"], RobotLoadThenCentre
         )
         new_multi_rotation_scan_params = construct_from_values(
-            values, values["multi_rotation_scan"], MultiRotationScan
+            values, values["multi_rotation_scan"], RotationScan
         )
         values["multi_rotation_scan"] = new_multi_rotation_scan_params
         values["robot_load_then_centre"] = new_robot_load_then_centre_params

mx_bluesky/hyperion/parameters/rotation.py

@@ -42,7 +42,8 @@ class RotationScanPerSweep(OptionalGonioAngleStarts, OptionalXyzStarts):
         omega_start_deg: The initial angle of the rotation in degrees (default 0)
         scan_width_deg: The sweep of the rotation in degrees, this must be positive (default 360)
         rotation_direction: Indicates the direction of rotation, if RotationDirection.POSITIVE
-            the final angle is obtained by adding scan_width_deg, otherwise by subtraction (default NEGATIVE)
+            the final angle is obtained by adding scan_width_deg, otherwise by subtraction (default NEGATIVE).
+            See "Hyperion Coordinate Systems" in the documentation.
         nexus_vds_start_img: The frame number of the first frame captured during the rotation
     """
 
@@ -104,7 +105,7 @@ class RotationExperiment(DiffractionExperimentWithSample, WithHyperionUDCFeature
             return aperture_position
 
 
-class RotationScan(WithScan, RotationScanPerSweep, RotationExperiment):
+class SingleRotationScan(WithScan, RotationScanPerSweep, RotationExperiment):
     @property
     def detector_params(self):
         return self._detector_params(self.omega_start_deg)
@@ -129,12 +130,12 @@ class RotationScan(WithScan, RotationScanPerSweep, RotationExperiment):
         return int(self.scan_width_deg / self.rotation_increment_deg)
 
 
-class MultiRotationScan(RotationExperiment, SplitScan):
+class RotationScan(RotationExperiment, SplitScan):
     rotation_scans: Annotated[list[RotationScanPerSweep], Len(min_length=1)]
 
-    def _single_rotation_scan(self, scan: RotationScanPerSweep) -> RotationScan:
+    def _single_rotation_scan(self, scan: RotationScanPerSweep) -> SingleRotationScan:
         # self has everything from RotationExperiment
-        allowed_keys = RotationScan.model_fields.keys()  # type: ignore # mypy doesn't recognise this as a property...
+        allowed_keys = SingleRotationScan.model_fields.keys()  # type: ignore # mypy doesn't recognise this as a property...
         params_dump = self.model_dump()
         # provided `scan` has everything from RotationScanPerSweep
         scan_dump = scan.model_dump()
@@ -142,13 +143,13 @@ class MultiRotationScan(RotationExperiment, SplitScan):
             k: v for k, v in (params_dump | scan_dump).items() if k in allowed_keys
         }
         # together they have everything for RotationScan
-        rotation_scan = RotationScan(**rotation_scan_kv_pairs)
+        rotation_scan = SingleRotationScan(**rotation_scan_kv_pairs)
         return rotation_scan
 
     @model_validator(mode="after")
     @classmethod
     def correct_start_vds(cls, values: Any) -> Any:
-        assert isinstance(values, MultiRotationScan)
+        assert isinstance(values, RotationScan)
         start_img = 0.0
         for scan in values.rotation_scans:
             scan.nexus_vds_start_img = int(start_img)
@@ -167,7 +168,7 @@ class MultiRotationScan(RotationExperiment, SplitScan):
         return self
 
     @property
-    def single_rotation_scans(self) -> Iterator[RotationScan]:
+    def single_rotation_scans(self) -> Iterator[SingleRotationScan]:
         for scan in self.rotation_scans:
             yield self._single_rotation_scan(scan)
 

mx_bluesky/hyperion/utils/context.py

@@ -5,11 +5,14 @@ import mx_bluesky.hyperion.experiment_plans as hyperion_plans
 from mx_bluesky.common.utils.log import LOGGER
 
 
-def setup_context() -> BlueskyContext:
+def setup_context(dev_mode: bool = False) -> BlueskyContext:
     context = BlueskyContext()
     context.with_plan_module(hyperion_plans)
 
-    context.with_dodal_module(get_beamline_based_on_environment_variable())
+    context.with_dodal_module(
+        get_beamline_based_on_environment_variable(),
+        mock=dev_mode,
+    )
 
     LOGGER.info(f"Plans found in context: {context.plan_functions.keys()}")