mx-bluesky 1.5.11__py3-none-any.whl → 1.5.12__py3-none-any.whl

mx_bluesky/beamlines/i04/oav_centering_plans/oav_imaging.py

@@ -0,0 +1,115 @@
+import os
+import time
+
+import bluesky.plan_stubs as bps
+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.mx_phase1.beamstop import Beamstop, BeamstopPositions
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.robot import BartRobot, PinMounted
+from dodal.devices.scintillator import InOut, Scintillator
+from dodal.devices.xbpm_feedback import XBPMFeedback
+from dodal.devices.zebra.zebra_controlled_shutter import (
+    ZebraShutter,
+    ZebraShutterControl,
+    ZebraShutterState,
+)
+from ophyd_async.core import InOut as core_INOUT
+
+from mx_bluesky.common.utils.exceptions import BeamlineStateError
+
+initial_wait_group = "Wait for scint to move in"
+
+
+def take_oav_image_with_scintillator_in(
+    image_name: str | None = None,
+    image_path: str = "dls_sw/i04/software/bluesky/scratch",
+    transmission: float = 1,
+    attenuator: BinaryFilterAttenuator = inject("attenuator"),
+    shutter: ZebraShutter = inject("sample_shutter"),
+    oav: OAV = inject("oav"),
+    robot: BartRobot = inject("robot"),
+    beamstop: Beamstop = inject("beamstop"),
+    backlight: Backlight = inject("backlight"),
+    scintillator: Scintillator = inject("scintillator"),
+    xbpm_feedback: XBPMFeedback = inject("xbpm_feedback"),
+) -> MsgGenerator:
+    """
+    Takes an OAV image at specified transmission after necessary checks and preparation steps.
+
+    Args:
+        image_name: Name of the OAV image to be saved
+        image_path: Path where the image should be saved
+        transmission: Transmission of the beam, takes a value from 0 to 1 where
+                    1 lets all the beam through and 0 lets none of the beam through.
+        devices: These are the specific ophyd-devices used for the plan, the
+                    defaults are always correct.
+    """
+
+    yield from _prepare_beamline_for_scintillator_images(
+        robot, beamstop, backlight, scintillator, xbpm_feedback, initial_wait_group
+    )
+
+    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}"
+
+    yield from bps.wait(initial_wait_group)
+
+    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)
+
+
+def _prepare_beamline_for_scintillator_images(
+    robot: BartRobot,
+    beamstop: Beamstop,
+    backlight: Backlight,
+    scintillator: Scintillator,
+    xbpm_feedback: XBPMFeedback,
+    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.
+    """
+    pin_mounted = yield from bps.rd(robot.gonio_pin_sensor)
+    if pin_mounted == PinMounted.PIN_MOUNTED:
+        raise BeamlineStateError("Pin should not be mounted!")
+
+    yield from bps.trigger(xbpm_feedback, group=group)
+
+    yield from bps.abs_set(
+        beamstop.selected_pos, BeamstopPositions.DATA_COLLECTION, group=group
+    )
+
+    yield from bps.abs_set(backlight, core_INOUT.OUT, group=group)
+
+    yield from bps.abs_set(scintillator.selected_pos, InOut.IN, group=group)
+
+
+def take_and_save_oav_image(
+    file_name: str,
+    file_path: str,
+    oav: OAV,
+) -> MsgGenerator:
+    """
+    Plan which takes and saves an OAV image to the specified path.
+     Args:
+        file_name: Filename specifying the name of the image,
+        file_path: Path as a string specifying where the image should be saved,
+        oav: The OAV to take the image with
+    """
+    group = "oav image path setting"
+    full_file_path = file_path + "/" + file_name
+    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.trigger(oav.snapshot, wait=True)
+    else:
+        raise FileExistsError("OAV image file path already exists")

mx_bluesky/beamlines/i04/parameters/constants.py

@@ -0,0 +1,21 @@
+from pydantic.dataclasses import dataclass
+
+from mx_bluesky.common.parameters.constants import (
+    FeatureSettings,
+    FeatureSettingSources,
+)
+
+
+# These currently exist in GDA domain.properties
+class I04FeatureSettingsSources(FeatureSettingSources):
+    ASSUMED_WAVELENGTH_IN_A = "gda.px.expttable.default.wavelength"
+    XRC_UNSCALED_TRANSMISSION_FRAC = "gda.mx.bluesky.i04.xrc.unscaled_transmission_frac"
+    XRC_UNSCALED_EXPOSURE_TIME_S = "gda.mx.bluesky.i04.xrc.unscaled_exposure_time_s"
+
+
+# Use these defaults if we can't read from the config server
+@dataclass
+class I04FeatureSettings(FeatureSettings):
+    ASSUMED_WAVELENGTH_IN_A: float = 0.95373
+    XRC_UNSCALED_TRANSMISSION_FRAC: int = 1
+    XRC_UNSCALED_EXPOSURE_TIME_S: float = 0.007

mx_bluesky/beamlines/i04/redis_to_murko_forwarder.py

@@ -1,21 +1,27 @@
 import io
 import json
+import logging
 import pickle
 from datetime import timedelta
+from logging import StreamHandler
 from typing import TypedDict
 
 import numpy as np
 import zmq
 from dodal.devices.i04.constants import RedisConstants
-from dodal.devices.i04.murko_results import MurkoResult
+from dodal.devices.i04.murko_results import RESULTS_COMPLETE_MESSAGE, MurkoResult
 from numpy.typing import NDArray
 from PIL import Image
 from redis import StrictRedis
 
+from mx_bluesky.beamlines.i04.callbacks.murko_callback import (
+    FORWARDING_COMPLETE_MESSAGE,
+)
 from mx_bluesky.common.utils.log import LOGGER
 
 MURKO_ADDRESS = "tcp://i04-murko-prod.diamond.ac.uk:8008"
 
+
 FullMurkoResults = dict[str, list[MurkoResult]]
 
 
@@ -112,6 +118,12 @@ class BatchMurkoForwarder:
             self.redis_client.expire(redis_key, timedelta(days=7))
         self.redis_client.publish("murko-results", pickle.dumps(results))
 
+    def send_stop_message_to_redis(self):
+        LOGGER.info(f"Publishing results complete message: {RESULTS_COMPLETE_MESSAGE}")
+        self.redis_client.publish(
+            "murko-results", pickle.dumps(RESULTS_COMPLETE_MESSAGE)
+        )
+
     def add(self, sample_id: str, uuid: str, image: NDArray):
         """Add an image to the batch to send to murko."""
         image_size = get_image_size(image)
@@ -159,6 +171,13 @@ class RedisListener:
         if message and message["type"] == "message":
             data = json.loads(message["data"])
             LOGGER.info(f"Received from redis: {data}")
+            if data == FORWARDING_COMPLETE_MESSAGE:
+                LOGGER.info(
+                    f"Received forwarding complete message: {FORWARDING_COMPLETE_MESSAGE}"
+                )
+                self.forwarder.flush()
+                self.forwarder.send_stop_message_to_redis()
+                return
             uuid = data["uuid"]
             sample_id = data["sample_id"]
 
@@ -188,6 +207,10 @@ class RedisListener:
 
 
 def main():
+    stream_handler = StreamHandler()
+    stream_handler.setLevel(logging.INFO)
+    LOGGER.addHandler(stream_handler)
+
     client = RedisListener()
     client.listen_for_image_data_forever()
 

mx_bluesky/beamlines/i04/thawing_plan.py

@@ -1,18 +1,15 @@
-from collections.abc import Callable
-from functools import partial
-
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
-from bluesky.preprocessors import run_decorator, subs_decorator
+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.oav.oav_detector import OAV
 from dodal.devices.oav.oav_to_redis_forwarder import OAVToRedisForwarder, Source
 from dodal.devices.robot import BartRobot
 from dodal.devices.smargon import Smargon
 from dodal.devices.thawer import OnOff, Thawer
+from dodal.log import LOGGER
 
 from mx_bluesky.beamlines.i04.callbacks.murko_callback import MurkoCallback
 
@@ -29,53 +26,26 @@ def thaw(
 
     Args:
         time_to_thaw (float): Time to thaw for, in seconds.
-        rotation (float, optional): How much to rotate by whilst thawing, in degrees.
-                                    Defaults to 360.
-        ... devices: These are the specific ophyd-devices used for the plan, the
-                     defaults are always correct.
+        rotation (float): How much to rotate by whilst thawing, in degrees.
+        thawer (Thawer): The thawing device.
+        smargon (Smargon): The smargon used to rotate.
     """
-    yield from _thaw(time_to_thaw, rotation, thawer, smargon)
-
-
-def thaw_and_stream_to_redis(
-    time_to_thaw: float,
-    rotation: float = 360,
-    robot: BartRobot = inject("robot"),
-    thawer: Thawer = inject("thawer"),
-    smargon: Smargon = inject("smargon"),
-    oav: OAV = inject("oav_full_screen"),
-    oav_to_redis_forwarder: OAVToRedisForwarder = inject("oav_to_redis_forwarder"),
-) -> MsgGenerator:
-    """Turns on the thawer and rotates the sample by {rotation} degrees to thaw it, then
-    rotates {rotation} degrees back and turns the thawer off. The speed of the goniometer
-    is set such that the process takes whole process will take {time_to_thaw} time.
+    initial_velocity = yield from bps.rd(smargon.omega.velocity)
+    new_velocity = abs(rotation / time_to_thaw) * 2.0
 
-    At the same time streams OAV images to redis for later processing (e.g. by murko).
-    On the first rotation the images from the large ROI are streamed, on the second the
-    smaller ROI is used.
+    def do_thaw():
+        yield from bps.abs_set(smargon.omega.velocity, new_velocity, wait=True)
+        yield from bps.abs_set(thawer, OnOff.ON, wait=True)
+        yield from bps.rel_set(smargon.omega, rotation, wait=True)
+        yield from bps.rel_set(smargon.omega, -rotation, wait=True)
 
-    Args:
-        time_to_thaw (float): Time to thaw for, in seconds.
-        rotation (float, optional): How much to rotate by whilst thawing, in degrees.
-                                    Defaults to 360.
-        ... devices: These are the specific ophyd-devices used for the plan, the
-                     defaults are always correct
-    """
+    def cleanup():
+        yield from bps.abs_set(smargon.omega.velocity, initial_velocity, wait=True)
+        yield from bps.abs_set(thawer, OnOff.OFF, wait=True)
 
-    def switch_forwarder_to_roi() -> MsgGenerator:
-        yield from bps.complete(oav_to_redis_forwarder, wait=True)
-        yield from bps.mv(oav_to_redis_forwarder.selected_source, Source.ROI.value)
-        yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
-
-    yield from _thaw_and_stream_to_redis(
-        time_to_thaw,
-        rotation,
-        robot,
-        thawer,
-        smargon,
-        oav,
-        oav_to_redis_forwarder,
-        switch_forwarder_to_roi,
+    yield from bpp.contingency_wrapper(
+        do_thaw(),
+        final_plan=cleanup,
     )
 
 
@@ -85,14 +55,13 @@ def thaw_and_murko_centre(
     robot: BartRobot = inject("robot"),
     thawer: Thawer = inject("thawer"),
     smargon: Smargon = inject("smargon"),
-    oav: OAV = inject("oav_full_screen"),
     murko_results: MurkoResultsDevice = inject("murko_results"),
     oav_to_redis_forwarder: OAVToRedisForwarder = inject("oav_to_redis_forwarder"),
 ) -> MsgGenerator:
     """Thaws the sample and centres it using murko by:
         1. Turns on the thawer
         2. Rotates the sample by {rotation} degrees, whilst this is happening images from
-        the large ROI of the OAV are being fed to murko
+        the full screen OAV are being fed to murko
         3. After the rotation has completed moves to the average centre returned by murko
         from these images
         4. Rotate {rotation} degrees back to the start, whilst this is happening images
@@ -109,147 +78,173 @@ def thaw_and_murko_centre(
         ... devices: These are the specific ophyd-devices used for the plan, the
                      defaults are always correct
     """
-
     murko_results_group = "get_results"
 
-    def centre_then_switch_forwarder_to_roi() -> MsgGenerator:
-        yield from bps.complete(oav_to_redis_forwarder, wait=True)
+    sample_id = yield from bps.rd(robot.sample_id)
+    sample_id = int(sample_id)
 
-        yield from bps.mv(oav_to_redis_forwarder.selected_source, Source.ROI.value)
+    oav_fs = oav_to_redis_forwarder.sources[Source.FULL_SCREEN].oav_ref()
 
+    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,
+        RedisConstants.MURKO_REDIS_DB,
+    )
+
+    def cleanup():
+        yield from bps.mv(oav_fs.zoom_controller.level, initial_zoom_level)
+        yield from bps.abs_set(smargon.omega.velocity, initial_velocity, wait=True)
+        yield from bps.abs_set(thawer, OnOff.OFF, wait=True)
+
+    def centre_from_murko():
         yield from bps.wait(murko_results_group)
+
         x_predict = yield from bps.rd(murko_results.x_mm)
         y_predict = yield from bps.rd(murko_results.y_mm)
         z_predict = yield from bps.rd(murko_results.z_mm)
 
+        LOGGER.info(f"Got results: {x_predict, y_predict, z_predict}")
+
         yield from bps.rel_set(smargon.x, x_predict)
         yield from bps.rel_set(smargon.y, y_predict)
         yield from bps.rel_set(smargon.z, z_predict)
 
-        yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
+    @subs_decorator(murko_callback)
+    @contingency_decorator(final_plan=cleanup)
+    def do_thaw_and_murko_centre():
+        yield from bps.mv(
+            murko_results.sample_id,
+            str(sample_id),
+            oav_to_redis_forwarder.sample_id,
+            sample_id,
+            oav_fs.zoom_controller.level,
+            "1.0x",
+        )
+        yield from bps.abs_set(smargon.omega.velocity, new_velocity, wait=True)
+        yield from bps.abs_set(thawer, OnOff.ON, wait=True)
 
-    sample_id = yield from bps.rd(robot.sample_id)
-    yield from bps.mv(murko_results.sample_id, str(sample_id))
+        def rotate_in_one_direction_then_murko_centre(
+            rotation: float, oav_mode: Source
+        ):
+            @run_decorator(md={"sample_id": sample_id})
+            def rotate_in_one_direction_and_start_murko_and_stream_to_redis():
+                yield from bps.stage(murko_results, wait=True)
+                yield from bps.trigger(murko_results, group=murko_results_group)
 
-    yield from bps.stage(murko_results, wait=True)
-    yield from bps.trigger(murko_results, group=murko_results_group)
+                yield from _rotate_in_one_direction_and_stream_to_redis(
+                    smargon, oav_to_redis_forwarder, oav_mode, rotation
+                )
 
-    yield from bpp.contingency_wrapper(
-        _thaw_and_stream_to_redis(
-            time_to_thaw,
-            rotation,
-            robot,
-            thawer,
-            smargon,
-            oav,
-            oav_to_redis_forwarder,
-            centre_then_switch_forwarder_to_roi,
-        ),
-        final_plan=partial(bps.unstage, murko_results, wait=True),
-    )
+            yield from rotate_in_one_direction_and_start_murko_and_stream_to_redis()
+
+            yield from centre_from_murko()
+            yield from bps.unstage(murko_results, wait=True)
 
+        yield from rotate_in_one_direction_then_murko_centre(
+            rotation, Source.FULL_SCREEN
+        )
+        yield from rotate_in_one_direction_then_murko_centre(-rotation, Source.ROI)
+
+    yield from do_thaw_and_murko_centre()
 
-def _thaw(
+
+def thaw_and_stream_to_redis(
     time_to_thaw: float,
-    rotation: float,
-    thawer: Thawer,
-    smargon: Smargon,
-    plan_between_rotations: Callable[[], MsgGenerator] | None = None,
+    rotation: float = 360,
+    robot: BartRobot = inject("robot"),
+    thawer: Thawer = inject("thawer"),
+    smargon: Smargon = inject("smargon"),
+    oav_to_redis_forwarder: OAVToRedisForwarder = inject("oav_to_redis_forwarder"),
 ) -> MsgGenerator:
     """Turns on the thawer and rotates the sample by {rotation} degrees to thaw it, then
     rotates {rotation} degrees back and turns the thawer off. The speed of the goniometer
     is set such that the process takes whole process will take {time_to_thaw} time.
 
+    At the same time streams OAV images to redis for later processing (e.g. by murko).
+    On the first rotation the images from the large ROI are streamed, on the second the
+    smaller ROI is used.
+
     Args:
         time_to_thaw (float): Time to thaw for, in seconds.
-        rotation (float): How much to rotate by whilst thawing, in degrees.
-        thawer (Thawer): The thawing device.
-        smargon (Smargon): The smargon used to rotate.
-        plan_between_rotations (MsgGenerator, optional): A plan to run between rotations
-                                    of the smargon. Defaults to no plan.
+        rotation (float, optional): How much to rotate by whilst thawing, in degrees.
+                                    Defaults to 360.
+        ... devices: These are the specific ophyd-devices used for the plan, the
+                     defaults are always correct
     """
+    sample_id = yield from bps.rd(robot.sample_id)
+    sample_id = int(sample_id)
+
+    oav_fs = oav_to_redis_forwarder.sources[Source.FULL_SCREEN].oav_ref()
+
+    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
 
-    def do_thaw():
-        yield from bps.abs_set(smargon.omega.velocity, new_velocity, wait=True)
-        yield from bps.abs_set(thawer.control, OnOff.ON, wait=True)
-        yield from bps.rel_set(smargon.omega, rotation, wait=True)
-        if plan_between_rotations:
-            yield from plan_between_rotations()
-        yield from bps.rel_set(smargon.omega, -rotation, wait=True)
+    murko_callback = MurkoCallback(
+        RedisConstants.REDIS_HOST,
+        RedisConstants.REDIS_PASSWORD,
+        RedisConstants.MURKO_REDIS_DB,
+    )
 
     def cleanup():
+        yield from bps.mv(oav_fs.zoom_controller.level, initial_zoom_level)
         yield from bps.abs_set(smargon.omega.velocity, initial_velocity, wait=True)
-        yield from bps.abs_set(thawer.control, OnOff.OFF, wait=True)
+        yield from bps.abs_set(thawer, OnOff.OFF, wait=True)
 
-    # Always cleanup even if there is a failure
-    yield from bpp.contingency_wrapper(
-        do_thaw(),
-        final_plan=cleanup,
-    )
-
-
-def _thaw_and_stream_to_redis(
-    time_to_thaw: float,
-    rotation: float,
-    robot: BartRobot,
-    thawer: Thawer,
-    smargon: Smargon,
-    oav: OAV,
-    oav_to_redis_forwarder: OAVToRedisForwarder,
-    plan_between_rotations: Callable[[], MsgGenerator],
-) -> MsgGenerator:
-    zoom_percentage = yield from bps.rd(oav.zoom_controller.percentage)
-    sample_id = yield from bps.rd(robot.sample_id)
-
-    sample_id = int(sample_id)
-    zoom_level_before_thawing = yield from bps.rd(oav.zoom_controller.level)
-
-    yield from bps.mv(oav.zoom_controller.level, "1.0x")
-
-    microns_per_pixel_x = yield from bps.rd(oav.microns_per_pixel_x)
-    microns_per_pixel_y = yield from bps.rd(oav.microns_per_pixel_y)
-    beam_centre_i = yield from bps.rd(oav.beam_centre_i)
-    beam_centre_j = yield from bps.rd(oav.beam_centre_j)
-
-    @subs_decorator(
-        MurkoCallback(
-            RedisConstants.REDIS_HOST,
-            RedisConstants.REDIS_PASSWORD,
-            RedisConstants.MURKO_REDIS_DB,
-        )
-    )
-    @run_decorator(
-        md={
-            "microns_per_x_pixel": microns_per_pixel_x,
-            "microns_per_y_pixel": microns_per_pixel_y,
-            "beam_centre_i": beam_centre_i,
-            "beam_centre_j": beam_centre_j,
-            "zoom_percentage": zoom_percentage,
-            "sample_id": sample_id,
-        }
-    )
-    def _main_plan():
+    @subs_decorator(murko_callback)
+    @contingency_decorator(final_plan=cleanup)
+    def do_thaw_and_stream_to_redis():
         yield from bps.mv(
             oav_to_redis_forwarder.sample_id,
             sample_id,
-            oav_to_redis_forwarder.selected_source,
-            Source.FULL_SCREEN.value,
+            oav_fs.zoom_controller.level,
+            "1.0x",
         )
-
-        yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
-        yield from bps.monitor(smargon.omega.user_readback, name="smargon")
-        yield from bps.monitor(oav_to_redis_forwarder.uuid, name="oav")
-        yield from _thaw(
-            time_to_thaw, rotation, thawer, smargon, plan_between_rotations
+        yield from bps.abs_set(smargon.omega.velocity, new_velocity, wait=True)
+        yield from bps.abs_set(thawer, OnOff.ON, wait=True)
+
+        @run_decorator(md={"sample_id": sample_id})
+        def rotate_in_one_direction_and_stream_to_redis(
+            rotation: float, oav_mode: Source
+        ):
+            yield from _rotate_in_one_direction_and_stream_to_redis(
+                smargon, oav_to_redis_forwarder, oav_mode, rotation
+            )
+
+        yield from rotate_in_one_direction_and_stream_to_redis(
+            rotation, Source.FULL_SCREEN
         )
-        yield from bps.complete(oav_to_redis_forwarder)
+        yield from rotate_in_one_direction_and_stream_to_redis(-rotation, Source.ROI)
 
-    def cleanup():
-        yield from bps.mv(oav.zoom_controller.level, zoom_level_before_thawing)
+    yield from do_thaw_and_stream_to_redis()
 
-    yield from bpp.contingency_wrapper(
-        _main_plan(),
-        final_plan=cleanup,
+
+def _rotate_in_one_direction_and_stream_to_redis(
+    smargon: Smargon,
+    oav_to_redis_forwarder: OAVToRedisForwarder,
+    oav_mode: Source,
+    rotation: float,
+):
+    def get_metadata_from_current_oav():
+        current_source_idx = yield from bps.rd(oav_to_redis_forwarder.selected_source)
+        oav = oav_to_redis_forwarder.sources[current_source_idx].oav_ref()
+        yield from bps.create()
+        oav_info = yield from bps.read(oav)
+        LOGGER.info(f"Got oav information: {oav_info}")
+        yield from bps.save()
+
+    yield from bps.mv(
+        oav_to_redis_forwarder.selected_source,
+        oav_mode.value,
     )
+
+    yield from get_metadata_from_current_oav()
+    yield from bps.monitor(smargon.omega.user_readback, name="smargon")
+    yield from bps.monitor(oav_to_redis_forwarder.uuid, name="oav")
+
+    yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
+    yield from bps.rel_set(smargon.omega, rotation, wait=True)
+    yield from bps.complete(oav_to_redis_forwarder, wait=True)

mx_bluesky/beamlines/i24/serial/dcid.py

@@ -112,6 +112,8 @@ class DCID:
         match expt_params.detector_name:
             case "eiger":
                 self.detector = Eiger()
+            case _:
+                raise ValueError("Unknown detector:", expt_params.detector_name)
 
         self.server = server or DEFAULT_ISPYB_SERVER
         self.emit_errors = emit_errors
@@ -144,7 +146,7 @@ class DCID:
         try:
             if not start_time:
                 start_time = datetime.datetime.now().astimezone()
-            elif not start_time.timetz:
+            else:
                 start_time = start_time.astimezone()
 
             resolution = get_resolution(
@@ -156,10 +158,7 @@ class DCID:
             transmission = self.parameters.transmission * 100
             xbeam, ybeam = beam_settings.beam_center_in_mm
 
-            if isinstance(self.detector, Eiger):
-                start_image_number = 1
-            else:
-                raise ValueError("Unknown detector:", self.detector)
+            start_image_number = 1
 
             events = [
                 {

mx_bluesky/beamlines/i24/serial/extruder/i24ssx_extruder_collect_py3v2.py

@@ -253,6 +253,7 @@ def main_extruder_plan(
                     parameters.exposure_time_s,
                 ],
                 dcm,
+                detector_stage,
             )
             yield from setup_zebra_for_extruder_with_pump_probe_plan(
                 zebra,
@@ -275,6 +276,7 @@ def main_extruder_plan(
                     parameters.exposure_time_s,
                 ],
                 dcm,
+                detector_stage,
             )
             yield from setup_zebra_for_quickshot_plan(
                 zebra, parameters.exposure_time_s, parameters.num_images, wait=True
@@ -374,6 +376,7 @@ def tidy_up_at_collection_end_plan(
     parameters: ExtruderParameters,
     dcid: DCID,
     dcm: DCM,
+    detector_stage: YZStage,
 ) -> MsgGenerator:
     """A plan to tidy up at the end of a collection, successful or aborted.
 
@@ -386,7 +389,7 @@ def tidy_up_at_collection_end_plan(
 
     # Clean Up
     if parameters.detector_name == "eiger":
-        yield from sup.eiger("return-to-normal", None, dcm)
+        yield from sup.eiger("return-to-normal", None, dcm, detector_stage)
         SSX_LOGGER.debug(f"{parameters.filename}_{caget(pv.eiger_seq_id)}")
     SSX_LOGGER.debug("End of Run")
     SSX_LOGGER.info("Close hutch shutter")
@@ -452,7 +455,7 @@ def run_plan_in_wrapper(
         ),
         final_plan=lambda: (
             yield from tidy_up_at_collection_end_plan(
-                zebra, shutter, parameters, dcid, dcm
+                zebra, shutter, parameters, dcid, dcm, detector_stage
             )
         ),
         auto_raise=False,