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

dodal/devices/i04/murko_results.py

@@ -1,6 +1,5 @@
 import json
 import pickle
-from collections import OrderedDict
 from enum import Enum
 from typing import TypedDict
 
@@ -17,10 +16,11 @@ from redis.asyncio import StrictRedis
 from dodal.devices.i04.constants import RedisConstants
 from dodal.devices.oav.oav_calculations import (
     calculate_beam_distance,
-    camera_coordinates_to_xyz_mm,
 )
 from dodal.log import LOGGER
 
+NO_MURKO_RESULT = (-1, -1)
+
 MurkoResult = dict
 FullMurkoResults = dict[str, list[MurkoResult]]
 
@@ -43,12 +43,19 @@ class Coord(Enum):
 
 
 class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
-    """Device that takes crystal centre coords from Murko and uses them to set the
+    """Device that takes crystal centre values from Murko and uses them to set the
     x, y, z coordinate of the sample to be in line with the beam centre.
-    (x, z) coords can be read at 90°, and (x, y) at 180° (or the closest omega angle to
-    90° and 180°). The average of the x values at these angles is taken, and sin(omega)z
-    and cosine(omega)y are taken to account for the rotation. This value is used to
-    calculate a number of mm the sample needs to move to be in line with the beam centre.
+    The most_likely_click[1] value from Murko corresponds with the x coordinate of the
+    sample. The most_likely_click[0] value from Murko corresponds with a component of
+    the y and z coordinates of the sample, depending on the omega angle, as the sample
+    is rotated around the x axis.
+
+    Given a most_likely_click value at a certain omega angle θ:
+    most_likely_click[1] = x
+    most_likely_click[0] = cos(θ)y - sin(θ)z
+
+    A value for x can be found by averaging all most_likely_click[1] values, and
+    solutions for y and z can be calculated using numpy's linear algebra library.
     """
 
     TIMEOUT_S = 2
@@ -59,6 +66,7 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         redis_password=RedisConstants.REDIS_PASSWORD,
         redis_db=RedisConstants.MURKO_REDIS_DB,
         name="",
+        stop_angle=350,
     ):
         self.redis_client = StrictRedis(
             host=redis_host,
@@ -67,17 +75,11 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
         )
         self.pubsub = self.redis_client.pubsub()
         self._last_omega = 0
-        self._last_result = None
         self.sample_id = soft_signal_rw(str)  # Should get from redis
-        self.coords = {"x": {}, "y": {}, "z": {}}
-        self.search_angles = OrderedDict(
-            [  # Angles to search and dimensions to gather at each angle
-                (90, ("x", "z")),
-                (180, ("x", "y")),
-                (270, ()),  # Stop searching here
-            ]
-        )
-        self.angles_to_search = list(self.search_angles.keys())
+        self.stop_angle = stop_angle
+        self.x_dists_mm = []
+        self.y_dists_mm = []
+        self.omegas = []
 
         with self.add_children_as_readables():
             # Diffs from current x/y/z
@@ -101,95 +103,90 @@ class MurkoResultsDevice(StandardReadable, Triggerable, Stageable):
     async def trigger(self):
         # Wait for results
         sample_id = await self.sample_id.get_value()
-        final_message = None
-        while self.angles_to_search:
-            # waits here for next batch to be recieved
+        while self._last_omega < self.stop_angle:
+            # waits here for next batch to be received
             message = await self.pubsub.get_message(timeout=self.TIMEOUT_S)
             if message is None:  # No more messages to process
-                await self.process_batch(
-                    final_message, sample_id
-                )  # Process final message again
                 break
             await self.process_batch(message, sample_id)
-            final_message = message
-        x_values = list(self.coords["x"].values())
-        y_values = list(self.coords["y"].values())
-        z_values = list(self.coords["z"].values())
-        assert x_values, "No x values"
-        assert z_values, "No z values"
-        assert y_values, "No y values"
-        self._x_mm_setter(float(np.mean(x_values)))
-        self._y_mm_setter(float(np.mean(y_values)))
-        self._z_mm_setter(float(np.mean(z_values)))
+
+        for i in range(len(self.omegas)):
+            LOGGER.debug(
+                f"omega: {round(self.omegas[i], 2)}, x: {round(self.x_dists_mm[i], 2)}, y: {round(self.y_dists_mm[i], 2)}"
+            )
+
+        LOGGER.info(f"Using average of x beam distances: {self.x_dists_mm}")
+        avg_x = float(np.mean(self.x_dists_mm))
+        LOGGER.info(f"Finding least square y and z from y distances: {self.y_dists_mm}")
+        best_y, best_z = get_yz_least_squares(self.y_dists_mm, self.omegas)
+        # x, y, z are relative to beam centre. Need to move negative these values to get centred.
+        self._x_mm_setter(-avg_x)
+        self._y_mm_setter(-best_y)
+        self._z_mm_setter(-best_z)
 
     async def process_batch(self, message: dict | None, sample_id: str):
         if message and message["type"] == "message":
-            batch_results = pickle.loads(message["data"])
+            batch_results: list[dict] = pickle.loads(message["data"])
             for results in batch_results:
-                LOGGER.info(f"Got {results} from redis")
                 for uuid, result in results.items():
-                    metadata_str = await self.redis_client.hget(  # type: ignore
+                    if metadata_str := await self.redis_client.hget(  # type: ignore
                         f"murko:{sample_id}:metadata", uuid
-                    )
-                    if metadata_str and self.angles_to_search:
-                        self.process_result(result, uuid, metadata_str)
-
-    def process_result(
-        self, result: dict, uuid: int, metadata_str: str
-    ) -> float | None:
-        metadata = MurkoMetadata(json.loads(metadata_str))
-        omega_angle = metadata["omega_angle"]
-        LOGGER.info(f"Got angle {omega_angle}")
-        # Find closest to next search angle
-        movement = self.get_coords_if_at_angle(metadata, result, omega_angle)
-        if movement is not None:
-            LOGGER.info(f"Using result {uuid}, {metadata_str}, {result}")
-            search_angle = self.angles_to_search.pop(0)
-            for coord in self.search_angles[search_angle]:
-                self.coords[coord][omega_angle] = movement[Coord[coord].value]
-                LOGGER.info(f"Found {coord} at {movement}, angle = {omega_angle}")
-        self._last_omega = omega_angle
-        self._last_result = result
-
-    def get_coords_if_at_angle(
-        self, metadata: MurkoMetadata, result: MurkoResult, omega: float
-    ) -> np.ndarray | None:
-        """Gets the 'most_likely_click' coordinates from Murko if omega or the last
-        omega are the closest angle to the search angle. Otherwise returns None.
+                    ):
+                        LOGGER.info(
+                            f"Found metadata for uuid {uuid}, processing result"
+                        )
+                        self.process_result(
+                            result, MurkoMetadata(json.loads(metadata_str))
+                        )
+                    else:
+                        LOGGER.info(f"Found no metadata for uuid {uuid}")
+
+    def process_result(self, result: dict, metadata: MurkoMetadata):
+        """Uses the 'most_likely_click' coordinates from Murko to calculate the
+        horizontal and vertical distances from the beam centre, and store these values
+        as well as the omega angle the image was taken at.
         """
