mx-bluesky 1.2.0__py3-none-any.whl → 1.4.1a0__py3-none-any.whl

mx_bluesky/hyperion/experiment_plans/robot_load_then_centre_plan.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
-import dataclasses
 from typing import cast
 
-from blueapi.core import BlueskyContext, MsgGenerator
+import bluesky.preprocessors as bpp
+import pydantic
+from blueapi.core import BlueskyContext
+from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.backlight import Backlight
@@ -12,7 +14,7 @@ from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.fast_grid_scan import PandAFastGridScan, ZebraFastGridScan
 from dodal.devices.flux import Flux
-from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, VFMMirrorVoltages
+from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
 from dodal.devices.motors import XYZPositioner
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -31,15 +33,23 @@ from dodal.devices.zocalo import ZocaloResults
 from dodal.log import LOGGER
 from ophyd_async.fastcs.panda import HDFPanda
 
+from mx_bluesky.common.parameters.constants import OavConstants
+from mx_bluesky.common.parameters.gridscan import RobotLoadThenCentre
 from mx_bluesky.hyperion.device_setup_plans.utils import (
     fill_in_energy_if_not_supplied,
     start_preparing_data_collection_then_do_plan,
 )
+from mx_bluesky.hyperion.experiment_plans.change_aperture_then_move_plan import (
+    change_aperture_then_move_to_xtal,
+)
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    XRayCentreEventHandler,
+)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     GridDetectThenXRayCentreComposite,
 )
 from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
