mx-bluesky 1.4.2__py3-none-any.whl → 1.4.4__py3-none-any.whl

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

@@ -3,28 +3,27 @@ from __future__ import annotations
 from collections.abc import Callable, Sequence
 from typing import TYPE_CHECKING, Any, cast
 
-from mx_bluesky.common.parameters.components import IspybExperimentType
-from mx_bluesky.common.utils.log import set_dcgid_tag
-from mx_bluesky.hyperion.external_interaction.callbacks.common.ispyb_mapping import (
-    populate_data_collection_group,
-    populate_remaining_data_collection_info,
-)
-from mx_bluesky.hyperion.external_interaction.callbacks.ispyb_callback_base import (
+from mx_bluesky.common.external_interaction.callbacks.common.ispyb_callback_base import (
     BaseISPyBCallback,
 )
-from mx_bluesky.hyperion.external_interaction.callbacks.rotation.ispyb_mapping import (
-    populate_data_collection_info_for_rotation,
+from mx_bluesky.common.external_interaction.callbacks.common.ispyb_mapping import (
+    populate_data_collection_group,
+    populate_remaining_data_collection_info,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
+from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionInfo,
     DataCollectionPositionInfo,
     ScanDataInfo,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
+from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
     IspybIds,
     StoreInIspyb,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER
+from mx_bluesky.common.parameters.components import IspybExperimentType
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_tag
+from mx_bluesky.hyperion.external_interaction.callbacks.rotation.ispyb_mapping import (
+    populate_data_collection_info_for_rotation,
+)
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
@@ -58,10 +57,10 @@ class RotationISPyBCallback(BaseISPyBCallback):
 
     def activity_gated_start(self, doc: RunStart):
         if doc.get("subplan_name") == CONST.PLAN.ROTATION_OUTER:
-            ISPYB_LOGGER.info(
+            ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                 "ISPyB callback received start document with experiment parameters."
             )
-            hyperion_params = doc.get("hyperion_parameters")
+            hyperion_params = doc.get("mx_bluesky_parameters")
             assert isinstance(hyperion_params, str)
             self.params = RotationScan.model_validate_json(hyperion_params)
             dcgid = (
@@ -73,16 +72,18 @@ class RotationISPyBCallback(BaseISPyBCallback):
                 self.params.ispyb_experiment_type
                 == IspybExperimentType.CHARACTERIZATION
             ):
-                ISPYB_LOGGER.info("Screening collection - using new DCG")
+                ISPYB_ZOCALO_CALLBACK_LOGGER.info(
+                    "Screening collection - using new DCG"
+                )
                 dcgid = None
                 self.last_sample_id = None
             else:
-                ISPYB_LOGGER.info(
+                ISPYB_ZOCALO_CALLBACK_LOGGER.info(
                     f"Collection is {self.params.ispyb_experiment_type} - storing sampleID to bundle images"
                 )
                 self.last_sample_id = self.params.sample_id
             self.ispyb = StoreInIspyb(self.ispyb_config)
-            ISPYB_LOGGER.info("Beginning ispyb deposition")
+            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)
@@ -100,7 +101,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             self.ispyb_ids = self.ispyb.begin_deposition(
                 data_collection_group_info, [scan_data_info]
             )
-        ISPYB_LOGGER.info("ISPYB handler received start document.")
+        ISPYB_ZOCALO_CALLBACK_LOGGER.info("ISPYB handler received start document.")
         if doc.get("subplan_name") == CONST.PLAN.ROTATION_MAIN:
             self.uid_to_finalize_on = doc.get("uid")
         return super().activity_gated_start(doc)
@@ -111,9 +112,9 @@ class RotationISPyBCallback(BaseISPyBCallback):
         event_sourced_position_info: DataCollectionPositionInfo | None,
         params,
     ) -> Sequence[ScanDataInfo]:
-        assert (
-            self.ispyb_ids.data_collection_ids
-        ), "Expect an existing DataCollection to update"
+        assert self.ispyb_ids.data_collection_ids, (
+            "Expect an existing DataCollection to update"
+        )
 
         return [
             ScanDataInfo(
@@ -131,9 +132,9 @@ class RotationISPyBCallback(BaseISPyBCallback):
             doc["data"]["smargon-y"],
             doc["data"]["smargon-z"],
         ]
-        assert (
-            self.params
-        ), "handle_ispyb_hardware_read triggered before activity_gated_start"
+        assert self.params, (
+            "handle_ispyb_hardware_read triggered before activity_gated_start"
+        )
         motor_positions_um = [position * 1000 for position in motor_positions_mm]
         comment = f"Sample position (µm): ({motor_positions_um[0]:.0f}, {motor_positions_um[1]:.0f}, {motor_positions_um[2]:.0f}) {self.params.comment} "
         scan_data_infos[0].data_collection_info.comments = comment

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

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from mx_bluesky.hyperion.external_interaction.ispyb.data_model import DataCollectionInfo
+from mx_bluesky.common.external_interaction.ispyb.data_model import DataCollectionInfo
 from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
 

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

@@ -2,20 +2,22 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback import (
+from mx_bluesky.common.external_interaction.callbacks.common.logging_callback import (
+    format_doc_for_log,
+)
+from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
-from mx_bluesky.hyperion.external_interaction.nexus.nexus_utils import (
+from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
+    AxisDirection,
     create_beam_and_attenuator_parameters,
     vds_type_based_on_bit_depth,
 )
-from mx_bluesky.hyperion.external_interaction.nexus.write_nexus import NexusWriter
-from mx_bluesky.hyperion.log import NEXUS_LOGGER
+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 ..logging_callback import format_doc_for_log
-
 if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart
 
@@ -64,7 +66,7 @@ class RotationNexusFileCallback(PlanReactiveCallback):
                 self.writer.attenuator,
             ) = create_beam_and_attenuator_parameters(
                 data["dcm-energy_in_kev"],
-                data["flux_flux_reading"],
+                data["flux-flux_reading"],
                 data["attenuator-actual_transmission"],
             )
             vds_data_type = vds_type_based_on_bit_depth(doc["data"]["eiger_bit_depth"])
@@ -78,7 +80,7 @@ class RotationNexusFileCallback(PlanReactiveCallback):
             self.meta_data_run_number = doc.get("meta_data_run_number")
         if doc.get("subplan_name") == CONST.PLAN.ROTATION_OUTER:
             self.run_uid = doc.get("uid")
-            hyperion_params = doc.get("hyperion_parameters")
+            hyperion_params = doc.get("mx_bluesky_parameters")
             assert isinstance(hyperion_params, str)
             NEXUS_LOGGER.info(
                 f"Nexus writer received start document with experiment parameters {hyperion_params}"
@@ -100,5 +102,7 @@ class RotationNexusFileCallback(PlanReactiveCallback):
                 vds_start_index=parameters.nexus_vds_start_img,
                 full_num_of_images=self.full_num_of_images,
                 meta_data_run_number=self.meta_data_run_number,
-                rotation_direction=parameters.rotation_direction,
+                axis_direction=AxisDirection.NEGATIVE
+                if parameters.features.omega_flip
+                else AxisDirection.POSITIVE,
             )

mx_bluesky/hyperion/external_interaction/callbacks/sample_handling/sample_handling_callback.py

@@ -1,45 +1,14 @@
-import dataclasses
-from collections.abc import Generator
-from functools import partial
-from typing import Any
+from event_model import RunStart, RunStop
 
-import bluesky.plan_stubs as bps
-from bluesky.preprocessors import contingency_wrapper
-from bluesky.utils import Msg, make_decorator
-from event_model import Event, EventDescriptor, RunStart
-
-from mx_bluesky.hyperion.exceptions import CrystalNotFoundException, SampleException
-from mx_bluesky.hyperion.external_interaction.callbacks.common.abstract_event import (
-    AbstractEvent,
-)
-from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback import (
+from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
-from mx_bluesky.hyperion.external_interaction.ispyb.exp_eye_store import (
+from mx_bluesky.common.external_interaction.ispyb.exp_eye_store import (
     BLSampleStatus,
     ExpeyeInteraction,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
-
-# TODO remove this event-raising shenanigans once
-# https://github.com/bluesky/bluesky/issues/1829 is addressed
-
-
-@dataclasses.dataclass(frozen=True)
-class _ExceptionEvent(AbstractEvent):
-    exception_type: str
-
-
-def _exception_interceptor(exception: Exception) -> Generator[Msg, Any, Any]:
-    yield from bps.create(CONST.DESCRIPTORS.SAMPLE_HANDLING_EXCEPTION)
-    yield from bps.read(_ExceptionEvent(type(exception).__name__))
-    yield from bps.save()
-
-
-sample_handling_callback_decorator = make_decorator(
-    partial(contingency_wrapper, except_plan=_exception_interceptor)
-)
+from mx_bluesky.common.utils.exceptions import CrystalNotFoundException, SampleException
+from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
 
 
 class SampleHandlingCallback(PlanReactiveCallback):
@@ -47,7 +16,7 @@ class SampleHandlingCallback(PlanReactiveCallback):
     field according to the type of exception raised."""
 
     def __init__(self):
-        super().__init__(log=ISPYB_LOGGER)
+        super().__init__(log=ISPYB_ZOCALO_CALLBACK_LOGGER)
         self._sample_id: int | None = None
         self._descriptor: str | None = None
 
@@ -57,16 +26,13 @@ class SampleHandlingCallback(PlanReactiveCallback):
             self.log.info(f"Recording sample ID at run start {sample_id}")
             self._sample_id = sample_id
 
-    def activity_gated_descriptor(self, doc: EventDescriptor) -> EventDescriptor | None:
-        if doc.get("name") == CONST.DESCRIPTORS.SAMPLE_HANDLING_EXCEPTION:
-            self._descriptor = doc["uid"]
-        return super().activity_gated_descriptor(doc)
-
-    def activity_gated_event(self, doc: Event) -> Event | None:
-        if doc["descriptor"] == self._descriptor:
-            exception_type = doc["data"]["exception_type"]
+    def activity_gated_stop(self, doc: RunStop) -> RunStop:
+        if doc["exit_status"] != "success":
+            exception_type, message = SampleException.type_and_message_from_reason(
+                doc.get("reason", "")
+            )
             self.log.info(
-                f"Sample handling callback intercepted exception of type {exception_type}"
+                f"Sample handling callback intercepted exception of type {exception_type}: {message}"
             )
             self._record_exception(exception_type)
         return doc

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -3,11 +3,24 @@ from functools import cache
 from daq_config_server.client import ConfigServer
 
 from mx_bluesky.common.external_interaction.config_server import FeatureFlags
-from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 
 
 class HyperionFeatureFlags(FeatureFlags):
+    """
+    Feature flags specific to Hyperion.
+
+    Attributes:
+        use_panda_for_gridscan:         If True then the PandA is used for gridscans, otherwise the zebra is used
+        compare_cpu_and_gpu_zocalo:     If True then GPU result processing is enabled alongside CPU, if False then
+            CPU only is used.
+        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.
+    """
+
     @staticmethod
     @cache
     def get_config_server() -> ConfigServer:
@@ -16,3 +29,4 @@ class HyperionFeatureFlags(FeatureFlags):
     use_panda_for_gridscan: bool = CONST.I03.USE_PANDA_FOR_GRIDSCAN
     compare_cpu_and_gpu_zocalo: bool = CONST.I03.COMPARE_CPU_AND_GPU_ZOCALO
     set_stub_offsets: bool = CONST.I03.SET_STUB_OFFSETS
+    omega_flip: bool = CONST.I03.OMEGA_FLIP

mx_bluesky/hyperion/parameters/components.py

@@ -1,7 +1,8 @@
-from pydantic import BaseModel, Field
+from pydantic import Field
 
+from mx_bluesky.common.parameters.components import WithPandaGridScan
 from mx_bluesky.hyperion.external_interaction.config_server import HyperionFeatureFlags
 
 
-class WithHyperionFeatures(BaseModel):
+class WithHyperionUDCFeatures(WithPandaGridScan):
     features: HyperionFeatureFlags = Field(default=HyperionFeatureFlags())

mx_bluesky/hyperion/parameters/constants.py

@@ -28,6 +28,7 @@ class I03Constants:
     SHUTTER_TIME_S = 0.06
     USE_PANDA_FOR_GRIDSCAN = False
     SET_STUB_OFFSETS = False
+    OMEGA_FLIP = True
 
     # Turns on GPU processing for zocalo and logs a comparison between GPU and CPU-
     # processed results. GPU results never used in analysis for now

mx_bluesky/hyperion/parameters/gridscan.py

@@ -7,27 +7,20 @@ from dodal.devices.fast_grid_scan import (
     PandAGridScanParams,
     ZebraGridScanParams,
 )
-from pydantic import Field, PrivateAttr
-from scanspec.core import Path as ScanPath
-from scanspec.specs import Line, Static
-
-from mx_bluesky.common.parameters.components import (
-    SplitScan,
-    WithOptionalEnergyChange,
-    WithPandaGridScan,
-)
+
 from mx_bluesky.common.parameters.gridscan import (
     GridCommon,
-    SpecifiedGrid,
+    SpecifiedThreeDGridScan,
 )
-from mx_bluesky.hyperion.parameters.components import WithHyperionFeatures
+from mx_bluesky.hyperion.parameters.components import WithHyperionUDCFeatures
 from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 
 
-class HyperionGridCommon(GridCommon, WithHyperionFeatures):
-    # This class only exists so that we can properly select enable_dev_shm. Remove in
-    # https://github.com/DiamondLightSource/hyperion/issues/1395"""
+class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
+    """Used by models which require detector parameters but have no specifications of the grid"""
 
+    # These detector params only exist so that we can properly select enable_dev_shm. Remove in
+    # https://github.com/DiamondLightSource/hyperion/issues/1395"""
     @property
     def detector_params(self):
         self.det_dist_to_beam_converter_path = (
@@ -37,9 +30,9 @@ class HyperionGridCommon(GridCommon, WithHyperionFeatures):
         optional_args = {}
         if self.run_number:
             optional_args["run_number"] = self.run_number
-        assert (
-            self.detector_distance_mm is not None
-        ), "Detector distance must be filled before generating DetectorParams"
+        assert self.detector_distance_mm is not None, (
+            "Detector distance must be filled before generating DetectorParams"
+        )
         return DetectorParams(
             detector_size_constants=I03Constants.DETECTOR,
             expected_energy_ev=self.demand_energy_ev,
@@ -59,28 +52,42 @@ class HyperionGridCommon(GridCommon, WithHyperionFeatures):
         )
 
 
-class HyperionThreeDGridScan(
-    HyperionGridCommon,
-    SpecifiedGrid,
-    SplitScan,
-    WithOptionalEnergyChange,
-    WithPandaGridScan,
-):
-    """Parameters representing a so-called 3D grid scan, which consists of doing a
-    gridscan in X and Y, followed by one in X and Z."""
-
-    grid1_omega_deg: float = Field(default=CONST.PARAM.GRIDSCAN.OMEGA_1)  # type: ignore
-    grid2_omega_deg: float = Field(default=CONST.PARAM.GRIDSCAN.OMEGA_2)
-    x_step_size_um: float = Field(default=CONST.PARAM.GRIDSCAN.BOX_WIDTH_UM)
-    y_step_size_um: float = Field(default=CONST.PARAM.GRIDSCAN.BOX_WIDTH_UM)
-    z_step_size_um: float = Field(default=CONST.PARAM.GRIDSCAN.BOX_WIDTH_UM)
-    y2_start_um: float
-    z2_start_um: float
-    x_steps: int = Field(gt=0)
-    y_steps: int = Field(gt=0)
-    z_steps: int = Field(gt=0)
-    _set_stub_offsets: bool = PrivateAttr(default_factory=lambda: False)
+class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan, WithHyperionUDCFeatures):
+    """Hyperion's 3D grid scan deviates from the common class due to: optionally using a PandA, optionally using dev_shm for GPU analysis, and using a config server for features"""
+
+    # These detector params only exist so that we can properly select enable_dev_shm. Remove in
+    # https://github.com/DiamondLightSource/hyperion/issues/1395"""
+    @property
+    def detector_params(self):
+        self.det_dist_to_beam_converter_path = (
+            self.det_dist_to_beam_converter_path
+            or CONST.PARAM.DETECTOR.BEAM_XY_LUT_PATH
+        )
+        optional_args = {}
+        if self.run_number:
+            optional_args["run_number"] = self.run_number
+        assert self.detector_distance_mm is not None, (
+            "Detector distance must be filled before generating DetectorParams"
+        )
+        return DetectorParams(
+            detector_size_constants=I03Constants.DETECTOR,
+            expected_energy_ev=self.demand_energy_ev,
+            exposure_time=self.exposure_time_s,
+            directory=self.storage_directory,
+            prefix=self.file_name,
+            detector_distance=self.detector_distance_mm,
+            omega_start=self.omega_start_deg or 0,
+            omega_increment=0,
+            num_images_per_trigger=1,
+            num_triggers=self.num_images,
+            use_roi_mode=self.use_roi_mode,
+            det_dist_to_beam_converter_path=self.det_dist_to_beam_converter_path,
+            trigger_mode=self.trigger_mode,
+            enable_dev_shm=self.features.compare_cpu_and_gpu_zocalo,
+            **optional_args,
+        )
 
+    # Relative to common grid scan, stub offsets are defined by config server
     @property
     def FGS_params(self) -> ZebraGridScanParams:
         return ZebraGridScanParams(
@@ -124,59 +131,17 @@ class HyperionThreeDGridScan(
             transmission_fraction=self.transmission_frac,
         )
 
-    def do_set_stub_offsets(self, value: bool):
-        self._set_stub_offsets = value
-
-    @property
-    def grid_1_spec(self):
-        x_end = self.x_start_um + self.x_step_size_um * (self.x_steps - 1)
-        y1_end = self.y_start_um + self.y_step_size_um * (self.y_steps - 1)
-        grid_1_x = Line("sam_x", self.x_start_um, x_end, self.x_steps)
-        grid_1_y = Line("sam_y", self.y_start_um, y1_end, self.y_steps)
-        grid_1_z = Static("sam_z", self.z_start_um)
-        return grid_1_y.zip(grid_1_z) * ~grid_1_x
-
-    @property
-    def grid_2_spec(self):
-        x_end = self.x_start_um + self.x_step_size_um * (self.x_steps - 1)
-        z2_end = self.z2_start_um + self.z_step_size_um * (self.z_steps - 1)
-        grid_2_x = Line("sam_x", self.x_start_um, x_end, self.x_steps)
-        grid_2_z = Line("sam_z", self.z2_start_um, z2_end, self.z_steps)
-        grid_2_y = Static("sam_y", self.y2_start_um)
-        return grid_2_z.zip(grid_2_y) * ~grid_2_x
-
-    @property
-    def scan_indices(self):
-        """The first index of each gridscan, useful for writing nexus files/VDS"""
-        return [
-            0,
-            len(ScanPath(self.grid_1_spec.calculate()).consume().midpoints["sam_x"]),
-        ]
-
-    @property
-    def scan_spec(self):
-        """A fully specified ScanSpec object representing both grids, with x, y, z and
-        omega positions."""
-        return self.grid_1_spec.concat(self.grid_2_spec)
 
-    @property
-    def scan_points(self):
-        """A list of all the points in the scan_spec."""
-        return ScanPath(self.scan_spec.calculate()).consume().midpoints
-
-    @property
-    def scan_points_first_grid(self):
-        """A list of all the points in the first grid scan."""
-        return ScanPath(self.grid_1_spec.calculate()).consume().midpoints
+class OddYStepsException(Exception): ...
 
-    @property
-    def scan_points_second_grid(self):
-        """A list of all the points in the second grid scan."""
-        return ScanPath(self.grid_2_spec.calculate()).consume().midpoints
 
-    @property
-    def num_images(self) -> int:
-        return len(self.scan_points["sam_x"])
+class PinTipCentreThenXrayCentre(
+    GridCommonWithHyperionDetectorParams, WithHyperionUDCFeatures
+):
+    tip_offset_um: float = 0
 
 
-class OddYStepsException(Exception): ...
+class GridScanWithEdgeDetect(
+    GridCommonWithHyperionDetectorParams, WithHyperionUDCFeatures
+):
+    pass

mx_bluesky/hyperion/parameters/load_centre_collect.py

@@ -1,4 +1,4 @@
-from typing import TypeVar
+from typing import Self, TypeVar
 
 from pydantic import BaseModel, model_validator
 
@@ -8,7 +8,8 @@ from mx_bluesky.common.parameters.components import (
     WithSample,
     WithVisit,
 )
-from mx_bluesky.common.parameters.gridscan import (
+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
@@ -23,7 +24,11 @@ def construct_from_values(parent_context: dict, child_dict: dict, t: type[T]) ->
 
 
 class LoadCentreCollect(
-    MxBlueskyParameters, WithVisit, WithSample, WithCentreSelection
+    MxBlueskyParameters,
+    WithVisit,
+    WithSample,
+    WithCentreSelection,
+    WithHyperionUDCFeatures,
 ):
     """Experiment parameters to perform the combined robot load,
     pin-tip centre and rotation scan operations."""
@@ -39,10 +44,31 @@ class LoadCentreCollect(
             | RobotLoadThenCentre.model_fields.keys()
             | MultiRotationScan.model_fields.keys()
         )
+
         disallowed_keys = values.keys() - allowed_keys
-        assert (
-            disallowed_keys == set()
-        ), f"Unexpected fields found in LoadCentreCollect {disallowed_keys}"
+        assert disallowed_keys == set(), (
+            f"Unexpected fields found in LoadCentreCollect {disallowed_keys}"
+        )
+
+        keys_from_outer_load_centre_collect = (
+            MxBlueskyParameters.model_fields.keys()
+            | WithSample.model_fields.keys()
+            | WithVisit.model_fields.keys()
+        )
+        duplicated_robot_load_then_centre_keys = (
+            keys_from_outer_load_centre_collect
+            & values["robot_load_then_centre"].keys()
+        )
+        assert not (duplicated_robot_load_then_centre_keys), (
+            f"Unexpected keys in robot_load_then_centre: {', '.join(duplicated_robot_load_then_centre_keys)}"
+        )
+
+        duplicated_multi_rotation_scan_keys = (
+            keys_from_outer_load_centre_collect & values["multi_rotation_scan"].keys()
+        )
+        assert not (duplicated_multi_rotation_scan_keys), (
+            f"Unexpected keys in multi_rotation_scan: {', '.join(duplicated_multi_rotation_scan_keys)}"
+        )
 
         new_robot_load_then_centre_params = construct_from_values(
             values, values["robot_load_then_centre"], RobotLoadThenCentre
@@ -53,3 +79,22 @@ class LoadCentreCollect(
         values["multi_rotation_scan"] = new_multi_rotation_scan_params
         values["robot_load_then_centre"] = new_robot_load_then_centre_params
         return values
+
+    @model_validator(mode="after")
+    def _check_rotation_start_xyz_is_not_specified(self) -> Self:
+        for scan in self.multi_rotation_scan.single_rotation_scans:
+            assert (
+                not scan.x_start_um and not scan.y_start_um and not scan.z_start_um
+            ), (
+                "Specifying start xyz for sweeps is not supported in combination with centring."
+            )
+        return self
+
+    @model_validator(mode="after")
+    def _check_different_gridscan_and_rotation_energy_not_specified(self) -> Self:
+        assert (
+            self.multi_rotation_scan.demand_energy_ev is None
+            or self.multi_rotation_scan.demand_energy_ev
+            == self.robot_load_then_centre.demand_energy_ev
+        ), "Setting a different energy for gridscan and rotation is not supported."
+        return self

mx_bluesky/hyperion/parameters/robot_load.py

@@ -0,0 +1,40 @@
+from pydantic import Field
+
+from mx_bluesky.common.parameters.components import (
+    MxBlueskyParameters,
+    WithOptionalEnergyChange,
+    WithSample,
+    WithSnapshot,
+    WithVisit,
+)
+from mx_bluesky.common.parameters.constants import (
+    HardwareConstants,
+)
+from mx_bluesky.hyperion.parameters.components import WithHyperionUDCFeatures
+from mx_bluesky.hyperion.parameters.gridscan import (
+    GridCommonWithHyperionDetectorParams,
+    PinTipCentreThenXrayCentre,
+)
+
+
+class RobotLoadAndEnergyChange(
+    MxBlueskyParameters, WithSample, WithSnapshot, WithOptionalEnergyChange, WithVisit
+):
+    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)
+
+
+class RobotLoadThenCentre(
+    GridCommonWithHyperionDetectorParams, WithHyperionUDCFeatures
+):
+    thawing_time: float = Field(default=HardwareConstants.THAWING_TIME)
+
+    @property
+    def robot_load_params(self) -> RobotLoadAndEnergyChange:
+        my_params = self.model_dump()
+        return RobotLoadAndEnergyChange(**my_params)
+
+    @property
+    def pin_centre_then_xray_centre_params(self) -> PinTipCentreThenXrayCentre:
+        my_params = self.model_dump()
+        del my_params["thawing_time"]
+        return PinTipCentreThenXrayCentre(**my_params)