mx-bluesky 1.5.5__py3-none-any.whl → 1.5.7__py3-none-any.whl

mx_bluesky/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.5'
-__version_tuple__ = version_tuple = (1, 5, 5)
+__version__ = version = '1.5.7'
+__version_tuple__ = version_tuple = (1, 5, 7)
 
 __commit_id__ = commit_id = None

mx_bluesky/beamlines/i02_1/parameters/gridscan.py

@@ -0,0 +1,35 @@
+from dodal.devices.i02_1.fast_grid_scan import ZebraGridScanParamsTwoD
+from scanspec.specs import Product
+
+from mx_bluesky.common.parameters.components import SplitScan, WithOptionalEnergyChange
+from mx_bluesky.common.parameters.gridscan import SpecifiedGrid
+
+
+class SpecifiedTwoDGridScan(
+    SpecifiedGrid[ZebraGridScanParamsTwoD],
+    SplitScan,
+    WithOptionalEnergyChange,
+):
+    """Parameters representing a so-called 2D grid scan, which consists of doing a
+    gridscan in X and Y."""
+
+    @property
+    def scan_spec(self) -> Product[str]:
+        """A fully specified ScanSpec object representing the grid, with x, y, z and
+        omega positions."""
+        return self.grid_1_spec
+
+    @property
+    def FGS_params(self) -> ZebraGridScanParamsTwoD:
+        return ZebraGridScanParamsTwoD(
+            x_steps=self.x_steps,
+            y_steps=self.y_steps,
+            x_step_size_mm=self.x_step_size_um / 1000,
+            y_step_size_mm=self.y_step_size_um / 1000,
+            x_start_mm=self.x_start_um / 1000,
+            y1_start_mm=self.y_start_um / 1000,
+            z1_start_mm=self.z_start_um / 1000,
+            set_stub_offsets=self._set_stub_offsets,
+            transmission_fraction=0.5,
+            dwell_time_ms=self.exposure_time_s,
+        )

mx_bluesky/beamlines/i04/experiment_plans/i04_grid_detect_then_xray_centre_plan.py

@@ -13,7 +13,7 @@ from dodal.devices.common_dcm import BaseDCM
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.fast_grid_scan import (
-    ZebraFastGridScan,
+    ZebraFastGridScanThreeD,
     set_fast_grid_scan_params,
 )
 from dodal.devices.flux import Flux
