dls-dodal 1.49.0__py3-none-any.whl → 1.51.0__py3-none-any.whl

dodal/devices/p45.py

@@ -41,15 +41,3 @@ class TomoStageWithStretchAndSkew(StandardReadable):
             self.y = SampleY(prefix)
             self.theta = SampleTheta(prefix)
         super().__init__(name)
-
-
-class Choppers(StandardReadable):
-    """
-    Grouping for the P45 chopper motors
-    """
-
-    def __init__(self, prefix: str, name: str = ""):
-        with self.add_children_as_readables():
-            self.x = Motor(prefix + "ENDAT")
-            self.y = Motor(prefix + "BISS")
-        super().__init__(name)

dodal/devices/p60/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.p60.lab_xray_source import LabXraySource, LabXraySourceReadable
+
+__all__ = ["LabXraySource", "LabXraySourceReadable"]

dodal/devices/p60/lab_xray_source.py

@@ -0,0 +1,21 @@
+from ophyd_async.core import (
+    StandardReadable,
+    StrictEnum,
+    soft_signal_r_and_setter,
+)
+
+
+class LabXraySource(StrictEnum):
+    AL_KALPHA = 1486.6
+    MG_KALPHA = 1253.6
+
+
+class LabXraySourceReadable(StandardReadable):
+    """Simple device to get the laboratory x-ray tube energy reading"""
+
+    def __init__(self, xraysource: LabXraySource, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.energy_ev, _ = soft_signal_r_and_setter(
+                float, initial_value=xraysource.value, units="eV"
+            )
+        super().__init__(name)

dodal/devices/pgm.py

@@ -16,7 +16,7 @@ class PGM(StandardReadable):
         self,
         prefix: str,
         grating: type[StrictEnum],
-        gratingPv: str,
+        gratingPv: str = "GRATINGSELECT:SELECT",
         name: str = "",
     ) -> None:
         """

dodal/devices/robot.py

@@ -7,6 +7,7 @@ from ophyd_async.core import (
     AsyncStatus,
     Device,
     StandardReadable,
+    StandardReadableFormat,
     StrictEnum,
     set_and_wait_for_value,
     wait_for_value,
@@ -74,18 +75,21 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
     LOAD_TOLERANCE_MM = 0.02
 
     def __init__(self, name: str, prefix: str) -> None:
-        self.barcode = epics_signal_r(str, prefix + "BARCODE")
-        self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.barcode = epics_signal_r(str, prefix + "BARCODE")
+            self.gonio_pin_sensor = epics_signal_r(PinMounted, prefix + "PIN_MOUNTED")
+
+            self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
+            self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
         self.next_pin = epics_signal_rw_rbv(float, prefix + "NEXT_PIN")
         self.next_puck = epics_signal_rw_rbv(float, prefix + "NEXT_PUCK")
-        self.current_puck = epics_signal_r(float, prefix + "CURRENT_PUCK_RBV")
-        self.current_pin = epics_signal_r(float, prefix + "CURRENT_PIN_RBV")
 
-        self.next_sample_id = epics_signal_rw_rbv(int, prefix + "NEXT_ID")
         self.sample_id = epics_signal_r(int, prefix + "CURRENT_ID_RBV")
+        self.next_sample_id = epics_signal_rw_rbv(int, prefix + "NEXT_ID")
 
         self.load = epics_signal_x(prefix + "LOAD.PROC")
+        self.unload = epics_signal_x(prefix + "UNLD.PROC")
         self.program_running = epics_signal_r(bool, prefix + "PROGRAM_RUNNING")
         self.program_name = epics_signal_r(str, prefix + "PROGRAM_NAME")
 
@@ -93,7 +97,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.controller_error = ErrorStatus(prefix + "CNTL")
 
         self.reset = epics_signal_x(prefix + "RESET.PROC")
-        self.stop = epics_signal_x(prefix + "ABORT.PROC")
+        self.abort = epics_signal_x(prefix + "ABORT.PROC")
         self.init = epics_signal_x(prefix + "INIT.PROC")
         self.soak = epics_signal_x(prefix + "SOAK.PROC")
         self.home = epics_signal_x(prefix + "GOHM.PROC")
@@ -173,7 +177,7 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
                 self._load_pin_and_puck(value),
                 timeout=self.LOAD_TIMEOUT + self.NOT_BUSY_TIMEOUT,
             )
-        except (asyncio.TimeoutError, TimeoutError) as e:
+        except TimeoutError as e:
             # Will only need to catch asyncio.TimeoutError after https://github.com/bluesky/ophyd-async/issues/572
             await self.prog_error.raise_if_error(e)
             await self.controller_error.raise_if_error(e)

dodal/devices/smargon.py

@@ -3,7 +3,7 @@ from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import TypedDict, cast
+from typing import NotRequired, TypedDict, cast
 
 from bluesky import plan_stubs as bps
 from bluesky.protocols import Movable
@@ -11,14 +11,13 @@ from bluesky.utils import Msg
 from ophyd_async.core import (
     AsyncStatus,
     Device,
-    StandardReadable,
     StrictEnum,
     wait_for_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from typing_extensions import NotRequired
 
+from dodal.devices.motors import XYZStage
 from dodal.devices.util.epics_util import SetWhenEnabled
 
 
@@ -116,7 +115,7 @@ class CombinedMove(TypedDict):
     chi: NotRequired[float | None]
 
 
-class Smargon(StandardReadable, Movable):
+class Smargon(XYZStage, Movable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -126,9 +125,6 @@ class Smargon(StandardReadable, Movable):
 
     def __init__(self, prefix: str = "", name: str = ""):
         with self.add_children_as_readables():
-            self.x = Motor(prefix + "X")
-            self.y = Motor(prefix + "Y")
-            self.z = Motor(prefix + "Z")
             self.chi = Motor(prefix + "CHI")
             self.phi = Motor(prefix + "PHI")
             self.omega = Motor(prefix + "OMEGA")
@@ -143,7 +139,7 @@ class Smargon(StandardReadable, Movable):
 
         self.defer_move = epics_signal_rw(DeferMoves, prefix + "CS1:DeferMoves")
 
-        super().__init__(name)
+        super().__init__(prefix, name)
 
     def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
         """Obtain a plan stub that returns the smargon XYZ axis limits
