mx-bluesky 0.3.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

mx_bluesky/hyperion/device_setup_plans/smargon.py

@@ -0,0 +1,25 @@
+import numpy as np
+from bluesky import plan_stubs as bps
+from dodal.devices.smargon import Smargon
+
+from mx_bluesky.hyperion.exceptions import WarningException
+
+
+def move_smargon_warn_on_out_of_range(
+    smargon: Smargon, position: np.ndarray | list[float] | tuple[float, float, float]
+):
+    """Throws a WarningException if the specified position is out of range for the
+    smargon. Otherwise moves to that position."""
+    limits = yield from smargon.get_xyz_limits()
+    if not limits.position_valid(position):
+        raise WarningException(
+            "Pin tip centring failed - pin too long/short/bent and out of range"
+        )
+    yield from bps.mv(
+        smargon.x,
+        position[0],
+        smargon.y,
+        position[1],
+        smargon.z,
+        position[2],
+    )

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -0,0 +1,55 @@
+from collections.abc import Generator
+
+from bluesky import plan_stubs as bps
+from bluesky import preprocessors as bpp
+from bluesky.utils import Msg
+from dodal.devices.dcm import DCM
+from dodal.devices.detector import (
+    DetectorParams,
+)
+from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
+from dodal.devices.eiger import EigerDetector
+
+from mx_bluesky.hyperion.device_setup_plans.position_detector import (
+    set_detector_z_position,
+    set_shutter,
+)
+
+
+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))
+        detector_params.expected_energy_ev = actual_energy_ev
+    return detector_params
+
+
+def start_preparing_data_collection_then_do_plan(
+    eiger: EigerDetector,
+    detector_motion: DetectorMotion,
+    detector_distance_mm: float | None,
+    plan_to_run: Generator[Msg, None, None],
+    group="ready_for_data_collection",
+) -> Generator[Msg, None, None]:
+    """Starts preparing for the next data collection and then runs the
+    given plan.
+
+     Preparation consists of:
+     * Arming the Eiger
+     * Moving the detector to the specified position
+     * Opening the detect shutter
+     If the plan fails it will disarm the eiger.
+    """
+
+    def wrapped_plan():
+        yield from bps.abs_set(eiger.do_arm, 1, group=group)
+        if detector_distance_mm:
+            yield from set_detector_z_position(
+                detector_motion, detector_distance_mm, group
+            )
+        yield from set_shutter(detector_motion, ShutterState.OPEN, group)
+        yield from plan_to_run
+
+    yield from bpp.contingency_wrapper(
+        wrapped_plan(),
+        except_plan=lambda e: (yield from bps.stop(eiger)),
+    )

mx_bluesky/hyperion/device_setup_plans/xbpm_feedback.py

@@ -0,0 +1,93 @@
+from bluesky import plan_stubs as bps
+from bluesky.preprocessors import finalize_wrapper
+from bluesky.utils import make_decorator
+from dodal.devices.attenuator import Attenuator
+from dodal.devices.xbpm_feedback import Pause, XBPMFeedback
+
+from mx_bluesky.hyperion.log import LOGGER
+
+
+def _check_and_pause_feedback(
+    xbpm_feedback: XBPMFeedback,
+    attenuator: Attenuator,
+    desired_transmission_fraction: float,
+):
+    """Checks that the xbpm is in position before then turning it off and setting a new
+    transmission.
+
+    Args:
+        xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
+                                      the beam in position
+        attenuator (Attenuator): The attenuator used to set transmission
+        desired_transmission_fraction (float): The desired transmission to set after
+                                               turning XBPM feedback off.
+
+    """
+    yield from bps.mv(attenuator, 1.0)
+    LOGGER.info("Waiting for XBPM feedback to be stable")
+    yield from bps.trigger(xbpm_feedback, wait=True)
+    LOGGER.info(
+        f"XPBM feedback in position, pausing and setting transmission to {desired_transmission_fraction}"
+    )
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)
+    yield from bps.mv(attenuator, desired_transmission_fraction)
+
+
+def _unpause_xbpm_feedback_and_set_transmission_to_1(
+    xbpm_feedback: XBPMFeedback, attenuator: Attenuator
+):
+    """Turns the XBPM feedback back on and sets transmission to 1 so that it keeps the
+    beam aligned whilst not collecting.
+
+    Args:
+        xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
+                                      the beam in position
+        attenuator (Attenuator): The attenuator used to set transmission
+    """
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)
+
+
+def transmission_and_xbpm_feedback_for_collection_wrapper(
+    plan,
+    xbpm_feedback: XBPMFeedback,
+    attenuator: Attenuator,
+    desired_transmission_fraction: float,
+):
+    """Sets the transmission for the data collection, ensuring the xbpm feedback is valid
+    this wrapper should be run around every data collection or movement that may disrupt
+    the XBPM feedback.
+
+    XBPM feedback isn't reliable during collections due to:
+     * Objects (e.g. attenuator) crossing the beam can cause large (incorrect) feedback movements
+     * Lower transmissions/higher energies are less reliable for the xbpm
+
+    So we need to keep the transmission at 100% and the feedback on when not collecting
+    and then turn it off and set the correct transmission for collection. The feedback
+    mostly accounts for slow thermal drift so it is safe to assume that the beam is
+    stable during a collection.
+
+    Args:
+        plan: The plan performing the data collection
+        xbpm_feedback (XBPMFeedback): The XBPM device that is responsible for keeping
+                                      the beam in position
+        attenuator (Attenuator): The attenuator used to set transmission
+        desired_transmission_fraction (float): The desired transmission for the collection
+    """
+
+    def _inner_plan():
+        yield from _check_and_pause_feedback(
+            xbpm_feedback, attenuator, desired_transmission_fraction
+        )
+        return (yield from plan)
+
+    return (
+        yield from finalize_wrapper(
+            _inner_plan(),
+            _unpause_xbpm_feedback_and_set_transmission_to_1(xbpm_feedback, attenuator),
+        )
+    )
+
+
+transmission_and_xbpm_feedback_for_collection_decorator = make_decorator(
+    transmission_and_xbpm_feedback_for_collection_wrapper
+)

