dls-dodal 1.43.0__py3-none-any.whl → 1.45.0__py3-none-any.whl

dodal/devices/electron_analyser/abstract_analyser_io.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract_region import EnergyMode
+
+
+class AbstractAnalyserDriverIO(ABC, StandardReadable):
+    """
+    Generic device to configure electron analyser with new region settings.
+    Electron analysers should inherit from this class for further specialisation.
+    """
+
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
+            self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
+            self.slices = epics_signal_rw(int, prefix + "SLICES")
+            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.pass_energy = epics_signal_rw(
+                self.pass_energy_type, prefix + "PASS_ENERGY"
+            )
+            self.energy_step = epics_signal_rw(float, prefix + "STEP_SIZE")
+            self.iterations = epics_signal_rw(int, prefix + "NumExposures")
+            self.acquisition_mode = epics_signal_rw(str, prefix + "ACQ_MODE")
+
+        super().__init__(name)
+
+    def to_kinetic_energy(
+        self, value: float, excitation_energy: float, mode: EnergyMode
+    ) -> float:
+        return excitation_energy - value if mode == EnergyMode.BINDING else value
+
+    @property
+    @abstractmethod
+    def pass_energy_type(self) -> type:
+        """
+        Return the type the pass_energy should be. Each one is unfortunately different
+        for the underlying analyser software and cannot be changed on epics side.
+        """
+
+
+TAbstractAnalyserDriverIO = TypeVar(
+    "TAbstractAnalyserDriverIO", bound=AbstractAnalyserDriverIO
+)

dodal/devices/electron_analyser/abstract_region.py

@@ -0,0 +1,112 @@
+import re
+from abc import ABC
+from collections.abc import Callable
+from enum import Enum
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, Field, model_validator
+
+
+def java_to_python_case(java_str: str) -> str:
+    """
+    Convert a camelCase Java-style string to a snake_case Python-style string.
+
+    :param java_str: The Java-style camelCase string.
+    :return: The Python-style snake_case string.
+    """
+    new_value = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", java_str)
+    new_value = re.sub("([a-z0-9])([A-Z])", r"\1_\2", new_value).lower()
+    return new_value
+
+
+def switch_case_validation(data: dict, f: Callable[[str], str]) -> dict:
+    return {f(key): value for key, value in data.items()}
+
+
+class JavaToPythonModel(BaseModel):
+    @model_validator(mode="before")
+    @classmethod
+    def before_validation(cls, data: dict) -> dict:
+        data = switch_case_validation(data, java_to_python_case)
+        return data
+
+
+def energy_mode_validation(data: dict) -> dict:
+    # Convert binding_energy to energy_mode to make base region more generic
+    if "binding_energy" in data:
+        is_binding_energy = data["binding_energy"]
+        del data["binding_energy"]
+        data["energy_mode"] = (
+            EnergyMode.BINDING if is_binding_energy else EnergyMode.KINETIC
+        )
+    return data
+
+
+class EnergyMode(str, Enum):
+    KINETIC = "Kinetic"
+    BINDING = "Binding"
+
+
+class AbstractBaseRegion(ABC, JavaToPythonModel):
+    """
+    Generic region model that holds the data. Specialised region models should inherit
+    this to extend functionality. All energy units are assumed to be in eV.
+    """
+
+    name: str = "New_region"
+    enabled: bool = False
+    slices: int = 1
+    iterations: int = 1
+    # These ones we need subclasses to provide default values
+    lens_mode: str
+    pass_energy: int
+    acquisition_mode: str
+    low_energy: float
+    high_energy: float
+    step_time: float
+    energy_step: float  # in eV
+    energy_mode: EnergyMode = EnergyMode.KINETIC
+
+    def is_binding_energy(self) -> bool:
+        return self.energy_mode == EnergyMode.BINDING
+
+    def is_kinetic_energy(self) -> bool:
+        return self.energy_mode == EnergyMode.KINETIC
+
+    def to_kinetic_energy(self, value: float, excitation_energy: float) -> float:
+        return value if self.is_binding_energy() else excitation_energy - value
+
+    @model_validator(mode="before")
+    @classmethod
+    def before_validation(cls, data: dict) -> dict:
+        data = switch_case_validation(data, java_to_python_case)
+        return energy_mode_validation(data)
+
+
+TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
+
+
+class AbstractBaseSequence(ABC, JavaToPythonModel, Generic[TAbstractBaseRegion]):
+    """
+    Generic sequence model that holds the list of region data. Specialised sequence
+    models should inherit this to extend functionality and define type of region to
+    hold.
+    """
+
+    version: float = 0.1  # If file format changes within prod, increment this number!
+    regions: list[TAbstractBaseRegion] = Field(default_factory=lambda: [])
+
+    def get_enabled_regions(self) -> list[TAbstractBaseRegion]:
+        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()]
+
+    def get_region_by_name(self, name: str) -> TAbstractBaseRegion | None:
+        return next((region for region in self.regions if region.name == name), None)
+
+
+TAbstractBaseSequence = TypeVar("TAbstractBaseSequence", bound=AbstractBaseSequence)

