dls-dodal 1.33.0__py3-none-any.whl → 1.35.0__py3-none-any.whl

dodal/devices/hutch_shutter.py

@@ -1,13 +1,12 @@
-from enum import Enum
-
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     StandardReadable,
+    StrictEnum,
     wait_for_value,
 )
-from ophyd_async.epics.signal import epics_signal_r, epics_signal_w
+from ophyd_async.epics.core import epics_signal_r, epics_signal_w
 
 HUTCH_SAFE_FOR_OPERATIONS = 0  # Hutch is locked and can't be entered
 
@@ -16,13 +15,13 @@ class ShutterNotSafeToOperateError(Exception):
     pass
 
 
-class ShutterDemand(str, Enum):
+class ShutterDemand(StrictEnum):
     OPEN = "Open"
     CLOSE = "Close"
     RESET = "Reset"
 
 
-class ShutterState(str, Enum):
+class ShutterState(StrictEnum):
     FAULT = "Fault"
     OPEN = "Open"
     OPENING = "Opening"

dodal/devices/i10/i10_apple2.py

@@ -0,0 +1,399 @@
+import asyncio
+import csv
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, SupportsFloat
+
+import numpy as np
+from bluesky.protocols import Movable
+from ophyd_async.core import (
+    AsyncStatus,
+    Reference,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_r_and_setter,
+    soft_signal_rw,
+)
+
+from dodal.devices.apple2_undulator import (
+    Apple2,
+    Apple2Val,
+    Lookuptable,
+    UndulatorGap,
+    UndulatorJawPhase,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.pgm import PGM
+from dodal.log import LOGGER
+
+ROW_PHASE_MOTOR_TOLERANCE = 0.004
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+MAXIMUM_GAP_MOTOR_POSITION = 100
+DEFAULT_JAW_PHASE_POLY_PARAMS = [1.0 / 7.5, -120.0 / 7.5]
+ALPHA_OFFSET = 180
+
+
+# data class to store the lookup table configuration that is use in convert_csv_to_lookup
+@dataclass
+class LookupPath:
+    Gap: Path
+    Phase: Path
+
+
+@dataclass
+class LookupTableConfig:
+    path: LookupPath
+    source: tuple[str, str]
+    mode: str | None
+    min_energy: str | None
+    max_energy: str | None
+    poly_deg: list | None
+
+
+class I10Apple2(Apple2):
+    """
+    I10Apple2 is the i10 version of Apple2 ID.
+    The set and update_lookuptable should be the only part that is I10 specific.
+
+    A pair of look up tables are needed to provide the conversion
+     between motor position and energy.
+    Set is in energy(eV).
+    """
+
+    def __init__(
+        self,
+        id_gap: UndulatorGap,
+        id_phase: UndulatorPhaseAxes,
+        id_jaw_phase: UndulatorJawPhase,
+        energy_gap_table_path: Path,
+        energy_phase_table_path: Path,
+        source: tuple[str, str],
+        prefix: str = "",
+        mode: str = "Mode",
+        min_energy: str = "MinEnergy",
+        max_energy: str = "MaxEnergy",
+        poly_deg: list | None = None,
+        name: str = "",
+    ) -> None:
+        """
+        Parameters
+        ----------
+        id_gap:
+            An UndulatorGap device.
+        id_phase:
+            An UndulatorPhaseAxes device.
+        energy_gap_table_path:
+            The path to id gap look up table.
+        energy_phase_table_path:
+            The path to id phase look up table.
+        source:
+            The column name and the name of the source in look up table. e.g. ("source", "idu")
+        mode:
+            The column name of the mode in look up table.
+        min_energy:
+            The column name that contain the maximum energy in look up table.
+        max_energy:
+            The column name that contain the maximum energy in look up table.
+        poly_deg:
+            The column names for the parameters for the energy conversion polynomial, starting with the least significant.
+        prefix:
+            Not in use but needed for device_instantiation.
+        Name:
+            Name of the device
+        """
+
+        # A dataclass contains the path to the look up table and the expected column names.
+        self.lookup_table_config = LookupTableConfig(
+            path=LookupPath(Gap=energy_gap_table_path, Phase=energy_phase_table_path),
+            source=source,
+            mode=mode,
+            min_energy=min_energy,
+            max_energy=max_energy,
+            poly_deg=poly_deg,
+        )
+
+        super().__init__(
+            id_gap=id_gap,
+            id_phase=id_phase,
+            prefix=prefix,
+            name=name,
+        )
+        with self.add_children_as_readables():
+            self.id_jaw_phase = Reference(id_jaw_phase)
+
+    @AsyncStatus.wrap
+    async def set(self, value: SupportsFloat) -> None:
+        """
+        Check polarisation state and use it together with the energy(value)
+        to calculate the required gap and phases before setting it.
+        """
+        value = float(value)
+        if self.pol is None:
+            LOGGER.warning("Polarisation not set attempting to read from hardware")
+            pol, phase = await self.determinePhaseFromHardware()
+            if pol is None:
+                raise ValueError(f"Pol is not set for {self.name}")
+            self.pol = pol
+
+        self._polarisation_set(self.pol)
+        gap, phase = self._get_id_gap_phase(value)
+        phase3 = phase * (-1 if self.pol == "la" else (1))
+        id_set_val = Apple2Val(
+            top_outer=str(phase),
+            top_inner="0.0",
+            btm_inner=str(phase3),
+            btm_outer="0.0",
+            gap=str(gap),
+        )
+        LOGGER.info(f"Setting polarisation to {self.pol}, with {id_set_val}")
+        await self._set(value=id_set_val, energy=value)
+        if self.pol != "la":
+            await self.id_jaw_phase().set(0)
+            await self.id_jaw_phase().set_move.set(1)
+
+    def update_lookuptable(self):
+        """
+        Update the stored lookup tabled from file.
+
+        """
+        LOGGER.info("Updating lookup dictionary from file.")
+        for key, path in self.lookup_table_config.path.__dict__.items():
+            if path.exists():
+                self.lookup_tables[key] = convert_csv_to_lookup(
+                    file=path,
+                    source=self.lookup_table_config.source,
+                    mode=self.lookup_table_config.mode,
+                    min_energy=self.lookup_table_config.min_energy,
+                    max_energy=self.lookup_table_config.max_energy,
+                    poly_deg=self.lookup_table_config.poly_deg,
+                )
+                # ensure the importing lookup table is the correct format
+                Lookuptable.model_validate(self.lookup_tables[key])
+            else:
+                raise FileNotFoundError(f"{key} look up table is not in path: {path}")
+
+        self._available_pol = list(self.lookup_tables["Gap"].keys())
+
+
+class I10Apple2PGM(StandardReadable, Movable):
+    """
+    Compound device to set both ID and PGM energy at the sample time,poly_deg
+
+    """
+
+    def __init__(
+        self, id: I10Apple2, pgm: PGM, prefix: str = "", name: str = ""
+    ) -> None:
+        """
+        Parameters
+        ----------
+        id:
+            An Apple2 device.
+        pgm:
+            A PGM/mono device.
+        prefix:
+            Not in use but needed for device_instantiation.
+        name:
+            New device name.
+        """
+        super().__init__(name=name)
+        self.id_ref = Reference(id)
+        self.pgm_ref = Reference(pgm)
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.energy_offset = soft_signal_rw(float, initial_value=0)
+
+    @AsyncStatus.wrap
+    async def set(self, value: float) -> None:
+        LOGGER.info(f"Moving f{self.name} energy to {value}.")
+        await asyncio.gather(
+            self.id_ref().set(value=value + await self.energy_offset.get_value()),
+            self.pgm_ref().energy.set(value),
+        )
+
+
+class I10Apple2Pol(StandardReadable, Movable):
+    """
+    Compound device to set polorisation of ID.
+    """
+
+    def __init__(self, id: I10Apple2, prefix: str = "", name: str = "") -> None:
+        """
+        Parameters
+        ----------
+        id:
+            An I10Apple2 device.
+        prefix:
+            Not in use but needed for device_instantiation.
+        name:
+            New device name.
+        """
+        super().__init__(name=name)
+        with self.add_children_as_readables():
+            self.id = id
+
+    @AsyncStatus.wrap
+    async def set(self, value: str) -> None:
+        self.id.pol = value  # change polarisation.
+        LOGGER.info(f"Changing f{self.name} polarisation to {value}.")
+        await self.id.set(
+            await self.id.energy.get_value()
+        )  # Move id to new polarisation
+
+
+class LinearArbitraryAngle(StandardReadable, Movable):
+    """
+    Device to set polorisation angle of the ID. Linear Arbitrary Angle (laa)
+     is the direction of the magnetic field which can be change by varying the jaw_phase
+     in (linear arbitrary (la) mode,
+     The angle of 0 is equivalent to linear horizontal "lh" (sigma) and
+      90 is linear vertical "lv" (pi).
+    This device require a jaw_phase to angle conversion which is done via a polynomial.
+    """
+
+    def __init__(
+        self,
+        id: I10Apple2,
+        prefix: str = "",
+        name: str = "",
+        jaw_phase_limit: float = 12.0,
+        jaw_phase_poly_param: list[float] = DEFAULT_JAW_PHASE_POLY_PARAMS,
+        angle_threshold_deg=30.0,
+    ) -> None:
+        """
+        Parameters
+        ----------
+        id: I10Apple2
+            An I10Apple2 device.
+        prefix: str
+            Not in use but needed for device_instantiation.
+        name: str
+            New device name.
+        jaw_phase_limit: float
+            The maximum allowed jaw_phase movement.
+        jaw_phase_poly_param: list
+            polynomial parameters highest power first.
+        """
+        super().__init__(name=name)
+        self.id_ref = Reference(id)
+        self.jaw_phase_from_angle = np.poly1d(jaw_phase_poly_param)
+        self.angle_threshold_deg = angle_threshold_deg
+        self.jaw_phase_limit = jaw_phase_limit
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.angle, self._angle_set = soft_signal_r_and_setter(
+                float, initial_value=None
+            )
+
+    @AsyncStatus.wrap
+    async def set(self, value: SupportsFloat) -> None:
+        value = float(value)
+        pol = self.id_ref().pol
+        if pol != "la":
+            raise RuntimeError(
+                f"Angle control is not available in polarisation {pol} with {self.id_ref().name}"
+            )
+        # Moving to real angle which is 210 to 30.
+        alpha_real = value if value > self.angle_threshold_deg else value + ALPHA_OFFSET
+        jaw_phase = self.jaw_phase_from_angle(alpha_real)
+        if abs(jaw_phase) > self.jaw_phase_limit:
+            raise RuntimeError(
+                f"jaw_phase position for angle ({value}) is outside permitted range"
+                f" [-{self.jaw_phase_limit}, {self.jaw_phase_limit}]"
+            )
+        await self.id_ref().id_jaw_phase().set(jaw_phase)
+        self._angle_set(value)
+
+
+def convert_csv_to_lookup(
+    file: str,
+    source: tuple[str, str],
+    mode: str | None = "Mode",
+    min_energy: str | None = "MinEnergy",
+    max_energy: str | None = "MaxEnergy",
+    poly_deg: list | None = None,
+) -> dict[str | None, dict[str, dict[str, dict[str, Any]]]]:
+    """
+    Convert csv to a dictionary that can be read by Apple2 ID device.
+
+    Parameters
+    -----------
+    file: str
+        File path.
+    source: tuple[str, str]
+        Tuple(column name, source name)
+        e.g. ("Source", "idu").
+    mode: str = "Mode"
+        Column name for the available modes, "lv","lh","pc","nc" etc
+    min_energy: str = "MinEnergy":
+        Column name for min energy for the polynomial.
+    max_energy: str = "MaxEnergy",
+        Column name for max energy for the polynomial.
+    poly_deg: list | None = None,
+        Column names for the parameters for the polynomial, starting with the least significant.
+
+    return
+    ------
+        return a dictionary that conform to Apple2 lookup table format:
+
+        {mode: {'Energies': {Any: {'Low': float,
+                                'High': float,
+                                'Poly':np.poly1d
+                                }
+                            }
+                'Limit': {'Minimum': float,
+                        'Maximum': float
+                        }
+            }
+        }
+    """
+    if poly_deg is None:
+        poly_deg = [
+            "7th-order",
+            "6th-order",
+            "5th-order",
+            "4th-order",
+            "3rd-order",
+            "2nd-order",
+            "1st-order",
+            "b",
+        ]
+    look_up_table = {}
+    pol = []
+
+    def data2dict(row) -> None:
+        # logic for the conversion for each row of data.
+        if row[mode] not in pol:
+            pol.append(row[mode])
+            look_up_table[row[mode]] = {}
+            look_up_table[row[mode]] = {
+                "Energies": {},
+                "Limit": {
+                    "Minimum": float(row[min_energy]),
+                    "Maximum": float(row[max_energy]),
+                },
+            }
+
+        # create polynomial object for energy to gap/phase
+        cof = [float(row[x]) for x in poly_deg]
+        poly = np.poly1d(cof)
+
+        look_up_table[row[mode]]["Energies"][row[min_energy]] = {
+            "Low": float(row[min_energy]),
+            "High": float(row[max_energy]),
+            "Poly": poly,
+        }
+        look_up_table[row[mode]]["Limit"]["Minimum"] = min(
+            look_up_table[row[mode]]["Limit"]["Minimum"], float(row[min_energy])
+        )
+        look_up_table[row[mode]]["Limit"]["Maximum"] = max(
+            look_up_table[row[mode]]["Limit"]["Maximum"], float(row[max_energy])
+        )
+
+    with open(file, newline="") as csvfile:
+        reader = csv.DictReader(csvfile)
+        for row in reader:
+            # If there are multiple source only convert requested.
+            if row[source[0]] == source[1]:
+                data2dict(row=row)
+    if not look_up_table:
+        raise RuntimeError(f"Unable to convert lookup table:/n/t{file}")
+    return look_up_table

dodal/devices/i10/i10_setting_data.py

@@ -0,0 +1,7 @@
+from ophyd_async.core import StrictEnum
+
+
+class I10Grating(StrictEnum):
+    Au400 = "400 line/mm Au"
+    Si400 = "400 line/mm Si"
+    Au1200 = "1200 line/mm Au"

dodal/devices/i22/dcm.py

@@ -1,32 +1,24 @@
 import time
-from collections.abc import Sequence
-from dataclasses import dataclass
-from typing import Literal
 
+import numpy as np
 from bluesky.protocols import Reading
 from event_model.documents.event_descriptor import DataKey
-from ophyd_async.core import ConfigSignal, StandardReadable, soft_signal_r_and_setter
+from ophyd_async.core import (
+    Array1D,
+    StandardReadable,
+    StandardReadableFormat,
+    soft_signal_r_and_setter,
+)
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
+
+from dodal.common.crystal_metadata import CrystalMetadata
 
 # 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
 
 
-@dataclass(frozen=True, unsafe_hash=True)
-class CrystalMetadata:
-    """
-    Metadata used in the NeXus format,
-    see https://manual.nexusformat.org/classes/base_classes/NXcrystal.html
-    """
-
-    usage: Literal["Bragg", "Laue"] | None = None
-    type: str | None = None
-    reflection: tuple[int, int, int] | None = None
-    d_spacing: tuple[float, str] | None = None
-
-
 class DoubleCrystalMonochromator(StandardReadable):
     """
     A double crystal monochromator (DCM), used to select the energy of the beam.
@@ -39,22 +31,21 @@ class DoubleCrystalMonochromator(StandardReadable):
 
     def __init__(
         self,
-        motion_prefix: str,
         temperature_prefix: str,
-        crystal_1_metadata: CrystalMetadata | None = None,
-        crystal_2_metadata: CrystalMetadata | None = None,
+        crystal_1_metadata: CrystalMetadata,
+        crystal_2_metadata: CrystalMetadata,
         prefix: str = "",
         name: str = "",
     ) -> None:
         with self.add_children_as_readables():
             # Positionable Parameters
-            self.bragg = Motor(motion_prefix + "BRAGG")
-            self.offset = Motor(motion_prefix + "OFFSET")
-            self.perp = Motor(motion_prefix + "PERP")
-            self.energy = Motor(motion_prefix + "ENERGY")
-            self.crystal_1_roll = Motor(motion_prefix + "XTAL1:ROLL")
-            self.crystal_2_roll = Motor(motion_prefix + "XTAL2:ROLL")
-            self.crystal_2_pitch = Motor(motion_prefix + "XTAL2:PITCH")
+            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")
@@ -70,61 +61,37 @@ class DoubleCrystalMonochromator(StandardReadable):
 
         # Soft metadata
         # If supplied include crystal details in output of read_configuration
-        crystal_1_metadata = crystal_1_metadata or CrystalMetadata()
-        crystal_2_metadata = crystal_2_metadata or CrystalMetadata()
-        with self.add_children_as_readables(ConfigSignal):
-            if crystal_1_metadata.usage is not None:
-                self.crystal_1_usage, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_1_metadata.usage
-                )
-            else:
-                self.crystal_1_usage = None
-            if crystal_1_metadata.type is not None:
-                self.crystal_1_type, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_1_metadata.type
-                )
-            else:
-                self.crystal_1_type = None
-            if crystal_1_metadata.reflection is not None:
-                self.crystal_1_reflection, _ = soft_signal_r_and_setter(
-                    Sequence[int], initial_value=list(crystal_1_metadata.reflection)
-                )
-            else:
-                self.crystal_1_reflection = None
-            if crystal_1_metadata.d_spacing is not None:
-                self.crystal_1_d_spacing, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=crystal_1_metadata.d_spacing[0],
-                    units=crystal_1_metadata.d_spacing[1],
-                )
-            else:
-                self.crystal_1_d_spacing = None
-            if crystal_2_metadata.usage is not None:
-                self.crystal_2_usage, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_2_metadata.usage
-                )
-            else:
-                self.crystal_2_usage = None
-            if crystal_2_metadata.type is not None:
-                self.crystal_2_type, _ = soft_signal_r_and_setter(
-                    str, initial_value=crystal_2_metadata.type
-                )
-            else:
-                self.crystal_2_type = None
-            if crystal_2_metadata.reflection is not None:
-                self.crystal_2_reflection, _ = soft_signal_r_and_setter(
-                    Sequence[int], initial_value=list(crystal_2_metadata.reflection)
-                )
-            else:
-                self.crystal_2_reflection = None
-            if crystal_2_metadata.d_spacing is not None:
-                self.crystal_2_d_spacing, _ = soft_signal_r_and_setter(
-                    float,
-                    initial_value=crystal_2_metadata.d_spacing[0],
-                    units=crystal_2_metadata.d_spacing[1],
-                )
-            else:
-                self.crystal_2_d_spacing = None
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.crystal_1_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_1_metadata.usage
+            )
+            self.crystal_1_type, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_1_metadata.type
+            )
+            self.crystal_1_reflection, _ = soft_signal_r_and_setter(
+                Array1D[np.int32],
+                initial_value=np.array(crystal_1_metadata.reflection),
+            )
+            self.crystal_1_d_spacing, _ = soft_signal_r_and_setter(
+                float,
+                initial_value=crystal_1_metadata.d_spacing[0],
+                units=crystal_1_metadata.d_spacing[1],
+            )
+            self.crystal_2_usage, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_2_metadata.usage
+            )
+            self.crystal_2_type, _ = soft_signal_r_and_setter(
+                str, initial_value=crystal_2_metadata.type
+            )
+            self.crystal_2_reflection, _ = soft_signal_r_and_setter(
+                Array1D[np.int32],
+                initial_value=np.array(crystal_2_metadata.reflection),
+            )
+            self.crystal_2_d_spacing, _ = soft_signal_r_and_setter(
+                float,
+                initial_value=crystal_2_metadata.d_spacing[0],
+                units=crystal_2_metadata.d_spacing[1],
+            )
 
         super().__init__(name)
 

dodal/devices/i22/fswitch.py

@@ -1,19 +1,19 @@
 import asyncio
 import time
-from enum import Enum
 
 from bluesky.protocols import Reading
 from event_model import DataKey
 from ophyd_async.core import (
-    ConfigSignal,
     DeviceVector,
     StandardReadable,
+    StandardReadableFormat,
+    StrictEnum,
     soft_signal_r_and_setter,
 )
-from ophyd_async.epics.signal import epics_signal_r
+from ophyd_async.epics.core import epics_signal_r
 
 
-class FilterState(str, Enum):
+class FilterState(StrictEnum):
     """
     Note that the in/out here refers to the internal rocker
     position so a PV value of IN implies a filter OUT of beam
@@ -54,7 +54,7 @@ class FSwitch(StandardReadable):
                 for i in range(FSwitch.NUM_FILTERS)
             }
         )
-        with self.add_children_as_readables(ConfigSignal):
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             if lens_geometry is not None:
                 self.lens_geometry, _ = soft_signal_r_and_setter(
                     str, initial_value=lens_geometry

dodal/devices/i24/aperture.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
-class AperturePositions(str, Enum):
+class AperturePositions(StrictEnum):
     IN = "In"
     OUT = "Out"
     ROBOT = "Robot"

dodal/devices/i24/beamstop.py

@@ -1,11 +1,9 @@
-from enum import Enum
-
-from ophyd_async.core import StandardReadable
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.core import epics_signal_rw
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_rw
 
 
-class BeamstopPositions(str, Enum):
+class BeamstopPositions(StrictEnum):
     CHECK_BEAM = "CheckBeam"
     DATA_COLLECTION = "Data Collection"
     DATA_COLLECTION_FAR = "Data Collection Far"

dodal/devices/i24/dcm.py

@@ -1,6 +1,6 @@
 from ophyd_async.core import StandardReadable
+from ophyd_async.epics.core import epics_signal_r
 from ophyd_async.epics.motor import Motor
-from ophyd_async.epics.signal import epics_signal_r
 
 
 class DCM(StandardReadable):