@@ -48,6 +48,7 @@ from mx_bluesky.common.external_interaction.callbacks.common.zocalo_callback imp
 )
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback import (
     GridscanISPyBCallback,
+    generate_start_info_from_omega_map,
 )
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.nexus_callback import (
     GridscanNexusFileCallback,
@@ -80,7 +81,7 @@ def i04_grid_detect_then_xray_centre(
     backlight: Backlight = inject("backlight"),
     beamstop: Beamstop = inject("beamstop"),
     dcm: BaseDCM = inject("dcm"),
-    zebra_fast_grid_scan: ZebraFastGridScan = inject("zebra_fast_grid_scan"),
+    zebra_fast_grid_scan: ZebraFastGridScanThreeD = inject("zebra_fast_grid_scan"),
     flux: Flux = inject("flux"),
     oav: OAV = inject("oav"),
     pin_tip_detection: PinTipDetection = inject("pin_tip_detection"),
@@ -198,7 +199,9 @@ def create_gridscan_callbacks() -> tuple[
         GridscanISPyBCallback(
             param_type=GridCommon,
             emit=ZocaloCallback(
-                PlanNameConstants.DO_FGS, EnvironmentConstants.ZOCALO_ENV
+                PlanNameConstants.DO_FGS,
+                EnvironmentConstants.ZOCALO_ENV,
+                generate_start_info_from_omega_map,
             ),
         ),
     )

mx_bluesky/beamlines/i04/redis_to_murko_forwarder.py

@@ -7,7 +7,7 @@ from typing import TypedDict
 import numpy as np
 import zmq
 from dodal.devices.i04.constants import RedisConstants
-from dodal.devices.i04.murko_results import FullMurkoResults, MurkoResult
+from dodal.devices.i04.murko_results import MurkoResult
 from numpy.typing import NDArray
 from PIL import Image
 from redis import StrictRedis
@@ -16,6 +16,8 @@ from mx_bluesky.common.utils.log import LOGGER
 
 MURKO_ADDRESS = "tcp://i04-murko-prod.diamond.ac.uk:8008"
 
+FullMurkoResults = dict[str, list[MurkoResult]]
+
 
 class MurkoRequest(TypedDict):
     """See https://github.com/MartinSavko/murko#usage for more information."""

mx_bluesky/beamlines/i04/thawing_plan.py

@@ -1,8 +1,9 @@
 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, stage_wrapper, subs_decorator
+from bluesky.preprocessors import run_decorator, subs_decorator
 from bluesky.utils import MsgGenerator
 from dodal.common import inject
 from dodal.devices.i04.constants import RedisConstants
@@ -42,7 +43,7 @@ def thaw_and_stream_to_redis(
     robot: BartRobot = inject("robot"),
     thawer: Thawer = inject("thawer"),
     smargon: Smargon = inject("smargon"),
-    oav: OAV = inject("oav"),
+    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
@@ -84,7 +85,7 @@ def thaw_and_murko_centre(
     robot: BartRobot = inject("robot"),
     thawer: Thawer = inject("thawer"),
     smargon: Smargon = inject("smargon"),
-    oav: OAV = inject("oav"),
+    oav: OAV = inject("oav_full_screen"),
     murko_results: MurkoResultsDevice = inject("murko_results"),
     oav_to_redis_forwarder: OAVToRedisForwarder = inject("oav_to_redis_forwarder"),
 ) -> MsgGenerator:
@@ -109,14 +110,14 @@ def thaw_and_murko_centre(
                      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)
 
-        yield from bps.trigger(murko_results, group="get_results")
-
         yield from bps.mv(oav_to_redis_forwarder.selected_source, Source.ROI.value)
 
-        yield from bps.wait("get_results")
+        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)
@@ -127,7 +128,13 @@ def thaw_and_murko_centre(
 
         yield from bps.kickoff(oav_to_redis_forwarder, wait=True)
 
-    yield from stage_wrapper(
+    sample_id = yield from bps.rd(robot.sample_id)
+    yield from bps.abs_set(murko_results.sample_id, int(sample_id))
+
+    yield from bps.stage(murko_results)
+    yield from bps.trigger(murko_results, group=MURKO_RESULTS_GROUP)
+
+    yield from bpp.contingency_wrapper(
         _thaw_and_stream_to_redis(
             time_to_thaw,
             rotation,
@@ -138,7 +145,7 @@ def thaw_and_murko_centre(
             oav_to_redis_forwarder,
             centre_then_switch_forwarder_to_ROI,
         ),
-        [murko_results],
+        final_plan=partial(bps.unstage, murko_results),
     )
 
 

mx_bluesky/beamlines/i24/jungfrau_commissioning/do_external_acquisition.py

@@ -0,0 +1,44 @@
+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 (
+    create_jungfrau_external_triggering_info,
+)
+from pydantic import PositiveInt
+
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_utils import (
+    fly_jungfrau,
+    override_file_path,
+)
+
+
+def do_external_acquisition(
+    exp_time_s: float,
+    total_triggers: PositiveInt = 1,
+    output_file_name: str | None = None,
+    wait: bool = False,
+    jungfrau: CommissioningJungfrau = inject("commissioning_jungfrau"),
+) -> MsgGenerator[WatchableAsyncStatus]:
+    """
+    Kickoff external triggering on the Jungfrau, and optionally wait for completion.
+
+    Must be used within an open Bluesky run.
+
+    Args:
+        exp_time_s: Length of detector exposure for each frame.
+        total_triggers: Number of external triggers recieved 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_name:
+        override_file_path(jungfrau, output_file_name)
+
+    trigger_info = create_jungfrau_external_triggering_info(total_triggers, exp_time_s)
+    status = yield from fly_jungfrau(jungfrau, trigger_info, wait)
+    return status

mx_bluesky/beamlines/i24/jungfrau_commissioning/do_internal_acquisition.py

@@ -0,0 +1,46 @@
+from bluesky.utils import MsgGenerator
+from dodal.beamlines.i24 import CommissioningJungfrau
+from dodal.common import inject
+from ophyd_async.core import (
+    WatchableAsyncStatus,
+)
+from ophyd_async.fastcs.jungfrau import (
+    create_jungfrau_internal_triggering_info,
+)
+from pydantic import PositiveInt
+
+from mx_bluesky.beamlines.i24.jungfrau_commissioning.plan_utils import (
+    fly_jungfrau,
+    override_file_path,
+)
+
+
+def do_internal_acquisition(
+    exp_time_s: float,
+    total_frames: PositiveInt = 1,
+    jungfrau: CommissioningJungfrau = inject("jungfrau"),
+    path_of_output_file: str | None = None,
+    wait: bool = False,
+) -> MsgGenerator[WatchableAsyncStatus]:
+    """
+    Kickoff internal triggering on the Jungfrau, and optionally wait for completion. Frames
+    per trigger will trigger as rapidly as possible according to the Jungfrau deadtime.
+
+    Must be used within an open Bluesky run.
+
+    Args:
+        exp_time_s: Length of detector exposure for each frame.
+        total_frames: Number of frames taken after being internally triggered.
+        period_between_frames_s: Time between each detector frame, including deadtime. Not needed if frames_per_triggers is 1.
+        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
+        wait: Optionally block until data collection is complete.
+    """
+
+    if path_of_output_file:
+        override_file_path(jungfrau, path_of_output_file)
+
+    trigger_info = create_jungfrau_internal_triggering_info(total_frames, exp_time_s)
+    status = yield from fly_jungfrau(jungfrau, trigger_info, wait)
+    return status

mx_bluesky/beamlines/i24/jungfrau_commissioning/plan_utils.py

@@ -0,0 +1,73 @@
+from pathlib import PurePath
+from typing import cast
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+from bluesky.utils import MsgGenerator
+from dodal.common.watcher_utils import log_on_percentage_complete
+from dodal.devices.i24.commissioning_jungfrau import CommissioningJungfrau
+from ophyd_async.core import (
+    AutoIncrementingPathProvider,
+    StaticFilenameProvider,
+    TriggerInfo,
+    WatchableAsyncStatus,
+)
+
+from mx_bluesky.common.utils.log import LOGGER
+
+JF_COMPLETE_GROUP = "JF complete"
+
+
+def fly_jungfrau(
+    jungfrau: CommissioningJungfrau, trigger_info: TriggerInfo, wait: bool = False
+) -> MsgGenerator[WatchableAsyncStatus]:
+    """Stage, prepare, and kickoff Jungfrau with a configured TriggerInfo. Optionally wait
+    for completion.
+
+    Note that this plan doesn't include unstaging of the Jungfrau, and a run must be open
+    before this plan is called.
+
+    Args:
+    jungfrau: Jungfrau device.
+    trigger_info: TriggerInfo which should be acquired using jungfrau util functions create_jungfrau_internal_triggering_info
+        or create_jungfrau_external_triggering_info.
+    wait: Optionally block until data collection is complete.
+    """
+
+    @bpp.contingency_decorator(
+        except_plan=lambda _: (yield from bps.unstage(jungfrau, wait=True))
+    )
+    def _fly_with_unstage_contingency():
+        yield from bps.stage(jungfrau)
+        LOGGER.info("Setting up detector...")
+        yield from bps.prepare(jungfrau, trigger_info, wait=True)
+        LOGGER.info("Detector prepared. Starting acquisition")
+        yield from bps.kickoff(jungfrau, wait=True)
+        LOGGER.info("Waiting for acquisition to complete...")
+        status = yield from bps.complete(jungfrau, group=JF_COMPLETE_GROUP)
+
+        # StandardDetector.complete converts regular status to watchable status,
+        # but bluesky plan stubs can't see this currently
+        status = cast(WatchableAsyncStatus, status)
+        log_on_percentage_complete(
+            status, "Jungfrau data collection triggers recieved", 10
+        )
+        if wait:
+            yield from bps.wait(JF_COMPLETE_GROUP)
+        return status
+
+    return (yield from _fly_with_unstage_contingency())
+
+
+def override_file_path(jungfrau: CommissioningJungfrau, path_of_output_file: str):
+    """While we should generally use device instantiation to set the path,
+    during commissioning, it is useful to be able to explicitly set the filename
+    and path.
+
+    This function must be called before the Jungfrau is prepared.
+    """
+    _file_path = PurePath(path_of_output_file)
+    _new_filename_provider = StaticFilenameProvider(_file_path.name)
+    jungfrau._writer._path_info = AutoIncrementingPathProvider(  # noqa: SLF001
+        _new_filename_provider, _file_path.parent
+    )

mx_bluesky/common/device_setup_plans/robot_load_unload.py

@@ -12,6 +12,8 @@ from dodal.plan_stubs.motor_utils import MoveTooLarge, home_and_reset_wrapper
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 
+SLEEP_PER_CHECK = 0.1
+
 
 def wait_for_smargon_not_disabled(smargon: Smargon, timeout=60):
     """Waits for the smargon disabled flag to go low. The robot hardware is responsible
@@ -19,7 +21,6 @@ def wait_for_smargon_not_disabled(smargon: Smargon, timeout=60):
     connection between the robot and the smargon.
     """
     LOGGER.info("Waiting for smargon enabled")
-    SLEEP_PER_CHECK = 0.1
     times_to_check = int(timeout / SLEEP_PER_CHECK)
     for _ in range(times_to_check):
         smargon_disabled = yield from bps.rd(smargon.disabled)

mx_bluesky/common/experiment_plans/common_flyscan_xray_centre_plan.py

@@ -9,8 +9,10 @@ import bluesky.preprocessors as bpp
 import numpy as np
 from bluesky.protocols import Readable
 from bluesky.utils import MsgGenerator
+from dodal.common.beamlines.commissioning_mode import read_commissioning_mode
 from dodal.devices.fast_grid_scan import (
     FastGridScanCommon,
+    FastGridScanThreeD,
 )
 from dodal.devices.zocalo import ZocaloResults
 from dodal.devices.zocalo.zocalo_results import (
@@ -226,11 +228,33 @@ def _fetch_xrc_results_from_zocalo(
             for xr in filtered_results
         ]
     else:
-        LOGGER.warning("No X-ray centre received")
-        raise CrystalNotFoundException()
+        commissioning_mode = yield from read_commissioning_mode()
+        if commissioning_mode:
+            LOGGER.info("Commissioning mode enabled, returning dummy result")
+            flyscan_results = [_generate_dummy_xrc_result(parameters)]
+        else:
+            LOGGER.warning("No X-ray centre received")
+            raise CrystalNotFoundException()
     yield from _fire_xray_centre_result_event(flyscan_results)
 
 
+def _generate_dummy_xrc_result(params: SpecifiedThreeDGridScan) -> XRayCentreResult:
+    com = [params.x_steps / 2, params.y_steps / 2, params.z_steps / 2]
+    max_voxel = [round(p) for p in com]
+    return _xrc_result_in_boxes_to_result_in_mm(
+        XrcResult(
+            centre_of_mass=com,
+            max_voxel=max_voxel,
+            bounding_box=[max_voxel, [p + 1 for p in max_voxel]],
+            n_voxels=1,
+            max_count=10000,
+            total_count=100000,
+            sample_id=params.sample_id,
+        ),
+        params,
+    )
+
+
 @bpp.set_run_key_decorator(PlanNameConstants.GRIDSCAN_MAIN)
 @bpp.run_decorator(md={"subplan_name": PlanNameConstants.GRIDSCAN_MAIN})
 def run_gridscan(
@@ -260,13 +284,13 @@ def run_gridscan(
         fgs_composite.eiger,
         fgs_composite.synchrotron,
         [parameters.scan_points_first_grid, parameters.scan_points_second_grid],
-        parameters.scan_indices,
         plan_during_collection=beamline_specific.read_during_collection_plan,
     )
 
-    # GDA's gridscans requires Z steps to be at 0, so make sure we leave this device
+    # GDA's 3D gridscans requires Z steps to be at 0, so make sure we leave this device
     # in a GDA-happy state.
-    yield from bps.abs_set(beamline_specific.fgs_motors.z_steps, 0, wait=False)
+    if isinstance(beamline_specific.fgs_motors, FastGridScanThreeD):
+        yield from bps.abs_set(beamline_specific.fgs_motors.z_steps, 0, wait=False)
 
 
 def wait_for_gridscan_valid(fgs_motors: FastGridScanCommon, timeout=0.5):

mx_bluesky/common/experiment_plans/inner_plans/do_fgs.py

@@ -17,6 +17,9 @@ from scanspec.core import AxesPoints, Axis
 from mx_bluesky.common.experiment_plans.inner_plans.read_hardware import (
     read_hardware_for_zocalo,
 )
+from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback import (
+    GridscanPlane,
+)
 from mx_bluesky.common.parameters.constants import (
     PlanNameConstants,
 )
@@ -66,7 +69,6 @@ def kickoff_and_complete_gridscan(
     detector: EigerDetector,  # Once Eiger inherits from StandardDetector, use that type instead
     synchrotron: Synchrotron,
     scan_points: list[AxesPoints[Axis]],
-    scan_start_indices: list[int],
     plan_during_collection: Callable[[], MsgGenerator] | None = None,
 ):
     """Triggers a grid scan motion program and waits for completion, accounting for synchrotron topup.
@@ -80,15 +82,10 @@ def kickoff_and_complete_gridscan(
         synchrotron (Synchrotron):              Synchrotron device
         scan_points (list[AxesPoints[Axis]]):   Each element in the list contains all the grid points for that grid scan.
                                                 Two elements in this list indicates that two grid scans will be done, eg for Hyperion's 3D grid scans.
-        scan_start_indices (list[int]):         Contains the first index of each grid scan
         plan_during_collection (Optional, MsgGenerator): Generic plan called in between kickoff and completion,
                                                 eg waiting on zocalo.
     """
 
-    assert len(scan_points) == len(scan_start_indices), (
-        "scan_points and scan_start_indices must be lists of the same length!"
-    )
-
     plan_name = PlanNameConstants.DO_FGS
 
     @TRACER.start_as_current_span(plan_name)
@@ -96,8 +93,10 @@ def kickoff_and_complete_gridscan(
     @bpp.run_decorator(
         md={
             "subplan_name": plan_name,
-            "scan_points": scan_points,
-            "scan_start_indices": scan_start_indices,
+            "omega_to_scan_spec": {
+                GridscanPlane.OMEGA_XY: scan_points[0],
+                GridscanPlane.OMEGA_XZ: scan_points[1],
+            },
         }
     )
     @bpp.contingency_decorator(

mx_bluesky/common/external_interaction/callbacks/common/ispyb_callback_base.py

@@ -86,11 +86,11 @@ class BaseISPyBCallback(PlanReactiveCallback):
 
     def activity_gated_start(self, doc: RunStart):
         self._oav_snapshot_event_idx = 0
-        return self._tag_doc(doc)
+        return self.tag_doc(doc)
 
     def activity_gated_descriptor(self, doc: EventDescriptor):
         self.descriptors[doc["uid"]] = doc
-        return self._tag_doc(doc)
+        return self.tag_doc(doc)
 
     def activity_gated_event(self, doc: Event) -> Event:
         """Subclasses should extend this to add a call to set_dcig_tag from
@@ -112,10 +112,10 @@ class BaseISPyBCallback(PlanReactiveCallback):
             case DocDescriptorNames.HARDWARE_READ_DURING:
                 scan_data_infos = self._handle_ispyb_transmission_flux_read(doc)
             case _:
-                return self._tag_doc(doc)
+                return self.tag_doc(doc)
         self.ispyb_ids = self.ispyb.update_deposition(self.ispyb_ids, scan_data_infos)
         ISPYB_ZOCALO_CALLBACK_LOGGER.info(f"Received ISPYB IDs: {self.ispyb_ids}")
-        return self._tag_doc(doc)
+        return self.tag_doc(doc)
 
     def _handle_ispyb_hardware_read(self, doc) -> Sequence[ScanDataInfo]:
         assert self.params, "Event handled before activity_gated_start received params"
@@ -203,7 +203,7 @@ class BaseISPyBCallback(PlanReactiveCallback):
             ISPYB_ZOCALO_CALLBACK_LOGGER.warning(
                 f"Failed to finalise ISPyB deposition on stop document: {format_doc_for_log(doc)} with exception: {e}"
             )
-        return self._tag_doc(doc)
+        return self.tag_doc(doc)
 
     def _append_to_comment(self, id: int, comment: str) -> None:
         assert self.ispyb is not None
@@ -218,7 +218,7 @@ class BaseISPyBCallback(PlanReactiveCallback):
         for id in self.ispyb_ids.data_collection_ids:
             self._append_to_comment(id, comment)
 
-    def _tag_doc(self, doc: D) -> D:
+    def tag_doc(self, doc: D) -> D:
         assert isinstance(doc, dict)
         if self.ispyb_ids:
             doc["ispyb_dcids"] = self.ispyb_ids.data_collection_ids

mx_bluesky/common/external_interaction/callbacks/common/zocalo_callback.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable, Generator
 from typing import TYPE_CHECKING
 
 from bluesky.callbacks import CallbackBase
@@ -10,12 +11,14 @@ from mx_bluesky.common.parameters.constants import (
 )
 from mx_bluesky.common.utils.exceptions import ISPyBDepositionNotMade
 from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER
-from mx_bluesky.common.utils.utils import number_of_frames_from_scan_spec
 
 if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart, RunStop
 
 
+ZocaloInfoGenerator = Generator[list[ZocaloStartInfo], dict, None]
+
+
 class ZocaloCallback(CallbackBase):
     """Callback class to handle the triggering of Zocalo processing.
     Will start listening for collections when {triggering_plan} has been started.
@@ -26,40 +29,45 @@ class ZocaloCallback(CallbackBase):
 
     Shouldn't be subscribed directly to the RunEngine, instead should be passed to the
     `emit` argument of an ISPyB callback which appends DCIDs to the relevant start doc.
+
+    Args:
+        triggering_plan: Name of the bluesky sub-plan inside of which we generate information
+            to be submitted to zocalo; this is identified by the 'subplan_name' entry in the
+            run start metadata.
+        zocalo_environment: Name of the zocalo environment we use to connect to zocalo
+        start_info_generator_factory: A factory method which returns a Generator,
+            the generator is sent the ZOCALO_HW_READ event document and in return yields
+            one or more ZocaloStartInfo which will each be submitted to zocalo as a job.
     """
 
+    def __init__(
+        self,
+        triggering_plan: str,
+        zocalo_environment: str,
+        start_info_generator_factory: Callable[[], ZocaloInfoGenerator],
+    ):
+        super().__init__()
+        self._info_generator_factory = start_info_generator_factory
+        self.triggering_plan = triggering_plan
+        self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
+        self._reset_state()
+
     def _reset_state(self):
         self.run_uid: str | None = None
         self.zocalo_info: list[ZocaloStartInfo] = []
         self._started_zocalo_collections: list[ZocaloStartInfo] = []
         self.descriptors: dict[str, EventDescriptor] = {}
-        self.start_frame = 0
-
-    def __init__(self, triggering_plan: str, zocalo_environment: str):
-        super().__init__()
-        self.triggering_plan = triggering_plan
-        self.zocalo_interactor = ZocaloTrigger(zocalo_environment)
-        self._reset_state()
+        self._info_generator = self._info_generator_factory()
+        # Prime the generator
+        next(self._info_generator)
 
     def start(self, doc: RunStart):
         ISPYB_ZOCALO_CALLBACK_LOGGER.info("Zocalo handler received start document.")
         if self.triggering_plan and doc.get("subplan_name") == self.triggering_plan:
             self.run_uid = doc.get("uid")
         if self.run_uid:
-            if (
-                isinstance(scan_points := doc.get("scan_points"), list)
-                and isinstance(ispyb_ids := doc.get("ispyb_dcids"), tuple)
-                and len(ispyb_ids) > 0
-            ):
-                ISPYB_ZOCALO_CALLBACK_LOGGER.info(f"Zocalo triggering for {ispyb_ids}")
-                ids_and_shape = list(zip(ispyb_ids, scan_points, strict=False))
-                for idx, id_and_shape in enumerate(ids_and_shape):
-                    id, shape = id_and_shape
-                    num_frames = number_of_frames_from_scan_spec(shape)
-                    self.zocalo_info.append(
-                        ZocaloStartInfo(id, None, self.start_frame, num_frames, idx)
-                    )
-                    self.start_frame += num_frames
+            zocalo_infos = self._info_generator.send(doc)  # type: ignore
+            self.zocalo_info.extend(zocalo_infos)
 
     def descriptor(self, doc: EventDescriptor):
         self.descriptors[doc["uid"]] = doc