dls-dodal 1.65.0__py3-none-any.whl → 1.66.0__py3-none-any.whl

dodal/devices/i10/i10_apple2.py

@@ -1,12 +1,7 @@
-import csv
-import io
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, SupportsFloat
+from typing import SupportsFloat
 
 import numpy as np
 from bluesky.protocols import Movable
-from daq_config_server.client import ConfigServer
 from ophyd_async.core import (
     AsyncStatus,
     Reference,
@@ -15,17 +10,19 @@ from ophyd_async.core import (
     derived_signal_rw,
     soft_signal_rw,
 )
-from pydantic import BaseModel, ConfigDict, RootModel
 
 from dodal.devices.apple2_undulator import (
+    MAXIMUM_MOVE_TIME,
     Apple2,
     Apple2Controller,
+    Apple2PhasesVal,
     Apple2Val,
     Pol,
     UndulatorGap,
     UndulatorJawPhase,
     UndulatorPhaseAxes,
 )
+from dodal.devices.util.lookup_tables_apple2 import EnergyMotorLookup
 from dodal.log import LOGGER
 
 ROW_PHASE_MOTOR_TOLERANCE = 0.004
@@ -33,290 +30,11 @@ 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
-MAXIMUM_MOVE_TIME = 550  # There is no useful movements take longer than this.
 
 
-# data class to store the lookup table configuration that is use in convert_csv_to_lookup
-@dataclass
-class LookupPath:
-    Gap: Path
-    Phase: Path
+class I10Apple2(Apple2[UndulatorPhaseAxes]):
+    """I10Apple2 device is an apple2 with extra jaw phase motor."""
 
-
-@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 EnergyMinMax(BaseModel):
-    Minimum: float
-    Maximum: float
-
-
-class EnergyCoverageEntry(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    Low: float
-    High: float
-    Poly: np.poly1d
-
-
-class EnergyCoverage(RootModel):
-    root: dict[str, EnergyCoverageEntry]
-
-
-class LookupTableEntries(BaseModel):
-    Energies: EnergyCoverage
-    Limit: EnergyMinMax
-
-
-class Lookuptable(RootModel):
-    """BaseModel class for the lookup table.
-    Apple2 lookup table should be in this format.
-
-    {mode: {'Energies': {Any: {'Low': float,
-                            'High': float,
-                            'Poly':np.poly1d
-                            }
-                        }
-            'Limit': {'Minimum': float,
-                    'Maximum': float
-                    }
-        }
-    }
-    """
-
-    root: dict[str, LookupTableEntries]
-
-
-class I10EnergyMotorLookup:
-    """
-    Handles lookup tables for I10 Apple2 ID, converting energy and polarisation to gap
-     and phase. Fetches and parses lookup tables from a config server, supports dynamic
-     updates, and validates input.
-    """
-
-    def __init__(
-        self,
-        lookuptable_dir: str,
-        source: tuple[str, str],
-        config_client: ConfigServer,
-        mode: str = "Mode",
-        min_energy: str = "MinEnergy",
-        max_energy: str = "MaxEnergy",
-        gap_file_name: str = "IDEnergy2GapCalibrations.csv",
-        phase_file_name: str = "IDEnergy2PhaseCalibrations.csv",
-        poly_deg: list | None = None,
-    ):
-        """Initialise the I10EnergyMotorLookup class with lookup table headers provided.
-
-        Parameters
-        ----------
-        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")
-        config_client:
-            The config server client to fetch the look up table.
-        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.
-
-        """
-        self.lookup_tables: dict[str, dict[str | None, dict[str, dict[str, Any]]]] = {
-            "Gap": {},
-            "Phase": {},
-        }
-        energy_gap_table_path = Path(lookuptable_dir, gap_file_name)
-        energy_phase_table_path = Path(lookuptable_dir, phase_file_name)
-        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,
-        )
-        self.config_client = config_client
-        self._available_pol = []
-
-    @property
-    def available_pol(self) -> list[str | None]:
-        return self._available_pol
-
-    @available_pol.setter
-    def available_pol(self, value: list[str | None]) -> None:
-        self._available_pol = value
-
-    def update_lookuptable(self):
-        """
-        Update lookup tables from files and validate their format.
-        """
-        LOGGER.info("Updating lookup dictionary from file.")
-        for key, path in self.lookup_table_config.path.__dict__.items():
-            self.lookup_tables[key] = self.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,
-            )
-            Lookuptable.model_validate(self.lookup_tables[key])
-
-        self.available_pol = list(self.lookup_tables["Gap"].keys())
-
-    def get_motor_from_energy(self, energy: float, pol: Pol) -> tuple[float, float]:
-        """
-        Convert energy and polarisation to gap and phase motor positions.
-
-        Parameters
-        ----------
-        energy : float
-            Desired energy in eV.
-        pol : Pol
-            Polarisation mode.
-
-        Returns
-        -------
-        tuple[float, float]
-            (gap, phase) motor positions.
-
-        """
-        if self.available_pol == []:
-            self.update_lookuptable()
-
-        gap_poly = self._get_poly(
-            lookup_table=self.lookup_tables["Gap"], energy=energy, pol=pol
-        )
-        phase_poly = self._get_poly(
-            lookup_table=self.lookup_tables["Phase"], energy=energy, pol=pol
-        )
-        return gap_poly(energy), phase_poly(energy)
-
-    def _get_poly(
-        self,
-        energy: float,
-        pol: Pol,
-        lookup_table: dict[str | None, dict[str, dict[str, Any]]],
-    ) -> np.poly1d:
-        """
-        Get polynomial for a given energy and polarisation.
-
-        Raises
-        ------
-        ValueError
-            If energy is out of bounds or coefficients are missing.
-        """
-        if (
-            energy < lookup_table[pol]["Limit"]["Minimum"]
-            or energy > lookup_table[pol]["Limit"]["Maximum"]
-        ):
-            raise ValueError(
-                "Demanding energy must lie between {} and {} eV!".format(
-                    lookup_table[pol]["Limit"]["Minimum"],
-                    lookup_table[pol]["Limit"]["Maximum"],
-                )
-            )
-        else:
-            for energy_range in lookup_table[pol]["Energies"].values():
-                if energy >= energy_range["Low"] and energy < energy_range["High"]:
-                    return energy_range["Poly"]
-
-        raise ValueError(
-            """Cannot find polynomial coefficients for your requested energy.
-        There might be gap in the calibration lookup table."""
-        )
-
-    def convert_csv_to_lookup(
-        self,
-        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 a CSV file to a lookup table dictionary.
-
-        Returns
-        -------
-        dict
-            Dictionary in Apple2 lookup table format.
-
-        Raises
-        ------
-        RuntimeError
-            If the CSV cannot be converted.
-
-        """
-        if poly_deg is None:
-            poly_deg = [
-                "7th-order",
-                "6th-order",
-                "5th-order",
-                "4th-order",
-                "3rd-order",
-                "2nd-order",
-                "1st-order",
-                "b",
-            ]
-        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]),
-                        "Maximum": float(row[max_energy]),
-                    },
-                }
-
-            # Create polynomial object for energy-to-gap/phase conversion
-            coefficients = [float(row[coef]) for coef in poly_deg]
-            polynomial = np.poly1d(coefficients)
-
-            lookup_table[mode_value]["Energies"][row[min_energy]] = {
-                "Low": float(row[min_energy]),
-                "High": float(row[max_energy]),
-                "Poly": polynomial,
-            }
-
-            # Update energy limits
-            lookup_table[mode_value]["Limit"]["Minimum"] = min(
-                lookup_table[mode_value]["Limit"]["Minimum"], float(row[min_energy])
-            )
-            lookup_table[mode_value]["Limit"]["Maximum"] = max(
-                lookup_table[mode_value]["Limit"]["Maximum"], float(row[max_energy])
-            )
-
-        csv_file = self.config_client.get_file_contents(file, reset_cached_result=True)
-        reader = csv.DictReader(io.StringIO(csv_file))
-        for row in reader:
-            # If there are multiple source only convert requested.
-            if row[source[0]] == source[1]:
-                process_row(row=row)
-        if not lookup_table:
-            raise RuntimeError(f"Unable to convert lookup table:\t{file}")
-        return lookup_table
-
-
-class I10Apple2(Apple2):
     def __init__(
         self,
         id_gap: UndulatorGap,
@@ -325,11 +43,8 @@ class I10Apple2(Apple2):
         name: str = "",
     ) -> None:
         """
-        I10Apple2 device is an apple2 with extra jaw phase motor.
-
-        Parameters
-        ----------
-
+        Parameters:
+        ------------
         id_gap : UndulatorJawPhase
             The gap motor of the undulator.
         id_phase : UndulatorJawPhase
@@ -353,26 +68,19 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
     def __init__(
         self,
         apple2: I10Apple2,
-        lookuptable_dir: str,
-        source: tuple[str, str],
-        config_client: ConfigServer,
+        energy_motor_lut: EnergyMotorLookup,
         jaw_phase_limit: float = 12.0,
         jaw_phase_poly_param: list[float] = DEFAULT_JAW_PHASE_POLY_PARAMS,
         angle_threshold_deg=30.0,
         name: str = "",
     ) -> None:
         """
-
-        parameters
-        ----------
+        Parameters:
+        -----------
         apple2 : I10Apple2
             An I10Apple2 device.
-        lookuptable_dir : str
-            The path to look up table.
-        source : tuple[str, str]
-            The column name and the name of the source in look up table. e.g. ( "source", "idu")
-        config_client : ConfigServer
-            The config server client to fetch the look up table.
+        energy_motor_lut: EnergyMotorLookup
+            The class that handles the look up table logic for the insertion device.
         jaw_phase_limit : float, optional
             The maximum allowed jaw_phase movement., by default 12.0
         jaw_phase_poly_param : list[float], optional
@@ -383,14 +91,10 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
             New device name.
         """
 
-        self.lookup_table_client = I10EnergyMotorLookup(
-            lookuptable_dir=lookuptable_dir,
-            source=source,
-            config_client=config_client,
-        )
+        self.energy_motor_lut = energy_motor_lut
         super().__init__(
             apple2=apple2,
-            energy_to_motor_converter=self.lookup_table_client.get_motor_from_energy,
+            energy_to_motor_converter=self.energy_motor_lut.get_motor_from_energy,
             name=name,
         )
 
@@ -437,11 +141,13 @@ class I10Apple2Controller(Apple2Controller[I10Apple2]):
         gap, phase = self.energy_to_motor(energy=value, pol=pol)
         phase3 = phase * (-1 if pol == Pol.LA else 1)
         id_set_val = Apple2Val(
-            top_outer=f"{phase:.6f}",
-            top_inner="0.0",
-            btm_inner=f"{phase3:.6f}",
-            btm_outer="0.0",
             gap=f"{gap:.6f}",
+            phase=Apple2PhasesVal(
+                top_outer=f"{phase:.6f}",
+                top_inner="0.0",
+                btm_inner=f"{phase3:.6f}",
+                btm_outer="0.0",
+            ),
         )
 
         LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")
@@ -486,4 +192,4 @@ class LinearArbitraryAngle(StandardReadable, Movable[SupportsFloat]):
 
     @AsyncStatus.wrap
     async def set(self, angle: float) -> None:
-        await self.linear_arbitrary_angle().set(angle)
+        await self.linear_arbitrary_angle().set(angle, timeout=MAXIMUM_MOVE_TIME)

dodal/devices/i17/i17_apple2.py

@@ -1,6 +1,7 @@
 from dodal.devices.apple2_undulator import (
     Apple2,
     Apple2Controller,
+    Apple2PhasesVal,
     Apple2Val,
     EnergyMotorConvertor,
 )
@@ -40,11 +41,13 @@ class I17Apple2Controller(Apple2Controller[Apple2]):
         pol = await self._check_and_get_pol_setpoint()
         gap, phase = self.energy_to_motor(energy=value, pol=pol)
         id_set_val = Apple2Val(
-            top_outer=f"{phase:.6f}",
-            top_inner="0.0",
-            btm_inner=f"{phase:.6f}",
-            btm_outer="0.0",
             gap=f"{gap:.6f}",
+            phase=Apple2PhasesVal(
+                top_outer=f"{phase:.6f}",
+                top_inner="0.0",
+                btm_inner=f"{phase:.6f}",
+                btm_outer="0.0",
+            ),
         )
 
         LOGGER.info(f"Setting polarisation to {pol}, with values: {id_set_val}")

dodal/devices/ipin.py

@@ -1,5 +1,22 @@
-from ophyd_async.core import StandardReadable, StandardReadableFormat
-from ophyd_async.epics.core import epics_signal_r
+from ophyd_async.core import StandardReadable, StandardReadableFormat, SubsetEnum
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+
+class IPinGain(SubsetEnum):
+    GAIN_10E3_LOW_NOISE = "10^3 low noise"
+    GAIN_10E4_LOW_NOISE = "10^4 low noise"
+    GAIN_10E5_LOW_NOISE = "10^5 low noise"
+    GAIN_10E6_LOW_NOISE = "10^6 low noise"
+    GAIN_10E7_LOW_NOISE = "10^7 low noise"
+    GAIN_10E8_LOW_NOISE = "10^8 low noise"
+    GAIN_10E9_LOW_NOISE = "10^9 low noise"
+    GAIN_10E5_HIGH_SPEED = "10^5 high speed"
+    GAIN_10E6_HIGH_SPEED = "10^6 high speed"
+    GAIN_10E7_HIGH_SPEED = "10^7 high speed"
+    GAIN_10E8_HIGH_SPEED = "10^8 high speed"
+    GAIN_10E9_HIGH_SPEED = "10^9 high speed"
+    GAIN_10E10_HIGH_SPEED = "10^10 high spd"
+    GAIN_10E11_HIGH_SPEED = "10^11 high spd"
 
 
 class IPin(StandardReadable):
@@ -10,4 +27,5 @@ class IPin(StandardReadable):
             format=StandardReadableFormat.HINTED_SIGNAL
         ):
             self.pin_readback = epics_signal_r(float, prefix + "I")
