dls-dodal 1.48.0__py3-none-any.whl → 1.50.0__py3-none-any.whl

dodal/devices/electron_analyser/vgscienta/__init__.py

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

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,4 +1,4 @@
-from dodal.devices.electron_analyser.abstract.base_detector import (
+from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
 from dodal.devices.electron_analyser.vgscienta.driver_io import (

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -14,6 +14,7 @@ from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
 from dodal.devices.electron_analyser.util import to_kinetic_energy
+from dodal.devices.electron_analyser.vgscienta.enums import AcquisitionMode
 from dodal.devices.electron_analyser.vgscienta.region import (
     DetectorMode,
     VGScientaRegion,
@@ -35,7 +36,7 @@ class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
             # Used to read detector data after acqusition.
             self.external_io = epics_signal_r(Array1D[np.float64], prefix + "EXTIO")
 
-        super().__init__(prefix, name)
+        super().__init__(prefix, AcquisitionMode, name)
 
     @AsyncStatus.wrap
     async def set(self, region: VGScientaRegion):

dodal/devices/electron_analyser/vgscienta/enums.py

@@ -0,0 +1,19 @@
+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"
+
+
+class AcquisitionMode(StrictEnum):
+    SWEPT = "Swept"
+    FIXED = "Fixed"

dodal/devices/electron_analyser/vgscienta/region.py

@@ -1,7 +1,5 @@
 import uuid
-from enum import Enum
 
-from ophyd_async.core import StrictEnum
 from pydantic import Field
 
 from dodal.devices.electron_analyser.abstract.base_region import (
@@ -9,31 +7,18 @@ from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseSequence,
     JavaToPythonModel,
 )
+from dodal.devices.electron_analyser.vgscienta.enums import (
+    AcquisitionMode,
+    DetectorMode,
+    Status,
+)
 
 
-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):
+class VGScientaRegion(AbstractBaseRegion[AcquisitionMode]):
     # Override defaults of base region class
     lens_mode: str = "Angular45"
     pass_energy: int = 5
-    acquisition_mode: str = AcquisitionMode.SWEPT
+    acquisition_mode: AcquisitionMode = AcquisitionMode.SWEPT
     low_energy: float = 8.0
     high_energy: float = 10.0
     step_time: float = 1.0

dodal/devices/hutch_shutter.py

@@ -81,14 +81,14 @@ class HutchShutter(StandardReadable, Movable[ShutterDemand]):
 
     @AsyncStatus.wrap
     async def set(self, value: ShutterDemand):
-        interlock_state = await self.interlock.shutter_safe_to_operate()
-        if not interlock_state and not TEST_MODE:
-            # If not in test mode, fail. If in test mode, the optics hutch may be open.
-            raise ShutterNotSafeToOperateError(
-                "The hutch has not been locked, not operating shutter."
-            )
         if not TEST_MODE:
             if value == ShutterDemand.OPEN:
+                interlock_state = await self.interlock.shutter_safe_to_operate()
+                if not interlock_state:
+                    # If not in test mode, fail. If in test mode, the optics hutch may be open.
+                    raise ShutterNotSafeToOperateError(
+                        "The hutch has not been locked, not operating shutter."
+                    )
                 await self.control.set(ShutterDemand.RESET, wait=True)
                 await self.control.set(value, wait=True)
                 return await wait_for_value(

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/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"