dodal/devices/electron_analyser/specs_analyser_io.py

@@ -0,0 +1,19 @@
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+
+
+class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.psu_mode = epics_signal_rw(str, prefix + "SCAN_RANGE")
+            self.values = epics_signal_rw(int, prefix + "VALUES")
+            self.centre_energy = epics_signal_rw(float, prefix + "KINETIC_ENERGY")
+
+        super().__init__(prefix, name)
+
+    @property
+    def pass_energy_type(self) -> type:
+        return float

dodal/devices/electron_analyser/specs_region.py

@@ -0,0 +1,26 @@
+from pydantic import Field
+
+from dodal.devices.electron_analyser.abstract_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+)
+
+
+class SpecsRegion(AbstractBaseRegion):
+    # Override base class with defaults
+    lens_mode: str = "SmallArea"
+    pass_energy: int = 5
+    acquisition_mode: str = "Fixed Transmission"
+    low_energy: float = Field(default=800, alias="start_energy")
+    high_energy: float = Field(default=850, alias="end_energy")
+    step_time: float = Field(default=1.0, alias="exposure_time")
+    energy_step: float = Field(default=0.1, alias="step_energy")
+    # Specific to this class
+    values: int = 1
+    centre_energy: float = 0
+    psu_mode: str = "1.5keV"
+    estimated_time_in_ms: float = 0
+
+
+class SpecsSequence(AbstractBaseSequence[SpecsRegion]):
+    regions: list[SpecsRegion] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/vgscienta_analyser_io.py

@@ -0,0 +1,26 @@
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.electron_analyser.abstract_analyser_io import (
+    AbstractAnalyserDriverIO,
+)
+from dodal.devices.electron_analyser.vgscienta_region import (
+    DetectorMode,
+)
+
+
+class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO):
+    def __init__(self, prefix: str, name: str = "") -> None:
+        with self.add_children_as_readables():
+            self.centre_energy = epics_signal_rw(float, prefix + "CENTRE_ENERGY")
+            self.first_x_channel = epics_signal_rw(int, prefix + "MinX")
+            self.first_y_channel = epics_signal_rw(int, prefix + "MinY")
+            self.x_channel_size = epics_signal_rw(int, prefix + "SizeX")
+            self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
+            self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
+            self.image_mode = epics_signal_rw(str, prefix + "ImageMode")
+
+        super().__init__(prefix, name)
+
+    @property
+    def pass_energy_type(self) -> type:
+        return str

dodal/devices/electron_analyser/vgscienta_region.py

