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

dodal/devices/oav/oav_detector.py

@@ -5,14 +5,21 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     LazyMock,
+    SignalR,
+    SignalRW,
     StandardReadable,
     derived_signal_r,
     soft_signal_rw,
 )
-from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.areadetector.plugins.CAM import Cam
-from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
+from dodal.devices.oav.oav_parameters import (
+    DEFAULT_OAV_WINDOW,
+    OAVConfig,
+    OAVConfigBase,
+    OAVConfigBeamCentre,
+)
 from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
 
@@ -30,7 +37,21 @@ def _get_correct_zoom_string(zoom: str) -> str:
     return zoom
 
 
-class ZoomController(StandardReadable, Movable[str]):
+class BaseZoomController(StandardReadable, Movable[str]):
+    level: SignalRW[str]
+    percentage: SignalRW[float]
+
+
+class NullZoomController(BaseZoomController):
+    def __init__(self):
+        self.level = soft_signal_rw(str, "1.0x")
+        self.percentage = soft_signal_rw(float, 100)
+
+    def set(self, value):
+        raise Exception("Attempting to set zoom level of a null zoom controller")
+
+
+class ZoomController(BaseZoomController):
     """
     Device to control the zoom level. This should be set like
         o = OAV(name="oav")
@@ -53,12 +74,27 @@ class ZoomController(StandardReadable, Movable[str]):
 
 
 class OAV(StandardReadable):
-    def __init__(self, prefix: str, config: OAVConfig, name: str = ""):
+    beam_centre_i: SignalR[int]
+    beam_centre_j: SignalR[int]
+
+    def __init__(
+        self,
+        prefix: str,
+        config: OAVConfigBase,
+        name: str = "",
+        zoom_controller: BaseZoomController | None = None,
+    ):
         self.oav_config = config
         self._prefix = prefix
         self._name = name
         _bl_prefix = prefix.split("-")[0]
-        self.zoom_controller = ZoomController(f"{_bl_prefix}-EA-OAV-01:FZOOM:", name)
+
+        if not zoom_controller:
+            self.zoom_controller = ZoomController(
+                f"{_bl_prefix}-EA-OAV-01:FZOOM:", name
+            )
+        else:
+            self.zoom_controller = zoom_controller
 
         self.cam = Cam(f"{prefix}CAM:", name=name)
         with self.add_children_as_readables():
@@ -79,18 +115,6 @@ class OAV(StandardReadable):
                 size=self.sizes[Coords.Y],
                 coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
-            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 = 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,
@@ -107,14 +131,6 @@ class OAV(StandardReadable):
         value = self.parameters[_zoom].microns_per_pixel[coord]
         return value * DEFAULT_OAV_WINDOW[coord] / size
 
-    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 = self._read_current_zoom(zoom_level)
-        value = self.parameters[_zoom].crosshair[coord]
-
-        return int(value * size / DEFAULT_OAV_WINDOW[coord])
-
     async def connect(
         self,
         mock: bool | LazyMock = False,
@@ -124,3 +140,63 @@ class OAV(StandardReadable):
         self.parameters = self.oav_config.get_parameters()
 
         return await super().connect(mock, timeout, force_reconnect)
+
+
+class OAVBeamCentreFile(OAV):
+    """OAV device that reads its beam centre values from a file. The config parameter
+    must be a OAVConfigBeamCentre object, as this contains a filepath to where the beam
+    centre values are stored.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        config: OAVConfigBeamCentre,
+        name: str = "",
+        zoom_controller: BaseZoomController | None = None,
+    ):
+        super().__init__(prefix, config, name, zoom_controller)
+
+        with self.add_children_as_readables():
+            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 = 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),
+            )
+        # Set name so that new child signals get correct name
+        self.set_name(self.name)
+
+    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 = self._read_current_zoom(zoom_level)
+        value = self.parameters[_zoom].crosshair[coord]
+        return int(value * size / DEFAULT_OAV_WINDOW[coord])
+
+
+class OAVBeamCentrePV(OAV):
+    """OAV device that reads its beam centre values from PVs."""
+
+    def __init__(
+        self,
+        prefix: str,
+        config: OAVConfig,
+        name: str = "",
+        zoom_controller: BaseZoomController | None = None,
+        overlay_channel: int = 1,
+    ):
+        with self.add_children_as_readables():
+            self.beam_centre_i = epics_signal_r(
+                int, prefix + f"OVER:{overlay_channel}:CenterX"
+            )
+            self.beam_centre_j = epics_signal_r(
+                int, prefix + f"OVER:{overlay_channel}:CenterY"
+            )
+        super().__init__(prefix, config, name, zoom_controller)