+            self.gain = epics_signal_rw(IPinGain, prefix + "GAIN")
         super().__init__(name)

dodal/devices/motors.py

@@ -7,6 +7,8 @@ from ophyd_async.epics.motor import Motor
 
 _X, _Y, _Z = "X", "Y", "Z"
 
+_OMEGA = "OMEGA"
+
 
 class Stage(StandardReadable, ABC):
     """
@@ -77,6 +79,21 @@ class XYZThetaStage(XYZStage):
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
+class XYZOmegaStage(XYZStage):
+    def __init__(
+        self,
+        prefix: str,
+        name: str = "",
+        x_infix: str = _X,
+        y_infix: str = _Y,
+        z_infix: str = _Z,
+        omega_infix: str = _OMEGA,
+    ) -> None:
+        with self.add_children_as_readables():
+            self.omega = Motor(prefix + omega_infix)
+        super().__init__(prefix, name, x_infix, y_infix, z_infix)
+
+
 class XYPhiStage(XYStage):
     def __init__(
         self,
@@ -141,7 +158,7 @@ class XYZPitchYawRollStage(XYZStage):
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
 
-class SixAxisGonio(XYZStage):
+class SixAxisGonio(XYZOmegaStage):
     def __init__(
         self,
         prefix: str,
@@ -151,7 +168,7 @@ class SixAxisGonio(XYZStage):
         z_infix: str = _Z,
         kappa_infix: str = "KAPPA",
         phi_infix: str = "PHI",
-        omega_infix: str = "OMEGA",
+        omega_infix: str = _OMEGA,
     ):
         """Six-axis goniometer with a standard xyz stage and three axes of rotation:
         kappa, phi and omega.
