mx-bluesky 1.4.7__py3-none-any.whl → 1.4.8__py3-none-any.whl

mx_bluesky/common/plans/common_flyscan_xray_centre_plan.py

@@ -0,0 +1,316 @@
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Callable, Sequence
+from functools import partial
+
+import bluesky.plan_stubs as bps
+import bluesky.preprocessors as bpp
+import numpy as np
+import pydantic
+from bluesky.protocols import Readable
+from bluesky.utils import MsgGenerator
+from dodal.devices.eiger import EigerDetector
+from dodal.devices.fast_grid_scan import (
+    FastGridScanCommon,
+)
+from dodal.devices.smargon import Smargon
+from dodal.devices.synchrotron import Synchrotron
+from dodal.devices.zocalo import ZocaloResults
+from dodal.devices.zocalo.zocalo_results import (
+    XrcResult,
+    get_full_processing_results,
+)
+
+from mx_bluesky.common.parameters.constants import (
+    DocDescriptorNames,
+    GridscanParamConstants,
+    PlanGroupCheckpointConstants,
+    PlanNameConstants,
+)
+from mx_bluesky.common.parameters.gridscan import SpecifiedThreeDGridScan
+from mx_bluesky.common.plans.inner_plans.do_fgs import (
+    ZOCALO_STAGE_GROUP,
+    kickoff_and_complete_gridscan,
+)
+from mx_bluesky.common.plans.read_hardware import (
+    read_hardware_plan,
+)
+from mx_bluesky.common.utils.exceptions import (
+    CrystalNotFoundException,
+    SampleException,
+)
+from mx_bluesky.common.utils.log import LOGGER
+from mx_bluesky.common.utils.tracing import TRACER
+from mx_bluesky.common.xrc_result import XRayCentreResult
+
+
+@pydantic.dataclasses.dataclass(config={"arbitrary_types_allowed": True})
+class FlyScanEssentialDevices:
+    eiger: EigerDetector
+    synchrotron: Synchrotron
+    zocalo: ZocaloResults
+    smargon: Smargon
+
+
+@dataclasses.dataclass
+class BeamlineSpecificFGSFeatures:
+    setup_trigger_plan: Callable[..., MsgGenerator]
+    tidy_plan: Callable[..., MsgGenerator]
+    set_flyscan_params_plan: Callable[..., MsgGenerator]
+    fgs_motors: FastGridScanCommon
+    read_pre_flyscan_plan: Callable[
+        ..., MsgGenerator
+    ]  # Eventually replace with https://github.com/DiamondLightSource/mx-bluesky/issues/819
+    read_during_collection_plan: Callable[..., MsgGenerator]
+    get_xrc_results_from_zocalo: bool
+
+
+def construct_beamline_specific_FGS_features(
+    setup_trigger_plan: Callable[..., MsgGenerator],
+    tidy_plan: Callable[..., MsgGenerator],
+    set_flyscan_params_plan: Callable[..., MsgGenerator],
+    fgs_motors: FastGridScanCommon,
+    signals_to_read_pre_flyscan: list[Readable],
+    signals_to_read_during_collection: list[Readable],
+    get_xrc_results_from_zocalo: bool = False,
+) -> BeamlineSpecificFGSFeatures:
+    """Construct the class needed to do beamline-specific parts of the XRC FGS
+
+    Args:
+        setup_trigger_plan (Callable): Configure triggering, for example with the Zebra or PandA device.
+        Ran directly before kicking off the gridscan.
+
+        tidy_plan (Callable): Tidy up states of devices. Ran at the end of the flyscan, regardless of
+        whether or not it finished successfully.
+
+        set_flyscan_params_plan (Callable): Set PV's for the relevant Fast Grid Scan dodal device
+
+        fgs_motors (Callable): Composite device representing the fast grid scan's motion program parameters.
+
+        signals_to_read_pre_flyscan (Callable): Signals which will be read and saved as a bluesky event document
+        after all configuration, but before the gridscan.
+
+        signals_to_read_during_collection (Callable): Signals which will be read and saved as a bluesky event
+        document whilst the gridscan motion is in progress
+
+        get_xrc_results_from_zocalo (bool): If true, fetch grid scan results from zocalo after completion, as well as
+        update the ispyb comment field with information about the results. See _fetch_xrc_results_from_zocalo
+    """
+    read_pre_flyscan_plan = partial(
+        read_hardware_plan,
+        signals_to_read_pre_flyscan,
+        DocDescriptorNames.HARDWARE_READ_PRE,
+    )
+
+    read_during_collection_plan = partial(
+        read_hardware_plan,
+        signals_to_read_during_collection,
+        DocDescriptorNames.HARDWARE_READ_DURING,
+    )
+
+    return BeamlineSpecificFGSFeatures(
+        setup_trigger_plan,
+        tidy_plan,
+        set_flyscan_params_plan,
+        fgs_motors,
+        read_pre_flyscan_plan,
+        read_during_collection_plan,
+        get_xrc_results_from_zocalo,
+    )
+
+
+def common_flyscan_xray_centre(
+    composite: FlyScanEssentialDevices,
+    parameters: SpecifiedThreeDGridScan,
+    beamline_specific: BeamlineSpecificFGSFeatures,
+) -> MsgGenerator:
+    """Main entry point of the MX-Bluesky x-ray centering flyscan
+
+    Args:
+        composite (FlyScanEssentialDevices): Devices required to perform this plan.
+
+        parameters (SpecifiedThreeDGridScan): Parameters required to perform this plan.
+
+        beamline_specific (BeamlineSpecificFGSFeatures): Configure the beamline-specific version
+        of this plan: For example triggering setup and tidy up plans, as well as what to do with the
+        centering results.
+
+    With a minimum set of devices and parameters, prepares for; performs; and tidies up a flyscan
+    x-ray-center plan. This includes: Configuring desired triggering; writing nexus files; triggering zocalo;
+    reading hardware before and during the scan; and tidying up devices after
+    the plan is complete. Optionally fetch results from zocalo after completing the grid scan.
+
+    This plan will also push data to ispyb when used with the ispyb_activation_decorator.
+
+    There are a few other useful decorators to use with this plan, see: verify_undulator_gap_before_run_decorator, transmission_and_xbpm_feedback_for_collection_decorator
+    """
+
+    def _decorated_flyscan():
+        @bpp.set_run_key_decorator(PlanNameConstants.GRIDSCAN_OUTER)
+        @bpp.run_decorator(  # attach experiment metadata to the start document
+            md={
+                "subplan_name": PlanNameConstants.GRIDSCAN_OUTER,
+                "mx_bluesky_parameters": parameters.model_dump_json(),
+                "activate_callbacks": [
+                    "GridscanNexusFileCallback",
+                ],
+            }
+        )
+        @bpp.finalize_decorator(lambda: beamline_specific.tidy_plan(composite))
+        def run_gridscan_and_tidy(
+            fgs_composite: FlyScanEssentialDevices,
+            params: SpecifiedThreeDGridScan,
+            beamline_specific: BeamlineSpecificFGSFeatures,
+        ) -> MsgGenerator:
+            yield from beamline_specific.setup_trigger_plan(fgs_composite, parameters)
+
+            LOGGER.info("Starting grid scan")
+            yield from bps.stage(
+                fgs_composite.zocalo, group=ZOCALO_STAGE_GROUP
+            )  # connect to zocalo and make sure the queue is clear
+            yield from run_gridscan(fgs_composite, params, beamline_specific)
+
+            LOGGER.info("Grid scan finished")
+
+            if beamline_specific.get_xrc_results_from_zocalo:
+                yield from _fetch_xrc_results_from_zocalo(composite.zocalo, parameters)
+
+        yield from run_gridscan_and_tidy(composite, parameters, beamline_specific)
+
+    composite.eiger.set_detector_parameters(parameters.detector_params)
+    yield from _decorated_flyscan()
+
+
+def _fetch_xrc_results_from_zocalo(
+    zocalo_results: ZocaloResults,
+    parameters: SpecifiedThreeDGridScan,
+) -> MsgGenerator:
+    """
+    Get XRC results from the ZocaloResults device which was staged during a grid scan,
+    and store them in XRayCentreEventHandler.xray_centre_results by firing an event.
+
+    The RunEngine must be subscribed to XRayCentreEventHandler for this plan to work.
+    """
+
+    LOGGER.info("Getting X-ray center Zocalo results...")
+
+    yield from bps.trigger(zocalo_results)
+    LOGGER.info("Zocalo triggered and read, interpreting results.")
+    xrc_results = yield from get_full_processing_results(zocalo_results)
+    LOGGER.info(f"Got xray centres, top 5: {xrc_results[:5]}")
+    filtered_results = [
+        result
+        for result in xrc_results
+        if result["total_count"]
+        >= GridscanParamConstants.ZOCALO_MIN_TOTAL_COUNT_THRESHOLD
+    ]
+    discarded_count = len(xrc_results) - len(filtered_results)
+    if discarded_count > 0:
+        LOGGER.info(f"Removed {discarded_count} results because below threshold")
+    if filtered_results:
+        flyscan_results = [
+            _xrc_result_in_boxes_to_result_in_mm(xr, parameters)
+            for xr in filtered_results
+        ]
+    else:
+        LOGGER.warning("No X-ray centre received")
+        raise CrystalNotFoundException()
+    yield from _fire_xray_centre_result_event(flyscan_results)
+
+
+@bpp.set_run_key_decorator(PlanNameConstants.GRIDSCAN_MAIN)
+@bpp.run_decorator(md={"subplan_name": PlanNameConstants.GRIDSCAN_MAIN})
+def run_gridscan(
+    fgs_composite: FlyScanEssentialDevices,
+    parameters: SpecifiedThreeDGridScan,
+    beamline_specific: BeamlineSpecificFGSFeatures,
+):
+    # Currently gridscan only works for omega 0, see https://github.com/DiamondLightSource/mx-bluesky/issues/410
+    with TRACER.start_span("moving_omega_to_0"):
+        yield from bps.abs_set(fgs_composite.smargon.omega, 0)
+
+    with TRACER.start_span("ispyb_hardware_readings"):
+        yield from beamline_specific.read_pre_flyscan_plan()
+
+    LOGGER.info("Setting fgs params")
+    yield from beamline_specific.set_flyscan_params_plan()
+
+    LOGGER.info("Waiting for gridscan validity check")
+    yield from wait_for_gridscan_valid(beamline_specific.fgs_motors)
+
+    LOGGER.info("Waiting for arming to finish")
+    yield from bps.wait(PlanGroupCheckpointConstants.GRID_READY_FOR_DC)
+    yield from bps.stage(fgs_composite.eiger)  # type: ignore # See: https://github.com/bluesky/bluesky/issues/1809
+
+    yield from kickoff_and_complete_gridscan(
+        beamline_specific.fgs_motors,
+        fgs_composite.eiger,
+        fgs_composite.synchrotron,
+        [parameters.scan_points_first_grid, parameters.scan_points_second_grid],
+        parameters.scan_indices,
+        plan_during_collection=beamline_specific.read_during_collection_plan,
+    )
+    yield from bps.abs_set(beamline_specific.fgs_motors.z_steps, 0, wait=False)
+
+
+def wait_for_gridscan_valid(fgs_motors: FastGridScanCommon, timeout=0.5):
+    LOGGER.info("Waiting for valid fgs_params")
+    SLEEP_PER_CHECK = 0.1
+    times_to_check = int(timeout / SLEEP_PER_CHECK)
+    for _ in range(times_to_check):
+        scan_invalid = yield from bps.rd(fgs_motors.scan_invalid)
+        pos_counter = yield from bps.rd(fgs_motors.position_counter)
+        LOGGER.debug(
+            f"Scan invalid: {scan_invalid} and position counter: {pos_counter}"
+        )
+        if not scan_invalid and pos_counter == 0:
+            LOGGER.info("Gridscan scan valid and position counter reset")
+            return
+        yield from bps.sleep(SLEEP_PER_CHECK)
+    raise SampleException("Scan invalid - pin too long/short/bent and out of range")
+
+
+def _xrc_result_in_boxes_to_result_in_mm(
+    xrc_result: XrcResult, parameters: SpecifiedThreeDGridScan
+) -> XRayCentreResult:
+    fgs_params = parameters.FGS_params
+    xray_centre = fgs_params.grid_position_to_motor_position(
+        np.array(xrc_result["centre_of_mass"])
+    )
+    # A correction is applied to the bounding box to map discrete grid coordinates to
+    # the corners of the box in motor-space; we do not apply this correction
+    # to the xray-centre as it is already in continuous space and the conversion has
+    # been performed already
+    # In other words, xrc_result["bounding_box"] contains the position of the box centre,
+    # so we subtract half a box to get the corner of the box
+    return XRayCentreResult(
+        centre_of_mass_mm=xray_centre,
+        bounding_box_mm=(
+            fgs_params.grid_position_to_motor_position(
+                np.array(xrc_result["bounding_box"][0]) - 0.5
+            ),
+            fgs_params.grid_position_to_motor_position(
+                np.array(xrc_result["bounding_box"][1]) - 0.5
+            ),
+        ),
+        max_count=xrc_result["max_count"],
+        total_count=xrc_result["total_count"],
+    )
+
+
+def _fire_xray_centre_result_event(results: Sequence[XRayCentreResult]):
+    def empty_plan():
+        return iter([])
+
+    yield from bpp.set_run_key_wrapper(
+        bpp.run_wrapper(
+            empty_plan(),
+            md={
+                PlanNameConstants.FLYSCAN_RESULTS: [
+                    dataclasses.asdict(r) for r in results
+                ]
+            },
+        ),
+        PlanNameConstants.FLYSCAN_RESULTS,
+    )

