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

dodal/devices/i22/dcm.py

@@ -5,7 +5,6 @@ from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
 from ophyd_async.core import (
     Array1D,
-    StandardReadable,
     StandardReadableFormat,
     soft_signal_r_and_setter,
 )
@@ -13,13 +12,18 @@ from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.crystal_metadata import CrystalMetadata
+from dodal.devices.common_dcm import (
+    BaseDCM,
+    PitchAndRollCrystal,
+    RollCrystal,
+)
 
 # Conversion constant for energy and wavelength, taken from the X-Ray data booklet
 # Converts between energy in KeV and wavelength in angstrom
 _CONVERSION_CONSTANT = 12.3984
 
 
-class DoubleCrystalMonochromator(StandardReadable):
+class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
 
@@ -39,13 +43,7 @@ class DoubleCrystalMonochromator(StandardReadable):
     ) -> None:
         with self.add_children_as_readables():
             # Positionable Parameters
-            self.bragg = Motor(prefix + "BRAGG")
-            self.offset = Motor(prefix + "OFFSET")
             self.perp = Motor(prefix + "PERP")
-            self.energy = Motor(prefix + "ENERGY")
-            self.crystal_1_roll = Motor(prefix + "XTAL1:ROLL")
-            self.crystal_2_roll = Motor(prefix + "XTAL2:ROLL")
-            self.crystal_2_pitch = Motor(prefix + "XTAL2:PITCH")
 
             # Temperatures
             self.backplate_temp = epics_signal_r(float, temperature_prefix + "PT100-7")
@@ -93,12 +91,12 @@ class DoubleCrystalMonochromator(StandardReadable):
                 units=crystal_2_metadata.d_spacing[1],
             )
 
