tomwer 1.3.0.dev2__py3-none-any.whl → 1.3.0rc10__py3-none-any.whl

tomwer/core/process/reconstruction/nabu/nabuslices.py

@@ -41,6 +41,7 @@ from processview.core.manager.manager import ProcessManager, DatasetState
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils.slurm import is_slurm_available
+from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.process.reconstruction.nabu.utils import slice_index_to_int
 from tomwer.core.process.icat.gallery import (
     IcatScreenshots,
@@ -83,7 +84,7 @@ from processview.core.superviseprocess import SuperviseProcess
 from silx.io.dictdump import h5todict
 from silx.io.utils import h5py_read_dataset
 from silx.utils.enum import Enum as _Enum
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
@@ -201,6 +202,7 @@ def run_slices_reconstruction(
             ask_sinogram_registration=ask_sinogram_registration,
             ask_sinogram_load=ask_sinogram_load,
             instanciate_class_only=instanciate_classes_only,
+            axis=config.get("reconstruction", {}).get("slice_plane", "XY"),
         )
 
         # specific treatments of results
@@ -443,15 +445,14 @@ class NabuSlicesTask(
         )
 
         # register result
-        with scan.acquire_process_file_lock():
-            self.register_process(
-                process_file=scan.process_file,
-                entry=entry,
-                configuration=configuration,
-                results={},
-                process_index=process_index,
-                overwrite=True,
-            )
+        self.register_process(
+            process_file=scan.process_file,
+            entry=entry,
+            configuration=configuration,
+            results={},
+            process_index=process_index,
+            overwrite=True,
+        )
         if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
@@ -493,7 +494,7 @@ class NabuSlicesTask(
         :rtype:dict
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
                 entries = NabuSlicesTask._get_process_nodes(
                     root_node=h5f, process=NabuSlicesTask
                 )
@@ -509,7 +510,7 @@ class NabuSlicesTask(
         configuration_path = None
         res = {}
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
             nabu_nodes = NabuSlicesTask._get_process_nodes(
                 root_node=h5f[entry], process=NabuSlicesTask
             )
@@ -587,7 +588,13 @@ def interpret_tomwer_configuration(
         return nabu_config
 
     if "tomwer_slices" in config and scan is not None:
-        slices = list(NabuSliceMode.getSlices(config["tomwer_slices"], scan))
+        slices = list(
+            NabuSliceMode.getSlices(
+                config["tomwer_slices"],
+                scan=scan,
+                axis=config.get("reconstruction", {}).get("slice_plane", "XY"),
+            )
+        )
     else:
         slices = []
 
@@ -631,6 +638,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         config: dict,
         dry_run: bool,
         slice_index: Union[int, str, None],
+        axis: NabuPlane,
         target: Target,
         ask_sinogram_registration: bool,
         ask_sinogram_load: bool,
@@ -644,6 +652,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             target=target,
             cluster_config=cluster_config,
             process_name=process_name,
+            axis=axis,
         )
         self._slice_index = slice_index
         if not isinstance(config, dict):
@@ -686,7 +695,9 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         """
         if isinstance(self.slice_index, str):
             self._slice_index = slice_index_to_int(
-                slice_index=self.slice_index, scan=self.scan
+                slice_index=self.slice_index,
+                scan=self.scan,
+                axis=self.axis,
             )
         elif (
             isinstance(self.slice_index, float)
@@ -734,8 +745,19 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         # the policy is to save nabu .cfg file at the same location as the
         # force overwrite results
         if self.slice_index is not None:
-            config["reconstruction"]["start_z"] = self.slice_index
-            config["reconstruction"]["end_z"] = self.slice_index
+            if self.axis is NabuPlane.YZ:
+                config["reconstruction"]["start_x"] = self.slice_index
+                config["reconstruction"]["end_x"] = self.slice_index
+            elif self.axis is NabuPlane.XZ:
+                config["reconstruction"]["start_y"] = self.slice_index
+                config["reconstruction"]["end_y"] = self.slice_index
+            elif self.axis is NabuPlane.XY:
+                config["reconstruction"]["start_z"] = self.slice_index
+                config["reconstruction"]["end_z"] = self.slice_index
+            else:
+                raise ValueError(
+                    f"self.axis has an invalid value: {self.axis} when expected to be in {NabuPlane.values()}"
+                )
 
         if self.slice_index is not None:
             os.makedirs(config["output"]["location"], exist_ok=True)
@@ -763,8 +785,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 self._process_config(
                     config_to_dump=config_to_dump,
                     config_file=conf_file,
-                    start_z=None,
-                    end_z=None,
                     info="nabu slice reconstruction",
                     file_format=config_to_dump["output"]["file_format"],
                     process_name=self.process_name,
@@ -798,6 +818,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 file_format=file_format,
                 scan=self.scan,
                 slice_index=None,
+                axis=self.axis,
             )
 
             return (CallBack(callback, self.scan),)
@@ -806,19 +827,25 @@ class SingleSliceRunner(_NabuBaseReconstructor):
 
     @staticmethod
     def get_file_basename_reconstruction(
-        scan, pag, ctf, db, slice_index: Union[str, int]
+        scan,
+        pag,
+        ctf,
+        db,
+        slice_index: Union[str, int],
+        axis: NabuPlane,
     ):
+        axis = NabuPlane.from_value(axis)
         if pag:
             assert db is not None, "if paganin defined, db should not be None"
         if slice_index is not None:
-            slice_index = slice_index_to_int(slice_index, scan=scan)
+            slice_index = slice_index_to_int(slice_index, scan=scan, axis=axis)
 
         assert type(db) in (int, type(None))
         if isinstance(scan, NXtomoScan):
             basename, _ = os.path.splitext(scan.master_file)
             basename = os.path.basename(basename)
             try:
-                with HDF5File(scan.master_file, mode="r") as h5f:
+                with HDF5File(scan.master_file, mode="r", swmr=get_swmr_mode()) as h5f:
                     if len(h5f.keys()) > 1:
                         # if there is more than one entry in the file append the entry name to the file basename
                         basename = "_".join((basename, scan.entry.lstrip("/")))
@@ -840,6 +867,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                         basename + "slice_pag",
                         str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
+                        "plane",
+                        axis.value,
                     )
                 )
             elif ctf:
@@ -848,13 +877,22 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                         basename + "slice_ctf",
                         str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
+                        "plane",
+                        axis.value,
                     )
                 )
             else:
-                return "_".join((basename + "slice", str(slice_index).zfill(6)))
+                return "_".join(
+                    (
+                        basename + "slice",
+                        str(slice_index).zfill(6),
+                        "plane",
+                        axis.value,
+                    )
+                )
 
     @docstring(_NabuBaseReconstructor)
-    def _get_file_basename_reconstruction(self, pag, db, ctf):
+    def _get_file_basename_reconstruction(self, pag, db, ctf, axis):
         """
 
         :param TomwerScanBase scan: scan reconstructed
@@ -866,7 +904,12 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         :return: basename of the file reconstructed (without any extension)
         """
         return self.get_file_basename_reconstruction(
-            scan=self.scan, db=db, pag=pag, slice_index=self.slice_index, ctf=ctf
+            scan=self.scan,
+            db=db,
+            pag=pag,
+            slice_index=self.slice_index,
+            ctf=ctf,
+            axis=axis,
         )
 
 
@@ -881,6 +924,7 @@ def run_single_slice_reconstruction(
     cluster_config: Optional[dict] = None,
     add_to_latest_reconstructions=True,
     instanciate_class_only=False,
+    axis: NabuPlane = NabuPlane.XY,
 ) -> Optional[ResultsRun]:
     """
     # TODO: might need something like a context or an option "keep" slice in memory
@@ -904,6 +948,12 @@ def run_single_slice_reconstruction(
     """
     # TODO: remove local from the function signature
     target = Target.SLURM if cluster_config not in ({}, None) else Target.LOCAL
+    axis = NabuPlane.from_value(axis)
+    # FIXEME: nabu fails if outer_circle activated and if the axis != z
+    if axis != NabuPlane.XY and nabu_config.get("reconstruction", {}).get(
+        "clip_outer_circle", False
+    ):
+        nabu_config["reconstruction"]["clip_outer_circle"] = False
 
     if process_id is not None:
         try:
@@ -918,6 +968,7 @@ def run_single_slice_reconstruction(
         config=nabu_config,
         dry_run=dry_run,
         slice_index=slice_index,
+        axis=axis,
         target=target,
         ask_sinogram_registration=ask_sinogram_registration,
         ask_sinogram_load=ask_sinogram_load,
@@ -943,7 +994,7 @@ class NabuSliceMode(_Enum):
     OTHER = "other"
 
     @staticmethod
-    def getSlices(slices, scan) -> tuple:
+    def getSlices(slices, scan, axis=NabuPlane.XY) -> tuple:
         res = []
         try:
             mode = NabuSliceMode.from_value(slices)
@@ -954,7 +1005,11 @@ class NabuSliceMode(_Enum):
                 pass
         else:
             if mode == mode.MIDDLE:
-                n_slice = scan.dim_2 or 2048
+                axis = NabuPlane.from_value(axis)
+                if axis is NabuPlane.XY:
+                    n_slice = scan.dim_2 or 2048
+                elif axis in (NabuPlane.YZ, NabuPlane.XZ):
+                    n_slice = scan.dim_1 or 2048
                 res.append(n_slice // 2)
             else:
                 raise ValueError(

tomwer/core/process/reconstruction/nabu/nabuvolume.py

@@ -45,7 +45,7 @@ from processview.core.superviseprocess import SuperviseProcess
 from silx.io.utils import h5py_read_dataset
 from tomwer.core.utils.deprecation import deprecated_warning
 
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
@@ -275,8 +275,6 @@ class VolumeRunner(_NabuBaseReconstructor):
                     self._process_config(
                         config_to_dump=config_to_dump,
                         config_file=conf_file,
-                        start_z=config_to_dump["reconstruction"]["start_z"],
-                        end_z=config_to_dump["reconstruction"]["end_z"],
                         info="nabu volume reconstruction",
                         file_format=config_slices["output"]["file_format"],
                         process_name=self.process_name,
@@ -326,17 +324,16 @@ class VolumeRunner(_NabuBaseReconstructor):
         if "postproc" in config:
             config["postproc"] = config["postproc"]
 
-        if "start_z" in config:
-            config["reconstruction"]["start_z"] = config["start_z"]
-            del config["start_z"]
-        if "end_z" in config:
-            config["reconstruction"]["end_z"] = config["end_z"]
-            del config["end_z"]
+        # make sure start_[x] and end_[x] come from config
+        for key in ("start_x", "end_x", "start_y", "end_y", "start_z", "end_z"):
+            if key in config:
+                config["reconstruction"][key] = config[key]
+                del config[key]
 
         return config, nabu_cfg_folder
 
     @docstring(_NabuBaseReconstructor)
-    def _get_file_basename_reconstruction(self, pag, db, ctf):
+    def _get_file_basename_reconstruction(self, pag, db, ctf, axis):
         """
 
         :param TomwerScanBase scan: scan reconstructed
@@ -345,6 +342,7 @@ class VolumeRunner(_NabuBaseReconstructor):
                                             entire volume
         :param bool pag: is it a paganin reconstruction
         :param int db: delta / beta parameter
+        :param axis: axis over which the reconstruction goes. For volume always expected to be z. So ignored in the function
         :return: basename of the file reconstructed (without any extension)
         """
         assert type(db) in (int, type(None))
@@ -354,7 +352,9 @@ class VolumeRunner(_NabuBaseReconstructor):
             basename = os.path.basename(basename)
             try:
                 # if there is more than one entry in the file append the entry name to the file basename
-                with HDF5File(self.scan.master_file, mode="r") as h5f:
+                with HDF5File(
+                    self.scan.master_file, mode="r", swmr=get_swmr_mode()
+                ) as h5f:
                     if len(h5f.keys()) > 1:
                         basename = "_".join((basename, self.scan.entry.strip("/")))
             except Exception:
@@ -531,24 +531,29 @@ class NabuVolumeTask(
         self.outputs.future_tomo_obj = future_tomo_obj
 
         # build screenshots
-        try:
-            screenshots = {}
-            [
-                screenshots.update(
-                    select_screenshot_from_volume(
-                        VolumeFactory.create_tomo_object_from_identifier(rec_identifier)
+        if scan.latest_vol_reconstructions is not None:
+            try:
+                screenshots = {}
+                [
+                    screenshots.update(
+                        select_screenshot_from_volume(
+                            VolumeFactory.create_tomo_object_from_identifier(
+                                rec_identifier
+                            )
+                        )
                     )
+                    for rec_identifier in scan.latest_vol_reconstructions
+                ]
+            except Exception as e:
+                _logger.error(f"screenshot creation failed. Error is {e}")
+            else:
+                self.outputs.screenshots = IcatScreenshots(
+                    data_dir=deduce_dataset_gallery_location(scan),
+                    screenshots=screenshots,
+                    scan=scan,
                 )
-                for rec_identifier in scan.latest_vol_reconstructions
-            ]
-        except Exception as e:
-            _logger.error(f"screenshot creation failed. Error is {e}")
         else:
-            self.outputs.screenshots = IcatScreenshots(
-                data_dir=deduce_dataset_gallery_location(scan),
-                screenshots=screenshots,
-                scan=scan,
-            )
+            self.outputs.screenshots = tuple()
 
     def set_configuration(self, configuration: dict) -> None:
         Task.set_configuration(self, configuration=configuration)

tomwer/core/process/reconstruction/nabu/plane.py

@@ -0,0 +1,9 @@
+"""Define nabu Axis"""
+
+from silx.utils.enum import Enum as _Enum
+
+
+class NabuPlane(_Enum):
+    YZ = "YZ"
+    XZ = "XZ"
+    XY = "XY"

tomwer/core/process/reconstruction/nabu/utils.py

@@ -41,6 +41,7 @@ from nabu.pipeline.fullfield.nabu_config import (
 from silx.utils.enum import Enum as _Enum
 
 import tomwer.version
+from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
@@ -148,15 +149,19 @@ def get_recons_volume_identifier(
     file_format: str,
     scan: TomwerScanBase,
     slice_index: typing.Union[int, None],
+    axis: NabuPlane,
 ) -> tuple:
     """
     return tuple of DataUrl for existings slices
     """
+    axis = NabuPlane.from_value(axis)
     file_format = file_format.lower()
     if file_format in ("hdf5", "h5", "hdf"):
         if slice_index is not None:
             # case of a single hdf5 file
-            file_name = "_".join((file_prefix, str(slice_index).zfill(6)))
+            file_name = "_".join(
+                (file_prefix, "plane", axis.value, str(slice_index).zfill(6))
+            )
         else:
             file_name = file_prefix
         file_name = ".".join((file_name, file_format))
@@ -176,7 +181,9 @@ def get_recons_volume_identifier(
     elif file_format in ("vol", "raw"):
         if slice_index is not None:
             # case of a single hdf5 file
-            file_name = "_".join((file_prefix, str(slice_index).zfill(6)))
+            file_name = "_".join(
+                (file_prefix, "plane", axis.value, str(slice_index).zfill(6))
+            )
         else:
             file_name = file_prefix
         file_name = ".".join((file_name, file_format))
@@ -227,6 +234,7 @@ def get_multi_cor_recons_volume_identifiers(
     file_prefix: str,
     cors: tuple,
     file_format: str,
+    axis=NabuPlane.XY,
 ) -> dict:
     """
     util to retrieve Volumes (identifier) reconstructed by nabu-multicor
@@ -241,7 +249,11 @@ def get_multi_cor_recons_volume_identifiers(
     """
     _logger.info("Deduce volume identifiers for nabu-multicor")
     if isinstance(slice_index, str):
-        slice_index = slice_index_to_int(slice_index=slice_index, scan=scan)
+        slice_index = slice_index_to_int(
+            slice_index=slice_index,
+            scan=scan,
+            axis=axis,  # for now we always expect the multicor to be done along Z
+        )
     assert isinstance(
         slice_index, int
     ), "slice_index is expected to be an int or to be converted to it"
@@ -260,7 +272,6 @@ def get_multi_cor_recons_volume_identifiers(
         if file_format in ("hdf5", "h5", "hdf"):
             file_path = os.path.join(
                 location,
-                f"{file_prefix}_{cor:.3f}",  # this level is expected to be removed on the future nabu versions
                 f"{file_prefix}_{cor:.3f}_{str(slice_index).zfill(5)}.{file_format}",
             )
             volume = HDF5Volume(
@@ -493,11 +504,14 @@ def update_cfg_file_after_transfer(config_file_path, old_path, new_path):
 
 
 def slice_index_to_int(
-    slice_index: typing.Union[int, str], scan: TomwerScanBase
+    slice_index: typing.Union[int, str],
+    scan: TomwerScanBase,
+    axis=NabuPlane.XY,
 ) -> int:
     """
     cast a slice to an index. The slice can be a string in ['first', 'last', 'middle']
     """
+    axis = NabuPlane.from_value(axis)
     if slice_index == "fisrt":
         return 0
     elif slice_index == "last":
@@ -518,11 +532,20 @@ def slice_index_to_int(
             _logger.warning("Scan not provided. Consider the 1024 width detector")
             # default middle.
             return 1024
-        elif scan.dim_2 is None:
-            _logger.warning("unable to get dim size, guess this is 2048 width")
-            return 1024
+        elif axis is NabuPlane.XY:
+            if scan.dim_2 is None:
+                _logger.warning("unable to get dim size, guess this is 2048 height")
+                return 1024
+            else:
+                return scan.dim_2 // 2
+        elif axis in (NabuPlane.YZ, NabuPlane.XZ):
+            if scan.dim_1 is None:
+                _logger.warning("unable to get dim size, guess this is 2048 width")
+                return 1024
+            else:
+                return scan.dim_1 // 2
         else:
-            return scan.dim_2 // 2
+            raise ValueError(f"axis {axis} is not handled")
     else:
         return int(slice_index)
 

tomwer/core/process/reconstruction/saaxis/saaxis.py

@@ -520,7 +520,10 @@ class SAAxisTask(
                     cors_res, rois = self._post_processing(
                         scan=scan,
                         slice_index=slice_index,
-                        cor_reconstructions=cor_reconstructions,
+                        cor_reconstructions={
+                            cor: recons
+                            for cor, recons in zip(params.cors, cor_reconstructions)
+                        },
                     )
                 except Exception as e:
                     _logger.error(e)

tomwer/core/process/reconstruction/sadeltabeta/sadeltabeta.py

@@ -87,7 +87,7 @@ from .params import SADeltaBetaParams
 _logger = logging.getLogger(__name__)
 
 
-DEFAULT_RECONS_FOLDER = "sadeltabeta_results"
+DEFAULT_RECONS_FOLDER = "multi_delta_beta_results"
 
 
 def one_slice_several_db(
@@ -250,6 +250,7 @@ class SADeltaBetaTask(
             raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
 
         config = copy(self.inputs.sa_delta_beta_params)
+        axis = config.get("reconstruction", {}).get("slice_plane", "XY")
         params = SADeltaBetaParams.from_dict(config)
 
         # insure scan contains some parameter regarding sa delta / beta
@@ -303,6 +304,7 @@ class SADeltaBetaTask(
                 slice_index=slice_index,
                 dry_run=dry_run,
                 cluster_config=cluster_config,
+                axis=axis,
             )
         except Exception as e:
             _logger.error(e)
@@ -318,6 +320,7 @@ class SADeltaBetaTask(
                 slice_index=slice_index,
                 db_reconstructions=dbs_res,
                 future_tomo_objs=future_tomo_objs,
+                axis=axis,
             )
 
             # step 4: run post processing (compute score for each slice)
@@ -424,6 +427,7 @@ class SADeltaBetaTask(
         slice_index,
         advancement,
         dry_run,
+        axis,
         cluster_config: Optional[dict],
     ):
         future_tomo_objs = {}
@@ -448,6 +452,7 @@ class SADeltaBetaTask(
             process_id=self.process_id,
             instanciate_classes_only=True,
             output_file_prefix_pattern=None,
+            axis=axis,
         )
 
         for runner in runners:
@@ -510,6 +515,7 @@ class SADeltaBetaTask(
         nabu_config: dict,
         db_reconstructions,
         slice_index,
+        axis,
         future_tomo_objs: dict,
     ):
         assert isinstance(nabu_config, dict)
@@ -536,6 +542,7 @@ class SADeltaBetaTask(
                 pag=pag,
                 db=int(db) if db is not None else None,
                 ctf=ctf,
+                axis=axis,
             )
             # retrieve url
             volume_identifier = nabu_utils.get_recons_volume_identifier(
@@ -544,6 +551,7 @@ class SADeltaBetaTask(
                 file_format=nabu_config.get("file_format", "hdf5"),
                 scan=scan,
                 slice_index=None,
+                axis=axis,
             )
 
             assert len(volume_identifier) <= 1, "only one slice expected"

tomwer/core/process/reconstruction/scores/params.py

@@ -179,9 +179,9 @@ class SABaseParams:
             "dry_run": self.dry_run,
             "output_dir": self.output_dir or "",
             "score_method": self.score_method.value,
-            "cluster_config": self.cluster_config
-            if self.cluster_config is not None
-            else "",
+            "cluster_config": (
+                self.cluster_config if self.cluster_config is not None else ""
+            ),
         }
 
     def load_from_dict(self, dict_: dict):

tomwer/core/process/reconstruction/test/test_darkref_copy.py

@@ -35,8 +35,8 @@ def test_register_and_copy_darks_and_flats(
     scan_with_raw = MockNXtomo(
         scan_path=scan_folder_with_raw,
         create_ini_dark=True,
-        create_ini_ref=True,
-        create_final_ref=False,
+        create_ini_flat=True,
+        create_final_flat=False,
         n_proj=10,
         n_ini_proj=10,
         dim=12,
@@ -44,8 +44,8 @@ def test_register_and_copy_darks_and_flats(
     scan_without_raw = MockNXtomo(
         scan_path=scan_folder_without_raw,
         create_ini_dark=False,
-        create_ini_ref=False,
-        create_final_ref=False,
+        create_ini_flat=False,
+        create_final_flat=False,
         n_proj=10,
         n_ini_proj=10,
         dim=12,

tomwer/core/process/stitching/nabustitcher.py

@@ -139,32 +139,33 @@ class StitchingPostProcAggregation(_StitchingPostProcAggregation):
     once stitching is done remotly we need to 'aggregate' the different part in the correct order
     """
 
-    def __init__(self, futures, stitching_config) -> None:
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
         self._n_finished = 0
-        self._futures = futures
-        if isinstance(stitching_config, dict):
+
+        if isinstance(self.stitching_config, dict):
             stitching_type = StitchingType.from_value(
-                stitching_config["stitching"]["type"]
+                self.stitching_config["stitching"]["type"]
             )
             if stitching_type is StitchingType.Z_PREPROC:
                 self._stitching_config = PreProcessedZStitchingConfiguration.from_dict(
-                    stitching_config
+                    self.stitching_config
                 )
             elif stitching_type is StitchingType.Z_POSTPROC:
                 self._stitching_config = PostProcessedZStitchingConfiguration.from_dict(
-                    stitching_config
+                    self.stitching_config
                 )
             else:
                 raise NotImplementedError("stitching type not handled")
-        elif not isinstance(stitching_config, StitchingConfiguration):
+        elif not isinstance(self.stitching_config, StitchingConfiguration):
             raise TypeError(
-                f"stitching_config is expected to be an instance of {StitchingConfiguration}. {type(stitching_config)} provided instead"
+                f"stitching_config is expected to be an instance of {StitchingConfiguration}. {type(self.stitching_config)} provided instead"
             )
-        else:
-            self._stitching_config = stitching_config
 
     def onePartFinished(self, *args, **kwargs):
         self._n_finished += 1
+        # note: for now we only consider the user of the futures.
+        # if users want to only run post-processing agregation then they will use the nabu CLI for it.
         if self._n_finished == len(self._futures):
             _logger.info("All slurm job finished. Will aggregate results")
             self.process()