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

mx_bluesky/common/utils/utils.py

@@ -4,6 +4,8 @@ from math import asin
 from scanspec.core import AxesPoints, Axis
 from scipy.constants import physical_constants
 
+from mx_bluesky.common.utils.log import LOGGER
+
 hc_in_ev_and_angstrom: float = (
     physical_constants["speed of light in vacuum"][0]
     * physical_constants["Planck constant in eV/Hz"][0]
@@ -40,3 +42,49 @@ def energy_to_bragg_angle(energy_kev: float, d_a: float) -> float:
     wavelength_a = convert_ev_to_angstrom(energy_kev * 1000)
     d = d_a
     return asin(wavelength_a / (2 * d)) * 180 / math.pi
+
+
+def fix_transmission_and_exposure_time_for_current_wavelength(
+    current_wavelength_a: float,
+    assumed_wavelength_a_from_settings: float,
+    requested_trans_frac: float = 100,
+    requested_exposure_time_s: float = 0.004,
+) -> tuple[float, float]:
+    """
+    Calculates an exposure time and transmission fraction for XRC which will provide a good signal
+    on the detector by using a known good wavelength, comparing it to the beamlines current wavelength,
+    then scaling accordingly.
+
+    Args:
+        current_wavelength_a: Current energy of the beamline in angstroms.
+        assumed_wavelength_a_from_settings: The known "good" wavelength. This should be read from
+            'gda.px.expttable.default.wavelength' in GDA's domain.properties, via the config server.
+        requested_trans_frac: Requested transmission fraction to use.
+        requested_exposure_time_s: Requested exposure time to use.
+
+    Returns:
+        The scaled transmission fraction and exposure time respectively, in a tuple.
+    """
+
+    wavelength_scale = (assumed_wavelength_a_from_settings / current_wavelength_a) ** 2
+
+    # Transmission frac needed to get ideal signal
+    ideal_trans_frac = requested_trans_frac * wavelength_scale
+    if ideal_trans_frac <= 1:
+        new_trans_frac = ideal_trans_frac
+        new_exposure_time_s = requested_exposure_time_s
+    else:
+        # If the scaling would result in transmission fraction > 1,
+        # cap it to 1, find remaining scaling needed, and apply it
+        # to exposure time instead.
+        new_trans_frac = 1
+        scaling_applied_to_trans = new_trans_frac / requested_trans_frac
+        remaining_scaling_needed = wavelength_scale / scaling_applied_to_trans
+        new_exposure_time_s = requested_exposure_time_s * remaining_scaling_needed
+
+    LOGGER.info(
+        f"Fixing transmission fraction to {new_trans_frac} and exposure time to {new_exposure_time_s}s"
+    )
+
+    # Exposure time in FGS IOC is in ms, and must be an integer, so round it here
+    return new_trans_frac, round(new_exposure_time_s, 3)

mx_bluesky/hyperion/__main__.py

@@ -45,21 +45,13 @@ from mx_bluesky.hyperion.runner import (
 from mx_bluesky.hyperion.utils.context import setup_context
 
 
-def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
+def compose_start_args(context: BlueskyContext, plan_name: str):
     experiment_registry_entry = PLAN_REGISTRY.get(plan_name)
     if experiment_registry_entry is None:
         raise PlanNotFoundError(f"Experiment plan '{plan_name}' not found in registry.")
 
     experiment_internal_param_type = experiment_registry_entry.get("param_type")
     plan = context.plan_functions.get(plan_name)
-    if experiment_internal_param_type is None:
-        raise PlanNotFoundError(
-            f"Corresponding internal param type for '{plan_name}' not found in registry."
-        )
-    if plan is None:
-        raise PlanNotFoundError(
-            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))
         parameters = update_params_from_agamemnon(parameters)
@@ -80,13 +72,11 @@ class RunExperiment(Resource):
         self.runner = runner
         self.context = context
 
-    def put(self, plan_name: str, action: Actions):
+    def put(self, plan_name: str, action: str):
         status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
         if action == Actions.START.value:
             try:
-                plan, params, plan_name = compose_start_args(
-                    self.context, plan_name, action
-                )
+                plan, params, plan_name = compose_start_args(self.context, plan_name)
                 status_and_message = self.runner.start(plan, params, plan_name)
             except Exception as e:
                 status_and_message = make_error_status_and_message(e)

mx_bluesky/hyperion/baton_handler.py

@@ -15,10 +15,6 @@ from dodal.devices.robot import BartRobot
 from dodal.devices.smargon import Smargon
 
 from mx_bluesky.common.device_setup_plans.robot_load_unload import robot_unload
-from mx_bluesky.common.experiment_plans.inner_plans.udc_default_state import (
-    UDCDefaultDevices,
-    move_to_udc_default_state,
-)
 from mx_bluesky.common.external_interaction.alerting import (
     AlertService,
     get_alerting_service,
@@ -28,11 +24,16 @@ from mx_bluesky.common.utils.context import (
     device_composite_from_context,
     find_device_in_context,
 )
+from mx_bluesky.common.utils.exceptions import BeamlineCheckFailureError
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
     create_devices,
     load_centre_collect_full,
 )
+from mx_bluesky.hyperion.experiment_plans.udc_default_state import (
+    UDCDefaultDevices,
+    move_to_udc_default_state,
+)
 from mx_bluesky.hyperion.external_interaction.agamemnon import (
     create_parameters_from_agamemnon,
 )
@@ -100,7 +101,11 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
             runner: The runner
         """
         _raise_udc_start_alert(get_alerting_service())
-        yield from _move_to_udc_default_state(context)
+        yield from bpp.contingency_wrapper(
+            _move_to_udc_default_state(context),
+            except_plan=trap_default_state_exception,
+            auto_raise=False,
+        )
 
         # re-fetch the baton because the device has been reinstantiated
         baton = _get_baton(context)
@@ -121,8 +126,20 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
         yield from bps.abs_set(baton.current_user, NO_USER, wait=True)
         _raise_baton_released_alert(get_alerting_service(), previous_requested_user)
 
+    def trap_default_state_exception(e: Exception):
+        yield from bps.null()
+        if isinstance(e, BeamlineCheckFailureError):
+            LOGGER.warning("Caught default state check failure:", exc_info=e)
+            raise PlanError("Caught default state check failure") from e
+        else:
+            LOGGER.warning("Caught unexpected exception", exc_info=e)
+            raise PlanError("Unexpected exception from UDC Default State plan") from e
+
     def collect_then_release() -> MsgGenerator:
-        yield from bpp.contingency_wrapper(collect(), final_plan=release_baton)
+        yield from bpp.contingency_wrapper(
+            collect(),
+            final_plan=release_baton,
+        )
 
     context.run_engine(acquire_baton())
     _initialise_udc(context, runner.is_dev_mode)

mx_bluesky/hyperion/experiment_plans/pin_centre_then_xray_centre_plan.py

@@ -21,6 +21,10 @@ from mx_bluesky.common.experiment_plans.common_grid_detect_then_xray_centre_plan
 from mx_bluesky.common.experiment_plans.oav_snapshot_plan import (
     setup_beamline_for_oav,
 )
+from mx_bluesky.common.experiment_plans.pin_tip_centring_plan import (
+    PinTipCentringComposite,
+    pin_tip_centre_plan,
+)
 from mx_bluesky.common.external_interaction.callbacks.xray_centre.ispyb_callback import (
     ispyb_activation_wrapper,
 )
@@ -31,10 +35,6 @@ from mx_bluesky.common.xrc_result import XRayCentreEventHandler
 from mx_bluesky.hyperion.experiment_plans.hyperion_flyscan_xray_centre_plan import (
     construct_hyperion_specific_features,
 )
-from mx_bluesky.hyperion.experiment_plans.pin_tip_centring_plan import (
-    PinTipCentringComposite,
-    pin_tip_centre_plan,
-)
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.device_composites import (
     HyperionGridDetectThenXRayCentreComposite,
@@ -78,8 +78,7 @@ def pin_centre_then_flyscan_plan(
 
     pin_tip_centring_composite = PinTipCentringComposite(
         oav=composite.oav,
-        smargon=composite.smargon,
-        backlight=composite.backlight,
+        gonio=composite.smargon,
         pin_tip_detection=composite.pin_tip_detection,
     )
 

mx_bluesky/hyperion/experiment_plans/robot_load_and_change_energy.py

@@ -20,7 +20,7 @@ from dodal.devices.motors import XYZStage
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.robot import BartRobot, SampleLocation
 from dodal.devices.smargon import Smargon
-from dodal.devices.thawer import Thawer
+from dodal.devices.thawer import OnOff, Thawer
 from dodal.devices.webcam import Webcam
 from dodal.devices.xbpm_feedback import XBPMFeedback
 
@@ -82,7 +82,6 @@ def do_robot_load(
     sample_location: SampleLocation,
     sample_id: int,
     demand_energy_ev: float | None,
-    thawing_time: float,
 ):
     yield from bps.abs_set(composite.robot.next_sample_id, sample_id, wait=True)
 
@@ -96,13 +95,10 @@ def do_robot_load(
 
     yield from bps.wait("robot_load")
 
-    yield from bps.abs_set(
-        composite.thawer.thaw_for_time_s,
-        thawing_time,
-        group="thawing_finished",
-    )
     yield from wait_for_smargon_not_disabled(composite.smargon)
 
+    yield from bps.mv(composite.thawer, OnOff.ON)
+
 
 def pin_already_loaded(
     robot: BartRobot, sample_location: SampleLocation
@@ -120,7 +116,6 @@ def robot_load_and_snapshots(
     location: SampleLocation,
     snapshot_directory: Path,
     sample_id: int,
-    thawing_time: float,
     demand_energy_ev: float | None,
 ):
     yield from bps.abs_set(composite.backlight, InOut.IN, group="snapshot")
@@ -134,7 +129,6 @@ def robot_load_and_snapshots(
         location,
         sample_id,
         demand_energy_ev,
-        thawing_time,
     )
 
     gonio_finished = yield from do_plan_while_lower_gonio_at_home(
@@ -173,7 +167,6 @@ def robot_load_and_change_energy_plan(
                 sample_location,
                 params.snapshot_directory,
                 params.sample_id,
-                params.thawing_time,
                 params.demand_energy_ev,
             ),
             md={

mx_bluesky/hyperion/experiment_plans/robot_load_then_centre_plan.py

@@ -10,6 +10,7 @@ from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
+from dodal.devices.beamsize.beamsize import BeamsizeBase
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.fast_grid_scan import PandAFastGridScan, ZebraFastGridScanThreeD
@@ -26,7 +27,7 @@ from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import Smargon
 from dodal.devices.synchrotron import Synchrotron
 from dodal.devices.thawer import Thawer
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.webcam import Webcam
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import Zebra
@@ -70,6 +71,7 @@ class RobotLoadThenCentreComposite:
     # HyperionGridDetectThenXRayCentreComposite fields
     aperture_scatterguard: ApertureScatterguard
     backlight: Backlight
+    beamsize: BeamsizeBase
     detector_motion: DetectorMotion
     eiger: EigerDetector
     zebra_fast_grid_scan: ZebraFastGridScanThreeD
@@ -79,7 +81,7 @@ class RobotLoadThenCentreComposite:
     smargon: Smargon
     synchrotron: Synchrotron
     s4_slit_gaps: S4SlitGaps
-    undulator: Undulator
+    undulator: UndulatorInKeV
     zebra: Zebra
     zocalo: ZocaloResults
     panda: HDFPanda

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -10,6 +10,7 @@ from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.backlight import Backlight
+from dodal.devices.beamsize.beamsize import BeamsizeBase
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
@@ -21,7 +22,8 @@ from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.smargon import CombinedMove, Smargon
 from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.undulator import Undulator
+from dodal.devices.thawer import Thawer
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import RotationDirection, Zebra
 from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
@@ -74,6 +76,7 @@ class RotationScanComposite(OavSnapshotComposite):
     aperture_scatterguard: ApertureScatterguard
     attenuator: BinaryFilterAttenuator
     backlight: Backlight
+    beamsize: BeamsizeBase
     beamstop: Beamstop
     dcm: DCM
     detector_motion: DetectorMotion
@@ -81,13 +84,14 @@ class RotationScanComposite(OavSnapshotComposite):
     flux: Flux
     robot: BartRobot
     smargon: Smargon
-    undulator: Undulator
+    undulator: UndulatorInKeV
     synchrotron: Synchrotron
     s4_slit_gaps: S4SlitGaps
     sample_shutter: ZebraShutter
     zebra: Zebra
     oav: OAV
     xbpm_feedback: XBPMFeedback
+    thawer: Thawer
 
 
 def create_devices(context: BlueskyContext) -> RotationScanComposite:
@@ -258,6 +262,7 @@ def rotation_scan_plan(
             composite.aperture_scatterguard,
             params.selected_aperture,
             composite.backlight,
+            composite.thawer,
             group=CONST.WAIT.ROTATION_READY_FOR_DC,
         )
 
@@ -301,6 +306,7 @@ def rotation_scan_plan(
             composite.flux,
             composite.dcm,
             composite.eiger,
+            composite.beamsize,
         )
 
     yield from _rotation_scan_plan(motion_values, composite)

mx_bluesky/hyperion/experiment_plans/set_energy_plan.py

@@ -12,7 +12,7 @@ from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
 from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
 from dodal.devices.i03.dcm import DCM
 from dodal.devices.i03.undulator_dcm import UndulatorDCM
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 
 from mx_bluesky.common.parameters.constants import PlanNameConstants
@@ -39,7 +39,7 @@ class SetEnergyComposite:
 # Remove composite after https://github.com/DiamondLightSource/dodal/issues/1092
 @pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class XBPMWrapperComposite:
-    undulator: Undulator
+    undulator: UndulatorInKeV
     xbpm_feedback: XBPMFeedback
     attenuator: BinaryFilterAttenuator
     dcm: DCM

mx_bluesky/hyperion/experiment_plans/udc_default_state.py

@@ -0,0 +1,160 @@
+import bluesky.plan_stubs as bps
+import pydantic
+from bluesky.utils import MsgGenerator
+from dodal.common.beamlines.beamline_parameters import (
+    get_beamline_parameters,
+)
+from dodal.devices.aperturescatterguard import ApertureValue
+from dodal.devices.collimation_table import CollimationTable
+from dodal.devices.cryostream import CryoStream, CryoStreamGantry, CryoStreamSelection
+from dodal.devices.cryostream import InOut as CryoInOut
+from dodal.devices.fluorescence_detector_motion import FluorescenceDetector
+from dodal.devices.fluorescence_detector_motion import InOut as FlouInOut
+from dodal.devices.hutch_shutter import HutchShutter, ShutterDemand
+from dodal.devices.mx_phase1.beamstop import BeamstopPositions
+from dodal.devices.robot import BartRobot, PinMounted
+from dodal.devices.scintillator import InOut as ScinInOut
+from dodal.devices.scintillator import Scintillator
+from dodal.devices.smargon import Smargon
+from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutterState
+
+from mx_bluesky.common.experiment_plans.beamstop_check import (
+    BeamstopCheckDevices,
+    move_beamstop_in_and_verify_using_diode,
+)
+from mx_bluesky.common.utils.exceptions import BeamlineCheckFailureError
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
+)
+from mx_bluesky.hyperion.parameters.constants import HyperionFeatureSettings
+
+_GROUP_PRE_BEAMSTOP_CHECK = "pre_beamstop_check"
+_GROUP_POST_BEAMSTOP_CHECK = "post_beamstop_check"
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class UDCDefaultDevices(BeamstopCheckDevices):
+    collimation_table: CollimationTable
+    cryostream: CryoStream
+    cryostream_gantry: CryoStreamGantry
+    fluorescence_det_motion: FluorescenceDetector
+    hutch_shutter: HutchShutter
+    robot: BartRobot
+    scintillator: Scintillator
+    smargon: Smargon
+
+
+class UnexpectedSampleError(BeamlineCheckFailureError): ...
+
+
+class CryoStreamError(BeamlineCheckFailureError): ...
+
+
+def move_to_udc_default_state(devices: UDCDefaultDevices):
+    """Moves beamline to known positions prior to UDC start"""
+    yield from _verify_correct_cryostream_selected(devices.cryostream_gantry)
+
+    cryostream_temp = yield from bps.rd(devices.cryostream.temperature_k)
+    cryostream_pressure = yield from bps.rd(devices.cryostream.back_pressure_bar)
+    if cryostream_temp > devices.cryostream.MAX_TEMP_K:
+        raise CryoStreamError("Cryostream temperature is too high, not starting UDC")
+    if cryostream_pressure > devices.cryostream.MAX_PRESSURE_BAR:
+        raise CryoStreamError("Cryostream back pressure is too high, not starting UDC")
+
+    yield from _verify_no_sample_present(devices.robot)
+
+    # Close fast shutter before opening hutch shutter
+    yield from bps.abs_set(devices.sample_shutter, ZebraShutterState.CLOSE, wait=True)
+
+    commissioning_mode_enabled = yield from bps.rd(devices.baton.commissioning)
+
+    if commissioning_mode_enabled:
+        LOGGER.warning("Not opening hutch shutter - commissioning mode is enabled.")
+    else:
+        yield from bps.abs_set(
+            devices.hutch_shutter, ShutterDemand.OPEN, group=_GROUP_PRE_BEAMSTOP_CHECK
+        )
+
+    yield from bps.abs_set(devices.scintillator.selected_pos, ScinInOut.OUT, wait=True)
+
+    yield from bps.abs_set(
+        devices.fluorescence_det_motion.pos,
+        FlouInOut.OUT,
+        group=_GROUP_PRE_BEAMSTOP_CHECK,
+    )
+
+    yield from bps.abs_set(
+        devices.collimation_table.inboard_y,
+        0,
+        group=_GROUP_PRE_BEAMSTOP_CHECK,
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.outboard_y, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.upstream_y, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.upstream_x, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.collimation_table.downstream_x, 0, group=_GROUP_PRE_BEAMSTOP_CHECK
+    )
+
+    # Wait for all of the above to complete
+    yield from bps.wait(group=_GROUP_PRE_BEAMSTOP_CHECK, timeout=0.1)
+
+    feature_flags: HyperionFeatureSettings = (
+        get_hyperion_config_client().get_feature_flags()
+    )
+    if feature_flags.BEAMSTOP_DIODE_CHECK:
+        beamline_parameters = get_beamline_parameters()
+        config_client = get_hyperion_config_client()
+        features_settings: HyperionFeatureSettings = config_client.get_feature_flags()
+        detector_min_z = features_settings.DETECTOR_DISTANCE_LIMIT_MIN_MM
+        detector_max_z = features_settings.DETECTOR_DISTANCE_LIMIT_MAX_MM
+        yield from move_beamstop_in_and_verify_using_diode(
+            devices, beamline_parameters, detector_min_z, detector_max_z
+        )
+    else:
+        yield from bps.abs_set(
+            devices.beamstop.selected_pos, BeamstopPositions.DATA_COLLECTION, wait=True
+        )
+
+    yield from bps.abs_set(
+        devices.aperture_scatterguard.selected_aperture,
+        ApertureValue.SMALL,
+        group=_GROUP_POST_BEAMSTOP_CHECK,
+    )
+
+    yield from bps.abs_set(
+        devices.cryostream.course, CryoInOut.IN, group=_GROUP_POST_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.cryostream.fine, CryoInOut.IN, group=_GROUP_POST_BEAMSTOP_CHECK
+    )
+
+    yield from bps.wait(_GROUP_POST_BEAMSTOP_CHECK)
+
+
+def _verify_correct_cryostream_selected(
+    cryostream_gantry: CryoStreamGantry,
+) -> MsgGenerator:
+    cryostream_selection = yield from bps.rd(cryostream_gantry.cryostream_selector)
+    cryostream_selected = yield from bps.rd(cryostream_gantry.cryostream_selected)
+    if cryostream_selection != CryoStreamSelection.CRYOJET or cryostream_selected != 1:
+        raise CryoStreamError(
+            f"Cryostream is not selected for use, control PV selection = {cryostream_selection}, "
+            f"current status {cryostream_selected}"
+        )
+
+
+def _verify_no_sample_present(robot: BartRobot):
+    pin_mounted = yield from bps.rd(robot.gonio_pin_sensor)
+
+    if pin_mounted != PinMounted.NO_PIN_MOUNTED:
+        # Cannot unload this sample because we do not know the correct visit for it
+        raise UnexpectedSampleError(
+            "An unexpected sample was found, please unload the sample manually."
+        )

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -220,7 +220,7 @@ def _get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
 def _get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
     try:
         first_collection: dict = parameters["collection"][0]
-        wavelength = first_collection.get("wavelength")
+        wavelength: float | None = first_collection.get("wavelength")
         assert isinstance(wavelength, float)
         demand_energy_ev = convert_angstrom_to_ev(wavelength)
         return {"demand_energy_ev": demand_energy_ev}

mx_bluesky/hyperion/external_interaction/callbacks/rotation/ispyb_callback.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Sequence
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from dodal.devices.zocalo import ZocaloStartInfo
 
@@ -92,7 +92,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
             ISPYB_ZOCALO_CALLBACK_LOGGER.info("Beginning ispyb deposition")
             data_collection_group_info = populate_data_collection_group(self.params)
             data_collection_info = populate_data_collection_info_for_rotation(
-                cast(SingleRotationScan, self.params)
+                self.params
             )
             data_collection_info = populate_remaining_data_collection_info(
                 self.params.comment,

mx_bluesky/hyperion/external_interaction/callbacks/rotation/ispyb_mapping.py

@@ -6,6 +6,7 @@ from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 def populate_data_collection_info_for_rotation(params: SingleRotationScan):
     info = DataCollectionInfo(
+        chi_start=params.chi_start_deg,
         omega_start=params.omega_start_deg,
         data_collection_number=params.detector_params.run_number,  # type:ignore # the validator always makes this int
         n_images=params.num_images,

mx_bluesky/hyperion/external_interaction/callbacks/rotation/nexus_callback.py

@@ -2,9 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-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,
 )
@@ -14,7 +11,7 @@ from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
     vds_type_based_on_bit_depth,
 )
 from mx_bluesky.common.external_interaction.nexus.write_nexus import NexusWriter
-from mx_bluesky.common.utils.log import NEXUS_LOGGER
+from mx_bluesky.common.utils.log import NEXUS_LOGGER, format_doc_for_log
 from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 

mx_bluesky/hyperion/external_interaction/config_server.py

@@ -2,15 +2,15 @@ from functools import cache
 
 from mx_bluesky.common.external_interaction.config_server import MXConfigClient
 from mx_bluesky.hyperion.parameters.constants import (
-    HyperionFeatureSetting,
-    HyperionFeatureSettingSources,
+    HyperionFeatureSettings,
+    HyperionFeatureSettingsSources,
 )
 
 
 @cache
-def get_hyperion_config_client() -> MXConfigClient[HyperionFeatureSetting]:
+def get_hyperion_config_client() -> MXConfigClient[HyperionFeatureSettings]:
     return MXConfigClient(
-        feature_sources=HyperionFeatureSettingSources,
-        feature_dc=HyperionFeatureSetting,
+        feature_sources=HyperionFeatureSettingsSources,
+        feature_dc=HyperionFeatureSettings,
         url="https://daq-config.diamond.ac.uk",
     )

mx_bluesky/hyperion/parameters/constants.py

@@ -8,7 +8,7 @@ from mx_bluesky.common.parameters.constants import (
     DocDescriptorNames,
     EnvironmentConstants,
     ExperimentParamConstants,
-    FeatureSetting,
+    FeatureSettings,
     FeatureSettingSources,
     HardwareConstants,
     OavConstants,
@@ -32,20 +32,27 @@ class I03Constants:
 
 
 # These currently exist in GDA domain.properties
-class HyperionFeatureSettingSources(FeatureSettingSources):
+class HyperionFeatureSettingsSources(FeatureSettingSources):
     USE_GPU_RESULTS = "gda.mx.hyperion.xrc.use_gpu_results"
     USE_PANDA_FOR_GRIDSCAN = "gda.mx.hyperion.use_panda_for_gridscans"
     SET_STUB_OFFSETS = "gda.mx.hyperion.do_stub_offsets"
     PANDA_RUNUP_DISTANCE_MM = "gda.mx.hyperion.panda_runup_distance_mm"
+    DETECTOR_DISTANCE_LIMIT_MAX_MM = "gda.detector.distance.limit.max"
+    DETECTOR_DISTANCE_LIMIT_MIN_MM = "gda.detector.distance.limit.min"
+    BEAMSTOP_DIODE_CHECK = "gda.mx.hyperion.enable_beamstop_diode_check"
 
 
 # Use these defaults if we can't read from the config server
 @dataclass
-class HyperionFeatureSetting(FeatureSetting):
+class HyperionFeatureSettings(FeatureSettings):
     USE_GPU_RESULTS: bool = True
     USE_PANDA_FOR_GRIDSCAN: bool = False
     SET_STUB_OFFSETS: bool = False
     PANDA_RUNUP_DISTANCE_MM: float = 0.16
+    # From GDA mx-config hutch_utilities.py default values
+    DETECTOR_DISTANCE_LIMIT_MAX_MM: float = 700
+    DETECTOR_DISTANCE_LIMIT_MIN_MM: float = 250
+    BEAMSTOP_DIODE_CHECK: bool = False
 
 
 @dataclass(frozen=True)

mx_bluesky/hyperion/parameters/device_composites.py

@@ -16,7 +16,7 @@ from dodal.devices.flux import Flux
 from dodal.devices.robot import BartRobot
 from dodal.devices.s4_slit_gaps import S4SlitGaps
 from dodal.devices.synchrotron import Synchrotron
-from dodal.devices.undulator import Undulator
+from dodal.devices.undulator import UndulatorInKeV
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import Zebra
 from dodal.devices.zebra.zebra_controlled_shutter import ZebraShutter
@@ -41,7 +41,7 @@ class HyperionFlyScanXRayCentreComposite(FlyScanEssentialDevices):
     eiger: EigerDetector
     flux: Flux
     s4_slit_gaps: S4SlitGaps
-    undulator: Undulator
+    undulator: UndulatorInKeV
     synchrotron: Synchrotron
     zebra: Zebra
     zocalo: ZocaloResults