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

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -0,0 +1,121 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+import numpy as np
+from ophyd_async.core import (
+    Array1D,
+    SignalR,
+    StandardReadable,
+    StandardReadableFormat,
+    derived_signal_r,
+    soft_signal_rw,
+)
+from ophyd_async.epics.adcore import ADBaseIO
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.types import EnergyMode
+from dodal.devices.electron_analyser.util import to_binding_energy
+
+
+class AbstractAnalyserDriverIO(ABC, StandardReadable, ADBaseIO):
+    """
+    Generic device to configure electron analyser with new region settings.
+    Electron analysers should inherit from this class for further specialisation.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
+            self.spectrum = epics_signal_r(Array1D[np.float64], prefix + "INT_SPECTRUM")
+            self.total_intensity = derived_signal_r(
+                self._calculate_total_intensity, spectrum=self.spectrum
+            )
+            self.excitation_energy = soft_signal_rw(float, initial_value=0, units="eV")
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.region_name = soft_signal_rw(str, initial_value="null")
+            self.energy_mode = soft_signal_rw(
+                EnergyMode, initial_value=EnergyMode.KINETIC
+            )
+            self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
+            self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
+            self.slices = epics_signal_rw(int, prefix + "SLICES")
+            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.pass_energy = epics_signal_rw(
+                self.pass_energy_type, prefix + "PASS_ENERGY"
+            )
+            self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
+            self.iterations = epics_signal_rw(int, prefix + "NumExposures")
+            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
+
+            # Read once per scan after data acquired
+            self.energy_axis = self._create_energy_axis_signal(prefix)
+            self.binding_energy_axis = derived_signal_r(
+                self._calculate_binding_energy_axis,
+                "eV",
+                energy_axis=self.energy_axis,
+                excitation_energy=self.excitation_energy,
+                energy_mode=self.energy_mode,
+            )
+            self.angle_axis = self._create_angle_axis_signal(prefix)
+            self.step_time = epics_signal_r(float, prefix + "AcquireTime")
+            self.total_steps = epics_signal_r(int, prefix + "TOTAL_POINTS_RBV")
+            self.total_time = derived_signal_r(
+                self._calculate_total_time,
+                "s",
+                total_steps=self.total_steps,
+                step_time=self.step_time,
+                iterations=self.iterations,
+            )
+
+        super().__init__(prefix=prefix, name=name)
+
+    @abstractmethod
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        """
+        The signal that defines the angle axis. Depends on analyser model.
+        """
+
+    @abstractmethod
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        """
+        The signal that defines the energy axis. Depends on analyser model.
+        """
+
+    def _calculate_binding_energy_axis(
+        self,
+        energy_axis: Array1D[np.float64],
+        excitation_energy: float,
+        energy_mode: EnergyMode,
+    ) -> Array1D[np.float64]:
+        is_binding = energy_mode == EnergyMode.BINDING
+        return np.array(
+            [
+                to_binding_energy(i_energy_axis, EnergyMode.KINETIC, excitation_energy)
+                if is_binding
+                else i_energy_axis
+                for i_energy_axis in energy_axis
+            ]
+        )
+
+    def _calculate_total_time(
+        self, total_steps: int, step_time: float, iterations: int
+    ) -> float:
+        return total_steps * step_time * iterations
+
+    def _calculate_total_intensity(self, spectrum: Array1D[np.float64]) -> float:
+        return float(np.sum(spectrum, dtype=np.float64))
+
+    @property
+    @abstractmethod
+    def pass_energy_type(self) -> type:
+        """
+        Return the type the pass_energy should be. Each one is unfortunately different
+        for the underlying analyser software and cannot be changed on epics side.
+        """
+
+
+TAbstractAnalyserDriverIO = TypeVar(
+    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
+)

dodal/devices/electron_analyser/{abstract_region.py → abstract/base_region.py}

@@ -1,11 +1,12 @@
 import re
 from abc import ABC
 from collections.abc import Callable
-from enum import Enum
 from typing import Generic, TypeVar
 
 from pydantic import BaseModel, Field, model_validator
 
+from dodal.devices.electron_analyser.types import EnergyMode
+
 
 def java_to_python_case(java_str: str) -> str:
     """