dodal/devices/oav/oav_parameters.py

@@ -1,8 +1,9 @@
 import json
 import xml.etree.ElementTree as et
+from abc import abstractmethod
 from collections import ChainMap
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic, TypeVar
 from xml.etree.ElementTree import Element
 
 # GDA currently assumes this aspect ratio for the OAV window size.
@@ -107,22 +108,19 @@ class OAVParameters:
 @dataclass
 class ZoomParams:
     microns_per_pixel: tuple[float, float]
+
+
+@dataclass
+class ZoomParamsCrosshair(ZoomParams):
     crosshair: tuple[int, int]
 
 
-class OAVConfig:
-    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
-    with information about microns per pixels and crosshairs.
-    """
+ParamType = TypeVar("ParamType", bound="ZoomParams")
 
-    def __init__(self, zoom_params_file: str, display_config_file: str):
-        self.zoom_params = self._get_zoom_params(zoom_params_file)
-        self.display_config = self._get_display_config(display_config_file)
 
-    def _get_display_config(self, display_config_file: str):
-        with open(display_config_file) as f:
-            file_lines = f.readlines()
-        return file_lines
+class OAVConfigBase(Generic[ParamType]):
+    def __init__(self, zoom_params_file: str):
+        self.zoom_params = self._get_zoom_params(zoom_params_file)
 
     def _get_zoom_params(self, zoom_params_file: str):
         tree = et.parse(zoom_params_file)
@@ -138,6 +136,39 @@ class OAVConfig:
             um_per_pix[zoom] = (um_pix_x, um_pix_y)
         return um_per_pix
 
+    @abstractmethod
+    def get_parameters(self) -> dict[str, ParamType]: ...
+
+
+class OAVConfig(OAVConfigBase[ZoomParams]):
+    def get_parameters(self) -> dict[str, ZoomParams]:
+        config = {}
+        um_xy = self._read_zoom_params()
+        for zoom_key in list(um_xy.keys()):
+            config[zoom_key] = ZoomParams(
+                microns_per_pixel=um_xy[zoom_key],
+            )
+        return config
+
+
+class OAVConfigBeamCentre(OAVConfigBase[ZoomParamsCrosshair]):
+    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
+    with information about microns per pixels and crosshairs.
+    """
+
+    def __init__(
+        self,
+        zoom_params_file: str,
+        display_config_file: str,
+    ):
+        self.display_config = self._get_display_config(display_config_file)
+        super().__init__(zoom_params_file)
+
+    def _get_display_config(self, display_config_file: str):
+        with open(display_config_file) as f:
+            file_lines = f.readlines()
+        return file_lines
+
     def _read_display_config(self) -> dict:
         crosshairs = {}
         for i in range(len(self.display_config)):
@@ -148,13 +179,12 @@ class OAVConfig:
                 crosshairs[zoom] = (x, y)
         return crosshairs
 
-    def get_parameters(self) -> dict[str, ZoomParams]:
+    def get_parameters(self) -> dict[str, ZoomParamsCrosshair]:
         config = {}
         um_xy = self._read_zoom_params()
         bc_xy = self._read_display_config()
         for zoom_key in list(bc_xy.keys()):
