tomwer 1.4.18__py3-none-any.whl → 1.5.0__py3-none-any.whl

tomwer/gui/edit/nxtomoeditor.py

@@ -2,12 +2,13 @@ from __future__ import annotations
 
 import logging
 import weakref
-
+import pint
 import numpy
 from silx.gui import qt
 
 from nxtomo.nxobject.nxdetector import ImageKey, FOV
 from nxtomo.utils.transformation import build_matrix
+from nxtomo.paths.nxtomo import LATEST_VERSION as _LATEST_NXTOMO_VERSION
 
 from tomwer.core.process.edit.nxtomoeditor import NXtomoEditorTask, NXtomoEditorKeys
 from tomwer.core.scan.nxtomoscan import NXtomoScan
@@ -18,6 +19,8 @@ from tomwer.gui.edit.nxtomowarmer import NXtomoProxyWarmer
 
 _logger = logging.getLogger(__name__)
 
+_ureg = pint.get_application_registry()
+
 
 class NXtomoEditorDialog(qt.QDialog):
     """
@@ -119,48 +122,58 @@ class NXtomoEditor(qt.QWidget):
         self._detectorQTWI = qt.QTreeWidgetItem(self._instrumentQTWI)
         self._detectorQTWI.setText(0, "detector")
         ## pixel size
-        self._xPixelSizeQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
-        self._xPixelSizeQTWI.setText(0, "x pixel size")
-        self._xPixelSizeMetricEntry = MetricEntry("", parent=self)
-        self._xPixelSizeMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
-        self._tree.setItemWidget(self._xPixelSizeQTWI, 1, self._xPixelSizeMetricEntry)
-        self._editableWidgets.append(self._xPixelSizeMetricEntry)
-        self._xPixelSizeLB = PadlockButton(self)
-        self._xPixelSizeLB.setMaximumSize(30, 30)
-        self._lockerPBs.append(self._xPixelSizeLB)
-        self._tree.setItemWidget(self._xPixelSizeQTWI, 2, self._xPixelSizeLB)
-
-        self._yPixelSizeQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
-        self._yPixelSizeQTWI.setText(0, "y pixel size")
-        self._yPixelSizeMetricEntry = MetricEntry("", parent=self)
-        self._yPixelSizeMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
-        self._tree.setItemWidget(self._yPixelSizeQTWI, 1, self._yPixelSizeMetricEntry)
-        self._editableWidgets.append(self._yPixelSizeMetricEntry)
-        self._yPixelSizeLB = PadlockButton(self)
-        self._yPixelSizeLB.setMaximumSize(30, 30)
-        self._lockerPBs.append(self._yPixelSizeLB)
-        self._tree.setItemWidget(self._yPixelSizeQTWI, 2, self._yPixelSizeLB)
-
-        ## distance
+        self._xDetectorPixelSizeQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
+        self._xDetectorPixelSizeQTWI.setText(0, "x pixel size")
+        self._xDetectorPixelSizeMetricEntry = MetricEntry("", parent=self)
+        self._xDetectorPixelSizeMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._xDetectorPixelSizeQTWI, 1, self._xDetectorPixelSizeMetricEntry
+        )
+        self._editableWidgets.append(self._xDetectorPixelSizeMetricEntry)
+        self._xDetectorPixelSizeLB = PadlockButton(self)
+        self._xDetectorPixelSizeLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._xDetectorPixelSizeLB)
+        self._tree.setItemWidget(
+            self._xDetectorPixelSizeQTWI, 2, self._xDetectorPixelSizeLB
+        )
+
+        self._yDetectorPixelSizeQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
+        self._yDetectorPixelSizeQTWI.setText(0, "y pixel size")
+        self._yDetectorPixelSizeMetricEntry = MetricEntry("", parent=self)
+        self._yDetectorPixelSizeMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._yDetectorPixelSizeQTWI, 1, self._yDetectorPixelSizeMetricEntry
+        )
+        self._editableWidgets.append(self._yDetectorPixelSizeMetricEntry)
+        self._yDetectorPixelSizeLB = PadlockButton(self)
+        self._yDetectorPixelSizeLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._yDetectorPixelSizeLB)
+        self._tree.setItemWidget(
+            self._yDetectorPixelSizeQTWI, 2, self._yDetectorPixelSizeLB
+        )
+
+        ## sample - distance
         self._sampleDetectorDistanceQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
-        self._sampleDetectorDistanceQTWI.setText(0, "distance")
-        self._distanceMetricEntry = MetricEntry("", parent=self)
-        self._distanceMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._sampleDetectorDistanceQTWI.setText(0, "sample-detector distance")
+        self._sampleDetectorDistanceMetricEntry = MetricEntry("", parent=self)
+        self._sampleDetectorDistanceMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._sampleDetectorDistanceQTWI, 1, self._sampleDetectorDistanceMetricEntry
+        )
+        self._editableWidgets.append(self._sampleDetectorDistanceMetricEntry)
+        self._sampleDetectorDistanceLB = PadlockButton(self)
+        self._sampleDetectorDistanceLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._sampleDetectorDistanceLB)
         self._tree.setItemWidget(
-            self._sampleDetectorDistanceQTWI, 1, self._distanceMetricEntry
+            self._sampleDetectorDistanceQTWI, 2, self._sampleDetectorDistanceLB
         )
-        self._editableWidgets.append(self._distanceMetricEntry)
-        self._distanceLB = PadlockButton(self)
-        self._distanceLB.setMaximumSize(30, 30)
-        self._lockerPBs.append(self._distanceLB)
-        self._tree.setItemWidget(self._sampleDetectorDistanceQTWI, 2, self._distanceLB)
 
         ## field of view
         self._fieldOfViewQTWI = qt.QTreeWidgetItem(self._detectorQTWI)
         self._fieldOfViewQTWI.setText(0, "field of view")
         self._fieldOfViewCB = qt.QComboBox(self)
-        for value in FOV.values():
-            self._fieldOfViewCB.addItem(value)
+        for FOV_item in FOV:
+            self._fieldOfViewCB.addItem(FOV_item.value)
         self._tree.setItemWidget(self._fieldOfViewQTWI, 1, self._fieldOfViewCB)
         self._editableWidgets.append(self._fieldOfViewCB)
         self._fieldOfViewLB = PadlockButton(self)
@@ -188,9 +201,77 @@ class NXtomoEditor(qt.QWidget):
         self._yFlippedLB.setMaximumSize(30, 30)
         self._lockerPBs.append(self._yFlippedLB)
         self._tree.setItemWidget(self._yFlippedQTWI, 2, self._yFlippedLB)
+        # source
+        self._sourceQTWI = qt.QTreeWidgetItem(self._instrumentQTWI)
+        self._sourceQTWI.setText(0, "source")
+        ## source - sample
+        self._sampleSourceDistanceQTWI = qt.QTreeWidgetItem(self._sourceQTWI)
+        self._sampleSourceDistanceQTWI.setText(0, "sample-source distance")
+        self._sampleSourceDistanceMetricEntry = MetricEntry("", parent=self)
+        self._sampleSourceDistanceMetricEntry.setToolTip(
+            "sample-source distance. Expected to be negative"
+        )
+        self._sampleSourceDistanceMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._sampleSourceDistanceQTWI, 1, self._sampleSourceDistanceMetricEntry
+        )
+        self._editableWidgets.append(self._sampleSourceDistanceMetricEntry)
+        self._sampleSourceDistanceLB = PadlockButton(self)
+        self._sampleSourceDistanceLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._sampleSourceDistanceLB)
+        self._tree.setItemWidget(
+            self._sampleSourceDistanceQTWI, 2, self._sampleSourceDistanceLB
+        )
         # 2: sample
         self._sampleQTWI = qt.QTreeWidgetItem(self._tree)
         self._sampleQTWI.setText(0, "sample")
+        # ## pixel size
+        self._xSamplePixelSizeQTWI = qt.QTreeWidgetItem(self._sampleQTWI)
+        self._xSamplePixelSizeQTWI.setText(0, "x pixel size")
+        self._xSamplePixelSizeMetricEntry = MetricEntry("", parent=self)
+        self._xSamplePixelSizeMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._xSamplePixelSizeQTWI, 1, self._xSamplePixelSizeMetricEntry
+        )
+        self._editableWidgets.append(self._xSamplePixelSizeMetricEntry)
+        self._xSamplePixelSizeLB = PadlockButton(self)
+        self._xSamplePixelSizeLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._xSamplePixelSizeLB)
+        self._tree.setItemWidget(
+            self._xSamplePixelSizeQTWI, 2, self._xSamplePixelSizeLB
+        )
+
+        self._ySamplePixelSizeQTWI = qt.QTreeWidgetItem(self._sampleQTWI)
+        self._ySamplePixelSizeQTWI.setText(0, "y pixel size")
+        self._ySamplePixelSizeMetricEntry = MetricEntry("", parent=self)
+        self._ySamplePixelSizeMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._ySamplePixelSizeQTWI, 1, self._ySamplePixelSizeMetricEntry
+        )
+        self._editableWidgets.append(self._ySamplePixelSizeMetricEntry)
+        self._ySamplePixelSizeLB = PadlockButton(self)
+        self._ySamplePixelSizeLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._ySamplePixelSizeLB)
+        self._tree.setItemWidget(
+            self._ySamplePixelSizeQTWI, 2, self._ySamplePixelSizeLB
+        )
+
+        ## propagation distance
+        self._propagationDistanceQTWI = qt.QTreeWidgetItem(self._sampleQTWI)
+        self._propagationDistanceQTWI.setText(0, "propagation distance")
+        self._propagationDistanceMetricEntry = MetricEntry("", parent=self)
+        self._propagationDistanceMetricEntry.layout().setContentsMargins(2, 2, 2, 2)
+        self._tree.setItemWidget(
+            self._propagationDistanceQTWI, 1, self._propagationDistanceMetricEntry
+        )
+        self._editableWidgets.append(self._propagationDistanceMetricEntry)
+        self._propagationDistanceLB = PadlockButton(self)
+        self._propagationDistanceLB.setMaximumSize(30, 30)
+        self._lockerPBs.append(self._propagationDistanceLB)
+        self._tree.setItemWidget(
+            self._propagationDistanceQTWI, 2, self._propagationDistanceLB
+        )
+
         ## x translation
         self._xTranslationQTWI = qt.QTreeWidgetItem(self._sampleQTWI)
         self._xTranslationQTWI.setText(0, "x translation")
@@ -215,12 +296,26 @@ class NXtomoEditor(qt.QWidget):
         # connect signal / slot
         self._energyEntry.editingFinished.connect(self._editingFinished)
         self._energyLockerLB.toggled.connect(self._editingFinished)
-        self._xPixelSizeMetricEntry.editingFinished.connect(self._editingFinished)
-        self._xPixelSizeLB.toggled.connect(self._editingFinished)
-        self._yPixelSizeMetricEntry.editingFinished.connect(self._editingFinished)
-        self._yPixelSizeLB.toggled.connect(self._editingFinished)
-        self._distanceMetricEntry.editingFinished.connect(self._editingFinished)
-        self._distanceLB.toggled.connect(self._editingFinished)
+        self._xDetectorPixelSizeMetricEntry.editingFinished.connect(
+            self._editingFinished
+        )
+        self._xDetectorPixelSizeLB.toggled.connect(self._editingFinished)
+        self._yDetectorPixelSizeMetricEntry.editingFinished.connect(
+            self._editingFinished
+        )
+        self._yDetectorPixelSizeLB.toggled.connect(self._editingFinished)
+        self._xSamplePixelSizeMetricEntry.editingFinished.connect(self._editingFinished)
+        self._xSamplePixelSizeLB.toggled.connect(self._editingFinished)
+        self._ySamplePixelSizeMetricEntry.editingFinished.connect(self._editingFinished)
+        self._ySamplePixelSizeLB.toggled.connect(self._editingFinished)
+        self._sampleDetectorDistanceMetricEntry.editingFinished.connect(
+            self._editingFinished
+        )
+        self._sampleDetectorDistanceLB.toggled.connect(self._editingFinished)
+        self._propagationDistanceMetricEntry.editingFinished.connect(
+            self._editingFinished
+        )
+        self._propagationDistanceLB.toggled.connect(self._editingFinished)
         self._fieldOfViewCB.currentIndexChanged.connect(self._editingFinished)
         self._fieldOfViewLB.toggled.connect(self._editingFinished)
         self._xFlippedCB.toggled.connect(self._editingFinished)
@@ -229,37 +324,106 @@ class NXtomoEditor(qt.QWidget):
         self._yFlippedLB.toggled.connect(self._editingFinished)
 
     def update_tree(self) -> None:
-        if self.getScan() is not None:
+        scan = self.getScan()
+        if scan is not None:
             self._updateInstrument()
             self._updateSample()
+            self._updateSource()
             self._tree.resizeColumnToContents(0)
 
+            # update items according to NXtomo nexus version
+            nexus_version = scan.nexus_version
+            if nexus_version is None:
+                nexus_version = _LATEST_NXTOMO_VERSION
+            # handle nxtomo 1.4 version
+            allow_source_sample_distance = bool(nexus_version >= 1.4)
+            self._sampleSourceDistanceMetricEntry.setEnabled(
+                allow_source_sample_distance
+            )
+            self._sampleSourceDistanceLB.setEnabled(allow_source_sample_distance)
+
+            # handle nxtomo 1.5 version
+            allow_sample_pixel_size_and_prop_distance = bool(nexus_version >= 1.5)
+            self._xSamplePixelSizeMetricEntry.setEnabled(
+                allow_sample_pixel_size_and_prop_distance
+            )
+            self._xSamplePixelSizeLB.setEnabled(
+                allow_sample_pixel_size_and_prop_distance
+            )
+            self._ySamplePixelSizeMetricEntry.setEnabled(
+                allow_sample_pixel_size_and_prop_distance
+            )
+            self._ySamplePixelSizeLB.setEnabled(
+                allow_sample_pixel_size_and_prop_distance
+            )
+            self._propagationDistanceMetricEntry.setEnabled(
+                allow_sample_pixel_size_and_prop_distance
+            )
+            self._propagationDistanceLB.setEnabled(
+                allow_sample_pixel_size_and_prop_distance
+            )
+
     def _updateInstrument(self) -> None:
         scan = self.getScan()
         if scan is None:
             return
-        else:
-            for name, fct in {
-                "energy": self._updateEnergy,
-                "pixel size": self._updatePixelSize,
-                "frame flips": self._updateFlipped,
-                "field of view": self._updateFieldOfView,
-                "sample-detector distance": self._updateDistance,
-            }.items():
-                try:
-                    fct(scan=scan)
-                except Exception as e:
-                    _logger.error(f"Failed to update {name}. Error is {e}")
+        update_dict = {
+            "energy": self._updateEnergy,
+            "detector pixel size": self._updateDetectorPixelSize,
+            "frame flips": self._updateFlipped,
+            "field of view": self._updateFieldOfView,
+            "sample-detector distance": self._updateSampleDetectorDistance,
+        }
+        if scan.nexus_version is None or scan.nexus_version >= 1.4:
+            update_dict.update(
+                {
+                    "sample-source distance": self._updateSampleSourceDistance,
+                }
+            )
+        if scan.nexus_version is None or scan.nexus_version >= 1.5:
+            update_dict.update(
+                {
+                    "propagation distance": self._updatePropagationDistance,
+                }
+            )
+        for name, fct in update_dict.items():
+            try:
+                fct(scan=scan)
+            except Exception as e:
+                _logger.error(f"Could not update {name}. Error is {e}")
 
     def _updateSample(self) -> None:
         scan = self.getScan()
         if scan is None:
             return
-        else:
+
+        update_dict = {
+            "translations": self._updateTranslations,
+        }
+        if scan.nexus_version is None or scan.nexus_version >= 1.5:
+            update_dict.update(
+                {
+                    "sample pixel size": self._updateSamplePixelSize,
+                    "propagation distance": self._updatePropagationDistance,
+                }
+            )
+        for name, fct in update_dict.items():
+            try:
+                fct(scan=scan)
+            except Exception as e:
+                _logger.error(f"Fail to update {name}. Error is {e}")
+
+    def _updateSource(self) -> None:
+        scan = self.getScan()
+        if scan is None:
+            return
+        if scan.nexus_version is None or scan.nexus_version >= 1.4:
             try:
-                self._updateTranslations(scan=scan)
+                self._updateSampleSourceDistance(scan=scan)
             except Exception as e:
-                _logger.error(f"Fail to update translations. Error is {e}")
+                _logger.error(
+                    f"Could not update sample - source distance. Error is {e}"
+                )
 
     def _updateTranslations(self, scan: NXtomoScan) -> None:
         assert isinstance(scan, NXtomoScan)
@@ -325,26 +489,52 @@ class NXtomoEditor(qt.QWidget):
         if (not self._yFlippedLB.isLocked()) and flip_ud is not None:
             self._yFlippedCB.setChecked(flip_ud)
 
-    def _updateDistance(self, scan: NXtomoScan) -> None:
-        if not self._distanceLB.isLocked():
-            # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
-            self._distanceMetricEntry.setValue(scan.distance)
+    def _updateSampleDetectorDistance(self, scan: NXtomoScan) -> None:
+        if not self._sampleDetectorDistanceLB.isLocked():
+            # if in 'auto' mode: we want to overwrite the NXtomo existing value by the one of the GUI
+            self._sampleDetectorDistanceMetricEntry.setValue(
+                scan.sample_detector_distance
+            )
+
+    def _updateSampleSourceDistance(self, scan: NXtomoScan) -> None:
+        if not self._sampleSourceDistanceLB.isLocked():
+            self._sampleSourceDistanceMetricEntry.setValue(scan.source_sample_distance)
+
+    def _updatePropagationDistance(self, scan: NXtomoScan) -> None:
+        if not self._propagationDistanceLB.isLocked():
+            # if in 'auto' mode: we want to overwrite the NXtomo existing value by the one of the GUI
+            self._propagationDistanceMetricEntry.setValue(scan.propagation_distance)
 
     def _updateEnergy(self, scan: NXtomoScan) -> None:
         assert isinstance(scan, NXtomoScan)
         if not self._energyLockerLB.isLocked():
-            # if in ''auto mode: we want to overwrite the NXtomo existing value by the one of the GUI
-            energy = scan.energy
-            self._energyEntry.setValue(energy)
-
-    def _updatePixelSize(self, scan: NXtomoScan) -> None:
+            # if in 'auto' mode: we want to overwrite the NXtomo existing value by the one of the GUI
+            energy_in_kev: float | None = scan.energy
+            if energy_in_kev is not None:
+                # move from float to pint.Quantity
+                assert not isinstance(energy_in_kev, pint.Quantity)
+            self._energyEntry.setValue(energy_in_kev)
+
+    def _updateDetectorPixelSize(self, scan: NXtomoScan) -> None:
         assert isinstance(scan, NXtomoScan)
-        if not self._xPixelSizeLB.isLocked():
-            x_pixel_size = scan.x_pixel_size
-            self._xPixelSizeMetricEntry.setValue(x_pixel_size)
-        if not self._yPixelSizeLB.isLocked():
-            y_pixel_size = scan.y_pixel_size
-            self._yPixelSizeMetricEntry.setValue(y_pixel_size)
+        if not self._xDetectorPixelSizeLB.isLocked():
+            x_pixel_size = scan.detector_x_pixel_size
+            self._xDetectorPixelSizeMetricEntry.setValue(x_pixel_size)
+        if not self._yDetectorPixelSizeLB.isLocked():
+            y_pixel_size = scan.detector_y_pixel_size
+            self._yDetectorPixelSizeMetricEntry.setValue(y_pixel_size)
+
+    def _updateSamplePixelSize(self, scan: NXtomoScan) -> None:
+        if not self._xSamplePixelSizeLB.isLocked():
+            # if in 'auto' mode: we want to overwrite the NXtomo existing value by the one of the GUI
+            self._xSamplePixelSizeMetricEntry.setValue(
+                scan.get_sample_pixel_size(which="x", fallback_to_det_pixel_size=False)
+            )
+        if not self._ySamplePixelSizeLB.isLocked():
+            # if in 'auto' mode: we want to overwrite the NXtomo existing value by the one of the GUI
+            self._ySamplePixelSizeMetricEntry.setValue(
+                scan.get_sample_pixel_size(which="y", fallback_to_det_pixel_size=False)
+            )
 
     def _editingFinished(self, *args, **kwargs):
         self.sigEditingFinished.emit()
@@ -384,24 +574,61 @@ class NXtomoEditor(qt.QWidget):
         Return a dict with field full name as key
         and a tuple as value (field_value, is_locked)
 
+        field_value is given in keV for energies else in 'base units'
+
         limitation: for now sample position are not handled because this is a 'corner case' for now
         """
