dls-dodal 1.36.3__py3-none-any.whl → 1.37.0__py3-none-any.whl

dodal/devices/current_amplifiers/sr570.py

@@ -0,0 +1,214 @@
+import asyncio
+from enum import Enum
+
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadableFormat,
+    StrictEnum,
+)
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.devices.current_amplifiers.current_amplifier import CurrentAmp
+from dodal.log import LOGGER
+
+
+class SR570GainTable(StrictEnum):
+    """Coarse/unit sensitivity setting for SR570 current amplifier"""
+
+    SEN_1 = "mA/V"
+    SEN_2 = "uA/V"
+    SEN_3 = "nA/V"
+    SEN_4 = "pA/V"
+
+
+class SR570FineGainTable(StrictEnum):
+    """Fine sensitivity setting for SR570 current amplifier"""
+
+    SEN_1 = "1"
+    SEN_2 = "2"
+    SEN_3 = "5"
+    SEN_4 = "10"
+    SEN_5 = "20"
+    SEN_6 = "50"
+    SEN_7 = "100"
+    SEN_8 = "200"
+    SEN_9 = "500"
+
+
+class SR570RaiseTimeTable(float, Enum):
+    """These are the gain dependent raise time(s) for SR570 current amplifier"""
+
+    SEN_1 = 1e-4
+    SEN_2 = 1e-2
+    SEN_3 = 0.15
+    SEN_4 = 0.2
+
+
+class SR570FullGainTable(Enum):
+    """Combined gain table, as each gain step is a combination of both coarse gain and
+    fine gain setting"""
+
+    SEN_1 = [SR570GainTable.SEN_1, SR570FineGainTable.SEN_1]
+    SEN_2 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_9]
+    SEN_3 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_8]
+    SEN_4 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_7]
+    SEN_5 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_6]
+    SEN_6 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_5]
+    SEN_7 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_4]
+    SEN_8 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_3]
+    SEN_9 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_2]
+    SEN_10 = [SR570GainTable.SEN_2, SR570FineGainTable.SEN_1]
+    SEN_11 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_9]
+    SEN_12 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_8]
+    SEN_13 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_7]
+    SEN_14 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_6]
+    SEN_15 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_5]
+    SEN_16 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_4]
+    SEN_17 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_3]
+    SEN_18 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_2]
+    SEN_19 = [SR570GainTable.SEN_3, SR570FineGainTable.SEN_1]
+    SEN_20 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_9]
+    SEN_21 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_8]
+    SEN_22 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_7]
+    SEN_23 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_6]
+    SEN_24 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_5]
+    SEN_25 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_4]
+    SEN_26 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_3]
+    SEN_27 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_2]
+    SEN_28 = [SR570GainTable.SEN_4, SR570FineGainTable.SEN_1]
+
+
+class SR570GainToCurrentTable(float, Enum):
+    """Conversion table for gain(sen) to current"""
+
+    SEN_1 = 1e3
+    SEN_2 = 2e3
+    SEN_3 = 5e3
+    SEN_4 = 1e4
+    SEN_5 = 2e4
+    SEN_6 = 5e4
+    SEN_7 = 1e5
+    SEN_8 = 2e5
+    SEN_9 = 5e5
+    SEN_10 = 1e6
+    SEN_11 = 2e6
+    SEN_12 = 5e6
+    SEN_13 = 1e7
+    SEN_14 = 2e7
+    SEN_15 = 5e7
+    SEN_16 = 1e8
+    SEN_17 = 2e8
+    SEN_18 = 5e8
+    SEN_19 = 1e9
+    SEN_20 = 2e9
+    SEN_21 = 5e9
+    SEN_22 = 1e10
+    SEN_23 = 2e10
+    SEN_24 = 5e10
+    SEN_25 = 1e11
+    SEN_26 = 2e11
+    SEN_27 = 5e11
+    SEN_28 = 1e12
+
+
+class SR570(CurrentAmp):
+    """
+    SR570 current amplifier device. This is similar to Femto with the only different
+     is SR570 has two gain setting fine and coarse, therefore it requires extra
+     gain tables.
+    Attributes:
+        fine_gain (SignalRW): This is the epic signal that control SR570 fine gain.
+        coarse_gain (SignalRW): This is the epic signal that control SR570 coarse gain.
+        fine_gain_table (strictEnum): The table that fine_gain use to set gain.
+        coarse_gain_table (strictEnum): The table that coarse_gain use to set gain.
+        timeout (float): Maximum waiting time in second for setting gain.
+        raise_timetable (Enum): Table contain the amount of time to wait after
+            setting gain.
+        combined_table (Enum): Table that combine fine and coarse table into one.
+        gain (SignalRW([str]): Soft signal to store the member name of the current gain
+            setting in gain_conversion_table.
+        upperlimit (float): upperlimit of the current amplifier
+        lowerlimit (float): lowerlimit of the current amplifier
+
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        suffix: str,
+        fine_gain_table: type[StrictEnum],
+        coarse_gain_table: type[StrictEnum],
+        combined_table: type[Enum],
+        gain_to_current_table: type[Enum],
+        raise_timetable: type[Enum],
+        upperlimit: float = 4.8,
+        lowerlimit: float = 0.4,
+        timeout: float = 1,
+        name: str = "",
+    ) -> None:
+        super().__init__(name=name, gain_conversion_table=gain_to_current_table)
+
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.fine_gain = epics_signal_rw(fine_gain_table, prefix + suffix + "1")
+            self.coarse_gain = epics_signal_rw(coarse_gain_table, prefix + suffix + "2")
+
+        self.fine_gain_table = fine_gain_table
+        self.coarse_gain_table = coarse_gain_table
+        self.timeout = timeout
+        self.raise_timetable = raise_timetable
+        self.combined_table = combined_table
+        self.upperlimit = upperlimit
+        self.lowerlimit = lowerlimit
+
+    @AsyncStatus.wrap
+    async def set(self, value) -> None:
+        if value not in [item.value for item in self.gain_conversion_table]:
+            raise ValueError(
+                f"Gain value {value} is not within {self.name} range."
+                + "\n Available gain:"
+                + f" {[f'{c.value:.0e}' for c in self.gain_conversion_table]}"
+            )
+        SEN_setting = self.gain_conversion_table(value).name
+        LOGGER.info(f"{self.name} gain change to {value}")
+
+        coarse_gain, fine_gain = self.combined_table[SEN_setting].value
+        await asyncio.gather(
+            self.fine_gain.set(value=fine_gain, timeout=self.timeout),
+            self.coarse_gain.set(value=coarse_gain, timeout=self.timeout),
+        )
+        await asyncio.sleep(self.raise_timetable[coarse_gain.name].value)
+
+    @AsyncStatus.wrap
+    async def increase_gain(self, value=3) -> None:
+        current_gain = int((await self.get_gain()).name.split("_")[-1])
+        current_gain += value
+        if current_gain > len(self.combined_table):
+            await self.set(
+                self.gain_conversion_table[f"SEN_{len(self.combined_table)}"]
+            )
+            raise ValueError("Gain at max value")
+        await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
+
+    @AsyncStatus.wrap
+    async def decrease_gain(self, value=3) -> None:
+        current_gain = int((await self.get_gain()).name.split("_")[-1])
+        current_gain -= value
+        if current_gain < 1:
+            await self.set(self.gain_conversion_table["SEN_1"])
+            raise ValueError("Gain at min value")
+        await self.set(self.gain_conversion_table[f"SEN_{current_gain}"])
+
+    @AsyncStatus.wrap
+    async def get_gain(self) -> Enum:
+        result = await asyncio.gather(
+            self.coarse_gain.get_value(), self.fine_gain.get_value()
+        )
+        return self.gain_conversion_table[self.combined_table(result).name]
+
+    @AsyncStatus.wrap
+    async def get_upperlimit(self) -> float:
+        return self.upperlimit
+
+    @AsyncStatus.wrap
+    async def get_lowerlimit(self) -> float:
+        return self.lowerlimit

dodal/devices/current_amplifiers/struck_scaler_counter.py

@@ -0,0 +1,79 @@
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadableFormat,
+    StrictEnum,
+    set_and_wait_for_other_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
+
+from dodal.devices.current_amplifiers import (
+    CurrentAmpCounter,
+)
+
+
+class CountMode(StrictEnum):
+    AUTO = "AutoCount"
+    ONE_SHOT = "OneShot"
+
+
+class CountState(StrictEnum):
+    DONE = "Done"
+    COUNT = "Count"  # type: ignore
+
+
+COUNT_PER_VOLTAGE = 100000
+
+
+class StruckScaler(CurrentAmpCounter):
+    """
+    StruckScaler is a counting card that record the output signal from a wide
+      range of detectors. This class contains the basic control to run the struckscaler
+      card together with a current amplifier. It has functions that provide conversion
+      between count and voltage.
+    Attributes:
+        readout(SignalR): Scaler card output.
+        count_mode (SignalR[CountMode]): Counting card setting.
+        count_time (SignalRW([float]): Count time.
+    """
+
+    def __init__(
+        self, prefix: str, suffix: str, count_per_volt=COUNT_PER_VOLTAGE, name: str = ""
+    ):
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.readout = epics_signal_r(float, prefix + suffix)
+        with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL):
+            self.count_mode = epics_signal_rw(CountMode, prefix + ":AutoCount")
+            self.count_time = epics_signal_rw(float, prefix + ".TP")
+        self.trigger_start = epics_signal_rw(CountState, prefix + ".CNT")
+        super().__init__(count_per_volt=count_per_volt, name=name)
+
+    @AsyncStatus.wrap
+    async def stage(self) -> None:
+        await self.count_mode.set(CountMode.ONE_SHOT)
+
+    @AsyncStatus.wrap
+    async def unstage(self) -> None:
+        await self.count_mode.set(CountMode.AUTO)
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        await set_and_wait_for_other_value(
+            set_signal=self.trigger_start,
+            set_value=CountState.COUNT,
+            match_signal=self.trigger_start,
+            match_value=CountState.COUNT,
+        )
+
+    @AsyncStatus.wrap
+    async def prepare(self, value) -> None:
+        await self.count_time.set(value)
+
+    async def get_count(self) -> float:
+        await self.trigger()
+        return await self.readout.get_value()
+
+    async def get_count_per_sec(self) -> float:
+        return await self.get_count() / await self.count_time.get_value()
+
+    async def get_voltage_per_sec(self) -> float:
+        return await self.get_count_per_sec() / self.count_per_volt

dodal/devices/detector/det_dim_constants.py

@@ -26,6 +26,21 @@ class DetectorSizeConstants:
         ALL_DETECTORS[self.det_type_string] = self
 
 
+PILATUS_TYPE_6M = "PILATUS_6M"
+PILATUS_6M_DIMENSION_X = 423.636
+PILATUS_6M_DIMENSION_Y = 434.644
+PILATUS_6M_DIMENSION = DetectorSize(PILATUS_6M_DIMENSION_X, PILATUS_6M_DIMENSION_Y)
+PIXELS_X_PILATUS_6M = 2463
+PIXELS_Y_PILATUS_6M = 2527
+PIXELS_PILATUS_6M = DetectorSize(PIXELS_X_PILATUS_6M, PIXELS_Y_PILATUS_6M)
+PILATUS_6M_SIZE = DetectorSizeConstants(
+    PILATUS_TYPE_6M,
+    PILATUS_6M_DIMENSION,
+    PIXELS_PILATUS_6M,
+    PILATUS_6M_DIMENSION,
+    PIXELS_PILATUS_6M,
+)
+
 EIGER_TYPE_EIGER2_X_4M = "EIGER2_X_4M"
 EIGER2_X_4M_DIMENSION_X = 155.1
 EIGER2_X_4M_DIMENSION_Y = 162.15

dodal/devices/eiger_odin.py

@@ -91,10 +91,10 @@ class OdinNodesStatus(Device):
     def wait_for_no_errors(self, timeout) -> dict[SubscriptionStatus, str]:
         errors = {}
         for node_number, node_pv in enumerate(self.nodes):
-            errors[
-                await_value(node_pv.error_status, False, timeout)
-            ] = f"Filewriter {node_number} is in an error state with error message\
+            errors[await_value(node_pv.error_status, False, timeout)] = (
+                f"Filewriter {node_number} is in an error state with error message\
                      - {node_pv.error_message.get()}"
+            )
 
         return errors
 

dodal/devices/fast_grid_scan.py

@@ -97,9 +97,14 @@ class GridScanParamsCommon(AbstractExperimentWithBeamParams):
         """Converts a grid position, given as steps in the x, y, z grid,
         to a real motor position.
 
-        :param grid_position: The x, y, z position in grid steps
-        :return: The motor position this corresponds to.
-        :raises: IndexError if the desired position is outside the grid."""
+        Args:
+            grid_position: The x, y, z position in grid steps. The origin is at the
+                centre of the first grid box
+        Returns:
+            The motor position this corresponds to.
+        Raises:
+            IndexError if the desired position is outside the grid.
+        """
         for position, axis in zip(
             grid_position, [self.x_axis, self.y_axis, self.z_axis], strict=False
         ):

dodal/devices/i03/beamstop.py

@@ -0,0 +1,85 @@
+from asyncio import gather
+from math import isclose
+
+from ophyd_async.core import StandardReadable, StrictEnum
+from ophyd_async.epics.motor import Motor
+
+from dodal.common.beamlines.beamline_parameters import GDABeamlineParameters
+from dodal.common.signal_utils import create_hardware_backed_soft_signal
+
+
+class BeamstopPositions(StrictEnum):
+    """
+    Beamstop positions.
+    GDA supports Standard/High/Low resolution positions, as well as parked and
+    robot load however all 3 resolution positions are the same. We also
+    do not use the robot load position in Hyperion.
+
+    Until we support moving the beamstop it is only necessary to check whether the
+    beamstop is in beam or not.
+
+    See Also:
+        https://github.com/DiamondLightSource/mx-bluesky/issues/484
+
+    Attributes:
+        DATA_COLLECTION: The beamstop is in beam ready for data collection
+        UNKNOWN: The beamstop is in some other position, check the device motor
+            positions to determine it.
+    """
+
+    DATA_COLLECTION = "Data Collection"
+    UNKNOWN = "Unknown"
+
+
+class Beamstop(StandardReadable):
+    """
+    Beamstop for I03.
+
+    Attributes:
+        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.
+    """
+
+    def __init__(
+        self,
+        prefix: str,
+        beamline_parameters: GDABeamlineParameters,
+        name: str = "",
+    ):
+        with self.add_children_as_readables():
+            self.x_mm = Motor(prefix + "X")
+            self.y_mm = Motor(prefix + "Y")
+            self.z_mm = Motor(prefix + "Z")
+            self.selected_pos = create_hardware_backed_soft_signal(
+                BeamstopPositions, self._get_selected_position
+            )
+
+        self._in_beam_xyz_mm = [
+            float(beamline_parameters[f"in_beam_{axis}_STANDARD"])
+            for axis in ("x", "y", "z")
+        ]
+        self._xyz_tolerance_mm = [
+            float(beamline_parameters[f"bs_{axis}_tolerance"])
+            for axis in ("x", "y", "z")
+        ]
+
+        super().__init__(name)
+
+    async def _get_selected_position(self) -> BeamstopPositions:
+        current_pos = await gather(
+            self.x_mm.user_readback.get_value(),
+            self.y_mm.user_readback.get_value(),
+            self.z_mm.user_readback.get_value(),
+        )
+        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
+            )
+        ):
+            return BeamstopPositions.DATA_COLLECTION
+        else:
+            return BeamstopPositions.UNKNOWN

