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

mx_bluesky/common/utils/exceptions.py

@@ -7,20 +7,22 @@ from bluesky.preprocessors import contingency_wrapper
 from bluesky.utils import Msg
 
 
-class WarningException(Exception):
+class WarningError(
+    Exception
+):  # see https://github.com/DiamondLightSource/mx-bluesky/issues/1394 on naming
     """An exception used when we want to warn GDA of a
     problem but continue with UDC anyway"""
 
     pass
 
 
-class ISPyBDepositionNotMade(Exception):
+class ISPyBDepositionNotMadeError(Exception):
     """Raised when the ISPyB or Zocalo callbacks can't access ISPyB deposition numbers."""
 
     pass
 
 
-class SampleException(WarningException):
+class SampleError(WarningError):
     """An exception which identifies an issue relating to the sample."""
 
     def __str__(self):
@@ -36,7 +38,7 @@ class SampleException(WarningException):
 T = TypeVar("T")
 
 
-class CrystalNotFoundException(SampleException):
+class CrystalNotFoundError(SampleError):
     """Raised if grid detection completed normally but no crystal was found."""
 
     def __init__(self, *args):
@@ -49,7 +51,7 @@ def catch_exception_and_warn(
     *args,
     **kwargs,
 ) -> Generator[Msg, None, T]:
-    """A plan wrapper to catch a specific exception and instead raise a WarningException,
+    """A plan wrapper to catch a specific exception and instead raise a WarningError,
     so that UDC is not halted
 
     Example usage:
