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

mx_bluesky/hyperion/experiment_plans/grid_detect_then_xray_centre_plan.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+
+from blueapi.core import BlueskyContext, MsgGenerator
+from bluesky import plan_stubs as bps
+from bluesky import preprocessors as bpp
+from dodal.devices.aperturescatterguard import ApertureScatterguard
+from dodal.devices.attenuator import Attenuator
+from dodal.devices.backlight import Backlight, BacklightPosition
+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.oav.oav_detector import OAV
+from dodal.devices.oav.oav_parameters import OAV_CONFIG_JSON, OAVParameters
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.robot import BartRobot
+from dodal.devices.s4_slit_gaps import S4SlitGaps
+from dodal.devices.smargon import Smargon
+from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.undulator import Undulator
+from dodal.devices.xbpm_feedback import XBPMFeedback
+from dodal.devices.zebra import Zebra
+from dodal.devices.zebra_controlled_shutter import ZebraShutter
+from dodal.devices.zocalo import ZocaloResults
+from ophyd_async.fastcs.panda import HDFPanda
+
+from mx_bluesky.hyperion.device_setup_plans.manipulate_sample import (
+    move_aperture_if_required,
+)
+from mx_bluesky.hyperion.device_setup_plans.utils import (
+    start_preparing_data_collection_then_do_plan,
+)
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    FlyScanXRayCentreComposite as FlyScanXRayCentreComposite,
+)
+from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
+    flyscan_xray_centre,
+)
+from mx_bluesky.hyperion.experiment_plans.oav_grid_detection_plan import (
+    OavGridDetectionComposite,
+    grid_detection_plan,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.grid_detection_callback import (
+    GridDetectionCallback,
+    GridParamUpdate,
+)
+from mx_bluesky.hyperion.external_interaction.callbacks.xray_centre.ispyb_callback import (
+    ispyb_activation_wrapper,
+)
+from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.parameters.gridscan import (
+    GridScanWithEdgeDetect,
+    ThreeDGridScan,
+)
+from mx_bluesky.hyperion.utils.context import device_composite_from_context
+
+
+@dataclasses.dataclass
+class GridDetectThenXRayCentreComposite:
+    """All devices which are directly or indirectly required by this plan"""
+
+    aperture_scatterguard: ApertureScatterguard
+    attenuator: Attenuator
+    backlight: Backlight
+    dcm: DCM
+    detector_motion: DetectorMotion
+    eiger: EigerDetector
+    zebra_fast_grid_scan: ZebraFastGridScan
+    flux: Flux
+    oav: OAV
+    pin_tip_detection: PinTipDetection
+    smargon: Smargon
+    synchrotron: Synchrotron
+    s4_slit_gaps: S4SlitGaps
+    undulator: Undulator
+    xbpm_feedback: XBPMFeedback
+    zebra: Zebra
+    zocalo: ZocaloResults
+    panda: HDFPanda
+    panda_fast_grid_scan: PandAFastGridScan
+    robot: BartRobot
+    sample_shutter: ZebraShutter
+
+
+def create_devices(context: BlueskyContext) -> GridDetectThenXRayCentreComposite:
+    return device_composite_from_context(context, GridDetectThenXRayCentreComposite)
+
+
+def create_parameters_for_flyscan_xray_centre(
+    grid_scan_with_edge_params: GridScanWithEdgeDetect,
+    grid_parameters: GridParamUpdate,
+) -> ThreeDGridScan:
+    params_json = grid_scan_with_edge_params.model_dump()
+    params_json.update(grid_parameters)
+    flyscan_xray_centre_parameters = ThreeDGridScan(**params_json)
+    LOGGER.info(f"Parameters for FGS: {flyscan_xray_centre_parameters}")
+    return flyscan_xray_centre_parameters
+
+
+def detect_grid_and_do_gridscan(
+    composite: GridDetectThenXRayCentreComposite,
+    parameters: GridScanWithEdgeDetect,
+    oav_params: OAVParameters,
+):
+    snapshot_template = f"{parameters.detector_params.prefix}_{parameters.detector_params.run_number}_{{angle}}"
+
+    grid_params_callback = GridDetectionCallback(composite.oav.parameters)
+
+    @bpp.subs_decorator([grid_params_callback])
+    def run_grid_detection_plan(
+        oav_params,
+        snapshot_template,
+        snapshot_dir: Path,
+    ):
+        grid_detect_composite = OavGridDetectionComposite(
+            backlight=composite.backlight,
+            oav=composite.oav,
+            smargon=composite.smargon,
+            pin_tip_detection=composite.pin_tip_detection,
+        )
+
+        yield from grid_detection_plan(
+            grid_detect_composite,
+            oav_params,
+            snapshot_template,
+            str(snapshot_dir),
+            grid_width_microns=parameters.grid_width_um,
+        )
+
+    yield from run_grid_detection_plan(
+        oav_params,
+        snapshot_template,
+        parameters.snapshot_directory,
+    )
+
+    yield from bps.abs_set(
+        composite.backlight, BacklightPosition.OUT, group=CONST.WAIT.GRID_READY_FOR_DC
+    )
+
+    yield from move_aperture_if_required(
+        composite.aperture_scatterguard,
+        parameters.selected_aperture,
+        group=CONST.WAIT.GRID_READY_FOR_DC,
+    )
+
+    yield from flyscan_xray_centre(
+        FlyScanXRayCentreComposite(
+            aperture_scatterguard=composite.aperture_scatterguard,
+            attenuator=composite.attenuator,
+            backlight=composite.backlight,
+            eiger=composite.eiger,
+            panda_fast_grid_scan=composite.panda_fast_grid_scan,
+            flux=composite.flux,
+            s4_slit_gaps=composite.s4_slit_gaps,
+            smargon=composite.smargon,
+            undulator=composite.undulator,
+            synchrotron=composite.synchrotron,
+            xbpm_feedback=composite.xbpm_feedback,
+            zebra=composite.zebra,
+            zocalo=composite.zocalo,
+            panda=composite.panda,
+            zebra_fast_grid_scan=composite.zebra_fast_grid_scan,
+            dcm=composite.dcm,
+            robot=composite.robot,
+            sample_shutter=composite.sample_shutter,
+        ),
+        create_parameters_for_flyscan_xray_centre(
+            parameters, grid_params_callback.get_grid_parameters()
+        ),
+    )
+
+
+def grid_detect_then_xray_centre(
+    composite: GridDetectThenXRayCentreComposite,
+    parameters: GridScanWithEdgeDetect,
+    oav_config: str = OAV_CONFIG_JSON,
+) -> MsgGenerator:
+    """
+    A plan which combines the collection of snapshots from the OAV and the determination
+    of the grid dimensions to use for the following grid scan.
+    """
+
+    eiger: EigerDetector = composite.eiger
+
+    eiger.set_detector_parameters(parameters.detector_params)
+
+    oav_params = OAVParameters("xrayCentring", oav_config)
+
+    plan_to_perform = ispyb_activation_wrapper(
+        detect_grid_and_do_gridscan(
+            composite,
+            parameters,
+            oav_params,
+        ),
+        parameters,
+    )
+
+    return start_preparing_data_collection_then_do_plan(
+        eiger,
+        composite.detector_motion,
+        parameters.detector_params.detector_distance,
+        plan_to_perform,
+        group=CONST.WAIT.GRID_READY_FOR_DC,
+    )

mx_bluesky/hyperion/experiment_plans/oav_grid_detection_plan.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import dataclasses
+import math
+from typing import TYPE_CHECKING
+
+import bluesky.plan_stubs as bps
+import numpy as np
+from blueapi.core import BlueskyContext
+from dodal.devices.backlight import Backlight
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.oav.pin_image_recognition.utils import NONE_VALUE
+from dodal.devices.oav.utils import PinNotFoundException, wait_for_tip_to_be_found
+from dodal.devices.smargon import Smargon
+
+from mx_bluesky.hyperion.device_setup_plans.setup_oav import (
+    pre_centring_setup_oav,
+)
+from mx_bluesky.hyperion.exceptions import catch_exception_and_warn
+from mx_bluesky.hyperion.log import LOGGER
+from mx_bluesky.hyperion.parameters.constants import CONST
+from mx_bluesky.hyperion.utils.context import device_composite_from_context
+
+if TYPE_CHECKING:
+    from dodal.devices.oav.oav_parameters import OAVParameters
+
+
+@dataclasses.dataclass
+class OavGridDetectionComposite:
+    """All devices which are directly or indirectly required by this plan"""
+
+    backlight: Backlight
+    oav: OAV
+    smargon: Smargon
+    pin_tip_detection: PinTipDetection
+
+
+def create_devices(context: BlueskyContext) -> OavGridDetectionComposite:
+    return device_composite_from_context(context, OavGridDetectionComposite)
+
+
+def get_min_and_max_y_of_pin(
+    top: np.ndarray, bottom: np.ndarray, full_image_height_px: int
+) -> tuple[int, int]:
+    """Gives the minimum and maximum y that would cover the whole pin.
+
+    First filters out where no edge was found or the edge covers the full image.
+    If this results in no edges found then returns a min/max that covers the full image
+    """
+    filtered_top = top[np.where((top != 0) & (top != NONE_VALUE))]
+    min_y = min(filtered_top) if len(filtered_top) else 0
+    filtered_bottom = bottom[
+        np.where((bottom != full_image_height_px) & (bottom != NONE_VALUE))
+    ]
+    max_y = max(filtered_bottom) if len(filtered_bottom) else full_image_height_px
+    return min_y, max_y
+
+
+def grid_detection_plan(
+    composite: OavGridDetectionComposite,
+    parameters: OAVParameters,
+    snapshot_template: str,
+    snapshot_dir: str,
+    grid_width_microns: float,
+    box_size_um: float = 20,
+):
+    """
+    Creates the parameters for two grids that are 90 degrees from each other and
+    encompass the whole of the sample as it appears in the OAV.
+
+    Args:
+        composite (OavGridDetectionComposite): Composite containing devices for doing a grid detection.
+        parameters (OAVParameters): Object containing parameters for setting up the OAV
+        snapshot_template (str): A template for the name of the snapshots, expected to be filled in with an angle
+        snapshot_dir (str): The location to save snapshots
+        grid_width_microns (int): The width of the grid to scan in microns
+        box_size_um (float): The size of each box of the grid in microns
+    """
+    oav: OAV = composite.oav
+    smargon: Smargon = composite.smargon
+    pin_tip_detection: PinTipDetection = composite.pin_tip_detection
+
+    LOGGER.info("OAV Centring: Starting grid detection centring")
+
+    yield from bps.wait()
+
+    # Set relevant PVs to whatever the config dictates.
+    yield from pre_centring_setup_oav(oav, parameters, pin_tip_detection)
+
+    LOGGER.info("OAV Centring: Camera set up")
+
+    assert isinstance(oav.parameters.micronsPerXPixel, float)
+    box_size_x_pixels = box_size_um / oav.parameters.micronsPerXPixel
+    assert isinstance(oav.parameters.micronsPerYPixel, float)
+    box_size_y_pixels = box_size_um / oav.parameters.micronsPerYPixel
+
+    grid_width_pixels = int(grid_width_microns / oav.parameters.micronsPerXPixel)
+
+    # The FGS uses -90 so we need to match it
+    for angle in [0, -90]:
+        yield from bps.mv(smargon.omega, angle)
+        # need to wait for the OAV image to update
+        # See #673 for improvements
+        yield from bps.sleep(CONST.HARDWARE.OAV_REFRESH_DELAY)
+
+        tip_x_px, tip_y_px = yield from catch_exception_and_warn(
+            PinNotFoundException, wait_for_tip_to_be_found, pin_tip_detection
+        )
+
+        LOGGER.info(f"Tip is at x,y: {tip_x_px},{tip_y_px}")
+
+        top_edge = np.array((yield from bps.rd(pin_tip_detection.triggered_top_edge)))
+        bottom_edge = np.array(
+            (yield from bps.rd(pin_tip_detection.triggered_bottom_edge))
+        )
+
+        full_image_height_px = yield from bps.rd(oav.cam.array_size.array_size_y)
+
+        # only use the area from the start of the pin onwards
+        top_edge = top_edge[tip_x_px : tip_x_px + grid_width_pixels]
+        bottom_edge = bottom_edge[tip_x_px : tip_x_px + grid_width_pixels]
+        LOGGER.info(f"OAV Edge detection top: {list(top_edge)}")
+        LOGGER.info(f"OAV Edge detection bottom: {list(bottom_edge)}")
+
+        min_y, max_y = (
+            float(n)
+            for n in get_min_and_max_y_of_pin(
+                top_edge, bottom_edge, full_image_height_px
+            )
+        )
+
+        grid_height_px: float = max_y - min_y
+
+        y_steps: int = math.ceil(grid_height_px / box_size_y_pixels)
+
+        # Panda not configured to run a half complete snake so enforce even rows on first grid
+        # See https://github.com/DiamondLightSource/hyperion/wiki/PandA-constant%E2%80%90motion-scanning#motion-program-summary
+        if y_steps % 2 and angle == 0:
+            LOGGER.debug(
+                f"Forcing number of rows in first grid to be even: Adding an extra row onto bottom of first grid and shifting grid upwards by {box_size_y_pixels/2}"
+            )
+            y_steps += 1
+            min_y -= box_size_y_pixels / 2
+            max_y += box_size_y_pixels / 2
+            grid_height_px += box_size_y_pixels
+
+        LOGGER.info(f"Drawing snapshot {grid_width_pixels} by {grid_height_px}")
+
+        x_steps = math.ceil(grid_width_pixels / box_size_x_pixels)
+
+        upper_left = (tip_x_px, min_y)
+
+        yield from bps.abs_set(oav.grid_snapshot.top_left_x, upper_left[0])
+        yield from bps.abs_set(oav.grid_snapshot.top_left_y, upper_left[1])
+        yield from bps.abs_set(oav.grid_snapshot.box_width, box_size_x_pixels)
+        yield from bps.abs_set(oav.grid_snapshot.num_boxes_x, x_steps)
+        yield from bps.abs_set(oav.grid_snapshot.num_boxes_y, y_steps)
+
+        snapshot_filename = snapshot_template.format(angle=abs(angle))
+
+        yield from bps.abs_set(oav.grid_snapshot.filename, snapshot_filename)
+        yield from bps.abs_set(oav.grid_snapshot.directory, snapshot_dir)
+        yield from bps.trigger(oav.grid_snapshot, wait=True)
+        yield from bps.create(CONST.DESCRIPTORS.OAV_GRID_SNAPSHOT_TRIGGERED)
+
+        yield from bps.read(oav.grid_snapshot)
+        yield from bps.read(smargon)
+        yield from bps.save()
+
+        LOGGER.info(
+            f"Grid calculated at {angle}: {x_steps} by {y_steps} steps starting at {upper_left}px"
+        )

mx_bluesky/hyperion/experiment_plans/oav_snapshot_plan.py

@@ -0,0 +1,81 @@
+from datetime import datetime
+from typing import Protocol
+
+from blueapi.core import MsgGenerator
+from bluesky import plan_stubs as bps
+from dodal.devices.aperturescatterguard import ApertureScatterguard, ApertureValue
+from dodal.devices.backlight import Backlight, BacklightPosition
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.oav_parameters import OAVParameters
+from dodal.devices.smargon import Smargon
+
+from mx_bluesky.hyperion.device_setup_plans.setup_oav import setup_general_oav_params
+from mx_bluesky.hyperion.parameters.components import WithSnapshot
+from mx_bluesky.hyperion.parameters.constants import CONST, DocDescriptorNames
+
+OAV_SNAPSHOT_SETUP_SHOT = "oav_snapshot_setup_shot"
+OAV_SNAPSHOT_GROUP = "oav_snapshot_group"
+
+
+class OavSnapshotComposite(Protocol):
+    smargon: Smargon
+    oav: OAV
+    aperture_scatterguard: ApertureScatterguard
+    backlight: Backlight
+
+
+def setup_beamline_for_OAV(
+    smargon: Smargon,
+    backlight: Backlight,
+    aperture_scatterguard: ApertureScatterguard,
+    group=CONST.WAIT.READY_FOR_OAV,
+):
+    max_vel = yield from bps.rd(smargon.omega.max_velocity)
+    yield from bps.abs_set(smargon.omega.velocity, max_vel, group=group)
+    yield from bps.abs_set(backlight, BacklightPosition.IN, group=group)
+    yield from bps.abs_set(
+        aperture_scatterguard,
+        ApertureValue.ROBOT_LOAD,
+        group=group,
+    )
+
+
+def oav_snapshot_plan(
+    composite: OavSnapshotComposite,
+    parameters: WithSnapshot,
+    oav_parameters: OAVParameters,
+    wait: bool = True,
+) -> MsgGenerator:
+    if not parameters.take_snapshots:
+        return
+    yield from bps.wait(group=CONST.WAIT.READY_FOR_OAV)
+    yield from _setup_oav(composite, parameters, oav_parameters)
+    for omega in parameters.snapshot_omegas_deg or []:
+        yield from _take_oav_snapshot(composite, omega)
+
+
+def _setup_oav(
+    composite: OavSnapshotComposite,
+    parameters: WithSnapshot,
+    oav_parameters: OAVParameters,
+):
+    yield from setup_general_oav_params(composite.oav, oav_parameters)
+    yield from bps.abs_set(
+        composite.oav.snapshot.directory, str(parameters.snapshot_directory)
+    )
+
+
+def _take_oav_snapshot(composite: OavSnapshotComposite, omega: float):
+    yield from bps.abs_set(
+        composite.smargon.omega, omega, group=OAV_SNAPSHOT_SETUP_SHOT
+    )
+    time_now = datetime.now()
+    filename = f"{time_now.strftime('%H%M%S')}_oav_snapshot_{omega:.0f}"
+    yield from bps.abs_set(
+        composite.oav.snapshot.filename, filename, group=OAV_SNAPSHOT_SETUP_SHOT
+    )
+    yield from bps.wait(group=OAV_SNAPSHOT_SETUP_SHOT)
+    yield from bps.trigger(composite.oav.snapshot, wait=True)
+    yield from bps.create(DocDescriptorNames.OAV_ROTATION_SNAPSHOT_TRIGGERED)
+    yield from bps.read(composite.oav.snapshot)
+    yield from bps.save()