tomwer 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

orangecontrib/tomwer/widgets/reconstruction/AxisOW.py

@@ -93,11 +93,7 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
     sigScanReady = qt.Signal(TomwerScanBase)
     """Signal emitted when a scan is ready"""
 
-    _rpSetting = Setting(dict())
-    "AxisRP store as dict"
-    # this one is keep for backward compatibility. Will be removed on 0.10 I guess
-
-    static_input = Setting({"data": None, "axis_params": None})
+    _ewoks_default_inputs = Setting({"data": None, "axis_params": None, "gui": None})
 
     class Inputs:
         data = Input(name="data", type=TomwerScanBase, doc="one scan to be process")
@@ -126,17 +122,18 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
         self._axis_params = axis_params or QAxisRP()
 
         # handle settings
-        axis_params_settings = self.static_input.get("axis_params", None)
-        if axis_params_settings is None:
-            axis_params_settings = self._rpSetting.copy()
-        if axis_params_settings != dict():
+        #  axis params settings
+        axis_params_settings = self._ewoks_default_inputs.get("axis_params", None)
+        if axis_params_settings not in (None, dict()):
             try:
                 self._axis_params.load_from_dict(axis_params_settings)
             except Exception as e:
-                logger.error("fail to load reconstruction settings:", str(e))
-        gui_settings = self.static_input.get("gui", None)
+                logger.error(f"fail to load reconstruction settings: {str(e)}")
+
+        #  gui settings
+        gui_settings = self._ewoks_default_inputs.get("gui", {})
         if gui_settings is None:
-            gui_settings = self._rpSetting.get("gui", {})
+            gui_settings = {}
 
         original_mode = self._axis_params.mode
         if original_mode is AxisMode.manual:
@@ -236,6 +233,16 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
                     relative_cor=original_cor, abs_cor=None
                 )
 
+    def __new__(cls, *args, **kwargs):
+        # ensure backward compatibility with 'static_input'
+        static_input = kwargs.get("stored_settings", {}).get("static_input", None)
+        if static_input not in (None, {}):
+            logger.warning(
+                "static_input has been deprecated. Will be replaced by _ewoks_default_inputs in the workflow file. Please save the workflow to apply modifications"
+            )
+            kwargs["stored_settings"]["_ewoks_default_inputs"] = static_input
+        return super().__new__(cls, *args, **kwargs)
+
     def _processingStart(self, *args, **kwargs):
         WidgetLongProcessing._startProcessing(self)
 
@@ -362,8 +369,7 @@ class AxisOW(SuperviseOW, WidgetLongProcessing):
 
     def _updateSettingsVals(self):
         # remove rp setting to the advantage of 'static_input'
