dls-dodal 1.46.0__py3-none-any.whl → 1.47.0__py3-none-any.whl

dodal/devices/i10/diagnostics.py

@@ -1,6 +1,4 @@
-from bluesky.protocols import Movable
 from ophyd_async.core import (
-    AsyncStatus,
     Device,
     StandardReadable,
     StrictEnum,
@@ -13,7 +11,6 @@ from ophyd_async.epics.core import (
     epics_signal_r,
     epics_signal_rw,
 )
-from ophyd_async.epics.motor import Motor
 
 from dodal.devices.current_amplifiers import (
     CurrentAmpDet,
@@ -23,6 +20,7 @@ from dodal.devices.current_amplifiers import (
     FemtoDDPCA,
     StruckScaler,
 )
+from dodal.devices.positioner import create_positioner
 
 
 class D3Position(StrictEnum):
@@ -70,36 +68,6 @@ class InOutReadBackTable(StrictEnum):
     OUT_OF_BEAM = "Out of Beam"
 
 
-class Positioner(StandardReadable, Movable):
-    """1D stage with a enum table to select positions."""
-
-    def __init__(
-        self,
-        prefix: str,
-        positioner_enum: type[StrictEnum],
-        positioner_suffix: str = "",
-        Positioner_pv_suffix: str = ":MP:SELECT",
-        name: str = "",
-    ) -> None:
-        self._stage_motion = Motor(prefix=prefix + positioner_suffix)
-        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.stage_position = epics_signal_rw(
-                positioner_enum,
-                read_pv=prefix + positioner_suffix + Positioner_pv_suffix,
-            )
-        super().__init__(name=name)
-        self.positioner_enum = positioner_enum
-
-    @AsyncStatus.wrap
-    async def set(self, value: StrictEnum) -> None:
-        if value in self.positioner_enum:
-            await self.stage_position.set(value=value)
-        else:
-            raise ValueError(
-                f"{value} is not an allow position. Position must be: {self.positioner_enum}"
-            )
-
-
 class I10PneumaticStage(StandardReadable):
     """Pneumatic stage only has two real positions in or out.
     Use for fluorescent screen which can be insert into the x-ray beam.
@@ -154,16 +122,13 @@ class FullDiagnostic(Device):
         self,
         prefix: str,
         positioner_enum: type[StrictEnum],
-        positioner_suffix: str = "",
-        Positioner_pv_suffix: str = ":MP:SELECT",
+        positioner_suffix: str,
         cam_infix: str = "DCAM:",
         name: str = "",
     ) -> None:
-        self.positioner = Positioner(
-            prefix=prefix,
-            positioner_enum=positioner_enum,
-            positioner_suffix=positioner_suffix,
-            Positioner_pv_suffix=Positioner_pv_suffix,
+        self.positioner = create_positioner(
+            positioner_enum,
+            prefix + positioner_suffix,
         )
         self.screen = ScreenCam(
             prefix,
@@ -185,28 +150,11 @@ class I10Diagnostic(Device):
             positioner_suffix="DET:X",
         )
         self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
-        self.d5 = Positioner(
-            prefix=prefix + "IONC-01:",
-            positioner_enum=D5Position,
-            positioner_suffix="Y",
-        )
-
-        self.d5A = Positioner(
-            prefix=prefix + "PHDGN-06:",
-            positioner_enum=D5APosition,
-            positioner_suffix="DET:X",
-        )
+        self.d5 = create_positioner(D5Position, f"{prefix}IONC-01:Y")
+        self.d5A = create_positioner(D5APosition, f"{prefix}PHDGN-06:DET:X")
+        self.d6 = FullDiagnostic(f"{prefix}PHDGN-05:", D6Position, "DET:X")
+        self.d7 = create_positioner(D7Position, f"{prefix}PHDGN-07:Y")
 
-        self.d6 = FullDiagnostic(
-            prefix=prefix + "PHDGN-05:",
-            positioner_enum=D6Position,
-            positioner_suffix="DET:X",
-        )
-        self.d7 = Positioner(
-            prefix=prefix + "PHDGN-07:",
-            positioner_enum=D7Position,
-            positioner_suffix="Y",
-        )
         super().__init__(name)
 
 

dodal/devices/i24/focus_mirrors.py

@@ -1,8 +1,6 @@
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import StandardReadable, StrictEnum, derived_signal_r
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
-
 
 class HFocusMode(StrictEnum):
     FOCUS_10 = "HMFMfocus10"
@@ -40,21 +38,19 @@ class FocusMirrorsMode(StandardReadable):
         self.vertical = epics_signal_rw(VFocusMode, prefix + "G0:TARGETAPPLY")
 
         with self.add_children_as_readables():
-            self.beam_size_x = create_r_hardware_backed_soft_signal(
-                int, self._get_beam_size_x, units="um"
+            self.beam_size_x = derived_signal_r(
+                self._get_beam_size_x, horizontal=self.horizontal, derived_units="um"
             )
-            self.beam_size_y = create_r_hardware_backed_soft_signal(
-                int, self._get_beam_size_y, units="um"
+            self.beam_size_y = derived_signal_r(
+                self._get_beam_size_y, vertical=self.vertical, derived_units="um"
             )
 
         super().__init__(name)
 
-    async def _get_beam_size_x(self) -> int:
-        h_mode = await self.horizontal.get_value()
-        beam_x = BEAM_SIZES[h_mode.removeprefix("HMFM")][0]
+    def _get_beam_size_x(self, horizontal: HFocusMode) -> int:
+        beam_x = BEAM_SIZES[horizontal.removeprefix("HMFM")][0]
         return beam_x
 
-    async def _get_beam_size_y(self) -> int:
-        v_mode = await self.vertical.get_value()
-        beam_y = BEAM_SIZES[v_mode.removeprefix("VMFM")][1]
+    def _get_beam_size_y(self, vertical: VFocusMode) -> int:
+        beam_y = BEAM_SIZES[vertical.removeprefix("VMFM")][1]
         return beam_y

dodal/devices/i24/pilatus_metadata.py

@@ -2,11 +2,9 @@
 
 import re
 
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, derived_signal_r
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
-
 
 class PilatusMetadata(StandardReadable):
     def __init__(self, prefix: str, name: str = "") -> None:
@@ -14,21 +12,23 @@ class PilatusMetadata(StandardReadable):
         self.template = epics_signal_r(str, prefix + "cam1:FileTemplate_RBV")
         self.filenumber = epics_signal_r(int, prefix + "cam1:FileNumber_RBV")
         with self.add_children_as_readables():
-            self.filename_template = create_r_hardware_backed_soft_signal(
-                str, self._get_full_filename_template
+            self.filename_template = derived_signal_r(
+                self._get_full_filename_template,
+                filename=self.filename,
+                filename_template=self.template,
+                file_number=self.filenumber,
             )
         super().__init__(name)
 
-    async def _get_full_filename_template(self) -> str:
+    def _get_full_filename_template(
+        self, filename: str, filename_template: str, file_number: int
+    ) -> str:
         """
         Get the template file path by querying the detector PVs.
         Mirror the construction that the PPU does.
 
         Returns: A template string, with the image numbers replaced with '#'
         """
-        filename = await self.filename.get_value()
-        filename_template = await self.template.get_value()
-        file_number = await self.filenumber.get_value()
         # Exploit fact that passing negative numbers will put the - before the 0's
         expected_filename = str(
             filename_template % (filename, f"{file_number:05d}_", -9)

dodal/devices/i24/pmac.py

@@ -10,6 +10,7 @@ from ophyd_async.core import (
     SignalR,
     SignalRW,
     StandardReadable,
+    observe_signals_value,
     soft_signal_rw,
     wait_for_value,
 )
@@ -120,15 +121,16 @@ class ProgramRunner(Device, Flyable):
         self,
         pmac_str_sig: SignalRW,
         status_sig: SignalR,
+        counter_sig: SignalR,
         prog_num_sig: SignalRW,
-        collection_time_sig: SignalRW,
+        counter_time_sig: SignalRW,
         name: str = "",
     ) -> None:
         self._signal_ref = Reference(pmac_str_sig)
         self._status_ref = Reference(status_sig)
+        self._counter_ref = Reference(counter_sig)
         self._prog_num_ref = Reference(prog_num_sig)
-
-        self._collection_time_ref = Reference(collection_time_sig)
+        self._counter_time_ref = Reference(counter_time_sig)
 
         super().__init__(name)
 
@@ -151,16 +153,18 @@ class ProgramRunner(Device, Flyable):
 
     @AsyncStatus.wrap
     async def complete(self):
-        """Stop collecting when the scan status PV goes to 0.
-
-        Args:
-            complete_time (float): total time required by the collection to \
-            finish correctly.
+        """Stop collecting when the scan status PV goes to 0 or when counter PV hasn't \
+            updated for 30 seconds.
         """
-        scan_complete_time = await self._collection_time_ref().get_value()
-        await wait_for_value(
-            self._status_ref(), ScanState.DONE, timeout=scan_complete_time
-        )
+        counter_time = await self._counter_time_ref().get_value()
+        async for signal, value in observe_signals_value(
+            self._status_ref(),
+            self._counter_ref(),
+            timeout=counter_time,
+        ):
+            if signal is self._status_ref():
+                if value == ScanState.DONE:
+                    break
 
 
 class ProgramAbort(Triggerable):
@@ -217,13 +221,14 @@ class PMAC(StandardReadable):
         # A couple of soft signals for running a collection: program number to send to
         # the PMAC_STRING and expected collection time.
         self.program_number = soft_signal_rw(int)
-        self.collection_time = soft_signal_rw(float, initial_value=600.0, units="s")
+        self.counter_time = soft_signal_rw(float, initial_value=30.0, units="s")
 
         self.run_program = ProgramRunner(
             self.pmac_string,
             self.scanstatus,
+            self.counter,
             self.program_number,
-            self.collection_time,
+            self.counter_time,
         )
         self.abort_program = ProgramAbort(self.pmac_string, self.scanstatus)
 

dodal/devices/{i03 → mx_phase1}/beamstop.py

@@ -1,11 +1,9 @@
-from asyncio import gather
 from math import isclose
 
-from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.core import StandardReadable, StrictEnum, derived_signal_r
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class BeamstopPositions(StrictEnum):
@@ -33,7 +31,7 @@ class BeamstopPositions(StrictEnum):
 
 class Beamstop(StandardReadable):
     """
-    Beamstop for I03.
+    Beamstop for I03 and I04.
 
     Attributes:
         x: beamstop x position in mm
@@ -53,8 +51,8 @@ class Beamstop(StandardReadable):
             self.x_mm = Motor(prefix + "X")
             self.y_mm = Motor(prefix + "Y")
             self.z_mm = Motor(prefix + "Z")
-            self.selected_pos = create_r_hardware_backed_soft_signal(
-                BeamstopPositions, self._get_selected_position
+            self.selected_pos = derived_signal_r(
+                self._get_selected_position, x=self.x_mm, y=self.y_mm, z=self.z_mm
             )
 
         self._in_beam_xyz_mm = [
@@ -68,12 +66,8 @@ class Beamstop(StandardReadable):
 
         super().__init__(name)
 
-    async def _get_selected_position(self) -> BeamstopPositions:
-        current_pos = await gather(
-            self.x_mm.user_readback.get_value(),
-            self.y_mm.user_readback.get_value(),
-            self.z_mm.user_readback.get_value(),
-        )
+    def _get_selected_position(self, x: float, y: float, z: float) -> BeamstopPositions:
+        current_pos = [x, y, z]
         if all(
             isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
             for axis_pos, axis_in_beam, axis_tolerance in zip(

dodal/devices/oav/oav_calculations.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 
-def camera_coordinates_to_xyz(
+def camera_coordinates_to_xyz_mm(
     horizontal: float,
     vertical: float,
     omega: float,
@@ -9,7 +9,7 @@ def camera_coordinates_to_xyz(
     microns_per_j_pixel: float,
 ) -> np.ndarray:
     """
-    Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millmeters.
+    Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millimetres.
     For an overview of the coordinate system for I03 see https://github.com/DiamondLightSource/hyperion/wiki/Gridscan-Coordinate-System.
 
     Args:

dodal/devices/oav/oav_detector.py

@@ -6,10 +6,11 @@ from ophyd_async.core import (
     AsyncStatus,
     LazyMock,
     StandardReadable,
+    derived_signal_r,
+    soft_signal_rw,
 )
 from ophyd_async.epics.core import epics_signal_rw
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.devices.areadetector.plugins.CAM import Cam
 from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
 from dodal.devices.oav.snapshots.snapshot import Snapshot
@@ -60,49 +61,58 @@ class OAV(StandardReadable):
         self.zoom_controller = ZoomController(f"{_bl_prefix}-EA-OAV-01:FZOOM:", name)
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
-
         with self.add_children_as_readables():
             self.grid_snapshot = SnapshotWithGrid(f"{prefix}MJPG:", name)
-            self.microns_per_pixel_x = create_r_hardware_backed_soft_signal(
-                float,
-                lambda: self._get_microns_per_pixel(Coords.X),
+
+        self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
+
+        with self.add_children_as_readables():
+            self.microns_per_pixel_x = derived_signal_r(
+                self._get_microns_per_pixel,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.X],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.X.value),
             )
-            self.microns_per_pixel_y = create_r_hardware_backed_soft_signal(
-                float,
-                lambda: self._get_microns_per_pixel(Coords.Y),
+            self.microns_per_pixel_y = derived_signal_r(
+                self._get_microns_per_pixel,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.Y],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
-            self.beam_centre_i = create_r_hardware_backed_soft_signal(
-                int, lambda: self._get_beam_position(Coords.X)
+            self.beam_centre_i = derived_signal_r(
+                self._get_beam_position,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.X],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.X.value),
             )
-            self.beam_centre_j = create_r_hardware_backed_soft_signal(
-                int, lambda: self._get_beam_position(Coords.Y)
+            self.beam_centre_j = derived_signal_r(
+                self._get_beam_position,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.Y],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
             self.snapshot = Snapshot(
                 f"{self._prefix}MJPG:",
                 self._name,
             )
 
-        self.sizes = [self.grid_snapshot.x_size, self.grid_snapshot.y_size]
-
         super().__init__(name)
 
-    async def _read_current_zoom(self) -> str:
-        _zoom = await self.zoom_controller.level.get_value()
+    def _read_current_zoom(self, _zoom: str) -> str:
         return _get_correct_zoom_string(_zoom)
 
-    async def _get_microns_per_pixel(self, coord: int) -> float:
+    def _get_microns_per_pixel(self, zoom_level: str, size: int, coord: int) -> float:
         """Extracts the microns per x pixel and y pixel for a given zoom level."""
-        _zoom = await self._read_current_zoom()
+        _zoom = self._read_current_zoom(zoom_level)
         value = self.parameters[_zoom].microns_per_pixel[coord]
-        size = await self.sizes[coord].get_value()
         return value * DEFAULT_OAV_WINDOW[coord] / size
 
-    async def _get_beam_position(self, coord: int) -> int:
+    def _get_beam_position(self, zoom_level: str, size: int, coord: int) -> int:
         """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
         zoom level. """
-        _zoom = await self._read_current_zoom()
+        _zoom = self._read_current_zoom(zoom_level)
         value = self.parameters[_zoom].crosshair[coord]
-        size = await self.sizes[coord].get_value()
+
         return int(value * size / DEFAULT_OAV_WINDOW[coord])
 
     async def connect(

dodal/devices/oav/utils.py

@@ -7,7 +7,7 @@ from bluesky.utils import Msg
 
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
-    camera_coordinates_to_xyz,
+    camera_coordinates_to_xyz_mm,
 )
 from dodal.devices.oav.oav_detector import OAV
 from dodal.devices.oav.pin_image_recognition import PinTipDetection
@@ -90,7 +90,7 @@ def calculate_x_y_z_of_pixel(
     """Get the x, y, z position of a pixel in mm"""
     beam_distance_px: Pixel = calculate_beam_distance(beam_centre, *pixel)
 
-    return current_x_y_z + camera_coordinates_to_xyz(
+    return current_x_y_z + camera_coordinates_to_xyz_mm(
         beam_distance_px[0],
         beam_distance_px[1],
         current_omega,

dodal/devices/p99/andor2_point.py

@@ -0,0 +1,41 @@
+from ophyd_async.core import (
+    StandardReadableFormat,
+)
+from ophyd_async.epics.adandor import Andor2DriverIO
+from ophyd_async.epics.adcore import NDPluginBaseIO, SingleTriggerDetector
+from ophyd_async.epics.core import epics_signal_r
+
+
+class Andor2Point(SingleTriggerDetector):
+    """Using the andor2 as if it is a massive point detector, read the read uncached
+    value after a picture is taken."""
+
+    def __init__(
+        self,
+        prefix: str,
+        drv_suffix: str,
+        read_uncached: dict[str, str],
+        name: str = "",
+        plugins: dict[str, NDPluginBaseIO] | None = None,
+    ) -> None:
+        """
+        Parameters
+        ----------
+        prefix: str,
+           Beamline camera pv
+        drv_suffix : str,
+            Camera pv suffix
+        read_uncached: dict[str,str]
+            A dictionary contains the name and the pv suffix for the statistic plugin.
+        name: str:
+            Name of the device.
+        plugins:: Optional[dict[str, NDPluginBaseIO] | None
+            Dictionary containing plugin that are forward to the base class.
+        """
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            for k, v in read_uncached.items():
+                setattr(self, k, epics_signal_r(float, prefix + v))
+
+        super().__init__(
+            drv=Andor2DriverIO(prefix + drv_suffix), name=name, plugins=plugins
+        )

dodal/devices/positioner.py

@@ -0,0 +1,49 @@
+from typing import TypeVar
+
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.epics.core import (
+    epics_signal_rw,
+)
+from ophyd_async.epics.motor import Motor
+
+T = TypeVar("T", bound=StrictEnum)
+
+
+class Positioner1D(StandardReadable, Movable[T]):
+    """1D stage with a enum table to select positions.
+
+    Use this when writing a device with an EPICS positioner on a single axis.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        datatype: type[StrictEnum],
+        positioner_pv_suffix: str = ":MP:SELECT",
+        name: str = "",
+    ) -> None:
+        self._stage_motion = Motor(prefix=prefix)
+        with self.add_children_as_readables():
+            self.stage_position = epics_signal_rw(
+                datatype,
+                read_pv=prefix + positioner_pv_suffix,
+            )
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: T) -> None:
+        await self.stage_position.set(value=value)
+
+
+def create_positioner(
+    datatype: type[T],
+    prefix,
+    positioner_pv_suffix: str = ":MP:SELECT",
+    name: str = "",
+) -> Positioner1D[T]:
+    return Positioner1D[datatype](prefix, datatype, positioner_pv_suffix, name)

dodal/devices/tetramm.py

@@ -131,11 +131,14 @@ class TetrammController(DetectorController):
         )
 
     async def arm(self):
-        self._arm_status = await set_and_wait_for_value(self._drv.acquire, True)
+        self._arm_status = await set_and_wait_for_value(
+            self._drv.acquire, True, wait_for_set_completion=False
+        )
 
     async def wait_for_idle(self):
-        if self._arm_status:
+        if self._arm_status and not self._arm_status.done:
             await self._arm_status
+        self._arm_status = None
 
     def _validate_trigger(self, trigger: DetectorTrigger) -> None:
         supported_trigger_types = {

dodal/devices/util/adjuster_plans.py

@@ -20,6 +20,6 @@ def lookup_table_adjuster(
     def adjust(group=None) -> Generator[Msg, None, None]:
         setpoint = lookup_table(input)
         LOGGER.info(f"lookup_table_adjuster setting {output_device.name} to {setpoint}")
-        yield from bps.abs_set(output_device, setpoint, group=group)  # type: ignore # See: https://github.com/DiamondLightSource/dodal/issues/827
+        yield from bps.abs_set(output_device, setpoint, group=group)
 
     return adjust

dodal/devices/zebra/zebra_constants_mapping.py

@@ -89,7 +89,7 @@ class ZebraMapping(ZebraMappingValidations):
     # Which of the Zebra's four AND gates is used to control the automatic shutter, if it's being used.
     # After defining, the correct GateControl device can be accessed with, eg,
     # zebra.logic_gates.and_gates[zebra.mapping.AND_GATE_FOR_AUTO_SHUTTER]. Set to -1 if not being used.
-    AND_GATE_FOR_AUTO_SHUTTER: int = Field(default=-1, ge=-1, le=4)
+    AND_GATE_FOR_AUTO_SHUTTER: int = Field(default=2, ge=-1, le=4)
 
 
 class UnmappedZebraException(Exception):

dodal/devices/zocalo/__init__.py

@@ -12,10 +12,7 @@ __all__ = [
     "XrcResult",
     "ZocaloTrigger",
     "get_full_processing_results",
-    "ZOCALO_READING_PLAN_NAME",
     "NoResultsFromZocalo",
     "NoZocaloSubscription",
     "ZocaloStartInfo",
 ]
-
-ZOCALO_READING_PLAN_NAME = "zocalo reading"

dodal/devices/zocalo/zocalo_results.py

@@ -1,7 +1,6 @@
 import asyncio
 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
 
@@ -47,7 +46,6 @@ class ZocaloSource(str, Enum):
 
 DEFAULT_TIMEOUT = 180
 DEFAULT_SORT_KEY = SortKeys.max_count
-ZOCALO_READING_PLAN_NAME = "zocalo reading"
 CLEAR_QUEUE_WAIT_S = 2.0
 ZOCALO_STAGE_GROUP = "clear zocalo queue"
 
@@ -389,12 +387,12 @@ def get_full_processing_results(
     """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
+    com = yield from bps.rd(zocalo.centre_of_mass, default_value=[])
+    max_voxel = yield from bps.rd(zocalo.max_voxel, default_value=[])
+    max_count = yield from bps.rd(zocalo.max_count, default_value=[])
+    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=[])
     return [
         _corrected_xrc_result(
             XrcResult(
@@ -410,27 +408,3 @@ def get_full_processing_results(
             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))