mx-bluesky 1.5.10__py3-none-any.whl → 1.5.12__py3-none-any.whl

mx_bluesky/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.10'
-__version_tuple__ = version_tuple = (1, 5, 10)
+__version__ = version = '1.5.12'
+__version_tuple__ = version_tuple = (1, 5, 12)
 
 __commit_id__ = commit_id = None

mx_bluesky/beamlines/aithre_lasershaping/experiment_plans/robot_load_plan.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+import pydantic
+from dodal.devices.motors import XYZOmegaStage, XYZStage
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.robot import BartRobot, SampleLocation
+
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.constants import CONST
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.robot_load_parameters import (
+    AithreRobotLoad,
+)
+from mx_bluesky.common.device_setup_plans.robot_load_unload import (
+    do_plan_while_lower_gonio_at_home,
+)
+from mx_bluesky.common.experiment_plans.pin_tip_centring_plan import (
+    PinTipCentringComposite,
+    pin_tip_centre_plan,
+)
+from mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+    PlanNameConstants,
+)
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class RobotLoadComposite:
+    # RobotLoad fields
+    robot: BartRobot
+    lower_gonio: XYZStage
+    oav: OAV
+    gonio: XYZOmegaStage
+
+
+def _move_gonio_to_home_position(
+    composite: RobotLoadComposite,
+    x_home: float = 0.0,
+    y_home: float = 0.0,
+    z_home: float = 0.0,
+    omega_home: float = 0.0,
+    group: str = "group",
+):
+    """
+    Move Gonio to home position, default is zero
+    """
+    yield from bps.abs_set(composite.gonio.omega, omega_home, group=group)
+    yield from bps.abs_set(composite.gonio.x, x_home, group=group)
+    yield from bps.abs_set(composite.gonio.y, y_home, group=group)
+    yield from bps.abs_set(composite.gonio.z, z_home, group=group)
+
+    yield from bps.wait(group=group)
+
+
+def _take_robot_snapshots(oav: OAV, directory: Path):
+    time_now = datetime.now()
+    snapshot_format = f"{time_now.strftime('%H%M%S')}_{{device}}_after_load"
+    for device in [oav.snapshot]:
+        yield from bps.abs_set(
+            device.filename, snapshot_format.format(device=device.name)
+        )
+        yield from bps.abs_set(device.directory, str(directory))
+        # Note: should be able to use `wait=True` after https://github.com/bluesky/bluesky/issues/1795
+        yield from bps.trigger(device, group="snapshots")
+        yield from bps.wait("snapshots")
+
+
+def _do_robot_load_and_centre(
+    composite: RobotLoadComposite,
+    sample_location: SampleLocation,
+    sample_id: int,
+    pin_tip_detection: PinTipDetection,
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+):
+    yield from bps.abs_set(composite.robot.next_sample_id, sample_id, wait=True)
+    yield from bps.abs_set(
+        composite.robot,
+        sample_location,
+        group="robot_load",
+    )
+
+    yield from _move_gonio_to_home_position(composite=composite, group="robot_load")
+
+    yield from bps.wait(group="robot_load")
+
+    pin_tip_centring_composite = PinTipCentringComposite(
+        composite.oav, composite.gonio, pin_tip_detection
+    )
+    yield from pin_tip_centre_plan(
+        pin_tip_centring_composite, tip_offset_microns, oav_config_file
+    )
+
+
+def _robot_load_and_snapshots(
+    composite: RobotLoadComposite,
+    location: SampleLocation,
+    snapshot_directory: Path,
+    sample_id: int,
+    pin_tip_detection: PinTipDetection,
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+):
+    yield from bps.create(name=DocDescriptorNames.ROBOT_PRE_LOAD)
+    yield from bps.read(composite.robot)
+    yield from bps.save()
+
+    robot_load_plan = _do_robot_load_and_centre(
+        composite,
+        location,
+        sample_id,
+        pin_tip_detection,
+        tip_offset_microns,
+        oav_config_file,
+    )
+
+    gonio_finished = yield from do_plan_while_lower_gonio_at_home(
+        robot_load_plan, composite.lower_gonio
+    )
+    yield from bps.wait(group="snapshot")
+
+    yield from _take_robot_snapshots(composite.oav, snapshot_directory)
+
+    yield from bps.create(name=DocDescriptorNames.ROBOT_UPDATE)
+    yield from bps.read(composite.robot)
+    yield from bps.read(composite.oav.snapshot)
+    yield from bps.save()
+
+    yield from bps.wait(gonio_finished)
+
+
+def robot_load_and_snapshots_plan(
+    composite: RobotLoadComposite,
+    params: AithreRobotLoad,
+    ptd: PinTipDetection,
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+):
+    assert params.sample_puck is not None
+    assert params.sample_pin is not None
+
+    sample_location = SampleLocation(params.sample_puck, params.sample_pin)
+
+    yield from _move_gonio_to_home_position(composite)
+
+    yield from bpp.set_run_key_wrapper(
+        bpp.run_wrapper(
+            _robot_load_and_snapshots(
+                composite,
+                sample_location,
+                params.snapshot_directory,
+                params.sample_id,
+                ptd,
+                tip_offset_microns,
+                oav_config_file,
+            ),
+            md={
+                "subplan_name": PlanNameConstants.ROBOT_LOAD,
+                "metadata": {"visit": params.visit, "sample_id": params.sample_id},
+                "activate_callbacks": [
+                    "RobotLoadISPyBCallback",
+                ],
+            },
+        ),
+        PlanNameConstants.ROBOT_LOAD_AND_SNAPSHOTS,
+    )
+
+
+def robot_unload_plan(
+    composite: RobotLoadComposite,
+    params: AithreRobotLoad,
+):
+    @bpp.run_decorator(
+        md={
+            "subplan_name": PlanNameConstants.ROBOT_UNLOAD,
+            "metadata": {"visit": params.visit, "sample_id": params.sample_id},
+            "activate_callbacks": [
+                "RobotLoadISPyBCallback",
+            ],
+        },
+    )
+    def do_robot_unload_and_send_to_ispyb():
+        yield from _take_robot_snapshots(composite.oav, params.snapshot_directory)
+        yield from bps.wait(group="snapshot")
+        yield from _move_gonio_to_home_position(composite)
+
+        yield from bps.abs_set(composite.robot, None, wait=True)
+
+        yield from bps.create(name=DocDescriptorNames.ROBOT_UPDATE)
+        yield from bps.read(composite.robot)
+        yield from bps.read(composite.oav.snapshot)
+        yield from bps.save()
+
+    yield from do_robot_unload_and_send_to_ispyb()

