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

mx_bluesky/common/device_setup_plans/xbpm_feedback.py

@@ -6,7 +6,9 @@ from mx_bluesky.common.utils.log import LOGGER
 
 
 def unpause_xbpm_feedback_and_set_transmission_to_1(
-    xbpm_feedback: XBPMFeedback, attenuator: BinaryFilterAttenuator
+    xbpm_feedback: XBPMFeedback,
+    attenuator: BinaryFilterAttenuator,
+    timeout_for_stable: float = 0,
 ):
     """Turns the XBPM feedback back on and sets transmission to 1 so that it keeps the
     beam aligned whilst not collecting.
@@ -15,8 +17,13 @@ def unpause_xbpm_feedback_and_set_transmission_to_1(
         xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
                                       the beam in position
         attenuator (BinaryFilterAttenuator): The attenuator used to set transmission
+        timeout_for_stable: If specified and non-zero, specifies the time in seconds to wait for
+            feedback to stabilise, otherwise we do not wait.
     """
     yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)
+    if timeout_for_stable:
+        yield from bps.trigger(xbpm_feedback, group="feedback")
+        yield from bps.wait(group="feedback", timeout=timeout_for_stable)
 
 
 def check_and_pause_feedback(

mx_bluesky/common/experiment_plans/beamstop_check.py

@@ -0,0 +1,229 @@
+import pydantic
+from bluesky import plan_stubs as bps
+from bluesky.utils import MsgGenerator
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.backlight import Backlight
+from dodal.devices.baton import Baton
+from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
+from dodal.devices.ipin import IPin, IPinGain
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+from dodal.devices.xbpm_feedback import XBPMFeedback
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter, ZebraShutterState
+from ophyd_async.core import InOut
+
+from mx_bluesky.common.device_setup_plans.xbpm_feedback import (
+    unpause_xbpm_feedback_and_set_transmission_to_1,
+)
+from mx_bluesky.common.utils.exceptions import BeamlineCheckFailureError
+from mx_bluesky.common.utils.log import LOGGER
+
+_GROUP_PRE_BEAMSTOP_OUT_CHECK = "pre_background_check"
+_GROUP_POST_BEAMSTOP_OUT_CHECK = "post_background_check"
+_PARAM_IPIN_THRESHOLD = "ipin_threshold"
+
+_FEEDBACK_TIMEOUT_S = 10
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class BeamstopCheckDevices:
+    aperture_scatterguard: ApertureScatterguard
+    attenuator: BinaryFilterAttenuator
+    backlight: Backlight
+    baton: Baton
+    beamstop: Beamstop
+    detector_motion: DetectorMotion
+    ipin: IPin
+    sample_shutter: ZebraShutter
+    xbpm_feedback: XBPMFeedback
+
+
+class SampleCurrentBelowThresholdError(BeamlineCheckFailureError): ...
+
+
+class BeamstopNotInPositionError(BeamlineCheckFailureError): ...
+
+
+class BeamObstructedError(BeamlineCheckFailureError): ...
+
+
+def move_beamstop_in_and_verify_using_diode(
+    devices: BeamstopCheckDevices,
+    beamline_parameters: GDABeamlineParameters,
+    detector_min_z_mm: float,
+    detector_max_z_mm: float,
+) -> MsgGenerator:
+    """
+    Move the beamstop into the data collection position, checking the beam current
+    via the diode on the detector shutter, first with the beamstop out and then with
+    the beamstop in.
+    These checks aim to ensure that
+       * The beam is not obstructed by something other than the beamstop
+       * The beamstop has been successfully moved and is intercepting the beam
+
+    As a side-effect, this plan also does the following things:
+        * Move the detector z-axis in range
+        * Move the backlight out
+        * Unpauses feedback
+        * Sets xmission to 100%
+        * Sets IPin gain to 10^4 low noise
+        * Moves aperture scatterguard to OUT_OF_BEAM if it is currently in beam
+
+    Implementation note:
+        Some checks are repeated here such as closing the sample shutter, so that at a
+        future point this plan may be run independently of the udc default state script
+        if desired.
+    Note on commissioning mode:
+        When commissioning mode is enabled, the beamstop check will execute normally except
+        where it expects beam to be present, the absence of beam will be ignored.
+    Args:
+        devices: The device composite containing the necessary devices
+        beamline_parameters: A mapping containing the beamlineParameters
+        detector_min_z_mm: Detector minimum distance at which beamstop is effective
+        detector_max_z_mm: Detector maximum distance at which beamstop is effective
+    Raises:
+        SampleCurrentBelowThresholdError: If we do not have sufficient sample current to perform
+            the check.
+        BeamstopNotInPositionError: If the ipin current is too high, indicating that the
+            beamstop is not in the correct position.
+        BeamObstructedError: If the ipin current is too low after the first check
+            with the beamstop out, indicating a likely obstruction.
+    """
+    LOGGER.info("Performing beamstop check...")
+    commissioning_mode_enabled = yield from bps.rd(devices.baton.commissioning)
+    beamstop_threshold_uA = beamline_parameters[_PARAM_IPIN_THRESHOLD]  # noqa: N806
+
+    yield from _start_moving_detector_if_needed(
+        devices, detector_min_z_mm, detector_max_z_mm, _GROUP_POST_BEAMSTOP_OUT_CHECK
+    )
+    yield from _pre_beamstop_out_check_actions(devices)
+    yield from _beamstop_out_check(
+        devices, beamstop_threshold_uA, commissioning_mode_enabled
+    )
+    yield from _post_beamstop_out_check_actions(devices, _GROUP_POST_BEAMSTOP_OUT_CHECK)
+    yield from _beamstop_in_check(devices, beamstop_threshold_uA)
+
+
+def _pre_beamstop_out_check_actions(devices: BeamstopCheckDevices):
+    # Re-verify that the sample shutter is closed
+    yield from bps.abs_set(devices.sample_shutter, ZebraShutterState.CLOSE, wait=True)
+    LOGGER.info("Unpausing feedback, transmission to 100%, wait for feedback stable...")
+    try:
+        yield from unpause_xbpm_feedback_and_set_transmission_to_1(
+            devices.xbpm_feedback,
+            devices.attenuator,
+            _FEEDBACK_TIMEOUT_S,
+        )
+    except TimeoutError as e:
+        raise SampleCurrentBelowThresholdError(
+            "Unable to perform beamstop check - xbpm feedback did not become stable "
+            " - check if beam present?"
+        ) from e
+
+    yield from bps.abs_set(
+        devices.backlight, InOut.OUT, group=_GROUP_PRE_BEAMSTOP_OUT_CHECK
+    )
+
+    yield from bps.abs_set(
+        devices.aperture_scatterguard.selected_aperture,
+        ApertureValue.OUT_OF_BEAM,
+        group=_GROUP_PRE_BEAMSTOP_OUT_CHECK,
+    )
+
+    yield from bps.abs_set(
+        devices.ipin.gain,
+        IPinGain.GAIN_10E4_LOW_NOISE,
+        group=_GROUP_PRE_BEAMSTOP_OUT_CHECK,
+    )
+    yield from bps.abs_set(
+        devices.detector_motion.shutter,
+        ShutterState.CLOSED,
+        group=_GROUP_PRE_BEAMSTOP_OUT_CHECK,
+    )
+    yield from bps.abs_set(
+        devices.beamstop.selected_pos,
+        BeamstopPositions.OUT_OF_BEAM,
+        group=_GROUP_PRE_BEAMSTOP_OUT_CHECK,
+    )
+
+    LOGGER.info("Waiting for pre-background-check motions to complete...")
+    yield from bps.wait(group=_GROUP_PRE_BEAMSTOP_OUT_CHECK)
+
+    # Check detector shutter is closed
+    detector_shutter_state = yield from bps.rd(devices.detector_motion.shutter)
+    detector_shutter_is_closed = detector_shutter_state == ShutterState.CLOSED
+    if not detector_shutter_is_closed:
+        raise RuntimeError(
+            "Unable to proceed with beamstop background check, detector shutter did not close"
+        )
+
+
+def _start_moving_detector_if_needed(
+    devices: BeamstopCheckDevices,
+    detector_min_z_mm: float,
+    detector_max_z_mm: float,
+    group: str = None,
+):
+    detector_current_z = yield from bps.rd(devices.detector_motion.z)
+    target_z = max(min(detector_current_z, detector_max_z_mm), detector_min_z_mm)
+    if detector_current_z != target_z:
+        LOGGER.info(
+            f"Detector distance {detector_current_z}mm outside acceptable range for diode "
+            f"check {detector_min_z_mm} <= z <= {detector_max_z_mm}, moving it."
+        )
+        yield from bps.abs_set(devices.detector_motion.z, target_z, group=group)
+
+
+def _post_beamstop_out_check_actions(devices: BeamstopCheckDevices, group: str):
+    yield from bps.abs_set(
+        devices.beamstop.selected_pos,
+        BeamstopPositions.DATA_COLLECTION,
+        group=group,
+    )
+
+    LOGGER.info("Waiting for detector motion to complete...")
+    yield from bps.wait(group=group)
+
+
+def _beamstop_out_check(
+    devices: BeamstopCheckDevices,
+    beamstop_threshold_uA: float,  # noqa: N803
+    commissioning_mode_enabled: bool,
+):
+    ipin_beamstop_out_uA = yield from _check_ipin(devices)  # noqa: N806
+
+    LOGGER.info(f"Beamstop out ipin = {ipin_beamstop_out_uA}uA")
+    if ipin_beamstop_out_uA < beamstop_threshold_uA:
+        msg = (
+            f"IPin current {ipin_beamstop_out_uA}uA below threshold "
+            f"{beamstop_threshold_uA} with beamstop out - check "
+            f"that beam is not obstructed."
+        )
+        if commissioning_mode_enabled:
+            LOGGER.warning(msg + " - commissioning mode enabled - ignoring this")
+        else:
+            raise BeamObstructedError(msg)
+
+
+def _beamstop_in_check(devices: BeamstopCheckDevices, beamstop_threshold_uA: float):  # noqa: N803
+    ipin_in_beam_uA = yield from _check_ipin(devices)  # noqa: N806
+    if ipin_in_beam_uA > beamstop_threshold_uA:
+        raise BeamstopNotInPositionError(
+            f"Ipin is too high at {ipin_in_beam_uA} - check that beamstop is "
+            f"in the correct position."
+        )
+
+
+def _check_ipin(devices: BeamstopCheckDevices):
+    try:
+        yield from bps.abs_set(
+            devices.sample_shutter, ZebraShutterState.OPEN, wait=True
+        )
+        yield from bps.sleep(1)  # wait for reading to settle
+
+        return (yield from bps.rd(devices.ipin.pin_readback))  # noqa: N806
+    finally:
+        yield from bps.abs_set(
+            devices.sample_shutter, ZebraShutterState.CLOSE, wait=True
+        )

mx_bluesky/common/experiment_plans/common_flyscan_xray_centre_plan.py

@@ -279,6 +279,8 @@ def run_gridscan(
             raise SampleError(
                 "Scan invalid - gridscan not valid for detected pin position"
             ) from e
+        else:
+            raise e
 
     LOGGER.info("Waiting for arming to finish")
     yield from bps.wait(PlanGroupCheckpointConstants.GRID_READY_FOR_DC)

mx_bluesky/common/experiment_plans/inner_plans/read_hardware.py

@@ -4,13 +4,14 @@ import bluesky.plan_stubs as bps
 from bluesky.protocols import Readable
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
+from dodal.devices.beamsize.beamsize import BeamsizeBase
 from dodal.devices.common_dcm import DoubleCrystalMonochromator
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
 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 dodal.devices.undulator import UndulatorInKeV
 
 from mx_bluesky.common.parameters.constants import (
     DocDescriptorNames,
@@ -40,7 +41,7 @@ def read_hardware_for_zocalo(detector: EigerDetector):
 
 
 def standard_read_hardware_pre_collection(
-    undulator: Undulator,
+    undulator: UndulatorInKeV,
     synchrotron: Synchrotron,
     s4_slit_gaps: S4SlitGaps,
     dcm: DoubleCrystalMonochromator,
@@ -65,6 +66,7 @@ def standard_read_hardware_during_collection(
     flux: Flux,
     dcm: DoubleCrystalMonochromator,
     detector: EigerDetector,
+    beamsize: BeamsizeBase,
 ):
     signals_to_read_during_collection = [
         aperture_scatterguard,
@@ -72,6 +74,7 @@ def standard_read_hardware_during_collection(
         flux.flux_reading,
         dcm.energy_in_keV,
         detector.bit_depth,
+        beamsize,
     ]
     yield from read_hardware_plan(
         signals_to_read_during_collection, DocDescriptorNames.HARDWARE_READ_DURING

mx_bluesky/common/experiment_plans/oav_snapshot_plan.py

@@ -24,7 +24,6 @@ class OavSnapshotComposite(Protocol):
     smargon: Smargon
     oav: OAV
     aperture_scatterguard: ApertureScatterguard
-    backlight: Backlight
 
 
 def setup_beamline_for_oav(

mx_bluesky/{hyperion → common}/experiment_plans/pin_tip_centring_plan.py

@@ -4,7 +4,7 @@ import bluesky.plan_stubs as bps
 import pydantic
 from blueapi.core import BlueskyContext
 from bluesky.utils import Msg
-from dodal.devices.backlight import Backlight
+from dodal.devices.motors import XYZOmegaStage
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAV_CONFIG_JSON, OAVParameters
 from dodal.devices.oav.pin_image_recognition import PinTipDetection, Tip
@@ -14,27 +14,26 @@ from dodal.devices.oav.utils import (
     get_move_required_so_that_beam_is_at_pixel,
     wait_for_tip_to_be_found,
 )
-from dodal.devices.smargon import Smargon
 
+from mx_bluesky.common.device_setup_plans.gonio import (
+    move_gonio_warn_on_out_of_range,
+)
 from mx_bluesky.common.device_setup_plans.setup_oav import pre_centring_setup_oav
+from mx_bluesky.common.parameters.constants import HardwareConstants
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.exceptions import SampleError, catch_exception_and_warn
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.device_setup_plans.smargon import (
-    move_smargon_warn_on_out_of_range,
-)
-from mx_bluesky.hyperion.parameters.constants import CONST
 
 DEFAULT_STEP_SIZE = 0.5
+CONST = HardwareConstants()
 
 
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class PinTipCentringComposite:
     """All devices which are directly or indirectly required by this plan"""
 
-    backlight: Backlight
     oav: OAV
-    smargon: Smargon
+    gonio: XYZOmegaStage
     pin_tip_detection: PinTipDetection
 
 
@@ -53,7 +52,7 @@ def trigger_and_return_pin_tip(
 
 def move_pin_into_view(
     pin_tip_device: PinTipDetection,
-    smargon: Smargon,
+    gonio: XYZOmegaStage,
     step_magnitude_mm: float = DEFAULT_STEP_SIZE,
     max_steps: int = 2,
 ) -> Generator[Msg, None, Pixel]:
@@ -63,7 +62,7 @@ def move_pin_into_view(
 
     Args:
         pin_tip_device (PinTipDetection): The device being used to detect the pin
-        smargon (Smargon): The gonio to move the tip
+        gonio (XYZOmegaStage): The stage(gonio) to move the tip
         step_magnitude_mm (float, optional): Distance to move the gonio (in mm) for each
                                     step of the search. Defaults to 0.5.
         max_steps (int, optional): The number of steps to search with. Defaults to 2.
@@ -88,20 +87,20 @@ def move_pin_into_view(
         direction_multiple = -1 if tip_xy_px[0] == 0 else 1
         step_vector_mm = step_magnitude_mm * direction_multiple
 
-        smargon_x = yield from bps.rd(smargon.x.user_readback)
-        ideal_move_to_find_pin = float(smargon_x) + step_vector_mm
-        high_limit = yield from bps.rd(smargon.x.high_limit_travel)
-        low_limit = yield from bps.rd(smargon.x.low_limit_travel)
+        stage_x = yield from bps.rd(gonio.x.user_readback)
+        ideal_move_to_find_pin = float(stage_x) + step_vector_mm
+        high_limit = yield from bps.rd(gonio.x.high_limit_travel)
+        low_limit = yield from bps.rd(gonio.x.low_limit_travel)
         move_within_limits = max(min(ideal_move_to_find_pin, high_limit), low_limit)
         if move_within_limits != ideal_move_to_find_pin:
             LOGGER.warning(
                 f"Pin tip is off screen, and moving {step_vector_mm}mm would cross limits, "
                 f"moving to {move_within_limits} instead"
             )
-        yield from bps.mv(smargon.x, move_within_limits)
+        yield from bps.mv(gonio.x, move_within_limits)
 
         # Some time for the view to settle after the move
-        yield from bps.sleep(CONST.HARDWARE.OAV_REFRESH_DELAY)
+        yield from bps.sleep(CONST.OAV_REFRESH_DELAY)
 
     tip_xy_px = yield from trigger_and_return_pin_tip(pin_tip_device)
 
@@ -127,7 +126,7 @@ def pin_tip_centre_plan(
                                     to be.
     """
     oav: OAV = composite.oav
-    smargon: Smargon = composite.smargon
+    gonio: XYZOmegaStage = composite.gonio
     oav_params = OAVParameters("pinTipCentring", oav_config_file)
 
     pin_tip_setup = composite.pin_tip_detection
@@ -139,10 +138,10 @@ def pin_tip_centre_plan(
     def offset_and_move(tip: Pixel):
         pixel_to_move_to = (tip[0] + tip_offset_px, tip[1])
         position_mm = yield from get_move_required_so_that_beam_is_at_pixel(
-            smargon, pixel_to_move_to, oav
+            gonio, pixel_to_move_to, oav
         )
         LOGGER.info(f"Tip centring moving to : {position_mm}")
-        yield from move_smargon_warn_on_out_of_range(smargon, position_mm)
+        yield from move_gonio_warn_on_out_of_range(gonio, position_mm)
 
     LOGGER.info(f"Tip offset in pixels: {tip_offset_px}")
 
@@ -152,10 +151,10 @@ def pin_tip_centre_plan(
 
     yield from pre_centring_setup_oav(oav, oav_params, pin_tip_setup)
 
-    tip = yield from move_pin_into_view(pin_tip_detect, smargon)
+    tip = yield from move_pin_into_view(pin_tip_detect, gonio)
     yield from offset_and_move(tip)
 
-    yield from bps.mvr(smargon.omega, -90)
+    yield from bps.mvr(gonio.omega, -90)
 
     # need to wait for the OAV image to update
     # See #673 for improvements

mx_bluesky/common/external_interaction/callbacks/common/grid_detection_callback.py

@@ -83,12 +83,17 @@ class GridDetectionCallback(CallbackBase):
         beam_x = data["oav-beam_centre_i"]
         beam_y = data["oav-beam_centre_j"]
 
+        x_direction = data["oav-x_direction"]
+        y_direction = data["oav-y_direction"]
+        z_direction = data["oav-z_direction"]
+
         position_grid_start_mm = calculate_x_y_z_of_pixel(
             current_xyz,
             smargon_omega,
             centre_of_first_box,
             (beam_x, beam_y),
             (microns_per_pixel_x, microns_per_pixel_y),
+            (x_direction, y_direction, z_direction),
         )
         LOGGER.info(f"Calculated start position {position_grid_start_mm}")
 

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

@@ -5,14 +5,10 @@ from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 
-from dodal.beamline_specific_utils.i03 import beam_size_from_aperture
 from dodal.devices.detector import DetectorParams
 from dodal.devices.detector.det_resolution import resolution
 from dodal.devices.synchrotron import SynchrotronMode
 
-from mx_bluesky.common.external_interaction.callbacks.common.logging_callback import (
-    format_doc_for_log,
-)
 from mx_bluesky.common.external_interaction.callbacks.common.plan_reactive_callback import (
     PlanReactiveCallback,
 )
@@ -28,7 +24,11 @@ from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import get_ispyb_config
 from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
 from mx_bluesky.common.parameters.constants import DocDescriptorNames
-from mx_bluesky.common.utils.log import ISPYB_ZOCALO_CALLBACK_LOGGER, set_dcgid_tag
+from mx_bluesky.common.utils.log import (
+    ISPYB_ZOCALO_CALLBACK_LOGGER,
+    format_doc_for_log,
+    set_dcgid_tag,
+)
 from mx_bluesky.common.utils.utils import convert_ev_to_angstrom
 
 D = TypeVar("D")
@@ -147,18 +147,16 @@ class BaseISPyBCallback(PlanReactiveCallback):
         )
         return scan_data_infos
 
-    def _handle_ispyb_transmission_flux_read(self, doc) -> Sequence[ScanDataInfo]:
+    def _handle_ispyb_transmission_flux_read(
+        self, doc: Event
+    ) -> Sequence[ScanDataInfo]:
         assert self.params
         aperture = doc["data"]["aperture_scatterguard-selected_aperture"]
-        aperture_radius = doc["data"]["aperture_scatterguard-radius"]
-        beamsize = beam_size_from_aperture(aperture_radius)
-        beamsize_x_mm = beamsize.x_um / 1000 if beamsize.x_um else None
-        beamsize_y_mm = beamsize.y_um / 1000 if beamsize.y_um else None
+        beamsize_x_mm = doc["data"]["beamsize-x_um"] / 1000
+        beamsize_y_mm = doc["data"]["beamsize-y_um"] / 1000
         hwscan_data_collection_info = DataCollectionInfo(
             beamsize_at_samplex=beamsize_x_mm,
             beamsize_at_sampley=beamsize_y_mm,
-            focal_spot_size_at_samplex=beamsize_x_mm,
-            focal_spot_size_at_sampley=beamsize_y_mm,
             flux=doc["data"]["flux-flux_reading"],
         )
         if transmission := doc["data"]["attenuator-actual_transmission"]:

mx_bluesky/common/external_interaction/callbacks/common/ispyb_mapping.py

@@ -4,15 +4,14 @@ from mx_bluesky.common.external_interaction.ispyb.data_model import (
     DataCollectionGroupInfo,
     DataCollectionInfo,
 )
-from mx_bluesky.common.external_interaction.ispyb.ispyb_store import (
-    EIGER_FILE_SUFFIX,
-    I03_EIGER_DETECTOR,
-)
 from mx_bluesky.common.external_interaction.ispyb.ispyb_utils import (
     get_current_time_string,
 )
 from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
 
+I03_EIGER_DETECTOR = 78
+EIGER_FILE_SUFFIX = "h5"
+
 
 def populate_data_collection_group(params: DiffractionExperimentWithSample):
     dcg_info = DataCollectionGroupInfo(
@@ -31,7 +30,6 @@ def populate_remaining_data_collection_info(
 ):
     data_collection_info.visit_string = params.visit
     data_collection_info.parent_id = data_collection_group_id
-    data_collection_info.sample_id = params.sample_id
     data_collection_info.detector_id = I03_EIGER_DETECTOR
     data_collection_info.comments = comment
     data_collection_info.detector_distance = params.detector_params.detector_distance

mx_bluesky/common/external_interaction/callbacks/xray_centre/ispyb_callback.py

@@ -240,7 +240,7 @@ class GridscanISPyBCallback(BaseISPyBCallback):
             f"{y_steps} by {z_steps}."
         )
 
-        self._populate_axis_info(data_collection_info, omega)
+        self._populate_axis_info(data_collection_info, doc["data"])
 
         scan_data_info = ScanDataInfo(
             data_collection_info=data_collection_info,
@@ -254,15 +254,15 @@ class GridscanISPyBCallback(BaseISPyBCallback):
         self._oav_snapshot_event_idx += 1
         return [scan_data_info]
 
-    def _populate_axis_info(
-        self, data_collection_info: DataCollectionInfo, omega_start: float | None
-    ):
-        if omega_start is not None:
+    def _populate_axis_info(self, data_collection_info: DataCollectionInfo, doc: dict):
+        if (omega_start := doc.get("smargon-omega")) is not None:
             omega_in_gda_space = -omega_start
             data_collection_info.omega_start = omega_in_gda_space
             data_collection_info.axis_start = omega_in_gda_space
             data_collection_info.axis_end = omega_in_gda_space
             data_collection_info.axis_range = 0
+        if (chi_start := doc.get("smargon-chi")) is not None:
+            data_collection_info.chi_start = chi_start
 
     def populate_info_for_update(
         self,

mx_bluesky/common/external_interaction/config_server.py

@@ -9,7 +9,7 @@ from pydantic import TypeAdapter
 
 from mx_bluesky.common.parameters.constants import (
     GDA_DOMAIN_PROPERTIES_PATH,
-    FeatureSetting,
+    FeatureSettings,
     FeatureSettingSources,
     OavConstants,
 )
@@ -19,7 +19,7 @@ FEATURE_FLAG_CACHE_LENGTH_S = 60 * 5
 # Used by the config server when refreshing its cache
 _JSON_CONFIG_PATHS = [OavConstants.OAV_CONFIG_JSON]
 
-T = TypeVar("T", bound=FeatureSetting)
+T = TypeVar("T", bound=FeatureSettings)
 
 
 class MXConfigClient(ConfigServer, Generic[T]):

mx_bluesky/common/external_interaction/ispyb/data_model.py

@@ -1,3 +1,8 @@
+"""
+TODO replace these with autogenerated schema classes from the ExpEye API
+https://github.com/DiamondLightSource/mx-bluesky/issues/1419
+"""
+
 from dataclasses import asdict, dataclass
 from enum import Enum
 
@@ -18,6 +23,9 @@ class DataCollectionGroupInfo:
 
 @dataclass(kw_only=True)
 class DataCollectionInfo:
+    # This is used internally to keep track of the DataCollectionGroup ID
+    parent_id: int | None = None
+
     omega_start: float | None = None
     data_collection_number: int | None = None
     xtal_snapshot1: str | None = None
@@ -28,15 +36,12 @@ class DataCollectionInfo:
     n_images: int | None = None
     axis_range: float | None = None
     axis_end: float | None = None
+    chi_start: float | None = None
     kappa_start: float | None = None
 
-    parent_id: int | None = None
     visit_string: str | None = None
-    sample_id: int | None = None
     detector_id: int | None = None
     axis_start: float | None = None
-    focal_spot_size_at_samplex: float | None = None
-    focal_spot_size_at_sampley: float | None = None
     slitgap_vertical: float | None = None
     slitgap_horizontal: float | None = None
     beamsize_at_samplex: float | None = None
@@ -60,6 +65,8 @@ class DataCollectionInfo:
     synchrotron_mode: str | None = None
     undulator_gap1: float | None = None
     start_time: str | None = None
+    end_time: str | None = None
+    run_status: str | None = None
 
 
 @dataclass