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

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"
 
-    MURKO_RESULTS_GROUP = "get_results"
+    sample_id = yield from bps.rd(robot.sample_id)
+    sample_id = int(sample_id)
 
-    def centre_then_switch_forwarder_to_ROI() -> MsgGenerator:
-        yield from bps.complete(oav_to_redis_forwarder, wait=True)
+    oav_fs = oav_to_redis_forwarder.sources[Source.FULL_SCREEN].oav_ref()
 
-        yield from bps.mv(oav_to_redis_forwarder.selected_source, Source.ROI.value)
+    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)
 
-        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)
+
+        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)
 
-    sample_id = yield from bps.rd(robot.sample_id)
-    yield from bps.mv(murko_results.sample_id, str(sample_id))
+                yield from _rotate_in_one_direction_and_stream_to_redis(
+                    smargon, oav_to_redis_forwarder, oav_mode, rotation
+                )
 
-    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_start_murko_and_stream_to_redis()
 
-    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 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
     """
-    inital_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)
-
-    def cleanup():
-        yield from bps.abs_set(smargon.omega.velocity, inital_velocity, wait=True)
-        yield from bps.abs_set(thawer.control, 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")
+    oav_fs = oav_to_redis_forwarder.sources[Source.FULL_SCREEN].oav_ref()
 
-    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)
+    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
 
-    @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,
-        }
+    murko_callback = MurkoCallback(
+        RedisConstants.REDIS_HOST,
+        RedisConstants.REDIS_PASSWORD,
+        RedisConstants.MURKO_REDIS_DB,
     )
-    def _main_plan():
+
+    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)
+
+    @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/jungfrau_commissioning/experiment_plans/do_darks.py

@@ -3,10 +3,10 @@ from bluesky import plan_stubs as bps
 from bluesky.utils import MsgGenerator
 from dodal.common import inject
 from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
-from ophyd_async.core import WatchableAsyncStatus
 from ophyd_async.fastcs.jungfrau import (
     AcquisitionType,
     GainMode,
+    create_jungfrau_internal_triggering_info,
     create_jungfrau_pedestal_triggering_info,
 )
 from pydantic import PositiveInt
@@ -18,6 +18,7 @@ from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_stubs.plan_utils impor
 from mx_bluesky.common.utils.log import LOGGER
 
 PEDESTAL_DARKS_RUN = "PEDESTAL DARKS RUN"
+STANDARD_DARKS_RUN = "STANDARD DARKS RUN"
 
 
 def do_pedestal_darks(
@@ -26,7 +27,7 @@ def do_pedestal_darks(
     pedestal_loops: PositiveInt = 200,
     jungfrau: CommissioningJungfrau = inject("jungfrau"),
     path_of_output_file: str | None = None,
-) -> MsgGenerator[WatchableAsyncStatus]:
+) -> 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.
 
@@ -38,6 +39,9 @@ def do_pedestal_darks(
     4. Do the first three steps a second time, except use ForceSwitchG2 instead of ForceSwitchG1
     during step 2.
 
+    A pedestal scan should be acquired when detector configuration and environmental conditions change, but due to small
+    in instabilities in beamline conditions, it is recommended to run a pedestal scan on roughly an hourly basis.
+
     Args:
         exp_time_s: Length of detector exposure for each frame.
         pedestal_frames: Number of frames acquired per pedestal loop.
@@ -66,13 +70,54 @@ def do_pedestal_darks(
             jungfrau.drv.gain_mode,
             GainMode.DYNAMIC,
         )
-        return (
-            yield from fly_jungfrau(
-                jungfrau,
-                trigger_info,
-                wait=True,
-                log_on_percentage_prefix="Jungfrau pedestal dynamic gain mode darks triggers recieved",
-            )
+        yield from fly_jungfrau(
+            jungfrau,
+            trigger_info,
+            wait=True,
+            log_on_percentage_prefix="Jungfrau pedestal dynamic gain mode darks triggers received",
+        )
+
+    yield from _do_decorated_plan()
+
+
+def do_non_pedestal_darks(
+    gain_mode: GainMode,
+    exp_time_s: float = 0.001,
+    total_triggers: PositiveInt = 1000,
+    jungfrau: CommissioningJungfrau = inject("jungfrau"),
+    path_of_output_file: str | None = None,
+) -> MsgGenerator:
+    """Internally take a set of images at a given gain mode.
+
+    Non-pedestal darks are useful for detector panel cross-checks and for calculating masks.
+
+    Args:
+        gain_mode: Which gain mode to put the Jungfrau into before starting the acquisition.
+        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
+    """
+
+    @bpp.set_run_key_decorator(STANDARD_DARKS_RUN)
+    @bpp.run_decorator(md={"subplan_name": STANDARD_DARKS_RUN})
+    @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,
+            wait=True,
+            log_on_percentage_prefix=f"Jungfrau {gain_mode} gain mode darks triggers received",
         )
 
-    return (yield from _do_decorated_plan())
+    yield from _do_decorated_plan()

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

@@ -30,7 +30,7 @@ def do_external_acquisition(
 
     Args:
         exp_time_s: Length of detector exposure for each frame.
-        total_triggers: Number of external triggers recieved before acquisition is marked as complete.
+        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

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

@@ -21,7 +21,7 @@ def fly_jungfrau(
     jungfrau: CommissioningJungfrau,
     trigger_info: TriggerInfo,
     wait: bool = False,
-    log_on_percentage_prefix="Jungfrau data collection triggers recieved",
+    log_on_percentage_prefix="Jungfrau data collection triggers received",
 ) -> MsgGenerator[WatchableAsyncStatus]:
     """Stage, prepare, and kickoff Jungfrau with a configured TriggerInfo. Optionally wait
     for completion.

