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

mx_bluesky/hyperion/experiment_plans/grid_detect_then_xray_centre_plan.py

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

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

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

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -9,6 +9,7 @@ from bluesky.utils import MsgGenerator
 from dodal.devices.oav.oav_parameters import OAVParameters
 
 import mx_bluesky.common.xrc_result as flyscan_result
+from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.xrc_result import XRayCentreEventHandler
@@ -19,7 +20,7 @@ from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     MultiRotationScan,
     RotationScanComposite,
-    multi_rotation_scan,
+    multi_rotation_scan_internal,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
@@ -49,18 +50,24 @@ def load_centre_collect_full(
     """
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
+    oav_config_file = oav_params.oav_config_json
 
     @set_run_key_decorator(CONST.PLAN.LOAD_CENTRE_COLLECT)
     @run_decorator(
         md={
             "metadata": {"sample_id": parameters.sample_id},
-            "activate_callbacks": ["SampleHandlingCallback"],
+            "activate_callbacks": ["BeamDrawingCallback", "SampleHandlingCallback"],
+            "with_snapshot": parameters.multi_rotation_scan.model_dump_json(
+                include=WithSnapshot.model_fields.keys()  # type: ignore
+            ),
         }
     )
     def plan_with_callback_subs():
         flyscan_event_handler = XRayCentreEventHandler()
         yield from subs_wrapper(
-            robot_load_then_xray_centre(composite, parameters.robot_load_then_centre),
+            robot_load_then_xray_centre(
+                composite, parameters.robot_load_then_centre, oav_config_file
+            ),
             flyscan_event_handler,
         )
 
@@ -79,11 +86,13 @@ def load_centre_collect_full(
         else:
             # If the xray centring hasn't found a result but has not thrown an error it
             # means that we do not need to recentre and can collect where we are
-            initial_x = yield from bps.rd(composite.smargon.x.user_readback)
-            initial_y = yield from bps.rd(composite.smargon.y.user_readback)
-            initial_z = yield from bps.rd(composite.smargon.z.user_readback)
+            initial_x_mm = yield from bps.rd(composite.smargon.x.user_readback)
+            initial_y_mm = yield from bps.rd(composite.smargon.y.user_readback)
+            initial_z_mm = yield from bps.rd(composite.smargon.z.user_readback)
 
-            locations_to_collect_um = [np.array([initial_x, initial_y, initial_z])]
+            locations_to_collect_um = [
+                np.array([initial_x_mm, initial_y_mm, initial_z_mm]) * 1000
+            ]
 
         multi_rotation = parameters.multi_rotation_scan
         rotation_template = multi_rotation.rotation_scans.copy()
@@ -105,6 +114,6 @@ def load_centre_collect_full(
             multi_rotation.demand_energy_ev
             == parameters.robot_load_then_centre.demand_energy_ev
         ), "Setting a different energy for gridscan and rotation is not supported"
-        yield from multi_rotation_scan(composite, multi_rotation, oav_params)
+        yield from multi_rotation_scan_internal(composite, multi_rotation, oav_params)
 
     yield from plan_with_callback_subs()

mx_bluesky/hyperion/experiment_plans/oav_snapshot_plan.py

@@ -9,8 +9,8 @@ from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVParameters
 from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.device_setup_plans.setup_oav import setup_general_oav_params
 from mx_bluesky.common.parameters.components import WithSnapshot
-from mx_bluesky.hyperion.device_setup_plans.setup_oav import setup_general_oav_params
 from mx_bluesky.hyperion.parameters.constants import CONST, DocDescriptorNames
 
 OAV_SNAPSHOT_SETUP_SHOT = "oav_snapshot_setup_shot"
@@ -34,7 +34,7 @@ def setup_beamline_for_OAV(
     yield from bps.abs_set(smargon.omega.velocity, max_vel, group=group)
     yield from bps.abs_set(backlight, BacklightPosition.IN, group=group)
     yield from bps.abs_set(
-        aperture_scatterguard, ApertureValue.OUT_OF_BEAM, group=group
+        aperture_scatterguard.selected_aperture, ApertureValue.OUT_OF_BEAM, group=group
     )
 
 
@@ -45,9 +45,12 @@ def oav_snapshot_plan(
 ) -> MsgGenerator:
     if not parameters.take_snapshots:
         return
-    yield from _setup_oav(composite, parameters, oav_parameters)
-    for omega in parameters.snapshot_omegas_deg or []:
-        yield from _take_oav_snapshot(composite, omega)
+    if parameters.use_grid_snapshots:
+        yield from _generate_oav_snapshots(composite, parameters)
+    else:
+        yield from _setup_oav(composite, parameters, oav_parameters)
+        for omega in parameters.snapshot_omegas_deg or []:
+            yield from _take_oav_snapshot(composite, omega)
 
 
 def _setup_oav(
@@ -62,12 +65,24 @@ def _setup_oav(
     )
 
 
+def _generate_oav_snapshots(composite: OavSnapshotComposite, params: WithSnapshot):
+    """Generate rotation snapshots from previously captured grid snapshots"""
+    yield from bps.abs_set(
+        composite.oav.snapshot.directory, str(params.snapshot_directory)
+    )
+    for _ in 0, 270:
+        yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
+        yield from bps.read(composite.oav)
+        yield from bps.read(composite.smargon)
+        yield from bps.save()
+
+
 def _take_oav_snapshot(composite: OavSnapshotComposite, omega: float):
+    """Create new snapshots by triggering the OAV"""
     yield from bps.abs_set(
         composite.smargon.omega, omega, group=OAV_SNAPSHOT_SETUP_SHOT
     )
-    time_now = datetime.now()
-    filename = f"{time_now.strftime('%H%M%S')}_oav_snapshot_{omega:.0f}"
+    filename = _snapshot_filename(omega)
     yield from bps.abs_set(
         composite.oav.snapshot.filename,
         filename,
@@ -76,5 +91,11 @@ def _take_oav_snapshot(composite: OavSnapshotComposite, omega: float):
     yield from bps.wait(group=OAV_SNAPSHOT_SETUP_SHOT)
     yield from bps.trigger(composite.oav.snapshot, wait=True)
     yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
-    yield from bps.read(composite.oav.snapshot)
+    yield from bps.read(composite.oav)
     yield from bps.save()
+
+
+def _snapshot_filename(omega):
+    time_now = datetime.now()
+    filename = f"{time_now.strftime('%H%M%S%f')[:8]}_oav_snapshot_{omega:.0f}"
+    return filename

mx_bluesky/hyperion/experiment_plans/pin_centre_then_xray_centre_plan.py

@@ -8,6 +8,10 @@ from bluesky.utils import MsgGenerator
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.oav.oav_parameters import OAVParameters
 
+from mx_bluesky.common.device_setup_plans.manipulate_sample import move_phi_chi_omega
+from mx_bluesky.common.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback import (
     ispyb_activation_wrapper,
 )
@@ -15,13 +19,9 @@ from mx_bluesky.common.parameters.constants import OavConstants
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.xrc_result import XRayCentreEventHandler
-from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import move_phi_chi_omega
 from mx_bluesky.hyperion.device_setup_plans.utils import (
     start_preparing_data_collection_then_do_plan,
 )
-from mx_bluesky.hyperion.experiment_plans.change_aperture_then_move_plan import (
-    change_aperture_then_move_to_xtal,
-)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     GridDetectThenXRayCentreComposite,
     detect_grid_and_do_gridscan,

mx_bluesky/hyperion/experiment_plans/pin_tip_centring_plan.py

@@ -9,16 +9,17 @@ from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAV_CONFIG_JSON, OAVParameters
 from dodal.devices.oav.pin_image_recognition import PinTipDetection, Tip
 from dodal.devices.oav.utils import (
+    PinNotFoundException,
     Pixel,
     get_move_required_so_that_beam_is_at_pixel,
     wait_for_tip_to_be_found,
 )
 from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.device_setup_plans.setup_oav import pre_centring_setup_oav
 from mx_bluesky.common.utils.context import device_composite_from_context
-from mx_bluesky.common.utils.exceptions import SampleException
+from mx_bluesky.common.utils.exceptions import SampleException, catch_exception_and_warn
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.device_setup_plans.setup_oav import pre_centring_setup_oav
 from mx_bluesky.hyperion.device_setup_plans.smargon import (
     move_smargon_warn_on_out_of_range,
 )
@@ -159,6 +160,7 @@ def pin_tip_centre_plan(
     # need to wait for the OAV image to update
     # See #673 for improvements
     yield from bps.sleep(0.3)
-
-    tip = yield from wait_for_tip_to_be_found(pin_tip_detect)
+    tip = yield from catch_exception_and_warn(
+        PinNotFoundException, wait_for_tip_to_be_found, pin_tip_detect
+    )
     yield from offset_and_move(tip)

mx_bluesky/hyperion/experiment_plans/robot_load_and_change_energy.py

@@ -12,14 +12,15 @@ from blueapi.core import BlueskyContext
 from bluesky.utils import Msg
 from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
-from dodal.devices.dcm import DCM
+from dodal.devices.backlight import Backlight, BacklightPosition
 from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
+from dodal.devices.i03.dcm import DCM
+from dodal.devices.i03.undulator_dcm import UndulatorDCM
 from dodal.devices.motors import XYZPositioner
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.robot import BartRobot, SampleLocation
 from dodal.devices.smargon import Smargon, StubPosition
 from dodal.devices.thawer import Thawer
-from dodal.devices.undulator_dcm import UndulatorDCM
 from dodal.devices.webcam import Webcam
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.plan_stubs.motor_utils import MoveTooLarge, home_and_reset_wrapper
@@ -51,6 +52,7 @@ class RobotLoadAndEnergyChangeComposite:
     oav: OAV
     smargon: Smargon
     aperture_scatterguard: ApertureScatterguard
+    backlight: Backlight
 
 
 def create_devices(context: BlueskyContext) -> RobotLoadAndEnergyChangeComposite:
@@ -95,7 +97,9 @@ def prepare_for_robot_load(
     aperture_scatterguard: ApertureScatterguard, smargon: Smargon
 ):
     yield from bps.abs_set(
-        aperture_scatterguard, ApertureValue.OUT_OF_BEAM, group="prepare_robot_load"
+        aperture_scatterguard.selected_aperture,
+        ApertureValue.OUT_OF_BEAM,
+        group="prepare_robot_load",
     )
 
     yield from bps.mv(smargon.stub_offsets, StubPosition.RESET_TO_ROBOT_LOAD)
@@ -166,6 +170,8 @@ def robot_load_and_snapshots(
     thawing_time: float,
     demand_energy_ev: float | None,
 ):
+    yield from bps.abs_set(composite.backlight, BacklightPosition.IN, group="snapshot")
+
     robot_load_plan = do_robot_load(
         composite,
         location,
@@ -189,6 +195,8 @@ def robot_load_and_snapshots(
         except_plan=raise_exception_if_moved_out_of_cryojet,
     )
 
+    yield from bps.wait(group="snapshot")
+
     yield from take_robot_snapshots(composite.oav, composite.webcam, snapshot_directory)
 
     yield from bps.create(name=CONST.DESCRIPTORS.ROBOT_LOAD)