mx-bluesky 1.5.11__py3-none-any.whl → 1.5.14__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/hyperion_flyscan_xray_centre_plan.py

@@ -63,6 +63,7 @@ def construct_hyperion_specific_features(
         xrc_composite.flux.flux_reading,
         xrc_composite.dcm.energy_in_keV,
         xrc_composite.eiger.bit_depth,
+        xrc_composite.beamsize,
     ]
 
     setup_trigger_plan: Callable[..., MsgGenerator]

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,166 @@
+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 (
+    CryoStreamGantry,
+    CryoStreamSelection,
+    OxfordCryoJet,
+    OxfordCryoStream,
+)
+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 CONST, 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
+    cryojet: OxfordCryoJet
+    cryostream: OxfordCryoStream
+    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.temp)
+    cryostream_pressure = yield from bps.rd(devices.cryostream.back_pressure)
+    if cryostream_temp > CONST.HARDWARE.MAX_CRYO_TEMP_K:
+        raise CryoStreamError("Cryostream temperature is too high, not starting UDC")
+    if cryostream_pressure > CONST.HARDWARE.MAX_CRYO_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.cryojet.coarse, CryoInOut.IN, group=_GROUP_POST_BEAMSTOP_CHECK
+    )
+    yield from bps.abs_set(
+        devices.cryojet.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/__main__.py

@@ -2,6 +2,8 @@ import logging
 from collections.abc import Callable, Sequence
 from threading import Thread
 from time import sleep  # noqa
+from urllib import request
+from urllib.error import URLError
 
 from bluesky.callbacks import CallbackBase
 from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
@@ -51,14 +53,17 @@ from mx_bluesky.hyperion.external_interaction.callbacks.snapshot_callback import
     BeamDrawingCallback,
 )
 from mx_bluesky.hyperion.parameters.cli import parse_callback_dev_mode_arg
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.constants import CONST, HyperionConstants
 from mx_bluesky.hyperion.parameters.gridscan import (
     GridCommonWithHyperionDetectorParams,
     HyperionSpecifiedThreeDGridScan,
 )
 
+PING_TIMEOUT_S = 1
+
 LIVENESS_POLL_SECONDS = 1
 ERROR_LOG_BUFFER_LINES = 5000
+HYPERION_PING_INTERVAL_S = 19
 
 
 def create_gridscan_callbacks() -> tuple[
@@ -128,21 +133,6 @@ def setup_logging(dev_mode: bool):
     log_debug("nexgen logger added to nexus logger")
 
 
-def setup_threads():
-    proxy = Proxy(*CONST.CALLBACK_0MQ_PROXY_PORTS)
-    dispatcher = RemoteDispatcher(f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[1]}")
-    log_debug("Created proxy and dispatcher objects")
-
-    def start_proxy():
-        proxy.start()
-
-    def start_dispatcher(callbacks: list[Callable]):
-        [dispatcher.subscribe(cb) for cb in callbacks]
-        dispatcher.start()
-
-    return proxy, dispatcher, start_proxy, start_dispatcher
-
-
 def log_info(msg, *args, **kwargs):
     ISPYB_ZOCALO_CALLBACK_LOGGER.info(msg, *args, **kwargs)
     NEXUS_LOGGER.info(msg, *args, **kwargs)
@@ -175,20 +165,57 @@ class HyperionCallbackRunner:
         set_alerting_service(LoggingAlertService(CONST.GRAYLOG_STREAM_ID))
 
         self.callbacks = setup_callbacks()
-        self.proxy, self.dispatcher, start_proxy, start_dispatcher = setup_threads()
-        log_info("Created 0MQ proxy and local RemoteDispatcher.")
 
-        self.proxy_thread = Thread(target=start_proxy, daemon=True)
+        self.proxy = Proxy(*CONST.CALLBACK_0MQ_PROXY_PORTS)
+        self.proxy_thread = Thread(
+            target=self.proxy.start, daemon=True, name="0MQ Proxy"
+        )
+
+        self.dispatcher = RemoteDispatcher(
+            f"localhost:{CONST.CALLBACK_0MQ_PROXY_PORTS[1]}"
+        )
+
+        def start_dispatcher(callbacks: list[Callable]):
+            for cb in callbacks:
+                self.dispatcher.subscribe(cb)
+            self.dispatcher.start()
+
         self.dispatcher_thread = Thread(
-            target=start_dispatcher, args=[self.callbacks], daemon=True
+            target=start_dispatcher,
+            args=[self.callbacks],
+            daemon=True,
+            name="0MQ Dispatcher",
         )
 
+        self.watchdog_thread = Thread(target=run_watchdog, daemon=True, name="Watchdog")
+        log_info("Created 0MQ proxy and local RemoteDispatcher.")
+
     def start(self):
         log_info(f"Launching threads, with callbacks: {self.callbacks}")
         self.proxy_thread.start()
         self.dispatcher_thread.start()
+        self.watchdog_thread.start()
         log_info("Proxy and dispatcher thread launched.")
-        wait_for_threads_forever([self.proxy_thread, self.dispatcher_thread])
+        wait_for_threads_forever(
+            [self.proxy_thread, self.dispatcher_thread, self.watchdog_thread]
+        )
+
+
+def run_watchdog():
+    log_info("Hyperion watchdog keepalive running")
+    while True:
+        try:
+            with request.urlopen(
+                f"http://localhost:{HyperionConstants.HYPERION_PORT}/callbackPing",
+                timeout=PING_TIMEOUT_S,
+            ) as response:
+                if response.status != 200:
+                    log_debug(
+                        f"Unable to ping Hyperion liveness endpoint, status {response.status}"
+                    )
+        except URLError as e:
+            log_debug("Unable to ping Hyperion liveness endpoint", exc_info=e)
+        sleep(HYPERION_PING_INTERVAL_S)
 
 
 def main(dev_mode=False) -> None:

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,