dls-dodal 1.34.1__py3-none-any.whl → 1.35.0__py3-none-any.whl

dodal/devices/zebra_controlled_shutter.py

@@ -1,21 +1,20 @@
-from enum import Enum
-
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_w
 
 
-class ZebraShutterState(str, Enum):
+class ZebraShutterState(StrictEnum):
     CLOSE = "Close"
     OPEN = "Open"
 
 
-class ZebraShutterControl(str, Enum):
+class ZebraShutterControl(StrictEnum):
     MANUAL = "Manual"
     AUTO = "Auto"
 
@@ -26,7 +25,7 @@ class ZebraShutter(StandardReadable, Movable):
     Internally in the zebra there are two AND gates, one for manual control and one for
     automatic control. A soft input (aliased to control_mode) will switch between
     which of these AND gates to use. For the manual gate the shutter is then controlled
-    by a different soft input (aliased to _manual_position_setpoint). Both these AND
+    by a different soft input (aliased to manual_position_setpoint). Both these AND
     gates then feed into an OR gate, which then feeds to the shutter."""
 
     def __init__(self, prefix: str, name: str):

dodal/devices/zocalo/__init__.py

@@ -4,14 +4,14 @@ from dodal.devices.zocalo.zocalo_results import (
     NoZocaloSubscription,
     XrcResult,
     ZocaloResults,
-    get_processing_result,
+    get_full_processing_results,
 )
 
 __all__ = [
     "ZocaloResults",
     "XrcResult",
     "ZocaloTrigger",
-    "get_processing_result",
+    "get_full_processing_results",
     "ZOCALO_READING_PLAN_NAME",
     "NoResultsFromZocalo",
     "NoZocaloSubscription",

dodal/devices/zocalo/zocalo_constants.py

@@ -0,0 +1,3 @@
+from dodal.utils import is_test_mode
+
+ZOCALO_ENV = "dev_bluesky" if is_test_mode() else "bluesky"

dodal/devices/zocalo/zocalo_interaction.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 import zocalo.configuration
 from workflows.transport import lookup
 
+from dodal.devices.zocalo.zocalo_constants import ZOCALO_ENV
 from dodal.log import LOGGER
 
 
@@ -56,7 +57,7 @@ class ZocaloTrigger:
 
     see https://github.com/DiamondLightSource/dodal/wiki/How-to-Interact-with-Zocalo"""
 
-    def __init__(self, environment: str = "artemis"):
+    def __init__(self, environment: str = ZOCALO_ENV):
         self.zocalo_environment: str = environment
 
     def _send_to_zocalo(self, parameters: dict):

dodal/devices/zocalo/zocalo_results.py

@@ -1,7 +1,7 @@
 import asyncio
-from collections import OrderedDict
 from collections.abc import Generator, Sequence
 from enum import Enum
+from inspect import get_annotations
 from queue import Empty, Queue
 from typing import Any, TypedDict
 
@@ -9,17 +9,19 @@ import bluesky.plan_stubs as bps
 import numpy as np
 import workflows.recipe
 import workflows.transport
-from bluesky.protocols import Descriptor, Triggerable
+from bluesky.protocols import Triggerable
+from bluesky.utils import Msg
 from deepdiff import DeepDiff
 from numpy.typing import NDArray
 from ophyd_async.core import (
     AsyncStatus,
-    HintedSignal,
     StandardReadable,
+    StandardReadableFormat,
     soft_signal_r_and_setter,
 )
 from workflows.transport.common_transport import CommonTransport
 
+from dodal.devices.zocalo.zocalo_constants import ZOCALO_ENV
 from dodal.devices.zocalo.zocalo_interaction import _get_zocalo_connection
 from dodal.log import LOGGER
 
@@ -51,7 +53,7 @@ ZOCALO_STAGE_GROUP = "clear zocalo queue"
 
 
 class XrcResult(TypedDict):
-    centre_of_mass: list[int]
+    centre_of_mass: list[float]
     max_voxel: list[int]
     max_count: int
     n_voxels: int
@@ -114,7 +116,7 @@ class ZocaloResults(StandardReadable, Triggerable):
     def __init__(
         self,
         name: str = "zocalo",
-        zocalo_environment: str = "dev_artemis",
+        zocalo_environment: str = ZOCALO_ENV,
         channel: str = "xrc.i03",
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
@@ -130,14 +132,23 @@ class ZocaloResults(StandardReadable, Triggerable):
         self.transport: CommonTransport | None = None
         self.use_cpu_and_gpu = use_cpu_and_gpu
 
-        self.results, self._results_setter = soft_signal_r_and_setter(
-            list[XrcResult], name="results"
+        self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="centre_of_mass"
         )
-        self.centres_of_mass, self._com_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], name="centres_of_mass"
+        self.bounding_box, self._bounding_box_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="bounding_box"
         )