mx_bluesky/beamlines/aithre_lasershaping/goniometer_controls.py

@@ -53,9 +53,9 @@ def go_to_furthest_maximum(
 ) -> MsgGenerator:
     """Rotate to positive or negative maximum, whichever is further away"""
 
-    LIMIT_OF_TRAVEL = 3600
+    limit_of_travel = 3600
     current_value: float = yield from bps.rd(goniometer.omega.user_readback)
 
     yield from bps.mv(
-        goniometer.omega, -LIMIT_OF_TRAVEL if current_value > 0 else LIMIT_OF_TRAVEL
+        goniometer.omega, -limit_of_travel if current_value > 0 else limit_of_travel
     )

mx_bluesky/beamlines/aithre_lasershaping/parameters/constants.py

@@ -0,0 +1,17 @@
+import os
+
+from pydantic.dataclasses import dataclass
+
+TEST_MODE = os.environ.get("AITHRE_TEST_MODE")
+
+
+@dataclass(frozen=True)
+class AithreConstants:
+    BEAMLINE = "aithre"
+    OAV_CENTRING_FILE = (
+        "/dls/science/groups/i23/aithre/daq_configuration/json/OAVCentring_aithre.json"
+    )
+    LOG_FILE_NAME = "aithre.log"
+
+
+CONST = AithreConstants()

mx_bluesky/beamlines/aithre_lasershaping/parameters/robot_load_parameters.py

@@ -0,0 +1,13 @@
+from mx_bluesky.common.parameters.components import (
+    WithSample,
+    WithSnapshot,
+    WithVisit,
+)
+
+
+class AithreRobotLoad(
+    WithSample,
+    WithSnapshot,
+    WithVisit,
+):
+    pass

mx_bluesky/beamlines/aithre_lasershaping/pin_tip_centring.py

