dls-dodal 1.55.0__py3-none-any.whl → 1.56.0__py3-none-any.whl

dodal/devices/electron_analyser/util.py

@@ -4,10 +4,30 @@ from dodal.devices.electron_analyser.enums import EnergyMode
 def to_kinetic_energy(
     value: float, value_mode: EnergyMode, excitation_energy: float
 ) -> float:
+    """
+    Convert a value that is binding energy to kinetic energy.
+    Parameters:
+        value: The value to convert.
+        value_mode: Energy mode of the value. If it is already kinetic, return the
+                    same value. If it is binding, convert to kinetic.
+        excitation_energy: Value to calculate the conversion.
+    Returns:
+        Caluclated kinetic energy value
+    """
     return value if value_mode == EnergyMode.KINETIC else excitation_energy - value
 
 
 def to_binding_energy(
     value: float, value_mode: EnergyMode, excitation_energy: float
 ) -> float:
+    """
+    Convert a value that is kinetic energy to binding energy.
+    Parameters:
+        value: The value to convert.
+        value_mode: Energy mode of the value. If it is already binding, return the
+                    same value. If it is kinetic, convert to binding.
+        excitation_energy: Value to calculate the conversion.
+    Returns:
+        Caluclated binding energy value
+    """
     return value if value_mode == EnergyMode.BINDING else excitation_energy - value

dodal/devices/electron_analyser/vgscienta/__init__.py

@@ -1,13 +1,13 @@
 from .detector import VGScientaDetector
 from .driver_io import VGScientaAnalyserDriverIO