mx_bluesky/hyperion/exceptions.py

@@ -0,0 +1,47 @@
+from collections.abc import Callable, Generator
+from typing import TypeVar
+
+from bluesky.plan_stubs import null
+from bluesky.preprocessors import contingency_wrapper
+from bluesky.utils import Msg
+
+
+class WarningException(Exception):
+    """An exception used when we want to warn GDA of a
+    problem but continue with UDC anyway"""
+
+    pass
+
+
+T = TypeVar("T")
+
+
+def catch_exception_and_warn(
+    exception_to_catch: type[Exception],
+    func: Callable[..., Generator[Msg, None, T]],
+    *args,
+    **kwargs,
+) -> Generator[Msg, None, T]:
+    """A plan wrapper to catch a specific exception and instead raise a WarningException,
+    so that UDC is not halted
+
+    Example usage:
+
+    'def plan_which_can_raise_exception_a(*args, **kwargs):
+        ...
+    yield from catch_exception_and_warn(ExceptionA, plan_which_can_raise_exception_a, **args, **kwargs)'
+
+    This will catch ExceptionA raised by the plan and instead raise a WarningException
+    """
+
+    def warn_if_exception_matches(exception: Exception):
+        if isinstance(exception, exception_to_catch):
+            raise WarningException(str(exception))
+        yield from null()
+
+    return (
+        yield from contingency_wrapper(
+            func(*args, **kwargs),
+            except_plan=warn_if_exception_matches,
+        )
+    )

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -0,0 +1,30 @@
+"""This module contains the experimental plans which hyperion can run.
+
+The __all__ list in here are the plans that are externally available from outside Hyperion.
+"""
+
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    flyscan_xray_centre,
+)
+from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
+    grid_detect_then_xray_centre,
+)
+from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
+    pin_tip_centre_then_xray_centre,
+)
+from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
+    robot_load_then_centre,
+)
+from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
+    multi_rotation_scan,
+    rotation_scan,
+)
+
+__all__ = [
+    "flyscan_xray_centre",
+    "grid_detect_then_xray_centre",
+    "rotation_scan",
+    "pin_tip_centre_then_xray_centre",
+    "multi_rotation_scan",
+    "robot_load_then_centre",
+]

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TypedDict
+
+import mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan as flyscan_xray_centre_plan
+import mx_bluesky.hyperion.experiment_plans.rotation_scan_plan as rotation_scan_plan
+from mx_bluesky.hyperion.experiment_plans import (
+    grid_detect_then_xray_centre_plan,
+    load_centre_collect_full_plan,
+    pin_centre_then_xray_centre_plan,
+    robot_load_then_centre_plan,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util import (
+    CallbacksFactory,
+    create_gridscan_callbacks,
+    create_load_centre_collect_callbacks,
+    create_robot_load_and_centre_callbacks,
+    create_rotation_callbacks,
+)
+from mx_bluesky.hyperion.parameters.gridscan import (
+    GridScanWithEdgeDetect,
+    PinTipCentreThenXrayCentre,
+    RobotLoadThenCentre,
+    ThreeDGridScan,
+)
+from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
+from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan, RotationScan
+
+
+def not_implemented():
+    raise NotImplementedError
+
+
+def do_nothing():
+    pass
+
+
+class ExperimentRegistryEntry(TypedDict):
+    setup: Callable
+    param_type: type[
+        ThreeDGridScan
+        | GridScanWithEdgeDetect
+        | RotationScan
+        | MultiRotationScan
+        | PinTipCentreThenXrayCentre
+        | RobotLoadThenCentre
+        | LoadCentreCollect
+    ]
+    callbacks_factory: CallbacksFactory
+
+
+PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
+    "flyscan_xray_centre": {
+        "setup": flyscan_xray_centre_plan.create_devices,
+        "param_type": ThreeDGridScan,
+        "callbacks_factory": create_gridscan_callbacks,
+    },
+    "grid_detect_then_xray_centre": {
+        "setup": grid_detect_then_xray_centre_plan.create_devices,
+        "param_type": GridScanWithEdgeDetect,
+        "callbacks_factory": create_gridscan_callbacks,
+    },
+    "rotation_scan": {
+        "setup": rotation_scan_plan.create_devices,
+        "param_type": RotationScan,
+        "callbacks_factory": create_rotation_callbacks,
+    },
+    "pin_tip_centre_then_xray_centre": {
+        "setup": pin_centre_then_xray_centre_plan.create_devices,
+        "param_type": PinTipCentreThenXrayCentre,
+        "callbacks_factory": create_gridscan_callbacks,
+    },
+    "robot_load_then_centre": {
+        "setup": robot_load_then_centre_plan.create_devices,
+        "param_type": RobotLoadThenCentre,
+        "callbacks_factory": create_robot_load_and_centre_callbacks,
+    },
+    "multi_rotation_scan": {
+        "setup": rotation_scan_plan.create_devices,
+        "param_type": MultiRotationScan,
+        "callbacks_factory": create_rotation_callbacks,
+    },
+    "load_centre_collect_full_plan": {
+        "setup": load_centre_collect_full_plan.create_devices,
+        "param_type": LoadCentreCollect,
+        "callbacks_factory": create_load_centre_collect_callbacks,
+    },
+}
+
+
+class PlanNotFound(Exception):
+    pass