-        search_angle = self.angles_to_search[0]
-        LOGGER.info(f"Compare {omega}, {search_angle}, {self._last_omega}")
-        if (  # if last omega is closest
-            abs(omega - search_angle) >= abs(self._last_omega - search_angle)
-            and self._last_result is not None
-        ):
-            closest_result = self._last_result
-            closest_omega = self._last_omega
-        elif omega - search_angle >= 0:  # if this omega is closest
-            closest_result = result
-            closest_omega = omega
+        omega = metadata["omega_angle"]
+        coords = result["most_likely_click"]  # As proportion from top, left of image
+        LOGGER.info(f"Got most_likely_click: {coords} at angle {omega}")
+        if (
+            tuple(coords) == NO_MURKO_RESULT
+        ):  # See https://github.com/MartinSavko/murko/issues/9
+            LOGGER.info("Murko didn't produce a result, moving on")
         else:
-            return None
-        coords = closest_result[
-            "most_likely_click"
-        ]  # As proportion from top, left of image
-        shape = closest_result["original_shape"]  # Dimensions of image in pixels
-        # Murko returns coords as y, x
-        centre_px = (coords[1] * shape[1], coords[0] * shape[0])
-        LOGGER.info(
-            f"Using image taken at {closest_omega}, which found xtal at {centre_px}"
-        )
-
-        beam_dist_px = calculate_beam_distance(
-            (metadata["beam_centre_i"], metadata["beam_centre_j"]),
-            centre_px[0],
-            centre_px[1],
-        )
+            shape = result["original_shape"]  # Dimensions of image in pixels
+            # Murko returns coords as y, x
+            centre_px = (coords[1] * shape[1], coords[0] * shape[0])
+
+            beam_dist_px = calculate_beam_distance(
+                (metadata["beam_centre_i"], metadata["beam_centre_j"]),
+                centre_px[0],
+                centre_px[1],
+            )
+            self.x_dists_mm.append(
+                beam_dist_px[0] * metadata["microns_per_x_pixel"] / 1000
+            )
+            self.y_dists_mm.append(
+                beam_dist_px[1] * metadata["microns_per_y_pixel"] / 1000
+            )
+            self.omegas.append(omega)
+            self._last_omega = omega
+
+
+def get_yz_least_squares(vertical_dists: list, omegas: list) -> tuple[float, float]:
+    """Get the least squares solution for y and z from the vertical distances and omega angles.
+
+    Args:
+        v_dists (list): List of vertical distances from beam centre. Any units
+        omegas (list): List of omega angles in degrees.
+
+    Returns:
+        tuple[float, float]: y, z distances from centre, in whichever units
+        v_dists came as.
+    """
+    thetas = np.radians(omegas)
+    matrix = np.column_stack([np.cos(thetas), -np.sin(thetas)])
 
