mx-bluesky 1.5.15__py3-none-any.whl → 1.5.16__py3-none-any.whl

mx_bluesky/Getting started.ipynb

@@ -52,6 +52,7 @@
     "import importlib\n",
     "\n",
     "from dodal.utils import collect_factories\n",
+    "\n",
     "beamline = \"i02_2\"\n",
     "module_name = f\"dodal.beamlines.{beamline}\"\n",
     "beamline_module = importlib.import_module(module_name)\n",

mx_bluesky/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.15'
-__version_tuple__ = version_tuple = (1, 5, 15)
+__version__ = version = '1.5.16'
+__version_tuple__ = version_tuple = (1, 5, 16)
 
 __commit_id__ = commit_id = None

mx_bluesky/beamlines/i04/callbacks/murko_callback.py

@@ -7,6 +7,7 @@ from bluesky.callbacks import CallbackBase
 from dodal.log import LOGGER
 from event_model.documents import Event, RunStart, RunStop
 from redis import StrictRedis
+from redis.exceptions import ConnectionError
 
 FORWARDING_COMPLETE_MESSAGE = "image_forwarding_complete"
 
@@ -57,7 +58,20 @@ class MurkoCallback(CallbackBase):
         self.last_uuid = None
         self.previous_omegas: list[OmegaReading] = []
 
+    def _check_redis_connection(self):
+        try:
+            self.redis_client.ping()
+            return True
+        except ConnectionError:
+            LOGGER.warning(
+                f"Failed to connect to redis: {self.redis_client}. Murko callback will not run"
+            )
+            return False
+
     def start(self, doc: RunStart) -> RunStart | None:
+        self.redis_connected = self._check_redis_connection()
+        if not self.redis_connected:
+            return doc
         self.murko_metadata: dict = {"sample_id": doc.get("sample_id")}
         self.last_uuid = None
         self.previous_omegas = []
@@ -67,6 +81,8 @@ class MurkoCallback(CallbackBase):
         return doc
 
     def event(self, doc: Event) -> Event:
+        if not self.redis_connected:
+            return doc
         data = doc["data"]
         for prefix in ("oav", "oav_full_screen"):
             if f"{prefix}-beam_centre_j" in data:
@@ -114,6 +130,8 @@ class MurkoCallback(CallbackBase):
         self.redis_client.publish("murko", json.dumps(metadata))
 
     def stop(self, doc: RunStop) -> RunStop | None:
+        if not self.redis_connected:
+            return doc
         LOGGER.info(f"Finished streaming {self.murko_metadata['sample_id']} to murko")
         LOGGER.info(
             f"Publishing forwarding complete message: {FORWARDING_COMPLETE_MESSAGE}"

mx_bluesky/beamlines/i04/experiment_plans/i04_grid_detect_then_xray_centre_plan.py

@@ -78,7 +78,7 @@ from mx_bluesky.common.parameters.gridscan import (
     SpecifiedThreeDGridScan,
 )
 from mx_bluesky.common.preprocessors.preprocessors import (
-    transmission_and_xbpm_feedback_for_collection_decorator,
+    set_transmission_and_trigger_xbpm_feedback_before_collection_decorator,
 )
 from mx_bluesky.common.utils.exceptions import CrystalNotFoundError
 from mx_bluesky.common.utils.log import LOGGER
@@ -203,7 +203,7 @@ def i04_default_grid_detect_and_xray_centre(
 
         @bpp.subs_decorator(callbacks)
         @verify_undulator_gap_before_run_decorator(composite)
-        @transmission_and_xbpm_feedback_for_collection_decorator(
+        @set_transmission_and_trigger_xbpm_feedback_before_collection_decorator(
             composite,
             grid_common_params.transmission_frac,
             PlanNameConstants.GRIDSCAN_OUTER,
@@ -291,6 +291,7 @@ def construct_i04_specific_features(
         xrc_composite.eiger.bit_depth,
         xrc_composite.beamsize,
         xrc_composite.eiger.cam.roi_mode,
+        xrc_composite.eiger.ispyb_detector_id,
     ]
 
     tidy_plan = partial(

mx_bluesky/beamlines/i04/thawing_plan.py

@@ -88,6 +88,7 @@ def thaw_and_murko_centre(
     initial_zoom_level = yield from bps.rd(oav_fs.zoom_controller.level)
     initial_velocity = yield from bps.rd(smargon.omega.velocity)
     new_velocity = abs(rotation / time_to_thaw) * 2.0
+
     murko_callback = MurkoCallback(
         RedisConstants.REDIS_HOST,
         RedisConstants.REDIS_PASSWORD,

mx_bluesky/beamlines/i24/jungfrau_commissioning/__init__.py

@@ -0,0 +1,13 @@
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.experiment_plans.do_darks import (
+    do_non_pedestal_darks,
+    do_pedestal_darks,
+)
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.experiment_plans.rotation_scan_plan import (
+    single_rotation_plan,
+)
+
+__all__ = [
+    "do_pedestal_darks",
+    "do_non_pedestal_darks",
+    "single_rotation_plan",
+]

mx_bluesky/beamlines/i24/jungfrau_commissioning/callbacks/metadata_writer.py

@@ -0,0 +1,86 @@
+import json
+from pathlib import Path
+
+from bluesky.callbacks import CallbackBase
+
+from mx_bluesky.beamlines.i24.parameters.constants import PlanNameConstants
+from mx_bluesky.common.parameters.rotation import SingleRotationScan
+from mx_bluesky.common.utils.log import LOGGER
+
+READING_DUMP_FILENAME = "collection_info.json"
+
+
+class JsonMetadataWriter(CallbackBase):
+    """Callback class to handle the creation of metadata json files for commissioning.
+
+    To use, subscribe the Bluesky RunEngine to an instance of this class.
+    E.g.:
+        metadata_writer_callback = JsonMetadataWriter(parameters)
+        RE.subscribe(metadata_writer_callback)
+    Or decorate a plan using bluesky.preprocessors.subs_decorator.
+
+    See: https://blueskyproject.io/bluesky/callbacks.html#ways-to-invoke-callbacks
+
+    """
+
+    def __init__(self):
+        self.wavelength_in_a = None
+        self.energy_in_kev = None
+        self.detector_distance_mm = None
+        self.final_path: Path | None = None
+        self.descriptors: dict[str, dict] = {}
+        self.transmission: float | None = None
+        self.parameters: SingleRotationScan | None = None
+
+        super().__init__()
+
+    def start(self, doc: dict):  # type: ignore
+        if doc.get("subplan_name") == PlanNameConstants.ROTATION_MAIN:
+            json_params = doc.get("rotation_scan_params")
+            assert json_params is not None
+            LOGGER.info(
+                f"Metadata writer recieved start document with experiment parameters {json_params}"
+            )
+            self.parameters = SingleRotationScan(**json.loads(json_params))
+            self.run_start_uid = doc.get("uid")
+
+    def descriptor(self, doc: dict):  # type: ignore
+        self.descriptors[doc["uid"]] = doc
+
+    def event(self, doc: dict):  # type: ignore
+        event_descriptor = self.descriptors[doc["descriptor"]]
+
+        if event_descriptor.get("name") == PlanNameConstants.ROTATION_DEVICE_READ:
+            assert self.parameters is not None
+            data = doc.get("data")
+            assert data is not None
+            self.wavelength_in_a = data.get("dcm-wavelength_in_a")
+            self.energy_in_kev = data.get("dcm-energy_in_keV")
+            self.detector_distance_mm = data.get("detector_motion-z")
+            assert data.get("detector-_writer-file_path"), (
+                "No detector writer path was found"
+            )
+            self.final_path = Path(data.get("detector-_writer-file_path"))
+
+            LOGGER.info(
+                f"Metadata writer received parameters, energy_in_kev: {self.energy_in_kev}, wavelength: {self.wavelength_in_a}, det_distance_mm: {self.detector_distance_mm}, file path: {self.final_path}"
+            )
+
+    def stop(self, doc: dict):  # type: ignore
+        assert self.parameters is not None
+        if (
+            self.run_start_uid is not None
+            and doc.get("run_start") == self.run_start_uid
+            and self.final_path
+        ):
+            with open(self.final_path / READING_DUMP_FILENAME, "w") as f:
+                f.write(
+                    json.dumps(
+                        {
+                            "wavelength_in_a": self.wavelength_in_a,
+                            "energy_kev": self.energy_in_kev,
+                            "angular_increment_deg": self.parameters.rotation_increment_deg,
+                            "detector_distance_mm": self.detector_distance_mm,
+                        }
+                    )
+                )

mx_bluesky/beamlines/i24/jungfrau_commissioning/composites.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import pydantic
+from dodal.devices.attenuator.attenuator import EnumFilterAttenuator
+from dodal.devices.hutch_shutter import HutchShutter
+from dodal.devices.i24.aperture import Aperture
+from dodal.devices.i24.beamstop import Beamstop
+from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
+from dodal.devices.i24.dcm import DCM
+from dodal.devices.i24.dual_backlight import DualBacklight
+from dodal.devices.i24.vgonio import VerticalGoniometer
+from dodal.devices.motors import YZStage
+from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.xbpm_feedback import XBPMFeedback
+from dodal.devices.zebra.zebra import Zebra
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class RotationScanComposite:
+    """All devices which are directly or indirectly required by this plan"""
+
+    aperture: Aperture
+    attenuator: EnumFilterAttenuator
+    jungfrau: CommissioningJungfrau
+    gonio: VerticalGoniometer
+    synchrotron: Synchrotron
+    sample_shutter: ZebraShutter
+    zebra: Zebra
+    xbpm_feedback: XBPMFeedback
+    hutch_shutter: HutchShutter
+    beamstop: Beamstop
+    det_stage: YZStage
+    backlight: DualBacklight
+    dcm: DCM

mx_bluesky/beamlines/i24/jungfrau_commissioning/experiment_plans/do_darks.py

@@ -13,7 +13,6 @@ from pydantic import PositiveInt
 
 from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_stubs.plan_utils import (
     fly_jungfrau,
-    override_file_path,
 )
 from mx_bluesky.common.utils.log import LOGGER
 
@@ -25,8 +24,8 @@ def do_pedestal_darks(
     exp_time_s: float = 0.001,
     pedestal_frames: PositiveInt = 20,
     pedestal_loops: PositiveInt = 200,
+    filename: str = "pedestal_darks",
     jungfrau: CommissioningJungfrau = inject("jungfrau"),
-    path_of_output_file: str | None = None,
 ) -> MsgGenerator:
     """Acquire darks in pedestal mode, using dynamic gain mode. This calibrates the offsets
     for the jungfrau, and must be performed before acquiring real data in dynamic gain mode.
@@ -46,18 +45,19 @@ def do_pedestal_darks(
         exp_time_s: Length of detector exposure for each frame.
         pedestal_frames: Number of frames acquired per pedestal loop.
         pedestal_loops: Number of times to acquire a set of pedestal_frames
+        filename: Name of output file
         jungfrau: Jungfrau device
-        path_of_output_file: Absolute path of the detector file output, including file name. If None, then use the PathProvider
-            set during Jungfrau device instantiation
     """
 
     @bpp.set_run_key_decorator(PEDESTAL_DARKS_RUN)
-    @bpp.run_decorator(md={"subplan_name": PEDESTAL_DARKS_RUN})
+    @bpp.run_decorator(
+        md={
+            "subplan_name": PEDESTAL_DARKS_RUN,
+            "detector_file_template": filename,
+        }
+    )
     @bpp.stage_decorator([jungfrau])
     def _do_decorated_plan():
-        if path_of_output_file:
-            override_file_path(jungfrau, path_of_output_file)
-
         trigger_info = create_jungfrau_pedestal_triggering_info(
             exp_time_s, pedestal_frames, pedestal_loops
         )
@@ -67,12 +67,11 @@ def do_pedestal_darks(
         yield from bps.mv(
             jungfrau.drv.acquisition_type,
             AcquisitionType.PEDESTAL,
-            jungfrau.drv.gain_mode,
-            GainMode.DYNAMIC,
         )
         yield from fly_jungfrau(
             jungfrau,
             trigger_info,
+            GainMode.DYNAMIC,
             wait=True,
             log_on_percentage_prefix="Jungfrau pedestal dynamic gain mode darks triggers received",
         )
@@ -84,8 +83,8 @@ def do_non_pedestal_darks(
     gain_mode: GainMode,
     exp_time_s: float = 0.001,
     total_triggers: PositiveInt = 1000,
+    filename: str = "darks",
     jungfrau: CommissioningJungfrau = inject("jungfrau"),
-    path_of_output_file: str | None = None,
 ) -> MsgGenerator:
     """Internally take a set of images at a given gain mode.
 
@@ -96,26 +95,26 @@ def do_non_pedestal_darks(
         exp_time_s: Length of detector exposure for each trigger.
         total_triggers: Total triggers for the dark scan.
         jungfrau: Jungfrau device
-        path_of_output_file: Absolute path of the detector file output, including file name. If None, then use the PathProvider
-            set during Jungfrau device instantiation
+        filename: Name of output file
     """
 
     @bpp.set_run_key_decorator(STANDARD_DARKS_RUN)
-    @bpp.run_decorator(md={"subplan_name": STANDARD_DARKS_RUN})
+    @bpp.run_decorator(
+        md={
+            "subplan_name": STANDARD_DARKS_RUN,
+            "detector_file_template": filename,
+        }
+    )
     @bpp.stage_decorator([jungfrau])
     def _do_decorated_plan():
-        if path_of_output_file:
-            override_file_path(jungfrau, path_of_output_file)
-
         trigger_info = create_jungfrau_internal_triggering_info(
             total_triggers, exp_time_s
         )
 
-        yield from bps.mv(jungfrau.drv.gain_mode, gain_mode)
-
         yield from fly_jungfrau(
             jungfrau,
             trigger_info,
+            gain_mode,
             wait=True,
             log_on_percentage_prefix=f"Jungfrau {gain_mode} gain mode darks triggers received",
         )

mx_bluesky/beamlines/i24/jungfrau_commissioning/experiment_plans/rotation_scan_plan.py

@@ -0,0 +1,292 @@
+from functools import partial
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+from bluesky.preprocessors import run_decorator
+from bluesky.utils import MsgGenerator
+from dodal.devices.hutch_shutter import ShutterState
+from dodal.devices.i24.aperture import AperturePositions
+from dodal.devices.i24.beamstop import BeamstopPositions
+from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
+from dodal.devices.i24.dual_backlight import BacklightPositions
+from dodal.devices.zebra.zebra import ArmDemand, I24Axes, Zebra
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
+from ophyd_async.fastcs.jungfrau import (
+    GainMode,
+    create_jungfrau_external_triggering_info,
+)
+from pydantic import BaseModel, field_validator
+
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.callbacks.metadata_writer import (
+    JsonMetadataWriter,
+)
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.composites import (
+    RotationScanComposite,
+)
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_stubs.plan_utils import (
+    JF_COMPLETE_GROUP,
+    fly_jungfrau,
+)
+from mx_bluesky.beamlines.i24.parameters.constants import (
+    PlanNameConstants,
+)
+from mx_bluesky.common.device_setup_plans.setup_zebra_and_shutter import (
+    setup_zebra_for_rotation,
+    tidy_up_zebra_after_rotation_scan,
+)
+from mx_bluesky.common.experiment_plans.inner_plans.read_hardware import (
+    read_hardware_plan,
+)
+from mx_bluesky.common.experiment_plans.rotation.rotation_utils import (
+    RotationMotionProfile,
+    calculate_motion_profile,
+)
+from mx_bluesky.common.parameters.components import PARAMETER_VERSION
+from mx_bluesky.common.parameters.constants import (
+    USE_NUMTRACKER,
+    PlanGroupCheckpointConstants,
+)
+from mx_bluesky.common.parameters.rotation import (
+    SingleRotationScan,
+)
+from mx_bluesky.common.utils.log import LOGGER
+
+READING_DUMP_FILENAME = "collection_info.json"
+
+# Should be read from config file, see
+# https://github.com/DiamondLightSource/mx-bluesky/issues/1502
+JF_DET_STAGE_Y_POSITION_MM = 730
+DEFAULT_DETECTOR_DISTANCE_MM = 200
+
+
+class ExternalRotationScanParams(BaseModel):
+    transmission_fractions: list[float]
+    exposure_time_s: float
+    omega_start_deg: float = 0
+    rotation_increment_per_image_deg: float = 0.1
+    filename: str = "rotations"
+    detector_distance_mm: float = DEFAULT_DETECTOR_DISTANCE_MM
+    sample_id: int
+
+    @field_validator("transmission_fractions")
+    @classmethod
+    def validate_transmission_fractions(cls, values):
+        for v in values:
+            if not 0 <= v <= 1:
+                raise ValueError(
+                    f"All transmission fractions must be between 0 and 1; got {v}"
+                )
+        return values
+
+
+def _get_internal_rotation_params(
+    entry_params: ExternalRotationScanParams, transmission: float
+) -> SingleRotationScan:
+    return SingleRotationScan(
+        sample_id=entry_params.sample_id,
+        visit=USE_NUMTRACKER,  # See https://github.com/DiamondLightSource/mx-bluesky/issues/1527
+        parameter_model_version=PARAMETER_VERSION,
+        file_name=entry_params.filename,
+        transmission_frac=transmission,
+        exposure_time_s=entry_params.exposure_time_s,
+        storage_directory=USE_NUMTRACKER,
+    )
+
+
+class HutchClosedError(Exception): ...
+
+
+def rotation_scan_plan(
+    composite: RotationScanComposite, params: ExternalRotationScanParams
+) -> MsgGenerator:
+    """BlueAPI entry point for i24 JF rotation scans"""
+
+    for transmission in params.transmission_fractions:
+        rotation_params = _get_internal_rotation_params(params, transmission)
+        yield from single_rotation_plan(composite, rotation_params)
+
+
+def set_up_beamline_for_rotation(
+    composite: RotationScanComposite,
+    det_z_mm: float,
+    transmission_frac: float,
+):
+    """Check hutch is open, then, in parallel, move backlight in,
+    move aperture in, move beamstop out and move det stages in. Wait for this parallel
+    move to finish."""
+
+    hutch_shutter_state: ShutterState = yield from bps.rd(
+        composite.hutch_shutter.status
+    )
+    LOGGER.info(f"Hutch shutter: {hutch_shutter_state}")
+    if hutch_shutter_state != ShutterState.OPEN:
+        LOGGER.error(f"Hutch shutter is not open! State is {hutch_shutter_state}")
+        raise HutchClosedError(
+            f"Hutch shutter is not open! State is {hutch_shutter_state}"
+        )
+
+    LOGGER.info(
+        "Making sure aperture and beamstop are in, detector stages are in position, backlight is out, and transmission is set..."
+    )
+    yield from bps.mv(
+        composite.aperture.position,
+        AperturePositions.IN,
+        composite.beamstop.pos_select,
+        BeamstopPositions.DATA_COLLECTION,
+        composite.det_stage.y,
+        JF_DET_STAGE_Y_POSITION_MM,
+        composite.backlight.backlight_position,
+        BacklightPositions.OUT,
+        composite.det_stage.z,
+        det_z_mm,
+        composite.attenuator,
+        transmission_frac,
+    )
+
+
+def single_rotation_plan(
+    composite: RotationScanComposite,
+    params: SingleRotationScan,
+):
+    """A stub plan to collect diffraction images from a sample continuously rotating
+    about a fixed axis - for now this axis is limited to omega.
+    Needs additional setup of the sample environment and a wrapper to clean up."""
+
+    @bpp.set_run_key_decorator(PlanNameConstants.SINGLE_ROTATION_SCAN)
+    @run_decorator()
+    def _plan_in_run_decorator():
+        if not params.detector_distance_mm:
+            LOGGER.info(
+                f"Using default detector distance of  {DEFAULT_DETECTOR_DISTANCE_MM} mm"
+            )
+            params.detector_distance_mm = DEFAULT_DETECTOR_DISTANCE_MM
+
+        yield from set_up_beamline_for_rotation(
+            composite, params.detector_distance_mm, params.transmission_frac
+        )
+
+        # This value isn't actually used, see https://github.com/DiamondLightSource/mx-bluesky/issues/1224
+        _motor_time_to_speed = 1
+        _max_velocity_deg_s = yield from bps.rd(composite.gonio.omega.max_velocity)
+
+        motion_values = calculate_motion_profile(
+            params, _motor_time_to_speed, _max_velocity_deg_s
+        )
+
+        # Callback which intercepts read documents and writes to json file,
+        # used for saving device metadata
+        metadata_writer = JsonMetadataWriter()
+
+        @bpp.subs_decorator([metadata_writer])
+        @bpp.set_run_key_decorator(PlanNameConstants.ROTATION_MAIN)
+        @bpp.run_decorator(
+            md={
+                "subplan_name": PlanNameConstants.ROTATION_MAIN,
+                "scan_points": [params.scan_points],
+                "rotation_scan_params": params.model_dump_json(),
+                "detector_file_template": params.file_name,
+            }
+        )
+        def _rotation_scan_plan(
+            motion_values: RotationMotionProfile,
+            composite: RotationScanComposite,
+        ):
+            _jf_trigger_info = create_jungfrau_external_triggering_info(
+                params.num_images, params.detector_params.exposure_time_s
+            )
+
+            axis = composite.gonio.omega
+
+            # can move to start as fast as possible
+            yield from bps.abs_set(
+                axis.velocity, motion_values.max_velocity_deg_s, wait=True
+            )
+            LOGGER.info(f"Moving omega to start value, {motion_values.start_scan_deg=}")
+            yield from bps.abs_set(
+                axis,
+                motion_values.start_motion_deg,
+                group=PlanGroupCheckpointConstants.ROTATION_READY_FOR_DC,
+            )
+
+            yield from setup_zebra_for_rotation(
+                composite.zebra,
+                composite.sample_shutter,
+                axis=I24Axes.OMEGA,
+                start_angle=motion_values.start_scan_deg,
+                scan_width=motion_values.scan_width_deg,
+                direction=motion_values.direction,
+                shutter_opening_deg=motion_values.shutter_opening_deg,
+                shutter_opening_s=motion_values.shutter_time_s,
+            )
+
+            yield from bps.wait(PlanGroupCheckpointConstants.ROTATION_READY_FOR_DC)
+
+            # Get ready for the actual scan
+            yield from bps.abs_set(
+                axis.velocity, motion_values.speed_for_rotation_deg_s, wait=True
+            )
+            yield from bps.abs_set(composite.zebra.pc.arm, ArmDemand.ARM, wait=True)
+
+            # Should check topup gate here, but not yet implemented,
+            # see https://github.com/DiamondLightSource/mx-bluesky/issues/1501
+
+            # Read hardware after preparing jungfrau so that device metadata output from callback is correct
+            # Whilst metadata is being written in bluesky we need to access the private writer here
+            read_hardware_partial = partial(
+                read_hardware_plan,
+                [
+                    composite.dcm.energy_in_keV,
+                    composite.dcm.wavelength_in_a,
+                    composite.det_stage.z,
+                    composite.jungfrau._writer.file_path,  # noqa: SLF001 N
+                ],
+                PlanNameConstants.ROTATION_DEVICE_READ,
+            )
+
+            yield from fly_jungfrau(
+                composite.jungfrau,
+                _jf_trigger_info,
+                GainMode.DYNAMIC,
+                wait=False,
+                log_on_percentage_prefix="Jungfrau rotation scan triggers received",
+                read_hardware_after_prepare_plan=read_hardware_partial,
+            )
+
+            LOGGER.info("Executing rotation scan")
+            yield from bps.rel_set(
+                axis,
+                motion_values.distance_to_move_deg,
+                wait=False,
+                group=JF_COMPLETE_GROUP,
+            )
+
+            LOGGER.info(
+                "Waiting for omega to finish moving and for Jungfrau to receive correct number of triggers"
+            )
+            yield from bps.wait(group=JF_COMPLETE_GROUP)
+
+        yield from bpp.finalize_wrapper(
+            _rotation_scan_plan(motion_values, composite),
+            final_plan=partial(
+                _cleanup_plan,
+                composite.zebra,
+                composite.jungfrau,
+                composite.sample_shutter,
+            ),
+        )
+
+    yield from _plan_in_run_decorator()
+
+
+def _cleanup_plan(
+    zebra: Zebra,
+    jf: CommissioningJungfrau,
+    zebra_shutter: ZebraShutter,
+    group="rotation cleanup",
+):
+    LOGGER.info("Tidying up Zebra and Jungfrau...")
+    yield from bps.unstage(jf, group=group)
+    yield from tidy_up_zebra_after_rotation_scan(
+        zebra, zebra_shutter, group=group, wait=False
+    )
+    yield from bps.wait(group=group)

mx_bluesky/beamlines/i24/jungfrau_commissioning/plan_stubs/do_external_acquisition.py

@@ -5,20 +5,20 @@ from ophyd_async.core import (
     WatchableAsyncStatus,
 )
 from ophyd_async.fastcs.jungfrau import (
+    GainMode,
     create_jungfrau_external_triggering_info,
 )
 from pydantic import PositiveInt
 
 from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_stubs.plan_utils import (
     fly_jungfrau,
-    override_file_path,
 )
 
 
 def do_external_acquisition(
     exp_time_s: float,
+    gain_mode: GainMode,
     total_triggers: PositiveInt = 1,
-    output_file_path: str | None = None,
     wait: bool = False,
     jungfrau: CommissioningJungfrau = inject("commissioning_jungfrau"),
 ) -> MsgGenerator[WatchableAsyncStatus]:
@@ -32,14 +32,9 @@ def do_external_acquisition(
         exp_time_s: Length of detector exposure for each frame.
         total_triggers: Number of external triggers received before acquisition is marked as complete.
         jungfrau: Jungfrau device
-        output_file_name: Absolute path of the detector file output, including file name. If None, then use the PathProvider
-            set during jungfrau device instantiation
         wait: Optionally block until data collection is complete.
     """
 
-    if output_file_path:
-        override_file_path(jungfrau, output_file_path)
-
     trigger_info = create_jungfrau_external_triggering_info(total_triggers, exp_time_s)
-    status = yield from fly_jungfrau(jungfrau, trigger_info, wait=wait)
+    status = yield from fly_jungfrau(jungfrau, trigger_info, gain_mode, wait=wait)
     return status