mx_bluesky/common/plans/read_hardware.py

@@ -4,7 +4,7 @@ import bluesky.plan_stubs as bps
 from bluesky.protocols import Readable
 from dodal.devices.aperturescatterguard import ApertureScatterguard
 from dodal.devices.attenuator.attenuator import BinaryFilterAttenuator
-from dodal.devices.dcm import DCM
+from dodal.devices.common_dcm import BaseDCM
 from dodal.devices.eiger import EigerDetector
 from dodal.devices.flux import Flux
 from dodal.devices.s4_slit_gaps import S4SlitGaps
@@ -43,7 +43,7 @@ def standard_read_hardware_pre_collection(
     undulator: Undulator,
     synchrotron: Synchrotron,
     s4_slit_gaps: S4SlitGaps,
-    dcm: DCM,
+    dcm: BaseDCM,
     smargon: Smargon,
 ):
     LOGGER.info("Reading status of beamline for callbacks, pre collection.")
@@ -63,7 +63,7 @@ def standard_read_hardware_during_collection(
     aperture_scatterguard: ApertureScatterguard,
     attenuator: BinaryFilterAttenuator,
     flux: Flux,
-    dcm: DCM,
+    dcm: BaseDCM,
     detector: EigerDetector,
 ):
     signals_to_read_during_collection = [

mx_bluesky/common/utils/log.py

@@ -66,14 +66,15 @@ def do_default_logging_setup(
     """Configures dodal logger so that separate debug and info log files are created,
     info logs are sent to Graylog, info logs are streamed to sys.sterr, and logs from ophyd
     and bluesky and ophyd-async are optionally included."""
-
+    logging_path, debug_logging_path = _get_logging_dirs()
     handlers = set_up_all_logging_handlers(
         dodal_logger,
-        _get_logging_dir(),
+        logging_path,
         file_name,
         dev_mode,
         ERROR_LOG_BUFFER_LINES,
         graylog_port,
+        debug_logging_path,
     )
 
     if integrate_all_logs:
@@ -102,8 +103,8 @@ def flush_debug_handler() -> str:
     return handler.target.baseFilename
 
 
-def _get_logging_dir() -> Path:
-    """Get the path to write the mx_bluesky log files to.
+def _get_logging_dirs() -> tuple[Path, Path]:
+    """Get the paths to write the mx_bluesky log files to.
 
     Log location can be specified in the LOG_DIR environment variable, otherwise MX bluesky logs are written to 'dls_sw/ixx/logs/bluesky'.
     This directory will be created if it is not found
@@ -111,18 +112,20 @@ def _get_logging_dir() -> Path:
     Logs are written to ./tmp/logs/bluesky if BEAMLINE environment variable is not found
 
     Returns:
-        logging_path (Path): Path to the log file for the file handler to write to.
+        tuple[Path, Path]: Paths to the standard log file and to the debug log file, for the file handlers to write to
     """
 
     logging_str = environ.get("LOG_DIR")
+    beamline = environ.get("BEAMLINE")
     if logging_str:
         logging_path = Path(logging_str)
+        debug_logging_path = logging_path
+    elif beamline:
+        logging_path = Path(f"/dls_sw/{beamline}/logs/bluesky/")
+        debug_logging_path = Path(f"/dls/tmp/{beamline}/logs/bluesky/")
     else:
-        beamline = environ.get("BEAMLINE")
-        logging_path = (
-            Path(f"/dls_sw/{beamline}/logs/bluesky/")
-            if beamline
-            else Path("/tmp/logs/bluesky")
-        )
+        logging_path = Path("/tmp/logs/bluesky")
+        debug_logging_path = logging_path
     Path.mkdir(logging_path, exist_ok=True, parents=True)
-    return logging_path
+    Path.mkdir(debug_logging_path, exist_ok=True, parents=True)
+    return logging_path, debug_logging_path

mx_bluesky/hyperion/__main__.py

@@ -82,7 +82,6 @@ class BlueskyRunner:
         self,
         RE: RunEngine,
         context: BlueskyContext,
-        skip_startup_connection=False,
     ) -> None:
         self.command_queue: Queue[Command] = Queue()
         self.current_status: StatusAndMessage = StatusAndMessage(Status.IDLE)
@@ -101,12 +100,6 @@ class BlueskyRunner:
         if VERBOSE_EVENT_LOGGING:
             RE.subscribe(VerbosePlanExecutionLoggingCallback())
 
-        self.skip_startup_connection = skip_startup_connection
-        if not self.skip_startup_connection:
-            LOGGER.info("Initialising dodal devices...")
-            for plan_name in PLAN_REGISTRY:
-                PLAN_REGISTRY[plan_name]["setup"](context)
-
     def start(
         self,
         experiment: Callable,
@@ -278,15 +271,11 @@ class FlushLogs(Resource):
 def create_app(
     test_config=None,
     RE: RunEngine = RunEngine({}),
-    skip_startup_connection: bool = False,
 ) -> tuple[Flask, BlueskyRunner]:
-    context = setup_context(
-        wait_for_connection=not skip_startup_connection,
-    )
+    context = setup_context()
     runner = BlueskyRunner(
         RE,
         context=context,
-        skip_startup_connection=skip_startup_connection,
     )
     app = Flask(__name__)
     if test_config:
@@ -316,9 +305,7 @@ def create_targets():
         CONST.LOG_FILE_NAME, CONST.GRAYLOG_PORT, dev_mode=args.dev_mode
     )
     LOGGER.info(f"Hyperion launched with args:{argv}")
-    app, runner = create_app(
-        skip_startup_connection=args.skip_startup_connection,
-    )
+    app, runner = create_app()
     return app, runner, hyperion_port, args.dev_mode
 
 

mx_bluesky/hyperion/device_setup_plans/dcm_pitch_roll_mirror_adjuster.py

@@ -6,7 +6,7 @@ from dodal.devices.focusing_mirror import (
     MirrorStripe,
     MirrorVoltages,
 )
-from dodal.devices.undulator_dcm import UndulatorDCM
+from dodal.devices.i03.undulator_dcm import UndulatorDCM
 from dodal.devices.util.adjuster_plans import lookup_table_adjuster
 from dodal.devices.util.lookup_tables import (
     linear_interpolation_lut,
@@ -102,7 +102,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
     dcm = undulator_dcm.dcm_ref()
     LOGGER.info(f"Adjusting DCM and VFM for {energy_kev} keV")
     d_spacing_a: float = yield from bps.rd(
-        undulator_dcm.dcm_ref().crystal_metadata_d_spacing
+        undulator_dcm.dcm_ref().crystal_metadata_d_spacing_a
     )
     bragg_deg = energy_to_bragg_angle(energy_kev, d_spacing_a)
     LOGGER.info(f"Target Bragg angle = {bragg_deg} degrees")
@@ -110,7 +110,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
         linear_interpolation_lut(
             *parse_lookup_table(undulator_dcm.pitch_energy_table_path)
         ),
-        dcm.pitch_in_mrad,
+        dcm.xtal_1.pitch_in_mrad,
         bragg_deg,
     )
     yield from dcm_pitch_adjuster(DCM_GROUP)
@@ -122,7 +122,7 @@ def adjust_dcm_pitch_roll_vfm_from_lut(
         linear_interpolation_lut(
             *parse_lookup_table(undulator_dcm.roll_energy_table_path)
         ),
-        dcm.roll_in_mrad,
+        dcm.xtal_1.roll_in_mrad,
         bragg_deg,
     )
     yield from dcm_roll_adjuster(DCM_GROUP)

mx_bluesky/hyperion/device_setup_plans/setup_zebra.py

@@ -1,8 +1,4 @@
-from collections.abc import Callable
-from functools import wraps
-
 import bluesky.plan_stubs as bps
-import bluesky.preprocessors as bpp
 from bluesky.utils import MsgGenerator
 from dodal.devices.zebra.zebra import (
     ArmDemand,
@@ -21,31 +17,6 @@ from mx_bluesky.common.utils.log import LOGGER
 ZEBRA_STATUS_TIMEOUT = 30
 
 
-def bluesky_retry(func: Callable):
-    """Decorator that will retry the decorated plan if it fails.
-
-    Use this with care as it knows nothing about the state of the world when things fail.
-    If it is possible that your plan fails when the beamline is in a transient state that
-    the plan could not act on do not use this decorator without doing some more intelligent
-    clean up.
-
-    You should avoid using this decorator often in general production as it hides errors,
-    instead it should be used only for debugging these underlying errors.
-    """
-
-    @wraps(func)
-    def newfunc(*args, **kwargs):
-        def log_and_retry(exception):
-            LOGGER.error(f"Function {func.__name__} failed with {exception}, retrying")
-            yield from func(*args, **kwargs)
-
-        yield from bpp.contingency_wrapper(
-            func(*args, **kwargs), except_plan=log_and_retry, auto_raise=False
-        )
-
-    return newfunc
-
-
 def arm_zebra(zebra: Zebra):
     yield from bps.abs_set(zebra.pc.arm, ArmDemand.ARM, wait=True)
 
@@ -105,7 +76,6 @@ def configure_zebra_and_shutter_for_auto_shutter(
     yield from set_shutter_auto_input(zebra, input, group=group)
 
 
-@bluesky_retry
 def setup_zebra_for_rotation(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -185,7 +155,6 @@ def setup_zebra_for_rotation(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-@bluesky_retry
 def setup_zebra_for_gridscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -215,7 +184,6 @@ def setup_zebra_for_gridscan(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-@bluesky_retry
 def tidy_up_zebra_after_gridscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,
@@ -236,7 +204,6 @@ def tidy_up_zebra_after_gridscan(
         yield from bps.wait(group, timeout=ZEBRA_STATUS_TIMEOUT)
 
 
-@bluesky_retry
 def setup_zebra_for_panda_flyscan(
     zebra: Zebra,
     zebra_shutter: ZebraShutter,

mx_bluesky/hyperion/device_setup_plans/utils.py

@@ -3,16 +3,16 @@ from collections.abc import Generator
 from bluesky import plan_stubs as bps
 from bluesky import preprocessors as bpp
 from bluesky.utils import Msg
-from dodal.devices.dcm import DCM
 from dodal.devices.detector import (
     DetectorParams,
 )
 from dodal.devices.detector.detector_motion import DetectorMotion, ShutterState
 from dodal.devices.eiger import EigerDetector
-from dodal.devices.i03.beamstop import Beamstop
+from dodal.devices.i03 import Beamstop
+from dodal.devices.i03.dcm import DCM
 
-from mx_bluesky.hyperion.device_setup_plans.check_beamstop import check_beamstop
-from mx_bluesky.hyperion.device_setup_plans.position_detector import (
+from mx_bluesky.common.device_setup_plans.check_beamstop import check_beamstop
+from mx_bluesky.common.device_setup_plans.position_detector import (
     set_detector_z_position,
     set_shutter,
 )

mx_bluesky/hyperion/experiment_plans/__init__.py

@@ -3,9 +3,6 @@
 The __all__ list in here are the plans that are externally available from outside Hyperion.
 """
 
-from mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan import (
-    flyscan_xray_centre,
-)
 from mx_bluesky.hyperion.experiment_plans.grid_detect_then_xray_centre_plan import (
     grid_detect_then_xray_centre,
 )
@@ -17,13 +14,10 @@ from mx_bluesky.hyperion.experiment_plans.pin_centre_then_xray_centre_plan impor
 )
 from mx_bluesky.hyperion.experiment_plans.rotation_scan_plan import (
     multi_rotation_scan,
-    rotation_scan,
 )
 
 __all__ = [
-    "flyscan_xray_centre",
     "grid_detect_then_xray_centre",
-    "rotation_scan",
     "pin_tip_centre_then_xray_centre",
     "multi_rotation_scan",
     "load_centre_collect_full",

mx_bluesky/hyperion/experiment_plans/experiment_registry.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import TypedDict
 
-import mx_bluesky.hyperion.experiment_plans.flyscan_xray_centre_plan as flyscan_xray_centre_plan
 import mx_bluesky.hyperion.experiment_plans.rotation_scan_plan as rotation_scan_plan
 from mx_bluesky.hyperion.experiment_plans import (
     grid_detect_then_xray_centre_plan,
@@ -40,18 +39,10 @@ class ExperimentRegistryEntry(TypedDict):
 
 
 PLAN_REGISTRY: dict[str, ExperimentRegistryEntry] = {
-    "flyscan_xray_centre": {
-        "setup": flyscan_xray_centre_plan.create_devices,
-        "param_type": HyperionSpecifiedThreeDGridScan,
-    },
     "grid_detect_then_xray_centre": {
         "setup": grid_detect_then_xray_centre_plan.create_devices,
         "param_type": GridScanWithEdgeDetect,
     },
-    "rotation_scan": {
-        "setup": rotation_scan_plan.create_devices,
-        "param_type": RotationScan,
-    },
     "pin_tip_centre_then_xray_centre": {
         "setup": pin_centre_then_xray_centre_plan.create_devices,
         "param_type": PinTipCentreThenXrayCentre,