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

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -1,8 +1,8 @@
 import logging
 from collections.abc import Callable, Sequence
 from threading import Thread
+from time import sleep  # noqa
 
-import bluesky.plan_stubs as bps
 from bluesky.callbacks import CallbackBase
 from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
 from dodal.log import LOGGER as dodal_logger
@@ -26,7 +26,7 @@ from mx_bluesky.common.external_interaction.callbacks.xray_centre.nexus_callback
 from mx_bluesky.common.utils.log import (
     ISPYB_ZOCALO_CALLBACK_LOGGER,
     NEXUS_LOGGER,
-    _get_logging_dir,
+    _get_logging_dirs,
     tag_filter,
 )
 from mx_bluesky.hyperion.external_interaction.callbacks.robot_load.ispyb_callback import (
@@ -93,14 +93,16 @@ 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(dev_mode)
         if logger.handlers == []:
             handlers = set_up_all_logging_handlers(
                 logger,
-                _get_logging_dir(),
+                logging_path,
                 filename,
                 dev_mode,
-                error_log_buffer_lines=ERROR_LOG_BUFFER_LINES,
-                graylog_port=CONST.GRAYLOG_PORT,
+                ERROR_LOG_BUFFER_LINES,
+                CONST.GRAYLOG_PORT,
+                debug_logging_path,
             )
             handlers["graylog_handler"].addFilter(tag_filter)
     log_info(f"Loggers initialised with dev_mode={dev_mode}")
@@ -140,7 +142,7 @@ def wait_for_threads_forever(threads: Sequence[Thread]):
     try:
         log_debug("Trying to wait forever on callback and dispatcher threads")
         while all(alive):
-            yield from bps.sleep(LIVENESS_POLL_SECONDS)
+            sleep(LIVENESS_POLL_SECONDS)
             alive = [t.is_alive() for t in threads]
     except KeyboardInterrupt:
         log_info("Main thread received interrupt - exiting.")

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/callbacks/snapshot_callback.py

@@ -1,4 +1,9 @@
+import dataclasses
 import re
+from collections.abc import Iterator
+from datetime import datetime
+from math import cos, radians, sin
+from pathlib import Path
 
 from dodal.devices.oav.snapshots.snapshot_image_processing import (
     compute_beam_centre_pixel_xy_for_mm_position,
@@ -10,17 +15,35 @@ from PIL import Image
 from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
-from mx_bluesky.common.parameters.constants import DocDescriptorNames
+from mx_bluesky.common.parameters.components import WithSnapshot
+from mx_bluesky.common.parameters.constants import DocDescriptorNames, PlanNameConstants
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER as CALLBACK_LOGGER
 
+COMPRESSION_LEVEL = 6  # 6 is the default compression level for PIL if not specified
+
+
+@dataclasses.dataclass
+class _SnapshotInfo:
+    beam_centre: tuple[int, int]
+    microns_per_pixel: tuple[float, float]
+    snapshot_path: str
+    omega: int
+    sample_pos_mm: tuple[float, float, float]
+
+    @property
+    def snapshot_basename(self) -> str:
+        match = re.match("(.*)\\.png", self.snapshot_path)
+        assert match, f"Snapshot {self.snapshot_path} was not a .png file"
+        return match.groups()[0]
+
 
 class BeamDrawingCallback(PlanReactiveCallback):
     """
     Callback that monitors for OAV_ROTATION_SNAPSHOT_TRIGGERED events and
     draws a crosshair at the beam centre, saving the snapshot to a file.
-    The callback assumes an OAV device "oav"
+    The callback assumes an OAV device "oav" and Smargon "smargon"
     Examples:
-        Take a snapshot at the current location
+        Take a rotation snapshot at the current location
     >>> from bluesky.run_engine import RunEngine
     >>> import bluesky.preprocessors as bpp
     >>> import bluesky.plan_stubs as bps
@@ -39,69 +62,198 @@ class BeamDrawingCallback(PlanReactiveCallback):
     ...         yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
     ...         yield from bps.read(oav)
     ...         yield from bps.save()
+
+        Generate rotation snapshots from a previously taken base gridscan snapshot.
+        WithSnapshot.snapshot_omegas_deg is ignored and snapshots are generated for the previously captured
+        0, 90 base images named "my_snapshot_prefix_0" and "my_snapshot_prefix_90"
+    >>> from dodal.devices.smargon import Smargon
+    >>> def take_snapshot(params: WithSnapshot, oav: OAV, smargon: Smargon, run_engine: RunEngine):
+    ...     run_engine.subscribe(BeamDrawingCallback())
+    ...     @bpp.run_decorator(md={
+    ...     "activate_callbacks": ["BeamDrawingCallback"],
+    ...         "with_snapshot": params.model_dump_json(),
+    ...     })
+    ...     def inner_plan():
+    ...         for omega in (0, 90,):
+    ...             yield from bps.abs_set(smargon.omega, omega, wait=True)
+    ...             yield from bps.abs_set(oav.grid_snapshot.directory, "/path/to/grid_snapshot_folder", wait=True)
+    ...             yield from bps.abs_set(oav.grid_snapshot.filename, f"my_grid_snapshot_prefix_{omega}", wait=True)
+    ...             yield from bps.trigger(oav.grid_snapshot, wait=True)
+    ...             yield from bps.create(DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED)
+    ...             yield from bps.read(oav)        # Capture base image path
+    ...             yield from bps.read(smargon)    # Capture base image sample x, y, z, omega
+    ...             yield from bps.save()
+    ...             # Rest of gridscan here...
+    ...         # Later on...
+    ...         for omega in (0, 90,):
+    ...             yield from bps.abs_set(oav.snapshot.last_saved_path,
+    ...                 f"/path/to/snapshot_folder/my_snapshot_prefix_{omega}.png", wait=True)
+    ...             yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
+    ...             yield from bps.read(oav)            # Capture path info for generated snapshot
+    ...             yield from bps.read(smargon)        # Capture the current sample x, y, z
+    ...             yield from bps.save()
     """
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, log=CALLBACK_LOGGER, **kwargs)
-        self._snapshot_files: list[str] = []
-        self._microns_per_pixel: tuple[float, float]
-        self._beam_centre: tuple[int, int]
+        self._base_snapshots: list[_SnapshotInfo] = []
         self._rotation_snapshot_descriptor: str = ""
+        self._grid_snapshot_descriptor: str = ""
+        self._next_snapshot_info: Iterator | None = None
+        self._use_grid_snapshots: bool = False
+
+    def _reset(self):
+        self._base_snapshots = []
 
     def activity_gated_start(self, doc: RunStart):
         if self.activity_uid == doc.get("uid"):
-            with_snapshot_json = doc.get("with_snapshot")  # type: ignore
-            assert with_snapshot_json, (
-                "run start event did not have expected snapshot json"
-            )
+            self._reset()
+            with_snapshot = WithSnapshot.model_validate_json(doc.get("with_snapshot"))  # type: ignore
+            self._use_grid_snapshots = with_snapshot.use_grid_snapshots
+            CALLBACK_LOGGER.info(f"Snapshot callback initialised with {with_snapshot}")
+        elif doc.get("subplan_name") == PlanNameConstants.ROTATION_MAIN:
+            self._next_snapshot_info = None
+            CALLBACK_LOGGER.info("Snapshot callback start rotation")
         return doc
 
     def activity_gated_descriptor(self, doc: EventDescriptor) -> EventDescriptor | None:
         if doc.get("name") == DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED:
             self._rotation_snapshot_descriptor = doc["uid"]
+        elif doc.get("name") == DocDescriptorNames.OAV_GRID_SNAPSHOT_TRIGGERED:
+            self._grid_snapshot_descriptor = doc["uid"]
         return doc
 
     def activity_gated_event(self, doc: Event) -> Event:
         if doc["descriptor"] == self._rotation_snapshot_descriptor:
             self._handle_rotation_snapshot(doc)
+        elif doc["descriptor"] == self._grid_snapshot_descriptor:
+            self._handle_grid_snapshot(doc)
         return doc
 
-    def _extract_base_snapshot_params(self, doc: Event):
+    def _extract_base_snapshot_params(
+        self, snapshot_device_prefix: str, doc: Event
+    ) -> _SnapshotInfo:
         data = doc["data"]
-        self._snapshot_files.append(data["oav-snapshot-last_saved_path"])
-        self._microns_per_pixel = (
-            data["oav-microns_per_pixel_x"],
-            data["oav-microns_per_pixel_y"],
+        base_snapshot_path = data[f"oav-{snapshot_device_prefix}-last_saved_path"]
+        return _SnapshotInfo(
+            beam_centre=(data["oav-beam_centre_i"], data["oav-beam_centre_j"]),
+            microns_per_pixel=(
+                data["oav-microns_per_pixel_x"],
+                data["oav-microns_per_pixel_y"],
+            ),
+            snapshot_path=base_snapshot_path,
+            sample_pos_mm=(
+                data.get("smargon-x", 0.0),
+                data.get("smargon-y", 0.0),
+                data.get("smargon-z", 0.0),
+            ),
+            omega=round(data.get("smargon-omega", 0.0)),
         )
-        self._beam_centre = (data["oav-beam_centre_i"], data["oav-beam_centre_j"])
 
-    def _handle_rotation_snapshot(self, doc: Event):
-        self._extract_base_snapshot_params(doc)
+    def _handle_grid_snapshot(self, doc: Event):
+        snapshot_info = self._extract_base_snapshot_params("grid_snapshot", doc)
+        self._base_snapshots.append(snapshot_info)
+
+    def _handle_rotation_snapshot(self, doc: Event) -> Event:
         data = doc["data"]
-        snapshot_path = data["oav-snapshot-last_saved_path"]
-        match = re.match("(.*)\\.png", snapshot_path)
-        assert match, f"Snapshot {snapshot_path} was not a .png file"
-        snapshot_base = match.groups()[0]
-        output_snapshot_path = f"{snapshot_base}_with_beam_centre.png"
-        self._generate_snapshot_at(snapshot_path, output_snapshot_path, 0, 0)
+        if self._use_grid_snapshots:
+            if not self._next_snapshot_info:
+                self._next_snapshot_info = iter(self._base_snapshots)
+            snapshot_info = next(self._next_snapshot_info, None)
+            assert snapshot_info, (
+                "Insufficient base gridscan snapshots to generate required rotation snapshots"
+            )
+            current_sample_pos_mm = (
+                data["smargon-x"],
+                data["smargon-y"],
+                data["smargon-z"],
+            )
+            CALLBACK_LOGGER.info(
+                f"Generating snapshot at {current_sample_pos_mm} from base snapshot {snapshot_info}"
+            )
+            output_snapshot_directory = data["oav-snapshot-directory"]
+            base_file_stem = Path(snapshot_info.snapshot_path).stem
+            output_snapshot_filename = _snapshot_filename(base_file_stem)
+            output_snapshot_path = (
+                f"{output_snapshot_directory}/{output_snapshot_filename}.png"
+            )
+            self._generate_snapshot_at(
+                snapshot_info,
+                output_snapshot_path,
+                *self._image_plane_offset_mm(snapshot_info, current_sample_pos_mm),
+            )
+        else:
+            snapshot_info = self._extract_base_snapshot_params("snapshot", doc)
+            output_snapshot_path = (
+                f"{snapshot_info.snapshot_basename}_with_beam_centre.png"
+            )
+            CALLBACK_LOGGER.info(
+                f"Annotating snapshot {output_snapshot_path} from base snapshot {snapshot_info}"
+            )
+            self._generate_snapshot_zero_offset(
+                snapshot_info,
+                output_snapshot_path,
+            )
         data["oav-snapshot-last_saved_path"] = output_snapshot_path
         return doc
 
+    def _image_plane_offset_mm(
+        self,
+        snapshot_info: _SnapshotInfo,
+        current_sample_pos_mm: tuple[float, float, float],
+    ) -> tuple[float, float]:
+        return self._project_xyz_to_xy(
+            (
+                (current_sample_pos_mm[0] - snapshot_info.sample_pos_mm[0]),
+                (current_sample_pos_mm[1] - snapshot_info.sample_pos_mm[1]),
+                (current_sample_pos_mm[2] - snapshot_info.sample_pos_mm[2]),
+            ),
+            snapshot_info.omega,
+        )
+
+    def _project_xyz_to_xy(
+        self, xyz: tuple[float, float, float], omega_deg: float
+    ) -> tuple[float, float]:
+        return (
+            xyz[0],
+            xyz[1] * cos(-radians(omega_deg)) + xyz[2] * sin(-radians(omega_deg)),
+        )
+
+    def _generate_snapshot_zero_offset(
+        self,
+        base_snapshot_info: _SnapshotInfo,
+        output_snapshot_path: str,
+    ):
+        self._generate_snapshot_at(base_snapshot_info, output_snapshot_path, 0, 0)
+
     def _generate_snapshot_at(
-        self, input_snapshot_path: str, output_snapshot_path: str, x_mm: int, y_mm: int
+        self,
+        base_snapshot_info: _SnapshotInfo,
+        output_snapshot_path: str,
+        image_plane_dx_mm: float,
+        image_plane_dy_mm: float,
     ):
         """
         Save a snapshot to the specified path, with an annotated crosshair at the specified
         position
         Args:
-            input_snapshot_path: The non-annotated image path.
+            base_snapshot_info: Metadata about the base snapshot image from which the annotated
+                image will be derived.
             output_snapshot_path:  The path to the image that will be annotated.
-            x_mm: Relative x location of the sample to the original image (mm)
-            y_mm: Relative y location of the sample to the original image (mm)
+            image_plane_dx_mm: Relative x location of the sample to the original image in the image plane (mm)
+            image_plane_dy_mm: Relative y location of the sample to the original image in the image plane (mm)
         """
-        image = Image.open(input_snapshot_path)
+        image = Image.open(base_snapshot_info.snapshot_path)
         x_px, y_px = compute_beam_centre_pixel_xy_for_mm_position(
-            (x_mm, y_mm), self._beam_centre, self._microns_per_pixel
+            (image_plane_dx_mm, image_plane_dy_mm),
+            base_snapshot_info.beam_centre,
+            base_snapshot_info.microns_per_pixel,
         )
         draw_crosshair(image, x_px, y_px)
-        image.save(output_snapshot_path, format="png")
+        image.save(output_snapshot_path, format="png", compress_level=COMPRESSION_LEVEL)
+
+
+def _snapshot_filename(grid_snapshot_name):
+    time_now = datetime.now()
+    filename = f"{time_now.strftime('%H%M%S%f')[:8]}_oav_snapshot_{grid_snapshot_name}"
+    return filename

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,8 +8,6 @@ from mx_bluesky._version import version
 @dataclass
 class HyperionArgs:
     dev_mode: bool = False
-    verbose_event_logging: bool = False
-    skip_startup_connection: bool = False
 
 
 def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
@@ -17,7 +15,7 @@ def _add_callback_relevant_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--dev",
         action="store_true",
-        help="Use dev options, such as local graylog instances and S03",
+        help="Use dev options, such as local graylog instances",
     )
 
 
@@ -30,22 +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,
-                 skip_startup_connection: 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(
-        "--skip-startup-connection",
-        action="store_true",
-        help="Skip connecting to EPICS PVs on startup",
-    )
     parser.add_argument(
         "--version",
         help="Print hyperion version string",
@@ -54,7 +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,
-        skip_startup_connection=args.skip_startup_connection or False,
     )

mx_bluesky/hyperion/parameters/constants.py

@@ -12,8 +12,6 @@ from mx_bluesky.common.parameters.constants import (
     OavConstants,
     PlanGroupCheckpointConstants,
     PlanNameConstants,
-    SimConstants,
-    TriggerConstants,
 )
 
 TEST_MODE = os.environ.get("HYPERION_TEST_MODE")
@@ -30,6 +28,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.
@@ -42,15 +41,12 @@ class I03Constants:
 @dataclass(frozen=True)
 class HyperionConstants:
     DESCRIPTORS = DocDescriptorNames()
-    TRIGGER = TriggerConstants()
     ZOCALO_ENV = EnvironmentConstants.ZOCALO_ENV
     HARDWARE = HardwareConstants()
     I03 = I03Constants()
     PARAM = ExperimentParamConstants()
     PLAN = PlanNameConstants()
     WAIT = PlanGroupCheckpointConstants()
-    SIM = SimConstants()
-    TRIGGER = TriggerConstants()
     CALLBACK_0MQ_PROXY_PORTS = (5577, 5578)
     DESCRIPTORS = DocDescriptorNames()
     CONFIG_SERVER_URL = (

mx_bluesky/hyperion/parameters/device_composites.py

@@ -6,13 +6,17 @@ from dodal.devices.aperturescatterguard import (
 )
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
-from dodal.devices.dcm import DCM
+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
@@ -24,22 +28,53 @@ 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 (
+    FlyScanEssentialDevices,
+)
+
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
-class HyperionFlyScanXRayCentreComposite:
+class HyperionFlyScanXRayCentreComposite(FlyScanEssentialDevices):
     """All devices which are directly or indirectly required by this plan"""
 
     aperture_scatterguard: ApertureScatterguard
     attenuator: BinaryFilterAttenuator
+    dcm: BaseDCM
+    eiger: EigerDetector
+    flux: Flux
+    s4_slit_gaps: S4SlitGaps
+    undulator: Undulator
+    synchrotron: Synchrotron
+    zebra: Zebra
+    zocalo: ZocaloResults
+    panda: HDFPanda
+    panda_fast_grid_scan: PandAFastGridScan
+    robot: BartRobot
+    sample_shutter: ZebraShutter
     backlight: Backlight
-    dcm: DCM
+    xbpm_feedback: XBPMFeedback
+    zebra_fast_grid_scan: ZebraFastGridScan
+
+
+@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: BaseDCM
+    detector_motion: DetectorMotion
     eiger: EigerDetector
     zebra_fast_grid_scan: ZebraFastGridScan
     flux: Flux
-    s4_slit_gaps: S4SlitGaps
+    oav: OAV
+    pin_tip_detection: PinTipDetection
     smargon: Smargon
-    undulator: Undulator
     synchrotron: Synchrotron
+    s4_slit_gaps: S4SlitGaps
+    undulator: Undulator
     xbpm_feedback: XBPMFeedback
     zebra: Zebra
     zocalo: ZocaloResults

mx_bluesky/hyperion/parameters/gridscan.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-from dodal.devices.detector import (
-    DetectorParams,
-)
 from dodal.devices.fast_grid_scan import (
     PandAGridScanParams,
     ZebraGridScanParams,
@@ -13,7 +10,6 @@ from mx_bluesky.common.parameters.gridscan import (
     SpecifiedThreeDGridScan,
 )
 from mx_bluesky.hyperion.parameters.components import WithHyperionUDCFeatures
-from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 
 
 class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
@@ -23,34 +19,11 @@ class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
     # 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_s=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
-            or self.features.use_gpu_results,
-            **optional_args,
+        params = super().detector_params
+        params.enable_dev_shm = (
+            self.features.compare_cpu_and_gpu_zocalo or self.features.use_gpu_results
         )
+        return params
 
 
 class HyperionSpecifiedThreeDGridScan(WithHyperionUDCFeatures, SpecifiedThreeDGridScan):
@@ -58,36 +31,14 @@ class HyperionSpecifiedThreeDGridScan(WithHyperionUDCFeatures, SpecifiedThreeDGr
 
     # 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_s=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
-            or self.features.use_gpu_results,
-            **optional_args,
+        params = super().detector_params
+        params.enable_dev_shm = (
+            self.features.compare_cpu_and_gpu_zocalo or self.features.use_gpu_results
         )
+        return params
 
     # Relative to common grid scan, stub offsets are defined by config server
     @property