-    pin_centre_then_xray_centre_plan,
+    pin_centre_then_flyscan_plan,
 )
 from mx_bluesky.hyperion.experiment_plans.robot_load_and_change_energy import (
     RobotLoadAndEnergyChangeComposite,
@@ -47,10 +57,9 @@ from mx_bluesky.hyperion.experiment_plans.robot_load_and_change_energy import (
     robot_load_and_change_energy_plan,
 )
 from mx_bluesky.hyperion.parameters.constants import CONST
-from mx_bluesky.hyperion.parameters.gridscan import RobotLoadThenCentre
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class RobotLoadThenCentreComposite:
     # common fields
     xbpm_feedback: XBPMFeedback
@@ -78,7 +87,7 @@ class RobotLoadThenCentreComposite:
 
     # SetEnergyComposite fields
     vfm: FocusingMirrorWithStripes
-    vfm_mirror_voltages: VFMMirrorVoltages
+    mirror_voltages: MirrorVoltages
     dcm: DCM
     undulator_dcm: UndulatorDCM
 
@@ -87,6 +96,10 @@ class RobotLoadThenCentreComposite:
     webcam: Webcam
     lower_gonio: XYZPositioner
 
+    @property
+    def sample_motors(self):
+        return self.smargon
+
 
 def create_devices(context: BlueskyContext) -> RobotLoadThenCentreComposite:
     from mx_bluesky.hyperion.utils.context import device_composite_from_context
@@ -94,32 +107,57 @@ def create_devices(context: BlueskyContext) -> RobotLoadThenCentreComposite:
     return device_composite_from_context(context, RobotLoadThenCentreComposite)
 
 
-def centring_plan_from_robot_load_params(
+def _flyscan_plan_from_robot_load_params(
     composite: RobotLoadThenCentreComposite,
     params: RobotLoadThenCentre,
+    oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
 ):
-    yield from pin_centre_then_xray_centre_plan(
+    yield from pin_centre_then_flyscan_plan(
         cast(GridDetectThenXRayCentreComposite, composite),
         params.pin_centre_then_xray_centre_params(),
     )
 
 
-def robot_load_then_centre_plan(
+def _robot_load_then_flyscan_plan(
     composite: RobotLoadThenCentreComposite,
     params: RobotLoadThenCentre,
+    oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
 ):
     yield from robot_load_and_change_energy_plan(
         cast(RobotLoadAndEnergyChangeComposite, composite),
         params.robot_load_params(),
     )
 
-    yield from centring_plan_from_robot_load_params(composite, params)
+    yield from _flyscan_plan_from_robot_load_params(composite, params, oav_config_file)
 
 
 def robot_load_then_centre(
     composite: RobotLoadThenCentreComposite,
     parameters: RobotLoadThenCentre,
 ) -> MsgGenerator:
+    """Perform pin-tip detection followed by a flyscan to determine centres of interest.
+    Performs a robot load if necessary. Centre on the best diffracting centre.
+    """
+
+    xray_centre_event_handler = XRayCentreEventHandler()
+
+    yield from bpp.subs_wrapper(
+        robot_load_then_xray_centre(composite, parameters), xray_centre_event_handler
+    )
+    flyscan_results = xray_centre_event_handler.xray_centre_results
+    if flyscan_results is not None:
+        yield from change_aperture_then_move_to_xtal(
+            flyscan_results[0], composite.smargon, composite.aperture_scatterguard
+        )
+    # else no chi change, no need to recentre.
+
+
+def robot_load_then_xray_centre(
+    composite: RobotLoadThenCentreComposite,
+    parameters: RobotLoadThenCentre,
+) -> MsgGenerator:
+    """Perform pin-tip detection followed by a flyscan to determine centres of interest.
+    Performs a robot load if necessary."""
     eiger: EigerDetector = composite.eiger
 
     # TODO: get these from one source of truth #254
@@ -135,13 +173,13 @@ def robot_load_then_centre(
     doing_chi_change = parameters.chi_start_deg is not None
 
     if doing_sample_load:
-        plan = robot_load_then_centre_plan(
+        plan = _robot_load_then_flyscan_plan(
             composite,
             parameters,
         )
         LOGGER.info("Pin not loaded, loading and centring")
     elif doing_chi_change:
-        plan = centring_plan_from_robot_load_params(composite, parameters)
+        plan = _flyscan_plan_from_robot_load_params(composite, parameters)
         LOGGER.info("Pin already loaded but chi changed so centring")
     else:
         LOGGER.info("Pin already loaded and chi not changed so doing nothing")

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -4,7 +4,9 @@ import dataclasses
 
 import bluesky.plan_stubs as bps
 import bluesky.preprocessors as bpp
-from blueapi.core import BlueskyContext, MsgGenerator
+import pydantic
+from blueapi.core import BlueskyContext
+from bluesky.utils import MsgGenerator
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.backlight import Backlight
@@ -22,8 +24,11 @@ from dodal.devices.undulator import Undulator
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra import RotationDirection, Zebra
 from dodal.devices.zebra_controlled_shutter import ZebraShutter
-from dodal.plans.check_topup import check_topup_and_wait_if_necessary
+from dodal.plan_stubs.check_topup import check_topup_and_wait_if_necessary
 
+from mx_bluesky.common.device_setup_plans.read_hardware_for_setup import (
+    read_hardware_for_zocalo,
+)
 from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
     cleanup_sample_environment,
     move_phi_chi_omega,
@@ -32,7 +37,6 @@ from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
 )
 from mx_bluesky.hyperion.device_setup_plans.read_hardware_for_setup import (
     read_hardware_during_collection,
-    read_hardware_for_zocalo,
     read_hardware_pre_collection,
 )
 from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
@@ -60,7 +64,7 @@ from mx_bluesky.hyperion.parameters.rotation import (
 from mx_bluesky.hyperion.utils.context import device_composite_from_context
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class RotationScanComposite(OavSnapshotComposite):
     """All devices which are directly or indirectly required by this plan"""
 
@@ -252,7 +256,7 @@ def rotation_scan_plan(
             composite.undulator,
             composite.synchrotron,
             composite.s4_slit_gaps,
-            composite.robot,
+            composite.dcm,
             composite.smargon,
         )
 
@@ -327,6 +331,13 @@ def _move_and_rotation(
         yield from setup_beamline_for_OAV(
             composite.smargon, composite.backlight, composite.aperture_scatterguard
         )
+        yield from bps.wait(group=CONST.WAIT.READY_FOR_OAV)
+        if params.selected_aperture:
+            yield from bps.abs_set(
+                composite.aperture_scatterguard.aperture_outside_beam,
+                params.selected_aperture,
+                group=CONST.WAIT.ROTATION_READY_FOR_DC,
+            )
         yield from oav_snapshot_plan(composite, params, oav_params)
     yield from rotation_scan_plan(
         composite,
@@ -348,7 +359,7 @@ def rotation_scan(
         md={
             "subplan_name": CONST.PLAN.ROTATION_OUTER,
             CONST.TRIGGER.ZOCALO: CONST.PLAN.ROTATION_MAIN,
-            "zocalo_environment": parameters.zocalo_environment,
+            "zocalo_environment": CONST.ZOCALO_ENV,
             "hyperion_parameters": parameters.model_dump_json(),
             "activate_callbacks": [
                 "RotationISPyBCallback",
@@ -379,7 +390,7 @@ def rotation_scan(
             rotation_with_cleanup_and_stage(params),
             group=CONST.WAIT.ROTATION_READY_FOR_DC,
         )
-        yield from bps.unstage(eiger)
+        yield from bps.unstage(eiger)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
     yield from rotation_scan_plan_with_stage_and_cleanup(parameters)
 
@@ -407,6 +418,11 @@ def multi_rotation_scan(
         }
     )
     @bpp.stage_decorator([eiger])
+    @transmission_and_xbpm_feedback_for_collection_decorator(
+        composite.xbpm_feedback,
+        composite.attenuator,
+        parameters.transmission_frac,
+    )
     @bpp.finalize_decorator(lambda: _cleanup_plan(composite))
     def _multi_rotation_scan():
         for single_scan in parameters.single_rotation_scans:
@@ -416,6 +432,7 @@ def multi_rotation_scan(
                 md={
                     "subplan_name": CONST.PLAN.ROTATION_OUTER,
                     CONST.TRIGGER.ZOCALO: CONST.PLAN.ROTATION_MAIN,
+                    "zocalo_environment": CONST.ZOCALO_ENV,
                     "hyperion_parameters": single_scan.model_dump_json(),
                 }
             )

mx_bluesky/hyperion/experiment_plans/set_energy_plan.py

@@ -5,12 +5,11 @@
 * reenable feedback
 """
 
-import dataclasses
-
+import pydantic
 from bluesky import plan_stubs as bps
 from dodal.devices.attenuator import Attenuator
 from dodal.devices.dcm import DCM
-from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, VFMMirrorVoltages
+from dodal.devices.focusing_mirror import FocusingMirrorWithStripes, MirrorVoltages
 from dodal.devices.undulator_dcm import UndulatorDCM
 from dodal.devices.xbpm_feedback import XBPMFeedback
 
@@ -24,10 +23,10 @@ DESIRED_TRANSMISSION_FRACTION = 0.1
 UNDULATOR_GROUP = "UNDULATOR_GROUP"
 
 
-@dataclasses.dataclass
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
 class SetEnergyComposite:
     vfm: FocusingMirrorWithStripes
-    vfm_mirror_voltages: VFMMirrorVoltages
+    mirror_voltages: MirrorVoltages
     dcm: DCM
     undulator_dcm: UndulatorDCM
     xbpm_feedback: XBPMFeedback
@@ -42,7 +41,7 @@ def _set_energy_plan(
     yield from dcm_pitch_roll_mirror_adjuster.adjust_dcm_pitch_roll_vfm_from_lut(
         composite.undulator_dcm,
         composite.vfm,
-        composite.vfm_mirror_voltages,
+        composite.mirror_voltages,
         energy_kev,
     )
     yield from bps.wait(group=UNDULATOR_GROUP)

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -7,6 +7,7 @@ from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
 from dodal.log import LOGGER as dodal_logger
 from dodal.log import set_up_all_logging_handlers
 
+from mx_bluesky.common.utils.log import _get_logging_dir, tag_filter
 from mx_bluesky.hyperion.external_interaction.callbacks.log_uid_tag_callback import (
     LogUidTaggingCallback,
 )
@@ -31,8 +32,6 @@ from mx_bluesky.hyperion.external_interaction.callbacks.zocalo_callback import (
 from mx_bluesky.hyperion.log import (
     ISPYB_LOGGER,
     NEXUS_LOGGER,
-    _get_logging_dir,
-    tag_filter,
 )
 from mx_bluesky.hyperion.parameters.cli import parse_callback_dev_mode_arg
 from mx_bluesky.hyperion.parameters.constants import CONST

mx_bluesky/hyperion/external_interaction/callbacks/common/abstract_event.py

@@ -0,0 +1,66 @@
+import builtins
+import dataclasses
+import time
+from abc import ABC
+from typing import Literal
+
+from bluesky.protocols import Readable, Reading
+from event_model import DataKey
+
+
+@dataclasses.dataclass(frozen=True)
+class AbstractEvent(Readable, ABC):
+    """An abstract superclass that can be extended to provide lightweight software events
+    for bluesky plans, without having to incur the overhead of creating ophyd-async devices
+    specifically for the purpose.
+
+    The currently supported types for field annotations in the event are ``str``, ``int``, ``float``, ``bool``
+
+    In future array types may be supported.
+
+    Examples:
+        Subclasses should extend this class and decorate with::
+
+            @dataclasses.dataclass(frozen=True)
+
+        To raise an event, simply construct the event and then ``read`` it as you would a device::
+
+            yield from bps.create("MY_EVENT_NAME")
+            my_event = MyEvent(an_int=1)
+            yield from bps.read(my_event)
+            yield from bps.save()
+    """
+
+    def read(self) -> dict[str, Reading]:
+        return {
+            f.name: AbstractEvent._reading_from_value(getattr(self, f.name))
+            for f in dataclasses.fields(self)
+        }
+
+    def describe(self) -> dict[str, DataKey]:
+        return {
+            f.name: DataKey(dtype=AbstractEvent._dtype_of(f.type), shape=[], source="")
+            for f in dataclasses.fields(self)
+        }
+
+    @classmethod
+    def _reading_from_value(cls, value):
+        return Reading(timestamp=time.time(), value=value)
+
+    @classmethod
+    def _dtype_of(cls, t) -> Literal["string", "number", "boolean", "integer"]:
+        match t:
+            case builtins.str:
+                return "string"
+            case builtins.bool:
+                return "boolean"
+            case builtins.int:
+                return "integer"
+            case builtins.float:
+                return "number"
+        # TODO array support
+        raise ValueError(f"Unsupported type for AbstractEvent: {t}")
+
+    @property
+    def name(self) -> str:
+        return type(self).__name__

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from mx_bluesky.common.parameters.components import DiffractionExperimentWithSample
 from mx_bluesky.hyperion.external_interaction.ispyb.data_model import (
     DataCollectionGroupInfo,
     DataCollectionInfo,
@@ -11,7 +12,6 @@ from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
 from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_utils import (
     get_current_time_string,
 )
-from mx_bluesky.hyperion.parameters.components import DiffractionExperimentWithSample
 
 
 def populate_data_collection_group(params: DiffractionExperimentWithSample):

mx_bluesky/hyperion/external_interaction/callbacks/grid_detection_callback.py

@@ -2,7 +2,6 @@ from typing import TypedDict
 
 import numpy as np
 from bluesky.callbacks import CallbackBase
-from dodal.devices.oav.oav_detector import OAVConfigParams
 from dodal.devices.oav.utils import calculate_x_y_z_of_pixel
 from event_model.documents import Event
 
@@ -26,21 +25,19 @@ class GridParamUpdate(TypedDict):
 class GridDetectionCallback(CallbackBase):
     def __init__(
         self,
-        oav_params: OAVConfigParams,
         *args,
     ) -> None:
         super().__init__(*args)
-        self.oav_params = oav_params
-        self.start_positions: list = []
+        self.start_positions_mm: list = []
         self.box_numbers: list = []
 
     def event(self, doc: Event):
         data = doc.get("data")
-        top_left_x_px = data["oav_grid_snapshot_top_left_x"]
-        box_width_px = data["oav_grid_snapshot_box_width"]
+        top_left_x_px = data["oav-grid_snapshot-top_left_x"]
+        box_width_px = data["oav-grid_snapshot-box_width"]
         x_of_centre_of_first_box_px = top_left_x_px + box_width_px / 2
 
-        top_left_y_px = data["oav_grid_snapshot_top_left_y"]
+        top_left_y_px = data["oav-grid_snapshot-top_left_y"]
         y_of_centre_of_first_box_px = top_left_y_px + box_width_px / 2
 
         smargon_omega = data["smargon-omega"]
@@ -53,36 +50,44 @@ class GridDetectionCallback(CallbackBase):
             y_of_centre_of_first_box_px,
         )
 
-        position_grid_start = calculate_x_y_z_of_pixel(
-            current_xyz, smargon_omega, centre_of_first_box, self.oav_params
-        )
+        microns_per_pixel_x = data["oav-microns_per_pixel_x"]
+        microns_per_pixel_y = data["oav-microns_per_pixel_y"]
+        beam_x = data["oav-beam_centre_i"]
+        beam_y = data["oav-beam_centre_j"]
 
-        LOGGER.info(f"Calculated start position {position_grid_start}")
+        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),
+        )
+        LOGGER.info(f"Calculated start position {position_grid_start_mm}")
 
-        self.start_positions.append(position_grid_start)
+        self.start_positions_mm.append(position_grid_start_mm)
         self.box_numbers.append(
             (
-                data["oav_grid_snapshot_num_boxes_x"],
-                data["oav_grid_snapshot_num_boxes_y"],
+                data["oav-grid_snapshot-num_boxes_x"],
+                data["oav-grid_snapshot-num_boxes_y"],
             )
         )
 
-        self.x_step_size_mm = box_width_px * self.oav_params.micronsPerXPixel / 1000
-        self.y_step_size_mm = box_width_px * self.oav_params.micronsPerYPixel / 1000
-        self.z_step_size_mm = box_width_px * self.oav_params.micronsPerYPixel / 1000
+        self.x_step_size_um = box_width_px * microns_per_pixel_x
+        self.y_step_size_um = box_width_px * microns_per_pixel_y
+        self.z_step_size_um = box_width_px * microns_per_pixel_y
         return doc
 
     def get_grid_parameters(self) -> GridParamUpdate:
         return {
-            "x_start_um": self.start_positions[0][0],
-            "y_start_um": self.start_positions[0][1],
-            "y2_start_um": self.start_positions[0][1],
-            "z_start_um": self.start_positions[1][2],
-            "z2_start_um": self.start_positions[1][2],
+            "x_start_um": self.start_positions_mm[0][0] * 1000,
+            "y_start_um": self.start_positions_mm[0][1] * 1000,
+            "y2_start_um": self.start_positions_mm[0][1] * 1000,
+            "z_start_um": self.start_positions_mm[1][2] * 1000,
+            "z2_start_um": self.start_positions_mm[1][2] * 1000,
             "x_steps": self.box_numbers[0][0],
             "y_steps": self.box_numbers[0][1],
             "z_steps": self.box_numbers[1][1],
-            "x_step_size_um": self.x_step_size_mm,
-            "y_step_size_um": self.y_step_size_mm,
-            "z_step_size_um": self.z_step_size_mm,
+            "x_step_size_um": self.x_step_size_um,
+            "y_step_size_um": self.y_step_size_um,
+            "z_step_size_um": self.z_step_size_um,
         }

mx_bluesky/hyperion/external_interaction/callbacks/ispyb_callback_base.py

@@ -5,9 +5,12 @@ from collections.abc import Callable, Sequence
 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.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.common.utils.log import set_dcgid_tag
 from mx_bluesky.hyperion.external_interaction.callbacks.plan_reactive_callback import (
     PlanReactiveCallback,
 )
@@ -21,8 +24,7 @@ from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
     StoreInIspyb,
 )
 from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_utils import get_ispyb_config
-from mx_bluesky.hyperion.log import ISPYB_LOGGER, set_dcgid_tag
-from mx_bluesky.hyperion.parameters.components import DiffractionExperimentWithSample
+from mx_bluesky.hyperion.log import ISPYB_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.utils.utils import convert_eV_to_angstrom
 
@@ -33,6 +35,25 @@ if TYPE_CHECKING:
     from event_model.documents import Event, EventDescriptor, RunStart, RunStop
 
 
+def _update_based_on_energy(
+    doc: Event,
+    detector_params: DetectorParams,
+    data_collection_info: DataCollectionInfo,
+):
+    """If energy has been read as part of this reading then add it into the data
+    collection info along with the other fields that depend on it."""
+    if energy_kev := doc["data"].get("dcm-energy_in_kev", None):
+        energy_ev = energy_kev * 1000
+        wavelength_angstroms = convert_eV_to_angstrom(energy_ev)
+        data_collection_info.wavelength = wavelength_angstroms
+        data_collection_info.resolution = resolution(
+            detector_params,
+            wavelength_angstroms,
+            detector_params.detector_distance,
+        )
+    return data_collection_info
+
+
 class BaseISPyBCallback(PlanReactiveCallback):
     def __init__(
         self,
@@ -109,6 +130,9 @@ class BaseISPyBCallback(PlanReactiveCallback):
             slitgap_horizontal=doc["data"]["s4_slit_gaps_xgap"],
             slitgap_vertical=doc["data"]["s4_slit_gaps_ygap"],
         )
+        hwscan_data_collection_info = _update_based_on_energy(
+            doc, self.params.detector_params, hwscan_data_collection_info
+        )
         hwscan_position_info = DataCollectionPositionInfo(
             pos_x=float(doc["data"]["smargon-x"]),
             pos_y=float(doc["data"]["smargon-y"]),
@@ -137,16 +161,9 @@ class BaseISPyBCallback(PlanReactiveCallback):
         if transmission := doc["data"]["attenuator-actual_transmission"]:
             # Ispyb wants the transmission in a percentage, we use fractions
             hwscan_data_collection_info.transmission = transmission * 100
-        event_energy = doc["data"]["dcm-energy_in_kev"]
-        if event_energy:
-            energy_ev = event_energy * 1000
-            wavelength_angstroms = convert_eV_to_angstrom(energy_ev)
-            hwscan_data_collection_info.wavelength = wavelength_angstroms
-            hwscan_data_collection_info.resolution = resolution(
-                self.params.detector_params,
-                wavelength_angstroms,
-                self.params.detector_params.detector_distance,
-            )
+        hwscan_data_collection_info = _update_based_on_energy(
+            doc, self.params.detector_params, hwscan_data_collection_info
+        )
         scan_data_infos = self.populate_info_for_update(
             hwscan_data_collection_info, None, self.params
         )

mx_bluesky/hyperion/external_interaction/callbacks/log_uid_tag_callback.py

@@ -1,7 +1,7 @@
 from bluesky.callbacks import CallbackBase
 from event_model import RunStart, RunStop
 
-from mx_bluesky.hyperion.log import set_uid_tag
+from mx_bluesky.common.utils.log import set_uid_tag
 
 
 class LogUidTaggingCallback(CallbackBase):

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

@@ -62,7 +62,7 @@ class RobotLoadISPyBCallback(PlanReactiveCallback):
                 self.action_id is not None
             ), "ISPyB Robot load callback event called unexpectedly"
             barcode = doc["data"]["robot-barcode"]
-            oav_snapshot = doc["data"]["oav_snapshot_last_saved_path"]
+            oav_snapshot = doc["data"]["oav-snapshot-last_saved_path"]
             webcam_snapshot = doc["data"]["webcam-last_saved_path"]
             # I03 uses webcam/oav snapshots in place of before/after snapshots
             self.expeye.update_barcode_and_snapshots(

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

@@ -3,6 +3,8 @@ from __future__ import annotations
 from collections.abc import Callable, Sequence
 from typing import TYPE_CHECKING, Any, cast
 
+from mx_bluesky.common.parameters.components import IspybExperimentType
+from mx_bluesky.common.utils.log import set_dcgid_tag
 from mx_bluesky.hyperion.external_interaction.callbacks.common.ispyb_mapping import (
     populate_data_collection_group,
     populate_remaining_data_collection_info,
@@ -22,8 +24,7 @@ from mx_bluesky.hyperion.external_interaction.ispyb.ispyb_store import (
     IspybIds,
     StoreInIspyb,
 )
-from mx_bluesky.hyperion.log import ISPYB_LOGGER, set_dcgid_tag
-from mx_bluesky.hyperion.parameters.components import IspybExperimentType
+from mx_bluesky.hyperion.log import ISPYB_LOGGER
 from mx_bluesky.hyperion.parameters.constants import CONST
 from mx_bluesky.hyperion.parameters.rotation import RotationScan
 
@@ -60,7 +61,9 @@ class RotationISPyBCallback(BaseISPyBCallback):
             ISPYB_LOGGER.info(
                 "ISPyB callback received start document with experiment parameters."
             )
-            self.params = RotationScan.from_json(doc.get("hyperion_parameters"))
+            hyperion_params = doc.get("hyperion_parameters")
+            assert isinstance(hyperion_params, str)
+            self.params = RotationScan.model_validate_json(hyperion_params)
             dcgid = (
                 self.ispyb_ids.data_collection_group_id
                 if (self.params.sample_id == self.last_sample_id)
@@ -157,7 +160,7 @@ class RotationISPyBCallback(BaseISPyBCallback):
         data_collection_info = DataCollectionInfo(
             **{
                 f"xtal_snapshot{self._oav_snapshot_event_idx}": data.get(
-                    "oav_snapshot_last_saved_path"
+                    "oav-snapshot-last_saved_path"
                 )
             }
         )

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

@@ -78,12 +78,14 @@ class RotationNexusFileCallback(PlanReactiveCallback):
             self.meta_data_run_number = doc.get("meta_data_run_number")
         if doc.get("subplan_name") == CONST.PLAN.ROTATION_OUTER:
             self.run_uid = doc.get("uid")
-            json_params = doc.get("hyperion_parameters")
+            hyperion_params = doc.get("hyperion_parameters")
+            assert isinstance(hyperion_params, str)
             NEXUS_LOGGER.info(
-                f"Nexus writer received start document with experiment parameters {json_params}"
+                f"Nexus writer received start document with experiment parameters {hyperion_params}"
             )
-            parameters = RotationScan.from_json(json_params)
+            parameters = RotationScan.model_validate_json(hyperion_params)
             NEXUS_LOGGER.info("Setting up nexus file...")
+
             det_size = (
                 parameters.detector_params.detector_size_constants.det_size_pixels
             )