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

dodal/devices/i10/i10_apple2.py

@@ -8,6 +8,7 @@ import numpy as np
 from bluesky.protocols import Movable
 from ophyd_async.core import (
     AsyncStatus,
+    Device,
     Reference,
     StandardReadable,
     StandardReadableFormat,
@@ -15,16 +16,18 @@ from ophyd_async.core import (
     soft_signal_rw,
 )
 
-from dodal.devices.apple2_undulator import (
+from dodal.log import LOGGER
+
+from ..apple2_undulator import (
     Apple2,
     Apple2Val,
     Lookuptable,
+    Pol,
     UndulatorGap,
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
-from dodal.devices.pgm import PGM
-from dodal.log import LOGGER
+from ..pgm import PGM
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
 MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
@@ -51,22 +54,20 @@ class LookupTableConfig:
 
 
 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.
+    """I10Apple2 is the i10 version of Apple2 ID, set and update_lookuptable function
+    should be the only part that is I10 specific.
+
+    A pair of look up tables are needed to provide the conversion betwApple 2 ID/undulator has 4 extra degrees of freedom compare to the standard Undulator,
+    each bank of magnet can move independently to each other,
+    which allow the production of different x-ray polarisation as well as energy.
+    This type of ID is use on I10, I21, I09, I17 and I06 for soft x-ray.een motor position and energy.
 
-    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,
+        look_up_table_dir: str,
         source: tuple[str, str],
         prefix: str = "",
         mode: str = "Mode",
@@ -78,14 +79,8 @@ class I10Apple2(Apple2):
         """
         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.
+        look_up_table_dir:
+            The path to look up table.
         source:
             The column name and the name of the source in look up table. e.g. ("source", "idu")
         mode:
@@ -97,11 +92,17 @@ class I10Apple2(Apple2):
         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.
+            epic pv for id
         Name:
             Name of the device
         """
 
+        energy_gap_table_path = Path(
+            look_up_table_dir + "IDEnergy2GapCalibrations.csv",
+        )
+        energy_phase_table_path = Path(
+            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(
             path=LookupPath(Gap=energy_gap_table_path, Phase=energy_phase_table_path),
@@ -112,44 +113,62 @@ class I10Apple2(Apple2):
             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)
+            super().__init__(
+                id_gap=UndulatorGap(name="id_gap", prefix=prefix),
+                id_phase=UndulatorPhaseAxes(
+                    name="id_phase",
+                    prefix=prefix,
+                    top_outer="RPQ1",
+                    top_inner="RPQ2",
+                    btm_inner="RPQ3",
+                    btm_outer="RPQ4",
+                ),
+                prefix=prefix,
+                name=name,
+            )
+            self.id_jaw_phase = UndulatorJawPhase(
+                prefix=prefix,
+                move_pv="RPQ1",
+            )
 
     @AsyncStatus.wrap
-    async def set(self, value: SupportsFloat) -> None:
+    async def set(self, value: float) -> 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))
+
+        pol = await self.polarisation_setpoint.get_value()
+
+        if pol == Pol.NONE:
+            LOGGER.warning(
+                "Found no setpoint for polarisation. Attempting to"
+                " determine polarisation from hardware..."
+            )
+            pol = await self.polarisation.get_value()
+            if pol == Pol.NONE:
+                raise ValueError(
+                    f"Polarisation cannot be determined from hardware for {self.name}"
+                )
+
+            self._set_pol_setpoint(pol)
+        gap, phase = await self._get_id_gap_phase(value)
+        phase3 = phase * (-1 if pol == Pol.LA else 1)
         id_set_val = Apple2Val(
-            top_outer=str(phase),
+            top_outer=f"{phase:.6f}",
             top_inner="0.0",
-            btm_inner=str(phase3),
+            btm_inner=f"{phase3:.6f}",
             btm_outer="0.0",
-            gap=str(gap),
+            gap=f"{gap:.6f}",
         )
-        LOGGER.info(f"Setting polarisation to {self.pol}, with {id_set_val}")
+
+        LOGGER.info(f"Setting polarisation to {pol}, with values: {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)
+        if pol != Pol.LA:
+            await self.id_jaw_phase.set(0)
+            await self.id_jaw_phase.set_move.set(1)
+        LOGGER.info(f"Energy set to {value} eV successfully.")
 
     def update_lookuptable(self):
         """
@@ -175,15 +194,13 @@ class I10Apple2(Apple2):
         self._available_pol = list(self.lookup_tables["Gap"].keys())
 
 
-class I10Apple2PGM(StandardReadable, Movable[float]):
+class EnergySetter(StandardReadable, Movable[float]):
     """
-    Compound device to set both ID and PGM energy at the sample time,poly_deg
+    Compound device to set both ID and PGM energy at the same time.
 
     """
 
-    def __init__(
-        self, id: I10Apple2, pgm: PGM, prefix: str = "", name: str = ""
-    ) -> None:
+    def __init__(self, id: I10Apple2, pgm: PGM, name: str = "") -> None:
         """
         Parameters
         ----------
@@ -191,53 +208,52 @@ class I10Apple2PGM(StandardReadable, Movable[float]):
             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.id = id
         self.pgm_ref = Reference(pgm)
-        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+
+        self.add_readables(
+            [self.id.energy, self.pgm_ref().energy.user_readback],
+            StandardReadableFormat.HINTED_SIGNAL,
+        )
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_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.id.set(value=value + await self.energy_offset.get_value()),
             self.pgm_ref().energy.set(value),
         )
 
 
-class I10Apple2Pol(StandardReadable, Movable[str]):
+class I10Apple2Pol(StandardReadable, Movable[Pol]):
     """
     Compound device to set polorisation of ID.
     """
 
-    def __init__(self, id: I10Apple2, prefix: str = "", name: str = "") -> None:
+    def __init__(self, id: I10Apple2, 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
+        self.id_ref = Reference(id)
+        self.add_readables([self.id_ref().polarisation])
 
     @AsyncStatus.wrap
-    async def set(self, value: str) -> None:
-        self.id.pol = value  # change polarisation.
+    async def set(self, value: Pol) -> None:
         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
+        await self.id_ref().polarisation.set(value)
 
 
 class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
@@ -253,7 +269,6 @@ class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
     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,
@@ -264,8 +279,6 @@ class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
         ----------
         id: I10Apple2
             An I10Apple2 device.
-        prefix: str
-            Not in use but needed for device_instantiation.
         name: str
             New device name.
         jaw_phase_limit: float
@@ -286,8 +299,8 @@ class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
     @AsyncStatus.wrap
     async def set(self, value: SupportsFloat) -> None:
         value = float(value)
-        pol = self.id_ref().pol
-        if pol != "la":
+        pol = await self.id_ref().polarisation.get_value()
+        if pol != Pol.LA:
             raise RuntimeError(
                 f"Angle control is not available in polarisation {pol} with {self.id_ref().name}"
             )
@@ -299,10 +312,60 @@ class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
                 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)
+        await self.id_ref().id_jaw_phase.set(jaw_phase)
         self._angle_set(value)
 
 
+class I10Id(Device):
+    def __init__(
+        self,
+        pgm: PGM,
+        prefix: str,
+        look_up_table_dir: str,
+        source: tuple[str, str],
+        jaw_phase_limit=12.0,
+        jaw_phase_poly_param=DEFAULT_JAW_PHASE_POLY_PARAMS,
+        angle_threshold_deg=30.0,
+        name: str = "",
+    ) -> None:
+        """I10Id is a compound device that combines the I10-specific Apple2 undulator,
+        energy setter, and polarization control.
+        This class provides a high-level interface for controlling the undulator's
+        energy, polarization, and linear arbitrary angle.
+
+        Attributes
+        ----------
+        id : I10Apple2
+            The I10-specific Apple2 undulator device.
+        energy_setter : EnergySetter
+            A device for synchronizing the undulator and monochromator energy.
+        pol : I10Apple2Pol
+            A device for controlling the polarization of the undulator.
+        linear_arbitrary_angle : LinearArbitraryAngle
+            A device for controlling the linear arbitrary polarization angle.
+        """
+        self.energy = EnergySetter(
+            id=I10Apple2(
+                look_up_table_dir=look_up_table_dir,
+                name="id_energy",
+                source=source,
+                prefix=prefix,
+            ),
+            pgm=pgm,
+            name="energy",
+        )
+        self.pol = I10Apple2Pol(id=self.energy.id, name="pol")
+        self.laa = LinearArbitraryAngle(
+            id=self.energy.id,
+            name="laa",
+            jaw_phase_limit=jaw_phase_limit,
+            jaw_phase_poly_param=jaw_phase_poly_param,
+            angle_threshold_deg=angle_threshold_deg,
+        )
+
+        super().__init__(name=name)
+
+
 def convert_csv_to_lookup(
     file: str,
     source: tuple[str, str],
@@ -312,38 +375,28 @@ def convert_csv_to_lookup(
     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.
+    Convert a CSV file to a dictionary compatible with the Apple2 lookup table format.
 
     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
-                        }
-            }
-        }
+    ----------
+    file : str
+        Path to the CSV file.
+    source : tuple[str, str]
+        Tuple specifying the column name and source name (e.g., ("Source", "idu")).
+    mode : str, optional
+        Column name for the available modes (e.g., "lv", "lh", "pc", "nc"), by default "Mode".
+    min_energy : str, optional
+        Column name for the minimum energy, by default "MinEnergy".
+    max_energy : str, optional
+        Column name for the maximum energy, by default "MaxEnergy".
+    poly_deg : list, optional
+        Column names for polynomial coefficients, starting with the least significant term.
+
+    Returns
+    -------
+    dict
+        A dictionary conforming to the Apple2 lookup table format.
+
     """
     if poly_deg is None:
         poly_deg = [
@@ -356,15 +409,15 @@ def convert_csv_to_lookup(
             "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]] = {
+    lookup_table = {}
+    polarisations = set()
+
+    def process_row(row: dict) -> None:
+        """Process a single row from the CSV file and update the lookup table."""
+        mode_value = row[mode]
+        if mode_value not in polarisations:
+            polarisations.add(mode_value)
+            lookup_table[mode_value] = {
                 "Energies": {},
                 "Limit": {
                     "Minimum": float(row[min_energy]),
@@ -372,20 +425,22 @@ def convert_csv_to_lookup(
                 },
             }
 
-        # create polynomial object for energy to gap/phase
-        cof = [float(row[x]) for x in poly_deg]
-        poly = np.poly1d(cof)
+        # Create polynomial object for energy-to-gap/phase conversion
+        coefficients = [float(row[coef]) for coef in poly_deg]
+        polynomial = np.poly1d(coefficients)
 
-        look_up_table[row[mode]]["Energies"][row[min_energy]] = {
+        lookup_table[mode_value]["Energies"][row[min_energy]] = {
             "Low": float(row[min_energy]),
             "High": float(row[max_energy]),
-            "Poly": poly,
+            "Poly": polynomial,
         }
-        look_up_table[row[mode]]["Limit"]["Minimum"] = min(
-            look_up_table[row[mode]]["Limit"]["Minimum"], float(row[min_energy])
+
+        # Update energy limits
+        lookup_table[mode_value]["Limit"]["Minimum"] = min(
+            lookup_table[mode_value]["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])
+        lookup_table[mode_value]["Limit"]["Maximum"] = max(
+            lookup_table[mode_value]["Limit"]["Maximum"], float(row[max_energy])
         )
 
     with open(file, newline="") as csvfile:
@@ -393,7 +448,7 @@ def convert_csv_to_lookup(
         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:
+                process_row(row=row)
+    if not lookup_table:
         raise RuntimeError(f"Unable to convert lookup table:/n/t{file}")
-    return look_up_table
+    return lookup_table

dodal/devices/i18/diode.py

@@ -1,8 +1,36 @@
-from ophyd_async.core import (
-    StandardReadable,
-)
+from ophyd_async.core import StandardReadable, StrictEnum
 from ophyd_async.epics.core import epics_signal_r
 
+from dodal.devices.positioner import create_positioner
+
+
+class FilterAValues(StrictEnum):
+    """Maps from a short usable name to the string name in EPICS"""
+
+    AL_2MM = "2 mm Al"
+    AL_1_5MM = "1.5 mm Al"
+    AL_1_25MM = "1.25 mm Al"
+    AL_0_8MM = "0.8 mm Al"
+    AL_0_55MM = "0.55 mm Al"
+    AL_0_5MM = "0.5 mm Al"
+    AL_0_3MM = "0.3 mm Al"
+    AL_0_25MM = "0.25 mm Al"
+    AL_0_15MM = "0.15 mm Al"
+    AL_0_1MM = "0.1 mm Al"
+    AL_0_05MM = "0.05 mm Al"
+    AL_0_025MM = "0.025 mm Al"
+    AL_GAP = "Gap"
+
+
+class FilterBValues(StrictEnum):
+    DIAMOND_THIN = "Diamond thin"
+    DIAMOND_THICK = "Diamond thick"
+    NI_DRAIN = "ni drain"
+    AU_DRAIN = "au drain"
+    AL_DRAIN = "al drain"
+    GAP = "Gap"
+    IN_LINE_DIODE = "in line diode"
+
 
 class Diode(StandardReadable):
     def __init__(
@@ -10,8 +38,13 @@ class Diode(StandardReadable):
         prefix: str,
         name: str = "",
     ):
-        self._prefix = prefix
         with self.add_children_as_readables():
             self.signal = epics_signal_r(float, prefix + "B:DIODE:I")
+            self.positioner_a = create_positioner(
+                FilterAValues, prefix + "A:MP", positioner_pv_suffix=":SELECT"
+            )  # more complex, will be fixed on Tuesday 20.05.2025
+            self.positioner_b = create_positioner(
+                FilterBValues, prefix + "B:MP", positioner_pv_suffix=":SELECT"
+            )
 
         super().__init__(name=name)

dodal/devices/i22/nxsas.py

@@ -38,7 +38,7 @@ class MetadataHolder:
             if isinstance(value, tuple):
                 return {"units": value[1], **datakey(value[0])}
             dtype = "string"
-            shape = []
+            shape: list[int | None] = []
             match value:
                 case bool():
                     dtype = "boolean"

dodal/devices/mx_phase1/beamstop.py

@@ -1,6 +1,11 @@
+import asyncio
 from math import isclose
 
-from ophyd_async.core import StandardReadable, StrictEnum, derived_signal_r
+from ophyd_async.core import (
+    StandardReadable,
+    StrictEnum,
+    derived_signal_rw,
+)
 from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
@@ -37,8 +42,7 @@ class Beamstop(StandardReadable):
         x: beamstop x position in mm
         y: beamstop y position in mm
         z: beamstop z position in mm
-        selected_pos: Get the current position of the beamstop as an enum. Currently this
-            is read-only.
+        selected_pos: Get or set the current position of the beamstop as an enum.
     """
 
     def __init__(
@@ -51,10 +55,13 @@ class Beamstop(StandardReadable):
             self.x_mm = Motor(prefix + "X")
             self.y_mm = Motor(prefix + "Y")
             self.z_mm = Motor(prefix + "Z")
-            self.selected_pos = derived_signal_r(
-                self._get_selected_position, x=self.x_mm, y=self.y_mm, z=self.z_mm
+            self.selected_pos = derived_signal_rw(
+                self._get_selected_position,
+                self._set_selected_position,
+                x=self.x_mm,
+                y=self.y_mm,
+                z=self.z_mm,
             )
-
         self._in_beam_xyz_mm = [
             float(beamline_parameters[f"in_beam_{axis}_STANDARD"])
             for axis in ("x", "y", "z")
@@ -77,3 +84,13 @@ class Beamstop(StandardReadable):
             return BeamstopPositions.DATA_COLLECTION
         else:
             return BeamstopPositions.UNKNOWN
+
+    async def _set_selected_position(self, position: BeamstopPositions) -> None:
+        if position == BeamstopPositions.DATA_COLLECTION:
+            await asyncio.gather(
+                self.x_mm.set(self._in_beam_xyz_mm[0]),
+                self.y_mm.set(self._in_beam_xyz_mm[1]),
+                self.z_mm.set(self._in_beam_xyz_mm[2]),
+            )
+        elif position == BeamstopPositions.UNKNOWN:
+            raise ValueError(f"Cannot set beamstop to position {position}")