dls-dodal 1.51.0__py3-none-any.whl → 1.53.0__py3-none-any.whl

dodal/devices/b07_1/enums.py

@@ -0,0 +1,18 @@
+from ophyd_async.core import StrictEnum, SupersetEnum
+
+
+class Grating(StrictEnum):
+    AU_400 = "400 l/mm Au"
+    AU_600 = "600 l/mm Au"
+    PT_600 = "600 l/mm Pt"
+    AU_1200 = "1200 l/mm Au"
+    ML_1200 = "1200 l/mm ML"
+    NO_GRATING = "No Grating"
+
+
+class LensMode(SupersetEnum):
+    SMALL_AREA = "SmallArea"
+    ANGLE_RESOLVED_MODE_22 = "AngleResolvedMode22"
+    ANGLE_RESOLVED_MODE_30 = "AngleResolvedMode30"
+    LARGE_AREA = "LargeArea"
+    NOT_CONNECTED = "Not connected"

dodal/devices/electron_analyser/abstract/__init__.py

@@ -8,6 +8,8 @@ from .base_region import (
     AbstractBaseSequence,
     TAbstractBaseRegion,
     TAbstractBaseSequence,
+    TAcquisitionMode,
+    TLensMode,
 )
 
 __all__ = [
@@ -15,6 +17,8 @@ __all__ = [
     "AbstractBaseSequence",
     "TAbstractBaseRegion",
     "TAbstractBaseSequence",
+    "TAcquisitionMode",
+    "TLensMode",
     "AbstractAnalyserDriverIO",
     "AbstractElectronAnalyserDetector",
     "AbstractAnalyserDriverIO",

dodal/devices/electron_analyser/abstract/base_driver_io.py

@@ -11,7 +11,6 @@ from ophyd_async.core import (
     SignalR,
     StandardReadable,
     StandardReadableFormat,
-    StrictEnum,
     derived_signal_r,
     soft_signal_rw,
 )
@@ -20,6 +19,8 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     TAbstractBaseRegion,
+    TAcquisitionMode,
+    TLensMode,
 )
 from dodal.devices.electron_analyser.enums import EnergyMode
 from dodal.devices.electron_analyser.util import to_binding_energy, to_kinetic_energy
@@ -30,7 +31,7 @@ class AbstractAnalyserDriverIO(
     StandardReadable,
     ADBaseIO,
     Movable[TAbstractBaseRegion],
-    Generic[TAbstractBaseRegion],
+    Generic[TAbstractBaseRegion, TAcquisitionMode, TLensMode],
 ):
     """
     Generic device to configure electron analyser with new region settings.
@@ -40,11 +41,27 @@ class AbstractAnalyserDriverIO(
     def __init__(
         self,
         prefix: str,
-        acquisition_mode_type: type[StrictEnum],
+        acquisition_mode_type: type[TAcquisitionMode],
+        lens_mode_type: type[TLensMode],
         energy_sources: Mapping[str, SignalR[float]],
         name: str = "",
     ) -> None:
+        """
+        Constructor method for setting up electron analyser.
+
+        Args:
+            prefix: Base PV to connect to EPICS for this device.
+            acquisition_mode_type: Enum that determines the available acquisition modes
+                                   for this device.
+            lens_mode_type: Enum that determines the available lens mode for this
+                            device.
+            energy_sources: Map that pairs a source name to an energy value signal
+                            (in eV).
+            name: Name of the device.
+        """
         self.energy_sources = energy_sources
+        self.acquisition_mode_type = acquisition_mode_type
+        self.lens_mode_type = lens_mode_type
 
         with self.add_children_as_readables():
             self.image = epics_signal_r(Array1D[np.float64], prefix + "IMAGE")
@@ -63,7 +80,7 @@ class AbstractAnalyserDriverIO(
             self.low_energy = epics_signal_rw(float, prefix + "LOW_ENERGY")
             self.high_energy = epics_signal_rw(float, prefix + "HIGH_ENERGY")
             self.slices = epics_signal_rw(int, prefix + "SLICES")
-            self.lens_mode = epics_signal_rw(str, prefix + "LENS_MODE")
+            self.lens_mode = epics_signal_rw(lens_mode_type, prefix + "LENS_MODE")
             self.pass_energy = epics_signal_rw(
                 self.pass_energy_type, prefix + "PASS_ENERGY"
             )

dodal/devices/electron_analyser/abstract/base_region.py

@@ -3,13 +3,11 @@ from abc import ABC
 from collections.abc import Callable
 from typing import Generic, TypeVar
 
-from ophyd_async.core import StrictEnum
+from ophyd_async.core import StrictEnum, SupersetEnum
 from pydantic import BaseModel, Field, model_validator
 
 from dodal.devices.electron_analyser.enums import EnergyMode
 
-TStrictEnum = TypeVar("TStrictEnum", bound=StrictEnum)
-
 
 def java_to_python_case(java_str: str) -> str:
     """
@@ -46,7 +44,18 @@ def energy_mode_validation(data: dict) -> dict:
     return data
 
 
-class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
+TAcquisitionMode = TypeVar("TAcquisitionMode", bound=StrictEnum)
+# Allow SupersetEnum. Specs analysers can connect to Lens mode separately to the
+# analyser which leaves the enum to either be "Not connected" OR the available enums
+# when connected.
+TLensMode = TypeVar("TLensMode", bound=SupersetEnum | StrictEnum)
+
+
+class AbstractBaseRegion(
+    ABC,
+    JavaToPythonModel,
+    Generic[TAcquisitionMode, TLensMode],
+):
     """
     Generic region model that holds the data. Specialised region models should inherit
     this to extend functionality. All energy units are assumed to be in eV.
@@ -58,9 +67,9 @@ class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
     iterations: int = 1
     excitation_energy_source: str = "source1"
     # These ones we need subclasses to provide default values
-    lens_mode: str
+    lens_mode: TLensMode
     pass_energy: int
-    acquisition_mode: TStrictEnum
+    acquisition_mode: TAcquisitionMode
     low_energy: float
     high_energy: float
     step_time: float
@@ -83,7 +92,11 @@ class AbstractBaseRegion(ABC, JavaToPythonModel, Generic[TStrictEnum]):
 TAbstractBaseRegion = TypeVar("TAbstractBaseRegion", bound=AbstractBaseRegion)
 
 
-class AbstractBaseSequence(ABC, JavaToPythonModel, Generic[TAbstractBaseRegion]):
+class AbstractBaseSequence(
+    ABC,
+    JavaToPythonModel,
+    Generic[TAbstractBaseRegion, TLensMode],
+):
     """
     Generic sequence model that holds the list of region data. Specialised sequence
     models should inherit this to extend functionality and define type of region to

dodal/devices/electron_analyser/detector.py

@@ -48,7 +48,7 @@ class ElectronAnalyserRegionDetector(
     async def trigger(self) -> None:
         # Configure region parameters on the driver first before data collection.
         await self.driver.set(self.region)
-        super().trigger()
+        await super().trigger()
 
 
 TElectronAnalyserRegionDetector = TypeVar(

dodal/devices/electron_analyser/specs/detector.py

@@ -1,7 +1,9 @@
 from collections.abc import Mapping
+from typing import Generic
 
 from ophyd_async.core import SignalR
 
+from dodal.devices.electron_analyser.abstract.base_driver_io import TLensMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -10,10 +12,22 @@ from dodal.devices.electron_analyser.specs.region import SpecsRegion, SpecsSeque
 
 
 class SpecsDetector(
-    ElectronAnalyserDetector[SpecsAnalyserDriverIO, SpecsSequence, SpecsRegion]
+    ElectronAnalyserDetector[
+        SpecsAnalyserDriverIO[TLensMode],
+        SpecsSequence[TLensMode],
+        SpecsRegion[TLensMode],
+    ],
+    Generic[TLensMode],
 ):
     def __init__(
-        self, prefix: str, energy_sources: Mapping[str, SignalR[float]], name: str = ""
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
     ):
-        driver = SpecsAnalyserDriverIO(prefix, energy_sources)
-        super().__init__(SpecsSequence, driver, name)
+        driver = SpecsAnalyserDriverIO[TLensMode](
+            prefix, lens_mode_type, energy_sources
+        )
+        seq = SpecsSequence[lens_mode_type]
+        super().__init__(seq, driver, name)

dodal/devices/electron_analyser/specs/driver_io.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections.abc import Mapping
+from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
@@ -14,13 +15,21 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.abstract.base_region import TLensMode
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 from dodal.devices.electron_analyser.specs.region import SpecsRegion
 
 
-class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
+class SpecsAnalyserDriverIO(
+    AbstractAnalyserDriverIO[SpecsRegion, AcquisitionMode, TLensMode],
+    Generic[TLensMode],
+):
     def __init__(
-        self, prefix: str, energy_sources: Mapping[str, SignalR[float]], name: str = ""
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
@@ -31,11 +40,14 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             # Used to read detector data after acqusition.
             self.min_angle_axis = epics_signal_r(float, prefix + "Y_MIN_RBV")
             self.max_angle_axis = epics_signal_r(float, prefix + "Y_MAX_RBV")
+            self.energy_channels = epics_signal_r(
+                int, prefix + "TOTAL_POINTS_ITERATION_RBV"
+            )
 
-        super().__init__(prefix, AcquisitionMode, energy_sources, name)
+        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
 
     @AsyncStatus.wrap
-    async def set(self, region: SpecsRegion):
+    async def set(self, region: SpecsRegion[TLensMode]):
         await super().set(region)
 
         await asyncio.gather(
@@ -73,7 +85,7 @@ class SpecsAnalyserDriverIO(AbstractAnalyserDriverIO[SpecsRegion]):
             "eV",
             min_energy=self.low_energy,
             max_energy=self.high_energy,
-            total_points_iterations=self.slices,
+            total_points_iterations=self.energy_channels,
         )
         return energy_axis
 

dodal/devices/electron_analyser/specs/region.py

@@ -1,15 +1,18 @@
+from typing import Generic
+
 from pydantic import Field
 
 from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
+    TLensMode,
 )
 from dodal.devices.electron_analyser.specs.enums import AcquisitionMode
 
 
-class SpecsRegion(AbstractBaseRegion[AcquisitionMode]):
+class SpecsRegion(AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]):
     # Override base class with defaults
-    lens_mode: str = "SmallArea"
+    lens_mode: TLensMode
     pass_energy: int = 5
     acquisition_mode: AcquisitionMode = AcquisitionMode.FIXED_TRANSMISSION
     low_energy: float = Field(default=800, alias="start_energy")
@@ -19,9 +22,10 @@ class SpecsRegion(AbstractBaseRegion[AcquisitionMode]):
     # Specific to this class
     values: int = 1
     centre_energy: float = 0
-    psu_mode: str = "1.5keV"
+    # ToDo - Update to an enum https://github.com/DiamondLightSource/dodal/issues/1328
+    psu_mode: str = "1.5kV"
     estimated_time_in_ms: float = 0
 
 
-class SpecsSequence(AbstractBaseSequence[SpecsRegion]):
-    regions: list[SpecsRegion] = Field(default_factory=lambda: [])
+class SpecsSequence(AbstractBaseSequence[SpecsRegion, TLensMode], Generic[TLensMode]):
+    regions: list[SpecsRegion[TLensMode]] = Field(default_factory=lambda: [])

dodal/devices/electron_analyser/types.py

@@ -1,3 +1,5 @@
+from ophyd_async.core import StrictEnum, SupersetEnum
+
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
@@ -18,15 +20,29 @@ from dodal.devices.electron_analyser.vgscienta.detector import (
     VGScientaDetector,
 )
 
-ElectronAnalyserDetectorImpl = VGScientaDetector | SpecsDetector
-ElectronAnalyserDriverImpl = VGScientaAnalyserDriverIO | SpecsAnalyserDriverIO
+AnyAcqMode = StrictEnum
+AnyLensMode = SupersetEnum | StrictEnum
+
+# Electron analyser types that encompasses all implementations, useful for tests and
+# plans
+ElectronAnalyserDetectorImpl = (
+    VGScientaDetector[AnyLensMode] | SpecsDetector[AnyLensMode]
+)
+ElectronAnalyserDriverImpl = (
+    VGScientaAnalyserDriverIO[AnyLensMode] | SpecsAnalyserDriverIO[AnyLensMode]
+)
 
+# Short hand the type so less verbose
+AbstractBaseRegion = AbstractBaseRegion[AnyAcqMode, AnyLensMode]
+
+# Generic electron analyser types that supports full typing with the abstract classes.
 GenericElectronAnalyserDetector = ElectronAnalyserDetector[
-    AbstractAnalyserDriverIO[AbstractBaseRegion],
-    AbstractBaseSequence,
+    AbstractAnalyserDriverIO[AbstractBaseRegion, AnyAcqMode, AnyLensMode],
+    AbstractBaseSequence[AbstractBaseRegion, AnyLensMode],
     AbstractBaseRegion,
 ]
 
 GenericElectronAnalyserRegionDetector = ElectronAnalyserRegionDetector[
-    AbstractAnalyserDriverIO[AbstractBaseRegion], AbstractBaseRegion
+    AbstractAnalyserDriverIO[AbstractBaseRegion, AnyAcqMode, AnyLensMode],
+    AbstractBaseRegion,
 ]

dodal/devices/electron_analyser/vgscienta/detector.py

@@ -1,7 +1,9 @@
 from collections.abc import Mapping
+from typing import Generic
 
 from ophyd_async.core import SignalR
 
+from dodal.devices.electron_analyser.abstract.base_region import TLensMode
 from dodal.devices.electron_analyser.detector import (
     ElectronAnalyserDetector,
 )
@@ -16,13 +18,20 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 
 class VGScientaDetector(
     ElectronAnalyserDetector[
-        VGScientaAnalyserDriverIO,
-        VGScientaSequence,
-        VGScientaRegion,
-    ]
+        VGScientaAnalyserDriverIO[TLensMode],
+        VGScientaSequence[TLensMode],
+        VGScientaRegion[TLensMode],
+    ],
+    Generic[TLensMode],
 ):
     def __init__(
-        self, prefix: str, energy_sources: Mapping[str, SignalR], name: str = ""
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
     ):
-        driver = VGScientaAnalyserDriverIO(prefix, energy_sources)
-        super().__init__(VGScientaSequence, driver, name)
+        driver = VGScientaAnalyserDriverIO[TLensMode](
+            prefix, lens_mode_type, energy_sources
+        )
+        super().__init__(VGScientaSequence[lens_mode_type], driver, name)

dodal/devices/electron_analyser/vgscienta/driver_io.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections.abc import Mapping
+from typing import Generic
 
 import numpy as np
 from ophyd_async.core import (
@@ -14,6 +15,7 @@ from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 from dodal.devices.electron_analyser.abstract.base_driver_io import (
     AbstractAnalyserDriverIO,
 )
+from dodal.devices.electron_analyser.abstract.base_region import TLensMode
 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 (
@@ -22,9 +24,16 @@ from dodal.devices.electron_analyser.vgscienta.region import (
 )
 
 
-class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
+class VGScientaAnalyserDriverIO(
+    AbstractAnalyserDriverIO[VGScientaRegion, AcquisitionMode, TLensMode],
+    Generic[TLensMode],
+):
     def __init__(
-        self, prefix: str, energy_sources: Mapping[str, SignalR[float]], name: str = ""
+        self,
+        prefix: str,
+        lens_mode_type: type[TLensMode],
+        energy_sources: Mapping[str, SignalR[float]],
+        name: str = "",
     ) -> None:
         with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
             # Used for setting up region data acquisition.
@@ -35,10 +44,10 @@ class VGScientaAnalyserDriverIO(AbstractAnalyserDriverIO[VGScientaRegion]):
             self.y_channel_size = epics_signal_rw(int, prefix + "SizeY")
             self.detector_mode = epics_signal_rw(DetectorMode, prefix + "DETECTOR_MODE")
 
-        super().__init__(prefix, AcquisitionMode, energy_sources, name)
+        super().__init__(prefix, AcquisitionMode, lens_mode_type, energy_sources, name)
 
     @AsyncStatus.wrap
-    async def set(self, region: VGScientaRegion):
+    async def set(self, region: VGScientaRegion[TLensMode]):
         await super().set(region)
 
         excitation_energy = await self.excitation_energy.get_value()

dodal/devices/electron_analyser/vgscienta/region.py

@@ -1,4 +1,5 @@
 import uuid
+from typing import Generic
 
 from pydantic import Field
 
@@ -6,6 +7,7 @@ from dodal.devices.electron_analyser.abstract.base_region import (
     AbstractBaseRegion,
     AbstractBaseSequence,
     JavaToPythonModel,
+    TLensMode,
 )
 from dodal.devices.electron_analyser.vgscienta.enums import (
     AcquisitionMode,
@@ -14,9 +16,11 @@ from dodal.devices.electron_analyser.vgscienta.enums import (
 )
 
 
-class VGScientaRegion(AbstractBaseRegion[AcquisitionMode]):
+class VGScientaRegion(
+    AbstractBaseRegion[AcquisitionMode, TLensMode], Generic[TLensMode]
+):
     # Override defaults of base region class
-    lens_mode: str = "Angular45"
+    lens_mode: TLensMode
     pass_energy: int = 5
     acquisition_mode: AcquisitionMode = AcquisitionMode.SWEPT
     low_energy: float = 8.0
@@ -48,15 +52,17 @@ class VGScientaExcitationEnergySource(JavaToPythonModel):
     value: float = 0
 
 
-class VGScientaSequence(AbstractBaseSequence[VGScientaRegion]):
+class VGScientaSequence(
+    AbstractBaseSequence[VGScientaRegion, TLensMode], Generic[TLensMode]
+):
     element_set: str = Field(default="Unknown")
     excitation_energy_sources: list[VGScientaExcitationEnergySource] = Field(
         default_factory=lambda: []
     )
-    regions: list[VGScientaRegion] = Field(default_factory=lambda: [])
+    regions: list[VGScientaRegion[TLensMode]] = Field(default_factory=lambda: [])
 
     def get_excitation_energy_source_by_region(
-        self, region: VGScientaRegion
+        self, region: VGScientaRegion[TLensMode]
     ) -> VGScientaExcitationEnergySource:
         value = next(
             (

dodal/devices/i09/__init__.py

@@ -1,4 +1,4 @@
 from dodal.devices.i09.dcm import DCM
-from dodal.devices.i09.grating import I09Grating
+from dodal.devices.i09.enums import Grating, LensMode
 
-__all__ = ["DCM", "I09Grating"]
+__all__ = ["DCM", "Grating", "LensMode"]

dodal/devices/i09/enums.py

@@ -0,0 +1,15 @@
+from ophyd_async.core import StrictEnum
+
+
+class Grating(StrictEnum):
+    G_300 = "300 lines/mm"
+    G_400 = "400 lines/mm"
+    G_800 = "800 lines/mm"
+
+
+class LensMode(StrictEnum):
+    TRANSMISSION = "Transmission"
+    ANGULAR45 = "Angular45"
+    ANGULAR60 = "Angular60"
+    ANGULAR56 = "Angular56"
+    ANGULAR45VUV = "Angular45VUV"

dodal/devices/i09_1/__init__.py

@@ -0,0 +1,3 @@
+from .enums import LensMode
+
+__all__ = ["LensMode"]

dodal/devices/i09_1/enums.py

@@ -0,0 +1,19 @@
+from ophyd_async.core import SupersetEnum
+
+
+class LensMode(SupersetEnum):
+    LARGE_AREA = "LargeArea"
+    MEDIUM_ANGULAR_DISPERSION = "MediumAngularDispersion"
+    MEDIUM_AREA = "MediumArea"
+    SMALL_AREA = "SmallArea"
+    HIGH_MAGNIFICATION = "HighMagnification"
+    LOW_ANGULAR_DISPERSION = "LowAngularDispersion"
+    LOW_ANGULAR_DISPERSION2 = "LowAngularDispersion2"
+    HIGH_ANGULAR_DISPERSION = "HighAngularDispersion"
+    WIDE_ANGLE_MODE = "WideAngleMode"
+    MEDIUM_ANGLE_MODE = "MediumAngleMode"
+    MEDIUM_MAGNIFICATION = "MediumMagnification"
+    LOW_MAGNIFICATION = "LowMagnification"
+    HIGH_MAGNIFICATION2 = "HighMagnification2"
+    RAMP_MODE = "RampMode"
+    NOT_CONNECTED = "Not connected"

dodal/devices/linkam3.py

@@ -1,14 +1,7 @@
-import asyncio
-import time
-
-from bluesky.protocols import Location
 from ophyd_async.core import (
     StandardReadable,
     StandardReadableFormat,
     StrictEnum,
-    WatchableAsyncStatus,
-    WatcherUpdate,
-    observe_value,
 )
 from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
@@ -18,6 +11,8 @@ class PumpControl(StrictEnum):
     AUTO = "Auto"
 
 
+# TODO: Make use of Status PV:
+# https://github.com/DiamondLightSource/dodal/issues/338
 class Linkam3(StandardReadable):
     """Device to represent a Linkam3 temperature controller
 
@@ -34,81 +29,30 @@ class Linkam3(StandardReadable):
     settle_time: int = 0
 
     def __init__(self, prefix: str, name: str = ""):
-        self.temp = epics_signal_r(float, prefix + "TEMP:")
-        self.dsc = epics_signal_r(float, prefix + "DSC:")
-        self.start_heat = epics_signal_rw(bool, prefix + "STARTHEAT:")
-
-        self.ramp_rate = epics_signal_rw(
-            float, prefix + "RAMPRATE:", prefix + "RAMPRATE:SET:"
-        )
-        self.ramp_time = epics_signal_r(float, prefix + "RAMPTIME:")
-        self.set_point = epics_signal_rw(
-            float, prefix + "SETPOINT:", prefix + "SETPOINT:SET:"
-        )
-        self.pump_control = epics_signal_r(
-            PumpControl,
-            prefix + "LNP_MODE:SET:",
-        )
-        self.speed = epics_signal_rw(
-            float, prefix + "LNP_SPEED:", prefix + "LNP_SPEED:SET:"
-        )
-
-        self.chamber_vac = epics_signal_r(float, prefix + "VAC_CHAMBER:")
-        self.sensor_vac = epics_signal_r(float, prefix + "VAC_DATA1:")
-
-        self.error = epics_signal_r(str, prefix + "CTRLLR:ERR:")
-
-        # status is a bitfield stored in a double?
-        self.status = epics_signal_r(float, prefix + "STATUS:")
-
-        self.add_readables((self.temp,), format=StandardReadableFormat.HINTED_SIGNAL)
-        self.add_readables(
-            (self.ramp_rate, self.speed, self.set_point),
-            format=StandardReadableFormat.CONFIG_SIGNAL,
-        )
-
-        super().__init__(name=name)
-
-    @WatchableAsyncStatus.wrap
-    async def set(self, new_position: float, timeout: float | None = None):
-        # time.monotonic won't go backwards in case of NTP corrections
-        start = time.monotonic()
-        old_position = await self.set_point.get_value()
-        await self.set_point.set(new_position, wait=True)
-        async for current_position in observe_value(self.temp):
-            yield WatcherUpdate(
-                name=self.name,
-                current=current_position,
-                initial=old_position,
-                target=new_position,
-                time_elapsed=time.monotonic() - start,
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.temp = epics_signal_r(float, prefix + "TEMP")
+        with self.add_children_as_readables():
+            self.dsc = epics_signal_r(float, prefix + "DSC")
+            self.start_heat = epics_signal_rw(bool, prefix + "STARTHEAT")
+
+            self.ramp_rate = epics_signal_rw(
+                float, prefix + "RAMPRATE", prefix + "RAMPRATE:SET"
+            )
+            self.ramp_time = epics_signal_r(float, prefix + "RAMPTIME")
+            self.set_point = epics_signal_rw(
+                float, prefix + "SETPOINT", prefix + "SETPOINT:SET"
+            )
+            self.pump_control = epics_signal_r(
+                PumpControl,
+                prefix + "LNP_MODE:SET",
+            )
+            self.speed = epics_signal_rw(
+                float, prefix + "LNP_SPEED", prefix + "LNP_SPEED:SET"
             )
-            if abs(current_position - new_position) < self.tolerance:
-                await asyncio.sleep(self.settle_time)
-                break
-
-    # TODO: Make use of values in Status.
-    # https://github.com/DiamondLightSource/dodal/issues/338
-    async def _is_nth_bit_set(self, n: int) -> bool:
-        return bool(int(await self.status.get_value()) & 1 << n)
-
-    async def in_error(self) -> bool:
-        return await self._is_nth_bit_set(0)
-
-    async def at_setpoint(self) -> bool:
-        return await self._is_nth_bit_set(1)
-
-    async def heater_on(self) -> bool:
-        return await self._is_nth_bit_set(2)
 
-    async def pump_on(self) -> bool:
-        return await self._is_nth_bit_set(3)
+            self.chamber_vac = epics_signal_r(float, prefix + "VAC_CHAMBER")
+            self.sensor_vac = epics_signal_r(float, prefix + "VAC_DATA1")
 
-    async def pump_auto(self) -> bool:
-        return await self._is_nth_bit_set(4)
+            self.error = epics_signal_r(str, prefix + "CTRLLR:ERR")
 
-    async def locate(self) -> Location:
-        return {
-            "readback": await self.temp.get_value(),
-            "setpoint": await self.set_point.get_value(),
-        }
+        super().__init__(name=name)