dodal/devices/i04/transfocator.py

@@ -1,14 +1,18 @@
+import asyncio
 import math
-from time import sleep, time
 
-from ophyd import Component as Cpt
-from ophyd import Device, EpicsSignal, EpicsSignalRO, Kind
-from ophyd.status import DeviceStatus
+from ophyd_async.core import (
+    AsyncStatus,
+    StandardReadable,
+    observe_value,
+    wait_for_value,
+)
+from ophyd_async.epics.core import epics_signal_r, epics_signal_rw
 
 from dodal.log import LOGGER
 
 
-class Transfocator(Device):
+class Transfocator(StandardReadable):
     """The transfocator is a device that puts a number of lenses in the beam to change
     its shape.
 
@@ -18,34 +22,50 @@ class Transfocator(Device):
         my_transfocator.set(vert_beamsize_microns)
     """
 
-    beamsize_set_microns = Cpt(EpicsSignal, "VERT_REQ", kind=Kind.hinted)
-    predicted_vertical_num_lenses = Cpt(EpicsSignal, "LENS_PRED")
-
-    number_filters_sp = Cpt(EpicsSignal, "NUM_FILTERS")
-
-    start = Cpt(EpicsSignal, "START.PROC")
-    start_rbv = Cpt(EpicsSignalRO, "START_RBV")
-
-    vertical_lens_rbv = Cpt(EpicsSignalRO, "VER", kind=Kind.hinted)
+    def __init__(self, prefix: str, name: str = ""):
+        with self.add_children_as_readables():
+            self.beamsize_set_microns = epics_signal_rw(float, prefix + "VERT_REQ")
+            self.predicted_vertical_num_lenses = epics_signal_rw(
+                float, prefix + "LENS_PRED"
+            )
+            self.number_filters_sp = epics_signal_rw(int, prefix + "NUM_FILTERS")
+            self.start = epics_signal_rw(int, prefix + "START.PROC")
+            self.start_rbv = epics_signal_r(int, prefix + "START_RBV")
+            self.vertical_lens_rbv = epics_signal_r(float, prefix + "VER")
 