-        self._rpSetting = {}
-        self.static_input = {
+        self._ewoks_default_inputs = {
             "data": None,
             "axis_params": self._axis_params.to_dict(),
             "gui": {

orangecontrib/tomwer/widgets/reconstruction/CastNabuVolumeOW.py

@@ -31,7 +31,6 @@ from typing import Optional
 
 from processview.core.manager.manager import DatasetState, ProcessManager
 from tomwer.core import settings
-from orangecontrib.tomwer.widgets import utils
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
 from ...orange.managedprocess import SuperviseOW
@@ -45,6 +44,7 @@ from tomwer.synctools.stacks.reconstruction.castvolume import CastVolumeProcessS
 import tomwer.core.process.reconstruction.nabu.castvolume
 from tomwer.gui.reconstruction.nabu.castvolume import CastVolumeWidget
 from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.utils import isLowOnMemory
 import logging
 
 _logger = logging.getLogger(__name__)
@@ -88,10 +88,7 @@ class CastNabuVolumeOW(WidgetLongProcessing, SuperviseOW):
     compress_signal = False
     allows_cycle = True
 
-    _rpSetting = Setting(dict())
-    # kept for compatibility
-
-    static_input = Setting({"data": None, "cast_volume_params": {}})
+    _ewoks_default_inputs = Setting({"data": None, "cast_volume_params": {}})
 
     sigScanReady = qt.Signal(TomwerScanBase)
     "Signal emitted when a scan is ended"
@@ -123,7 +120,10 @@ class CastNabuVolumeOW(WidgetLongProcessing, SuperviseOW):
 
     class Outputs:
         data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
-        volume = Output(name="volume", type=TomwerVolumeBase, doc="cast volumes")
+        volume = Output(name="volume", type=TomwerVolumeBase, doc="raw volume")
+        cast_volume = Output(
+            name="cast volume", type=TomwerVolumeBase, doc="cast volume"
+        )
         future_tomo_obj = Output(
             name="future_tomo_obj",
             type=FutureTomwerObject,
@@ -144,14 +144,24 @@ class CastNabuVolumeOW(WidgetLongProcessing, SuperviseOW):
 
         self._layout.addWidget(self._window)
 
-        self.setConfiguration(self.static_input.get("cast_volume_params", {}))
+        cast_volume_params = self._ewoks_default_inputs.get("cast_volume_params", {})
+        self.setConfiguration(cast_volume_params)
 
         # connect signal / slot
         self._window.sigConfigChanged.connect(self._updateConfig)
-        # connect signal / slot
         self._processingStack.sigComputationStarted.connect(self._startProcessing)
         self._processingStack.sigComputationEnded.connect(self._endProcessing)
 
+    def __new__(cls, *args, **kwargs):
+        # ensure backward compatibility with 'static_input'
+        static_input = kwargs.get("stored_settings", {}).get("static_input", None)
+        if static_input not in (None, {}):
+            _logger.warning(
+                "static_input has been deprecated. Will be replaced by _ewoks_default_inputs in the workflow file. Please save the workflow to apply modifications"
+            )
+            kwargs["stored_settings"]["_ewoks_default_inputs"] = static_input
+        return super().__new__(cls, *args, **kwargs)
+
     @Inputs.data
     def process_data(self, scan: Optional[TomwerScanBase]):
         if scan is None:
@@ -162,7 +172,7 @@ class CastNabuVolumeOW(WidgetLongProcessing, SuperviseOW):
             )
         if (
             settings.isOnLbsram(scan)
-            and utils.isLowOnMemory(settings.get_lbsram_path()) is True
+            and isLowOnMemory(settings.get_lbsram_path()) is True
         ):
             ProcessManager().notify_dataset_state(
                 dataset=scan,
@@ -203,7 +213,7 @@ class CastNabuVolumeOW(WidgetLongProcessing, SuperviseOW):
         self._window.setConfiguration(configuration)
 
     def _updateConfig(self):
-        self.static_input = {
+        self._ewoks_default_inputs = {
             "data": None,
             "cast_volume_params": self.getConfiguration(),
         }
@@ -217,3 +227,7 @@ class CastNabuVolumeOW(WidgetLongProcessing, SuperviseOW):
                 self.Outputs.data.send(obj)
             elif isinstance(obj, TomwerVolumeBase):
                 self.Outputs.volume.send(obj)
+            # for now we store a cast_volume to the object but this is not very well design.
+            # I guess this will be removed once we move to ewoks or we need to redesign the stack approach
+            if obj.cast_volume is not None:
+                self.Outputs.cast_volume.send(obj.cast_volume)

orangecontrib/tomwer/widgets/reconstruction/DarkRefAndCopyOW.py

@@ -38,7 +38,6 @@ from orangewidget.widget import Input, Output
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.reconstruction.darkref.darkrefcopywidget import DarkRefAndCopyWidget
 from tomwer.synctools.darkref import QDKRFRP
-from tomwer.web.client import OWClient
 from tomwer.synctools.stacks.reconstruction.dkrefcopy import DarkRefCopyProcessStack
 from processview.core.manager import DatasetState
 from processview.core.manager import ProcessManager
@@ -50,7 +49,7 @@ import copy
 _logger = logging.getLogger(__name__)
 
 
-class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
+class DarkRefAndCopyOW(SuperviseOW, WidgetLongProcessing):
     """
     A simple widget managing the copy of an incoming folder to an other one
 
@@ -58,9 +57,11 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
     """
 
     # note of this widget should be the one registered on the documentation
-    name = "dark and flat field construction"
+    name = "reduced darks and flats"
     id = "orange.widgets.tomwer.darkrefs"
-    description = "This widget will generate dark refs for a received scan "
+    description = (
+        "This widget will generate reduced darks and flats for a received scan "
+    )
     icon = "icons/darkref.svg"
     priority = 15
     keywords = ["tomography", "dark", "darks", "ref", "refs", "flat", "flats"]
@@ -69,11 +70,7 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
     resizing_enabled = True
     compress_signal = False
 
-    _rpSetting = Setting(dict())
-    """Setting to load and save DarkRefAndCopyWidget settings"""
-    # this one is keep for backward compatibility. Will be removed on 0.10 I guess
-
-    static_input = Setting({"data": None, "dark_ref_params": None})
+    _ewoks_default_inputs = Setting({"data": None, "dark_ref_params": None})
 
     sigScanReady = qt.Signal(TomwerScanBase)
     """Signal emitted when a scan is ready"""
@@ -112,15 +109,12 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
         :param QKRFRP reconsparams: reconstruction parameters
         """
         SuperviseOW.__init__(self, parent)
-        OWClient.__init__(self)
         WidgetLongProcessing.__init__(self)
         recons_params = reconsparams or QDKRFRP()
         self._processing_stack = DarkRefCopyProcessStack(process_id=self.process_id)
 
-        dark_ref_params = self.static_input.get("dark_ref_params", None)
-        if dark_ref_params is None:
-            dark_ref_params = self._rpSetting
-        if dark_ref_params != dict():
+        dark_ref_params = self._ewoks_default_inputs.get("dark_ref_params", None)
+        if dark_ref_params not in ({}, None):
             try:
                 recons_params.dkrf.load_from_dict(dark_ref_params)
             except Exception:
@@ -153,7 +147,7 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
         self._processing_stack.sigRefSetted.connect(self.widget.setRefSetBy)
 
         # load some other copy parameters
-        if dark_ref_params != dict():
+        if dark_ref_params not in ({}, None):
             try:
                 if "activate" in dark_ref_params:
                     self.widget.setCopyActive(dark_ref_params.pop("activate"))
@@ -168,6 +162,16 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
 
         self.setCaption(self.windowTitle())
 
+    def __new__(cls, *args, **kwargs):
+        # ensure backward compatibility with 'static_input'
+        static_input = kwargs.get("stored_settings", {}).get("static_input", None)
+        if static_input not in (None, {}):
+            _logger.warning(
+                "static_input has been deprecated. Will be replaced by _ewoks_default_inputs in the workflow file. Please save the workflow to apply modifications"
+            )
+            kwargs["stored_settings"]["_ewoks_default_inputs"] = static_input
+        return super().__new__(cls, *args, **kwargs)
+
     @Inputs.data
     def process(self, scanID):
         if scanID is None:
@@ -204,15 +208,16 @@ class DarkRefAndCopyOW(SuperviseOW, OWClient, WidgetLongProcessing):
         self.sigScanReady.emit(scanID)
 
     def _updateSettingsVals(self):
-        self._rpSetting = self.widget.recons_params.to_dict()
-        self._rpSetting["auto"] = self.widget.isOnModeAuto()
-        self._rpSetting["activate"] = self.widget.isCopyActive()
-        self.static_input = {
+        self._ewoks_default_inputs = {
             "data": None,
             "dark_ref_params": self.widget.recons_params.to_dict(),
         }
-        self.static_input["dark_ref_params"]["auto"] = self.widget.isOnModeAuto()
-        self.static_input["dark_ref_params"]["activate"] = self.widget.isCopyActive()
+        self._ewoks_default_inputs["dark_ref_params"][
+            "auto"
+        ] = self.widget.isOnModeAuto()
+        self._ewoks_default_inputs["dark_ref_params"][
+            "activate"
+        ] = self.widget.isCopyActive()
 
     @property
     def recons_params(self):

orangecontrib/tomwer/widgets/reconstruction/NabuOW.py

@@ -30,7 +30,7 @@ __date__ = "14/02/2020"
 
 import logging
 from typing import Optional
-
+from tomwer.core.volume.volumefactory import VolumeFactory
 import tomwer.core.process.reconstruction.nabu.nabuslices
 from contextlib import AbstractContextManager
 from silx.gui import qt
@@ -71,11 +71,7 @@ class NabuOW(WidgetLongProcessing, SuperviseOW):
     compress_signal = False
     allows_cycle = True
 
-    # TODO: replace Nabu by default nabu recons by the new orange contrib
-    static_input = Setting({"data": None, "nabu_params": None})
-
-    _rpSetting = Setting(dict())
-    # this one is keep for backward compatibility. Will be removed on 0.10 I guess
+    _ewoks_default_inputs = Setting({"data": None, "nabu_params": None})
 
     ewokstaskclass = tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlices
 
@@ -111,6 +107,8 @@ class NabuOW(WidgetLongProcessing, SuperviseOW):
             doc="data with some remote processing",
         )
 
+        slice_urls = Output(name="slice urls", type=tuple, doc="tuple of urls created")
+
     class DialogCM(AbstractContextManager):
         """Simple context manager to hide / show button dialogs"""
 
@@ -157,10 +155,8 @@ class NabuOW(WidgetLongProcessing, SuperviseOW):
         self._buttons.hide()
 
         # load settings
-        nabu_params = self.static_input.get("nabu_params", None)
-        if nabu_params is None:
-            nabu_params = self._rpSetting
-        if nabu_params != dict():
+        nabu_params = self._ewoks_default_inputs.get("nabu_params", None)
+        if nabu_params not in (dict(), None):
             try:
                 self._nabuWidget.setConfiguration(nabu_params)
             except Exception:
@@ -176,6 +172,16 @@ class NabuOW(WidgetLongProcessing, SuperviseOW):
         self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self.accept)
         self._nabuWidget.sigConfigChanged.connect(self._updateSettingsVals)
 
+    def __new__(cls, *args, **kwargs):
+        # ensure backward compatibility with 'static_input'
+        static_input = kwargs.get("stored_settings", {}).get("static_input", None)
+        if static_input not in (None, {}):
+            _logger.warning(
+                "static_input has been deprecated. Will be replaced by _ewoks_default_inputs in the workflow file. Please save the workflow to apply modifications"
+            )
+            kwargs["stored_settings"]["_ewoks_default_inputs"] = static_input
+        return super().__new__(cls, *args, **kwargs)
+
     @Inputs.data
     def process(self, scan: TomwerScanBase):
         assert isinstance(scan, (TomwerScanBase, type(None)))
@@ -231,9 +237,21 @@ class NabuOW(WidgetLongProcessing, SuperviseOW):
     def _endProcessing(self, scan, future_tomo_obj):
         WidgetLongProcessing._endProcessing(self, scan)
         if scan is not None:
+            # send scan
             self.Outputs.data.send(scan)
+            # send slice urls
+            slice_urls = []
+            for rec_identifier in scan.latest_reconstructions:
+                slice_urls.extend(
+                    VolumeFactory.from_identifier_to_vol_urls(rec_identifier)
+                )
+            if len(slice_urls) > 0:
+                slice_urls = tuple(slice_urls)
+                self.Outputs.slice_urls.send(slice_urls)
+
             self.sigScanReady.emit(scan)
         if future_tomo_obj is not None:
+            # send future scan
             self.Outputs.future_out.send(future_tomo_obj)
 
     def setDryRun(self, dry_run):
@@ -249,11 +267,10 @@ class NabuOW(WidgetLongProcessing, SuperviseOW):
         self.__exec_for_ci = True
 
     def _updateSettingsVals(self):
-        self.static_input = {
+        self._ewoks_default_inputs = {
             "data": None,
             "nabu_params": self.getConfiguration(),
         }
-        self._rpSetting = self.getConfiguration()
 
     def getConfiguration(self):
         config = self._nabuWidget.getConfiguration()

orangecontrib/tomwer/widgets/reconstruction/NabuVolumeOW.py

@@ -32,12 +32,13 @@ import logging
 from contextlib import AbstractContextManager
 from silx.gui import qt
 from tomwer.synctools.stacks.reconstruction.nabu import NabuVolumeProcessStack
-from tomwer.core.process.reconstruction.nabu.nabuvolume import NabuVolume, VolumeRunner
+from tomwer.core.process.reconstruction.nabu.nabuvolume import NabuVolume
 from tomwer.gui.reconstruction.nabu.volume import NabuVolumeWindow
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
 from orangecontrib.tomwer.widgets.utils import WidgetLongProcessing
+from tomwer.core.volume.volumefactory import VolumeFactory
 from orangewidget.settings import Setting
 from orangewidget import gui
 from orangewidget.widget import Input, Output
@@ -49,6 +50,8 @@ from tomwer.utils import docstring
 from tomwer.core import settings
 import tomwer.core.process.reconstruction.nabu.nabuvolume
 from tomwer.core.volume.volumebase import TomwerVolumeBase
+from tomwer.core.utils.scanutils import format_output_location
+from tomoscan.identifier import VolumeIdentifier
 import functools
 import copy
 
@@ -79,10 +82,7 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
     compress_signal = False
     allows_cycle = True
 
-    _rpSetting = Setting(dict())
-    # kept for compatibility
-
-    static_input = Setting(
+    _ewoks_default_inputs = Setting(
         {"data": None, "nabu_volume_params": None, "nabu_params": None}
     )
 
@@ -119,6 +119,9 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
             type=TomwerVolumeBase,
             doc="volume(s) created",
         )
+        volume_urls = Output(
+            name="volume urls", type=tuple, doc="url of the volume(s) reconstructed"
+        )
 
     class DialogCM(AbstractContextManager):
         """Simple context manager to hida / show button dialogs"""
@@ -132,7 +135,7 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
         def __exit__(self, exc_type, exc_val, exc_tb):
             self._dialogButtonsBox.hide()
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, *args, **kwargs):
         """
         Widget which read the .hdf5 generated by octave and modify it.
         Then run a subprocess to call octave and run ftseries
@@ -164,10 +167,9 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
         self._buttons.hide()
 
         # load settings
-        nabu_volume_params = self.static_input.get("nabu_volume_params", None)
-        if nabu_volume_params is None:
-            nabu_volume_params = self._rpSetting
-        if nabu_volume_params != dict():
+        nabu_volume_params = self._ewoks_default_inputs.get("nabu_volume_params", None)
+
+        if nabu_volume_params not in (dict(), None):
             try:
                 self._nabuWidget.setConfiguration(nabu_volume_params)
             except Exception:
@@ -179,6 +181,16 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
         self._buttons.button(qt.QDialogButtonBox.Ok).clicked.connect(self.accept)
         self._nabuWidget.sigConfigChanged.connect(self._updateSettingsVals)
 
+    def __new__(cls, *args, **kwargs):
+        # ensure backward compatibility with 'static_input'
+        static_input = kwargs.get("stored_settings", {}).get("static_input", None)
+        if static_input not in (None, {}):
+            _logger.warning(
+                "static_input has been deprecated. Will be replaced by _ewoks_default_inputs in the workflow file. Please save the workflow to apply modifications"
+            )
+            kwargs["stored_settings"]["_ewoks_default_inputs"] = static_input
+        return super().__new__(cls, *args, **kwargs)
+
     @Inputs.data
     def process(self, scan: TomwerScanBase):
         assert isinstance(scan, (TomwerScanBase, type(None)))
@@ -207,7 +219,7 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
             ] = self._nabuWidget._mainWidget.getNabuFileFormat()
         # update output location if requested
         if self._nabuWidget._mainWidget.redefineOutputLocation():
-            config.get("output")["location"] = VolumeRunner.format_output_location(
+            config.get("output")["location"] = format_output_location(
                 location=self._nabuWidget._mainWidget.getNabuOutputLocation(),
                 scan=scan,
             )
@@ -272,7 +284,7 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
         db = dialog.getSelectedValue()
         if db is not None:
             try:
-                scan.nabu_recons_params["phase"]["delta_beta"] = db
+                scan.nabu_recons_params["phase"]["delta_beta"] = (db,)
             except Exception as e:
                 logging.error(e)
             else:
@@ -281,10 +293,27 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
     def _endProcessing(self, scan, future_tomo_obj):
         WidgetLongProcessing._endProcessing(self, scan)
         if scan is not None:
+            # send scan
             self.Outputs.data.send(scan)
             self.sigScanReady.emit(scan)
-            for vol in scan.latest_vol_reconstructions:
-                self.Outputs.volume.send(vol)
+            # send volume urls
+            volume_urls = []
+            for volume_id in scan.latest_vol_reconstructions:
+                assert isinstance(volume_id, VolumeIdentifier)
+                volume_urls.extend(VolumeFactory.from_identifier_to_vol_urls(volume_id))
+            if len(volume_urls) > 0:
+                self.Outputs.volume_urls.send(tuple(volume_urls))
+            # send volume identifier(s)  # only one expected
+            n_rec_volumes = len(scan.latest_vol_reconstructions)
+            if n_rec_volumes > 0:
+                if n_rec_volumes > 1:
+                    _logger.warning(
+                        f"{n_rec_volumes} volume reconstructed when at most one expected"
+                    )
+                volume = VolumeFactory.create_tomo_object_from_identifier(
+                    scan.latest_vol_reconstructions[0]
+                )
+                self.Outputs.volume.send(volume)
         if future_tomo_obj is not None:
             self.Outputs.future_out.send(future_tomo_obj)
 
@@ -297,9 +326,7 @@ class NabuVolumeOW(WidgetLongProcessing, SuperviseOW):
         self.show()
 
     def _updateSettingsVals(self):
-        self._rpSetting = self.getConfiguration()
-        # kept for compatibility
-        self.static_input = {
+        self._ewoks_default_inputs = {
             "data": None,
             "nabu_volume_params": self.getConfiguration(),
             "nabu_params": None,

orangecontrib/tomwer/widgets/reconstruction/SAAxisOW.py

@@ -190,7 +190,8 @@ class SAAxisWindow(_SAAxisWindow):
         if scan is None:
             return
         assert isinstance(scan, TomwerScanBase)
-        selected_cor_value = self.getCurrentCorValue()
+        selected_cor_value = self.getCurrentCorValue() or scan.saaxis_params.autofocus
+        # if validate is done manually then pick current cor value; else we are in 'auto mode' and get it from the autofocus.
         details = ProcessManager().get_dataset_details(
             dataset_id=scan.get_identifier(), process=self._processing_stack
         )
@@ -206,6 +207,12 @@ class SAAxisWindow(_SAAxisWindow):
             )
         else:
             scan.axis_params.set_relative_value(selected_cor_value)
+            if scan.nabu_recons_params is not None:
+                if "reconstruction" not in scan.nabu_recons_params:
+                    scan.nabu_recons_params["reconstruction"] = {}
+                scan.nabu_recons_params["reconstruction"][
+                    "rotation_axis_position"
+                ] = scan.axis_params.absolute_cor_value
             infos = "cor selected for {}: relative: {}, absolute: {}".format(
                 scan,
                 scan.axis_params.relative_cor_value,
@@ -286,11 +293,7 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
     sigScanReady = qt.Signal(TomwerScanBase)
     """Signal emitted when a scan is ready"""
 
-    _rpSetting = Setting(dict())
-    # kept for compatibility
-    "SAAxisRP store as dict"
-
-    static_input = Setting({"data": None, "sa_axis_params": None})
+    _ewoks_default_inputs = Setting({"data": None, "sa_axis_params": None})
 
     class Inputs:
         data = Input(
@@ -334,10 +337,8 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
         )
         self._layout.addWidget(self._widget)
 
-        sa_axis_params = self.static_input.get("sa_axis_params", None)
-        if sa_axis_params is None:
-            sa_axis_params = self._rpSetting
-        self.setConfiguration(sa_axis_params)
+        sa_axis_params = self._ewoks_default_inputs.get("sa_axis_params", None)
+        self.setConfiguration(sa_axis_params or {})
 
         # connect signal / slot
         self._widget.sigConfigurationChanged.connect(self._updateSettings)
@@ -352,6 +353,16 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
         # expose API
         self.wait_processing = self._widget.wait_processing
 
+    def __new__(cls, *args, **kwargs):
+        # ensure backward compatibility with 'static_input'
+        static_input = kwargs.get("stored_settings", {}).get("static_input", None)
+        if static_input not in (None, {}):
+            _logger.warning(
+                "static_input has been deprecated. Will be replaced by _ewoks_default_inputs in the workflow file. Please save the workflow to apply modifications"
+            )
+            kwargs["stored_settings"]["_ewoks_default_inputs"] = static_input
+        return super().__new__(cls, *args, **kwargs)
+
     def setConfiguration(self, configuration):
         if "workflow" in configuration:
             autofocus_lock = configuration["workflow"].get("autofocus_lock", None)
@@ -363,6 +374,9 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
     def getCurrentCorValue(self):
         return self._widget.getCurrentCorValue()
 
+    def setEstimatedCorPosition(self, value):
+        self._widget.setEstimatedCorPosition(value=value)
+
     def load_sinogram(self):
         self._widget.loadSinogram()
 
@@ -435,18 +449,14 @@ class SAAxisOW(SuperviseOW, WidgetLongProcessing):
     def _updateSettings(self):
         config = self._widget.getConfiguration()
         config.pop("cluster_config", None)
-        self._rpSetting = config
-        self._rpSetting["workflow"] = {
-            "autofocus_lock": self._widget.isAutoFocusLock(),
-        }
 
-        self.static_input = {
+        self._ewoks_default_inputs = {
             "data": None,
             "sa_axis_params": self._widget.getConfiguration(),
         }
-        self.static_input["sa_axis_params"][
-            "autofocus_lock"
-        ] = self._widget.isAutoFocusLock()
+        self._ewoks_default_inputs["sa_axis_params"]["workflow"] = {
+            "autofocus_lock": self._widget.isAutoFocusLock(),
+        }
 
     def _raiseResults(self):
         if not self.isAutoFocusLock():