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

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -41,7 +41,7 @@ def start_preparing_data_collection_then_do_plan(
     """
 
     def wrapped_plan():
-        yield from bps.abs_set(eiger.do_arm, 1, group=group)
+        yield from bps.abs_set(eiger.do_arm, 1, group=group)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
         if detector_distance_mm:
             yield from set_detector_z_position(
                 detector_motion, detector_distance_mm, group
@@ -51,5 +51,5 @@ def start_preparing_data_collection_then_do_plan(
 
     yield from bpp.contingency_wrapper(
         wrapped_plan(),
-        except_plan=lambda e: (yield from bps.stop(eiger)),
+        except_plan=lambda e: (yield from bps.stop(eiger)),  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     )

mx_bluesky/hyperion/device_setup_plans/xbpm_feedback.py

@@ -23,14 +23,14 @@ def _check_and_pause_feedback(
                                                turning XBPM feedback off.
 
     """
-    yield from bps.mv(attenuator, 1.0)
+    yield from bps.mv(attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
     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)
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.PAUSE)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+    yield from bps.mv(attenuator, desired_transmission_fraction)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
 
 def _unpause_xbpm_feedback_and_set_transmission_to_1(
@@ -44,7 +44,7 @@ def _unpause_xbpm_feedback_and_set_transmission_to_1(
                                       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)
+    yield from bps.mv(xbpm_feedback.pause_feedback, Pause.RUN, attenuator, 1.0)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
 
 
 def transmission_and_xbpm_feedback_for_collection_wrapper(

mx_bluesky/hyperion/exceptions.py

@@ -13,9 +13,21 @@ class WarningException(Exception):
     pass
 
 
+class SampleException(WarningException):
+    """An exception which identifies an issue relating to the sample."""
+
+    pass
+
+
 T = TypeVar("T")
 
 
+class CrystalNotFoundException(SampleException):
+    """Raised if grid detection completed normally but no crystal was found."""
+
+    pass
+
+
 def catch_exception_and_warn(
     exception_to_catch: type[Exception],
     func: Callable[..., Generator[Msg, None, T]],
@@ -36,7 +48,7 @@ def catch_exception_and_warn(
 
     def warn_if_exception_matches(exception: Exception):
         if isinstance(exception, exception_to_catch):
-            raise WarningException(str(exception))
+            raise SampleException(str(exception)) from exception
         yield from null()
 
     return (

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -9,6 +9,9 @@ from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     grid_detect_then_xray_centre,
 )
+from mx_bluesky.hyperion.experiment_plans.load_centre_collect_full_plan import (
+    load_centre_collect_full,
+)
 from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan import (
     pin_tip_centre_then_xray_centre,
 )
@@ -27,4 +30,5 @@ __all__ = [
     "pin_tip_centre_then_xray_centre",
     "multi_rotation_scan",
     "robot_load_then_centre",
+    "load_centre_collect_full",
 ]

mx_bluesky/hyperion/experiment_plans/change_aperture_then_move_plan.py

@@ -0,0 +1,83 @@
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+import numpy
+from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+from dodal.devices.smargon import Smargon, StubPosition
+
+from mx_bluesky.common.utils.tracing import TRACER
+from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import move_x_y_z
+from mx_bluesky.hyperion.experiment_plans.common.xrc_result import XRayCentreResult
+from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.hyperion.parameters.gridscan import HyperionThreeDGridScan
+
+
+def change_aperture_then_move_to_xtal(
+    best_hit: XRayCentreResult,
+    smargon: Smargon,
+    aperture_scatterguard: ApertureScatterguard,
+    parameters: HyperionThreeDGridScan | None = None,
+):
+    """For the given x-ray centring result,
+    * Change the aperture so that the beam size is comparable to the crystal size
+    * Centre on the centre-of-mass
+    * Reset the stub offsets if specified by params"""
+    if best_hit.bounding_box_mm is not None:
+        bounding_box_size = numpy.abs(
+            best_hit.bounding_box_mm[1] - best_hit.bounding_box_mm[0]
+        )
+        with TRACER.start_span("change_aperture"):
+            yield from _set_aperture_for_bbox_mm(
+                aperture_scatterguard, bounding_box_size
+            )
+    else:
+        LOGGER.warning("No bounding box size received")
+
+    # once we have the results, go to the appropriate position
+    LOGGER.info("Moving to centre of mass.")
+    with TRACER.start_span("move_to_result"):
+        x, y, z = best_hit.centre_of_mass_mm
+        yield from move_x_y_z(smargon, x, y, z, wait=True)
+
+    # TODO support for setting stub offsets in multipin
+    # https://github.com/DiamondLightSource/mx-bluesky/issues/552
+    if parameters and parameters.FGS_params.set_stub_offsets:
+        LOGGER.info("Recentring smargon co-ordinate system to this point.")
+        yield from bps.mv(
+            # See: https://github.com/bluesky/bluesky/issues/1809
+            smargon.stub_offsets,  # type: ignore
+            StubPosition.CURRENT_AS_CENTER,  # type: ignore
+        )
+
+
+def _set_aperture_for_bbox_mm(
+    aperture_device: ApertureScatterguard, bbox_size_mm: list[float] | numpy.ndarray
+):
+    # TODO confirm correction factor see https://github.com/DiamondLightSource/mx-bluesky/issues/618
+    ASSUMED_BOX_SIZE_MM = 0.020
+    bbox_size_boxes = [round(mm / ASSUMED_BOX_SIZE_MM) for mm in bbox_size_mm]
+    yield from set_aperture_for_bbox_size(aperture_device, bbox_size_boxes)
+
+
+def set_aperture_for_bbox_size(
+    aperture_device: ApertureScatterguard,
+    bbox_size: list[int] | numpy.ndarray,
+):
+    # bbox_size is [x,y,z], for i03 we only care about x
+    new_selected_aperture = (
+        ApertureValue.MEDIUM if bbox_size[0] < 2 else ApertureValue.LARGE
+    )
+    LOGGER.info(
+        f"Setting aperture to {new_selected_aperture} based on bounding box size {bbox_size}."
+    )
+
+    @bpp.set_run_key_decorator("change_aperture")
+    @bpp.run_decorator(
+        md={
+            "subplan_name": "change_aperture",
+            "aperture_size": new_selected_aperture.value,
+        }
+    )
+    def set_aperture():
+        yield from bps.abs_set(aperture_device, new_selected_aperture)
+
+    yield from set_aperture()

mx_bluesky/hyperion/experiment_plans/common/xrc_result.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Callable, Sequence
+from functools import partial
+
+import numpy as np
+
+from mx_bluesky.common.parameters.components import (
+    MultiXtalSelection,
+    TopNByMaxCountSelection,
+)
+
+
+@dataclasses.dataclass
+class XRayCentreResult:
+    """Represents information about a hit from an X-ray centring."""
+
+    centre_of_mass_mm: np.ndarray
+    bounding_box_mm: tuple[np.ndarray, np.ndarray]
+    max_count: int
+    total_count: int
+
+    def __eq__(self, o):
+        return (
+            isinstance(o, XRayCentreResult)
+            and o.max_count == self.max_count
+            and o.total_count == self.total_count
+            and all(o.centre_of_mass_mm == self.centre_of_mass_mm)
+            and all(o.bounding_box_mm[0] == self.bounding_box_mm[0])
+            and all(o.bounding_box_mm[1] == self.bounding_box_mm[1])
+        )
+
+
+def top_n_by_max_count(
+    unfiltered: Sequence[XRayCentreResult], n: int
+) -> Sequence[XRayCentreResult]:
+    sorted_hits = sorted(unfiltered, key=lambda result: result.max_count, reverse=True)
+    return sorted_hits[:n]
+
+
+def resolve_selection_fn(
+    params: MultiXtalSelection,
+) -> Callable[[Sequence[XRayCentreResult]], Sequence[XRayCentreResult]]:
+    if isinstance(params, TopNByMaxCountSelection):
+        return partial(top_n_by_max_count, n=params.n)
+    raise ValueError(f"Invalid selection function {params.name}")

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -5,6 +5,11 @@ 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.common.parameters.gridscan import (
+    GridScanWithEdgeDetect,
+    PinTipCentreThenXrayCentre,
+    RobotLoadThenCentre,
+)
 from mx_bluesky.hyperion.experiment_plans import (
     grid_detect_then_xray_centre_plan,
     load_centre_collect_full_plan,
@@ -18,12 +23,7 @@ from mx_bluesky.hyperion.external_interaction.callbacks.common.callback_util imp
     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.gridscan import HyperionThreeDGridScan
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
 from mx_bluesky.hyperion.parameters.rotation import MultiRotationScan, RotationScan
 
@@ -39,7 +39,7 @@ def do_nothing():
 class ExperimentRegistryEntry(TypedDict):
     setup: Callable
     param_type: type[
-        ThreeDGridScan
+        HyperionThreeDGridScan
         | GridScanWithEdgeDetect
         | RotationScan
         | MultiRotationScan
@@ -53,7 +53,7 @@ class ExperimentRegistryEntry(TypedDict):
 PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
     "flyscan_xray_centre": {
         "setup": flyscan_xray_centre_plan.create_devices,
-        "param_type": ThreeDGridScan,
+        "param_type": HyperionThreeDGridScan,
         "callbacks_factory": create_gridscan_callbacks,
     },
     "grid_detect_then_xray_centre": {
@@ -81,7 +81,7 @@ PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
         "param_type": MultiRotationScan,
         "callbacks_factory": create_rotation_callbacks,
     },
-    "load_centre_collect_full_plan": {
+    "load_centre_collect_full": {
         "setup": load_centre_collect_full_plan.create_devices,
         "param_type": LoadCentreCollect,
         "callbacks_factory": create_load_centre_collect_callbacks,