[feat] add goffset andorshrk

Author: yxkdejong

install/linux/usr/share/odemis/sim/sparc2-focus-test.odm.yaml

@@ -93,16 +93,12 @@
 # On some configuration, there is a dedicated camera for the acquisition of the
 # spectra, otherwise 'Camera' is used.
 "Spectral Camera": {
-    class: andorcam2.AndorCam2,
+    class: simcam.Camera,
     role: sp-ccd,
-    power_supplier: "Power Control Unit",
     init: {
-        device: "fake",
-        transp: [-1, 2], # if mirrored on X axis
-    },
-    properties: {
-        targetTemperature: -60, # °C
+        image: "sparc-spec-sim.h5",
     },
+    dependencies: {spectrograph: "Spectrograph"},
 }
 
 "Spectrometer IR": {

src/odemis/driver/andorshrk.py

@@ -49,10 +49,11 @@
 # SHAMROCK_I24SLITWIDTHMAX 24000
 SHUTTERMODEMIN = 0
 SHUTTERMODEMAX = 2  # Note: 1 is max on SR303, 2 is max on SR193
-# SHAMROCK_DET_OFFSET_MIN -240000
-# SHAMROCK_DET_OFFSET_MAX 240000
-# SHAMROCK_GRAT_OFFSET_MIN -20000
-# SHAMROCK_GRAT_OFFSET_MAX 20000
+
+DET_OFFSET_MIN = -240000
+DET_OFFSET_MAX = 240000
+GRAT_OFFSET_MIN = -20000
+GRAT_OFFSET_MAX = 20000
 
 SLIT_INDEX_MIN = 1
 SLIT_INDEX_MAX = 4
@@ -496,7 +497,9 @@ def __init__(self, name: str, role: str,
 
             axes = {"wavelength": model.Axis(unit="m", range=wl_range,
                                              speed=(max_speed, max_speed)),
-                    "grating": model.Axis(choices=gchoices)
+                    "grating": model.Axis(choices=gchoices),
+                    "goffset": model.Axis(unit=None,
+                                          range=((GRAT_OFFSET_MIN + DET_OFFSET_MIN), (GRAT_OFFSET_MAX + DET_OFFSET_MAX)))
                     }
 
             if self.FocusMirrorIsPresent():
@@ -1597,14 +1600,40 @@ def _getGratingChoices(self):
 
         return gchoices
 
+    def GetGoffset(self):
+        """
+        Checks the current grating and flip-mirror positions.
+        Returns the grating offset, consisting of the grating_offset + the detector offset.
+
+        The detector offset is the equivalent grating offset that is needed to compensate for the change in
+        optical path length, introduced by the flip-mirrors.
+        This allows to maintain a stable wavelength calibration across different optical paths, rather than forcing the user
+        to recalibrate for every detector configuration.
+        """
+
+        grating = self.GetGrating()
+        if "flip-in" in self.axes:
+            flip_in_pos = self.GetFlipperMirror(INPUT_FLIPPER)
+        else:
+            flip_in_pos = DIRECT_PORT
+
+        if "flip-out" in self.axes:
+            flip_out_pos = self.GetFlipperMirror(OUTPUT_FLIPPER)
+        else:
+            flip_out_pos = DIRECT_PORT
+
+        goffset = self.GetGratingOffset(grating) + self.GetDetectorOffset(flip_in_pos, flip_out_pos)
+        return goffset
+
     # high-level methods (interface)
     def _updatePosition(self, must_notify=False):
         """
         update the position VA
         """
         # TODO: support "axes" to limit the axes to update
         pos = {"wavelength": self.GetWavelength(),
-               "grating": self.GetGrating()
+               "grating": self.GetGrating(),
+               "goffset": self.GetGoffset()
               }
 
         if "focus" in self.axes:
@@ -1814,6 +1843,8 @@ def moveRel(self, shift):
                 actions.append((axis, self._doSetWavelengthRel, s))
             elif axis == "focus":
                 actions.append((axis, self._doSetFocusRel, s))
+            elif axis == "goffset":
+                actions.append((axis, self._doSetGoffsetRel, s))
             elif axis in self._slit_names.values():
                 sid = [k for k, v in self._slit_names.items() if v == axis][0]
                 actions.append((axis, self._doSetSlitRel, sid, s))
@@ -1851,6 +1882,8 @@ def moveAbs(self, pos):
                 actions.append((axis, self._doSetFilter, p, check))
             elif axis == "focus":
                 actions.append((axis, self._doSetFocusAbs, p))
+            elif axis == "goffset":
+                actions.append((axis, self._doSetGoffsetAbs, p))
             elif axis == "flip-in":
                 check = self._check_move.get(axis, True)
                 actions.append((axis, self._doSetFlipper, INPUT_FLIPPER, p, check))
@@ -2064,6 +2097,77 @@ def _doSetFlipper(self, flipper: int, pos: int, check: bool):
             logging.warning("Failed to update turret position, detector offset might be incorrect", exc_info=True)
         self._updatePosition()
 
+
+    def _doSetGoffsetAbs(self, target_offset, *, allow_grating_offset=True, single_detector_mode = False):
+
+        """
+        Change grating offset, by either changing the grating offset or the detector offset.
+        :param target_offset (float): the new grating offset to set
+        :param allow_grating_offset (bool): check to allow changing the grating offset, if false, only change
+        detector offset.
+        :param single_detector_mode (bool): if true, it will always change the grating offset,
+        even if the output flipper is not in the direct port position.
+        """
+
+        target_offset = int(round(target_offset))  # ensure that we get integers for steps
+        grating = self.GetGrating()
+        port_index = self.GetFlipperMirror(OUTPUT_FLIPPER)
+
+        if "flip-in" in self.axes:
+            flip_in_pos = self.GetFlipperMirror(INPUT_FLIPPER)
+        else:
+            flip_in_pos = DIRECT_PORT
+
+        if "flip-out" in self.axes:
+            flip_out_pos = self.GetFlipperMirror(OUTPUT_FLIPPER)
+        else:
+            flip_out_pos = DIRECT_PORT
+
+        single_detector = bool(single_detector_mode)
+        current_grat_offset = self.GetGratingOffset(grating)
+        current_det_offset = self.GetDetectorOffset(flip_in_pos, flip_out_pos)
+        logging.debug("Current goffset: %d (Grat: %d, Det: %d)",
+                      (current_grat_offset + current_det_offset),
+                      current_grat_offset, current_det_offset)
+
+        # The detector offset compensates for small naccuracies introduced by the flip-mirror mechanism.
+        # This value is normally stable and seldom requires re-adjustment.
+
+        if port_index == 0 or single_detector:
+            logging.debug(
+                "Choosing grating offset update (port_index=%s single_detector=%s)",
+                port_index, single_detector
+            )
+
+            # primary detector -> modify grating offset
+            if not allow_grating_offset:
+                logging.debug("Grating offset update disabled (grating=1, target=%d)", target_offset, )
+            else:
+                grating_offset = target_offset - current_det_offset
+                self.SetGratingOffset(grating, grating_offset)
+
+        # secondary detector (if multiple detectors) -> modify detector offset
+        else:
+            logging.debug(
+                "Choosing detector offset update (port_index=%s single_detector=%s)",
+                port_index, single_detector
+            )
+            detector_offset = target_offset - current_grat_offset
+            self.SetDetectorOffset(flip_in_pos, flip_out_pos, detector_offset)
+
+        self._updatePosition()
+
+    def _doSetGoffsetRel(self, shift):
+
+        """
+        Change the grating offset by either changing the grating offset or detector offset.
+        :param shift (float): relative change in offset
+        """
+
+        # We expect the goffset axis to exist
+        current_pos = self.position.value["goffset"]
+        return self._doSetGoffsetAbs(current_pos + shift)
+
     def _updateShutterMode(self, pos):
         """
         Update the state of the shutter depending on the detector used.
@@ -2451,6 +2555,9 @@ def ShamrockGetDetectorOffsetEx(self, device, entrancePort, exitPort, p_offset):
         offset.value = self._detoffset[_val(entrancePort), _val(exitPort)]
 
     def ShamrockSetGratingOffset(self, device, grating, offset):
+        cur_offset = self._goffset[_val(grating) - 1]
+        new_offset = _val(offset)
+        time.sleep(abs(cur_offset - new_offset) / 10000)
         self._goffset[_val(grating) - 1] = _val(offset)
 
     def ShamrockGetGratingOffset(self, device, grating, p_offset):

src/odemis/driver/test/andorshrk_test.py

@@ -589,6 +589,53 @@ def test_iris(self):
 
         sp.moveAbsSync({"iris-in": orig_pos})
 
+    def test_goffset(self):
+        self.assertIn("goffset", self.spectrograph.axes)
+        sp = self.spectrograph
+        rng = sp.axes["goffset"].range
+
+        orig_offsets = {}
+        orig_grating = sp.position.value["goffset"]
+
+        for g in sp.axes["grating"].choices:
+            sp.moveAbsSync({"grating": g})
+            orig_offsets[g] = sp.position.value["goffset"]
+
+        try:
+            # try absolute move for grating 1
+            sp.moveAbsSync({"grating": 1})
+            target_abs = rng[0] + 10
+            sp.moveAbsSync({"goffset": target_abs})
+            self.assertAlmostEqual(sp.position.value["goffset"], target_abs)
+
+            # try relative move for grating 1
+            shift = 5
+            expected_rel = sp.position.value["goffset"] + shift
+            sp.moveRelSync({"goffset": shift})
+            self.assertAlmostEqual(sp.position.value["goffset"], expected_rel)
+
+            # try other gratings
+            choices = sp.axes["grating"].choices
+            for g in choices:
+                if g > 1 and choices[g] != "mirror":
+                    sp.moveAbsSync({"grating": g})
+                    break
+            else:
+                self.skipTest("No second grating available to test Detector Offset logic")
+
+            target_alt = rng[0] + 20
+            sp.moveAbsSync({"goffset": target_alt})
+            self.assertAlmostEqual(sp.position.value["goffset"], target_alt)
+
+        finally:
+            # restore the original offset so other tests aren't affected
+            for g, offset in orig_offsets.items():
+                sp.moveAbsSync({"grating": g})
+                sp.moveAbsSync({"goffset": offset})
+
+            # restore original grating
+            sp.moveAbsSync({"grating": orig_grating})
+
 class TestShamrockAndCCD(SpectrographTestBaseClass, unittest.TestCase):
     """
     Test the Shamrock + AndorSpec class