@@ -0,0 +1,90 @@
+import uuid
+from enum import Enum
+
+from ophyd_async.core import StrictEnum
+from pydantic import Field
+
+from dodal.devices.electron_analyser.abstract_region import (
+    AbstractBaseRegion,
+    AbstractBaseSequence,
+    JavaToPythonModel,
+)
+
+
+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(AbstractBaseRegion):
+    # Override defaults of base region class
+    lens_mode: str = "Angular45"
+    pass_energy: int = 5
+    acquisition_mode: str = AcquisitionMode.SWEPT
+    low_energy: float = 8.0
+    high_energy: float = 10.0
+    step_time: float = 1.0
+    energy_step: float = Field(default=200.0)
+    # Specific to this class
+    id: str = Field(default=str(uuid.uuid4()), alias="region_id")
+    excitation_energy_source: str = "source1"
+    fix_energy: float = 9.0
+    total_steps: float = 13.0
+    total_time: float = 13.0
+    exposure_time: float = 1.0
+    first_x_channel: int = 1
+    last_x_channel: int = 1000
+    first_y_channel: int = 101
+    last_y_channel: int = 800
+    detector_mode: DetectorMode = DetectorMode.ADC
+    status: Status = Status.READY
+
+    def x_channel_size(self) -> int:
+        return self.last_x_channel - self.first_x_channel + 1
+
+    def y_channel_size(self) -> int:
+        return self.last_y_channel - self.first_y_channel + 1
+
+
+class VGScientaExcitationEnergySource(JavaToPythonModel):
+    name: str = "source1"
+    device_name: str = Field(default="", alias="scannable_name")
+    value: float = 0
+
+
+class VGScientaSequence(AbstractBaseSequence[VGScientaRegion]):
+    element_set: str = Field(default="Unknown")
+    excitation_energy_sources: list[VGScientaExcitationEnergySource] = Field(
+        default_factory=lambda: []
+    )
+    regions: list[VGScientaRegion] = Field(default_factory=lambda: [])
+
+    def get_excitation_energy_source_by_region(
+        self, region: VGScientaRegion
+    ) -> VGScientaExcitationEnergySource:
+        value = next(
+            (
+                e
+                for e in self.excitation_energy_sources
+                if region.excitation_energy_source == e.name
+            ),
+            None,
+        )
+        if value is None:
+            raise ValueError(
+                f'Unable to find excitation energy source using region "{region.name}"'
+            )
+        return value

dodal/devices/fast_grid_scan.py