-    TIMEOUT = 120
-    _POLLING_WAIT = 0.01
+        self.TIMEOUT = 120
 
-    def polling_wait_on_start_rbv(self, for_value):
-        # For some reason couldn't get monitors working on START_RBV
-        # (See https://github.com/DiamondLightSource/dodal/issues/152)
-        start_time = time()
-        while time() < start_time + self.TIMEOUT:
-            RBV_value = self.start_rbv.get()
-            if RBV_value == for_value:
-                return
-            sleep(self._POLLING_WAIT)
+        super().__init__(name=name)
 
-        # last try
-        if self.start_rbv.get() != for_value:
-            raise TimeoutError()
+    async def _observe_beamsize_microns(self):
+        is_set_filters_done = False
 
-    def set(self, beamsize_microns: float) -> DeviceStatus:
+        async def set_based_on_prediction(value: float):
+            if not math.isclose(
+                self.latest_pred_vertical_num_lenses, value, abs_tol=1e-8
+            ):
+                # We can only put an integer number of lenses in the beam but the
+                # calculation in the IOC returns the theoretical float number of lenses
+                nonlocal is_set_filters_done
+                value = round(value)
+                LOGGER.info(f"Transfocator setting {value} filters")
+                await self.number_filters_sp.set(value)
+                await self.start.set(1)
+                LOGGER.info("Waiting for start_rbv to change to 1")
+                await wait_for_value(self.start_rbv, 1, self.TIMEOUT)
+                LOGGER.info("Waiting for start_rbv to change to 0")
+                await wait_for_value(self.start_rbv, 0, self.TIMEOUT)
+                self.latest_pred_vertical_num_lenses = value
+                is_set_filters_done = True
+
+        # The value hasn't changed so assume the device is already set up correctly
+        async for value in observe_value(self.predicted_vertical_num_lenses):
+            await set_based_on_prediction(value)
+            if is_set_filters_done:
+                break
+
+    @AsyncStatus.wrap
+    async def set(self, value: float):
         """To set the beamsize on the transfocator we must:
         1. Set the beamsize in the calculator part of the transfocator
         2. Get the predicted number of lenses needed from this calculator
@@ -53,30 +73,24 @@ class Transfocator(Device):
         4. Start the device moving
         5. Wait for the start_rbv goes high and low again
         """
