mx-bluesky 1.5.11__py3-none-any.whl → 1.5.14__py3-none-any.whl

mx_bluesky/Getting started.ipynb

@@ -0,0 +1,170 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "57c4caad-c26c-45af-9089-659c32e96c18",
+   "metadata": {},
+   "source": [
+    "Welcome to MX-Bluesky! This introduction is aimed at beamline scientists running from a beamline workstation. To confirm your environment is setup correctly,\n",
+    "run the below command to see if you get your expected beamline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9d4cd08b-7097-46c2-9c1a-a71a19681c8d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dodal.utils import get_beamline_name\n",
+    "\n",
+    "beamline = get_beamline_name(\"dev\")\n",
+    "beamline = beamline.replace(\"-\",\"_\") # Convert ixx-n to ixx_n as this is the dodal format\n",
+    "print(f\"Beamline is {beamline}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe671aa3-a6b5-4a96-b27f-36c3d52453d6",
+   "metadata": {},
+   "source": [
+    "Now let's import your beamline module and see what devices are available"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "535811e1-ac7c-435e-af00-681caefd4787",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "synchrotron\n",
+      "sample_motors\n"
+     ]
+    }
+   ],
+   "source": [
+    "import importlib\n",
+    "\n",
+    "from dodal.utils import collect_factories\n",
+    "beamline = \"i02_2\"\n",
+    "module_name = f\"dodal.beamlines.{beamline}\"\n",
+    "beamline_module = importlib.import_module(module_name)\n",
+    "\n",
+    "for device in collect_factories(beamline_module):\n",
+    "    print(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "60768231-ae13-4e64-a1ec-eeec6136514a",
+   "metadata": {},
+   "source": [
+    "The Bluesky RunEngine must be used to interact with these devices. The RunEngine does a lot of things and is quite complicated. Some important benefits:\n",
+    "It can protect against using devices incorrectly, it allows us to pause and resume experiments, we can easily trace the sequence of events in experiments,\n",
+    "and we can customize it to do useful things like automatic plotting.\n",
+    "\n",
+    "A Bluesky plan is the name for any experimental procedure. A plan can be anything from a simple motor movement to a complex data collection involving tens of devices. A plan is made up of plan stubs, which are the most simple atomic operations. The two most common plan stubs are called \"abs_set\" and \"rd\", and these are essentially just writing to and reading from the PV of a device. Here's what that would look like on a simulated motor:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30aaf9a1-3921-4be6-9afa-e81c2b216be8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bluesky import RunEngine\n",
+    "from bluesky import plan_stubs as bps\n",
+    "from ophyd_async.sim import SimMotor\n",
+    "\n",
+    "RE = RunEngine() # Create the RunEngine. We only should be doing this once.\n",
+    "fake_motor = SimMotor() # Create the simulated motor\n",
+    "\n",
+    "# Create the overall plan we want to run in the RunEngine\n",
+    "def my_plan():\n",
+    "    initial_position = yield from bps.rd(fake_motor.user_readback)\n",
+    "    print(f\"Position of the motor before moving it is {initial_position}\")\n",
+    "    #Now move the motor\n",
+    "    yield from bps.abs_set(fake_motor, 5, wait=True) #The code will wait here until the motor has finished moving. The units will be the same as that in EPICS\n",
+    "    final_position = yield from bps.rd(fake_motor.user_readback)\n",
+    "    print(f\"Position of the motor after moving it is {final_position}\")\n",
+    "\n",
+    "# In Bluesky, when we actually run a plan, we must do it through the RunEngine like this\n",
+    "RE(my_plan())\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37d4bee0-561c-423a-85a4-ba8f157bc02a",
+   "metadata": {},
+   "source": [
+    "The above code can look confusing, mainly because of the \"yield from\" syntax. We need this because Bluesky plans are python generators rather then regular functions.\n",
+    "You don't need to understand generators to use Bluesky, you just need to remember than when calling a plan stub, you need to do \"yield from plan_name()\". If you try and call it like a regular function, eg, just doing \"plan_name()\", this won't actually run, and the code may not error - it catches everyone out!\n",
+    " \n",
+    "The above code ran instantly because the simulated motor has infinite velocity by default. We could set it to a realistic speed, then the code would take time to complete. Let's set the velocity using abs_set and try again:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2b7420b-d319-4ea7-b23f-4f4dad94eb34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from time import time\n",
+    "\n",
+    "RE(bps.abs_set(fake_motor, 0, wait=True)) # Move motor back to 0\n",
+    "RE(bps.abs_set(fake_motor.velocity, 2, wait=True)) #2 units per second\n",
+    "start_time = time()\n",
+    "RE(my_plan())\n",
+    "print(f\"Movement took {round(time()-start_time,2)}s\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "897483ec-bb9f-42f3-ad8b-15820bf613ee",
+   "metadata": {},
+   "source": [
+    "Note that the default acceleration of a fake motor is 0.5 units/s/s. To see what a device looks like and what signals are available to it, we recommend navigating the codebase using VSCode. With many devices including motors, the signals\n",
+    "of the dodal device will map very closely to the EPICS interface for that device. With a few exceptions, anything you are used to changing using EDM screens will also be doable inside a Bluesky plan.\n",
+    "\n",
+    "Now try writing a simple Bluesky plan to move a real motor available using the above example code to help."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bb69130d-ffc2-428c-83bf-56c4cbd47ca2",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

mx_bluesky/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.5.11'
-__version_tuple__ = version_tuple = (1, 5, 11)
+__version__ = version = '1.5.14'
+__version_tuple__ = version_tuple = (1, 5, 14)
 
 __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/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,74 @@
+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,
+    sample_name: str = "test",
+    visit: str = "cm40645-5",
+) -> MsgGenerator:
+    time_now = datetime.datetime.now()
+    year_now = str(time_now.year)
+    snapshot_directory = f"/dls/i23/data/{year_now}/{visit}/{sample_name}/snapshots"
+    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,
+    sample_name: str = "test",
+    visit: str = "cm40645-5",
+) -> MsgGenerator:
+    time_now = datetime.datetime.now()
+    year_now = str(time_now.year)
+    snapshot_directory = f"/dls/i23/data/{year_now}/{visit}/{sample_name}/snapshots"
+    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/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