-        self.bbox_sizes, self._bbox_setter = soft_signal_r_and_setter(
-            NDArray[np.uint64], "bbox_sizes", self.name
+        self.max_voxel, self._max_voxel_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="max_voxel"
+        )
+        self.max_count, self._max_count_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="max_count"
+        )
+        self.n_voxels, self._n_voxels_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="n_voxels"
+        )
+        self.total_count, self._total_count_setter = soft_signal_r_and_setter(
+            NDArray[np.uint64], name="total_count"
         )
         self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
             int, name="ispyb_dcid"
@@ -147,22 +158,27 @@ class ZocaloResults(StandardReadable, Triggerable):
         )
         self.add_readables(
             [
-                self.results,
-                self.centres_of_mass,
-                self.bbox_sizes,
+                self.max_voxel,
+                self.max_count,
+                self.n_voxels,
+                self.total_count,
+                self.centre_of_mass,
+                self.bounding_box,
                 self.ispyb_dcid,
                 self.ispyb_dcgid,
             ],
-            wrapper=HintedSignal,
+            format=StandardReadableFormat.HINTED_SIGNAL,
         )
         super().__init__(name)
 
     async def _put_results(self, results: Sequence[XrcResult], recipe_parameters):
-        self._results_setter(list(results))
         centres_of_mass = np.array([r["centre_of_mass"] for r in results])
-        bbox_sizes = np.array([bbox_size(r) for r in results])
         self._com_setter(centres_of_mass)
-        self._bbox_setter(bbox_sizes)
+        self._bounding_box_setter(np.array([r["bounding_box"] for r in results]))
+        self._max_voxel_setter(np.array([r["max_voxel"] for r in results]))
+        self._max_count_setter(np.array([r["max_count"] for r in results]))
+        self._n_voxels_setter(np.array([r["n_voxels"] for r in results]))
+        self._total_count_setter(np.array([r["total_count"] for r in results]))
         self._ispyb_dcid_setter(recipe_parameters["dcid"])
         self._ispyb_dcgid_setter(recipe_parameters["dcgid"])
 
@@ -286,48 +302,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         finally:
             self._kickoff_run = False
 
-    async def describe(self) -> dict[str, Descriptor]:
-        zocalo_array_type: Descriptor = {
-            "source": f"zocalo_service:{self.zocalo_environment}",
-            "dtype": "array",
-            "shape": [-1, 3],
-        }
-        zocalo_int_type: Descriptor = {
-            "source": f"zocalo_service:{self.zocalo_environment}",
-            "dtype": "integer",
-            "shape": [0],
-        }
-        return OrderedDict(
-            [
-                (
-                    self._name + "-results",
-                    {
-                        "source": f"zocalo_service:{self.zocalo_environment}",
-                        "dtype": "array",
-                        "shape": [
-                            -1,
-                        ],  # TODO describe properly - see https://github.com/DiamondLightSource/dodal/issues/253
-                    },
-                ),
-                (
-                    self._name + "-centres_of_mass",
-                    zocalo_array_type,
-                ),
-                (
-                    self._name + "-bbox_sizes",
-                    zocalo_array_type,
-                ),
-                (
-                    self._name + "-ispyb_dcid",
-                    zocalo_int_type,
-                ),
-                (
-                    self._name + "-ispyb_dcgid",
-                    zocalo_int_type,
-                ),
-            ],
-        )
-
     def _subscribe_to_results(self):
         self.transport = _get_zocalo_connection(self.zocalo_environment)
 
@@ -364,23 +338,62 @@ class ZocaloResults(StandardReadable, Triggerable):
         )
 
 