-        return camera_coordinates_to_xyz_mm(
-            beam_dist_px[0],
-            beam_dist_px[1],
-            closest_omega,
-            metadata["microns_per_x_pixel"],
-            metadata["microns_per_y_pixel"],
-        )
+    yz, residuals, rank, s = np.linalg.lstsq(matrix, vertical_dists, rcond=None)
+    y, z = yz
+    return y, z

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

dodal/devices/oav/oav_detector.py

@@ -5,14 +5,20 @@ from ophyd_async.core import (
     DEFAULT_TIMEOUT,
     AsyncStatus,
     LazyMock,
+    SignalR,
     StandardReadable,
     derived_signal_r,
     soft_signal_rw,
 )
-from ophyd_async.epics.core import epics_signal_rw
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.devices.areadetector.plugins.CAM import Cam
-from dodal.devices.oav.oav_parameters import DEFAULT_OAV_WINDOW, OAVConfig
+from dodal.devices.oav.oav_parameters import (
+    DEFAULT_OAV_WINDOW,
+    OAVConfig,
+    OAVConfigBase,
+    OAVConfigBeamCentre,
+)
 from dodal.devices.oav.snapshots.snapshot import Snapshot
 from dodal.devices.oav.snapshots.snapshot_with_grid import SnapshotWithGrid
 
@@ -53,7 +59,10 @@ class ZoomController(StandardReadable, Movable[str]):
 
 
 class OAV(StandardReadable):
-    def __init__(self, prefix: str, config: OAVConfig, name: str = ""):
+    beam_centre_i: SignalR[int]
+    beam_centre_j: SignalR[int]
+
+    def __init__(self, prefix: str, config: OAVConfigBase, name: str = ""):
         self.oav_config = config
         self._prefix = prefix
         self._name = name
@@ -79,18 +88,6 @@ class OAV(StandardReadable):
                 size=self.sizes[Coords.Y],
                 coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
             )
