mx-bluesky 1.4.7__py3-none-any.whl → 1.4.8__py3-none-any.whl

mx_bluesky/hyperion/experiment_plans/robot_load_then_centre_plan.py

@@ -10,13 +10,14 @@ 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.dcm import DCM
 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, MirrorVoltages
-from dodal.devices.i03.beamstop import Beamstop
+from dodal.devices.i03 import Beamstop
+from dodal.devices.i03.dcm import DCM
+from dodal.devices.i03.undulator_dcm import UndulatorDCM
 from dodal.devices.motors import XYZPositioner
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -26,7 +27,6 @@ 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_dcm import UndulatorDCM
 from dodal.devices.webcam import Webcam
 from dodal.devices.xbpm_feedback import XBPMFeedback
 from dodal.devices.zebra.zebra import Zebra
@@ -112,6 +112,7 @@ def _flyscan_plan_from_robot_load_params(
     yield from pin_centre_then_flyscan_plan(
         cast(GridDetectThenXRayCentreComposite, composite),
         params.pin_centre_then_xray_centre_params,
+        oav_config_file,
     )
 
 
@@ -131,6 +132,7 @@ def _robot_load_then_flyscan_plan(
 def robot_load_then_xray_centre(
     composite: RobotLoadThenCentreComposite,
     parameters: RobotLoadThenCentre,
+    oav_config_file: str = OavConstants.OAV_CONFIG_JSON,
 ) -> MsgGenerator:
     """Perform pin-tip detection followed by a flyscan to determine centres of interest.
     Performs a robot load if necessary."""
@@ -154,10 +156,7 @@ def robot_load_then_xray_centre(
 
     if doing_sample_load:
         LOGGER.info("Pin not loaded, loading and centring")
-        plan = _robot_load_then_flyscan_plan(
-            composite,
-            parameters,
-        )
+        plan = _robot_load_then_flyscan_plan(composite, parameters, oav_config_file)
     else:
         # Robot load normally sets the energy so we should do this explicitly if no load is
         # being done
@@ -168,7 +167,9 @@ def robot_load_then_xray_centre(
         )
 
         if doing_chi_change:
-            plan = _flyscan_plan_from_robot_load_params(composite, parameters)
+            plan = _flyscan_plan_from_robot_load_params(
+                composite, parameters, oav_config_file
+            )
             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

@@ -10,11 +10,11 @@ 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.dcm import DCM
 from dodal.devices.detector.detector_motion import DetectorMotion
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
-from dodal.devices.i03.beamstop import Beamstop
+from dodal.devices.i03 import Beamstop
+from dodal.devices.i03.dcm import DCM
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.oav_parameters import OAVParameters
 from dodal.devices.robot import BartRobot
@@ -30,6 +30,12 @@ from dodal.plans.preprocessors.verify_undulator_gap import (
     verify_undulator_gap_before_run_decorator,
 )
 
+from mx_bluesky.common.device_setup_plans.manipulate_sample import (
+    cleanup_sample_environment,
+    move_phi_chi_omega,
+    move_x_y_z,
+    setup_sample_environment,
+)
 from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.plans.read_hardware import (
     read_hardware_for_zocalo,
@@ -41,12 +47,6 @@ from mx_bluesky.common.preprocessors.preprocessors import (
 )
 from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
-from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
-    cleanup_sample_environment,
-    move_phi_chi_omega,
-    move_x_y_z,
-    setup_sample_environment,
-)
 from mx_bluesky.hyperion.device_setup_plans.setup_zebra import (
     arm_zebra,
     setup_zebra_for_rotation,
@@ -356,68 +356,30 @@ def _move_and_rotation(
                 group=CONST.WAIT.ROTATION_READY_FOR_DC,
             )
         yield from oav_snapshot_plan(composite, params, oav_params)
-    yield from rotation_scan_plan(
-        composite,
-        params,
-        motion_values,
-    )
+    yield from rotation_scan_plan(composite, params, motion_values)
 
 
-def rotation_scan(
+def multi_rotation_scan(
     composite: RotationScanComposite,
-    parameters: RotationScan,
+    parameters: MultiRotationScan,
     oav_params: OAVParameters | None = None,
 ) -> MsgGenerator:
-    parameters.features.update_self_from_server()
-
-    if not oav_params:
-        oav_params = OAVParameters(context="xrayCentring")
-
-    @transmission_and_xbpm_feedback_for_collection_decorator(
-        composite,
-        parameters.transmission_frac,
-    )
-    @verify_undulator_gap_before_run_decorator(composite)
-    @bpp.set_run_key_decorator("rotation_scan")
-    @bpp.run_decorator(  # attach experiment metadata to the start document
+    @bpp.set_run_key_decorator(CONST.PLAN.ROTATION_MULTI_OUTER)
+    @bpp.run_decorator(
         md={
-            "subplan_name": CONST.PLAN.ROTATION_OUTER,
-            "mx_bluesky_parameters": parameters.model_dump_json(),
+            "activate_callbacks": ["BeamDrawingCallback"],
             "with_snapshot": parameters.model_dump_json(
                 include=WithSnapshot.model_fields.keys()  # type: ignore
             ),
-            "activate_callbacks": [
-                "BeamDrawingCallback",
-                "RotationISPyBCallback",
-                "RotationNexusFileCallback",
-            ],
         }
     )
-    def rotation_scan_plan_with_stage_and_cleanup(
-        params: RotationScan,
-    ):
-        eiger: EigerDetector = composite.eiger
-        eiger.set_detector_parameters(params.detector_params)
-
-        @bpp.finalize_decorator(lambda: _cleanup_plan(composite))
-        def rotation_with_cleanup_and_stage(params: RotationScan):
-            yield from _move_and_rotation(composite, params, oav_params)
-
-        LOGGER.info("setting up and staging eiger...")
-        yield from start_preparing_data_collection_then_do_plan(
-            composite.beamstop,
-            eiger,
-            composite.detector_motion,
-            params.detector_distance_mm,
-            rotation_with_cleanup_and_stage(params),
-            group=CONST.WAIT.ROTATION_READY_FOR_DC,
-        )
-        yield from bps.unstage(eiger)
+    def _wrapped_multi_rotation_scan():
+        yield from multi_rotation_scan_internal(composite, parameters, oav_params)
 
-    yield from rotation_scan_plan_with_stage_and_cleanup(parameters)
+    yield from _wrapped_multi_rotation_scan()
 
 
-def multi_rotation_scan(
+def multi_rotation_scan_internal(
     composite: RotationScanComposite,
     parameters: MultiRotationScan,
     oav_params: OAVParameters | None = None,

mx_bluesky/hyperion/experiment_plans/set_energy_plan.py

@@ -9,10 +9,10 @@ import bluesky.preprocessors as bpp
 import pydantic
 from bluesky import plan_stubs as bps
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
-from dodal.devices.dcm import DCM
 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_dcm import UndulatorDCM
 from dodal.devices.xbpm_feedback import XBPMFeedback
 
 from mx_bluesky.common.parameters.constants import PlanNameConstants

mx_bluesky/hyperion/external_interaction/agamemnon.py

@@ -1,6 +1,7 @@
 import dataclasses
 import json
 import re
+import traceback
 from os import path
 from typing import Any, TypeVar
 
@@ -12,11 +13,6 @@ from pydantic_extra_types.semantic_version import SemanticVersion
 
 from mx_bluesky.common.parameters.components import (
     PARAMETER_VERSION,
-    MxBlueskyParameters,
-    TopNByMaxCountSelection,
-    WithCentreSelection,
-    WithOptionalEnergyChange,
-    WithSample,
     WithVisit,
 )
 from mx_bluesky.common.parameters.constants import (
@@ -24,9 +20,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 WithHyperionUDCFeatures
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.parameters.robot_load import RobotLoadThenCentre
 
 T = TypeVar("T", bound=WithVisit)
 AGAMEMNON_URL = "http://agamemnon.diamond.ac.uk/"
@@ -36,19 +30,6 @@ MULTIPIN_REGEX = rf"^{MULTIPIN_PREFIX}_(\d+)x(\d+(?:\.\d+)?)\+(\d+(?:\.\d+)?)$"
 MX_GENERAL_ROOT_REGEX = r"^/dls/(?P<beamline>[^/]+)/data/[^/]*/(?P<visit>[^/]+)(?:/|$)"
 
 
-class AgamemnonLoadCentreCollect(
-    MxBlueskyParameters,
-    WithVisit,
-    WithSample,
-    WithCentreSelection,
-    WithHyperionUDCFeatures,
-    WithOptionalEnergyChange,
-):
-    """Experiment parameters to compare against GDA populated LoadCentreCollect."""
-
-    robot_load_then_centre: RobotLoadThenCentre
-
-
 @dataclasses.dataclass
 class PinType:
     expected_number_of_crystals: int
@@ -131,15 +112,6 @@ def get_withvisit_parameters_from_agamemnon(parameters: dict) -> tuple:
     )
 
 
-def get_withsample_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
-    assert parameters.get("sample"), "instruction does not have a sample"
-    return {
-        "sample_id": parameters["sample"]["id"],
-        "sample_puck": parameters["sample"]["container"],
-        "sample_pin": parameters["sample"]["position"],
-    }
-
-
 def get_withenergy_parameters_from_agamemnon(parameters: dict) -> dict[str, Any]:
     try:
         first_collection: dict = parameters["collection"][0]
@@ -155,57 +127,75 @@ def get_param_version() -> SemanticVersion:
     return SemanticVersion.validate_from_str(str(PARAMETER_VERSION))
 
 
-def create_robot_load_then_centre_params_from_agamemnon(
-    parameters: dict,
-) -> RobotLoadThenCentre:
-    visit, detector_distance = get_withvisit_parameters_from_agamemnon(parameters)
-    with_sample_params = get_withsample_parameters_from_agamemnon(parameters)
-    with_energy_params = get_withenergy_parameters_from_agamemnon(parameters)
-    visit_directory, file_name = path.split(parameters["prefix"])
-    return RobotLoadThenCentre(
-        parameter_model_version=get_param_version(),
-        storage_directory=visit_directory + "/xraycentring",
-        visit=visit,
-        detector_distance_mm=detector_distance,
-        snapshot_directory=visit_directory + "/snapshots",
-        file_name=file_name,
-        **with_energy_params,
-        **with_sample_params,
-    )
-
-
 def populate_parameters_from_agamemnon(agamemnon_params):
     visit, detector_distance = get_withvisit_parameters_from_agamemnon(agamemnon_params)
-    with_sample_params = get_withsample_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)
-    robot_load_params = create_robot_load_then_centre_params_from_agamemnon(
-        agamemnon_params
-    )
-    return AgamemnonLoadCentreCollect(
-        parameter_model_version=SemanticVersion.validate_from_str(
-            str(PARAMETER_VERSION)
-        ),
-        visit=visit,
-        detector_distance_mm=detector_distance,
-        select_centres=TopNByMaxCountSelection(n=pin_type.expected_number_of_crystals),
-        robot_load_then_centre=robot_load_params,
-        **with_sample_params,
-        **with_energy_params,
+    first_collection = agamemnon_params["collection"][0]
+    visit_directory, file_name = path.split(agamemnon_params["prefix"])
+    return LoadCentreCollect.model_validate(
+        {
+            "parameter_model_version": get_param_version(),
+            "visit": visit,
+            "detector_distance_mm": detector_distance,
+            "sample_id": agamemnon_params["sample"]["id"],
+            "sample_puck": agamemnon_params["sample"]["container"],
+            "sample_pin": agamemnon_params["sample"]["position"],
+            "select_centres": {
+                "name": "TopNByMaxCount",
+                "n": pin_type.expected_number_of_crystals,
+            },
+            "robot_load_then_centre": {
+                "storage_directory": str(visit_directory) + "/xraycentring",
+                "file_name": file_name,
+                "tip_offset_um": pin_type.full_width / 2,
+                "grid_width_um": pin_type.full_width,
+                "omega_start_deg": 0.0,
+                "chi_start_deg": first_collection["chi"],
+                "transmission_frac": 1.0,
+                "features": {"use_gpu_results": True},
+                **with_energy_params,
+            },
+            "multi_rotation_scan": {
+                "comment": first_collection["comment"],
+                "storage_directory": str(visit_directory),
+                "exposure_time_s": first_collection["exposure_time"],
+                "file_name": file_name,
+                "transmission_frac": first_collection["transmission"],
+                "rotation_increment_deg": first_collection["omega_increment"],
+                "ispyb_experiment_type": first_collection["experiment_type"],
+                "snapshot_omegas_deg": [0.0, 90.0, 180.0, 270.0],
+                "rotation_scans": [
+                    {
+                        "scan_width_deg": (
+                            first_collection["number_of_images"]
+                            * first_collection["omega_increment"]
+                        ),
+                        "omega_start_deg": first_collection["omega_start"],
+                        "phi_start_deg": first_collection["phi_start"],
+                        "chi_start_deg": first_collection["chi"],
+                        "rotation_direction": "Positive",
+                    }
+                ],
+                **with_energy_params,
+            },
+        }
     )
 
 
-def create_parameters_from_agamemnon() -> AgamemnonLoadCentreCollect:
+def create_parameters_from_agamemnon() -> LoadCentreCollect | None:
     beamline_name = get_beamline_name("i03")
     agamemnon_params = get_next_instruction(beamline_name)
-
-    return populate_parameters_from_agamemnon(agamemnon_params)
+    return (
+        populate_parameters_from_agamemnon(agamemnon_params)
+        if agamemnon_params
+        else None
+    )
 
 
 def compare_params(load_centre_collect_params):
     try:
         parameters = create_parameters_from_agamemnon()
-
         # Log differences against GDA populated parameters
         differences = DeepDiff(
             parameters, load_centre_collect_params, math_epsilon=1e-5
@@ -214,10 +204,12 @@ def compare_params(load_centre_collect_params):
             LOGGER.info(
                 f"Different parameters found when directly reading from Hyperion: {differences}"
             )
-    except (ValueError, KeyError) as e:
-        LOGGER.warning(f"Failed to compare parameters: {e}")
-    except Exception as e:
-        LOGGER.warning(f"Unexpected error occurred. Failed to compare parameters: {e}")
+    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:

mx_bluesky/hyperion/external_interaction/callbacks/__main__.py

@@ -1,8 +1,8 @@
 import logging
 from collections.abc import Callable, Sequence
 from threading import Thread
+from time import sleep  # noqa
 
-import bluesky.plan_stubs as bps
 from bluesky.callbacks import CallbackBase
 from bluesky.callbacks.zmq import Proxy, RemoteDispatcher
 from dodal.log import LOGGER as dodal_logger
@@ -26,7 +26,7 @@ from mx_bluesky.common.external_interaction.callbacks.xray_centre.nexus_callback
 from mx_bluesky.common.utils.log import (
     ISPYB_ZOCALO_CALLBACK_LOGGER,
     NEXUS_LOGGER,
-    _get_logging_dir,
+    _get_logging_dirs,
     tag_filter,
 )
 from mx_bluesky.hyperion.external_interaction.callbacks.robot_load.ispyb_callback import (
@@ -93,14 +93,16 @@ def setup_logging(dev_mode: bool):
         (ISPYB_ZOCALO_CALLBACK_LOGGER, "hyperion_ispyb_callback.log"),
         (NEXUS_LOGGER, "hyperion_nexus_callback.log"),
     ]:
+        logging_path, debug_logging_path = _get_logging_dirs()
         if logger.handlers == []:
             handlers = set_up_all_logging_handlers(
                 logger,
-                _get_logging_dir(),
+                logging_path,
                 filename,
                 dev_mode,
-                error_log_buffer_lines=ERROR_LOG_BUFFER_LINES,
-                graylog_port=CONST.GRAYLOG_PORT,
+                ERROR_LOG_BUFFER_LINES,
+                CONST.GRAYLOG_PORT,
+                debug_logging_path,
             )
             handlers["graylog_handler"].addFilter(tag_filter)
     log_info(f"Loggers initialised with dev_mode={dev_mode}")
@@ -140,7 +142,7 @@ def wait_for_threads_forever(threads: Sequence[Thread]):
     try:
         log_debug("Trying to wait forever on callback and dispatcher threads")
         while all(alive):
-            yield from bps.sleep(LIVENESS_POLL_SECONDS)
+            sleep(LIVENESS_POLL_SECONDS)
             alive = [t.is_alive() for t in threads]
     except KeyboardInterrupt:
         log_info("Main thread received interrupt - exiting.")