-        super().__init__(name)
+        super().__init__(prefix, RollCrystal, PitchAndRollCrystal, name)
 
     async def describe(self) -> dict[str, DataKey]:
         default_describe = await super().describe()
         return {
-            f"{self.name}-wavelength": DataKey(
+            f"{self.name}-wavelength_in_a": DataKey(
                 dtype="number",
                 shape=[],
                 source=self.name,
@@ -109,7 +107,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
     async def read(self) -> dict[str, Reading]:
         default_reading = await super().read()
-        energy: float = default_reading[f"{self.name}-energy"]["value"]
+        energy: float = default_reading[f"{self.name}-energy_in_kev"]["value"]
         if energy > 0.0:
             wavelength = _CONVERSION_CONSTANT / energy
         else:
@@ -117,7 +115,7 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         return {
             **default_reading,
-            f"{self.name}-wavelength": Reading(
+            f"{self.name}-wavelength_in_a": Reading(
                 value=wavelength,
                 timestamp=time.time(),
             ),

dodal/devices/i24/dcm.py

@@ -1,28 +1,19 @@
-from ophyd_async.core import StandardReadable
 from ophyd_async.epics.core import epics_signal_r
-from ophyd_async.epics.motor import Motor
 
+from dodal.devices.common_dcm import (
+    BaseDCM,
+    PitchAndRollCrystal,
+    RollCrystal,
+)
 
-class DCM(StandardReadable):
+
+class DCM(BaseDCM[RollCrystal, PitchAndRollCrystal]):
     """
     A double crystal monocromator device, used to select the beam energy.
     """
 
     def __init__(self, prefix: str, name: str = "") -> None:
         with self.add_children_as_readables():
-            # Motors
-            self.bragg_in_degrees = Motor(prefix + "-MO-DCM-01:BRAGG")
-            self.x_translation_in_mm = Motor(prefix + "-MO-DCM-01:X")
-            self.offset_in_mm = Motor(prefix + "-MO-DCM-01:OFFSET")
-            self.gap_in_mm = Motor(prefix + "-MO-DCM-01:GAP")
-            self.energy_in_kev = Motor(prefix + "-MO-DCM-01:ENERGY")
-            self.xtal1_roll = Motor(prefix + "-MO-DCM-01:XTAL1:ROLL")
-            self.xtal2_roll = Motor(prefix + "-MO-DCM-01:XTAL2:ROLL")
-            self.xtal2_pitch = Motor(prefix + "-MO-DCM-01:XTAL2:PITCH")
-
-            # Wavelength is calculated in epics from the energy
-            self.wavelength_in_a = epics_signal_r(float, prefix + "-MO-DCM-01:LAMBDA")
-
             # Temperatures
             self.xtal1_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-1")
             self.xtal1_heater_temp = epics_signal_r(
@@ -39,4 +30,4 @@ class DCM(StandardReadable):
             self.b1_plate_temp = epics_signal_r(float, prefix + "-DI-DCM-01:PT100-7")
             self.gap_temp = epics_signal_r(float, prefix + "-DI-DCM-01:TC-1")
 
-        super().__init__(name)
+        super().__init__(prefix + "-MO-DCM-01:", RollCrystal, PitchAndRollCrystal, name)

dodal/devices/motors.py

@@ -38,3 +38,24 @@ class XYZPositioner(StandardReadable):
             self.y = Motor(prefix + infix[1])
             self.z = Motor(prefix + infix[2])
         super().__init__(name=name)
+
+
+class SixAxisGonio(XYZPositioner):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        infix: tuple[str, str, str, str, str, str] = (
+            "X",
+            "Y",
+            "Z",
+            "KAPPA",
+            "PHI",
+            "OMEGA",
+        ),
+    ):
+        with self.add_children_as_readables():
+            self.kappa = Motor(prefix + infix[3])
+            self.phi = Motor(prefix + infix[4])
+            self.omega = Motor(prefix + infix[5])
+        super().__init__(name=name, prefix=prefix, infix=infix[0:3])

dodal/devices/tetramm.py

@@ -244,10 +244,9 @@ class TetrammDetector(StandardDetector):
         super().__init__(
             controller,
             ADHDFWriter(
-                self.hdf,
-                path_provider,
-                lambda: self.name,
-                TetrammDatasetDescriber(controller),
+                fileio=self.hdf,
+                path_provider=path_provider,
+                dataset_describer=TetrammDatasetDescriber(controller),
                 plugins=plugins,
             ),
             config_signals,

dodal/devices/turbo_slit.py

@@ -1,8 +1,9 @@
-from ophyd_async.core import StandardReadable
+from bluesky.protocols import Movable
+from ophyd_async.core import AsyncStatus, StandardReadable
 from ophyd_async.epics.motor import Motor
 
 
-class TurboSlit(StandardReadable):
+class TurboSlit(StandardReadable, Movable[float]):
     """
     This collection of motors coordinates time resolved XAS experiments.
     It selects a beam out of the polychromatic fan.
@@ -12,9 +13,9 @@ class TurboSlit(StandardReadable):
     The xfine motor can move the slit in x direction at high frequencies for different scans.
     These slits can be scanned continously or in step mode.
     The relationship between the three motors is as follows:
-        - arc - position of the middle of the gap (coarse/ macro) extension
+        - arc - position of the middle of the gap in degrees (coarse/ macro) extension
         - gap - width in mm, provides energy resolution
-        - xfine selects the energy as part of the high frequency scan
+        - xfine - main scanning axis in mm, selects the energy as part of the high frequency scan
     """
 
     def __init__(self, prefix: str, name: str = ""):
@@ -23,3 +24,8 @@ class TurboSlit(StandardReadable):
             self.arc = Motor(prefix=prefix + "ARC")
             self.xfine = Motor(prefix=prefix + "XFINE")
         super().__init__(name=name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """This will move the default XFINE"""
+        await self.xfine.set(value)

dodal/devices/undulator.py

@@ -2,7 +2,7 @@ import os
 
 import numpy as np
 from bluesky.protocols import Movable
-from numpy import argmin, ndarray
+from numpy import ndarray
 from ophyd_async.core import (
     AsyncStatus,
     StandardReadable,
@@ -38,12 +38,12 @@ class UndulatorGapAccess(StrictEnum):
     DISABLED = "DISABLED"
 
 
-def _get_closest_gap_for_energy(
+def _get_gap_for_energy(
     dcm_energy_ev: float, energy_to_distance_table: ndarray
 ) -> float:
-    table = energy_to_distance_table.transpose()
-    idx = argmin(np.abs(table[0] - dcm_energy_ev))
-    return table[1][idx]
+    return np.interp(
+        dcm_energy_ev, energy_to_distance_table[:, 0], energy_to_distance_table[:, 1]
+    )
 
 
 class Undulator(StandardReadable, Movable[float]):
@@ -115,8 +115,10 @@ class Undulator(StandardReadable, Movable[float]):
 
     async def _set_undulator_gap(self, energy_kev: float) -> None:
         await self.raise_if_not_enabled()
-        LOGGER.info(f"Setting undulator gap to {energy_kev:.2f} kev")
         target_gap = await self._get_gap_to_match_energy(energy_kev)
+        LOGGER.info(
+            f"Setting undulator gap to {target_gap:.3f}mm based on {energy_kev:.2f}kev"
+        )
 
         # Check if undulator gap is close enough to the value from the DCM
         current_gap = await self.current_gap.get_value()
@@ -152,7 +154,7 @@ class Undulator(StandardReadable, Movable[float]):
         )
 
         # Use the lookup table to get the undulator gap associated with this dcm energy
-        return _get_closest_gap_for_energy(
+        return _get_gap_for_energy(
             energy_kev * 1000,
             energy_to_distance_table,
         )

dodal/devices/util/adjuster_plans.py

@@ -7,14 +7,13 @@ from collections.abc import Callable, Generator
 
 from bluesky import plan_stubs as bps
 from bluesky.utils import Msg
-from ophyd.epics_motor import EpicsMotor
 from ophyd_async.epics.motor import Motor
 
 from dodal.log import LOGGER
 
 
 def lookup_table_adjuster(
-    lookup_table: Callable[[float], float], output_device: EpicsMotor | Motor, input
+    lookup_table: Callable[[float], float], output_device: Motor, input
 ):
     """Returns a callable that adjusts a value according to a lookup table"""
 

dodal/devices/util/lookup_tables.py

@@ -64,3 +64,41 @@ def linear_interpolation_lut(
         return float(interp(s, s_values, t_values))
 
     return s_to_t2
+
+
+def linear_extrapolation_lut(
+    s_values: Sequence[float], t_values: Sequence[float]
+) -> Callable[[float], float]:
+    """
+    Return a callable that implements f(s) = t according to the conversion table data
+    supplied, with linear extrapolation outside that range. Inside the range of the table,
+    the function is equivalent to that returned by linear_interpolation_lut
+
+    Args:
+        s_values:  Values of the independent axis
+        t_values:  Values of the dependent axis
+
+    Returns:
+        A callable that returns t for the given s
+    """
+    assert len(s_values) == len(t_values), (
+        "Lookup table does not have the same number of values for each axis"
+    )
+    assert len(s_values) > 1, "Need at least 2 points in the lookup table"
+    interp = linear_interpolation_lut(s_values, t_values)
+    s_min = s_values[0]
+    s_max = s_values[-1]
+
+    def s_to_t(s: float) -> float:
+        if s < s_min:
+            return t_values[0] + (s - s_min) * (t_values[1] - t_values[0]) / (
+                s_values[1] - s_values[0]
+            )
+        elif s > s_max:
+            return t_values[-1] + (s - s_max) * (t_values[-1] - t_values[-2]) / (
+                s_values[-1] - s_values[-2]
+            )
+        else:
+            return interp(s)
+
+    return s_to_t

dodal/devices/util/test_utils.py

@@ -11,6 +11,7 @@ def patch_motor(motor: Motor, initial_position=0):
     set_mock_value(motor.deadband, 0.001)
     set_mock_value(motor.motor_done_move, 1)
     set_mock_value(motor.velocity, 3)
+    set_mock_value(motor.max_velocity, 5)
     return callback_on_mock_put(
         motor.user_setpoint,
         lambda pos, *args, **kwargs: set_mock_value(motor.user_readback, pos),

dodal/devices/zebra/zebra.py

@@ -51,6 +51,10 @@ class I24Axes:
     VGON_YH = EncEnum.ENC4
 
 
+class I23Axes:
+    OMEGA = EncEnum.ENC1
+
+
 class RotationDirection(StrictEnum):
     """
     Defines for a swept angle whether the scan width (sweep) is to be added or subtracted from

dodal/plan_stubs/data_session.py

@@ -33,7 +33,11 @@ def attach_data_session_metadata_wrapper(
     Yields:
         Iterator[Msg]: Plan messages
     """
-    provider = provider or get_path_provider()
+    try:
+        provider = provider or get_path_provider()
+    except NameError:
+        provider = None
+
     if isinstance(provider, UpdatingPathProvider):
         yield from bps.wait_for([provider.update])
         ress = yield from bps.wait_for([provider.data_session])
@@ -41,6 +45,11 @@ def attach_data_session_metadata_wrapper(
         # https://github.com/DiamondLightSource/dodal/issues/452
         # As part of 452, write each dataCollection into their own folder, then can use resource_dir directly
         yield from bpp.inject_md_wrapper(plan, md={DATA_SESSION: data_session})
+    elif provider is None:
+        logging.warning(
+            f"There is no PathProvider set, {attach_data_session_metadata_wrapper.__name__} will have no effect"
+        )
+        yield from plan
     else:
         logging.warning(
             f"{provider} is not an UpdatingPathProvider, {attach_data_session_metadata_wrapper.__name__} will have no effect"

dodal/plan_stubs/electron_analyser/configure_controller.py

@@ -0,0 +1,80 @@
+from bluesky import plan_stubs as bps
+
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.abstract_region import (
+    AbstractBaseRegion,
+)
+from dodal.devices.electron_analyser.specs_analyser_io import (
+    SpecsAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.specs_region import SpecsRegion
+from dodal.devices.electron_analyser.vgscienta_analyser_io import (
+    VGScientaAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta_region import (
+    VGScientaRegion,
+)
+from dodal.log import LOGGER
+
+
+def configure_analyser(
+    analyser: AbstractAnalyserDriverIO,
+    region: AbstractBaseRegion,
+    excitation_energy: float,
+):
+    LOGGER.info(f'Configuring analyser with region "{region.name}"')
+    low_energy = region.to_kinetic_energy(region.low_energy, excitation_energy)
+    high_energy = region.to_kinetic_energy(region.high_energy, 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.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
+
+
+def configure_specs(
+    analyser: SpecsAnalyserDriverIO, region: SpecsRegion, excitation_energy: float
+):
+    yield from configure_analyser(analyser, region, excitation_energy)
+    # fmt: off
+    yield from bps.mv(
+        analyser.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)
+
+
+def configure_vgscienta(
+    analyser: VGScientaAnalyserDriverIO, region: VGScientaRegion, excitation_energy
+):
+    yield from configure_analyser(analyser, region, excitation_energy)
+    centre_energy = region.to_kinetic_energy(region.fix_energy, 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.image_mode, "Single",
+    )
+    # fmt: on

dodal/plans/verify_undulator_gap.py

@@ -2,14 +2,14 @@ from typing import Protocol, runtime_checkable
 
 from bluesky import plan_stubs as bps
 
-from dodal.devices.dcm import DCM
+from dodal.devices.common_dcm import BaseDCM
 from dodal.devices.undulator import Undulator
 
 
 @runtime_checkable
 class CheckUndulatorDevices(Protocol):
     undulator: Undulator
-    dcm: DCM
+    dcm: BaseDCM
 
 
 def verify_undulator_gap(devices: CheckUndulatorDevices):

dodal/devices/electron_analyser/base_region.py

@@ -1,64 +0,0 @@
-from enum import Enum
-from typing import Any, Generic, TypeVar
-
-from pydantic import BaseModel, Field, model_validator
-
-
-class EnergyMode(str, Enum):
-    KINETIC = "Kinetic"
-    BINDING = "Binding"
-
-
-class BaseRegion(BaseModel):
-    """
-    Generic region model that holds the data. Specialised region models should inherit
-    this to extend functionality.
-    """
-
-    name: str = "New_region"
-    enabled: bool = False
-    slices: int = 1
-    iterations: int = 1
-    # These ones we need subclasses to provide default values
-    lensMode: str
-    passEnergy: int | float
-    acquisitionMode: str
-    lowEnergy: float
-    highEnergy: float
-    stepTime: float
-    energyStep: float
-    energyMode: EnergyMode = EnergyMode.KINETIC
-
-    @model_validator(mode="before")
-    @classmethod
-    def check_energy_mode(cls, data: Any) -> Any:
-        if isinstance(data, dict):
-            # convert bindingEnergy to energyMode to make base region more generic
-            if "bindingEnergy" in data:
-                is_binding_energy = data["bindingEnergy"]
-                del data["bindingEnergy"]
-                data["energyMode"] = (
-                    EnergyMode.BINDING if is_binding_energy else EnergyMode.KINETIC
-                )
-        return data
-
-
-TBaseRegion = TypeVar("TBaseRegion", bound=BaseRegion)
-
-
-class BaseSequence(BaseModel, Generic[TBaseRegion]):
-    """
-    Generic sequence model that holds the list of region data. Specialised sequence models
-    should inherit this to extend functionality.
-    """
-
-    regions: list[TBaseRegion] = Field(default_factory=lambda: [])
-
-    def get_enabled_regions(self) -> list[BaseRegion]:
-        return [r for r in self.regions if r.enabled]
-
-    def get_region_names(self) -> list[str]:
-        return [r.name for r in self.regions]
-
-    def get_enabled_region_names(self) -> list[str]:
-        return [r.name for r in self.get_enabled_regions()]

dodal/devices/electron_analyser/specs/specs_region.py

@@ -1,24 +0,0 @@
-from pydantic import Field
-
-from dodal.devices.electron_analyser.base_region import BaseRegion, BaseSequence
-
-
-class SpecsRegion(BaseRegion):
-    # Override base class with defaults
-    lensMode: str = "SmallArea"
-    passEnergy: int | float = 5.0
-    acquisitionMode: str = "Fixed Transmission"
-    lowEnergy: float = Field(default=800, alias="startEnergy")
-    highEnergy: float = Field(default=850, alias="endEnergy")
-    stepTime: float = Field(default=1.0, alias="exposureTime")
-    energyStep: float = Field(default=0.1, alias="stepEnergy")
-    # Specific to this class
-    values: float = 1
-    centreEnergy: float = 0
-    psuMode: str = "1.5keV"
-    acquisitionMode: str = ""
-    estimatedTimeInMs: float = 0
-
-
-class SpecsSequence(BaseSequence):
-    regions: list[SpecsRegion] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/vgscienta/vgscienta_region.py

@@ -1,77 +0,0 @@
-import uuid
-from enum import Enum
-
-from ophyd_async.core import StrictEnum
-from pydantic import BaseModel, Field
-
-from dodal.devices.electron_analyser.base_region import BaseRegion, BaseSequence
-
-
-class Status(str, Enum):
-    READY = "Ready"
-    RUNNING = "Running"
-    COMPLETED = "Completed"
-    INVALID = "Invalid"
-    ABORTED = "Aborted"
-
-
-class DetectorMode(StrictEnum):
-    ADC = "ADC"
-    PULSE_COUNTING = "Pulse Counting"
-
-
-class AcquisitionMode(str, Enum):
-    SWEPT = "Swept"
-    FIXED = "Fixed"
-
-
-class VGScientaRegion(BaseRegion):
-    # Override defaults of base region class
-    lensMode: str = "Angular45"
-    passEnergy: int | float = 5
-    acquisitionMode: str = AcquisitionMode.SWEPT
-    lowEnergy: float = 8.0
-    highEnergy: float = 10.0
-    stepTime: float = 1.0
-    energyStep: float = Field(default=200.0)
-    # Specific to this class
-    regionId: str = Field(default=str(uuid.uuid4()))
-    excitationEnergySource: str = "source1"
-    fixEnergy: float = 9.0
-    totalSteps: float = 13.0
-    totalTime: float = 13.0
-    exposureTime: float = 1.0
-    firstXChannel: int = 1
-    lastXChannel: int = 1000
-    firstYChannel: int = 101
-    lastYChannel: int = 800
-    detectorMode: DetectorMode = DetectorMode.ADC
-    status: Status = Status.READY
-
-
-class VGScientaExcitationEnergySource(BaseModel):
-    name: str = "source1"
-    scannableName: str = ""
-    value: float = 0
-
-
-class VGScientaSequence(BaseSequence):
-    elementSet: str = Field(default="Unknown")
-    excitationEnergySources: list[VGScientaExcitationEnergySource] = Field(
-        default_factory=lambda: []
-    )
-    regions: list[VGScientaRegion] = Field(default_factory=lambda: [])
-
-    def get_excitation_energy_source_by_region(
-        self, region: VGScientaRegion
-    ) -> VGScientaExcitationEnergySource | None:
-        filtered_excitation_energy_sources = [
-            e
-            for e in self.excitationEnergySources
-            if e.name == region.excitationEnergySource
-        ]
-        return (
-            filtered_excitation_energy_sources[0]
-            if len(filtered_excitation_energy_sources) == 1
-            else None
-        )

dodal/devices/util/motor_utils.py

@@ -1,6 +0,0 @@
-from ophyd import Component, EpicsMotor, EpicsSignalRO
-
-
-class ExtendedEpicsMotor(EpicsMotor):
-    motor_resolution: Component[EpicsSignalRO] = Component(EpicsSignalRO, ".MRES")
-    max_velocity: Component[EpicsSignalRO] = Component(EpicsSignalRO, ".VMAX")