-def get_processing_result(
+def _corrected_xrc_result(uncorrected: XrcResult) -> XrcResult:
+    corrected = XrcResult(**uncorrected)
+    corrected["centre_of_mass"] = [
+        coord - 0.5 for coord in uncorrected["centre_of_mass"]
+    ]
+    return corrected
+
+
+def get_full_processing_results(
     zocalo: ZocaloResults,
-) -> Generator[Any, Any, tuple[np.ndarray, np.ndarray] | tuple[None, None]]:
-    """A minimal plan which will extract the top ranked xray centre and crystal bounding
-    box size from the zocalo results. Returns (None, None) if no crystals were found."""
-
-    LOGGER.info("Getting zocalo processing results.")
-    centres_of_mass = yield from bps.rd(zocalo.centres_of_mass, default_value=[])  # type: ignore
-    LOGGER.debug(f"Centres of mass: {centres_of_mass}")
-    centre_of_mass = (
-        None
-        if len(centres_of_mass) == 0  # type: ignore
-        else centres_of_mass[0] - np.array([0.5, 0.5, 0.5])  # type: ignore
-    )
-    LOGGER.debug(f"Adjusted top centring result: {centre_of_mass}")
-    bbox_sizes = yield from bps.rd(zocalo.bbox_sizes, default_value=[])  # type: ignore
-    LOGGER.debug(f"Bounding box sizes: {centres_of_mass}")
-    bbox_size = None if len(bbox_sizes) == 0 else bbox_sizes[0]  # type: ignore
-    LOGGER.debug(f"Top bbox size: {bbox_size}")
-    return centre_of_mass, bbox_size
+) -> Generator[Msg, Any, Sequence[XrcResult]]:
+    """A plan that will return the raw zocalo results, ranked in descending order according to the sort key.
+    Returns empty list in the event no results found."""
+    LOGGER.info("Retrieving raw zocalo processing results")
+    com = yield from bps.rd(zocalo.centre_of_mass, default_value=[])  # type: ignore
+    max_voxel = yield from bps.rd(zocalo.max_voxel, default_value=[])  # type: ignore
+    max_count = yield from bps.rd(zocalo.max_count, default_value=[])  # type: ignore
+    n_voxels = yield from bps.rd(zocalo.n_voxels, default_value=[])  # type: ignore
+    total_count = yield from bps.rd(zocalo.total_count, default_value=[])  # type: ignore
+    bounding_box = yield from bps.rd(zocalo.bounding_box, default_value=[])  # type: ignore
+    return [
+        _corrected_xrc_result(
+            XrcResult(
+                centre_of_mass=com.tolist(),
+                max_voxel=mv.tolist(),
+                max_count=int(mc),
+                n_voxels=int(n),
+                total_count=int(tc),
+                bounding_box=bb.tolist(),
+            )
+        )
+        for com, mv, mc, n, tc, bb in zip(
+            com, max_voxel, max_count, n_voxels, total_count, bounding_box, strict=True
+        )
+    ]
+
+
+def get_processing_results_from_event(
+    device_name: str, doc: dict
+) -> Sequence[XrcResult]:
+    """
+    Decode an event document into the corresponding x-ray centring results
+
+    Args:
+    doc         A bluesky event document containing the signals read from the ZocaloResults
+    device_name The device name prefix to prepend to the document keys
+
+    Returns:
+        The list of XrcResults decoded from the event document
+    """
+    results_keys = get_annotations(XrcResult).keys()
+    results_dict = {k: doc["data"][f"{device_name}-{k}"] for k in results_keys}
+    results_values = [results_dict[k].tolist() for k in results_keys]
+
+    def create_result(*argv):
+        kwargs = dict(zip(results_keys, argv, strict=False))
+        return XrcResult(**kwargs)
+
+    return list(map(create_result, *results_values))

dodal/utils.py

@@ -79,6 +79,10 @@ def get_beamline_name(default: str) -> str:
     return environ.get("BEAMLINE") or default
 
 
+def is_test_mode() -> bool:
+    return environ.get("DODAL_TEST_MODE") == "true"
+
+
 def get_hostname() -> str:
     return socket.gethostname().split(".")[0]
 

dodal/devices/i24/i24_vgonio.py

@@ -1,17 +0,0 @@
-from ophyd import Component as Cpt
-from ophyd import EpicsMotor
-from ophyd.epics_motor import MotorBundle
-
-
-class VGonio(MotorBundle):
-    x = Cpt(EpicsMotor, "PINX")
-    z = Cpt(EpicsMotor, "PINZ")
-    yh = Cpt(EpicsMotor, "PINYH")
-    omega = Cpt(EpicsMotor, "OMEGA")
-    kappa = Cpt(EpicsMotor, "KAPPA")
-    phi = Cpt(EpicsMotor, "PHI")
-
-    # Real motors
-    xs = Cpt(EpicsMotor, "PINXS")
-    ys = Cpt(EpicsMotor, "PINXS")
-    zs = Cpt(EpicsMotor, "PINZS")