mx-bluesky 1.5.1__py3-none-any.whl → 1.5.3__py3-none-any.whl

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -1,5 +1,4 @@
 import bluesky.plan_stubs as bps
-from bluesky.utils import MsgGenerator
 from dodal.devices.zebra.zebra import (
     ArmDemand,
     EncEnum,
@@ -12,9 +11,11 @@ from dodal.devices.zebra.zebra_controlled_shutter import (
     ZebraShutterControl,
 )
 
+from mx_bluesky.common.parameters.constants import ZEBRA_STATUS_TIMEOUT
 from mx_bluesky.common.utils.log import LOGGER
-
-ZEBRA_STATUS_TIMEOUT = 30
+from mx_bluesky.phase1_zebra.device_setup_plans.setup_zebra import (
+    configure_zebra_and_shutter_for_auto_shutter,
+)
 
 
 def arm_zebra(zebra: Zebra):
@@ -35,47 +36,6 @@ def tidy_up_zebra_after_rotation_scan(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-def set_shutter_auto_input(zebra: Zebra, input: int, group="set_shutter_trigger"):
-    """Set the signal that controls the shutter. We use the second input to the
-    Zebra's AND2 gate for this input. ZebraShutter control mode must be in auto for this input to take control
-
-    For more details see the ZebraShutter device."""
-    auto_gate = zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER
-    auto_shutter_control = zebra.logic_gates.and_gates[auto_gate]
-    yield from bps.abs_set(auto_shutter_control.sources[2], input, group)
-
-
-def configure_zebra_and_shutter_for_auto_shutter(
-    zebra: Zebra, zebra_shutter: ZebraShutter, input: int, group="use_automatic_shutter"
-):
-    """Set the shutter to auto mode, and configure the zebra to trigger the shutter on
-    an input source. For the input, use one of the source constants in zebra.py
-
-    When the shutter is in auto/manual, logic in EPICS sets the Zebra's
-    SOFT_IN1 to low/high respectively. The Zebra's AND2 gate should be used to control the shutter while in auto mode.
-    To do this, we need (AND2 = SOFT_IN1 AND input), where input is the zebra signal we want to control the shutter when in auto mode.
-    """
-    # See https://github.com/DiamondLightSource/dodal/issues/813 for better typing here.
-
-    # Set shutter to auto mode
-    yield from bps.abs_set(
-        zebra_shutter.control_mode, ZebraShutterControl.AUTO, group=group
-    )
-
-    auto_gate = zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER
-
-    # Set first input of AND2 gate to SOFT_IN1, which is high when shutter is in auto mode
-    # Note the Zebra should ALWAYS be setup this way. See https://github.com/DiamondLightSource/mx-bluesky/issues/551
-    yield from bps.abs_set(
-        zebra.logic_gates.and_gates[auto_gate].sources[1],
-        zebra.mapping.sources.SOFT_IN1,
-        group=group,
-    )
-
-    # Set the second input of AND2 gate to the requested zebra input source
-    yield from set_shutter_auto_input(zebra, input, group=group)
-
-
 def setup_zebra_for_rotation(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -155,55 +115,6 @@ def setup_zebra_for_rotation(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-def setup_zebra_for_gridscan(
-    zebra: Zebra,
-    zebra_shutter: ZebraShutter,
-    group="setup_zebra_for_gridscan",
-    wait=True,
-):
-    # Set shutter to automatic and to trigger via motion controller GPIO signal (IN4_TTL)
-    yield from configure_zebra_and_shutter_for_auto_shutter(
-        zebra, zebra_shutter, zebra.mapping.sources.IN4_TTL, group=group
-    )
-
-    yield from bps.abs_set(
-        zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR],
-        zebra.mapping.sources.IN3_TTL,
-        group=group,
-    )
-    yield from bps.abs_set(
-        zebra.output.out_pvs[zebra.mapping.outputs.TTL_XSPRESS3],
-        zebra.mapping.sources.DISCONNECT,
-        group=group,
-    )
-    yield from bps.abs_set(
-        zebra.output.pulse_1.input, zebra.mapping.sources.DISCONNECT, group=group
-    )
-
-    if wait:
-        yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
-
-
-def tidy_up_zebra_after_gridscan(
-    zebra: Zebra,
-    zebra_shutter: ZebraShutter,
-    group="tidy_up_zebra_after_gridscan",
-    wait=True,
-) -> MsgGenerator:
-    yield from bps.abs_set(
-        zebra.output.out_pvs[zebra.mapping.outputs.TTL_DETECTOR],
-        zebra.mapping.sources.PC_PULSE,
-        group=group,
-    )
-    yield from bps.abs_set(
-        zebra_shutter.control_mode, ZebraShutterControl.MANUAL, group=group
-    )
-    yield from set_shutter_auto_input(zebra, zebra.mapping.sources.PC_GATE, group=group)
-
-    if wait:
-        yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
-
-
 def setup_zebra_for_panda_flyscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from functools import partial
 from pathlib import Path
 
@@ -19,14 +20,19 @@ from mx_bluesky.hyperion.device_setup_plans.setup_panda import (
     setup_panda_for_flyscan,
 )
 from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
-    setup_zebra_for_gridscan,
     setup_zebra_for_panda_flyscan,
-    tidy_up_zebra_after_gridscan,
+)
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
 )
 from mx_bluesky.hyperion.parameters.device_composites import (
     HyperionFlyScanXRayCentreComposite,
 )
 from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
+from mx_bluesky.phase1_zebra.device_setup_plans.setup_zebra import (
+    setup_zebra_for_gridscan,
+    tidy_up_zebra_after_gridscan,
+)
 
 
 class SmargonSpeedException(Exception):
@@ -59,9 +65,11 @@ def construct_hyperion_specific_features(
         xrc_composite.eiger.bit_depth,
     ]
 
-    if xrc_parameters.features.use_panda_for_gridscan:
+    setup_trigger_plan: Callable[..., MsgGenerator]
+
+    if get_hyperion_config_client().get_feature_flags().USE_PANDA_FOR_GRIDSCAN:
         setup_trigger_plan = _panda_triggering_setup
-        tidy_plan = _panda_tidy
+        tidy_plan = partial(_panda_tidy, xrc_composite)
         set_flyscan_params_plan = partial(
             set_fast_grid_scan_params,
             xrc_composite.panda_fast_grid_scan,
@@ -70,8 +78,14 @@ def construct_hyperion_specific_features(
         fgs_motors = xrc_composite.panda_fast_grid_scan
 
     else:
-        setup_trigger_plan = _zebra_triggering_setup
-        tidy_plan = partial(_generic_tidy, group="flyscan_zebra_tidy", wait=True)
+        setup_trigger_plan = setup_zebra_for_gridscan
+        tidy_plan = partial(
+            tidy_up_zebra_after_gridscan,
+            xrc_composite.zebra,
+            xrc_composite.sample_shutter,
+            group="flyscan_zebra_tidy",
+            wait=True,
+        )
         set_flyscan_params_plan = partial(
             set_fast_grid_scan_params,
             xrc_composite.zebra_fast_grid_scan,
@@ -89,46 +103,17 @@ def construct_hyperion_specific_features(
     )
 
 
-def _generic_tidy(
-    xrc_composite: HyperionFlyScanXRayCentreComposite, group, wait=True
-) -> MsgGenerator:
-    LOGGER.info("Tidying up Zebra")
-    yield from tidy_up_zebra_after_gridscan(
-        xrc_composite.zebra, xrc_composite.sample_shutter, group=group, wait=wait
-    )
-    LOGGER.info("Tidying up Zocalo")
-    # make sure we don't consume any other results
-    yield from bps.unstage(xrc_composite.zocalo, group=group, wait=wait)
-
-    # Turn off dev/shm streaming to avoid filling disk, see https://github.com/DiamondLightSource/hyperion/issues/1395
-    LOGGER.info("Turning off Eiger dev/shm streaming")
-    # Fix types in ophyd-async (https://github.com/DiamondLightSource/mx-bluesky/issues/855)
-    yield from bps.abs_set(
-        xrc_composite.eiger.odin.fan.dev_shm_enable,  # type: ignore
-        0,
-        group=group,
-        wait=wait,
-    )
-
-
 def _panda_tidy(xrc_composite: HyperionFlyScanXRayCentreComposite):
     group = "panda_flyscan_tidy"
     LOGGER.info("Disabling panda blocks")
     yield from disarm_panda_for_gridscan(xrc_composite.panda, group)
-    yield from _generic_tidy(xrc_composite, group, False)
+    yield from tidy_up_zebra_after_gridscan(
+        xrc_composite.zebra, xrc_composite.sample_shutter, group=group, wait=False
+    )
     yield from bps.wait(group, timeout=10)
     yield from bps.unstage(xrc_composite.panda)
 
 
-def _zebra_triggering_setup(
-    xrc_composite: HyperionFlyScanXRayCentreComposite,
-    parameters: HyperionSpecifiedThreeDGridScan,
-) -> MsgGenerator:
-    yield from setup_zebra_for_gridscan(
-        xrc_composite.zebra, xrc_composite.sample_shutter, wait=True
-    )
-
-
 def _panda_triggering_setup(
     xrc_composite: HyperionFlyScanXRayCentreComposite,
     parameters: HyperionSpecifiedThreeDGridScan,

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -24,7 +24,10 @@ from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     RotationScanComposite,
     rotation_scan_internal,
 )
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.external_interaction.config_server import (
+    get_hyperion_config_client,
+)
+from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.parameters.rotation import RotationScanPerSweep
 
@@ -51,7 +54,8 @@ def load_centre_collect_full(
     * If X-ray centring finds a diffracting centre then move to that centre and
     * do a collection with the specified parameters.
     """
-    parameters.features.update_self_from_server()
+
+    get_hyperion_config_client().refresh_cache()
 
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
@@ -60,7 +64,11 @@ def load_centre_collect_full(
     @set_run_key_decorator(CONST.PLAN.LOAD_CENTRE_COLLECT)
     @run_decorator(
         md={
-            "metadata": {"sample_id": parameters.sample_id},
+            "metadata": {
+                "sample_id": parameters.sample_id,
+                "visit": parameters.visit,
+                "container": parameters.sample_puck,
+            },
             "activate_callbacks": ["BeamDrawingCallback", "SampleHandlingCallback"],
             "with_snapshot": parameters.multi_rotation_scan.model_dump_json(
                 include=WithSnapshot.model_fields.keys()  # type: ignore
@@ -117,7 +125,7 @@ def load_centre_collect_full(
 
         multi_rotation.rotation_scans.clear()
 
-        is_alternating = parameters.features.alternate_rotation_direction
+        is_alternating = I03Constants.ALTERNATE_ROTATION_DIRECTION
 
         generator = rotation_scan_generator(is_alternating)
         next(generator)

mx_bluesky/hyperion/experiment_plans/pin_tip_centring_plan.py

@@ -155,7 +155,7 @@ def pin_tip_centre_plan(
     tip = yield from move_pin_into_view(pin_tip_detect, smargon)
     yield from offset_and_move(tip)
 
-    yield from bps.mvr(smargon.omega, 90)
+    yield from bps.mvr(smargon.omega, -90)
 
     # need to wait for the OAV image to update
     # See #673 for improvements

mx_bluesky/hyperion/experiment_plans/rotation_scan_plan.py

@@ -37,16 +37,16 @@ from mx_bluesky.common.device_setup_plans.manipulate_sample import (
 from mx_bluesky.common.device_setup_plans.utils import (
     start_preparing_data_collection_then_do_plan,
 )
+from mx_bluesky.common.experiment_plans.inner_plans.read_hardware import (
+    read_hardware_for_zocalo,
+    standard_read_hardware_during_collection,
+    standard_read_hardware_pre_collection,
+)
 from mx_bluesky.common.experiment_plans.oav_snapshot_plan import (
     OavSnapshotComposite,
     oav_snapshot_plan,
     setup_beamline_for_OAV,
 )
-from mx_bluesky.common.experiment_plans.read_hardware import (
-    read_hardware_for_zocalo,
-    standard_read_hardware_during_collection,
-    standard_read_hardware_pre_collection,
-)
 from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.preprocessors.preprocessors import (
     transmission_and_xbpm_feedback_for_collection_decorator,
@@ -58,7 +58,7 @@ from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
     setup_zebra_for_rotation,
     tidy_up_zebra_after_rotation_scan,
 )
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.rotation import (
     RotationScan,
     SingleRotationScan,
@@ -133,7 +133,7 @@ def calculate_motion_profile(
     direction = params.rotation_direction
     start_scan_deg = params.omega_start_deg
 
-    if params.features.omega_flip:
+    if I03Constants.OMEGA_FLIP:
         # If omega_flip is True then the motor omega axis is inverted with respect to the
         # hyperion coordinate system.
         start_scan_deg = -start_scan_deg
@@ -386,7 +386,6 @@ def rotation_scan_internal(
     parameters: RotationScan,
     oav_params: OAVParameters | None = None,
 ) -> MsgGenerator:
-    parameters.features.update_self_from_server()
     if not oav_params:
         oav_params = OAVParameters(context="xrayCentring")
     eiger: EigerDetector = composite.eiger

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -3,6 +3,7 @@ import json
 import re
 import traceback
 from collections.abc import Sequence
+from enum import StrEnum
 from os import path
 from typing import Any, TypeVar
 
@@ -14,6 +15,7 @@ from pydantic_extra_types.semantic_version import SemanticVersion
 
 from mx_bluesky.common.parameters.components import (
     PARAMETER_VERSION,
+    MxBlueskyParameters,
     WithVisit,
 )
 from mx_bluesky.common.parameters.constants import (
@@ -21,6 +23,7 @@ from mx_bluesky.common.parameters.constants import (
 )
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.utils.utils import convert_angstrom_to_eV
+from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 
 T = TypeVar("T", bound=WithVisit)
@@ -31,8 +34,13 @@ MULTIPIN_REGEX = rf"^{MULTIPIN_PREFIX}_(\d+)x(\d+(?:\.\d+)?)\+(\d+(?:\.\d+)?)$"
 MX_GENERAL_ROOT_REGEX = r"^/dls/(?P<beamline>[^/]+)/data/[^/]*/(?P<visit>[^/]+)(?:/|$)"
 
 
+class _InstructionType(StrEnum):
+    WAIT = "wait"
+    COLLECT = "collect"
+
+
 @dataclasses.dataclass
-class PinType:
+class _PinType:
     expected_number_of_crystals: int
     single_well_width_um: float
     tip_to_first_well_um: float = 0
@@ -54,7 +62,7 @@ class PinType:
         )
 
 
-class SinglePin(PinType):
+class _SinglePin(_PinType):
     def __init__(self):
         super().__init__(1, GridscanParamConstants.WIDTH_UM)
 
@@ -63,23 +71,115 @@ class SinglePin(PinType):
         return self.single_well_width_um
 
 
+def create_parameters_from_agamemnon() -> Sequence[MxBlueskyParameters]:
+    """Fetch the next instruction from agamemnon and convert it into one or more
+    mx-bluesky instructions.
+    Returns:
+        The generated sequence of mx-bluesky parameters, or empty list if
+        no instructions."""
+    beamline_name = get_beamline_name("i03")
+    agamemnon_instruction = _get_next_instruction(beamline_name)
+    if agamemnon_instruction:
+        match _instruction_and_data(agamemnon_instruction):
+            case (_InstructionType.COLLECT, data):
+                return _populate_parameters_from_agamemnon(data)
+            case (_InstructionType.WAIT, data):
+                return [
+                    Wait.model_validate(
+                        {
+                            "duration_s": data,
+                            "parameter_model_version": _get_param_version(),
+                        }
+                    )
+                ]
+
+    return []
+
+
+def compare_params(load_centre_collect_params: LoadCentreCollect):
+    """Compare the supplied parameters (as supplied from GDA) with those directly
+    created from agamemnon. Any differences are logged.
+    Args:
+        load_centre_collect_params: The parameters from GDA to compare."""
+    try:
+        lcc_requests = create_parameters_from_agamemnon()
+        # Log differences against GDA populated parameters
+        if not lcc_requests:
+            LOGGER.info("Agamemnon returned no instructions")
+        else:
+            differences = DeepDiff(
+                lcc_requests[0], load_centre_collect_params, math_epsilon=1e-5
+            )
+            if differences:
+                LOGGER.info(
+                    f"Different parameters found when directly reading from Hyperion: {differences}"
+                )
+    except (ValueError, KeyError):
+        LOGGER.warning(f"Failed to compare parameters: {traceback.format_exc()}")
+    except Exception:
+        LOGGER.warning(
+            f"Unexpected error occurred. Failed to compare parameters: {traceback.format_exc()}"
+        )
+
+
+def update_params_from_agamemnon(parameters: T) -> T:
+    """Update the supplied parameters with additional information from agamemnon.
+    This is currently necessary for multipin processing and called when Hyperion is invoked
+    from GDA.
+
+    Args:
+        parameters: The LoadCentreCollectParameters that will be updated with additional info,
+        such as multipin dimensions, number of crystals.
+    """
+    try:
+        beamline_name = get_beamline_name("i03")
+        agamemnon_params = _get_next_instruction(beamline_name)
+        instruction, collect_params = _instruction_and_data(agamemnon_params)
+        assert instruction == _InstructionType.COLLECT, (
+            "Unable to augment GDA parameters from agamemnon, agamemnon reports 'wait'"
+        )
+        pin_type = _get_pin_type_from_agamemnon_collect_parameters(collect_params)
+        if isinstance(parameters, LoadCentreCollect):
+            parameters.robot_load_then_centre.tip_offset_um = pin_type.full_width / 2
+            parameters.robot_load_then_centre.grid_width_um = pin_type.full_width
+            parameters.select_centres.n = pin_type.expected_number_of_crystals
+            if pin_type != _SinglePin():
+                # Rotation snapshots will be generated from the gridscan snapshots,
+                # no need to specify snapshot omega.
+                parameters.multi_rotation_scan.snapshot_omegas_deg = []
+                parameters.multi_rotation_scan.use_grid_snapshots = True
+    except (ValueError, ValidationError) as e:
+        LOGGER.warning(f"Failed to update parameters: {e}")
+    except Exception as e:
+        LOGGER.warning(f"Unexpected error occurred. Failed to update parameters: {e}")
+
+    return parameters
+
+
+def _instruction_and_data(agamemnon_instruction: dict) -> tuple[str, Any]:
+    instruction, data = next(iter(agamemnon_instruction.items()))
+    if instruction not in _InstructionType.__members__.values():
+        raise KeyError(
+            f"Unexpected instruction from agamemnon: {agamemnon_instruction}"
+        )
+    return instruction, data
+
+
 def _get_parameters_from_url(url: str) -> dict:
     response = requests.get(url, headers={"Accept": "application/json"})
     response.raise_for_status()
-    response_json = json.loads(response.content)
-    try:
-        return response_json["collect"]
-    except KeyError as e:
-        raise KeyError(f"Unexpected json from agamemnon: {response_json}") from e
+    return json.loads(response.content)
 
 
-def get_pin_type_from_agamemnon_parameters(parameters: dict) -> PinType:
-    loop_type_name: str | None = parameters["sample"]["loopType"]
+def _get_pin_type_from_agamemnon_collect_parameters(
+    collect_parameters: dict,
+) -> _PinType:
+    loop_type_name: str | None = collect_parameters["sample"]["loopType"]
     if loop_type_name:
         regex_search = re.search(MULTIPIN_REGEX, loop_type_name)
         if regex_search:
             wells, well_size, tip_to_first_well = regex_search.groups()
-            return PinType(int(wells), float(well_size), float(tip_to_first_well))
+            return _PinType(int(wells), float(well_size), float(tip_to_first_well))
         else:
             loop_type_message = (
                 f"Agamemnon loop type of {loop_type_name} not recognised"
@@ -87,14 +187,14 @@ def get_pin_type_from_agamemnon_parameters(parameters: dict) -> PinType:
             if loop_type_name.startswith(MULTIPIN_PREFIX):
                 raise ValueError(f"{loop_type_message}. {MULTIPIN_FORMAT_DESC}")
             LOGGER.warning(f"{loop_type_message}, assuming single pin")
-    return SinglePin()
+    return _SinglePin()
 
 
-def get_next_instruction(beamline: str) -> dict:
+def _get_next_instruction(beamline: str) -> dict:
     return _get_parameters_from_url(AGAMEMNON_URL + f"getnextcollect/{beamline}")
 
 
-def get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
+def _get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
     try:
         prefix = parameters["prefix"]
         collection = parameters["collection"]
@@ -113,7 +213,7 @@ def get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
     )
 
 
-def get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
+def _get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
     try:
         first_collection: dict = parameters["collection"][0]
         wavelength = first_collection.get("wavelength")
@@ -124,21 +224,29 @@ def get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]
         return {"demand_energy_ev": None}
 
 
-def get_param_version() -> SemanticVersion:
+def _get_param_version() -> SemanticVersion:
     return SemanticVersion.validate_from_str(str(PARAMETER_VERSION))
 
 
-def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreCollect]:
-    visit, detector_distance = get_withvisit_parameters_from_agamemnon(agamemnon_params)
-    with_energy_params = get_withenergy_parameters_from_agamemnon(agamemnon_params)
-    pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
+def _populate_parameters_from_agamemnon(
+    agamemnon_params,
+) -> Sequence[LoadCentreCollect]:
+    if not agamemnon_params:
+        # Empty dict means no instructions
+        return []
+
+    visit, detector_distance = _get_withvisit_parameters_from_agamemnon(
+        agamemnon_params
+    )
+    with_energy_params = _get_withenergy_parameters_from_agamemnon(agamemnon_params)
+    pin_type = _get_pin_type_from_agamemnon_collect_parameters(agamemnon_params)
     collections = agamemnon_params["collection"]
     visit_directory, file_name = path.split(agamemnon_params["prefix"])
 
     return [
         LoadCentreCollect.model_validate(
             {
-                "parameter_model_version": get_param_version(),
+                "parameter_model_version": _get_param_version(),
                 "visit": visit,
                 "detector_distance_mm": detector_distance,
                 "sample_id": agamemnon_params["sample"]["id"],
@@ -148,7 +256,6 @@ def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreC
                     "name": "TopNByMaxCount",
                     "n": pin_type.expected_number_of_crystals,
                 },
-                "features": {"use_gpu_results": True},
                 "robot_load_then_centre": {
                     "storage_directory": str(visit_directory) + "/xraycentring",
                     "file_name": file_name,
@@ -186,55 +293,3 @@ def populate_parameters_from_agamemnon(agamemnon_params) -> Sequence[LoadCentreC
         )
         for collection in collections
     ]
-
-
-def create_parameters_from_agamemnon() -> Sequence[LoadCentreCollect]:
-    beamline_name = get_beamline_name("i03")
-    agamemnon_params = get_next_instruction(beamline_name)
-    return (
-        populate_parameters_from_agamemnon(agamemnon_params) if agamemnon_params else []
-    )
-
-
-def compare_params(load_centre_collect_params: LoadCentreCollect):
-    try:
-        lcc_requests = create_parameters_from_agamemnon()
-        # Log differences against GDA populated parameters
-        if not lcc_requests:
-            LOGGER.info("Agamemnon returned no instructions")
-        else:
-            differences = DeepDiff(
-                lcc_requests[0], load_centre_collect_params, math_epsilon=1e-5
-            )
-            if differences:
-                LOGGER.info(
-                    f"Different parameters found when directly reading from Hyperion: {differences}"
-                )
-    except (ValueError, KeyError):
-        LOGGER.warning(f"Failed to compare parameters: {traceback.format_exc()}")
-    except Exception:
-        LOGGER.warning(
-            f"Unexpected error occurred. Failed to compare parameters: {traceback.format_exc()}"
-        )
-
-
-def update_params_from_agamemnon(parameters: T) -> T:
-    try:
-        beamline_name = get_beamline_name("i03")
-        agamemnon_params = get_next_instruction(beamline_name)
-        pin_type = get_pin_type_from_agamemnon_parameters(agamemnon_params)
-        if isinstance(parameters, LoadCentreCollect):
-            parameters.robot_load_then_centre.tip_offset_um = pin_type.full_width / 2
-            parameters.robot_load_then_centre.grid_width_um = pin_type.full_width
-            parameters.select_centres.n = pin_type.expected_number_of_crystals
-            if pin_type != SinglePin():
-                # Rotation snapshots will be generated from the gridscan snapshots,
-                # no need to specify snapshot omega.
-                parameters.multi_rotation_scan.snapshot_omegas_deg = []
-                parameters.multi_rotation_scan.use_grid_snapshots = True
-    except (ValueError, ValidationError) as e:
-        LOGGER.warning(f"Failed to update parameters: {e}")
-    except Exception as e:
-        LOGGER.warning(f"Unexpected error occurred. Failed to update parameters: {e}")
-
-    return parameters

mx_bluesky/hyperion/external_interaction/alerting/constants.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class Subjects(StrEnum):
+    UDC_STARTED = "UDC Started"
+    UDC_BATON_PASSED = "UDC Baton was passed"
+    UDC_RESUMED_OPERATION = "UDC Resumed operation"
+    UDC_SUSPENDED_OPERATION = "UDC Suspended operation"
+    NEW_CONTAINER = "Hyperion is collecting from a new container"
+    NEW_VISIT = "Hyperion has changed visit"
+    SAMPLE_ERROR = "Hyperion has encountered a sample error"
+    BEAMLINE_ERROR = "Hyperion has encountered a beamline error"

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -8,6 +8,10 @@ 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.external_interaction.alerting import set_alerting_service
+from mx_bluesky.common.external_interaction.alerting.log_based_service import (
+    LoggingAlertService,
+)
 from mx_bluesky.common.external_interaction.callbacks.common.log_uid_tag_callback import (
     LogUidTaggingCallback,
 )
@@ -156,6 +160,7 @@ class HyperionCallbackRunner:
     def __init__(self, dev_mode) -> None:
         setup_logging(dev_mode)
         log_info("Hyperion callback process started.")
+        set_alerting_service(LoggingAlertService(CONST.GRAYLOG_STREAM_ID))
 
         self.callbacks = setup_callbacks()
         self.proxy, self.dispatcher, start_proxy, start_dispatcher = setup_threads()

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

@@ -15,7 +15,7 @@ from mx_bluesky.common.external_interaction.nexus.nexus_utils import (
 )
 from mx_bluesky.common.external_interaction.nexus.write_nexus import NexusWriter
 from mx_bluesky.common.utils.log import NEXUS_LOGGER
-from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.constants import CONST, I03Constants
 from mx_bluesky.hyperion.parameters.rotation import SingleRotationScan
 
 if TYPE_CHECKING:
@@ -103,6 +103,6 @@ class RotationNexusFileCallback(PlanReactiveCallback):
                 full_num_of_images=self.full_num_of_images,
                 meta_data_run_number=self.meta_data_run_number,
                 axis_direction=AxisDirection.NEGATIVE
-                if parameters.features.omega_flip
+                if I03Constants.OMEGA_FLIP
                 else AxisDirection.POSITIVE,
             )