-            self.beam_centre_i = derived_signal_r(
-                self._get_beam_position,
-                zoom_level=self.zoom_controller.level,
-                size=self.sizes[Coords.X],
-                coord=soft_signal_rw(datatype=int, initial_value=Coords.X.value),
-            )
-            self.beam_centre_j = derived_signal_r(
-                self._get_beam_position,
-                zoom_level=self.zoom_controller.level,
-                size=self.sizes[Coords.Y],
-                coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
-            )
             self.snapshot = Snapshot(
                 f"{self._prefix}MJPG:",
                 self._name,
@@ -107,14 +104,6 @@ class OAV(StandardReadable):
         value = self.parameters[_zoom].microns_per_pixel[coord]
         return value * DEFAULT_OAV_WINDOW[coord] / size
 
-    def _get_beam_position(self, zoom_level: str, size: int, coord: int) -> int:
-        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
-        zoom level. """
-        _zoom = self._read_current_zoom(zoom_level)
-        value = self.parameters[_zoom].crosshair[coord]
-
-        return int(value * size / DEFAULT_OAV_WINDOW[coord])
-
     async def connect(
         self,
         mock: bool | LazyMock = False,
@@ -124,3 +113,52 @@ class OAV(StandardReadable):
         self.parameters = self.oav_config.get_parameters()
 
         return await super().connect(mock, timeout, force_reconnect)
+
+
+class OAVBeamCentreFile(OAV):
+    """OAV device that reads its beam centre values from a file. The config parameter
+    must be a OAVConfigBeamCentre object, as this contains a filepath to where the beam
+    centre values are stored.
+    """
+
+    def __init__(self, prefix: str, config: OAVConfigBeamCentre, name: str = ""):
+        super().__init__(prefix, config, name)
+
+        with self.add_children_as_readables():
+            self.beam_centre_i = derived_signal_r(
+                self._get_beam_position,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.X],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.X.value),
+            )
+            self.beam_centre_j = derived_signal_r(
+                self._get_beam_position,
+                zoom_level=self.zoom_controller.level,
+                size=self.sizes[Coords.Y],
+                coord=soft_signal_rw(datatype=int, initial_value=Coords.Y.value),
+            )
+        # Set name so that new child signals get correct name
+        self.set_name(self.name)
+
+    def _get_beam_position(self, zoom_level: str, size: int, coord: int) -> int:
+        """Extracts the beam location in pixels `xCentre` `yCentre`, for a requested \
+        zoom level. """
+        _zoom = self._read_current_zoom(zoom_level)
+        value = self.parameters[_zoom].crosshair[coord]
+        return int(value * size / DEFAULT_OAV_WINDOW[coord])
+
+
+class OAVBeamCentrePV(OAV):
+    """OAV device that reads its beam centre values from PVs."""
+
+    def __init__(
+        self, prefix: str, config: OAVConfig, name: str = "", overlay_channel: int = 1
+    ):
+        with self.add_children_as_readables():
+            self.beam_centre_i = epics_signal_r(
+                int, prefix + f"OVER:{overlay_channel}:CenterX"
+            )
+            self.beam_centre_j = epics_signal_r(
+                int, prefix + f"OVER:{overlay_channel}:CenterY"
+            )
+        super().__init__(prefix, config, name)

dodal/devices/oav/oav_parameters.py

@@ -1,8 +1,9 @@
 import json
 import xml.etree.ElementTree as et
+from abc import abstractmethod
 from collections import ChainMap
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic, TypeVar
 from xml.etree.ElementTree import Element
 
 # GDA currently assumes this aspect ratio for the OAV window size.
@@ -107,22 +108,19 @@ class OAVParameters:
 @dataclass
 class ZoomParams:
     microns_per_pixel: tuple[float, float]
+
+
+@dataclass
+class ZoomParamsCrosshair(ZoomParams):
     crosshair: tuple[int, int]
 
 
-class OAVConfig:
-    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
-    with information about microns per pixels and crosshairs.
-    """
+ParamType = TypeVar("ParamType", bound="ZoomParams")
 
-    def __init__(self, zoom_params_file: str, display_config_file: str):
-        self.zoom_params = self._get_zoom_params(zoom_params_file)
-        self.display_config = self._get_display_config(display_config_file)
 
-    def _get_display_config(self, display_config_file: str):
-        with open(display_config_file) as f:
-            file_lines = f.readlines()
-        return file_lines
+class OAVConfigBase(Generic[ParamType]):
+    def __init__(self, zoom_params_file: str):
+        self.zoom_params = self._get_zoom_params(zoom_params_file)
 
     def _get_zoom_params(self, zoom_params_file: str):
         tree = et.parse(zoom_params_file)
@@ -138,6 +136,39 @@ class OAVConfig:
             um_per_pix[zoom] = (um_pix_x, um_pix_y)
         return um_per_pix
 
+    @abstractmethod
+    def get_parameters(self) -> dict[str, ParamType]: ...
+
+
+class OAVConfig(OAVConfigBase[ZoomParams]):
+    def get_parameters(self) -> dict[str, ZoomParams]:
+        config = {}
+        um_xy = self._read_zoom_params()
+        for zoom_key in list(um_xy.keys()):
+            config[zoom_key] = ZoomParams(
+                microns_per_pixel=um_xy[zoom_key],
+            )
+        return config
+
+
+class OAVConfigBeamCentre(OAVConfigBase[ZoomParamsCrosshair]):
+    """ Read the OAV config files and return a dictionary of {'zoom_level': ZoomParams}\
+    with information about microns per pixels and crosshairs.
+    """
+
+    def __init__(
+        self,
+        zoom_params_file: str,
+        display_config_file: str,
+    ):
+        self.display_config = self._get_display_config(display_config_file)
+        super().__init__(zoom_params_file)
+
+    def _get_display_config(self, display_config_file: str):
+        with open(display_config_file) as f:
+            file_lines = f.readlines()
+        return file_lines
+
     def _read_display_config(self) -> dict:
         crosshairs = {}
         for i in range(len(self.display_config)):
@@ -148,13 +179,12 @@ class OAVConfig:
                 crosshairs[zoom] = (x, y)
         return crosshairs
 
-    def get_parameters(self) -> dict[str, ZoomParams]:
+    def get_parameters(self) -> dict[str, ZoomParamsCrosshair]:
         config = {}
         um_xy = self._read_zoom_params()
         bc_xy = self._read_display_config()
         for zoom_key in list(bc_xy.keys()):
-            config[zoom_key] = ZoomParams(
-                microns_per_pixel=um_xy[zoom_key],
-                crosshair=bc_xy[zoom_key],
+            config[zoom_key] = ZoomParamsCrosshair(
+                microns_per_pixel=um_xy[zoom_key], crosshair=bc_xy[zoom_key]
             )
         return config

dodal/devices/oav/oav_to_redis_forwarder.py

@@ -1,7 +1,7 @@
 import asyncio
 from collections.abc import Awaitable, Callable
 from datetime import timedelta
-from enum import Enum
+from enum import IntEnum
 from uuid import uuid4
 
 from aiohttp import ClientResponse, ClientSession
@@ -29,7 +29,7 @@ async def get_next_jpeg(response: ClientResponse) -> bytes:
             return line + await response.content.readuntil(JPEG_STOP_BYTE)
 
 
-class Source(Enum):
+class Source(IntEnum):
     FULL_SCREEN = 0
     ROI = 1
 

dodal/devices/robot.py

@@ -11,7 +11,12 @@ from ophyd_async.core import (
     set_and_wait_for_value,
     wait_for_value,
 )
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw_rbv, epics_signal_x
+from ophyd_async.epics.core import (
+    epics_signal_r,
+    epics_signal_rw,
+    epics_signal_rw_rbv,
+    epics_signal_x,
+)
 
 from dodal.log import LOGGER
 
@@ -88,6 +93,20 @@ class BartRobot(StandardReadable, Movable[SampleLocation]):
         self.controller_error = ErrorStatus(prefix + "CNTL")
 
         self.reset = epics_signal_x(prefix + "RESET.PROC")
+        self.stop = epics_signal_x(prefix + "ABORT.PROC")
+        self.init = epics_signal_x(prefix + "INIT.PROC")
+        self.soak = epics_signal_x(prefix + "SOAK.PROC")
+        self.home = epics_signal_x(prefix + "GOHM.PROC")
+        self.unload = epics_signal_x(prefix + "UNLD.PROC")
+        self.dry = epics_signal_x(prefix + "DRY.PROC")
+        self.open = epics_signal_x(prefix + "COLO.PROC")
+        self.close = epics_signal_x(prefix + "COLC.PROC")
+        self.cryomode_rbv = epics_signal_r(float, prefix + "CRYO_MODE_RBV")
+        self.cryomode = epics_signal_rw(str, prefix + "CRYO_MODE_CTRL")
+        self.gripper_temp = epics_signal_r(float, prefix + "GRIPPER_TEMP")
+        self.dewar_lid_temperature = epics_signal_rw(
+            float, prefix + "DW_1_TEMP", prefix + "DW_1_SET_POINT"
+        )
         super().__init__(name=name)
 
     async def pin_mounted_or_no_pin_found(self):