@@ -171,6 +167,9 @@ class Smargon(StandardReadable, Movable):
             for k, v in value.items():
                 if v is not None:
                     tasks.append(getattr(self, k).set(v))
-            await asyncio.gather(*tasks)
         finally:
             await self.defer_move.set(DeferMoves.OFF)
+        # The set() coroutines will not complete until after defer moves has been
+        # switched back off so we cannot wait for them until this point.
+        # see https://github.com/DiamondLightSource/dodal/issues/1315
+        await asyncio.gather(*tasks)

dodal/devices/zocalo/zocalo_results.py

@@ -10,7 +10,6 @@ import workflows.recipe
 import workflows.transport
 from bluesky.protocols import Triggerable
 from bluesky.utils import Msg
-from deepdiff.diff import DeepDiff
 from ophyd_async.core import (
     Array1D,
     AsyncStatus,
@@ -49,6 +48,9 @@ DEFAULT_SORT_KEY = SortKeys.max_count
 CLEAR_QUEUE_WAIT_S = 2.0
 ZOCALO_STAGE_GROUP = "clear zocalo queue"
 
+# Sentinel value required for inserting into the soft signal array
+_NO_SAMPLE_ID = -1
+
 
 class XrcResult(TypedDict):
     """
@@ -69,6 +71,7 @@ class XrcResult(TypedDict):
             as the volume of whole boxes as a half-open range i.e such that
             p1 = (x1, y1, z1) <= p < p2 = (x2, y2, z2) and
             p2 - p1 gives the dimensions in whole voxels.
+         sample_id: The sample id associated with the centre.
     """
 
     centre_of_mass: list[float]
@@ -77,6 +80,7 @@ class XrcResult(TypedDict):
     n_voxels: int
     total_count: int
     bounding_box: list[list[int]]
+    sample_id: int | None
 
 
 def bbox_size(result: XrcResult):
@@ -86,18 +90,6 @@ def bbox_size(result: XrcResult):
     ]
 
 
