Add i06-1 magnets

src/dodal/beamlines/i06_1.py

@@ -2,6 +2,10 @@
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.device_manager import DeviceManager
 from dodal.devices.beamlines.i06_1 import DiffractionDichroism
+from dodal.devices.beamlines.i06_1.magnets import (
+    MagnetThreeAxesRampRateController,
+    SuperConductingMagnetController,
+)
 from dodal.devices.motors import XYThetaStage
 from dodal.devices.temperture_controller import Lakeshore336
 from dodal.log import set_beamline as set_log_beamline
@@ -17,12 +21,12 @@
 
 
 @devices.factory()
-def diff_cooling_temperature_controller() -> Lakeshore336:
+def ls336_cooling() -> Lakeshore336:
     return Lakeshore336(prefix=f"{PREFIX.beamline_prefix}-EA-TCTRL-02:")
 
 
 @devices.factory()
-def diff_heating_temperature_controller() -> Lakeshore336:
+def ls336_heating() -> Lakeshore336:
     return Lakeshore336(prefix=f"{PREFIX.beamline_prefix}-EA-TCTRL-03:")
 
 
@@ -34,3 +38,17 @@ def xabs() -> XYThetaStage:
 @devices.factory()
 def dd() -> DiffractionDichroism:
     return DiffractionDichroism(f"{PREFIX.beamline_prefix}-EA-DDIFF-01:")
+
+
+@devices.factory()
+def mag_ramp_rate() -> MagnetThreeAxesRampRateController:
+    return MagnetThreeAxesRampRateController(f"{PREFIX.beamline_prefix}-EA-SMC")
+
+
+@devices.factory()
+def scmc(
+    mag_ramp_rate: MagnetThreeAxesRampRateController,
+) -> SuperConductingMagnetController:
+    return SuperConductingMagnetController(
+        f"{PREFIX.beamline_prefix}-EA-MAG-01:", mag_ramp_rate
+    )

src/dodal/devices/beamlines/i06_1/magnets/__init__.py

@@ -0,0 +1,35 @@
+from .coordinates import (
+    MagnetPosition,
+    MagnetRequest,
+    MagnetSphericalPosition,
+    MagnetSphericalRequest,
+)
+from .movement import MagnetPositionError
+from .ramp_controller import (
+    MagnetAxisRampRateController,
+    MagnetThreeAxesRampRateController,
+)
+from .superconducting_magnet import (
+    FlyMagnetInfo,
+    MagnetAxis,
+    MagnetLimitStatus,
+    MagnetMode,
+    MagnetRampStatus,
+    SuperConductingMagnetController,
+)
+
+__all__ = [
+    "MagnetPosition",
+    "MagnetSphericalPosition",
+    "MagnetSphericalRequest",
+    "MagnetRequest",
+    "MagnetPositionError",
+    "MagnetAxisRampRateController",
+    "MagnetThreeAxesRampRateController",
+    "FlyMagnetInfo",
+    "MagnetAxis",
+    "MagnetLimitStatus",
+    "MagnetMode",
+    "MagnetRampStatus",
+    "SuperConductingMagnetController",
+]

src/dodal/devices/beamlines/i06_1/magnets/coordinates.py