@@ -159,7 +176,6 @@ class SixAxisGonio(XYZStage):
         with self.add_children_as_readables():
             self.kappa = Motor(prefix + kappa_infix)
             self.phi = Motor(prefix + phi_infix)
-            self.omega = Motor(prefix + omega_infix)
         super().__init__(prefix, name, x_infix, y_infix, z_infix)
 
         self.vertical_in_lab_space = create_axis_perp_to_rotation(

dodal/devices/mx_phase1/beamstop.py

@@ -10,6 +10,8 @@ from ophyd_async.epics.motor import Motor
 
 from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
 
+_BEAMSTOP_OUT_DELTA_Y_MM = -2
+
 
 class BeamstopPositions(StrictEnum):
     """
@@ -28,6 +30,7 @@ class BeamstopPositions(StrictEnum):
     """
 
     DATA_COLLECTION = "Data Collection"
+    OUT_OF_BEAM = "Out"
     UNKNOWN = "Unknown"
 
 
@@ -63,6 +66,10 @@ class Beamstop(StandardReadable):
             float(beamline_parameters[f"in_beam_{axis}_STANDARD"])
             for axis in ("x", "y", "z")
         ]
+
+        self._out_of_beam_xyz_mm = list(self._in_beam_xyz_mm)
+        self._out_of_beam_xyz_mm[1] += _BEAMSTOP_OUT_DELTA_Y_MM
+
         self._xyz_tolerance_mm = [
             float(beamline_parameters[f"bs_{axis}_tolerance"])
             for axis in ("x", "y", "z")
@@ -72,24 +79,36 @@ class Beamstop(StandardReadable):
 
     def _get_selected_position(self, x: float, y: float, z: float) -> BeamstopPositions:
         current_pos = [x, y, z]
-        if all(
-            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
-            for axis_pos, axis_in_beam, axis_tolerance in zip(
-                current_pos, self._in_beam_xyz_mm, self._xyz_tolerance_mm, strict=False
-            )
-        ):
+        if self._is_near_position(current_pos, self._in_beam_xyz_mm):
             return BeamstopPositions.DATA_COLLECTION
+        elif self._is_near_position(current_pos, self._out_of_beam_xyz_mm):
+            return BeamstopPositions.OUT_OF_BEAM
         else:
             return BeamstopPositions.UNKNOWN
 
+    def _is_near_position(
+        self, current_pos: list[float], target_pos: list[float]
+    ) -> bool:
+        return all(
+            isclose(axis_pos, axis_in_beam, abs_tol=axis_tolerance)
+            for axis_pos, axis_in_beam, axis_tolerance in zip(
+                current_pos, target_pos, self._xyz_tolerance_mm, strict=False
+            )
+        )
+
     async def _set_selected_position(self, position: BeamstopPositions) -> None:
         match position:
             case BeamstopPositions.DATA_COLLECTION:
-                # Move z first as it could be under the table
-                await self.z_mm.set(self._in_beam_xyz_mm[2])
-                await asyncio.gather(
-                    self.x_mm.set(self._in_beam_xyz_mm[0]),
-                    self.y_mm.set(self._in_beam_xyz_mm[1]),
-                )
+                await self._safe_move_above_table(self._in_beam_xyz_mm)
+            case BeamstopPositions.OUT_OF_BEAM:
+                await self._safe_move_above_table(self._out_of_beam_xyz_mm)
             case _:
                 raise ValueError(f"Cannot set beamstop to position {position}")
+
+    async def _safe_move_above_table(self, pos: list[float]):
+        # Move z first as it could be under the table
+        await self.z_mm.set(pos[2])
+        await asyncio.gather(
+            self.x_mm.set(pos[0]),
+            self.y_mm.set(pos[1]),
+        )

dodal/devices/oav/oav_calculations.py

@@ -7,6 +7,9 @@ def camera_coordinates_to_xyz_mm(
     omega: float,
     microns_per_i_pixel: float,
     microns_per_j_pixel: float,
+    x_horizontal_sign: int,
+    y_vertical_sign: int,
+    z_vertical_sign: int,
 ) -> np.ndarray:
     """
     Converts from (horizontal,vertical) pixel measurements from the OAV camera into to (x, y, z) motor coordinates in millimetres.
@@ -18,13 +21,16 @@ def camera_coordinates_to_xyz_mm(
         omega (float): The omega angle of the smargon that the horizontal, vertical measurements were obtained at.
         microns_per_i_pixel (float): The number of microns per i pixel, adjusted for the zoom level horizontal was measured at.
         microns_per_j_pixel (float): The number of microns per j pixel, adjusted for the zoom level vertical was measured at.
+        x_horizontal_sign (int): Direction mapping for x, positive means the oav and motor are on same direction, default from hyperion
+        y_vertical_sign (int): Direction mapping for y
+        z_vertical_sign (int): Direction mapping for z
     """
     # Convert the vertical and horizontal into mm.
     horizontal *= microns_per_i_pixel * 1e-3
     vertical *= microns_per_j_pixel * 1e-3
 
     # +ve x in the OAV camera becomes -ve x in the smargon motors.
-    x = -horizontal
+    x = x_horizontal_sign * horizontal
 
     # Rotating the camera causes the position on the vertical horizontal to change by raising or lowering the centre.
     # We can negate this change by multiplying sin and cosine of the omega.
@@ -33,9 +39,8 @@ def camera_coordinates_to_xyz_mm(
     sine = np.sin(radians)
 
     # +ve y in the OAV camera becomes -ve y in the smargon motors/
-    y = -vertical * cosine
-
-    z = vertical * sine
+    y = y_vertical_sign * vertical * cosine
+    z = z_vertical_sign * vertical * sine
     return np.array([x, y, z], dtype=np.float64)