Merge branch 'jungfrau-gainmode-enums' into 'master'

JUNGFRAU: More user-friendly gain mode / gain setting parameters

See merge request !45

src/calng/conditions/JungfrauCondition.py

-import collections
 import operator
 
 from karabo.middlelayer import AccessMode, Assignment, String
 from .. import base_condition
-from ..corrections.JungfrauCorrection import GainModes
+from ..corrections.JungfrauCorrection import GainModes, GainSettings
 
 
-def old_settings_to_gain_mode(setting):
-    gain_mode = GainModes(setting)
-    if gain_mode in (GainModes.FIX_GAIN_1, GainModes.FIX_GAIN_2):
-        return 1
+def gain_mode_translator(gain_mode_string):
+    if gain_mode_string in {"dynamic", "forceswitchg1", "forceswitchg2"}:
+        return GainModes.ADAPTIVE_GAIN.name
+    elif gain_mode_string in {"fixg1", "fixg2"}:
+        return GainModes.FIXED_GAIN.name
     else:
-        return 0
+        raise ValueError(f"Unknown gain mode {gain_mode_string}")
 
 
-def old_settings_to_gain_setting(setting):
-    gain_mode = GainModes(setting)
-    if gain_mode is GainModes.DYNAMIC_GAIN_HG0:
-        return 1
-    else:
-        return 0
-
-
-def new_settings_to_gain_setting(setting):
+def gain_setting_translator(setting):
     if setting == "gain0":
-        return 0
+        return GainSettings.LOW_CDS.name
     elif setting == "highgain0":
-        return 1
+        return GainSettings.HIGH_CDS.name
     else:
         raise ValueError(f"Unknown gain setting {setting}")
 
 
-def new_gain_mode_to_gain_mode(gain_mode):
-    if gain_mode in {"dynamic", "forceswitchg1", "forceswitchg2"}:
-        return 0
-    elif gain_mode in {"fixg1", "fixg2"}:
-        return 1
-    else:
-        raise ValueError(f"Unknown gain_mode {gain_mode}")
-
-
 class JungfrauCondition(base_condition.ConditionBase):
-    detectorFirmwareVersion = String(
-        displayedName="Firmware version",
-        assignment=Assignment.OPTIONAL,
-        accessMode=AccessMode.INITONLY,
-        defaultValue="new",
-        options=["old", "new"],
-    )
     controlDeviceId = String(
         displayedName="Control device ID",
         assignment=Assignment.MANDATORY,
@@ -56,29 +32,17 @@ class JungfrauCondition(base_condition.ConditionBase):
 
     @property
     def keys_to_get(self):
-        key_map = [
-            # cells: 1.0 or 16.0
-            ("storageCells", "memoryCells", lambda n: n + 1),
-            (
-                "exposureTime",
-                "integrationTime",
-                lambda n: n * 1e6,
-            ),
-        ]
-        if self.detectorFirmwareVersion.value == "old":
-            key_map += [
-                # note: control device parameter is a vector
-                ("vHighVoltage", "biasVoltage", operator.itemgetter(0)),
-                # gain mode: omitted or 1.0
-                ("settings", "gainMode", old_settings_to_gain_mode),
-                # gain setting: 0.0 or 1.0 (derived from gain mode on device)
-                ("settings", "gainSetting", old_settings_to_gain_setting),
-            ]
-        else:
-            key_map += [
+        return {
+            self.controlDeviceId.value: [
+                # cells: 1.0 or 16.0
+                ("storageCells", "memoryCells", lambda n: n + 1),
+                (
+                    "exposureTime",
+                    "integrationTime",
+                    lambda n: n * 1e6,
+                ),
                 ("highVoltage", "biasVoltage", operator.itemgetter(0)),
-                ("settings", "gainSetting", new_settings_to_gain_setting),
-                ("gainMode", "gainMode", new_gain_mode_to_gain_mode),
+                ("settings", "gainSetting", gain_setting_translator),
+                ("gainMode", "gainMode", gain_mode_translator),
             ]
-
-        return {self.controlDeviceId.value: key_map}
+        }

src/calng/corrections/JungfrauCorrection.py

@@ -42,12 +42,13 @@ bad_pixel_constants = {
 
 # from pycalibration (TOOD: move to common shared lib)
 class GainModes(enum.Enum):
-    DYNAMIC_GAIN = "dynamicgain"
-    DYNAMIC_GAIN_HG0 = "dynamichg0"
-    FIX_GAIN_1 = "fixgain1"
-    FIX_GAIN_2 = "fixgain2"
-    FORCE_SWITCH_HG1 = "forceswitchg1"
-    FORCE_SWITCH_HG2 = "forceswitchg2"
+    ADAPTIVE_GAIN = 0
+    FIXED_GAIN = 1
+
+
+class GainSettings(enum.Enum):
+    LOW_CDS = 0
+    HIGH_CDS = 1
 
 
 class CorrectionFlags(enum.IntFlag):
@@ -380,7 +381,7 @@ class JungfrauCalcatFriend(base_calcat.BaseCalcatFriend):
             .reconfigurable()
             .commit(),
 
-            DOUBLE_ELEMENT(schema)
+            STRING_ELEMENT(schema)
             .key("constantParameters.gainMode")
             .displayedName("Gain mode")
             .description(
@@ -390,16 +391,18 @@ class JungfrauCalcatFriend(base_calcat.BaseCalcatFriend):
                 "for fixed gain (omitted otherwise)."
             )
             .assignmentOptional()
-            .defaultValue(0)
+            .defaultValue(GainModes.ADAPTIVE_GAIN.name)
+            .options(",".join(gain_mode.name for gain_mode in GainModes))
             .reconfigurable()
             .commit(),
 
-            DOUBLE_ELEMENT(schema)
+            STRING_ELEMENT(schema)
             .key("constantParameters.gainSetting")
             .displayedName("Gain setting")
             .description("See description of gainMode")
             .assignmentOptional()
-            .defaultValue(0)
+            .defaultValue(GainSettings.LOW_CDS.name)
+            .options(",".join(gain_setting.name for gain_setting in GainSettings))
             .reconfigurable()
             .commit(),
         )
@@ -421,10 +424,13 @@ class JungfrauCalcatFriend(base_calcat.BaseCalcatFriend):
         res["Integration Time"] = self._get_param("integrationTime")
         res["Sensor Temperature"] = self._get_param("sensorTemperature")
 
-        if self._get_param("gainMode") != 0:
-            # NOTE: always include if CalCat is updated for this
-            res["Gain mode"] = self._get_param("gainMode")
-        res["Gain Setting"] = self._get_param("gainSetting")
+        if (
+            gain_mode := GainModes[self._get_param("gainMode")]
+        ) is not GainModes.ADAPTIVE_GAIN:
+            # NOTE: currently only including if parameter for CalCat is 1
+            # change if conditions are tidied up in the database
+            res["Gain mode"] = gain_mode.value
+        res["Gain Setting"] = GainSettings[self._get_param("gainSetting")].value
 
         return res