-def get_dict_differences(
-    dict1: dict, dict1_source: str, dict2: dict, dict2_source: str
-) -> str | None:
-    """Returns a string containing dict1 and dict2 if there are differences between them, greater than a
-    1e-5 tolerance. If dictionaries are identical, return None"""
-
-    diff = DeepDiff(dict1, dict2, math_epsilon=1e-5, ignore_numeric_type_changes=True)
-
-    if diff:
-        return f"Zocalo results from {dict1_source} and {dict2_source} are not identical.\n Results from {dict1_source}: {dict1}\n Results from {dict2_source}: {dict2}"
-
-
 def source_from_results(results):
     return (
         ZocaloSource.GPU.value
@@ -127,10 +119,6 @@ class ZocaloResults(StandardReadable, Triggerable):
 
         prefix (str): EPICS PV prefix for the device
 
-        use_cpu_and_gpu (bool): When True, ZocaloResults will wait for results from the
-        CPU and the GPU, compare them, and provide a warning if the results differ. When
-        False, ZocaloResults will only use results from the CPU
-
         use_gpu (bool): When True, ZocaloResults will take the first set of
         results that it receives (which are likely the GPU results)
 
@@ -144,7 +132,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         sort_key: str = DEFAULT_SORT_KEY.value,
         timeout_s: float = DEFAULT_TIMEOUT,
         prefix: str = "",
-        use_cpu_and_gpu: bool = False,
         use_gpu: bool = False,
     ) -> None:
         self.zocalo_environment = zocalo_environment
@@ -154,7 +141,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         self._prefix = prefix
         self._raw_results_received: Queue = Queue()
         self.transport: CommonTransport | None = None
-        self.use_cpu_and_gpu = use_cpu_and_gpu
         self.use_gpu = use_gpu
 
         self.centre_of_mass, self._com_setter = soft_signal_r_and_setter(
@@ -175,6 +161,9 @@ class ZocaloResults(StandardReadable, Triggerable):
         self.total_count, self._total_count_setter = soft_signal_r_and_setter(
             Array1D[np.uint64], name="total_count"
         )
+        self.sample_id, self._sample_id_setter = soft_signal_r_and_setter(
+            Array1D[np.int64], name="sample_id"
+        )
         self.ispyb_dcid, self._ispyb_dcid_setter = soft_signal_r_and_setter(
             int, name="ispyb_dcid"
         )
@@ -189,6 +178,7 @@ class ZocaloResults(StandardReadable, Triggerable):
                 self.total_count,
                 self.centre_of_mass,
                 self.bounding_box,
+                self.sample_id,
                 self.ispyb_dcid,
                 self.ispyb_dcgid,
             ],
@@ -197,13 +187,15 @@ class ZocaloResults(StandardReadable, Triggerable):
         super().__init__(name)
 
     async def _put_results(self, results: Sequence[XrcResult], recipe_parameters):
-        centres_of_mass = np.array([r["centre_of_mass"] for r in results])
-        self._com_setter(centres_of_mass)
+        self._com_setter(np.array([r["centre_of_mass"] for r in results]))
         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._sample_id_setter(
+            np.array([r.get("sample_id") or _NO_SAMPLE_ID for r in results])
+        )
         self._ispyb_dcid_setter(recipe_parameters["dcid"])
         self._ispyb_dcgid_setter(recipe_parameters["dcgid"])
 