-from .enums import AcquisitionMode
-from .region import VGScientaExcitationEnergySource, VGScientaRegion, VGScientaSequence
+from .enums import AcquisitionMode, DetectorMode
+from .region import VGScientaRegion, VGScientaSequence
 
 __all__ = [
     "VGScientaDetector",
     "VGScientaAnalyserDriverIO",
     "AcquisitionMode",
-    "VGScientaExcitationEnergySource",
+    "DetectorMode",
     "VGScientaRegion",
     "VGScientaSequence",
 ]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -11,6 +11,7 @@ from dodal.devices.electron_analyser.abstract.types import (
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
+from dodal.devices.electron_analyser.enums import SelectedSource
 from dodal.devices.electron_analyser.vgscienta.driver_io import (
     VGScientaAnalyserDriverIO,
 )
@@ -34,7 +35,7 @@ class VGScientaDetector(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_sources: Mapping[str, SignalR[float]],
+        energy_sources: Mapping[SelectedSource, SignalR[float]],
         name: str = "",
     ):
         driver = VGScientaAnalyserDriverIO[TLensMode, TPsuMode, TPassEnergyEnum](

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -9,7 +9,6 @@ from ophyd_async.core import (
     SignalR,
     StandardReadableFormat,
 )
-from ophyd_async.epics.adcore import ADImageMode
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
@@ -20,7 +19,7 @@ from dodal.devices.electron_analyser.abstract.types import (
     TPassEnergyEnum,
     TPsuMode,
 )
-from dodal.devices.electron_analyser.util import to_kinetic_energy
+from dodal.devices.electron_analyser.enums import EnergyMode, SelectedSource
 from dodal.devices.electron_analyser.vgscienta.enums import (
     AcquisitionMode,
     DetectorMode,
@@ -46,7 +45,7 @@ class VGScientaAnalyserDriverIO(
         lens_mode_type: type[TLensMode],
         psu_mode_type: type[TPsuMode],
         pass_energy_type: type[TPassEnergyEnum],
-        energy_sources: Mapping[str, SignalR[float]],
+        energy_sources: Mapping[SelectedSource, SignalR[float]],
         name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
@@ -55,11 +54,11 @@ class VGScientaAnalyserDriverIO(
 
             self.region_min_x = epics_signal_rw(int, prefix + "MinX")
             self.region_size_x = epics_signal_rw(int, prefix + "SizeX")
-            self.sensor_max_size_x = epics_signal_rw(int, prefix + "MaxSizeX")
+            self.sensor_max_size_x = epics_signal_r(int, prefix + "MaxSizeX_RBV")
 
             self.region_min_y = epics_signal_rw(int, prefix + "MinY")
             self.region_size_y = epics_signal_rw(int, prefix + "SizeY")
-            self.sensor_max_size_y = epics_signal_rw(int, prefix + "MaxSizeY")
+            self.sensor_max_size_y = epics_signal_r(int, prefix + "MaxSizeY_RBV")
 
         super().__init__(
             prefix,
@@ -75,36 +74,29 @@ class VGScientaAnalyserDriverIO(
     async def set(self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]):
         source = self._get_energy_source(region.excitation_energy_source)
         excitation_energy = await source.get_value()  # eV
-
-        low_energy = to_kinetic_energy(
-            region.low_energy, region.energy_mode, excitation_energy
-        )
-        centre_energy = to_kinetic_energy(
-            region.centre_energy, region.energy_mode, excitation_energy
-        )
-        high_energy = to_kinetic_energy(
-            region.high_energy, region.energy_mode, excitation_energy
-        )
+        # Copy region so doesn't alter the actual region and switch to kinetic energy
+        ke_region = region.model_copy()
+        ke_region.switch_energy_mode(EnergyMode.KINETIC, excitation_energy)
         await asyncio.gather(
-            self.region_name.set(region.name),
-            self.energy_mode.set(region.energy_mode),
-            self.low_energy.set(low_energy),
-            self.centre_energy.set(centre_energy),
-            self.high_energy.set(high_energy),
-            self.slices.set(region.slices),
-            self.lens_mode.set(region.lens_mode),
-            self.pass_energy.set(region.pass_energy),
-            self.iterations.set(region.iterations),
-            self.acquisition_mode.set(region.acquisition_mode),
+            self.region_name.set(ke_region.name),
+            self.energy_mode.set(ke_region.energy_mode),
+            self.low_energy.set(ke_region.low_energy),
+            self.centre_energy.set(ke_region.centre_energy),
+            self.high_energy.set(ke_region.high_energy),
+            self.slices.set(ke_region.slices),
+            self.lens_mode.set(ke_region.lens_mode),
+            self.pass_energy.set(ke_region.pass_energy),
+            self.iterations.set(ke_region.iterations),
+            self.acquire_time.set(ke_region.acquire_time),
+            self.acquisition_mode.set(ke_region.acquisition_mode),
             self.excitation_energy.set(excitation_energy),
             self.excitation_energy_source.set(source.name),
-            self.energy_step.set(region.energy_step),
-            self.image_mode.set(ADImageMode.SINGLE),
-            self.detector_mode.set(region.detector_mode),
-            self.region_min_x.set(region.min_x),
-            self.region_size_x.set(region.size_x),
-            self.region_min_y.set(region.min_y),
-            self.region_size_y.set(region.size_y),
+            self.energy_step.set(ke_region.energy_step),
+            self.detector_mode.set(ke_region.detector_mode),
+            self.region_min_x.set(ke_region.min_x),
+            self.region_size_x.set(ke_region.size_x),
+            self.region_min_y.set(ke_region.min_y),
+            self.region_size_y.set(ke_region.size_y),
         )
 
     def _create_energy_axis_signal(self, prefix: str) -> SignalR[Array1D[np.float64]]:

dodal/devices/electron_analyser/vgscienta/enums.py

@@ -1,14 +1,6 @@
 from ophyd_async.core import StrictEnum
 
 
-class Status(StrictEnum):
-    READY = "Ready"
-    RUNNING = "Running"
-    COMPLETED = "Completed"
-    INVALID = "Invalid"
-    ABORTED = "Aborted"
-
-
 class DetectorMode(StrictEnum):
     ADC = "ADC"
     PULSE_COUNTING = "Pulse Counting"

dodal/devices/electron_analyser/vgscienta/region.py

@@ -6,7 +6,6 @@ from pydantic import Field, field_validator
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
-    JavaToPythonModel,
 )
 from dodal.devices.electron_analyser.abstract.types import (
     TLensMode,
@@ -16,7 +15,6 @@ from dodal.devices.electron_analyser.abstract.types import (
 from dodal.devices.electron_analyser.vgscienta.enums import (
     AcquisitionMode,
     DetectorMode,
-    Status,
 )
 
 
@@ -29,10 +27,10 @@ class VGScientaRegion(
     pass_energy: TPassEnergyEnum
     acquisition_mode: AcquisitionMode = AcquisitionMode.SWEPT
     low_energy: float = 8.0
+    centre_energy: float = Field(alias="fix_energy", default=9)
     high_energy: float = 10.0
-    step_time: float = 1.0
+    acquire_time: float = Field(default=1.0, alias="step_time")
     energy_step: float = Field(default=200.0)
-    centre_energy: float = Field(alias="fix_energy", default=9)
     # Specific to this class
     id: str = Field(default=str(uuid.uuid4()), alias="region_id")
     total_steps: float = 13.0
@@ -42,7 +40,6 @@ class VGScientaRegion(
     min_y: int = Field(alias="first_y_channel", default=101)
     sensor_max_size_y: int = Field(alias="last_y_channel", default=800)
     detector_mode: DetectorMode = DetectorMode.ADC
-    status: Status = Status.READY
 
     @property
     def size_x(self) -> int:
@@ -60,37 +57,11 @@ class VGScientaRegion(
         return str(val)
 
 
-class VGScientaExcitationEnergySource(JavaToPythonModel):
-    name: str = "source1"
-    device_name: str = Field(default="", alias="scannable_name")
-    value: float = 0
-
-
 class VGScientaSequence(
     AbstractBaseSequence[VGScientaRegion[TLensMode, TPassEnergyEnum]],
     Generic[TLensMode, TPsuMode, TPassEnergyEnum],
 ):
     psu_mode: TPsuMode = Field(alias="element_set")
-    excitation_energy_sources: list[VGScientaExcitationEnergySource] = Field(
-        default_factory=lambda: []
-    )
     regions: list[VGScientaRegion[TLensMode, TPassEnergyEnum]] = Field(
         default_factory=lambda: []
     )
-
-    def get_excitation_energy_source_by_region(
-        self, region: VGScientaRegion[TLensMode, TPassEnergyEnum]
-    ) -> 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/eurotherm.py

@@ -0,0 +1,126 @@
+from typing import Generic, TypeVar
+
+from bluesky.protocols import Locatable, Location
+from ophyd_async.core import (
+    AsyncStatus,
+    OnOff,
+    StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_rw_rbv
+
+"""
+Note: See i11 cyberstar blower for implementation of Eurotherm Controller
+"""
+
+
+class AutoManual(StrictEnum):
+    AUTO = "Automatic"
+    MANUAL = "Manual"
+
+
+class EurothermUpdate(StrictEnum):
+    PASSIVE = "Passive"
+    EVENT = "Event"
+    IO = "I/O Intr"
+    S10 = "10 second"
+    S5 = "5 second"
+    S2 = "2 second"
+    S1 = "1 second"
+    S0_5 = ".5 second"
+    S0_2 = ".2 second"
+    S0_1 = ".1 second"
+
+
+_EUROTHERM_RBV: str = ":RBV"
+
+
+class EurothermPID(StandardReadable):
+    """The class for the Eurotherm PID values"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.P = epics_signal_rw_rbv(float, f"{prefix}P", _EUROTHERM_RBV)
+            self.I = epics_signal_rw_rbv(float, f"{prefix}I", _EUROTHERM_RBV)
+            self.D = epics_signal_rw_rbv(float, f"{prefix}D", _EUROTHERM_RBV)
+
+        super().__init__(name)
+
+
+class UpdatingEurothermPID(EurothermPID):
+    """A Eurotherm PID controller that updates the PID values."""
+
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.update = epics_signal_rw(EurothermUpdate, f"{prefix}UPDATE.SCAN")
+
+        super().__init__(prefix=prefix, name=name)
+
+
+P = TypeVar("P", bound=EurothermPID)
+
+
+class EurothermGeneral(StandardReadable, Locatable[float], Generic[P]):
+    """A base class for any eurotherm controller."""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        pid_class: type[P] = EurothermPID,
+        temp_suffix: str = "PV:RBV",
+    ):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.temp = epics_signal_r(float, f"{prefix}{temp_suffix}")
+
+        with self.add_children_as_readables():
+            self.setpoint = epics_signal_rw_rbv(float, f"{prefix}SP", _EUROTHERM_RBV)
+            self.ramprate = epics_signal_rw_rbv(float, f"{prefix}RR", _EUROTHERM_RBV)
+            self.output = epics_signal_rw_rbv(float, f"{prefix}O", _EUROTHERM_RBV)
+            self.mode = epics_signal_rw_rbv(AutoManual, f"{prefix}MAN", _EUROTHERM_RBV)
+
+        self.tune = pid_class(prefix=prefix)
+
+        super().__init__(name)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
+        """Set the blower to a specific temperature."""
+        await self.setpoint.set(value, wait=True)
+
+    async def locate(self) -> Location[float]:
+        setpoint = await self.setpoint.get_value()
+        current_temp = await self.temp.get_value()
+        location = Location(setpoint=setpoint, readback=current_temp)
+        return location
+
+
+class UpdatingEurothermGeneral(EurothermGeneral):
+    """A Eurotherm controller that updates the setpoint and readback."""
+
+    def __init__(self, prefix: str, name: str = ""):
+        self.update = epics_signal_rw(EurothermUpdate, f"{prefix}UPDATE.SCAN")
+
+        super().__init__(prefix=prefix, name=name, pid_class=UpdatingEurothermPID)
+
+
+class EurothermAutotune(StandardReadable):
+    """Newer versions of Eurotherm controllers have the ability to Autotune the
+    PID values, and this is the device"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.control = epics_signal_rw(OnOff, f"{prefix}AUTOTUNE")
+            self.high_limit = epics_signal_rw(float, f"{prefix}OUTPHI")
+            self.low_limit = epics_signal_rw(float, f"{prefix}OUTPLO")
+
+        super().__init__(name)

dodal/devices/fluorescence_detector_motion.py

@@ -1,16 +1,9 @@
-from ophyd_async.core import StandardReadable, StrictEnum
-from ophyd_async.epics.core import epics_signal_r
-
-
-class FluorescenceDetectorControlState(StrictEnum):
-    OUT = "Out"
-    IN = "In"
+from ophyd_async.core import InOut, StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
 
 
 class FluorescenceDetector(StandardReadable):
     def __init__(self, prefix: str, name: str = ""):
         with self.add_children_as_readables():
-            self.pos = epics_signal_r(
-                FluorescenceDetectorControlState, prefix + "-EA-FLU-01:CTRL"
-            )
+            self.pos = epics_signal_rw(InOut, f"{prefix}CTRL")
         super().__init__(name)

dodal/devices/focusing_mirror.py

@@ -56,7 +56,7 @@ class SingleMirrorVoltage(Device):
     the demanded voltage setpoint is accepted, without blocking the caller as this process can take significant time.
     """
 
-    def __init__(self, name: str = "", prefix: str = ""):
+    def __init__(self, prefix: str, name: str = ""):
         self._actual_v = epics_signal_r(int, prefix + "R")
         self._setpoint_v = epics_signal_rw(int, prefix + "D")
         self._demand_accepted = epics_signal_r(MirrorVoltageDemand, prefix + "DSEV")

dodal/devices/i03/undulator_dcm.py

@@ -34,7 +34,6 @@ class UndulatorDCM(StandardReadable, Movable[float]):
         undulator: Undulator,
         dcm: DCM,
         daq_configuration_path: str,
-        prefix: str = "",
         name: str = "",
     ):
         self.undulator_ref = Reference(undulator)

dodal/devices/i09/enums.py

@@ -21,11 +21,11 @@ class PsuMode(StrictEnum):
 
 
 class PassEnergy(StrictEnum):
-    E5 = 5
-    E10 = 10
-    E20 = 20
-    E50 = 50
-    E70 = 70
-    E100 = 100
-    E200 = 200
-    E500 = 500
+    E5 = "5"
+    E10 = "10"
+    E20 = "20"
+    E50 = "50"
+    E70 = "70"
+    E100 = "100"
+    E200 = "200"
+    E500 = "500"

dodal/devices/i10/diagnostics.py

@@ -54,13 +54,13 @@ class D7Position(StrictEnum):
     SHUTTER = "Shutter"
 
 
-class InOutTable(StrictEnum):
+class InStateTable(StrictEnum):
     MOVE_IN = "Move In"
     MOVE_OUT = "Move Out"
     RESET = "Reset"
 
 
-class InOutReadBackTable(StrictEnum):
+class InStateReadBackTable(StrictEnum):
     MOVE_IN = "Moving In"
     MOVE_OUT = "Moving Out"
     IN_BEAM = "In Beam"
@@ -80,11 +80,11 @@ class I10PneumaticStage(StandardReadable):
     ) -> None:
         with self.add_children_as_readables(Format.HINTED_SIGNAL):
             self.stage_position_set = epics_signal_rw(
-                InOutTable,
+                InStateTable,
                 read_pv=prefix + "CON",
             )
             self.stage_position_readback = epics_signal_r(
-                InOutReadBackTable,
+                InStateReadBackTable,
                 read_pv=prefix + "STA",
             )
         super().__init__(name=name)

dodal/devices/i10/i10_apple2.py

@@ -69,7 +69,7 @@ class I10Apple2(Apple2):
         self,
         look_up_table_dir: str,
         source: tuple[str, str],
-        prefix: str = "",
+        prefix: str,
         mode: str = "Mode",
         min_energy: str = "MinEnergy",
         max_energy: str = "MaxEnergy",
@@ -97,11 +97,9 @@ class I10Apple2(Apple2):
             Name of the device
         """
 
-        energy_gap_table_path = Path(
-            look_up_table_dir + "IDEnergy2GapCalibrations.csv",
-        )
+        energy_gap_table_path = Path(look_up_table_dir, "IDEnergy2GapCalibrations.csv")
         energy_phase_table_path = Path(
-            look_up_table_dir + "IDEnergy2PhaseCalibrations.csv",
+            look_up_table_dir, "IDEnergy2PhaseCalibrations.csv"
         )
         # A dataclass contains the path to the look up table and the expected column names.
         self.lookup_table_config = LookupTableConfig(
@@ -124,7 +122,6 @@ class I10Apple2(Apple2):
                     btm_inner="RPQ3",
                     btm_outer="RPQ4",
                 ),
-                prefix=prefix,
                 name=name,
             )
             self.id_jaw_phase = UndulatorJawPhase(

dodal/devices/i11/cyberstar_blower.py

@@ -0,0 +1,34 @@
+from typing import Generic, TypeVar
+
+from ophyd_async.core import EnabledDisabled, StandardReadable
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.eurotherm import EurothermAutotune, EurothermGeneral
+
+EU = TypeVar("EU", bound=EurothermGeneral)
+
+
+class CyberstarBlower(StandardReadable, Generic[EU]):
+    """This is a specific device that uses a Eurotherm controller"""
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        controller_type: type[EU] = EurothermGeneral,
+    ):
+        self.enable = epics_signal_rw(EnabledDisabled, f"{prefix}DISABLE")
+        self.controller = controller_type(prefix, name)
+
+        super().__init__(name=name)
+
+
+class AutotunedCyberstarBlower(Generic[EU], CyberstarBlower[EU]):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        controller_type: type[EU] = EurothermGeneral,
+    ):
+        self.autotune = EurothermAutotune(prefix)
+        super().__init__(prefix, name=name, controller_type=controller_type)

dodal/devices/i11/diff_stages.py

@@ -0,0 +1,55 @@
+from ophyd_async.epics.motor import Motor
+
+from dodal.devices.motors import Stage
+
+
+class DiffractometerStage(Stage):
+    """
+    This is the diffractometer stage which contains both detectors,
+    it allows for rotations and also sample position. Contains:
+    theta, delta, two_theta, sample_position
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        theta_suffix: str = "THETA",
+        delta_suffix: str = "DELTA",
+        two_theta_suffix: str = "2THETA",
+        sample_pos_suffix: str = "SPOS",
+    ):
+        with self.add_children_as_readables():
+            self.theta = Motor(prefix + theta_suffix)
+            self.delta = Motor(prefix + delta_suffix)
+            self.two_theta = Motor(prefix + two_theta_suffix)
+            self.sample_position = Motor(prefix + sample_pos_suffix)
+
+        super().__init__(name=name)
+
+
+class DiffractometerBase(Stage):
+    """
+    This is the diffractometer stage which contains both detectors,
+    it allows for translation about x and y and also sample position. Contains:
+    x1, x2, y1, y2, y3. Used for aligning the detector to the beam/sample
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x1_suffix: str = "X1",
+        x2_suffix: str = "X2",
+        y1_suffix: str = "Y1",
+        y2_suffix: str = "Y2",
+        y3_suffix: str = "Y3",
+    ):
+        with self.add_children_as_readables():
+            self.x1 = Motor(prefix + x1_suffix)
+            self.x2 = Motor(prefix + x2_suffix)
+            self.y1 = Motor(prefix + y1_suffix)
+            self.y2 = Motor(prefix + y2_suffix)
+            self.y3 = Motor(prefix + y3_suffix)
+
+        super().__init__(name=name)