@@ -0,0 +1,31 @@
+from bluesky.utils import MsgGenerator
+from dodal.common import inject
+from dodal.devices.aithre_lasershaping.goniometer import Goniometer
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.constants import CONST
+from mx_bluesky.common.experiment_plans.pin_tip_centring_plan import (
+    PinTipCentringComposite,
+    pin_tip_centre_plan,
+)
+
+
+def aithre_pin_tip_centre(
+    oav: OAV = inject("OAV"),
+    gonio: Goniometer = inject("gonio"),
+    pin_tip_detection: PinTipDetection = inject("pin_tip_detection"),
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+) -> MsgGenerator:
+    """
+    A plan that use pin_tip_centre_plan from common for aithre
+    """
+
+    composite = PinTipCentringComposite(oav, gonio, pin_tip_detection)
+
+    yield from pin_tip_centre_plan(
+        composite=composite,
+        tip_offset_microns=tip_offset_microns,
+        oav_config_file=oav_config_file,
+    )

mx_bluesky/beamlines/aithre_lasershaping/robot_load.py

@@ -0,0 +1,80 @@
+import datetime
+
+from bluesky.utils import MsgGenerator
+from dodal.common import inject
+from dodal.devices.motors import XYZOmegaStage
+from dodal.devices.oav.oav_detector import OAV
+from dodal.devices.oav.pin_image_recognition import PinTipDetection
+from dodal.devices.robot import BartRobot
+
+from mx_bluesky.beamlines.aithre_lasershaping.experiment_plans.robot_load_plan import (
+    RobotLoadComposite,
+    robot_load_and_snapshots_plan,
+    robot_unload_plan,
+)
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.constants import CONST
+from mx_bluesky.beamlines.aithre_lasershaping.parameters.robot_load_parameters import (
+    AithreRobotLoad,
+)
+
+
+def robot_load_and_snapshot(
+    robot: BartRobot = inject("robot"),
+    gonio: XYZOmegaStage = inject("gonio"),
+    oav: OAV = inject("oav"),
+    ptd: PinTipDetection = inject("ptd"),
+    tip_offset_microns: float = 0,
+    oav_config_file: str = CONST.OAV_CENTRING_FILE,
+    sample_puck: int = 0,
+    sample_pin: int = 0,
+    sample_id: int = 0,
+    visit: str = "cm40645-5",
+    categories: str = "",
+) -> MsgGenerator:
+    """
+    categories: type of the sample, e.g. Germ, ProteinaseK, Screening
+    """
+    time_now = datetime.datetime.now()
+    year_now = str(time_now.year)
+    snapshot_directory = f"/dls/i23/data/{year_now}/{visit}/{categories}"
+    composite = RobotLoadComposite(robot, gonio, oav, gonio)
+    params = AithreRobotLoad(
+        sample_id=sample_id,
+        sample_puck=sample_puck,
+        sample_pin=sample_pin,
+        snapshot_directory=snapshot_directory,
+        visit=visit,
+        beamline="BL23I",
+    )
+
+    yield from robot_load_and_snapshots_plan(
+        composite, params, ptd, tip_offset_microns, oav_config_file
+    )
+
+
+def robot_unload(
+    robot: BartRobot = inject("robot"),
+    gonio: XYZOmegaStage = inject("gonio"),
+    oav: OAV = inject("oav"),
+    sample_puck: int = 0,
+    sample_pin: int = 0,
+    sample_id: int = 0,
+    visit: str = "cm40645-5",
+    categories: str = "",
+) -> MsgGenerator:
+    """
+    categories: type of the sample, e.g. Germ, ProteinaseK, Screening
+    """
+    time_now = datetime.datetime.now()
+    year_now = str(time_now.year)
+    snapshot_directory = f"/dls/i23/data/{year_now}/{visit}/{categories}"
+    composite = RobotLoadComposite(robot, gonio, oav, gonio)
+    params = AithreRobotLoad(
+        sample_id=sample_id,
+        sample_puck=sample_puck,
+        sample_pin=sample_pin,
+        snapshot_directory=snapshot_directory,
+        visit=visit,
+        beamline="BL23I",
+    )
+    yield from robot_unload_plan(composite, params)

mx_bluesky/beamlines/i02_1/parameters/gridscan.py