mx_bluesky/beamlines/i24/serial/__init__.py

@@ -3,19 +3,20 @@ from mx_bluesky.beamlines.i24.serial.web_gui_plans.general_plans import (
     gui_move_backlight,
     gui_move_detector,
     gui_run_chip_collection,
+    gui_run_extruder_collection,
+    gui_set_fiducial_0,
     gui_set_zoom_level,
-    gui_sleep,
     gui_stage_move_on_click,
 )
 
-from .extruder.i24ssx_Extruder_Collect_py3v2 import (
+from .extruder.i24ssx_extruder_collect_py3v2 import (
     enter_hutch,
     initialise_extruder,
     laser_check,
     run_extruder_plan,
 )
-from .fixed_target.i24ssx_Chip_Collect_py3v1 import run_fixed_target_plan
-from .fixed_target.i24ssx_Chip_Manager_py3v1 import (
+from .fixed_target.i24ssx_chip_collect_py3v1 import run_fixed_target_plan
+from .fixed_target.i24ssx_chip_manager_py3v1 import (
     block_check,
     cs_maker,
     cs_reset,
@@ -56,9 +57,10 @@ __all__ = [
     # GUI plans
     "gui_stage_move_on_click",
     "gui_gonio_move_on_click",
-    "gui_sleep",
     "gui_move_detector",
     "gui_run_chip_collection",
     "gui_move_backlight",
     "gui_set_zoom_level",
+    "gui_set_fiducial_0",
+    "gui_run_extruder_collection",
 ]

mx_bluesky/beamlines/i24/serial/dcid.py

@@ -95,7 +95,7 @@ class DCID:
 
     Attributes:
         error:
-            If an error has occured. This will be set, even if emit_errors = True
+            If an error has occurred. This will be set, even if emit_errors = True
     """
 
     def __init__(
@@ -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):
-                startImageNumber = 1
-            else:
-                raise ValueError("Unknown detector:", self.detector)
+            start_image_number = 1
 
             events = [
                 {
@@ -201,7 +200,7 @@ class DCID:
                 "imageDirectory": image_dir,
                 "numberOfImages": num_images,
                 "resolution": resolution,
-                "startImageNumber": startImageNumber,
+                "startImageNumber": start_image_number,
                 "startTime": start_time.isoformat(),
                 "transmission": transmission,
                 "visit": self.parameters.visit.name,