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

mx_bluesky/common/utils/utils.py

@@ -4,23 +4,25 @@ from math import asin
 from scanspec.core import AxesPoints, Axis
 from scipy.constants import physical_constants
 
-hc_in_eV_and_Angstrom: float = (
+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]
     * 1e10  # Angstroms per metre
 )
 
 
-def interconvert_eV_Angstrom(wavelength_or_energy: float) -> float:
-    return hc_in_eV_and_Angstrom / wavelength_or_energy
+def interconvert_ev_angstrom(wavelength_or_energy: float) -> float:
+    return hc_in_ev_and_angstrom / wavelength_or_energy
 
 
-def convert_eV_to_angstrom(hv: float) -> float:
-    return interconvert_eV_Angstrom(hv)
+def convert_ev_to_angstrom(hv: float) -> float:
+    return interconvert_ev_angstrom(hv)
 
 
-def convert_angstrom_to_eV(wavelength: float) -> float:
-    return interconvert_eV_Angstrom(wavelength)
+def convert_angstrom_to_ev(wavelength: float) -> float:
+    return interconvert_ev_angstrom(wavelength)
 
 
 def number_of_frames_from_scan_spec(scan_points: AxesPoints[Axis]):
@@ -37,6 +39,52 @@ def energy_to_bragg_angle(energy_kev: float, d_a: float) -> float:
     Returns:
         The bragg angle in degrees
     """
-    wavelength_a = convert_eV_to_angstrom(energy_kev * 1000)
+    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

@@ -22,7 +22,7 @@ from mx_bluesky.common.utils.log import (
 from mx_bluesky.hyperion.baton_handler import run_forever
 from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
-    PlanNotFound,
+    PlanNotFoundError,
 )
 from mx_bluesky.hyperion.external_interaction.agamemnon import (
     compare_params,
@@ -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 PlanNotFound(f"Experiment plan '{plan_name}' not found in registry.")
+        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 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))
         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)
@@ -115,7 +105,7 @@ class StopOrStatus(Resource):
         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__}"
+                f"Runner received status request - state of the runner object is: {self.runner.__dict__} - state of the run_engine is: {self.runner.run_engine.__dict__}"
             )
             status_and_message = self.runner.current_status
         return asdict(status_and_message)

mx_bluesky/hyperion/baton_handler.py

@@ -9,15 +9,12 @@ from bluesky.utils import MsgGenerator, RunEngineInterrupted
 from dodal.common.beamlines.commissioning_mode import set_commissioning_signal
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.baton import Baton
+from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 from dodal.devices.motors import XYZStage
 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,
@@ -27,18 +24,23 @@ 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,
 )
 from mx_bluesky.hyperion.external_interaction.alerting.constants import Subjects
 from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.plan_runner import PlanException, PlanRunner
+from mx_bluesky.hyperion.plan_runner import PlanError, PlanRunner
 from mx_bluesky.hyperion.utils.context import (
     clear_all_device_caches,
     setup_devices,
@@ -53,7 +55,7 @@ def run_forever(runner: PlanRunner):
         while True:
             try:
                 run_udc_when_requested(runner.context, runner)
-            except PlanException as e:
+            except PlanError as e:
                 LOGGER.info(
                     "Caught exception during plan execution, stopped and waiting for baton.",
                     exc_info=e,
@@ -64,7 +66,7 @@ def run_forever(runner: PlanRunner):
         # RunEngine.abort() will have been called and we will get RunEngineInterrupted
         LOGGER.info(
             f"RunEngine was interrupted. Runner state is {runner.current_status}, "
-            f"run engine is {runner.RE.state}"
+            f"run engine is {runner.run_engine.state}"
         )
 
 
@@ -93,13 +95,17 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
         * A user requests the baton away from Hyperion
         * Hyperion releases the baton when Agamemnon has no more instructions
         * The RunEngine raises a RequestAbort exception, most likely due to a shutdown command
-        * A plan raises an exception not of type WarningException (which is then wrapped as a PlanException)
+        * A plan raises an exception not of type WarningError (which is then wrapped as a PlanError)
         Args:
             baton: The baton device
             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)
@@ -109,7 +115,7 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
                 baton, runner, current_visit
             )
         if current_visit:
-            yield from _perform_robot_unload(runner.context, current_visit)
+            yield from _clean_up_udc(runner.context, current_visit)
 
     def release_baton() -> MsgGenerator:
         # If hyperion has given up the baton itself we need to also release requested
@@ -120,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)
@@ -145,13 +163,13 @@ def _initialise_udc(context: BlueskyContext, dev_mode: bool):
 
 def _wait_for_hyperion_requested(baton: Baton):
     LOGGER.debug("Hyperion waiting for baton...")
-    SLEEP_PER_CHECK = 0.1
+    sleep_per_check = 0.1
     while True:
         requested_user = yield from bps.rd(baton.requested_user)
         if requested_user == HYPERION_USER:
             LOGGER.debug("Baton requested for Hyperion")
             break
-        yield from bps.sleep(SLEEP_PER_CHECK)
+        yield from bps.sleep(sleep_per_check)
 
 
 def _fetch_and_process_agamemnon_instruction(
@@ -239,11 +257,17 @@ def _unrequest_baton(baton: Baton) -> MsgGenerator[str]:
     return requested_user
 
 
-def _perform_robot_unload(context: BlueskyContext, visit: str) -> MsgGenerator:
+def _clean_up_udc(context: BlueskyContext, visit: str) -> MsgGenerator:
+    cleanup_group = "cleanup"
     robot = find_device_in_context(context, "robot", BartRobot)
     smargon = find_device_in_context(context, "smargon", Smargon)
     aperture_scatterguard = find_device_in_context(
         context, "aperture_scatterguard", ApertureScatterguard
     )
     lower_gonio = find_device_in_context(context, "lower_gonio", XYZStage)
+    detector_motion = find_device_in_context(context, "detector_motion", DetectorMotion)
+    yield from bps.abs_set(
+        detector_motion.shutter, ShutterState.CLOSED, group=cleanup_group
+    )
     yield from robot_unload(robot, smargon, aperture_scatterguard, lower_gonio, visit)
+    yield from bps.wait(cleanup_group)

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -7,6 +7,6 @@ from dodal.devices.i03.dcm import DCM
 
 def fill_in_energy_if_not_supplied(dcm: DCM, detector_params: DetectorParams):
     if not detector_params.expected_energy_ev:
-        actual_energy_ev = 1000 * (yield from bps.rd(dcm.energy_in_kev))
+        actual_energy_ev = 1000 * (yield from bps.rd(dcm.energy_in_keV))
         detector_params.expected_energy_ev = actual_energy_ev
     return detector_params

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -57,5 +57,5 @@ PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
 }
 
 
-class PlanNotFound(Exception):
+class PlanNotFoundError(Exception):
     pass

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

@@ -15,7 +15,7 @@ from mx_bluesky.common.device_setup_plans.setup_zebra_and_shutter import (
     tidy_up_zebra_after_gridscan,
 )
 from mx_bluesky.common.experiment_plans.common_flyscan_xray_centre_plan import (
-    construct_beamline_specific_FGS_features,
+    construct_beamline_specific_fast_gridscan_features,
 )
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.device_setup_plans.setup_panda import (
@@ -35,7 +35,7 @@ from mx_bluesky.hyperion.parameters.device_composites import (
 from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
 
 
-class SmargonSpeedException(Exception):
+class SmargonSpeedError(Exception):
     pass
 
 
@@ -54,14 +54,14 @@ def construct_hyperion_specific_features(
         xrc_composite.smargon.x,
         xrc_composite.smargon.y,
         xrc_composite.smargon.z,
-        xrc_composite.dcm.energy_in_kev,
+        xrc_composite.dcm.energy_in_keV,
     ]
 
     signals_to_read_during_collection = [
         xrc_composite.aperture_scatterguard,
         xrc_composite.attenuator.actual_transmission,
         xrc_composite.flux.flux_reading,
-        xrc_composite.dcm.energy_in_kev,
+        xrc_composite.dcm.energy_in_keV,
         xrc_composite.eiger.bit_depth,
     ]
 
@@ -73,7 +73,7 @@ def construct_hyperion_specific_features(
         set_flyscan_params_plan = partial(
             set_fast_grid_scan_params,
             xrc_composite.panda_fast_grid_scan,
-            xrc_parameters.panda_FGS_params,
+            xrc_parameters.panda_fast_gridscan_params,
         )
         fgs_motors = xrc_composite.panda_fast_grid_scan
 
@@ -91,10 +91,10 @@ def construct_hyperion_specific_features(
         set_flyscan_params_plan = partial(
             set_fast_grid_scan_params,
             xrc_composite.zebra_fast_grid_scan,
-            xrc_parameters.FGS_params,
+            xrc_parameters.fast_gridscan_params,
         )
         fgs_motors = xrc_composite.zebra_fast_grid_scan
-    return construct_beamline_specific_FGS_features(
+    return construct_beamline_specific_fast_gridscan_features(
         setup_trigger_plan,
         tidy_plan,
         set_flyscan_params_plan,
@@ -126,21 +126,23 @@ def _panda_triggering_setup(
         xrc_composite.panda_fast_grid_scan.run_up_distance_mm
     )
 
-    DETECTOR_DEADTIME_S = 1e-4  # This value was empirically found to be safer than the documented deadtime in the Eiger manual
+    detector_deadtime_s = 1e-4  # This value was empirically found to be safer than the documented deadtime in the Eiger manual
 
-    time_between_x_steps_ms = (DETECTOR_DEADTIME_S + parameters.exposure_time_s) * 1e3
+    time_between_x_steps_ms = (detector_deadtime_s + parameters.exposure_time_s) * 1e3
 
     smargon_speed_limit_mm_per_s = yield from bps.rd(
         xrc_composite.smargon.x.max_velocity
     )
 
     sample_velocity_mm_per_s = (
-        parameters.panda_FGS_params.x_step_size_mm * 1e3 / time_between_x_steps_ms
+        parameters.panda_fast_gridscan_params.x_step_size_mm
+        * 1e3
+        / time_between_x_steps_ms
     )
     if sample_velocity_mm_per_s > smargon_speed_limit_mm_per_s:
-        raise SmargonSpeedException(
+        raise SmargonSpeedError(
             f"Smargon speed was calculated from x step size\
-            {parameters.panda_FGS_params.x_step_size_mm}mm and\
+            {parameters.panda_fast_gridscan_params.x_step_size_mm}mm and\
             time_between_x_steps_ms {time_between_x_steps_ms} as\
             {sample_velocity_mm_per_s}mm/s. The smargon's speed limit is\
             {smargon_speed_limit_mm_per_s}mm/s."
@@ -161,7 +163,7 @@ def _panda_triggering_setup(
 
     yield from setup_panda_for_flyscan(
         xrc_composite.panda,
-        parameters.panda_FGS_params,
+        parameters.panda_fast_gridscan_params,
         xrc_composite.smargon,
         parameters.exposure_time_s,
         time_between_x_steps_ms,

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -14,7 +14,7 @@ from dodal.devices.oav.oav_parameters import OAVParameters
 import mx_bluesky.common.xrc_result as flyscan_result
 from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.utils.context import device_composite_from_context
-from mx_bluesky.common.utils.exceptions import CrystalNotFoundException
+from mx_bluesky.common.utils.exceptions import CrystalNotFoundError
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.xrc_result import XRayCentreEventHandler
 from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
@@ -93,7 +93,7 @@ def load_centre_collect_full(
                 ),
                 flyscan_event_handler,
             )
-        except CrystalNotFoundException:
+        except CrystalNotFoundError:
             if parameters.select_centres.ignore_xtal_not_found:
                 LOGGER.info("Ignoring crystal not found due to parameter settings.")
             else:

mx_bluesky/hyperion/experiment_plans/optimise_attenuation_plan.py

@@ -13,7 +13,7 @@ from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
 
 
-class AttenuationOptimisationFailedException(Exception):
+class AttenuationOptimisationFailedError(Exception):
     pass
 
 
@@ -59,7 +59,7 @@ def check_parameters(
 
     if upper_transmission < lower_transmission:
         raise ValueError(
-            f"Upper transmission limit {upper_transmission} must be greater than lower tranmission limit {lower_transmission}"
+            f"Upper transmission limit {upper_transmission} must be greater than lower transmission limit {lower_transmission}"
         )
 
     if not upper_transmission >= initial_transmission >= lower_transmission:
@@ -80,7 +80,7 @@ def calculate_new_direction(direction: Direction, deadtime, deadtime_threshold):
         if deadtime > deadtime_threshold:
             direction = Direction.NEGATIVE
             LOGGER.info(
-                "Found tranmission to go above deadtime threshold. Reducing transmission..."
+                "Found transmission to go above deadtime threshold. Reducing transmission..."
             )
     return direction
 
@@ -111,7 +111,7 @@ def deadtime_calc_new_transmission(
         Minimum expected transmission. Raise an error if transmission goes lower.
 
     Raises:
-        AttenuationOptimisationFailedException:
+        AttenuationOptimisationFailedError:
         This error is thrown if the transmission goes below the expected value or if the maximum cycles are reached
 
     Returns:
@@ -124,7 +124,7 @@ def deadtime_calc_new_transmission(
     else:
         transmission /= increment
     if transmission < lower_transmission_limit:
-        raise AttenuationOptimisationFailedException(
+        raise AttenuationOptimisationFailedError(
             "Calculated transmission is below expected limit"
         )
     return transmission
@@ -218,7 +218,7 @@ def deadtime_optimisation(
         Minimum expected transmission. Raise an error if transmission goes lower.
 
     Raises:
-        AttenuationOptimisationFailedException:
+        AttenuationOptimisationFailedError:
         This error is thrown if the transmission goes below the expected value or the maximum cycles are reached
 
     Returns:
@@ -262,7 +262,7 @@ def deadtime_optimisation(
             break
 
         if cycle == max_cycles - 1:
-            raise AttenuationOptimisationFailedException(
+            raise AttenuationOptimisationFailedError(
                 f"Unable to optimise attenuation after maximum cycles.\
                                                             Deadtime did not get lower than threshold: {deadtime_threshold} in maximum cycles {max_cycles}"
             )
@@ -367,12 +367,12 @@ def total_counts_optimisation(
             if transmission > upper_transmission_limit:
                 transmission = upper_transmission_limit
             elif transmission < lower_transmission_limit:
-                raise AttenuationOptimisationFailedException(
+                raise AttenuationOptimisationFailedError(
                     f"Transmission has gone below lower threshold {lower_transmission_limit}"
                 )
 
         if cycle == max_cycles - 1:
-            raise AttenuationOptimisationFailedException(
+            raise AttenuationOptimisationFailedError(
                 f"Unable to optimise attenuation after maximum cycles.\
                                                             Total count is not within limits: {lower_count_limit} <= {total_count}\
                                                                 <= {upper_count_limit}"

mx_bluesky/hyperion/experiment_plans/pin_centre_then_xray_centre_plan.py

@@ -19,7 +19,11 @@ from mx_bluesky.common.experiment_plans.common_grid_detect_then_xray_centre_plan
     detect_grid_and_do_gridscan,
 )
 from mx_bluesky.common.experiment_plans.oav_snapshot_plan import (
-    setup_beamline_for_OAV,
+    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,13 +78,12 @@ 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,
     )
 
     def _pin_centre_then_flyscan_plan():
-        yield from setup_beamline_for_OAV(
+        yield from setup_beamline_for_oav(
             composite.smargon, composite.backlight, composite.aperture_scatterguard
         )
 

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