-        subscriber: int
-        status = DeviceStatus(self, timeout=self.TIMEOUT)
+        self.latest_pred_vertical_num_lenses = (
+            await self.predicted_vertical_num_lenses.get_value()
+        )
 
-        def set_based_on_predicition(old_value, value, *args, **kwargs):
-            if not math.isclose(old_value, value, abs_tol=1e-8):
-                self.predicted_vertical_num_lenses.unsubscribe(subscriber)
+        LOGGER.info(f"Transfocator setting {value} beamsize")
 
-                # We can only put an integer number of lenses in the beam but the
-                # calculation in the IOC returns the theoretical float number of lenses
-                value = round(value)
-                LOGGER.info(f"Transfocator setting {value} filters")
-                self.number_filters_sp.set(value).wait()
-                self.start.set(1).wait()
-                self.polling_wait_on_start_rbv(1)
-                self.polling_wait_on_start_rbv(0)
-            # The value hasn't changed so assume the device is already set up correctly
-            status.set_finished()
-
-        LOGGER.info(f"Transfocator setting {beamsize_microns} beamsize")
-        if self.beamsize_set_microns.get() != beamsize_microns:
-            subscriber = self.predicted_vertical_num_lenses.subscribe(
-                set_based_on_predicition, run=False
+        if await self.beamsize_set_microns.get_value() != value:
+            # Logic in the IOC calculates predicted_vertical_num_lenses when beam_set_microns changes
+            await asyncio.gather(
+                self.beamsize_set_microns.set(value),
+                self._observe_beamsize_microns(),
             )
-            self.beamsize_set_microns.set(beamsize_microns)
-        else:
-            status.set_finished()
-        return status
+
+        number_filters_rbv, vertical_lens_size_rbv = await asyncio.gather(
+            self.number_filters_sp.get_value(),
+            self.vertical_lens_rbv.get_value(),
+        )
+
+        LOGGER.info(
+            f"Transfocator set complete. Number of filters is: {number_filters_rbv} and Vertical beam size is: {vertical_lens_size_rbv}"
+        )

dodal/devices/i10/rasor/rasor_current_amp.py

@@ -0,0 +1,72 @@
+from ophyd_async.core import Device
+
+from dodal.devices.current_amplifiers import (
+    SR570,
+    Femto3xxGainTable,
+    Femto3xxGainToCurrentTable,
+    Femto3xxRaiseTime,
+    FemtoDDPCA,
+    SR570FineGainTable,
+    SR570FullGainTable,
+    SR570GainTable,
+    SR570GainToCurrentTable,
+    SR570RaiseTimeTable,
+)
+
+
+class RasorFemto(Device):
+    def __init__(self, prefix: str, suffix: str = "GAIN", name: str = "") -> None:
+        self.ca1 = FemtoDDPCA(
+            prefix + "-01:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        self.ca2 = FemtoDDPCA(
+            prefix + "-02:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        self.ca3 = FemtoDDPCA(
+            prefix + "-03:",
+            suffix=suffix,
+            gain_table=Femto3xxGainTable,
+            gain_to_current_table=Femto3xxGainToCurrentTable,
+            raise_timetable=Femto3xxRaiseTime,
+        )
+        super().__init__(name)
+
+
+class RasorSR570(Device):
+    def __init__(self, prefix: str, suffix: str = "SENS:SEL", name: str = "") -> None:
+        self.ca1 = SR570(
+            prefix + "-04:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        self.ca2 = SR570(
+            prefix + "-05:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        self.ca3 = SR570(
+            prefix + "-06:",
+            suffix=suffix,
+            fine_gain_table=SR570FineGainTable,
+            coarse_gain_table=SR570GainTable,
+            combined_table=SR570FullGainTable,
+            gain_to_current_table=SR570GainToCurrentTable,
+            raise_timetable=SR570RaiseTimeTable,
+        )
+        super().__init__(name)