+
+        def to_base_units_magnitude_if_exists(value: None | pint.Quantity):
+            if value is None:
+                return None
+            else:
+                return value.to_base_units().magnitude
+
+        energy = self._energyEntry.getValue()
+        if energy is not None:
+            assert isinstance(energy, float)
+
         return {
             NXtomoEditorKeys.ENERGY: (
-                self._energyEntry.getValue(),
+                energy,
                 self._energyLockerLB.isLocked(),
             ),
-            NXtomoEditorKeys.X_PIXEL_SIZE: (
-                self._xPixelSizeMetricEntry.getValue(),
-                self._xPixelSizeLB.isLocked(),
+            NXtomoEditorKeys.DETECTOR_X_PIXEL_SIZE: (
+                to_base_units_magnitude_if_exists(
+                    self._xDetectorPixelSizeMetricEntry.getValue()
+                ),
+                self._xDetectorPixelSizeLB.isLocked(),
             ),
-            NXtomoEditorKeys.Y_PIXEL_SIZE: (
-                self._yPixelSizeMetricEntry.getValue(),
-                self._yPixelSizeLB.isLocked(),
+            NXtomoEditorKeys.DETECTOR_Y_PIXEL_SIZE: (
+                to_base_units_magnitude_if_exists(
+                    self._yDetectorPixelSizeMetricEntry.getValue()
+                ),
+                self._yDetectorPixelSizeLB.isLocked(),
+            ),
+            NXtomoEditorKeys.SAMPLE_X_PIXEL_SIZE: (
+                to_base_units_magnitude_if_exists(
+                    self._xSamplePixelSizeMetricEntry.getValue()
+                ),
+                self._xSamplePixelSizeLB.isLocked(),
+            ),
+            NXtomoEditorKeys.SAMPLE_Y_PIXEL_SIZE: (
+                to_base_units_magnitude_if_exists(
+                    self._ySamplePixelSizeMetricEntry.getValue()
+                ),
+                self._ySamplePixelSizeLB.isLocked(),
             ),
             NXtomoEditorKeys.SAMPLE_DETECTOR_DISTANCE: (
-                self._distanceMetricEntry.getValue(),
-                self._distanceLB.isLocked(),
+                to_base_units_magnitude_if_exists(
+                    self._sampleDetectorDistanceMetricEntry.getValue()
+                ),
+                self._sampleDetectorDistanceLB.isLocked(),
+            ),
+            NXtomoEditorKeys.SAMPLE_SOURCE_DISTANCE: (
+                to_base_units_magnitude_if_exists(
+                    self._sampleSourceDistanceMetricEntry.getValue()
+                ),
+                self._sampleSourceDistanceLB.isLocked(),
             ),
             NXtomoEditorKeys.FIELD_OF_VIEW: (
                 self._fieldOfViewCB.currentText(),
@@ -415,55 +642,124 @@ class NXtomoEditor(qt.QWidget):
                 self._yFlippedCB.isChecked(),
                 self._yFlippedLB.isChecked(),
             ),
-            NXtomoEditorKeys.X_TRANSLATION: (self._xTranslationQLE.getValue(),),
-            NXtomoEditorKeys.Z_TRANSLATION: (self._zTranslationQLE.getValue(),),
+            NXtomoEditorKeys.PROPAGATION_DISTANCE: (
+                to_base_units_magnitude_if_exists(
+                    self._propagationDistanceMetricEntry.getValue(),
+                ),
+                self._propagationDistanceLB.isLocked(),
+            ),
+            NXtomoEditorKeys.X_TRANSLATION: (
+                to_base_units_magnitude_if_exists(self._xTranslationQLE.getValue()),
+            ),
+            NXtomoEditorKeys.Z_TRANSLATION: (
+                to_base_units_magnitude_if_exists(self._zTranslationQLE.getValue()),
+            ),
         }
 
     def setConfiguration(self, config: dict) -> None:
-        energy = config.get("instrument.beam.energy", None)
+        """
+        Load given configuration. We expect all quantities to be given:
+        * in keV for energies
+        * else in base units
+        """
+        # energy
+        energy = config.get(NXtomoEditorKeys.ENERGY, None)
         if energy is not None:
             energy, energy_locked = energy
+            assert energy is None or isinstance(
+                energy, float
+            ), "energy is expected to be dimensionless (float) already in keV"
             self._energyEntry.setValue(energy)
             self._energyLockerLB.setLock(energy_locked)
 
-        x_pixel_size = config.get("instrument.detector.x_pixel_size", None)
-        if x_pixel_size is not None:
-            x_pixel_size, x_pixel_size_locked = x_pixel_size
-            self._xPixelSizeMetricEntry.setValue(x_pixel_size)
-            self._xPixelSizeLB.setLock(x_pixel_size_locked)
-
-        y_pixel_size = config.get("instrument.detector.y_pixel_size", None)
-        if y_pixel_size is not None:
-            y_pixel_size, y_pixel_size_locked = y_pixel_size
-            self._yPixelSizeMetricEntry.setValue(y_pixel_size)
-            self._yPixelSizeLB.setLock(y_pixel_size_locked)
-
-        detector_sample_distance = config.get("instrument.detector.distance", None)
-        if detector_sample_distance is not None:
-            detector_sample_distance, distance_locked = detector_sample_distance
-            self._distanceMetricEntry.setValue(detector_sample_distance)
-            self._distanceLB.setLock(x_pixel_size_locked)
-
-        field_of_view = config.get("instrument.detector.field_of_view", None)
+        # detector pixel size
+        detector_x_pixel_size = config.get(NXtomoEditorKeys.DETECTOR_X_PIXEL_SIZE, None)
+        if detector_x_pixel_size is not None:
+            detector_x_pixel_size, detector_x_pixel_size_locked = detector_x_pixel_size
+            self._xDetectorPixelSizeMetricEntry.setValue(
+                detector_x_pixel_size, displayed_unit=_ureg.meter
+            )
+            self._xDetectorPixelSizeLB.setLock(detector_x_pixel_size_locked)
+
+        detector_y_pixel_size = config.get(NXtomoEditorKeys.DETECTOR_Y_PIXEL_SIZE, None)
+        if detector_y_pixel_size is not None:
+            detector_y_pixel_size, detector_y_pixel_size_locked = detector_y_pixel_size
+            self._yDetectorPixelSizeMetricEntry.setValue(
+                detector_y_pixel_size, displayed_unit=_ureg.meter
+            )
+            self._yDetectorPixelSizeLB.setLock(detector_y_pixel_size_locked)
+
+        # sample detector distance
+        sample_detector_distance = config.get(
+            NXtomoEditorKeys.SAMPLE_DETECTOR_DISTANCE, None
+        )
+        if sample_detector_distance is not None:
+            sample_detector_distance, distance_locked = sample_detector_distance
+            self._sampleDetectorDistanceMetricEntry.setValue(
+                sample_detector_distance, displayed_unit=_ureg.meter
+            )
+            self._sampleDetectorDistanceLB.setLock(distance_locked)
+
+        # field of view
+        field_of_view = config.get(NXtomoEditorKeys.FIELD_OF_VIEW, None)
         if field_of_view is not None:
             field_of_view, field_of_view_locked = field_of_view
-            self._fieldOfViewCB.setCurrentText(field_of_view)
+            field_of_view = FOV.from_value(field_of_view)
+            self._fieldOfViewCB.setCurrentText(field_of_view.value)
             self._fieldOfViewLB.setLock(field_of_view_locked)
 
-        x_flipped = config.get("instrument.detector.x_flipped", None)
+        # detector flips
+        x_flipped = config.get(NXtomoEditorKeys.X_FLIPPED, None)
         if x_flipped is not None:
             x_flipped, x_flipped_locked = x_flipped
             x_flipped = x_flipped in (True, "True", "true")
             self._xFlippedCB.setChecked(x_flipped)
             self._xFlippedLB.setLock(x_flipped_locked)
 
-        y_flipped = config.get("instrument.detector.y_flipped", None)
+        y_flipped = config.get(NXtomoEditorKeys.Y_FLIPPED, None)
         if y_flipped is not None:
             y_flipped, y_flipped_locked = y_flipped
             y_flipped = y_flipped in (True, "True", "true")
             self._yFlippedCB.setChecked(y_flipped)
             self._yFlippedLB.setLock(y_flipped_locked)
 
+        # sample source distance
+        sample_source_distance = config.get(
+            NXtomoEditorKeys.SAMPLE_SOURCE_DISTANCE, None
+        )
+        if sample_source_distance is not None:
+            sample_source_distance, sample_source_distance_locked = (
+                sample_source_distance
+            )
+            if sample_source_distance >= 0:
+                _logger.warning("the sample-source is expected to be negative")
+            self._sampleSourceDistanceMetricEntry.setValue(sample_source_distance)
+            self._sampleSourceDistanceLB.setLock(sample_source_distance_locked)
+
+        # sample pixel size
+        sample_x_pixel_size = config.get(NXtomoEditorKeys.SAMPLE_X_PIXEL_SIZE, None)
+        if sample_x_pixel_size is not None:
+            sample_x_pixel_size, x_sample_pixel_size_locked = sample_x_pixel_size
+            self._xSamplePixelSizeMetricEntry.setValue(
+                sample_x_pixel_size, displayed_unit=_ureg.meter
+            )
+            self._xSamplePixelSizeLB.setLock(x_sample_pixel_size_locked)
+
+        sample_y_pixel_size = config.get(NXtomoEditorKeys.SAMPLE_Y_PIXEL_SIZE, None)
+        if sample_y_pixel_size is not None:
+            sample_y_pixel_size, sample_y_pixel_size_locked = sample_y_pixel_size
+            self._ySamplePixelSizeMetricEntry.setValue(
+                sample_y_pixel_size, displayed_unit=_ureg.meter
+            )
+            self._ySamplePixelSizeLB.setLock(sample_y_pixel_size_locked)
+
+        # propagation distance
+        propagation_distance = config.get(NXtomoEditorKeys.PROPAGATION_DISTANCE, None)
+        if propagation_distance is not None:
+            propagation_distance, propagation_distance_locked = propagation_distance
+            self._propagationDistanceMetricEntry.setValue(propagation_distance)
+            self._propagationDistanceLB.setChecked(propagation_distance_locked)
+
     def getConfigurationForTask(self) -> dict:
         """
         default configuration is stored as field: (field_value, filed_is_locked) when the task expects field_key: field_value
@@ -498,7 +794,7 @@ class _TranslationMetricEntry(MetricEntry):
             else:
                 return super().validate(a0, a1)
 
-    def __init__(self, name, default_unit="m", parent=None):
+    def __init__(self, name, default_unit=_ureg.meter, parent=None):
         super().__init__(name, default_unit=default_unit, parent=parent)
         self._qlePixelSize.setValidator(self.TranslationValidator(self))
 
@@ -517,18 +813,30 @@ class _TranslationMetricEntry(MetricEntry):
 
 
 class EnergyEntry(qt.QLineEdit):
+    """
+    QLineEdit enabling to handle an energy in keV
+    """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.setValidator(MetricEntry.DoubleValidator())
 
-    def setValue(self, a0):
-        if a0 is None:
-            a0 = "unknown"
+    def setValue(self, value_kev: float | None):
+        if not isinstance(value_kev, (float, type(None))):
+            raise TypeError(
+                f"a0 is expected to be {None} or an instance of {float}. Got {type(value_kev)}"
+            )
+
+        if value_kev is None:
+            value_kev = "unknown"
         else:
-            a0 = str(a0)
-        super().setText(a0)
+            value_kev = str(value_kev)
+        super().setText(value_kev)
 
     def getValue(self) -> float | None:
+        """
+        Return energy in keV or None
+        """
         txt = self.text().replace(" ", "")
         if txt in ("unknown", ""):
             return None