@@ -20,7 +20,7 @@ class SpecifiedTwoDGridScan(
         return self.grid_1_spec
 
     @property
-    def FGS_params(self) -> ZebraGridScanParamsTwoD:
+    def fast_gridscan_params(self) -> ZebraGridScanParamsTwoD:
         return ZebraGridScanParamsTwoD(
             x_steps=self.x_steps,
             y_steps=self.y_steps,

mx_bluesky/beamlines/i04/__init__.py

@@ -1,5 +1,8 @@
 from mx_bluesky.beamlines.i04.experiment_plans.i04_grid_detect_then_xray_centre_plan import (
-    i04_grid_detect_then_xray_centre,
+    i04_default_grid_detect_and_xray_centre,
+)
+from mx_bluesky.beamlines.i04.oav_centering_plans.oav_imaging import (
+    take_oav_image_with_scintillator_in,
 )
 from mx_bluesky.beamlines.i04.thawing_plan import (
     thaw,
@@ -10,6 +13,7 @@ from mx_bluesky.beamlines.i04.thawing_plan import (
 __all__ = [
     "thaw",
     "thaw_and_stream_to_redis",
-    "i04_grid_detect_then_xray_centre",
+    "i04_default_grid_detect_and_xray_centre",
     "thaw_and_murko_centre",
+    "take_oav_image_with_scintillator_in",
 ]

mx_bluesky/beamlines/i04/callbacks/murko_callback.py

@@ -8,6 +8,8 @@ from dodal.log import LOGGER
 from event_model.documents import Event, RunStart, RunStop
 from redis import StrictRedis
 
+FORWARDING_COMPLETE_MESSAGE = "image_forwarding_complete"
+
 
 class OmegaReading(TypedDict):
     value: float
@@ -56,22 +58,28 @@ class MurkoCallback(CallbackBase):
         self.previous_omegas: list[OmegaReading] = []
 
     def start(self, doc: RunStart) -> RunStart | None:
-        self.sample_id = doc.get("sample_id")
-        self.murko_metadata = {
-            "zoom_percentage": doc.get("zoom_percentage"),
-            "microns_per_x_pixel": doc.get("microns_per_x_pixel"),
-            "microns_per_y_pixel": doc.get("microns_per_y_pixel"),
-            "beam_centre_i": doc.get("beam_centre_i"),
-            "beam_centre_j": doc.get("beam_centre_j"),
-            "sample_id": self.sample_id,
-        }
+        self.murko_metadata: dict = {"sample_id": doc.get("sample_id")}
         self.last_uuid = None
         self.previous_omegas = []
-        LOGGER.info(f"Starting to stream metadata to murko under {self.sample_id}")
+        LOGGER.info(
+            f"Starting to stream metadata to murko under {self.murko_metadata['sample_id']}"
+        )
         return doc
 
     def event(self, doc: Event) -> Event:
-        if latest_omega := doc["data"].get("smargon-omega"):
+        data = doc["data"]
+        for prefix in ("oav", "oav_full_screen"):
+            if f"{prefix}-beam_centre_j" in data:
+                self.murko_metadata.update(
+                    {
+                        "microns_per_x_pixel": data[f"{prefix}-microns_per_pixel_x"],
+                        "microns_per_y_pixel": data[f"{prefix}-microns_per_pixel_y"],
+                        "beam_centre_i": data[f"{prefix}-beam_centre_i"],
+                        "beam_centre_j": data[f"{prefix}-beam_centre_j"],
+                    }
+                )
+
+        if (latest_omega := data.get("smargon-omega")) is not None:
             if len(self.previous_omegas) <= 2 and self.last_uuid:
                 # For the first few images there's not enough data to extrapolate so we
                 # match them one to one
@@ -106,5 +114,12 @@ class MurkoCallback(CallbackBase):
         self.redis_client.publish("murko", json.dumps(metadata))
 
     def stop(self, doc: RunStop) -> RunStop | None:
-        LOGGER.info(f"Finished streaming {self.sample_id} to murko")
+        LOGGER.info(f"Finished streaming {self.murko_metadata['sample_id']} to murko")
+        LOGGER.info(
+            f"Publishing forwarding complete message: {FORWARDING_COMPLETE_MESSAGE}"
+        )
+        self.redis_client.publish(
+            "murko",
+            json.dumps(FORWARDING_COMPLETE_MESSAGE),
+        )
         return doc