-            config[zoom_key] = ZoomParams(
-                microns_per_pixel=um_xy[zoom_key],
-                crosshair=bc_xy[zoom_key],
+            config[zoom_key] = ZoomParamsCrosshair(
+                microns_per_pixel=um_xy[zoom_key], crosshair=bc_xy[zoom_key]
             )
         return config

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -1,7 +1,7 @@
 import asyncio
 from collections.abc import Awaitable, Callable
 from datetime import timedelta
-from enum import Enum
+from enum import IntEnum
 from uuid import uuid4
 
 from aiohttp import ClientResponse, ClientSession
@@ -29,7 +29,7 @@ async def get_next_jpeg(response: ClientResponse) -> bytes:
             return line + await response.content.readuntil(JPEG_STOP_BYTE)
 
 
-class Source(Enum):
+class Source(IntEnum):
     FULL_SCREEN = 0
     ROI = 1
 

dodal/devices/robot.py

@@ -11,7 +11,12 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_x,
+)
 
 from dodal.log import LOGGER
 
@@ -88,6 +93,20 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.controller_error = ErrorStatus(prefix + "CNTL")
 
         self.reset = epics_signal_x(prefix + "RESET.PROC")
+        self.stop = epics_signal_x(prefix + "ABORT.PROC")
+        self.init = epics_signal_x(prefix + "INIT.PROC")
+        self.soak = epics_signal_x(prefix + "SOAK.PROC")
+        self.home = epics_signal_x(prefix + "GOHM.PROC")
+        self.unload = epics_signal_x(prefix + "UNLD.PROC")
+        self.dry = epics_signal_x(prefix + "DRY.PROC")
+        self.open = epics_signal_x(prefix + "COLO.PROC")
+        self.close = epics_signal_x(prefix + "COLC.PROC")
+        self.cryomode_rbv = epics_signal_r(float, prefix + "CRYO_MODE_RBV")
+        self.cryomode = epics_signal_rw(str, prefix + "CRYO_MODE_CTRL")
+        self.gripper_temp = epics_signal_r(float, prefix + "GRIPPER_TEMP")
+        self.dewar_lid_temperature = epics_signal_rw(
+            float, prefix + "DW_1_TEMP", prefix + "DW_1_SET_POINT"
+        )
         super().__init__(name=name)
 
     async def pin_mounted_or_no_pin_found(self):

dodal/devices/smargon.py

@@ -1,14 +1,23 @@
+import asyncio
 from collections.abc import Collection, Generator
 from dataclasses import dataclass
 from enum import Enum
 from math import isclose
-from typing import cast
+from typing import TypedDict, cast
 
 from bluesky import plan_stubs as bps
+from bluesky.protocols import Movable
 from bluesky.utils import Msg
-from ophyd_async.core import AsyncStatus, Device, StandardReadable, wait_for_value
-from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    StandardReadable,
+    StrictEnum,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from ophyd_async.epics.motor import Motor
+from typing_extensions import NotRequired
 
 from dodal.devices.util.epics_util import SetWhenEnabled
 
@@ -91,7 +100,23 @@ class XYZLimits:
         )
 
 