@@ -58,12 +60,12 @@ def catch_exception_and_warn(
         ...
     yield from catch_exception_and_warn(ExceptionA, plan_which_can_raise_exception_a, **args, **kwargs)'
 
-    This will catch ExceptionA raised by the plan and instead raise a WarningException
+    This will catch ExceptionA raised by the plan and instead raise a WarningError
     """
 
     def warn_if_exception_matches(exception: Exception):
         if isinstance(exception, exception_to_catch):
-            raise SampleException(str(exception)) from exception
+            raise SampleError(str(exception)) from exception
         yield from null()
 
     return (

mx_bluesky/common/utils/log.py

@@ -10,11 +10,11 @@ from dodal.log import (
     integrate_bluesky_and_ophyd_logging,
     set_up_all_logging_handlers,
 )
-from dodal.log import LOGGER as dodal_logger
+from dodal.log import LOGGER as DODAL_LOGGER
 
 LOGGER = logging.getLogger("MX-Bluesky")
 LOGGER.setLevel("DEBUG")
-LOGGER.parent = dodal_logger
+LOGGER.parent = DODAL_LOGGER
 
 ISPYB_ZOCALO_CALLBACK_LOGGER = logging.getLogger("ISPyB and Zocalo callbacks")
 ISPYB_ZOCALO_CALLBACK_LOGGER.setLevel(logging.DEBUG)
@@ -68,7 +68,7 @@ def do_default_logging_setup(
     and bluesky and ophyd-async are optionally included."""
     logging_path, debug_logging_path = _get_logging_dirs(dev_mode)
     handlers = set_up_all_logging_handlers(
-        dodal_logger,
+        DODAL_LOGGER,
         logging_path,
         file_name,
         dev_mode,
@@ -78,7 +78,7 @@ def do_default_logging_setup(
     )
 
     if integrate_all_logs:
-        integrate_bluesky_and_ophyd_logging(dodal_logger)
+        integrate_bluesky_and_ophyd_logging(DODAL_LOGGER)
 
     handlers["graylog_handler"].addFilter(tag_filter)
 

mx_bluesky/common/utils/tracing.py

@@ -11,18 +11,18 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 def setup_tracing(service_name: str = "Hyperion"):
     resource = Resource(attributes={SERVICE_NAME: service_name})
 
-    traceProvider = TracerProvider(resource=resource)
+    trace_provider = TracerProvider(resource=resource)
     processor = BatchSpanProcessor(
         OTLPSpanExporter(endpoint="http://0.0.0.0:4318/v1/traces")
     )
-    traceProvider.add_span_processor(processor)
-    trace.set_tracer_provider(traceProvider)
+    trace_provider.add_span_processor(processor)
+    trace.set_tracer_provider(trace_provider)
 
     reader = PeriodicExportingMetricReader(
         OTLPMetricExporter(endpoint="http://0.0.0.0:4318/v1/metrics")
     )
-    meterProvider = MeterProvider(resource=resource, metric_readers=[reader])
-    metrics.set_meter_provider(meterProvider)
+    meter_provider = MeterProvider(resource=resource, metric_readers=[reader])
+    metrics.set_meter_provider(meter_provider)
 
 
 TRACER = trace.get_tracer(__name__)

mx_bluesky/common/utils/utils.py

@@ -4,23 +4,23 @@ from math import asin
 from scanspec.core import AxesPoints, Axis
 from scipy.constants import physical_constants
 
-hc_in_eV_and_Angstrom: float = (
+hc_in_ev_and_angstrom: float = (
     physical_constants["speed of light in vacuum"][0]
     * physical_constants["Planck constant in eV/Hz"][0]
     * 1e10  # Angstroms per metre
 )
 
 
-def interconvert_eV_Angstrom(wavelength_or_energy: float) -> float:
-    return hc_in_eV_and_Angstrom / wavelength_or_energy
+def interconvert_ev_angstrom(wavelength_or_energy: float) -> float:
+    return hc_in_ev_and_angstrom / wavelength_or_energy
 
 
-def convert_eV_to_angstrom(hv: float) -> float:
-    return interconvert_eV_Angstrom(hv)
+def convert_ev_to_angstrom(hv: float) -> float:
+    return interconvert_ev_angstrom(hv)
 
 
-def convert_angstrom_to_eV(wavelength: float) -> float:
-    return interconvert_eV_Angstrom(wavelength)
+def convert_angstrom_to_ev(wavelength: float) -> float:
+    return interconvert_ev_angstrom(wavelength)
 
 
 def number_of_frames_from_scan_spec(scan_points: AxesPoints[Axis]):
@@ -37,6 +37,6 @@ def energy_to_bragg_angle(energy_kev: float, d_a: float) -> float:
     Returns:
         The bragg angle in degrees
     """
-    wavelength_a = convert_eV_to_angstrom(energy_kev * 1000)
+    wavelength_a = convert_ev_to_angstrom(energy_kev * 1000)
     d = d_a
     return asin(wavelength_a / (2 * d)) * 180 / math.pi

mx_bluesky/hyperion/__main__.py

@@ -22,7 +22,7 @@ from mx_bluesky.common.utils.log import (
 from mx_bluesky.hyperion.baton_handler import run_forever
 from mx_bluesky.hyperion.experiment_plans.experiment_registry import (
     PLAN_REGISTRY,
-    PlanNotFound,
+    PlanNotFoundError,
 )
 from mx_bluesky.hyperion.external_interaction.agamemnon import (
     compare_params,
@@ -48,16 +48,16 @@ from mx_bluesky.hyperion.utils.context import setup_context
 def compose_start_args(context: BlueskyContext, plan_name: str, action: Actions):
     experiment_registry_entry = PLAN_REGISTRY.get(plan_name)
     if experiment_registry_entry is None:
-        raise PlanNotFound(f"Experiment plan '{plan_name}' not found in registry.")
+        raise PlanNotFoundError(f"Experiment plan '{plan_name}' not found in registry.")
 
     experiment_internal_param_type = experiment_registry_entry.get("param_type")
     plan = context.plan_functions.get(plan_name)
     if experiment_internal_param_type is None:
-        raise PlanNotFound(
+        raise PlanNotFoundError(
             f"Corresponding internal param type for '{plan_name}' not found in registry."
         )
     if plan is None:
-        raise PlanNotFound(
+        raise PlanNotFoundError(
             f"Experiment plan '{plan_name}' not found in context. Context has {context.plan_functions.keys()}"
         )
     try:
@@ -115,7 +115,7 @@ class StopOrStatus(Resource):
         status_and_message = StatusAndMessage(Status.FAILED, f"{action} not understood")
         if action == Actions.STATUS.value:
             LOGGER.debug(
-                f"Runner received status request - state of the runner object is: {self.runner.__dict__} - state of the RE is: {self.runner.RE.__dict__}"
+                f"Runner received status request - state of the runner object is: {self.runner.__dict__} - state of the run_engine is: {self.runner.run_engine.__dict__}"
             )
             status_and_message = self.runner.current_status
         return asdict(status_and_message)

mx_bluesky/hyperion/baton_handler.py

@@ -9,6 +9,7 @@ from bluesky.utils import MsgGenerator, RunEngineInterrupted
 from dodal.common.beamlines.commissioning_mode import set_commissioning_signal
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.baton import Baton
+from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 from dodal.devices.motors import XYZStage
 from dodal.devices.robot import BartRobot
 from dodal.devices.smargon import Smargon
@@ -38,7 +39,7 @@ from mx_bluesky.hyperion.external_interaction.agamemnon import (
 from mx_bluesky.hyperion.external_interaction.alerting.constants import Subjects
 from mx_bluesky.hyperion.parameters.components import Wait
 from mx_bluesky.hyperion.parameters.load_centre_collect import LoadCentreCollect
-from mx_bluesky.hyperion.plan_runner import PlanException, PlanRunner
+from mx_bluesky.hyperion.plan_runner import PlanError, PlanRunner
 from mx_bluesky.hyperion.utils.context import (
     clear_all_device_caches,
     setup_devices,
@@ -53,7 +54,7 @@ def run_forever(runner: PlanRunner):
         while True:
             try:
                 run_udc_when_requested(runner.context, runner)
-            except PlanException as e:
+            except PlanError as e:
                 LOGGER.info(
                     "Caught exception during plan execution, stopped and waiting for baton.",
                     exc_info=e,
@@ -64,7 +65,7 @@ def run_forever(runner: PlanRunner):
         # RunEngine.abort() will have been called and we will get RunEngineInterrupted
         LOGGER.info(
             f"RunEngine was interrupted. Runner state is {runner.current_status}, "
-            f"run engine is {runner.RE.state}"
+            f"run engine is {runner.run_engine.state}"
         )
 
 
@@ -93,7 +94,7 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
         * A user requests the baton away from Hyperion
         * Hyperion releases the baton when Agamemnon has no more instructions
         * The RunEngine raises a RequestAbort exception, most likely due to a shutdown command
-        * A plan raises an exception not of type WarningException (which is then wrapped as a PlanException)
+        * A plan raises an exception not of type WarningError (which is then wrapped as a PlanError)
         Args:
             baton: The baton device
             runner: The runner
@@ -109,7 +110,7 @@ def run_udc_when_requested(context: BlueskyContext, runner: PlanRunner):
                 baton, runner, current_visit
             )
         if current_visit:
-            yield from _perform_robot_unload(runner.context, current_visit)
+            yield from _clean_up_udc(runner.context, current_visit)
 
     def release_baton() -> MsgGenerator:
         # If hyperion has given up the baton itself we need to also release requested
@@ -145,13 +146,13 @@ def _initialise_udc(context: BlueskyContext, dev_mode: bool):
 
 def _wait_for_hyperion_requested(baton: Baton):
     LOGGER.debug("Hyperion waiting for baton...")
-    SLEEP_PER_CHECK = 0.1
+    sleep_per_check = 0.1
     while True:
         requested_user = yield from bps.rd(baton.requested_user)
         if requested_user == HYPERION_USER:
             LOGGER.debug("Baton requested for Hyperion")
             break
-        yield from bps.sleep(SLEEP_PER_CHECK)
+        yield from bps.sleep(sleep_per_check)
 
 
 def _fetch_and_process_agamemnon_instruction(
@@ -239,11 +240,17 @@ def _unrequest_baton(baton: Baton) -> MsgGenerator[str]:
     return requested_user
 
 
-def _perform_robot_unload(context: BlueskyContext, visit: str) -> MsgGenerator:
+def _clean_up_udc(context: BlueskyContext, visit: str) -> MsgGenerator:
+    cleanup_group = "cleanup"
     robot = find_device_in_context(context, "robot", BartRobot)
     smargon = find_device_in_context(context, "smargon", Smargon)
     aperture_scatterguard = find_device_in_context(
         context, "aperture_scatterguard", ApertureScatterguard
     )
     lower_gonio = find_device_in_context(context, "lower_gonio", XYZStage)
+    detector_motion = find_device_in_context(context, "detector_motion", DetectorMotion)
+    yield from bps.abs_set(
+        detector_motion.shutter, ShutterState.CLOSED, group=cleanup_group
+    )
     yield from robot_unload(robot, smargon, aperture_scatterguard, lower_gonio, visit)
+    yield from bps.wait(cleanup_group)

mx_bluesky/hyperion/device_setup_plans/smargon.py

@@ -2,23 +2,23 @@ import numpy as np
 from bluesky import plan_stubs as bps
 from bluesky.utils import FailedStatus
 from dodal.devices.smargon import CombinedMove, Smargon
-from ophyd_async.epics.motor import MotorLimitsException
+from ophyd_async.epics.motor import MotorLimitsError
 
-from mx_bluesky.common.utils.exceptions import SampleException
+from mx_bluesky.common.utils.exceptions import SampleError
 
 
 def move_smargon_warn_on_out_of_range(
     smargon: Smargon, position: np.ndarray | list[float] | tuple[float, float, float]
 ):
-    """Throws a SampleException if the specified position is out of range for the
+    """Throws a SampleError if the specified position is out of range for the
     smargon. Otherwise moves to that position. The check is from ophyd-async"""
     try:
         yield from bps.mv(
             smargon, CombinedMove(x=position[0], y=position[1], z=position[2])
         )
     except FailedStatus as fs:
-        if isinstance(fs.__cause__, MotorLimitsException):
-            raise SampleException(
+        if isinstance(fs.__cause__, MotorLimitsError):
+            raise SampleError(
                 "Pin tip centring failed - pin too long/short/bent and out of range"
             ) from fs.__cause__
         else:

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -7,6 +7,6 @@ from dodal.devices.i03.dcm import DCM
 
 def fill_in_energy_if_not_supplied(dcm: DCM, detector_params: DetectorParams):
     if not detector_params.expected_energy_ev:
-        actual_energy_ev = 1000 * (yield from bps.rd(dcm.energy_in_kev))
+        actual_energy_ev = 1000 * (yield from bps.rd(dcm.energy_in_keV))
         detector_params.expected_energy_ev = actual_energy_ev
     return detector_params

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -57,5 +57,5 @@ PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
 }
 
 
-class PlanNotFound(Exception):
+class PlanNotFoundError(Exception):
     pass

mx_bluesky/hyperion/experiment_plans/hyperion_flyscan_xray_centre_plan.py

@@ -15,7 +15,7 @@ from mx_bluesky.common.device_setup_plans.setup_zebra_and_shutter import (
     tidy_up_zebra_after_gridscan,
 )
 from mx_bluesky.common.experiment_plans.common_flyscan_xray_centre_plan import (
-    construct_beamline_specific_FGS_features,
+    construct_beamline_specific_fast_gridscan_features,
 )
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.hyperion.device_setup_plans.setup_panda import (
@@ -35,7 +35,7 @@ from mx_bluesky.hyperion.parameters.device_composites import (
 from mx_bluesky.hyperion.parameters.gridscan import HyperionSpecifiedThreeDGridScan
 
 
-class SmargonSpeedException(Exception):
+class SmargonSpeedError(Exception):
     pass
 
 
@@ -54,14 +54,14 @@ def construct_hyperion_specific_features(
         xrc_composite.smargon.x,
         xrc_composite.smargon.y,
         xrc_composite.smargon.z,
-        xrc_composite.dcm.energy_in_kev,
+        xrc_composite.dcm.energy_in_keV,
     ]
 
     signals_to_read_during_collection = [
         xrc_composite.aperture_scatterguard,
         xrc_composite.attenuator.actual_transmission,
         xrc_composite.flux.flux_reading,
-        xrc_composite.dcm.energy_in_kev,
+        xrc_composite.dcm.energy_in_keV,
         xrc_composite.eiger.bit_depth,
     ]
 
@@ -73,7 +73,7 @@ def construct_hyperion_specific_features(
         set_flyscan_params_plan = partial(
             set_fast_grid_scan_params,
             xrc_composite.panda_fast_grid_scan,
-            xrc_parameters.panda_FGS_params,
+            xrc_parameters.panda_fast_gridscan_params,
         )
         fgs_motors = xrc_composite.panda_fast_grid_scan
 
@@ -91,10 +91,10 @@ def construct_hyperion_specific_features(
         set_flyscan_params_plan = partial(
             set_fast_grid_scan_params,
             xrc_composite.zebra_fast_grid_scan,
-            xrc_parameters.FGS_params,
+            xrc_parameters.fast_gridscan_params,
         )
         fgs_motors = xrc_composite.zebra_fast_grid_scan
-    return construct_beamline_specific_FGS_features(
+    return construct_beamline_specific_fast_gridscan_features(
         setup_trigger_plan,
         tidy_plan,
         set_flyscan_params_plan,
@@ -112,8 +112,8 @@ def _panda_tidy(xrc_composite: HyperionFlyScanXRayCentreComposite):
     yield from tidy_up_zebra_after_gridscan(
         xrc_composite.zebra, xrc_composite.sample_shutter, group=group, wait=False
     )
+    yield from bps.unstage(xrc_composite.panda, group=group)
     yield from bps.wait(group, timeout=10)
-    yield from bps.unstage(xrc_composite.panda)
 
 
 def _panda_triggering_setup(
@@ -126,35 +126,36 @@ def _panda_triggering_setup(
         xrc_composite.panda_fast_grid_scan.run_up_distance_mm
     )
 
-    # Set the time between x steps pv
-    DEADTIME_S = 1e-6  # according to https://www.dectris.com/en/detectors/x-ray-detectors/eiger2/eiger2-for-synchrotrons/eiger2-x/
+    detector_deadtime_s = 1e-4  # This value was empirically found to be safer than the documented deadtime in the Eiger manual
 
-    time_between_x_steps_ms = (DEADTIME_S + parameters.exposure_time_s) * 1e3
+    time_between_x_steps_ms = (detector_deadtime_s + parameters.exposure_time_s) * 1e3
 
     smargon_speed_limit_mm_per_s = yield from bps.rd(
         xrc_composite.smargon.x.max_velocity
     )
 
     sample_velocity_mm_per_s = (
-        parameters.panda_FGS_params.x_step_size_mm * 1e3 / time_between_x_steps_ms
+        parameters.panda_fast_gridscan_params.x_step_size_mm
+        * 1e3
+        / time_between_x_steps_ms
     )
     if sample_velocity_mm_per_s > smargon_speed_limit_mm_per_s:
-        raise SmargonSpeedException(
+        raise SmargonSpeedError(
             f"Smargon speed was calculated from x step size\
-            {parameters.panda_FGS_params.x_step_size_mm}mm and\
+            {parameters.panda_fast_gridscan_params.x_step_size_mm}mm and\
             time_between_x_steps_ms {time_between_x_steps_ms} as\
             {sample_velocity_mm_per_s}mm/s. The smargon's speed limit is\
             {smargon_speed_limit_mm_per_s}mm/s."
         )
     else:
         LOGGER.info(
-            f"Panda grid scan: Smargon speed set to {smargon_speed_limit_mm_per_s} mm/s"
+            f"Panda grid scan: Smargon speed set to {sample_velocity_mm_per_s} mm/s"
             f" and using a run-up distance of {run_up_distance_mm}"
         )
 
     yield from bps.mv(
-        xrc_composite.panda_fast_grid_scan.time_between_x_steps_ms,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
-        time_between_x_steps_ms,  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+        xrc_composite.panda_fast_grid_scan.time_between_x_steps_ms,
+        time_between_x_steps_ms,
     )
 
     directory_provider_root = Path(parameters.storage_directory)
@@ -162,7 +163,7 @@ def _panda_triggering_setup(
 
     yield from setup_panda_for_flyscan(
         xrc_composite.panda,
-        parameters.panda_FGS_params,
+        parameters.panda_fast_gridscan_params,
         xrc_composite.smargon,
         parameters.exposure_time_s,
         time_between_x_steps_ms,

mx_bluesky/hyperion/experiment_plans/load_centre_collect_full_plan.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Generator
+from collections.abc import Generator, Sequence
 
 import bluesky.plan_stubs as bps
 import numpy as np
@@ -14,7 +14,7 @@ from dodal.devices.oav.oav_parameters import OAVParameters
 import mx_bluesky.common.xrc_result as flyscan_result
 from mx_bluesky.common.parameters.components import WithSnapshot
 from mx_bluesky.common.utils.context import device_composite_from_context
-from mx_bluesky.common.utils.exceptions import CrystalNotFoundException
+from mx_bluesky.common.utils.exceptions import CrystalNotFoundError
 from mx_bluesky.common.utils.log import LOGGER
 from mx_bluesky.common.xrc_result import XRayCentreEventHandler
 from mx_bluesky.hyperion.experiment_plans.robot_load_then_centre_plan import (
@@ -93,47 +93,18 @@ def load_centre_collect_full(
                 ),
                 flyscan_event_handler,
             )
-        except CrystalNotFoundException:
+        except CrystalNotFoundError:
             if parameters.select_centres.ignore_xtal_not_found:
                 LOGGER.info("Ignoring crystal not found due to parameter settings.")
             else:
                 raise
 
-        locations_to_collect_um: list[np.ndarray]
-        samples_to_collect: list[int]
-
-        if flyscan_event_handler.xray_centre_results:
-            selection_func = flyscan_result.resolve_selection_fn(
-                parameters.selection_params
-            )
-            hits = selection_func(flyscan_event_handler.xray_centre_results)
-            hits_to_collect = []
-            for hit in hits:
-                if hit.sample_id is None:
-                    LOGGER.warning(
-                        f"Diffracting centre {hit} not collected because no sample id was assigned."
-                    )
-                else:
-                    hits_to_collect.append(hit)
-
-            locations_to_collect_um = [
-                hit.centre_of_mass_mm * 1000 for hit in hits_to_collect
-            ]
-            samples_to_collect = [hit.sample_id for hit in hits_to_collect]
-            LOGGER.info(
-                f"Selected hits {hits_to_collect} using {selection_func}, args={parameters.selection_params}"
+        sample_ids_and_locations = yield from (
+            _samples_and_locations_to_collect(
+                flyscan_event_handler.xray_centre_results, parameters, composite
             )
-        else:
-            # If the xray centring hasn't found a result but has not thrown an error it
-            # means that we do not need to recentre and can collect where we are
-            initial_x_mm = yield from bps.rd(composite.smargon.x.user_readback)
-            initial_y_mm = yield from bps.rd(composite.smargon.y.user_readback)
-            initial_z_mm = yield from bps.rd(composite.smargon.z.user_readback)
-
-            locations_to_collect_um = [
-                np.array([initial_x_mm, initial_y_mm, initial_z_mm]) * 1000
-            ]
-            samples_to_collect = [parameters.sample_id]
+        )
+        sample_ids_and_locations.sort(key=_x_coordinate)
 
         multi_rotation = parameters.multi_rotation_scan
         rotation_template = multi_rotation.rotation_scans.copy()
@@ -144,9 +115,7 @@ def load_centre_collect_full(
 
         generator = rotation_scan_generator(is_alternating)
         next(generator)
-        for location, sample_id in zip(
-            locations_to_collect_um, samples_to_collect, strict=True
-        ):
+        for sample_id, location in sample_ids_and_locations:
             for rot in rotation_template:
                 combination = generator.send((rot, location, sample_id))
                 multi_rotation.rotation_scans.append(combination)
@@ -161,6 +130,51 @@ def load_centre_collect_full(
     yield from plan_with_callback_subs()
 
 
+def _samples_and_locations_to_collect(
+    xrc_results: Sequence[flyscan_result.XRayCentreResult] | None,
+    parameters: LoadCentreCollect,
+    composite: LoadCentreCollectComposite,
+) -> MsgGenerator[list[tuple[int, np.ndarray]]]:
+    if xrc_results:
+        selection_func = flyscan_result.resolve_selection_fn(
+            parameters.selection_params
+        )
+        hits = selection_func(xrc_results)
+        hits_to_collect = []
+        for hit in hits:
+            if hit.sample_id is None:
+                LOGGER.warning(
+                    f"Diffracting centre {hit} not collected because no sample id was assigned."
+                )
+            else:
+                hits_to_collect.append(hit)
+
+        samples_and_locations = [
+            (hit.sample_id, hit.centre_of_mass_mm * 1000) for hit in hits_to_collect
+        ]
+        LOGGER.info(
+            f"Selected hits {hits_to_collect} using {selection_func}, args={parameters.selection_params}"
+        )
+        return samples_and_locations
+    else:
+        # If the xray centring hasn't found a result but has not thrown an error it
+        # means that we do not need to recentre and can collect where we are
+        initial_x_mm = yield from bps.rd(composite.smargon.x.user_readback)
+        initial_y_mm = yield from bps.rd(composite.smargon.y.user_readback)
+        initial_z_mm = yield from bps.rd(composite.smargon.z.user_readback)
+
+        return [
+            (
+                parameters.sample_id,
+                np.array([initial_x_mm, initial_y_mm, initial_z_mm]) * 1000,
+            )
+        ]
+
+
+def _x_coordinate(sample_and_location: tuple[int, np.ndarray]) -> float:
+    return sample_and_location[1][0]  # type: ignore
+
+
 def rotation_scan_generator(
     is_alternating: bool,
 ) -> Generator[

mx_bluesky/hyperion/experiment_plans/optimise_attenuation_plan.py

@@ -13,7 +13,7 @@ from mx_bluesky.common.utils.context import device_composite_from_context
 from mx_bluesky.common.utils.log import LOGGER
 
 
-class AttenuationOptimisationFailedException(Exception):
+class AttenuationOptimisationFailedError(Exception):
     pass
 
 
@@ -59,7 +59,7 @@ def check_parameters(
 
     if upper_transmission < lower_transmission:
         raise ValueError(
-            f"Upper transmission limit {upper_transmission} must be greater than lower tranmission limit {lower_transmission}"
+            f"Upper transmission limit {upper_transmission} must be greater than lower transmission limit {lower_transmission}"
         )
 
     if not upper_transmission >= initial_transmission >= lower_transmission:
@@ -80,7 +80,7 @@ def calculate_new_direction(direction: Direction, deadtime, deadtime_threshold):
         if deadtime > deadtime_threshold:
             direction = Direction.NEGATIVE
             LOGGER.info(
-                "Found tranmission to go above deadtime threshold. Reducing transmission..."
+                "Found transmission to go above deadtime threshold. Reducing transmission..."
             )
     return direction
 
@@ -111,7 +111,7 @@ def deadtime_calc_new_transmission(
         Minimum expected transmission. Raise an error if transmission goes lower.
 
     Raises:
-        AttenuationOptimisationFailedException:
+        AttenuationOptimisationFailedError:
         This error is thrown if the transmission goes below the expected value or if the maximum cycles are reached
 
     Returns:
@@ -124,7 +124,7 @@ def deadtime_calc_new_transmission(
     else:
         transmission /= increment
     if transmission < lower_transmission_limit:
-        raise AttenuationOptimisationFailedException(
+        raise AttenuationOptimisationFailedError(
             "Calculated transmission is below expected limit"
         )
     return transmission
@@ -218,7 +218,7 @@ def deadtime_optimisation(
         Minimum expected transmission. Raise an error if transmission goes lower.
 
     Raises:
-        AttenuationOptimisationFailedException:
+        AttenuationOptimisationFailedError:
         This error is thrown if the transmission goes below the expected value or the maximum cycles are reached
 
     Returns:
@@ -262,7 +262,7 @@ def deadtime_optimisation(
             break
 
         if cycle == max_cycles - 1:
-            raise AttenuationOptimisationFailedException(
+            raise AttenuationOptimisationFailedError(
                 f"Unable to optimise attenuation after maximum cycles.\
                                                             Deadtime did not get lower than threshold: {deadtime_threshold} in maximum cycles {max_cycles}"
             )
@@ -367,12 +367,12 @@ def total_counts_optimisation(
             if transmission > upper_transmission_limit:
                 transmission = upper_transmission_limit
             elif transmission < lower_transmission_limit:
-                raise AttenuationOptimisationFailedException(
+                raise AttenuationOptimisationFailedError(
                     f"Transmission has gone below lower threshold {lower_transmission_limit}"
                 )
 
         if cycle == max_cycles - 1:
-            raise AttenuationOptimisationFailedException(
+            raise AttenuationOptimisationFailedError(
                 f"Unable to optimise attenuation after maximum cycles.\
                                                             Total count is not within limits: {lower_count_limit} <= {total_count}\
                                                                 <= {upper_count_limit}"