@@ -23,7 +23,7 @@ from ophyd_async.epics.core import (
 from pydantic import field_validator
 from pydantic.dataclasses import dataclass
 
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 from dodal.log import LOGGER
 from dodal.parameters.experiment_parameter_base import AbstractExperimentWithBeamParams
 
@@ -203,7 +203,7 @@ class FastGridScanCommon(StandardReadable, Flyable, ABC, Generic[ParamType]):
         self.stop_cmd = epics_signal_x(f"{prefix}STOP.PROC")
         self.status = epics_signal_r(int, f"{prefix}SCAN_STATUS")
 
-        self.expected_images = create_hardware_backed_soft_signal(
+        self.expected_images = create_r_hardware_backed_soft_signal(
             float, self._calculate_expected_images
         )
 

dodal/devices/i03/beamstop.py

@@ -5,7 +5,7 @@ from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
-from dodal.common.signal_utils import create_hardware_backed_soft_signal
+from dodal.common.signal_utils import create_r_hardware_backed_soft_signal
 
 
 class BeamstopPositions(StrictEnum):
@@ -53,7 +53,7 @@ class Beamstop(StandardReadable):
             self.x_mm = Motor(prefix + "X")
             self.y_mm = Motor(prefix + "Y")
             self.z_mm = Motor(prefix + "Z")
-            self.selected_pos = create_hardware_backed_soft_signal(
+            self.selected_pos = create_r_hardware_backed_soft_signal(
                 BeamstopPositions, self._get_selected_position
             )
 

dodal/devices/i10/diagnostics.py

@@ -0,0 +1,239 @@
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    Device,
+    StandardReadable,
+    StrictEnum,
+)
+from ophyd_async.core import StandardReadableFormat as Format
+from ophyd_async.core._device import DeviceConnector
+from ophyd_async.epics.adaravis import AravisDriverIO
+from ophyd_async.epics.adcore import SingleTriggerDetector
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+)
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.current_amplifiers import (
+    CurrentAmpDet,
+    Femto3xxGainTable,
+    Femto3xxGainToCurrentTable,
+    Femto3xxRaiseTime,
+    FemtoDDPCA,
+    StruckScaler,
+)
+
+
+class D3Position(StrictEnum):
+    NOTHING = "Nothing"
+    GRID = "Grid"
+
+
+class D5Position(StrictEnum):
+    CELL_IN = "Cell In"
+    CELL_OUT = "Cell Out"
+
+
+class D5APosition(StrictEnum):
+    OUT_OF_THE_BEAM = "Out of the beam"
+    DIODE = "Diode"
+    BLADE = "Blade"
+    LA = "La ref"
+    GD = "Gd ref"
+    YB = "Yb ref"
+    GRID = "Grid"
+
+
+class D6Position(StrictEnum):
+    DIODE_OUT = "Diode Out"
+    DIODE_IN = "Diode In"
+    AU_MESH = "Au Mesh"
+
+
+class D7Position(StrictEnum):
+    OUT = "Out"
+    SHUTTER = "Shutter"
+
+
+class InOutTable(StrictEnum):
+    MOVE_IN = "Move In"
+    MOVE_OUT = "Move Out"
+    RESET = "Reset"
+
+
+class InOutReadBackTable(StrictEnum):
+    MOVE_IN = "Moving In"
+    MOVE_OUT = "Moving Out"
+    IN_BEAM = "In Beam"
+    FAULT = "Fault"
+    OUT_OF_BEAM = "Out of Beam"
+
+
+class Positioner(StandardReadable, Movable):
+    """1D stage with a enum table to select positions."""
+
+    def __init__(
+        self,
+        prefix: str,
+        positioner_enum: type[StrictEnum],
+        positioner_suffix: str = "",
+        Positioner_pv_suffix: str = ":MP:SELECT",
+        name: str = "",
+    ) -> None:
+        self._stage_motion = Motor(prefix=prefix + positioner_suffix)
+        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
+            self.stage_position = epics_signal_rw(
+                positioner_enum,
+                read_pv=prefix + positioner_suffix + Positioner_pv_suffix,
+            )
+        super().__init__(name=name)
+        self.positioner_enum = positioner_enum
+
+    @AsyncStatus.wrap
+    async def set(self, value: StrictEnum) -> None:
+        if value in self.positioner_enum:
+            await self.stage_position.set(value=value)
+        else:
+            raise ValueError(
+                f"{value} is not an allow position. Position must be: {self.positioner_enum}"
+            )
+
+
+class I10PneumaticStage(StandardReadable):
+    """Pneumatic stage only has two real positions in or out.
+    Use for fluorescent screen which can be insert into the x-ray beam.
+    Most often use in conjunction with a webcam to locate the x-ray beam."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ) -> None:
+        with self.add_children_as_readables(Format.HINTED_SIGNAL):
+            self.stage_position_set = epics_signal_rw(
+                InOutTable,
+                read_pv=prefix + "CON",
+            )
+            self.stage_position_readback = epics_signal_r(
+                InOutReadBackTable,
+                read_pv=prefix + "STA",
+            )
+        super().__init__(name=name)
+
+
+class ScreenCam(Device):
+    """Compound device of pneumatic stage(fluorescent screen) and webcam"""
+
+    def __init__(
+        self,
+        prefix: str,
+        cam_infix="DCAM:",
+        name: str = "",
+    ) -> None:
+        self.screen_stage = I10PneumaticStage(
+            prefix=prefix,
+        )
+        cam_pv = prefix + cam_infix
+        self.centroid_x = epics_signal_r(float, read_pv=f"{cam_pv}STAT:CentroidX_RBV")
+        self.centroid_y = epics_signal_r(float, read_pv=f"{cam_pv}STAT:CentroidY_RBV")
+        self.single_trigger_centroid = SingleTriggerDetector(
+            drv=AravisDriverIO(prefix=cam_pv + "CAM:"),
+            read_uncached=[
+                self.centroid_x,
+                self.centroid_y,
+            ],
+        )
+        super().__init__(name=name)
+
+
+class FullDiagnostic(Device):
+    """Compound device of a diagnostic with screen, webcam and Positioner stage."""
+
+    def __init__(
+        self,
+        prefix: str,
+        positioner_enum: type[StrictEnum],
+        positioner_suffix: str = "",
+        Positioner_pv_suffix: str = ":MP:SELECT",
+        cam_infix: str = "DCAM:",
+        name: str = "",
+    ) -> None:
+        self.positioner = Positioner(
+            prefix=prefix,
+            positioner_enum=positioner_enum,
+            positioner_suffix=positioner_suffix,
+            Positioner_pv_suffix=Positioner_pv_suffix,
+        )
+        self.screen = ScreenCam(
+            prefix,
+            cam_infix,
+            name,
+        )
+        super().__init__(name)
+
+
+class I10Diagnostic(Device):
+    """Collection of all the diagnostic stage on i10."""
+
+    def __init__(self, prefix, name: str = "") -> None:
+        self.d1 = ScreenCam(prefix=prefix + "PHDGN-01:")
+        self.d2 = ScreenCam(prefix=prefix + "PHDGN-02:")
+        self.d3 = FullDiagnostic(
+            prefix=prefix + "PHDGN-03:",
+            positioner_enum=D3Position,
+            positioner_suffix="DET:X",
+        )
+        self.d4 = ScreenCam(prefix=prefix + "PHDGN-04:")
+        self.d5 = Positioner(
+            prefix=prefix + "IONC-01:",
+            positioner_enum=D5Position,
+            positioner_suffix="Y",
+        )
+
+        self.d5A = Positioner(
+            prefix=prefix + "PHDGN-06:",
+            positioner_enum=D5APosition,
+            positioner_suffix="DET:X",
+        )
+
+        self.d6 = FullDiagnostic(
+            prefix=prefix + "PHDGN-05:",
+            positioner_enum=D6Position,
+            positioner_suffix="DET:X",
+        )
+        self.d7 = Positioner(
+            prefix=prefix + "PHDGN-07:",
+            positioner_enum=D7Position,
+            positioner_suffix="Y",
+        )
+        super().__init__(name)
+
+
+class I10Diagnostic5ADet(Device):
+    """Diagnostic 5a detection with drain current and photo diode"""
+
+    def __init__(
+        self, prefix: str, name: str = "", connector: DeviceConnector | None = None
+    ) -> None:
+        self.drain_current = CurrentAmpDet(
+            current_amp=FemtoDDPCA(
+                prefix=prefix + "IAMP-06:",
+                suffix="GAIN",
+                gain_table=Femto3xxGainTable,
+                gain_to_current_table=Femto3xxGainToCurrentTable,
+                raise_timetable=Femto3xxRaiseTime,
+            ),
+            counter=StruckScaler(prefix=prefix + "SCLR-02:SCALER2", suffix=".S17"),
+        )
+        self.diode = CurrentAmpDet(
+            FemtoDDPCA(
+                prefix=prefix + "IAMP-05:",
+                suffix="GAIN",
+                gain_table=Femto3xxGainTable,
+                gain_to_current_table=Femto3xxGainToCurrentTable,
+                raise_timetable=Femto3xxRaiseTime,
+            ),
+            counter=StruckScaler(prefix=prefix + "SCLR-02:SCALER2", suffix=".S18"),
+        )
+        super().__init__(name, connector)