mx-bluesky 0.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

mx_bluesky/hyperion/__main__.py

@@ -0,0 +1,374 @@
+import atexit
+import json
+import threading
+from collections.abc import Callable
+from dataclasses import asdict
+from queue import Queue
+from traceback import format_exception
+from typing import Any
+
+from blueapi.core import BlueskyContext, MsgGenerator
+from bluesky.callbacks.zmq import Publisher
+from bluesky.run_engine import RunEngine
+from flask import Flask, request
+from flask_restful import Api, Resource
+from pydantic.dataclasses import dataclass
+
+from mx_bluesky.hyperion.exceptions import WarningException
+from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
+    PLAN_REGISTRY,
+    PlanNotFound,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.__main__ import (
+    setup_logging as setup_callback_logging,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.aperture_change_callback import (
+    ApertureChangeCallback,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util import (
+    CallbacksFactory,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.log_uid_tag_callback import (
+    LogUidTaggingCallback,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.logging_callback import (
+    VerbosePlanExecutionLoggingCallback,
+)
+from mx_bluesky.hyperion.log import (
+    LOGGER,
+    do_default_logging_setup,
+    flush_debug_handler,
+)
+from mx_bluesky.hyperion.parameters.cli import parse_cli_args
+from mx_bluesky.hyperion.parameters.components import HyperionParameters
+from mx_bluesky.hyperion.parameters.constants import CONST, Actions, Status
+from mx_bluesky.hyperion.tracing import TRACER
+from mx_bluesky.hyperion.utils.context import setup_context
+
+VERBOSE_EVENT_LOGGING: bool | None = None
+
+
+@dataclass
+class Command:
+    action: Actions
+    devices: Any | None = None
+    experiment: Callable[[Any, Any], MsgGenerator] | None = None
+    parameters: HyperionParameters | None = None
+    callbacks: CallbacksFactory | None = None
+
+
+@dataclass
+class StatusAndMessage:
+    status: str
+    message: str = ""
+
+    def __init__(self, status: Status, message: str = "") -> None:
+        self.status = status.value
+        self.message = message
+
+
+@dataclass
+class ErrorStatusAndMessage(StatusAndMessage):
+    exception_type: str = ""
+
+
+def make_error_status_and_message(exception: Exception):
+    return ErrorStatusAndMessage(
+        status=Status.FAILED.value,
+        message=repr(exception),
+        exception_type=type(exception).__name__,
+    )
+
+
+class BlueskyRunner:
+    def __init__(
+        self,
+        RE: RunEngine,
+        context: BlueskyContext,
+        skip_startup_connection=False,
+        use_external_callbacks: bool = False,
+    ) -> None:
+        self.command_queue: Queue[Command] = Queue()
+        self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
+        self.last_run_aborted: bool = False
+        self.aperture_change_callback = ApertureChangeCallback()
+        self.logging_uid_tag_callback = LogUidTaggingCallback()
+        self.context: BlueskyContext
+
+        self.RE = RE
+        self.context = context
+        self.subscribed_per_plan_callbacks: list[int] = []
+        RE.subscribe(self.aperture_change_callback)
+        RE.subscribe(self.logging_uid_tag_callback)
+
+        self.use_external_callbacks = use_external_callbacks
+        if self.use_external_callbacks:
+            LOGGER.info("Connecting to external callback ZMQ proxy...")
+            self.publisher = Publisher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[0]}")
+            RE.subscribe(self.publisher)
+
+        if VERBOSE_EVENT_LOGGING:
+            RE.subscribe(VerbosePlanExecutionLoggingCallback())
+
+        self.skip_startup_connection = skip_startup_connection
+        if not self.skip_startup_connection:
+            LOGGER.info("Initialising dodal devices...")
+            for plan_name in PLAN_REGISTRY:
+                PLAN_REGISTRY[plan_name]["setup"](context)
+
+    def start(
+        self,
+        experiment: Callable,
+        parameters: HyperionParameters,
+        plan_name: str,
+        callbacks: CallbacksFactory | None,
+    ) -> StatusAndMessage:
+        LOGGER.info(f"Started with parameters: {parameters.model_dump_json(indent=2)}")
+
+        devices: Any = PLAN_REGISTRY[plan_name]["setup"](self.context)
+
+        if (
+            self.current_status.status == Status.BUSY.value
+            or self.current_status.status == Status.ABORTING.value
+        ):
+            return StatusAndMessage(Status.FAILED, "Bluesky already running")
+        else:
+            self.current_status = StatusAndMessage(Status.BUSY)
+            self.command_queue.put(
+                Command(
+                    action=Actions.START,
+                    devices=devices,
+                    experiment=experiment,
+                    parameters=parameters,
+                    callbacks=callbacks,
+                )
+            )
+            return StatusAndMessage(Status.SUCCESS)
+
+    def stopping_thread(self):
+        try:
+            self.RE.abort()
+            self.current_status = StatusAndMessage(Status.IDLE)
+        except Exception as e:
+            self.current_status = make_error_status_and_message(e)
+
+    def stop(self) -> StatusAndMessage:
+        if self.current_status.status == Status.IDLE.value:
+            return StatusAndMessage(Status.FAILED, "Bluesky not running")
+        elif self.current_status.status == Status.ABORTING.value:
+            return StatusAndMessage(Status.FAILED, "Bluesky already stopping")
+        else:
+            self.current_status = StatusAndMessage(Status.ABORTING)
+            stopping_thread = threading.Thread(target=self.stopping_thread)
+            stopping_thread.start()
+            self.last_run_aborted = True
+            return StatusAndMessage(Status.ABORTING)
+
+    def shutdown(self):
+        """Stops the run engine and the loop waiting for messages."""
+        print("Shutting down: Stopping the run engine gracefully")
+        self.stop()
+        self.command_queue.put(Command(action=Actions.SHUTDOWN))
+
+    def wait_on_queue(self):
+        while True:
+            command = self.command_queue.get()
+            if command.action == Actions.SHUTDOWN:
+                return
+            elif command.action == Actions.START:
+                if command.experiment is None:
+                    raise ValueError("No experiment provided for START")
+                try:
+                    if (
+                        not self.use_external_callbacks
+                        and command.callbacks
+                        and (cbs := command.callbacks())
+                    ):
+                        LOGGER.info(
+                            f"Using callbacks for this plan: {not self.use_external_callbacks} - {cbs}"
+                        )
+                        self.subscribed_per_plan_callbacks += [
+                            self.RE.subscribe(cb) for cb in cbs
+                        ]
+                    with TRACER.start_span("do_run"):
+                        self.RE(command.experiment(command.devices, command.parameters))
+
+                    self.current_status = StatusAndMessage(
+                        Status.IDLE,
+                        self.aperture_change_callback.last_selected_aperture,
+                    )
+
+                    self.last_run_aborted = False
+                except WarningException as exception:
+                    LOGGER.warning("Warning Exception", exc_info=True)
+                    self.current_status = make_error_status_and_message(exception)
+                except Exception as exception:
+                    LOGGER.error("Exception on running plan", exc_info=True)
+
+                    if self.last_run_aborted:
+                        # Aborting will cause an exception here that we want to swallow
+                        self.last_run_aborted = False
+                    else:
+                        self.current_status = make_error_status_and_message(exception)
+                finally:
+                    [
+                        self.RE.unsubscribe(cb)
+                        for cb in self.subscribed_per_plan_callbacks
+                    ]
+
+
+def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
+    experiment_registry_entry = PLAN_REGISTRY.get(plan_name)
+    if experiment_registry_entry is None:
+        raise PlanNotFound(f"Experiment plan '{plan_name}' not found in registry.")
+
+    experiment_internal_param_type = experiment_registry_entry.get("param_type")
+    callback_type = experiment_registry_entry.get("callback_collection_type")
+    plan = context.plan_functions.get(plan_name)
+    if experiment_internal_param_type is None:
+        raise PlanNotFound(
+            f"Corresponding internal param type for '{plan_name}' not found in registry."
+        )
+    if plan is None:
+        raise PlanNotFound(
+            f"Experiment plan '{plan_name}' not found in context. Context has {context.plan_functions.keys()}"
+        )
+    try:
+        parameters = experiment_internal_param_type(**json.loads(request.data))
+        if parameters.model_extra:
+            raise ValueError(f"Extra fields not allowed {parameters.model_extra}")
+    except Exception as e:
+        raise ValueError(
+            f"Supplied parameters don't match the plan for this endpoint {request.data}"
+        ) from e
+    return plan, parameters, plan_name, callback_type
+
+
+class RunExperiment(Resource):
+    def __init__(self, runner: BlueskyRunner, context: BlueskyContext) -> None:
+        super().__init__()
+        self.runner = runner
+        self.context = context
+
+    def put(self, plan_name: str, action: Actions):
+        status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
+        if action == Actions.START.value:
+            try:
+                plan, params, plan_name, callback_type = compose_start_args(
+                    self.context, plan_name, action
+                )
+                status_and_message = self.runner.start(
+                    plan, params, plan_name, callback_type
+                )
+            except Exception as e:
+                status_and_message = make_error_status_and_message(e)
+                LOGGER.error(format_exception(e))
+
+        elif action == Actions.STOP.value:
+            status_and_message = self.runner.stop()
+        # no idea why mypy gives an attribute error here but nowhere else for this
+        # exact same situation...
+        return asdict(status_and_message)  # type: ignore
+
+
+class StopOrStatus(Resource):
+    def __init__(self, runner: BlueskyRunner) -> None:
+        super().__init__()
+        self.runner: BlueskyRunner = runner
+
+    def put(self, action):
+        status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
+        if action == Actions.STOP.value:
+            status_and_message = self.runner.stop()
+        return asdict(status_and_message)
+
+    def get(self, **kwargs):
+        action = kwargs.get("action")
+        status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
+        if action == Actions.STATUS.value:
+            LOGGER.debug(
+                f"Runner received status request - state of the runner object is: {self.runner.__dict__} - state of the RE is: {self.runner.RE.__dict__}"
+            )
+            status_and_message = self.runner.current_status
+        return asdict(status_and_message)
+
+
+class FlushLogs(Resource):
+    def put(self, **kwargs):
+        try:
+            status_and_message = StatusAndMessage(
+                Status.SUCCESS, f"Flushed debug log to {flush_debug_handler()}"
+            )
+        except Exception as e:
+            status_and_message = StatusAndMessage(
+                Status.FAILED, f"Failed to flush debug log: {e}"
+            )
+        return asdict(status_and_message)
+
+
+def create_app(
+    test_config=None,
+    RE: RunEngine = RunEngine({}),
+    skip_startup_connection: bool = False,
+    use_external_callbacks: bool = False,
+) -> tuple[Flask, BlueskyRunner]:
+    context = setup_context(
+        wait_for_connection=not skip_startup_connection,
+    )
+    runner = BlueskyRunner(
+        RE,
+        context=context,
+        use_external_callbacks=use_external_callbacks,
+        skip_startup_connection=skip_startup_connection,
+    )
+    app = Flask(__name__)
+    if test_config:
+        app.config.update(test_config)
+    api = Api(app)
+    api.add_resource(
+        RunExperiment,
+        "/<string:plan_name>/<string:action>",
+        resource_class_args=[runner, context],
+    )
+    api.add_resource(
+        FlushLogs,
+        "/flush_debug_log",
+    )
+    api.add_resource(
+        StopOrStatus,
+        "/<string:action>",
+        resource_class_args=[runner],
+    )
+    return app, runner
+
+
+def create_targets():
+    hyperion_port = 5005
+    args = parse_cli_args()
+    do_default_logging_setup(dev_mode=args.dev_mode)
+    if not args.use_external_callbacks:
+        setup_callback_logging(args.dev_mode)
+    app, runner = create_app(
+        skip_startup_connection=args.skip_startup_connection,
+        use_external_callbacks=args.use_external_callbacks,
+    )
+    return app, runner, hyperion_port, args.dev_mode
+
+
+def main():
+    app, runner, port, dev_mode = create_targets()
+    atexit.register(runner.shutdown)
+    flask_thread = threading.Thread(
+        target=lambda: app.run(
+            host="0.0.0.0", port=port, debug=True, use_reloader=False
+        ),
+        daemon=True,
+    )
+    flask_thread.start()
+    LOGGER.info(f"Hyperion now listening on {port} ({'IN DEV' if dev_mode else ''})")
+    runner.wait_on_queue()
+    flask_thread.join()
+
+
+if __name__ == "__main__":
+    main()

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -0,0 +1,134 @@
+import json
+
+import bluesky.plan_stubs as bps
+from dodal.devices.focusing_mirror import (
+    FocusingMirrorWithStripes,
+    MirrorStripe,
+    VFMMirrorVoltages,
+)
+from dodal.devices.undulator_dcm import UndulatorDCM
+from dodal.devices.util.adjuster_plans import lookup_table_adjuster
+from dodal.devices.util.lookup_tables import (
+    linear_interpolation_lut,
+)
+
+from mx_bluesky.hyperion.log import LOGGER
+
+MIRROR_VOLTAGE_GROUP = "MIRROR_VOLTAGE_GROUP"
+DCM_GROUP = "DCM_GROUP"
+
+
+def _apply_and_wait_for_voltages_to_settle(
+    stripe: MirrorStripe,
+    mirror: FocusingMirrorWithStripes,
+    mirror_voltages: VFMMirrorVoltages,
+):
+    with open(mirror_voltages.voltage_lookup_table_path) as lut_file:
+        json_obj = json.load(lut_file)
+
+    # sample mode is the only mode supported
+    sample_data = json_obj["sample"]
+    mirror_key = mirror.name.lower()
+    if stripe == MirrorStripe.BARE:
+        stripe_key = "bare"
+    elif stripe == MirrorStripe.RHODIUM:
+        stripe_key = "rh"
+    elif stripe == MirrorStripe.PLATINUM:
+        stripe_key = "pt"
+    else:
+        raise ValueError(f"Unsupported stripe '{stripe}'")
+
+    required_voltages = sample_data[stripe_key][mirror_key]
+    for voltage_channel, required_voltage in zip(
+        mirror_voltages.voltage_channels.values(), required_voltages, strict=False
+    ):
+        LOGGER.debug(
+            f"Applying and waiting for voltage {voltage_channel.name} = {required_voltage}"
+        )
+        yield from bps.abs_set(
+            voltage_channel, required_voltage, group=MIRROR_VOLTAGE_GROUP
+        )
+
+    yield from bps.wait(group=MIRROR_VOLTAGE_GROUP)
+
+
+def adjust_mirror_stripe(
+    energy_kev, mirror: FocusingMirrorWithStripes, mirror_voltages: VFMMirrorVoltages
+):
+    """Feedback should be OFF prior to entry, in order to prevent
+    feedback from making unnecessary corrections while beam is being adjusted."""
+    stripe = mirror.energy_to_stripe(energy_kev)
+
+    LOGGER.info(
+        f"Adjusting mirror stripe for {energy_kev}keV selecting {stripe} stripe"
+    )
+    yield from bps.abs_set(mirror.stripe, stripe, wait=True)
+    yield from bps.trigger(mirror.apply_stripe)
+
+    LOGGER.info("Adjusting mirror voltages...")
+    yield from _apply_and_wait_for_voltages_to_settle(stripe, mirror, mirror_voltages)
+
+
+def adjust_dcm_pitch_roll_vfm_from_lut(
+    undulator_dcm: UndulatorDCM,
+    vfm: FocusingMirrorWithStripes,
+    vfm_mirror_voltages: VFMMirrorVoltages,
+    energy_kev,
+):
+    """Beamline energy-change post-adjustments : Adjust DCM and VFM directly from lookup tables.
+    Lookups are performed against the Bragg angle which will have been automatically set by EPICS as a side-effect of the
+    energy change prior to calling this function.
+    Feedback should be OFF prior to entry, in order to prevent
+    feedback from making unnecessary corrections while beam is being adjusted."""
+
+    # DCM Pitch
+    dcm = undulator_dcm.dcm
+    LOGGER.info(f"Adjusting DCM and VFM for {energy_kev} keV")
+    bragg_deg = yield from bps.rd(dcm.bragg_in_degrees.user_readback)
+    LOGGER.info(f"Read Bragg angle = {bragg_deg} degrees")
+    dcm_pitch_adjuster = lookup_table_adjuster(
+        linear_interpolation_lut(undulator_dcm.pitch_energy_table_path),
+        dcm.pitch_in_mrad,
+        bragg_deg,
+    )
+    yield from dcm_pitch_adjuster(DCM_GROUP)
+    # It's possible we can remove these waits but we need to check
+    LOGGER.info("Waiting for DCM pitch adjust to complete...")
+
+    # DCM Roll
+    dcm_roll_adjuster = lookup_table_adjuster(
+        linear_interpolation_lut(undulator_dcm.roll_energy_table_path),
+        dcm.roll_in_mrad,
+        bragg_deg,
+    )
+    yield from dcm_roll_adjuster(DCM_GROUP)
+    LOGGER.info("Waiting for DCM roll adjust to complete...")
+
+    # DCM Perp pitch
+    offset_mm = undulator_dcm.dcm_fixed_offset_mm
+    LOGGER.info(f"Adjusting DCM offset to {offset_mm} mm")
+    yield from bps.abs_set(dcm.offset_in_mm, offset_mm, group=DCM_GROUP)
+
+    #
+    # Adjust mirrors
+    #
+
+    # No need to change HFM
+
+    # Assumption is focus mode is already set to "sample"
+    # not sure how we check this
+
+    # VFM Stripe selection
+    yield from adjust_mirror_stripe(energy_kev, vfm, vfm_mirror_voltages)
+    yield from bps.wait(DCM_GROUP)
+
+    # VFM Adjust - for I03 this table always returns the same value
+    vfm_lut = vfm.bragg_to_lat_lookup_table_path
+    assert vfm_lut is not None
+    vfm_x_adjuster = lookup_table_adjuster(
+        linear_interpolation_lut(vfm_lut),
+        vfm.x_mm,
+        bragg_deg,
+    )
+    LOGGER.info("Waiting for VFM Lat (Horizontal Translation) to complete...")
+    yield from vfm_x_adjuster()

mx_bluesky/hyperion/device_setup_plans/manipulate_sample.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import bluesky.plan_stubs as bps
+from dodal.devices.aperturescatterguard import (
+    ApertureScatterguard,
+    ApertureValue,
+)
+from dodal.devices.backlight import Backlight, BacklightPosition
+from dodal.devices.detector.detector_motion import DetectorMotion
+from dodal.devices.smargon import Smargon
+
+from mx_bluesky.hyperion.log import LOGGER
+
+LOWER_DETECTOR_SHUTTER_AFTER_SCAN = True
+
+
+def setup_sample_environment(
+    aperture_scatterguard: ApertureScatterguard,
+    aperture_position_gda_name: str | None,
+    backlight: Backlight,
+    group="setup_senv",
+):
+    """Move the aperture into required position, move out the backlight."""
+    aperture_value = (
+        None
+        if not aperture_position_gda_name
+        else ApertureValue(aperture_position_gda_name)
+    )
+    yield from move_aperture_if_required(
+        aperture_scatterguard, aperture_value, group=group
+    )
+    yield from bps.abs_set(backlight, BacklightPosition.OUT, group=group)
+
+
+def move_aperture_if_required(
+    aperture_scatterguard: ApertureScatterguard,
+    aperture_value: ApertureValue | None,
+    group="move_aperture",
+):
+    if not aperture_value:
+        previous_aperture_position = yield from bps.rd(aperture_scatterguard)
+        assert isinstance(previous_aperture_position, ApertureValue)
+        LOGGER.info(
+            f"Using previously set aperture position {previous_aperture_position}"
+        )
+
+    else:
+        LOGGER.info(f"Setting aperture position to {aperture_value}")
+        yield from bps.abs_set(
+            aperture_scatterguard,
+            aperture_value,
+            group=group,
+        )
+
+
+def cleanup_sample_environment(
+    detector_motion: DetectorMotion,
+    group="cleanup_senv",
+):
+    """Put the detector shutter back down"""
+
+    yield from bps.abs_set(
+        detector_motion.shutter,
+        int(not LOWER_DETECTOR_SHUTTER_AFTER_SCAN),
+        group=group,
+    )
+
+
+def move_x_y_z(
+    smargon: Smargon,
+    x_mm: float | None = None,
+    y_mm: float | None = None,
+    z_mm: float | None = None,
+    wait=False,
+    group="move_x_y_z",
+):
+    """Move the x, y, and z axes of the given smargon to the specified position. All
+    axes are optional."""
+
+    LOGGER.info(f"Moving smargon to x, y, z: {(x_mm, y_mm, z_mm)}")
+    if x_mm:
+        yield from bps.abs_set(smargon.x, x_mm, group=group)
+    if y_mm:
+        yield from bps.abs_set(smargon.y, y_mm, group=group)
+    if z_mm:
+        yield from bps.abs_set(smargon.z, z_mm, group=group)
+    if wait:
+        yield from bps.wait(group)
+
+
+def move_phi_chi_omega(
+    smargon: Smargon,
+    phi: float | None = None,
+    chi: float | None = None,
+    omega: float | None = None,
+    wait=False,
+    group="move_phi_chi_omega",
+):
+    """Move the x, y, and z axes of the given smargon to the specified position. All
+    axes are optional."""
+
+    LOGGER.info(f"Moving smargon to phi, chi, omega: {(phi, chi, omega)}")
+    if phi:
+        yield from bps.abs_set(smargon.phi, phi, group=group)
+    if chi:
+        yield from bps.abs_set(smargon.chi, chi, group=group)
+    if omega:
+        yield from bps.abs_set(smargon.omega, omega, group=group)
+    if wait:
+        yield from bps.wait(group)

mx_bluesky/hyperion/device_setup_plans/position_detector.py

@@ -0,0 +1,16 @@
+from bluesky import plan_stubs as bps
+from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
+
+from mx_bluesky.hyperion.log import LOGGER
+
+
+def set_detector_z_position(
+    detector_motion: DetectorMotion, detector_position: float, group=None
+):
+    LOGGER.info(f"Moving detector to {detector_position} ({group})")
+    yield from bps.abs_set(detector_motion.z, detector_position, group=group)
+
+
+def set_shutter(detector_motion: DetectorMotion, state: ShutterState, group=None):
+    LOGGER.info(f"Setting shutter to {state} ({group})")
+    yield from bps.abs_set(detector_motion.shutter, state, group=group)

mx_bluesky/hyperion/device_setup_plans/read_hardware_for_setup.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import bluesky.plan_stubs as bps
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.attenuator import Attenuator
+from dodal.devices.dcm import DCM
+from dodal.devices.eiger import EigerDetector
+from dodal.devices.flux import Flux
+from dodal.devices.robot import BartRobot
+from dodal.devices.s4_slit_gaps import S4SlitGaps
+from dodal.devices.smargon import Smargon
+from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.undulator import Undulator
+
+from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.hyperion.parameters.constants import CONST
+
+
+def read_hardware_pre_collection(
+    undulator: Undulator,
+    synchrotron: Synchrotron,
+    s4_slit_gaps: S4SlitGaps,
+    robot: BartRobot,
+    smargon: Smargon,
+):
+    LOGGER.info("Reading status of beamline for callbacks, pre collection.")
+    yield from bps.create(
+        name=CONST.DESCRIPTORS.HARDWARE_READ_PRE
+    )  # gives name to event *descriptor* document
+    yield from bps.read(undulator.current_gap)
+    yield from bps.read(synchrotron.synchrotron_mode)
+    yield from bps.read(s4_slit_gaps.xgap)
+    yield from bps.read(s4_slit_gaps.ygap)
+    yield from bps.read(smargon.x)
+    yield from bps.read(smargon.y)
+    yield from bps.read(smargon.z)
+    yield from bps.save()
+
+
+def read_hardware_during_collection(
+    aperture_scatterguard: ApertureScatterguard,
+    attenuator: Attenuator,
+    flux: Flux,
+    dcm: DCM,
+    detector: EigerDetector,
+):
+    LOGGER.info("Reading status of beamline for callbacks, during collection.")
+    yield from bps.create(name=CONST.DESCRIPTORS.HARDWARE_READ_DURING)
+    yield from bps.read(aperture_scatterguard)
+    yield from bps.read(attenuator.actual_transmission)
+    yield from bps.read(flux.flux_reading)
+    yield from bps.read(dcm.energy_in_kev)
+    yield from bps.read(detector.bit_depth)
+    yield from bps.save()
+
+
+def read_hardware_for_zocalo(detector: EigerDetector):
+    yield from bps.create(name=CONST.DESCRIPTORS.ZOCALO_HW_READ)
+    yield from bps.read(detector.odin.file_writer.id)
+    yield from bps.save()