-class Smargon(StandardReadable):
+class DeferMoves(StrictEnum):
+    ON = "Defer On"
+    OFF = "Defer Off"
+
+
+class CombinedMove(TypedDict):
+    """A move on multiple axes at once using a deferred move"""
+
+    x: NotRequired[float | None]
+    y: NotRequired[float | None]
+    z: NotRequired[float | None]
+    omega: NotRequired[float | None]
+    phi: NotRequired[float | None]
+    chi: NotRequired[float | None]
+
+
+class Smargon(StandardReadable, Movable):
     """
     Real motors added to allow stops following pin load (e.g. real_x1.stop() )
     X1 and X2 real motors provide compound chi motion as well as the compound X travel,
@@ -116,6 +141,8 @@ class Smargon(StandardReadable):
             self.stub_offsets = StubOffsets(prefix=prefix)
             self.disabled = epics_signal_r(int, prefix + "DISABLED")
 
+        self.defer_move = epics_signal_rw(DeferMoves, prefix + "CS1:DeferMoves")
+
         super().__init__(name)
 
     def get_xyz_limits(self) -> Generator[Msg, None, XYZLimits]:
@@ -135,3 +162,15 @@ class Smargon(StandardReadable):
             max_value = yield from bps.rd(pv.high_limit_travel)
             limits[name] = AxisLimit(min_value, max_value)
         return XYZLimits(**limits)
+
+    @AsyncStatus.wrap
+    async def set(self, value: CombinedMove):
+        await self.defer_move.set(DeferMoves.ON)
+        try:
+            tasks = []
+            for k, v in value.items():
+                if v is not None:
+                    tasks.append(getattr(self, k).set(v))
+            await asyncio.gather(*tasks)
+        finally:
+            await self.defer_move.set(DeferMoves.OFF)

dodal/devices/zebra/zebra.py

@@ -68,6 +68,14 @@ class RotationDirection(StrictEnum):
     def multiplier(self):
         return 1 if self == RotationDirection.POSITIVE else -1
 
+    @property
+    def opposite(self) -> RotationDirection:
+        return (
+            RotationDirection.POSITIVE
+            if self == RotationDirection.NEGATIVE
+            else RotationDirection.NEGATIVE
+        )
+
 
 class ArmDemand(Enum):
     ARM = 1

dodal/plans/configure_arm_trigger_and_disarm_detector.py

@@ -0,0 +1,167 @@
+import time
+
+import bluesky.plan_stubs as bps
+from bluesky import preprocessors as bpp
+from bluesky.run_engine import RunEngine
+from ophyd_async.core import DetectorTrigger
+from ophyd_async.fastcs.eiger import EigerDetector, EigerTriggerInfo
+
+from dodal.beamlines.i03 import fastcs_eiger
+from dodal.devices.detector import DetectorParams
+from dodal.log import LOGGER, do_default_logging_setup
+
+
+@bpp.run_decorator()
+def configure_arm_trigger_and_disarm_detector(
+    eiger: EigerDetector,
+    detector_params: DetectorParams,
+    trigger_info: EigerTriggerInfo,
+):
+    assert detector_params.expected_energy_ev
+    start = time.time()
+    yield from bps.unstage(eiger, wait=True)
+    LOGGER.info(f"Stopping Eiger-Odin: {time.time() - start}s")
+    start = time.time()
+    yield from set_cam_pvs(eiger, detector_params, wait=True)
+    LOGGER.info(f"Setting CAM PVs: {time.time() - start}s")
+    start = time.time()
+    yield from change_roi_mode(eiger, detector_params, wait=True)
+    LOGGER.info(f"Changing ROI Mode: {time.time() - start}s")
+    start = time.time()
+    yield from bps.abs_set(eiger.odin.num_frames_chunks, 1)
+    LOGGER.info(f"Setting # of Frame Chunks: {time.time() - start}s")
+    start = time.time()
+    yield from set_mx_settings_pvs(eiger, detector_params, wait=True)
+    LOGGER.info(f"Setting MX PVs: {time.time() - start}s")
+    start = time.time()
+    yield from bps.prepare(eiger, trigger_info, wait=True)
+    LOGGER.info(f"Preparing Eiger: {time.time() - start}s")
+    start = time.time()
+    yield from bps.kickoff(eiger, wait=True)
+    LOGGER.info(f"Kickoff Eiger: {time.time() - start}s")
+    start = time.time()
+    yield from bps.trigger(eiger.drv.detector.trigger)  # type: ignore
+    LOGGER.info(f"Triggering Eiger: {time.time() - start}s")
+    start = time.time()
+    yield from bps.complete(eiger, wait=True)
+    LOGGER.info(f"Completing Capture: {time.time() - start}s")
+    start = time.time()
+    yield from bps.unstage(eiger, wait=True)
+    LOGGER.info(f"Disarming Eiger: {time.time() - start}s")
+
+
+def set_cam_pvs(
+    eiger: EigerDetector,
+    detector_params: DetectorParams,
+    wait: bool,
+    group="cam_pvs",
+):
+    yield from bps.abs_set(
+        eiger.drv.detector.count_time, detector_params.exposure_time_s, group=group
+    )
+    yield from bps.abs_set(
+        eiger.drv.detector.frame_time, detector_params.exposure_time_s, group=group
+    )
+    yield from bps.abs_set(eiger.drv.detector.nexpi, 1, group=group)
+
+    if wait:
+        yield from bps.wait(group)
+
+
+def change_roi_mode(
+    eiger: EigerDetector,
+    detector_params: DetectorParams,
+    wait: bool,
+    group="roi_mode",
+):
+    detector_dimensions = (
+        detector_params.detector_size_constants.roi_size_pixels
+        if detector_params.use_roi_mode
+        else detector_params.detector_size_constants.det_size_pixels
+    )
+
+    yield from bps.abs_set(
+        eiger.drv.detector.roi_mode,
+        1 if detector_params.use_roi_mode else 0,
+        group=group,
+    )
+    yield from bps.abs_set(
+        eiger.odin.image_height,
+        detector_dimensions.height,
+        group=group,
+    )
+    yield from bps.abs_set(
+        eiger.odin.image_width,
+        detector_dimensions.width,
+        group=group,
+    )
+    yield from bps.abs_set(
+        eiger.odin.num_row_chunks,
+        detector_dimensions.height,
+        group=group,
+    )
+    yield from bps.abs_set(
+        eiger.odin.num_col_chunks,
+        detector_dimensions.width,
+        group=group,
+    )
+
+    if wait:
+        yield from bps.wait(group)
+
+
+def set_mx_settings_pvs(
+    eiger: EigerDetector,
+    detector_params: DetectorParams,
+    wait: bool,
+    group="mx_settings",
+):
+    beam_x_pixels, beam_y_pixels = detector_params.get_beam_position_pixels(
+        detector_params.detector_distance
+    )
+
+    yield from bps.abs_set(eiger.drv.detector.beam_center_x, beam_x_pixels, group)
+    yield from bps.abs_set(eiger.drv.detector.beam_center_y, beam_y_pixels, group)
+    yield from bps.abs_set(
+        eiger.drv.detector.detector_distance, detector_params.detector_distance, group
+    )
+
+    yield from bps.abs_set(
+        eiger.drv.detector.omega_start, detector_params.omega_start, group
+    )
+    yield from bps.abs_set(
+        eiger.drv.detector.omega_increment, detector_params.omega_increment, group
+    )
+
+    if wait:
+        yield from bps.wait(group)
+
+
+if __name__ == "__main__":
+    RE = RunEngine()
+    do_default_logging_setup()
+    eiger = fastcs_eiger(connect_immediately=True)
+    RE(
+        configure_arm_trigger_and_disarm_detector(
+            eiger=eiger,
+            detector_params=DetectorParams(
+                expected_energy_ev=12800,
+                exposure_time_s=0.01,
+                directory="/dls/i03/data/2025/cm40607-2/test_new_eiger/",
+                prefix="",
+                detector_distance=255,
+                omega_start=0,
+                omega_increment=0.1,
+                num_images_per_trigger=1,
+                num_triggers=1,
+                use_roi_mode=False,
+                det_dist_to_beam_converter_path="/dls_sw/i03/software/daq_configuration/lookup/DetDistToBeamXYConverter.txt",
+            ),
+            trigger_info=EigerTriggerInfo(
+                number_of_events=1,
+                energy_ev=12800,
+                trigger=DetectorTrigger.INTERNAL,
+                deadtime=0.0001,
+            ),
+        )
+    )

dodal/plan_stubs/electron_analyser/__init__.py

@@ -1,3 +0,0 @@
-from .configure_driver import configure_analyser, configure_specs, configure_vgscienta
-
-__all__ = ["configure_analyser", "configure_specs", "configure_vgscienta"]

dodal/plan_stubs/electron_analyser/configure_driver.py

@@ -1,92 +0,0 @@
-from bluesky import plan_stubs as bps
-from bluesky.utils import MsgGenerator, plan
-from ophyd_async.epics.adcore import ADImageMode
-
-from dodal.common.types import MsgGenerator
-from dodal.devices.electron_analyser.abstract import (
-    AbstractAnalyserDriverIO,
-    AbstractBaseRegion,
-)
-from dodal.devices.electron_analyser.specs import SpecsAnalyserDriverIO, SpecsRegion
-from dodal.devices.electron_analyser.util import to_kinetic_energy
-from dodal.devices.electron_analyser.vgscienta import (
-    VGScientaAnalyserDriverIO,
-    VGScientaRegion,
-)
-from dodal.log import LOGGER
-
-
-@plan
-def configure_analyser(
-    analyser: AbstractAnalyserDriverIO,
-    region: AbstractBaseRegion,
-    excitation_energy: float,
-) -> MsgGenerator:
-    LOGGER.info(f'Configuring analyser with region "{region.name}"')
-
-    low_energy = to_kinetic_energy(
-        region.low_energy, region.energy_mode, excitation_energy
-    )
-    high_energy = to_kinetic_energy(
-        region.high_energy, region.energy_mode, excitation_energy
-    )
-    pass_energy_type = analyser.pass_energy_type
-    pass_energy = pass_energy_type(region.pass_energy)
-
-    # Set detector settings, wait for them all to have completed
-    # fmt: off
-    yield from bps.mv(
-        analyser.region_name, region.name,
-        analyser.energy_mode, region.energy_mode,
-        analyser.excitation_energy, excitation_energy,
-        analyser.low_energy, low_energy,
-        analyser.high_energy, high_energy,
-        analyser.slices, region.slices,
-        analyser.lens_mode, region.lens_mode,
-        analyser.pass_energy, pass_energy,
-        analyser.iterations, region.iterations,
-        analyser.acquisition_mode, region.acquisition_mode,
-    )
-    # fmt: on
-
-
-@plan
-def configure_specs(
-    analyser: SpecsAnalyserDriverIO, region: SpecsRegion, excitation_energy: float
-) -> MsgGenerator:
-    yield from configure_analyser(analyser, region, excitation_energy)
-    # fmt: off
-    yield from bps.mv(
-        analyser.snapshot_values, region.values,
-        analyser.psu_mode, region.psu_mode,
-    )
-    # fmt: on
-    if region.acquisition_mode == "Fixed Transmission":
-        yield from bps.mv(analyser.centre_energy, region.centre_energy)
-
-    if region.acquisition_mode == "Fixed Energy":
-        yield from bps.mv(analyser.energy_step, region.energy_step)
-
-
-@plan
-def configure_vgscienta(
-    analyser: VGScientaAnalyserDriverIO, region: VGScientaRegion, excitation_energy
-) -> MsgGenerator:
-    yield from configure_analyser(analyser, region, excitation_energy)
-    centre_energy = to_kinetic_energy(
-        region.fix_energy, region.energy_mode, excitation_energy
-    )
-
-    # fmt: off
-    yield from bps.mv(
-        analyser.centre_energy, centre_energy,
-        analyser.energy_step, region.energy_step,
-        analyser.first_x_channel, region.first_x_channel,
-        analyser.first_y_channel, region.first_y_channel,
-        analyser.x_channel_size, region.x_channel_size(),
-        analyser.y_channel_size, region.y_channel_size(),
-        analyser.detector_mode, region.detector_mode,
-        analyser.excitation_energy_source, region.excitation_energy_source,
-        analyser.image_mode, ADImageMode.SINGLE,
-    )
-    # fmt: on