@@ -0,0 +1,93 @@
+import math
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True)
+class MagnetPosition:
+    x: float
+    y: float
+    z: float
+
+    @staticmethod
+    def calc_theta(x: float, z: float) -> float:
+        theta = math.degrees(math.atan2(-x, z))
+        return theta % 360
+
+    @staticmethod
+    def calc_rho(x: float, y: float, z: float) -> float:
+        return math.hypot(x, y, z)
+
+    @staticmethod
+    def calc_phi(x: float, y: float, z: float) -> float:
+        return math.degrees(math.atan2(math.hypot(x, z), y))
+
+    def to_spherical(self) -> "MagnetSphericalPosition":
+        return MagnetSphericalPosition(
+            rho=self.calc_rho(self.x, self.y, self.z),
+            theta=self.calc_theta(self.x, self.z),
+            phi=self.calc_phi(self.x, self.y, self.z),
+        )
+
+    @property
+    def field_magnitude(self) -> float:
+        return math.hypot(self.x, self.y, self.z)
+
+    def to_request_pos(self) -> "MagnetRequest":
+        return MagnetRequest(x=self.x, y=self.y, z=self.z)
+
+
+@dataclass(kw_only=True)
+class MagnetSphericalPosition:
+    rho: float
+    theta: float  # degrees
+    phi: float  # degrees
+
+    def to_cartesian(self) -> MagnetPosition:
+        theta = math.radians(self.theta)
+        phi = math.radians(self.phi)
+        return MagnetPosition(
+            x=-self.rho * math.sin(phi) * math.sin(theta),
+            y=self.rho * math.cos(phi),
+            z=self.rho * math.sin(phi) * math.cos(theta),
+        )
+
+    def to_request_pos(self) -> "MagnetSphericalRequest":
+        return MagnetSphericalRequest(rho=self.rho, theta=self.theta, phi=self.phi)
+
+
+@dataclass(frozen=True, kw_only=True)
+class MagnetRequest:
+    x: float | None = None
+    y: float | None = None
+    z: float | None = None
+
+    def __post_init__(self):
+        if self.x is None and self.y is None and self.z is None:
+            raise ValueError("At least one of x, y, or z must be specified.")
+
+    def resolve_pos(self, current: MagnetPosition) -> MagnetPosition:
+        """Resolve unspecified coordinates using the current position."""
+        return MagnetPosition(
+            x=current.x if self.x is None else self.x,
+            y=current.y if self.y is None else self.y,
+            z=current.z if self.z is None else self.z,
+        )
+
+
+@dataclass(frozen=True, kw_only=True)
+class MagnetSphericalRequest:
+    rho: float | None = None
+    theta: float | None = None
+    phi: float | None = None
+
+    def __post_init__(self):
+        if self.rho is None and self.theta is None and self.phi is None:
+            raise ValueError("At least one of rho, theta, or phi must be specified.")
+
+    def resolve_pos(self, current: MagnetSphericalPosition) -> MagnetSphericalPosition:
+        """Resolve unspecified coordinates using the current position."""
+        return MagnetSphericalPosition(
+            rho=current.rho if self.rho is None else self.rho,
+            theta=current.theta if self.theta is None else self.theta,
+            phi=current.phi if self.phi is None else self.phi,
+        )

src/dodal/devices/beamlines/i06_1/magnets/enums.py

@@ -0,0 +1,34 @@
+from ophyd_async.core import StrictEnum
+
+
+class MagnetMode(StrictEnum):
+    UNIAXIAL_X = "UNIAXIAL_X"
+    UNIAXIAL_Y = "UNIAXIAL_Y"
+    UNIAXIAL_Z = "UNIAXIAL_Z"
+    SPHERICAL = "SPHERICAL"
+    PLANAR_XZ = "PLANAR_XZ"
+    QUADRANT_XY = "QUADRANT_XY"
+    CUBIC = "CUBIC"
+    UNDEFINED = "UNDEFINED"
+
+    @property
+    def axis_alias(self) -> str:
+        match self:
+            case MagnetMode.UNIAXIAL_X:
+                return "x"
+            case MagnetMode.UNIAXIAL_Y:
+                return "y"
+            case MagnetMode.UNIAXIAL_Z:
+                return "z"
+            case _:
+                raise ValueError(f"{self} is not a valid uniaxial.")
+
+
+class MagnetRampStatus(StrictEnum):
+    RAMP_MADE = "RAMP MADE"
+    RAMPING = "RAMPING"
+
+
+class MagnetLimitStatus(StrictEnum):
+    OK = "OK"
+    VIOLATION = "VIOLATION"