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

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