@@ -42,11 +43,6 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class EnergyMode(str, Enum):
-    KINETIC = "Kinetic"
-    BINDING = "Binding"
-
-
 class AbstractBaseRegion(ABC, JavaToPythonModel):
     """
     Generic region model that holds the data. Specialised region models should inherit
@@ -73,9 +69,6 @@ class AbstractBaseRegion(ABC, JavaToPythonModel):
     def is_kinetic_energy(self) -> bool:
         return self.energy_mode == EnergyMode.KINETIC
 
-    def to_kinetic_energy(self, value: float, excitation_energy: float) -> float:
-        return value if self.is_binding_energy() else excitation_energy - value
-
     @model_validator(mode="before")
     @classmethod
     def before_validation(cls, data: dict) -> dict:

dodal/devices/electron_analyser/specs/__init__.py

@@ -0,0 +1,11 @@
+from .detector import SpecsDetector, SpecsRegionDetector
+from .driver_io import SpecsAnalyserDriverIO
+from .region import SpecsRegion, SpecsSequence
+
+__all__ = [
+    "SpecsDetector",
+    "SpecsRegionDetector",
+    "SpecsAnalyserDriverIO",
+    "SpecsRegion",
+    "SpecsSequence",
+]

dodal/devices/electron_analyser/specs/detector.py

@@ -0,0 +1,29 @@
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    AbstractElectronAnalyserDetector,
+    AbstractElectronAnalyserRegionDetector,
+)
+from dodal.devices.electron_analyser.specs.driver_io import SpecsAnalyserDriverIO
+from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSequence
+
+
+class SpecsRegionDetector(
+    AbstractElectronAnalyserRegionDetector[SpecsAnalyserDriverIO, SpecsRegion]
+):
+    def configure_region(self):
+        # ToDo - Need to move configure plans to here and rewrite tests
+        pass
+
+
+class SpecsDetector(
+    AbstractElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+):
+    def __init__(self, prefix: str, name: str):
+        super().__init__(prefix, name, SpecsSequence)
+
+    def _create_driver(self, prefix: str) -> SpecsAnalyserDriverIO:
+        return SpecsAnalyserDriverIO(prefix, "driver")
+
+    def _create_region_detector(
+        self, driver: SpecsAnalyserDriverIO, region: SpecsRegion
+    ) -> SpecsRegionDetector:
+        return SpecsRegionDetector(self.name, driver, region)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -0,0 +1,64 @@
+import numpy as np
+from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, derived_signal_r
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+
+
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            # Used for setting up region data acquisition.
+            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
+            self.snapshot_values = epics_signal_rw(int, prefix + "VALUES")
+            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
+
+            # Used to read detector data after acqusition.
+            self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
+            self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
+
+        super().__init__(prefix, name)
+
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        angle_axis = derived_signal_r(
+            self._calculate_angle_axis,
+            min_angle=self.min_angle_axis,
+            max_angle=self.max_angle_axis,
+            slices=self.slices,
+        )
+        return angle_axis
+
+    def _calculate_angle_axis(
+        self, min_angle: float, max_angle: float, slices: int
+    ) -> Array1D[np.float64]:
+        # SPECS returns the extreme edges of the range, not the centre of the pixels
+        width = (max_angle - min_angle) / slices
+        offset = width / 2
+
+        axis = np.array([min_angle + offset + i * width for i in range(slices)])
+        return axis
+
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        energy_axis = derived_signal_r(
+            self._calculate_energy_axis,
+            "eV",
+            min_energy=self.low_energy,
+            max_energy=self.high_energy,
+            total_points_iterations=self.slices,
+        )
+        return energy_axis
+
+    def _calculate_energy_axis(
+        self, min_energy: float, max_energy: float, total_points_iterations: int
+    ) -> Array1D[np.float64]:
+        # Note: Don't use the energy step because of the case where the step doesn't
+        # exactly fill the range
+        step = (max_energy - min_energy) / (total_points_iterations - 1)
+        axis = np.array([min_energy + i * step for i in range(total_points_iterations)])
+        return axis
+
+    @property
+    def pass_energy_type(self) -> type:
+        return float

dodal/devices/electron_analyser/{specs_region.py → specs/region.py}

@@ -1,6 +1,6 @@
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract_region import (
+from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
 )

dodal/devices/electron_analyser/types.py

@@ -0,0 +1,6 @@
+from ophyd_async.core import StrictEnum
+
+
+class EnergyMode(StrictEnum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"

dodal/devices/electron_analyser/util.py

@@ -0,0 +1,13 @@
+from dodal.devices.electron_analyser.types import EnergyMode
+
+
+def to_kinetic_energy(
+    value: float, value_mode: EnergyMode, excitation_energy: float
+) -> float:
+    return value if value_mode == EnergyMode.KINETIC else excitation_energy - value
+
+
+def to_binding_energy(
+    value: float, value_mode: EnergyMode, excitation_energy: float
+) -> float:
+    return value if value_mode == EnergyMode.BINDING else excitation_energy - value

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -0,0 +1,12 @@
+from .detector import VGScientaDetector, VGScientaRegionDetector
+from .driver_io import VGScientaAnalyserDriverIO
+from .region import VGScientaExcitationEnergySource, VGScientaRegion, VGScientaSequence
+
+__all__ = [
+    "VGScientaDetector",
+    "VGScientaRegionDetector",
+    "VGScientaAnalyserDriverIO",
+    "VGScientaExcitationEnergySource",
+    "VGScientaRegion",
+    "VGScientaSequence",
+]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -0,0 +1,36 @@
+from dodal.devices.electron_analyser.abstract.base_detector import (
+    AbstractElectronAnalyserDetector,
+    AbstractElectronAnalyserRegionDetector,
+)
+from dodal.devices.electron_analyser.vgscienta.driver_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
+    VGScientaRegion,
+    VGScientaSequence,
+)
+
+
+class VGScientaRegionDetector(
+    AbstractElectronAnalyserRegionDetector[VGScientaAnalyserDriverIO, VGScientaRegion]
+):
+    def configure_region(self):
+        # ToDo - Need to move configure plans to here and rewrite tests
+        pass
+
+
+class VGScientaDetector(
+    AbstractElectronAnalyserDetector[
+        VGScientaAnalyserDriverIO, VGScientaSequence, VGScientaRegion
+    ]
+):
+    def __init__(self, prefix: str, name: str):
+        super().__init__(prefix, name, VGScientaSequence)
+
+    def _create_driver(self, prefix: str) -> VGScientaAnalyserDriverIO:
+        return VGScientaAnalyserDriverIO(prefix, "driver")
+
+    def _create_region_detector(
+        self, driver: VGScientaAnalyserDriverIO, region: VGScientaRegion
+    ) -> VGScientaRegionDetector:
+        return VGScientaRegionDetector(self.name, driver, region)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -0,0 +1,39 @@
+import numpy as np
+from ophyd_async.core import Array1D, SignalR, StandardReadableFormat, soft_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract.base_driver_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta.region import (
+    DetectorMode,
+)
+
+
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.excitation_energy_source = soft_signal_rw(str, initial_value=None)
+            # Used for setting up region data acquisition.
+            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
+            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
+            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
+            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
+            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
+            self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
+
+        with self.add_children_as_readables():
+            # Used to read detector data after acqusition.
+            self.external_io = epics_signal_r(Array1D[np.float64], prefix + "EXTIO")
+
+        super().__init__(prefix, name)
+
+    def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        return epics_signal_r(Array1D[np.float64], prefix + "X_SCALE_RBV")
+
+    def _create_angle_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:
+        return epics_signal_r(Array1D[np.float64], prefix + "Y_SCALE_RBV")
+
+    @property
+    def pass_energy_type(self) -> type:
+        return str

dodal/devices/electron_analyser/{vgscienta_region.py → vgscienta/region.py}

@@ -4,7 +4,7 @@ from enum import Enum
 from ophyd_async.core import StrictEnum
 from pydantic import Field
 
-from dodal.devices.electron_analyser.abstract_region import (
+from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
     JavaToPythonModel,

dodal/devices/fast_grid_scan.py

@@ -12,6 +12,7 @@ from ophyd_async.core import (
     Signal,
     SignalRW,
     StandardReadable,
+    derived_signal_r,
     wait_for_value,
 )
 from ophyd_async.epics.core import (
@@ -23,7 +24,6 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
-from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -203,8 +203,11 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = create_r_hardware_backed_soft_signal(
-            float, self._calculate_expected_images
+        self.expected_images = derived_signal_r(
+            self._calculate_expected_images,
+            x=self.x_steps,
+            y=self.y_steps,
+            z=self.z_steps,
         )
 
         self.motion_program = MotionProgram(smargon_prefix)
@@ -231,12 +234,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         }
         super().__init__(name)
 
-    async def _calculate_expected_images(self):
-        x, y, z = await asyncio.gather(
-            self.x_steps.get_value(),
-            self.y_steps.get_value(),
-            self.z_steps.get_value(),
-        )
+    def _calculate_expected_images(self, x: float, y: float, z: float) -> float:
         LOGGER.info(f"Reading num of images found {x, y, z} images in each axis")
         first_grid = x * y
         second_grid = x * z

dodal/devices/i03/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+
+__all__ = ["Beamstop", "BeamstopPositions"]

dodal/devices/i04/__init__.py

@@ -0,0 +1,3 @@
+from dodal.devices.mx_phase1.beamstop import Beamstop, BeamstopPositions
+
+__all__ = ["Beamstop", "BeamstopPositions"]

dodal/devices/i04/constants.py

@@ -0,0 +1,9 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class RedisConstants:
+    REDIS_HOST = os.environ.get("VALKEY_PROD_SVC_SERVICE_HOST", "test_redis")
+    REDIS_PASSWORD = os.environ.get("VALKEY_PASSWORD", "test_redis_password")
+    MURKO_REDIS_DB = 7

dodal/devices/i04/murko_results.py

@@ -0,0 +1,195 @@
+import json
+import pickle
+from collections import OrderedDict
+from enum import Enum
+from typing import TypedDict
+
+import numpy as np
+from bluesky.protocols import Stageable, Triggerable
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+from redis.asyncio import StrictRedis
+
+from dodal.devices.i04.constants import RedisConstants
+from dodal.devices.oav.oav_calculations import (
+    calculate_beam_distance,
+    camera_coordinates_to_xyz_mm,
+)
+from dodal.log import LOGGER
+
+MurkoResult = dict
+FullMurkoResults = dict[str, list[MurkoResult]]
+
+
+class MurkoMetadata(TypedDict):
+    zoom_percentage: float
+    microns_per_x_pixel: float
+    microns_per_y_pixel: float
+    beam_centre_i: int
+    beam_centre_j: int
+    sample_id: str
+    omega_angle: float
+    uuid: str
+
+
+class Coord(Enum):
+    x = 0
+    y = 1
+    z = 2
+
+
+class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
+    """Device that takes crystal centre coords from Murko and uses them to set the
+    x, y, z coordinate of the sample to be in line with the beam centre.
+    (x, z) coords can be read at 90°, and (x, y) at 180° (or the closest omega angle to
+    90° and 180°). The average of the x values at these angles is taken, and sin(omega)z
+    and cosine(omega)y are taken to account for the rotation. This value is used to
+    calculate a number of mm the sample needs to move to be in line with the beam centre.
+    """
+
+    TIMEOUT_S = 2
+
+    def __init__(
+        self,
+        redis_host=RedisConstants.REDIS_HOST,
+        redis_password=RedisConstants.REDIS_PASSWORD,
+        redis_db=RedisConstants.MURKO_REDIS_DB,
+        name="",
+    ):
+        self.redis_client = StrictRedis(
+            host=redis_host,
+            password=redis_password,
+            db=redis_db,
+        )
+        self.pubsub = self.redis_client.pubsub()
+        self._last_omega = 0
+        self._last_result = None
+        self.sample_id = soft_signal_rw(str)  # Should get from redis
+        self.coords = {"x": {}, "y": {}, "z": {}}
+        self.search_angles = OrderedDict(
+            [  # Angles to search and dimensions to gather at each angle
+                (90, ("x", "z")),
+                (180, ("x", "y")),
+                (270, ()),  # Stop searching here
+            ]
+        )
+        self.angles_to_search = list(self.search_angles.keys())
+
+        with self.add_children_as_readables():
+            # Diffs from current x/y/z
+            self.x_mm, self._x_mm_setter = soft_signal_r_and_setter(float)
+            self.y_mm, self._y_mm_setter = soft_signal_r_and_setter(float)
+            self.z_mm, self._z_mm_setter = soft_signal_r_and_setter(float)
+        super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def stage(self):
+        await self.pubsub.subscribe("murko-results")
+        self._x_mm_setter(0)
+        self._y_mm_setter(0)
+        self._z_mm_setter(0)
+
+    @AsyncStatus.wrap
+    async def unstage(self):
+        await self.pubsub.unsubscribe()
+
+    @AsyncStatus.wrap
+    async def trigger(self):
+        # Wait for results
+        sample_id = await self.sample_id.get_value()
+        final_message = None
+        while self.angles_to_search:
+            # waits here for next batch to be recieved
+            message = await self.pubsub.get_message(timeout=self.TIMEOUT_S)
+            if message is None:  # No more messages to process
+                await self.process_batch(
+                    final_message, sample_id
+                )  # Process final message again
+                break
+            await self.process_batch(message, sample_id)
+            final_message = message
+        x_values = list(self.coords["x"].values())
+        y_values = list(self.coords["y"].values())
+        z_values = list(self.coords["z"].values())
+        assert x_values, "No x values"
+        assert z_values, "No z values"
+        assert y_values, "No y values"
+        self._x_mm_setter(float(np.mean(x_values)))
+        self._y_mm_setter(float(np.mean(y_values)))
+        self._z_mm_setter(float(np.mean(z_values)))
+
+    async def process_batch(self, message: dict | None, sample_id: str):
+        if message and message["type"] == "message":
+            batch_results = pickle.loads(message["data"])
+            for results in batch_results:
+                LOGGER.info(f"Got {results} from redis")
+                for uuid, result in results.items():
+                    metadata_str = await self.redis_client.hget(  # type: ignore
+                        f"murko:{sample_id}:metadata", uuid
+                    )
+                    if metadata_str and self.angles_to_search:
+                        self.process_result(result, uuid, metadata_str)
+
+    def process_result(
+        self, result: dict, uuid: int, metadata_str: str
+    ) -> float | None:
+        metadata = MurkoMetadata(json.loads(metadata_str))
+        omega_angle = metadata["omega_angle"]
+        LOGGER.info(f"Got angle {omega_angle}")
+        # Find closest to next search angle
+        movement = self.get_coords_if_at_angle(metadata, result, omega_angle)
+        if movement is not None:
+            LOGGER.info(f"Using result {uuid}, {metadata_str}, {result}")
+            search_angle = self.angles_to_search.pop(0)
+            for coord in self.search_angles[search_angle]:
+                self.coords[coord][omega_angle] = movement[Coord[coord].value]
+                LOGGER.info(f"Found {coord} at {movement}, angle = {omega_angle}")
+        self._last_omega = omega_angle
+        self._last_result = result
+
+    def get_coords_if_at_angle(
+        self, metadata: MurkoMetadata, result: MurkoResult, omega: float
+    ) -> np.ndarray | None:
+        """Gets the 'most_likely_click' coordinates from Murko if omega or the last
+        omega are the closest angle to the search angle. Otherwise returns None.
+        """
+        search_angle = self.angles_to_search[0]
+        LOGGER.info(f"Compare {omega}, {search_angle}, {self._last_omega}")
+        if (  # if last omega is closest
+            abs(omega - search_angle) >= abs(self._last_omega - search_angle)
+            and self._last_result is not None
+        ):
+            closest_result = self._last_result
+            closest_omega = self._last_omega
+        elif omega - search_angle >= 0:  # if this omega is closest
+            closest_result = result
+            closest_omega = omega
+        else:
+            return None
+        coords = closest_result[
+            "most_likely_click"
+        ]  # As proportion from top, left of image
+        shape = closest_result["original_shape"]  # Dimensions of image in pixels
+        # Murko returns coords as y, x
+        centre_px = (coords[1] * shape[1], coords[0] * shape[0])
+        LOGGER.info(
+            f"Using image taken at {closest_omega}, which found xtal at {centre_px}"
+        )
+
+        beam_dist_px = calculate_beam_distance(
+            (metadata["beam_centre_i"], metadata["beam_centre_j"]),
+            centre_px[0],
+            centre_px[1],
+        )
+
+        return camera_coordinates_to_xyz_mm(
+            beam_dist_px[0],
+            beam_dist_px[1],
+            closest_omega,
+            metadata["microns_per_x_pixel"],
+            metadata["microns_per_y_pixel"],
+        )