@@ -218,11 +210,6 @@ class ZocaloResults(StandardReadable, Triggerable):
         clearing the queue. Plans using this device should wait on ZOCALO_STAGE_GROUP
         before triggering processing for the experiment"""
 
-        if self.use_cpu_and_gpu and self.use_gpu:
-            raise ValueError(
-                "Cannot compare GPU and CPU results and use GPU results at the same time."
-            )
-
         LOGGER.info("Subscribing to results queue")
         try:
             self._subscribe_to_results()
@@ -268,55 +255,6 @@ class ZocaloResults(StandardReadable, Triggerable):
                     "Configured to use GPU results but CPU came first, using CPU results."
                 )
 
-            if self.use_cpu_and_gpu:
-                # Wait for results from CPU and GPU, warn and continue if only GPU times out. Error if CPU times out
-                if source_of_first_results == ZocaloSource.CPU:
-                    LOGGER.warning("Received zocalo results from CPU before GPU")
-                raw_results_two_sources = [raw_results]
-                try:
-                    raw_results_two_sources.append(
-                        self._raw_results_received.get(timeout=self.timeout_s / 2)
-                    )
-                    source_of_second_results = source_from_results(
-                        raw_results_two_sources[1]
-                    )
-                    first_results = raw_results_two_sources[0]["results"]
-                    second_results = raw_results_two_sources[1]["results"]
-
-                    if first_results and second_results:
-                        # Compare results from both sources and warn if they aren't the same
-                        differences_str = get_dict_differences(
-                            first_results[0],
-                            source_of_first_results,
-                            second_results[0],
-                            source_of_second_results,
-                        )
-                        if differences_str:
-                            LOGGER.warning(differences_str)
-
-                    # Always use CPU results
-                    raw_results = (
-                        raw_results_two_sources[0]
-                        if source_of_first_results == ZocaloSource.CPU
-                        else raw_results_two_sources[1]
-                    )
-
-                except Empty as err:
-                    source_of_missing_results = (
-                        ZocaloSource.CPU.value
-                        if source_of_first_results == ZocaloSource.GPU.value
-                        else ZocaloSource.GPU.value
-                    )
-                    if source_of_missing_results == ZocaloSource.GPU.value:
-                        LOGGER.warning(
-                            f"Zocalo results from {source_of_missing_results} timed out. Using results from {source_of_first_results}"
-                        )
-                    else:
-                        LOGGER.error(
-                            f"Zocalo results from {source_of_missing_results} timed out and GPU results not yet reliable"
-                        )
-                        raise err
-
             LOGGER.info(
                 f"Zocalo results from {source_from_results(raw_results)} processing: found {len(raw_results['results'])} crystals."
             )
@@ -350,7 +288,7 @@ class ZocaloResults(StandardReadable, Triggerable):
 
             results = message.get("results", [])
 
-            if self.use_cpu_and_gpu or self.use_gpu:
+            if self.use_gpu:
                 self._raw_results_received.put(
                     {"results": results, "recipe_parameters": recipe_parameters}
                 )
@@ -360,6 +298,8 @@ class ZocaloResults(StandardReadable, Triggerable):
                     self._raw_results_received.put(
                         {"results": results, "recipe_parameters": recipe_parameters}
                     )
+                else:
+                    LOGGER.warning("Discarding results as they are from GPU")
 
         subscription = workflows.recipe.wrap_subscribe(
             self.transport,
@@ -393,6 +333,7 @@ def get_full_processing_results(
     n_voxels = yield from bps.rd(zocalo.n_voxels, default_value=[])
     total_count = yield from bps.rd(zocalo.total_count, default_value=[])
     bounding_box = yield from bps.rd(zocalo.bounding_box, default_value=[])
+    sample_id = yield from bps.rd(zocalo.sample_id, default_value=[])
     return [
         _corrected_xrc_result(
             XrcResult(
@@ -402,9 +343,17 @@ def get_full_processing_results(
                 n_voxels=int(n),
                 total_count=int(tc),
                 bounding_box=bb.tolist(),
+                sample_id=int(s_id) if s_id != _NO_SAMPLE_ID else None,
             )
         )
-        for com, mv, mc, n, tc, bb in zip(
-            com, max_voxel, max_count, n_voxels, total_count, bounding_box, strict=True
+        for com, mv, mc, n, tc, bb, s_id in zip(
+            com,
+            max_voxel,
+            max_count,
+            n_voxels,
+            total_count,
+            bounding_box,
+            sample_id,
+            strict=True,
         )
     ]