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

mx_bluesky/hyperion/experiment_plans/pin_tip_centring_plan.py

@@ -15,6 +15,7 @@ from dodal.devices.oav.utils import (
 )
 from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.exceptions import SampleException
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.device_setup_plans.setup_oav import pre_centring_setup_oav
@@ -22,7 +23,6 @@ from mx_bluesky.hyperion.device_setup_plans.smargon import (
     move_smargon_warn_on_out_of_range,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 DEFAULT_STEP_SIZE = 0.5
 
@@ -53,7 +53,7 @@ def trigger_and_return_pin_tip(
 def move_pin_into_view(
     pin_tip_device: PinTipDetection,
     smargon: Smargon,
-    step_size_mm: float = DEFAULT_STEP_SIZE,
+    step_magnitude_mm: float = DEFAULT_STEP_SIZE,
     max_steps: int = 2,
 ) -> Generator[Msg, None, Pixel]:
     """Attempt to move the pin into view and return the tip location in pixels if found.
@@ -63,7 +63,7 @@ def move_pin_into_view(
     Args:
         pin_tip_device (PinTipDetection): The device being used to detect the pin
         smargon (Smargon): The gonio to move the tip
-        step_size (float, optional): Distance to move the gonio (in mm) for each
+        step_magnitude_mm (float, optional): Distance to move the gonio (in mm) for each
                                     step of the search. Defaults to 0.5.
         max_steps (int, optional): The number of steps to search with. Defaults to 2.
 
@@ -83,21 +83,21 @@ def move_pin_into_view(
         if pin_tip_valid(tip_xy_px):
             return (int(tip_xy_px[0]), int(tip_xy_px[1]))
 
-        if tip_xy_px[0] == 0:
-            # Pin is off in the -ve direction
-            step_size_mm = -step_size_mm
+        # Pin is off in the -ve direction if the returned tip x pixel value is 0
+        direction_multiple = -1 if tip_xy_px[0] == 0 else 1
+        step_vector_mm = step_magnitude_mm * direction_multiple
 
         smargon_x = yield from bps.rd(smargon.x.user_readback)
-        ideal_move_to_find_pin = float(smargon_x) + step_size_mm
+        ideal_move_to_find_pin = float(smargon_x) + step_vector_mm
         high_limit = yield from bps.rd(smargon.x.high_limit_travel)
         low_limit = yield from bps.rd(smargon.x.low_limit_travel)
         move_within_limits = max(min(ideal_move_to_find_pin, high_limit), low_limit)
         if move_within_limits != ideal_move_to_find_pin:
             LOGGER.warning(
-                f"Pin tip is off screen, and moving {step_size_mm} mm would cross limits, "
+                f"Pin tip is off screen, and moving {step_vector_mm}mm would cross limits, "
                 f"moving to {move_within_limits} instead"
             )
-        yield from bps.mv(smargon.x, move_within_limits)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.mv(smargon.x, move_within_limits)
 
         # Some time for the view to settle after the move
         yield from bps.sleep(CONST.HARDWARE.OAV_REFRESH_DELAY)
@@ -154,7 +154,7 @@ def pin_tip_centre_plan(
     tip = yield from move_pin_into_view(pin_tip_detect, smargon)
     yield from offset_and_move(tip)
 
-    yield from bps.mvr(smargon.omega, 90)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mvr(smargon.omega, 90)
 
     # need to wait for the OAV image to update
     # See #673 for improvements

mx_bluesky/hyperion/experiment_plans/robot_load_and_change_energy.py

@@ -54,7 +54,7 @@ class RobotLoadAndEnergyChangeComposite:
 
 
 def create_devices(context: BlueskyContext) -> RobotLoadAndEnergyChangeComposite:
-    from mx_bluesky.hyperion.utils.context import device_composite_from_context
+    from mx_bluesky.common.utils.context import device_composite_from_context
 
     return device_composite_from_context(context, RobotLoadAndEnergyChangeComposite)
 
@@ -95,21 +95,19 @@ def prepare_for_robot_load(
     aperture_scatterguard: ApertureScatterguard, smargon: Smargon
 ):
     yield from bps.abs_set(
-        aperture_scatterguard,
-        ApertureValue.ROBOT_LOAD,
-        group="prepare_robot_load",
+        aperture_scatterguard, ApertureValue.OUT_OF_BEAM, group="prepare_robot_load"
     )
 
-    yield from bps.mv(smargon.stub_offsets, StubPosition.RESET_TO_ROBOT_LOAD)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(smargon.stub_offsets, StubPosition.RESET_TO_ROBOT_LOAD)
 
     # fmt: off
     yield from bps.mv(
-        smargon.x, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.y, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.z, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.omega, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.chi, 0,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        smargon.phi, 0  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        smargon.x, 0,
+        smargon.y, 0,
+        smargon.z, 0,
+        smargon.omega, 0,
+        smargon.chi, 0,
+        smargon.phi, 0
     )
     # fmt: on
 
@@ -122,11 +120,6 @@ def do_robot_load(
     demand_energy_ev: float | None,
     thawing_time: float,
 ):
-    error_code = yield from bps.rd(composite.robot.error_code)
-    # Reset robot if light curtains were tripped
-    if error_code == 40:
-        yield from bps.trigger(composite.robot.reset, wait=True)
-
     yield from bps.abs_set(
         composite.robot,
         sample_location,
@@ -138,7 +131,7 @@ def do_robot_load(
     yield from bps.wait("robot_load")
 
     yield from bps.abs_set(
-        composite.thawer.thaw_for_time_s,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        composite.thawer.thaw_for_time_s,
         thawing_time,
         group="thawing_finished",
     )
@@ -200,7 +193,7 @@ def robot_load_and_snapshots(
 
     yield from bps.create(name=CONST.DESCRIPTORS.ROBOT_LOAD)
     yield from bps.read(composite.robot.barcode)
-    yield from bps.read(composite.oav.snapshot)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.read(composite.oav.snapshot)
     yield from bps.read(composite.webcam)
     yield from bps.save()
 

mx_bluesky/hyperion/experiment_plans/robot_load_then_centre_plan.py

@@ -37,6 +37,7 @@ from dodal.log import LOGGER
 from ophyd_async.fastcs.panda import HDFPanda
 
 from mx_bluesky.common.parameters.constants import OavConstants
+from mx_bluesky.common.xrc_result import XRayCentreEventHandler
 from mx_bluesky.hyperion.device_setup_plans.utils import (
     fill_in_energy_if_not_supplied,
     start_preparing_data_collection_then_do_plan,
@@ -44,9 +45,6 @@ from mx_bluesky.hyperion.device_setup_plans.utils import (
 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 (
-    XRayCentreEventHandler,
-)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     GridDetectThenXRayCentreComposite,
 )
@@ -106,7 +104,7 @@ class RobotLoadThenCentreComposite:
 
 
 def create_devices(context: BlueskyContext) -> RobotLoadThenCentreComposite:
-    from mx_bluesky.hyperion.utils.context import device_composite_from_context
+    from mx_bluesky.common.utils.context import device_composite_from_context
 
     return device_composite_from_context(context, RobotLoadThenCentreComposite)
 

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -27,9 +27,12 @@ from dodal.devices.zebra.zebra import RotationDirection, Zebra
 from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
 from dodal.plan_stubs.check_topup import check_topup_and_wait_if_necessary
 
-from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
+from mx_bluesky.common.plans.read_hardware import (
     read_hardware_for_zocalo,
+    standard_read_hardware_during_collection,
+    standard_read_hardware_pre_collection,
 )
+from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
     cleanup_sample_environment,
@@ -37,10 +40,6 @@ from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
     move_x_y_z,
     setup_sample_environment,
 )
-from mx_bluesky.hyperion.device_setup_plans.read_hardware_for_setup import (
-    read_hardware_during_collection,
-    read_hardware_pre_collection,
-)
 from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
     arm_zebra,
     setup_zebra_for_rotation,
@@ -62,7 +61,6 @@ from mx_bluesky.hyperion.parameters.rotation import (
     MultiRotationScan,
     RotationScan,
 )
-from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
@@ -267,7 +265,7 @@ def rotation_scan_plan(
         # get some information for the ispyb deposition and trigger the callback
         yield from read_hardware_for_zocalo(composite.eiger)
 
-        yield from read_hardware_pre_collection(
+        yield from standard_read_hardware_pre_collection(
             composite.undulator,
             composite.synchrotron,
             composite.s4_slit_gaps,
@@ -293,7 +291,7 @@ def rotation_scan_plan(
         LOGGER.info("Executing rotation scan")
         yield from bps.rel_set(axis, motion_values.distance_to_move_deg, wait=True)
 
-        yield from read_hardware_during_collection(
+        yield from standard_read_hardware_during_collection(
             composite.aperture_scatterguard,
             composite.attenuator,
             composite.flux,
@@ -346,6 +344,13 @@ def _move_and_rotation(
         yield from setup_beamline_for_OAV(
             composite.smargon, composite.backlight, composite.aperture_scatterguard
         )
+        yield from bps.wait(group=CONST.WAIT.READY_FOR_OAV)
+        if params.selected_aperture:
+            yield from bps.prepare(
+                composite.aperture_scatterguard,
+                params.selected_aperture,
+                group=CONST.WAIT.ROTATION_READY_FOR_DC,
+            )
         yield from oav_snapshot_plan(composite, params, oav_params)
     yield from rotation_scan_plan(
         composite,
@@ -376,8 +381,10 @@ def rotation_scan(
         }
     )
     @transmission_and_xbpm_feedback_for_collection_decorator(
+        composite.undulator,
         composite.xbpm_feedback,
         composite.attenuator,
+        composite.dcm,
         parameters.transmission_frac,
     )
     def rotation_scan_plan_with_stage_and_cleanup(
@@ -399,7 +406,7 @@ def rotation_scan(
             rotation_with_cleanup_and_stage(params),
             group=CONST.WAIT.ROTATION_READY_FOR_DC,
         )
-        yield from bps.unstage(eiger)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        yield from bps.unstage(eiger)
 
     yield from rotation_scan_plan_with_stage_and_cleanup(parameters)
 
@@ -427,10 +434,11 @@ def multi_rotation_scan(
             ],
         }
     )
-    @bpp.stage_decorator([eiger])
     @transmission_and_xbpm_feedback_for_collection_decorator(
+        composite.undulator,
         composite.xbpm_feedback,
         composite.attenuator,
+        composite.dcm,
         parameters.transmission_frac,
     )
     @bpp.finalize_decorator(lambda: _cleanup_plan(composite))
@@ -460,3 +468,4 @@ def multi_rotation_scan(
         _multi_rotation_scan(),
         group=CONST.WAIT.ROTATION_READY_FOR_DC,
     )
+    yield from bps.unstage(eiger)

mx_bluesky/hyperion/experiment_plans/set_energy_plan.py

@@ -54,7 +54,9 @@ def set_energy_plan(
     if energy_ev:
         yield from transmission_and_xbpm_feedback_for_collection_wrapper(
             _set_energy_plan(energy_ev / 1000, composite),
+            composite.undulator_dcm.undulator_ref(),
             composite.xbpm_feedback,
             composite.attenuator,
+            composite.dcm,
             DESIRED_TRANSMISSION_FRACTION,
         )

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -0,0 +1,104 @@
+import dataclasses
+import json
+import re
+from typing import TypeVar
+
+import requests
+from dodal.utils import get_beamline_name
+
+from mx_bluesky.common.parameters.components import WithVisit
+from mx_bluesky.common.parameters.constants import GridscanParamConstants
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+
+T = TypeVar("T", bound=WithVisit)
+AGAMEMNON_URL = "http://agamemnon.diamond.ac.uk/"
+MULTIPIN_PREFIX = "multipin"
+MULTIPIN_FORMAT_DESC = "Expected multipin format is multipin_{number_of_wells}x{well_size}+{distance_between_tip_and_first_well}"
+MULTIPIN_REGEX = rf"^{MULTIPIN_PREFIX}_(\d+)x(\d+(?:\.\d+)?)\+(\d+(?:\.\d+)?)$"
+
+
+@dataclasses.dataclass
+class PinType:
+    expected_number_of_crystals: int
+    single_well_width_um: float
+    tip_to_first_well_um: float = 0
+
+    @property
+    def full_width(self) -> float:
+        """This is the "width" of the area where there may be samples.
+
+        From a pin perspective this is along the length of the pin but we use width here as
+        we mount the sample at 90 deg to the optical camera.
+
+        We calculate the full width by adding all the gaps between wells then assuming
+        there is a buffer of {tip_to_first_well_um} either side too. In reality the
+        calculation does not need to be very exact as long as we get a width that's good
+        enough to use for optical centring and XRC grid size.
+        """
+        return (self.expected_number_of_crystals - 1) * self.single_well_width_um + (
+            2 * self.tip_to_first_well_um
+        )
+
+
+class SinglePin(PinType):
+    def __init__(self):
+        super().__init__(1, GridscanParamConstants.WIDTH_UM)
+
+    @property
+    def full_width(self) -> float:
+        return self.single_well_width_um
+
+
+def _get_parameters_from_url(url: str) -> dict:
+    response = requests.get(url, headers={"Accept": "application/json"})
+    response.raise_for_status()
+    response_json = json.loads(response.content)
+    try:
+        return response_json["collect"]
+    except KeyError as e:
+        raise KeyError(f"Unexpected json from agamemnon: {response_json}") from e
+
+
+def _get_pin_type_from_agamemnon_parameters(parameters: dict) -> PinType:
+    loop_type_name: str | None = parameters["sample"]["loopType"]
+    if loop_type_name:
+        regex_search = re.search(MULTIPIN_REGEX, loop_type_name)
+        if regex_search:
+            wells, well_size, tip_to_first_well = regex_search.groups()
+            return PinType(int(wells), float(well_size), float(tip_to_first_well))
+        else:
+            loop_type_message = (
+                f"Agamemnon loop type of {loop_type_name} not recognised"
+            )
+            if loop_type_name.startswith(MULTIPIN_PREFIX):
+                raise ValueError(f"{loop_type_message}. {MULTIPIN_FORMAT_DESC}")
+            LOGGER.warning(f"{loop_type_message}, assuming single pin")
+    return SinglePin()
+
+
+def get_next_instruction(beamline: str) -> dict:
+    return _get_parameters_from_url(AGAMEMNON_URL + f"getnextcollect/{beamline}")
+
+
+def get_pin_type_from_agamemnon(beamline: str) -> PinType:
+    params = get_next_instruction(beamline)
+    return _get_pin_type_from_agamemnon_parameters(params)
+
+
+def update_params_from_agamemnon(parameters: T) -> T:
+    try:
+        beamline_name = get_beamline_name("i03")
+        pin_type = get_pin_type_from_agamemnon(beamline_name)
+        if isinstance(parameters, LoadCentreCollect):
+            parameters.robot_load_then_centre.tip_offset_um = pin_type.full_width / 2
+            parameters.robot_load_then_centre.grid_width_um = pin_type.full_width
+            parameters.select_centres.n = pin_type.expected_number_of_crystals
+            if pin_type != SinglePin():
+                # Snapshots between each collection take a lot of time.
+                # Before we do https://github.com/DiamondLightSource/mx-bluesky/issues/226
+                # this will give no snapshots but that's preferable
+                parameters.multi_rotation_scan.snapshot_omegas_deg = []
+    except Exception as e:
+        LOGGER.warning(f"Failed to get pin type from agamemnon, using single pin {e}")
+    return parameters

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -3,6 +3,7 @@ from collections.abc import Callable, Sequence
 from threading import Thread
 from time import sleep
 
+from bluesky.callbacks import CallbackBase
 from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
 from dodal.log import LOGGER as dodal_logger
 from dodal.log import set_up_all_logging_handlers
@@ -48,17 +49,33 @@ LIVENESS_POLL_SECONDS = 1
 ERROR_LOG_BUFFER_LINES = 5000
 
 
-def setup_callbacks():
-    return [
+def create_gridscan_callbacks() -> tuple[
+    GridscanNexusFileCallback, GridscanISPyBCallback
+]:
+    return (
         GridscanNexusFileCallback(param_type=HyperionSpecifiedThreeDGridScan),
         GridscanISPyBCallback(
             param_type=GridCommonWithHyperionDetectorParams,
             emit=ZocaloCallback(CONST.PLAN.DO_FGS, CONST.ZOCALO_ENV),
         ),
+    )
+
+
+def create_rotation_callbacks() -> tuple[
+    RotationNexusFileCallback, RotationISPyBCallback
+]:
+    return (
         RotationNexusFileCallback(),
         RotationISPyBCallback(
             emit=ZocaloCallback(CONST.PLAN.ROTATION_MAIN, CONST.ZOCALO_ENV)
         ),
+    )
+
+
+def setup_callbacks() -> list[CallbackBase]:
+    return [
+        *create_gridscan_callbacks(),
+        *create_rotation_callbacks(),
         LogUidTaggingCallback(),
         RobotLoadISPyBCallback(),
         SampleHandlingCallback(),

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

@@ -136,7 +136,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             "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} "
+        comment = f"Sample position (µm): ({motor_positions_um[0]:.0f}, {motor_positions_um[1]:.0f}, {motor_positions_um[2]:.0f})"
         scan_data_infos[0].data_collection_info.comments = comment
         return scan_data_infos
 

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

@@ -19,22 +19,27 @@ class SampleHandlingCallback(PlanReactiveCallback):
         super().__init__(log=ISPYB_ZOCALO_CALLBACK_LOGGER)
         self._sample_id: int | None = None
         self._descriptor: str | None = None
+        self._run_id: str | None = None
 
     def activity_gated_start(self, doc: RunStart):
-        if not self._sample_id:
+        if not self._sample_id and self.active:
             sample_id = doc.get("metadata", {}).get("sample_id")
             self.log.info(f"Recording sample ID at run start {sample_id}")
             self._sample_id = sample_id
+            self._run_id = self.activity_uid
 
     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}: {message}"
-            )
-            self._record_exception(exception_type)
+        if self._run_id == doc.get("run_start"):
+            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}: {message}"
+                )
+                self._record_exception(exception_type)
+            self._sample_id = None
+            self._run_id = None
         return doc
 
     def _record_exception(self, exception_type: str):

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -1,6 +1,7 @@
 from functools import cache
 
 from daq_config_server.client import ConfigServer
+from pydantic import model_validator
 
 from mx_bluesky.common.external_interaction.config_server import FeatureFlags
 from mx_bluesky.common.utils.log import LOGGER
@@ -13,8 +14,10 @@ class HyperionFeatureFlags(FeatureFlags):
 
     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.
+        compare_cpu_and_gpu_zocalo:     If True then GPU result processing is enabled
+            alongside CPU and the results are compared. The CPU result is still take.n
+        use_gpu_results:                If True then GPU result processing is enabled
+            and the GPU result is taken.
         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
@@ -26,7 +29,15 @@ class HyperionFeatureFlags(FeatureFlags):
     def get_config_server() -> ConfigServer:
         return ConfigServer(CONST.CONFIG_SERVER_URL, LOGGER)
 
+    @model_validator(mode="after")
+    def use_gpu_and_compare_cannot_both_be_true(self):
+        assert not (self.use_gpu_results and self.compare_cpu_and_gpu_zocalo), (
+            "Cannot both use GPU results and compare them to CPU"
+        )
+        return self
+
     use_panda_for_gridscan: bool = CONST.I03.USE_PANDA_FOR_GRIDSCAN
     compare_cpu_and_gpu_zocalo: bool = CONST.I03.COMPARE_CPU_AND_GPU_ZOCALO
+    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

mx_bluesky/hyperion/parameters/cli.py

@@ -8,7 +8,6 @@ from mx_bluesky._version import version
 @dataclass
 class HyperionArgs:
     dev_mode: bool = False
-    use_external_callbacks: bool = False
     verbose_event_logging: bool = False
     skip_startup_connection: bool = False
 
@@ -34,8 +33,7 @@ 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,
-                 external_callbacks: bool)"""
+                 skip_startup_connection: bool)"""
     parser = argparse.ArgumentParser()
     _add_callback_relevant_args(parser)
     parser.add_argument(
@@ -48,11 +46,6 @@ def parse_cli_args() -> HyperionArgs:
         action="store_true",
         help="Skip connecting to EPICS PVs on startup",
     )
-    parser.add_argument(
-        "--external-callbacks",
-        action="store_true",
-        help="Run the external hyperion-callbacks service and publish events over ZMQ",
-    )
     parser.add_argument(
         "--version",
         help="Print hyperion version string",
@@ -64,5 +57,4 @@ def parse_cli_args() -> 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,
-        use_external_callbacks=args.external_callbacks or False,
     )

mx_bluesky/hyperion/parameters/constants.py

@@ -4,6 +4,7 @@ from dodal.devices.detector import EIGER2_X_16M_SIZE
 from pydantic.dataclasses import dataclass
 
 from mx_bluesky.common.parameters.constants import (
+    DeviceSettingsConstants,
     DocDescriptorNames,
     EnvironmentConstants,
     ExperimentParamConstants,
@@ -31,9 +32,12 @@ class I03Constants:
     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
+    # processed results.
     COMPARE_CPU_AND_GPU_ZOCALO = False
 
+    # Turns on GPU processing for zocalo and uses the results that come back
+    USE_GPU_RESULTS = False
+
 
 @dataclass(frozen=True)
 class HyperionConstants:
@@ -57,6 +61,7 @@ class HyperionConstants:
     GRAYLOG_PORT = 12232
     PARAMETER_SCHEMA_DIRECTORY = "src/hyperion/parameters/schemas/"
     LOG_FILE_NAME = "hyperion.log"
+    DEVICE_SETTINGS_CONSTANTS = DeviceSettingsConstants()
 
 
 CONST = HyperionConstants()

mx_bluesky/hyperion/parameters/device_composites.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import pydantic
+from dodal.devices.aperturescatterguard import (
+    ApertureScatterguard,
+)
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.backlight import Backlight
+from dodal.devices.dcm import DCM
+from dodal.devices.eiger import EigerDetector
+from dodal.devices.fast_grid_scan import (
+    PandAFastGridScan,
+    ZebraFastGridScan,
+)
+from dodal.devices.flux import Flux
+from dodal.devices.robot import BartRobot
+from dodal.devices.s4_slit_gaps import S4SlitGaps
+from dodal.devices.smargon import Smargon
+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
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class HyperionFlyScanXRayCentreComposite:
+    """All devices which are directly or indirectly required by this plan"""
+
+    aperture_scatterguard: ApertureScatterguard
+    attenuator: BinaryFilterAttenuator
+    backlight: Backlight
+    dcm: DCM
+    eiger: EigerDetector
+    zebra_fast_grid_scan: ZebraFastGridScan
+    flux: Flux
+    s4_slit_gaps: S4SlitGaps
+    smargon: Smargon
+    undulator: Undulator
+    synchrotron: Synchrotron
+    xbpm_feedback: XBPMFeedback
+    zebra: Zebra
+    zocalo: ZocaloResults
+    panda: HDFPanda
+    panda_fast_grid_scan: PandAFastGridScan
+    robot: BartRobot
+    sample_shutter: ZebraShutter

mx_bluesky/hyperion/parameters/gridscan.py

@@ -47,12 +47,13 @@ class GridCommonWithHyperionDetectorParams(GridCommon, WithHyperionUDCFeatures):
             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,
+            enable_dev_shm=self.features.compare_cpu_and_gpu_zocalo
+            or self.features.use_gpu_results,
             **optional_args,
         )
 
 
-class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan, WithHyperionUDCFeatures):
+class HyperionSpecifiedThreeDGridScan(WithHyperionUDCFeatures, SpecifiedThreeDGridScan):
     """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
@@ -83,7 +84,8 @@ class HyperionSpecifiedThreeDGridScan(SpecifiedThreeDGridScan, WithHyperionUDCFe
             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,
+            enable_dev_shm=self.features.compare_cpu_and_gpu_zocalo
+            or self.features.use_gpu_results,
             **optional_args,
         )