mx-bluesky 1.5.15__py3-none-any.whl → 1.6.3__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.6.3'
+__version_tuple__ = version_tuple = (1, 6, 3)
 
 __commit_id__ = commit_id = None

mx_bluesky/beamlines/i02_1/parameters/gridscan.py

@@ -1,4 +1,4 @@
-from dodal.devices.i02_1.fast_grid_scan import ZebraGridScanParamsTwoD
+from dodal.devices.beamlines.i02_1.fast_grid_scan import ZebraGridScanParamsTwoD
 from scanspec.specs import Product
 
 from mx_bluesky.common.parameters.components import SplitScan, WithOptionalEnergyChange

mx_bluesky/beamlines/i04/__init__.py

@@ -2,6 +2,8 @@ from mx_bluesky.beamlines.i04.experiment_plans.i04_grid_detect_then_xray_centre_
     i04_default_grid_detect_and_xray_centre,
 )
 from mx_bluesky.beamlines.i04.oav_centering_plans.oav_imaging import (
+    find_beam_centres,
+    optimise_transmission_with_oav,
     take_oav_image_with_scintillator_in,
 )
 from mx_bluesky.beamlines.i04.thawing_plan import (
@@ -16,4 +18,6 @@ __all__ = [
     "i04_default_grid_detect_and_xray_centre",
     "thaw_and_murko_centre",
     "take_oav_image_with_scintillator_in",
+    "optimise_transmission_with_oav",
+    "find_beam_centres",
 ]

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

@@ -9,6 +9,8 @@ from dodal.common import inject
 from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
+from dodal.devices.beamlines.i04.beamsize import Beamsize
+from dodal.devices.beamlines.i04.transfocator import Transfocator
 from dodal.devices.common_dcm import DoubleCrystalMonochromator
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
@@ -17,8 +19,6 @@ from dodal.devices.fast_grid_scan import (
     set_fast_grid_scan_params,
 )
 from dodal.devices.flux import Flux
-from dodal.devices.i04.beamsize import Beamsize
-from dodal.devices.i04.transfocator import Transfocator
 from dodal.devices.mx_phase1.beamstop import Beamstop
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -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/oav_centering_plans/oav_imaging.py

@@ -6,8 +6,10 @@ from bluesky.utils import MsgGenerator
 from dodal.common import inject
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
+from dodal.devices.beamlines.i04.beam_centre import CentreEllipseMethod
+from dodal.devices.beamlines.i04.max_pixel import MaxPixel
 from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
-from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.oav_detector import OAV, ZoomControllerWithBeamCentres
 from dodal.devices.robot import BartRobot, PinMounted
 from dodal.devices.scintillator import InOut, Scintillator
 from dodal.devices.xbpm_feedback import XBPMFeedback
@@ -19,8 +21,9 @@ from dodal.devices.zebra.zebra_controlled_shutter import (
 from ophyd_async.core import InOut as core_INOUT
 
 from mx_bluesky.common.utils.exceptions import BeamlineStateError
+from mx_bluesky.common.utils.log import LOGGER
 
-initial_wait_group = "Wait for scint to move in"
+OAV_PREPARE_BEAMLINE_FOR_SCINT_WAIT = "Wait for scint to move in"
 
 
 def take_oav_image_with_scintillator_in(
@@ -48,21 +51,36 @@ def take_oav_image_with_scintillator_in(
                     defaults are always correct.
     """
 
+    LOGGER.info("Preparing beamline to take scintillator images...")
     yield from _prepare_beamline_for_scintillator_images(
-        robot, beamstop, backlight, scintillator, xbpm_feedback, initial_wait_group
+        robot,
+        beamstop,
+        backlight,
+        scintillator,
+        xbpm_feedback,
+        shutter,
+        OAV_PREPARE_BEAMLINE_FOR_SCINT_WAIT,
+    )
+    yield from bps.abs_set(
+        attenuator, transmission, group=OAV_PREPARE_BEAMLINE_FOR_SCINT_WAIT
     )
-
-    yield from bps.abs_set(attenuator, transmission, group=initial_wait_group)
 
     if image_name is None:
         image_name = f"{time.time_ns()}ATT{transmission * 100}"
+    LOGGER.info(f"Using image name {image_name}")
+    LOGGER.info("Waiting for prepare beamline plan to complete...")
+    yield from bps.wait(OAV_PREPARE_BEAMLINE_FOR_SCINT_WAIT)
 
-    yield from bps.wait(initial_wait_group)
+    LOGGER.info("Opening shutter...")
 
     yield from bps.abs_set(shutter.control_mode, ZebraShutterControl.MANUAL, wait=True)
     yield from bps.abs_set(shutter, ZebraShutterState.OPEN, wait=True)
 
-    take_and_save_oav_image(file_path=image_path, file_name=image_name, oav=oav)
+    LOGGER.info("Taking image...")
+
+    yield from take_and_save_oav_image(
+        file_path=image_path, file_name=image_name, oav=oav
+    )
 
 
 def _prepare_beamline_for_scintillator_images(
@@ -71,11 +89,13 @@ def _prepare_beamline_for_scintillator_images(
     backlight: Backlight,
     scintillator: Scintillator,
     xbpm_feedback: XBPMFeedback,
+    shutter: ZebraShutter,
     group: str,
 ) -> MsgGenerator:
     """
-    Prepares the beamline for oav image by making sure the pin is NOT mounted and
-    the beam is on (feedback check). Finally, the scintillator is moved in.
+    Prepares the beamline for oav image by making sure the pin is not mounted and
+    the beam is on (feedback check). Finally, the scintillator is moved in and the
+    shutter opened.
     """
     pin_mounted = yield from bps.rd(robot.gonio_pin_sensor)
     if pin_mounted == PinMounted.PIN_MOUNTED:
@@ -90,6 +110,9 @@ def _prepare_beamline_for_scintillator_images(
     yield from bps.abs_set(backlight, core_INOUT.OUT, group=group)
 
     yield from bps.abs_set(scintillator.selected_pos, InOut.IN, group=group)
+    # Not waiting for control mode to be set before opening shutter can result in timeout error
+    yield from bps.abs_set(shutter.control_mode, ZebraShutterControl.MANUAL, wait=True)
+    yield from bps.abs_set(shutter, ZebraShutterState.OPEN, group=group)
 
 
 def take_and_save_oav_image(
@@ -109,7 +132,198 @@ def take_and_save_oav_image(
     if not os.path.exists(full_file_path):
         yield from bps.abs_set(oav.snapshot.filename, file_name, group=group)
         yield from bps.abs_set(oav.snapshot.directory, file_path, group=group)
-        yield from bps.wait(group)
+        yield from bps.wait(group, timeout=60)
         yield from bps.trigger(oav.snapshot, wait=True)
     else:
         raise FileExistsError("OAV image file path already exists")
+
+
+def _max_pixel_at_transmission(
+    max_pixel: MaxPixel,
+    attenuator: BinaryFilterAttenuator,
+    xbpm_feedback: XBPMFeedback,
+    transmission: float,
+):
+    # Potential controls issue on XBPM device means it can mark
+    # itself as stable before it really is
+    yield from bps.trigger(xbpm_feedback, wait=True)
+    yield from bps.mv(attenuator, transmission)
+    yield from bps.trigger(max_pixel, wait=True)
+    return (yield from bps.rd(max_pixel.max_pixel_val))
+
+
+def optimise_transmission_with_oav(
+    upper_bound: float = 100,
+    lower_bound: float = 0,
+    target_brightness_fraction: float = 0.75,
+    min_transmission_change: float = 5,
+    max_iterations: int = 10,
+    max_pixel: MaxPixel = inject("max_pixel"),
+    attenuator: BinaryFilterAttenuator = inject("attenuator"),
+    xbpm_feedback: XBPMFeedback = inject("xbpm_feedback"),
+) -> MsgGenerator:
+    """
+    Plan to find the optimal oav transmission. First the brightest pixel at 100%
+    transmission is taken. A fraction of this (target_brightness_fraction) is taken
+    as the target - as in the optimal transmission will have it's max pixel as the set
+    target. A binary search is used to reach this.
+    Args:
+        upper_bound: Maximum transmission which will be searched. In percent.
+        lower_bound: Minimum transmission which will be searched. In percent.
+        target_brightness_fraction: Fraction of the brightest pixel at 100%
+                    transmission which should be used as the target max pixel brightness.
+        min_transmission_change: If the next search point would require a transmission
+                    change less than this then we stop.
+        max_iterations: Maximum amount of iterations.
+    """
+
+    if upper_bound < lower_bound:
+        raise ValueError(
+            f"Upper bound ({upper_bound}) must be higher than lower bound {lower_bound}"
+        )
+
+    brightest_pixel_at_full_beam = yield from _max_pixel_at_transmission(
+        max_pixel, attenuator, xbpm_feedback, 1
+    )
+
+    if brightest_pixel_at_full_beam == 0:
+        raise ValueError("No beam found at full transmission")
+
+    target_pixel_brightness = brightest_pixel_at_full_beam * target_brightness_fraction
+    LOGGER.info(
+        f"Optimising until max pixel in image has a value of {target_pixel_brightness}"
+    )
+
+    iterations = 0
+
+    while iterations < max_iterations:
+        mid = round((upper_bound + lower_bound) / 2, 2)  # limit to 2 dp
+        LOGGER.info(f"On iteration {iterations}")
+
+        current_transmission = yield from bps.rd(attenuator.actual_transmission)
+        transmission_change_percent = abs(mid - current_transmission * 100)
+        if transmission_change_percent < min_transmission_change:
+            LOGGER.info(
+                f"Next transmission change would be small ({transmission_change_percent}%) so stopping at {current_transmission}"
+            )
+            return
+
+        brightest_pixel = yield from _max_pixel_at_transmission(
+            max_pixel, attenuator, xbpm_feedback, mid / 100
+        )
+
+        LOGGER.info(f"Upper bound is: {upper_bound}, Lower bound is: {lower_bound}")
+        LOGGER.info(
+            f"Testing transmission {mid}, brightest pixel found {brightest_pixel}"
+        )
+
+        if target_pixel_brightness == brightest_pixel:
+            mid = round(mid, 0)
+            LOGGER.info(f"\nOptimal transmission found: {mid}")
+            return
+
+        # condition for too low so want to try higher
+        elif brightest_pixel < target_pixel_brightness:
+            LOGGER.info("Result: Too low \n")
+            lower_bound = mid
+
+        # condition for too high so want to try lower
+        elif brightest_pixel > target_pixel_brightness:
+            LOGGER.info("Result: Too high \n")
+            upper_bound = mid
+        iterations += 1
+    raise StopIteration("Max iterations reached")
+
+
+def _get_all_zoom_levels(
+    zoom_controller: ZoomControllerWithBeamCentres,
+) -> MsgGenerator[tuple[str]]:
+    zoom_levels = []
+    level_signals = [
+        centring_device.level_name
+        for centring_device in zoom_controller.beam_centres.values()
+    ]
+    for signal in level_signals:
+        level_name = yield from bps.rd(signal)
+        if level_name:
+            zoom_levels.append(level_name)
+    return tuple(zoom_levels)
+
+
+def find_beam_centres(
+    zoom_levels_to_centre: tuple[str, ...] | None = None,
+    zoom_levels_to_optimise_transmission: tuple[str, ...] = ("1.0x", "7.5x"),
+    robot: BartRobot = inject("robot"),
+    beamstop: Beamstop = inject("beamstop"),
+    backlight: Backlight = inject("backlight"),
+    scintillator: Scintillator = inject("scintillator"),
+    xbpm_feedback: XBPMFeedback = inject("xbpm_feedback"),
+    max_pixel: MaxPixel = inject("max_pixel"),
+    centre_ellipse: CentreEllipseMethod = inject("beam_centre"),
+    attenuator: BinaryFilterAttenuator = inject("attenuator"),
+    zoom_controller: ZoomControllerWithBeamCentres = inject("zoom_controller"),
+    shutter: ZebraShutter = inject("sample_shutter"),
+) -> MsgGenerator:
+    """
+    Finds beam centres at the zoom levels given by zoom_levels_to_centre, first
+    optimising transmission if the zoom level is in zoom_levels_to_optimise_transmission.
+
+    Note that the previous beam centre values are used to draw an ROI box around the
+    OAV image when finding updated beam centre. If the previous values are very wrong,
+    this plan may fail or give inaccurate results.
+
+    zoom_levels_to_centre: The levels to do centring at, by default runs at all known
+                           zoom levels.
+    zoom_levels_to_optimise_transmission: The levels to optimise transmission at,
+                           defaults to 1x and 7.5x
+    """
+
+    all_zooms = yield from _get_all_zoom_levels(zoom_controller)
+    if zoom_levels_to_centre is None:
+        zoom_levels_to_centre = all_zooms
+
+    for zoom in [*zoom_levels_to_optimise_transmission, *zoom_levels_to_centre]:
+        if zoom not in all_zooms:
+            raise ValueError(f"Unknown zoom ({zoom}). Known zooms are {all_zooms}")
+
+    LOGGER.info("Preparing beamline for images...")
+    yield from _prepare_beamline_for_scintillator_images(
+        robot,
+        beamstop,
+        backlight,
+        scintillator,
+        xbpm_feedback,
+        shutter,
+        OAV_PREPARE_BEAMLINE_FOR_SCINT_WAIT,
+    )
+    LOGGER.info("Waiting for prepare beamline plan to complete...")
+    yield from bps.wait(OAV_PREPARE_BEAMLINE_FOR_SCINT_WAIT)
+
+    for centring_device in zoom_controller.beam_centres.values():
+        zoom_name = yield from bps.rd(centring_device.level_name)
+        if zoom_name in zoom_levels_to_centre:
+            LOGGER.info(f"Moving to zoom level {zoom_name}")
+            yield from bps.abs_set(zoom_controller, zoom_name, wait=True)
+            if zoom_name in zoom_levels_to_optimise_transmission:
+                LOGGER.info(f"Optimising transmission at zoom level {zoom_name}")
+                yield from optimise_transmission_with_oav(
+                    100,
+                    0,
+                    max_pixel=max_pixel,
+                    attenuator=attenuator,
+                    xbpm_feedback=xbpm_feedback,
+                )
+
+            yield from bps.trigger(centre_ellipse, wait=True)
+            centre_x = yield from bps.rd(centre_ellipse.center_x_val)
+            centre_y = yield from bps.rd(centre_ellipse.center_y_val)
+            centre_x = round(centre_x)
+            centre_y = round(centre_y)
+            LOGGER.info(
+                f"Writing centre values ({centre_x}, {centre_y}) to OAV PVs at zoom level {zoom_name}"
+            )
+            yield from bps.mv(
+                centring_device.x_centre, centre_x, centring_device.y_centre, centre_y
+            )
+
+    LOGGER.info("Find beam centre plan completed!")

mx_bluesky/beamlines/i04/redis_to_murko_forwarder.py

@@ -8,8 +8,11 @@ from typing import TypedDict
 
 import numpy as np
 import zmq
-from dodal.devices.i04.constants import RedisConstants
-from dodal.devices.i04.murko_results import RESULTS_COMPLETE_MESSAGE, MurkoResult
+from dodal.devices.beamlines.i04.constants import RedisConstants
+from dodal.devices.beamlines.i04.murko_results import (
+    RESULTS_COMPLETE_MESSAGE,
+    MurkoResult,
+)
 from numpy.typing import NDArray
 from PIL import Image
 from redis import StrictRedis

mx_bluesky/beamlines/i04/thawing_plan.py

@@ -3,8 +3,8 @@ import bluesky.preprocessors as bpp
 from bluesky.preprocessors import contingency_decorator, run_decorator, subs_decorator
 from bluesky.utils import MsgGenerator
 from dodal.common import inject
-from dodal.devices.i04.constants import RedisConstants
-from dodal.devices.i04.murko_results import MurkoResultsDevice
+from dodal.devices.beamlines.i04.constants import RedisConstants
+from dodal.devices.beamlines.i04.murko_results import MurkoResultsDevice
 from dodal.devices.oav.oav_to_redis_forwarder import OAVToRedisForwarder, Source
 from dodal.devices.robot import BartRobot
 from dodal.devices.smargon import Smargon
@@ -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.beamlines.i24.aperture import Aperture
+from dodal.devices.beamlines.i24.beamstop import Beamstop
+from dodal.devices.beamlines.i24.commissioning_jungfrau import CommissioningJungfrau
+from dodal.devices.beamlines.i24.dcm import DCM
+from dodal.devices.beamlines.i24.dual_backlight import DualBacklight
+from dodal.devices.beamlines.i24.vgonio import VerticalGoniometer
+from dodal.devices.hutch_shutter import HutchShutter
+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