tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

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

@@ -34,7 +34,7 @@ __date__ = "28/10/2021"
 
 import logging
 import os
-from copy import copy
+from copy import copy, deepcopy
 from typing import Optional, Union
 
 import h5py
@@ -52,13 +52,9 @@ import tomwer.version
 from tomwer.core.process.reconstruction.nabu.nabucommon import (
     ResultsLocalRun,
     ResultSlurmRun,
-    ResultsRun,
     ResultsWithStd,
 )
-from tomwer.core.process.reconstruction.nabu.nabuslices import (
-    SingleSliceRunner,
-    run_single_slice_reconstruction,
-)
+from tomwer.core.process.reconstruction.nabu.nabuslices import SingleSliceRunner
 from tomwer.core.process.reconstruction.scores import (
     ComputedScore,
     ScoreMethod,
@@ -75,6 +71,14 @@ from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils import logconfig
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.io.utils import format_stderr_stdout
+from tomwer.core.process.reconstruction.nabu.nabuscores import (
+    run_nabu_one_slice_several_config,
+)
+from tomwer.core.futureobject import FutureTomwerObject
+
+
+from silx.utils.deprecation import deprecated, deprecated_warning
 
 from ..nabu import utils as nabu_utils
 from .params import SADeltaBetaParams
@@ -101,223 +105,37 @@ def one_slice_several_db(
              (url, score) as value
     :rtype: tuple
     """
-    if isinstance(configuration, dict):
-        configuration = SADeltaBetaParams.from_dict(configuration)
-    elif not isinstance(configuration, SADeltaBetaParams):
-        raise TypeError(
-            "configuration should be a dictionary or an instance of SAAxisParams"
-        )
-
-    if scan.axis_params is None:
-        from tomwer.core.process.reconstruction.axis import AxisRP
-
-        scan.axis_params = AxisRP()
-
-    configuration.check_configuration()
-    slice_index = configuration.slice_indexes
-    delta_beta_s = configuration.delta_beta_values
-    output_dir = configuration.output_dir
-    dry_run = configuration.dry_run
-    cluster_config = configuration.cluster_config
-    _logger.info(
-        f"launch reconstruction of slice {slice_index} and delta / beta: {delta_beta_s}"
+    if isinstance(configuration, SADeltaBetaParams):
+        configuration = configuration.to_dict()
+
+    task = SADeltaBetaTask(
+        process_id=process_id,
+        inputs={
+            "data": scan,
+            "sa_axis_params": configuration,
+            "serialize_output_data": False,
+        },
+    )
+    task.run()
+    return (
+        task.outputs.scores,
+        task.outputs.std_out,
+        task.outputs.std_err,
+        task.outputs.rois,
     )
-    if isinstance(slice_index, str):
-        if not slice_index == "middle":
-            raise ValueError(f"slice index {slice_index} not recognized")
-    elif not len(slice_index) == 1:
-        raise ValueError("only manage one slice")
-    else:
-        slice_index = list(slice_index.values())[0]
-    advancement = Progress(f"sa-delta-beta - slice {slice_index} of {scan}")
-
-    config = configuration.nabu_params.copy()
-
-    _logger.info(f"start reconstruction of {scan}")
-    # if scan contains some center of position copy it to nabu
-    if scan.axis_params is not None and scan.axis_params.relative_cor_value is not None:
-        if "reconstruction" in config:
-            # move the cor value to the nabu reference
-            cor_nabu_ref = scan.axis_params.relative_cor_value + scan.dim_1 / 2.0
-            config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
-
-    _logger.info(f"set nabu reconstruction parameters to {scan}")
-    scan.nabu_recons_params = config
-
-    db_reconstructions = {}
-    # key is delta / beta, value is url
-    stderrs = []
-    stdouts = []
-    all_succeed = True
-    future_tomo_objs = {}
-    # key is delta / beta, value is future
-    if advancement is not None:
-        advancement.setMaxAdvancement(len(delta_beta_s))
-    for db in delta_beta_s:
-        if "output" not in config:
-            config["output"] = {}
-        if output_dir is None:
-            config["output"]["location"] = os.path.join(
-                scan.path, DEFAULT_RECONS_FOLDER
-            )
-        else:
-            config["output"]["location"] = output_dir
-        # TODO: allow file format modifications
-        config["output"]["file_format"] = "hdf5"
-        if "phase" not in config:
-            config["phase"] = {}
-        config["phase"]["delta_beta"] = (
-            db,
-        )  # warning: at this tage delta_beta expects a list of value
-        config["phase"]["method"] = "Paganin"
-        res = run_single_slice_reconstruction(
-            nabu_config=config,
-            scan=scan,
-            slice_index=slice_index,
-            dry_run=dry_run,
-            ask_sinogram_registration=False,
-            ask_sinogram_load=False,
-            cluster_config=cluster_config,
-            add_to_latest_reconstructions=False,
-            process_id=process_id,
-        )
-        if isinstance(res, ResultsRun):
-            all_succeed = all_succeed and res.success
-        if isinstance(res, ResultSlurmRun):
-            future_tomo_objs[db] = res.future_slurm_jobs
-        if isinstance(res, ResultsWithStd):
-            if slice_index is not None:
-                stderrs.append(res.std_err)
-                stdouts.append(res.std_out)
-        if isinstance(res, ResultsLocalRun) and len(res.results_urls) > 0:
-            assert len(res.results_urls) == 1, "only one slice expected"
-            db_reconstructions[db] = res.results_urls[0]
-
-        if advancement is not None:
-            advancement.increaseAdvancement(1)
-
-    pag = False
-    ctf = False
-    if "phase" in config:
-        phase_method = config["phase"].get("method", "").lower()
-        if phase_method in ("pag", "paganin"):
-            pag = True
-        elif phase_method in ("ctf",):
-            ctf = True
-
-    # treat future.
-    for db, future_tomo_obj_list in future_tomo_objs.items():
-        assert (
-            len(future_tomo_obj_list) == 1
-        ), "only one future should be created for one slice / db couple"
-        future = future_tomo_obj_list[0]
-        future.result()
-        if future.cancelled() or future.exception():
-            continue
-        file_prefix = SingleSliceRunner.get_file_basename_reconstruction(
-            scan=scan,
-            slice_index=slice_index,
-            pag=pag,
-            db=int(db) if db is not None else None,
-            ctf=ctf,
-        )
-        # retrieve url
-        volume_identifier = nabu_utils.get_recons_volume_identifier(
-            file_prefix=file_prefix,
-            location=config["output"]["location"],
-            file_format=config.get("file_format", "hdf5"),
-            scan=scan,
-            slice_index=None,
-            start_z=None,
-            end_z=None,
-            expects_single_slice=True,
-        )
-
-        assert len(volume_identifier) <= 1, "only one slice expected"
-        if len(volume_identifier) == 1:
-            db_reconstructions[db] = volume_identifier[0]
-        else:
-            _logger.warning(
-                f"something went wrong with reconstruction of {db} from {str(scan)}"
-            )
-
-    class PostProcessing:
-        def run(self):
-            datasets = self.load_datasets()
-
-            mask_disk_radius = get_disk_mask_radius(datasets)
-            scores = {}
-            rois = {}
-            for db, (url, data) in datasets.items():
-                if data is None:
-                    score = None
-                else:
-                    assert data.ndim == 2
-                    data_roi = apply_roi(data=data, radius=mask_disk_radius, url=url)
-                    rois[db] = data_roi
-
-                    # move data_roi to [0-1] range
-                    #  preprocessing: get percentile 0 and 99 from image and
-                    #  "clean" highest and lowest pixels from it
-                    min_p, max_p = numpy.percentile(data_roi, (1, 99))
-                    data_roi_int = data_roi[...]
-                    data_roi_int[data_roi_int < min_p] = min_p
-                    data_roi_int[data_roi_int > max_p] = max_p
-                    data_roi_int = (data_roi_int - min_p) / (max_p - min_p)
-
-                    score = ComputedScore(
-                        tv=compute_score(data=data_roi_int, method=ScoreMethod.TV),
-                        std=compute_score(data=data_roi_int, method=ScoreMethod.STD),
-                    )
-                scores[db] = (url, score)
-            return scores, rois
-
-        def load_datasets(self):
-            datasets_ = {}
-            for db, volume_identifier in db_reconstructions.items():
-                slice_url = None
-                # in case the try processing fails
-                try:
-                    volume = VolumeFactory.create_tomo_object_from_identifier(
-                        volume_identifier
-                    )
-                    volumes_urls = tuple(volume.browse_data_urls())
-                    if len(volumes_urls) > 1:
-                        _logger.warning(
-                            f"found a volume with mode that one url ({volumes_urls})"
-                        )
-                    slice_url = volumes_urls[0]
-                    data = get_data(slice_url)
-                except Exception as e:
-                    _logger.error(
-                        f"Fail to compute a score for {volume_identifier}. Reason is {e}"
-                    )
-                    datasets_[db] = (slice_url, None)
-                else:
-                    if data.ndim == 3:
-                        if data.shape[0] == 1:
-                            data = data.reshape(data.shape[1], data.shape[2])
-                        elif data.shape[2] == 1:
-                            data = data.reshape(data.shape[0], data.shape[1])
-                        else:
-                            raise ValueError(
-                                f"Data is expected to be 2D. Not {data.ndim}D"
-                            )
-                    elif data.ndim == 2:
-                        pass
-                    else:
-                        raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
-
-                    datasets_[db] = (slice_url, data)
-            return datasets_
-
-    post_processing = PostProcessing()
-    scores, rois = post_processing.run()
-    return scores, stdouts, stderrs, rois
 
 
-class SADeltaBetaProcess(
-    Task, SuperviseProcess, input_names=("data",), output_names=("data",)
+class SADeltaBetaTask(
+    Task,
+    SuperviseProcess,
+    input_names=("data", "sa_delta_beta_params"),
+    output_names=("data", "best_db"),
+    optional_input_names=(
+        "dry_run",
+        "dump_roi",
+        "dump_process",
+        "serialize_output_data",
+    ),
 ):
     """
     Main process to launch several reconstruction of a single slice with
@@ -346,10 +164,9 @@ class SADeltaBetaProcess(
         self._dump_process = inputs.get("dump_process", True)
         self._dump_roi = inputs.get("dump_roi", False)
         self._sa_delta_beta_params = inputs.get("sa_delta_beta_params", None)
-        if self._sa_delta_beta_params is not None:
-            self.set_configuration(self._sa_delta_beta_params)
         self._std_outs = tuple()
         self._std_errs = tuple()
+        self._cancelled = False
 
     @property
     def dump_roi(self):
@@ -374,6 +191,7 @@ class SADeltaBetaProcess(
     def dry_run(self):
         return self._dry_run
 
+    @deprecated(replacement="ewoks task inputs.sa_delta_beta_params")
     def set_configuration(self, configuration: dict) -> None:
         if isinstance(configuration, SADeltaBetaParams):
             self._settings = configuration.to_dict()
@@ -414,75 +232,363 @@ class SADeltaBetaProcess(
             scan = ScanFactory.create_scan_object_frm_dict(scan)
         else:
             raise ValueError(f"input type of {scan}: {type(scan)} is not managed")
+
+        config = copy(self.inputs.sa_delta_beta_params)
+        params = SADeltaBetaParams.from_dict(config)
+
         # insure scan contains some parameter regarding sa delta / beta
         if scan.sa_delta_beta_params is None:
-            scan.sa_delta_beta_params = SADeltaBetaParams()
+            scan.sa_delta_beta_params = params
+
+        # insure it also contains some axis_params
+        if scan.axis_params is None:
+            from tomwer.core.process.reconstruction.axis import AxisRP
+
+            scan.axis_params = AxisRP()
 
         # create dir if does not exists
-        config = copy(self.get_configuration())
-        params = SADeltaBetaParams.from_dict(config)
         if params.output_dir in (None, ""):
             params.output_dir = os.path.join(scan.path, DEFAULT_RECONS_FOLDER)
             if not os.path.exists(params.output_dir):
                 os.makedirs(params.output_dir)
-        db_res, self._std_outs, self._std_errs, rois = one_slice_several_db(
+
+        slice_index = self._preprocess_slice_index(params.slice_indexes)
+        delta_beta_s = params.delta_beta_values
+        output_dir = params.output_dir
+        # TODO: check: dry run should only be settable at one location
+        dry_run = self._dry_run or params.dry_run
+        cluster_config = params.cluster_config
+        nabu_config = params.nabu_recons_params
+
+        # step one: complete nabu configuration(s)
+        configs = self._config_preprocessing(
             scan=scan,
-            configuration=params.to_dict(),
-            process_id=self.process_id,
+            config=nabu_config,
+            delta_beta_s=delta_beta_s,
+            output_dir=output_dir,
+        )
+        # step 2: run reconstructions
+        advancement = Progress(
+            f"sa-delta-beta - slice {slice_index} of {scan.get_identifier().short_description()}"
         )
-        scan.sa_delta_beta_params.scores = db_res
+
+        dbs_res = {}
+        rois = {}
+
+        try:
+            (
+                _,
+                dbs_res,
+                future_tomo_objs,
+                self._std_outs,
+                self._std_errs,
+            ) = self._run_one_slice_several_db(
+                scan=scan,
+                configs=configs,
+                advancement=advancement,
+                slice_index=slice_index,
+                dry_run=dry_run,
+                cluster_config=cluster_config,
+            )
+        except Exception as e:
+            _logger.error(e)
+            mess = f"sa-delta-beta -nabu- computation for {str(scan)} failed."
+            state = DatasetState.FAILED
+        else:
+            # step 3: wait for future if any
+            self._resolve_futures(
+                scan=scan,
+                nabu_config=next(iter(configs.items()))[
+                    1
+                ],  # db is not used but paganin and other parameters are. Take the first nabu configuration available
+                slice_index=slice_index,
+                db_reconstructions=dbs_res,
+                future_tomo_objs=future_tomo_objs,
+            )
+
+            # step 4: run post processing (compute score for each slice)
+            try:
+                dbs_res, rois = self._post_processing(
+                    scan=scan,
+                    db_reconstructions=dbs_res,
+                )
+            except Exception as e:
+                _logger.error(e)
+                mess = f"sa-delta-beta -post-processing- computation for {str(scan)} failed."
+                state = DatasetState.FAILED
+                dbs_res = {}
+            else:
+                state = DatasetState.WAIT_USER_VALIDATION
+                self.delta_beta_s = scan.sa_delta_beta_params.autofocus
+                mess = "sa-delta-beta computation succeeded"
+
+        if self._cancelled:
+            state = DatasetState.CANCELLED
+            mess = "scan cancelled by the user"
+
+        ProcessManager().notify_dataset_state(
+            dataset=scan,
+            process=self,
+            state=state,
+            details=self._compute_mess_details(mess),
+        )
+
+        scan.sa_delta_beta_params.scores = dbs_res
         best_db = self.autofocus(scan=scan)
         # store nabu recons parameters to be used within the nabu volume for example.
-        config = self.get_configuration()["nabu_params"]
-        # beam shape is not directly used by nabu (uses ctf_geometry directly)
-        config.get("phase", {}).pop("beam_shape", None)
+
         sc_config = get_default_nabu_config(nabu_fullfield_default_config)
-        sc_config.update(config)
+        sc_config.update(nabu_config)
         if best_db is not None:
             sc_config["phase"]["delta_beta"] = (
                 best_db,
             )  # warning: at this tage delta_beta expects a list of value
+        # store used reconstruction parameters - to be used later on
         scan.nabu_recons_params = sc_config
 
         # end processing
-        self._process_end(scan=scan, db_res=db_res, score_rois=rois)
-        self.outputs.data = scan
-
-    def _process_end(self, scan, db_res, score_rois):
-        assert isinstance(scan, TomwerScanBase)
-        try:
-            extra = {
-                logconfig.DOC_TITLE: self._scheme_title,
-                logconfig.SCAN_ID: str(scan),
-            }
-            slice_index = self.get_configuration().get("slice_index", None)
-
-            if db_res is None:
-                info = f"fail to compute delta/beta scores of slice {slice_index} for scan {scan}."
-                _logger.processFailed(info, extra=extra)
-                ProcessManager().notify_dataset_state(
-                    dataset=scan, process=self, state=DatasetState.FAILED, details=info
+        if self.get_input_value("serialize_output_data", True):
+            self.outputs.data = scan.to_dict()
+        else:
+            self.outputs.data = scan
+        self.outputs.best_db = best_db
+
+        self._process_end(scan=scan, db_res=dbs_res, score_rois=rois)
+
+    def _compute_mess_details(self, mess=""):
+        """
+        util to join a message and nabu std err and std out
+        """
+        nabu_logs = []
+        for std_err, std_out in zip(self._std_errs, self.std_outs):
+            nabu_logs.append(format_stderr_stdout(stdout=std_out, stderr=std_err))
+        self._nabu_log = nabu_logs
+        nabu_logs.insert(0, mess)
+        return "\n".join(nabu_logs)
+
+    def _config_preprocessing(self, scan, config, delta_beta_s, output_dir) -> dict:
+        config.get("phase", {}).pop("beam_shape", None)
+        # if scan contains some center of position copy it to nabu
+        if (
+            scan.axis_params is not None
+            and scan.axis_params.relative_cor_value is not None
+        ):
+            if "reconstruction" in config:
+                # move the cor value to the nabu reference
+                cor_nabu_ref = scan.axis_params.relative_cor_value + scan.dim_1 / 2.0
+                config["reconstruction"]["rotation_axis_position"] = str(cor_nabu_ref)
+
+        _logger.info(f"set nabu reconstruction parameters to {scan}")
+        scan.nabu_recons_params = config
+        res = {}
+        for db in delta_beta_s:
+            l_config = deepcopy(config)
+            if "output" not in config:
+                l_config["output"] = {}
+            if output_dir is None:
+                l_config["output"]["location"] = os.path.join(
+                    scan.path, DEFAULT_RECONS_FOLDER
                 )
             else:
-                info = f"delta/beta scores of slice {slice_index} for scan {scan} computed."
-                _logger.processSucceed(info, extra=extra)
-                ProcessManager().notify_dataset_state(
-                    dataset=scan,
-                    process=self,
-                    state=DatasetState.WAIT_USER_VALIDATION,
-                    details=info,
+                l_config["output"]["location"] = output_dir
+            # TODO: allow file format modifications
+            l_config["output"]["file_format"] = "hdf5"
+            if "phase" not in config:
+                l_config["phase"] = {}
+            l_config["phase"]["delta_beta"] = db
+            l_config["phase"]["method"] = "Paganin"
+            res[db] = l_config
+        return res
+
+    def _run_one_slice_several_db(
+        self,
+        scan,
+        configs,
+        slice_index,
+        advancement,
+        dry_run,
+        cluster_config,
+    ):
+        future_tomo_objs = {}
+        success = True
+        recons_urls = {}
+        std_outs = []
+        std_errs = []
+
+        runners = run_nabu_one_slice_several_config(
+            nabu_configs=configs,
+            scan=scan,
+            slice_index=slice_index,
+            dry_run=dry_run,
+            file_format="hdf5",
+            advancement=advancement,
+            cluster_config=cluster_config.to_dict()
+            if cluster_config is not None
+            else None,
+            process_id=self.process_id,
+            instanciate_classes_only=True,
+            output_file_prefix_pattern=None,
+        )
+
+        for runner in runners:
+            if self._cancelled:
+                break
+
+            self._current_processing = runner
+            try:
+                results = runner.run()
+            except TimeoutError as e:
+                _logger.error(e)
+            else:
+                assert isinstance(
+                    results, dict
+                ), "results should be a dictionary with delta-beta as key and urls as value"
+
+                for db, res in results.items():
+                    success = success and res.success
+                    if isinstance(res, ResultsWithStd):
+                        std_outs.append(res.std_out)
+                        std_errs.append(res.std_err)
+                    if isinstance(res, ResultsLocalRun) and len(res.results_urls) > 0:
+                        assert len(res.results_urls) == 1, "only one slice expected"
+                        recons_urls[db] = res.results_urls[0]
+                    if isinstance(res, ResultSlurmRun):
+                        future_tomo_obj = FutureTomwerObject(
+                            tomo_obj=scan,
+                            process_requester_id=self.process_id,
+                            futures=res.future_slurm_jobs,
+                        )
+                        future_tomo_objs[db] = future_tomo_obj
+
+            if advancement is not None:
+                advancement.increaseAdvancement(1)
+
+        return success, recons_urls, future_tomo_objs, std_outs, std_errs
+
+    def _post_processing(
+        self,
+        scan,
+        db_reconstructions,
+    ):
+        post_processing = _PostProcessing(
+            scan=scan,
+            db_reconstructions=db_reconstructions,
+        )
+        post_processing._cancelled = self._cancelled
+        self._current_processing = post_processing
+        return post_processing.run()
+
+    def _resolve_futures(
+        self,
+        scan,
+        nabu_config: dict,
+        db_reconstructions,
+        slice_index,
+        future_tomo_objs: dict,
+    ):
+        assert isinstance(nabu_config, dict)
+        pag = False
+        ctf = False
+        if "phase" in nabu_config:
+            phase_method = nabu_config["phase"].get("method", "").lower()
+            if phase_method in ("pag", "paganin"):
+                pag = True
+            elif phase_method in ("ctf",):
+                ctf = True
+
+        # treat future.
+        for db, future_tomo_obj in future_tomo_objs.items():
+            if self._cancelled:
+                break
+
+            future_tomo_obj.results()
+            if future_tomo_obj.cancelled() or future_tomo_obj.exceptions():
+                continue
+            file_prefix = SingleSliceRunner.get_file_basename_reconstruction(
+                scan=scan,
+                slice_index=slice_index,
+                pag=pag,
+                db=int(db) if db is not None else None,
+                ctf=ctf,
+            )
+            # retrieve url
+            volume_identifier = nabu_utils.get_recons_volume_identifier(
+                file_prefix=file_prefix,
+                location=nabu_config["output"]["location"],
+                file_format=nabu_config.get("file_format", "hdf5"),
+                scan=scan,
+                slice_index=None,
+                start_z=None,
+                end_z=None,
+                expects_single_slice=True,
+            )
+
+            assert len(volume_identifier) <= 1, "only one slice expected"
+            if len(volume_identifier) == 1:
+                db_reconstructions[db] = volume_identifier[0]
+            else:
+                _logger.warning(
+                    f"something went wrong with reconstruction of {db} from {str(scan)}"
                 )
-        except Exception as e:
-            _logger.error(e)
+
+    @staticmethod
+    def _preprocess_slice_index(slice_index):
+        if isinstance(slice_index, str):
+            if not slice_index == "middle":
+                raise ValueError(f"slice index {slice_index} not recognized")
+            else:
+                return slice_index
+        elif not len(slice_index) == 1:
+            raise ValueError("only manage one slice")
         else:
-            if self._dump_process:
-                process_idx = SADeltaBetaProcess.process_to_tomwer_processes(
-                    scan=scan,
-                )
-                if self.dump_roi and process_idx is not None:
-                    self.dump_rois(
-                        scan, score_rois=score_rois, process_index=process_idx
+            return list(slice_index.values())[0]
+
+    def _process_end(self, scan, db_res, score_rois):
+        assert isinstance(scan, TomwerScanBase)
+        state = ProcessManager().get_dataset_state(
+            dataset_id=scan.get_identifier(), process=self
+        )
+        if state not in (
+            DatasetState.CANCELLED,
+            DatasetState.FAILED,
+            DatasetState.SKIPPED,
+        ):
+            try:
+                extra = {
+                    logconfig.DOC_TITLE: self._scheme_title,
+                    logconfig.SCAN_ID: str(scan),
+                }
+                slice_index = self.inputs.sa_delta_beta_params.get("slice_index", None)
+
+                if db_res is None:
+                    info = f"fail to compute delta/beta scores of slice {slice_index} for scan {scan}."
+                    _logger.processFailed(info, extra=extra)
+                    ProcessManager().notify_dataset_state(
+                        dataset=scan,
+                        process=self,
+                        state=DatasetState.FAILED,
+                        details=info,
                     )
+                else:
+                    info = f"delta/beta scores of slice {slice_index} for scan {scan} computed."
+                    _logger.processSucceed(info, extra=extra)
+                    ProcessManager().notify_dataset_state(
+                        dataset=scan,
+                        process=self,
+                        state=DatasetState.WAIT_USER_VALIDATION,
+                        details=info,
+                    )
+            except Exception as e:
+                _logger.error(e)
+            else:
+                if self._dump_process:
+                    process_idx = SADeltaBetaTask.process_to_tomwer_processes(
+                        scan=scan,
+                    )
+                    if self.dump_roi and process_idx is not None:
+                        self.dump_rois(
+                            scan, score_rois=score_rois, process_index=process_idx
+                        )
 
     @staticmethod
     def dump_rois(scan, score_rois: dict, process_index: int):
@@ -546,9 +652,9 @@ class SADeltaBetaProcess(
                         configuration=scan.sa_delta_beta_params.to_dict(),
                         process_index=process_index,
                         overwrite=True,
-                        process=SADeltaBetaProcess,
+                        process=SADeltaBetaTask,
                     )
-                    SADeltaBetaProcess._extends_results(
+                    SADeltaBetaTask._extends_results(
                         scan=scan, entry=entry, process_index=process_index
                     )
             except Exception as e:
@@ -593,3 +699,110 @@ class SADeltaBetaProcess(
                     results_db["reconstructed_slice"] = h5py.ExternalLink(
                         link_path, url.data_path()
                     )
+
+    def cancel(self):
+        """
+        stop current processing
+        """
+        if self._current_processing is not None:
+            self._cancelled = True
+            self._current_processing.cancel()
+
+
+class _PostProcessing:
+    """class used to run SA-delta-beta post-processing on reconstructed slices"""
+
+    def __init__(self, db_reconstructions, scan) -> None:
+        self._db_reconstructions = db_reconstructions
+        self._scan = scan
+        self._cancelled = False
+
+    def run(self):
+        datasets = self.load_datasets()
+
+        mask_disk_radius = get_disk_mask_radius(datasets)
+        scores = {}
+        rois = {}
+        for db, (url, data) in datasets.items():
+            if data is None:
+                score = None
+            else:
+                assert data.ndim == 2
+                data_roi = apply_roi(data=data, radius=mask_disk_radius, url=url)
+                rois[db] = data_roi
+
+                # move data_roi to [0-1] range
+                #  preprocessing: get percentile 0 and 99 from image and
+                #  "clean" highest and lowest pixels from it
+                min_p, max_p = numpy.percentile(data_roi, (1, 99))
+                data_roi_int = data_roi[...]
+                data_roi_int[data_roi_int < min_p] = min_p
+                data_roi_int[data_roi_int > max_p] = max_p
+                data_roi_int = (data_roi_int - min_p) / (max_p - min_p)
+
+                score = ComputedScore(
+                    tv=compute_score(data=data_roi_int, method=ScoreMethod.TV),
+                    std=compute_score(data=data_roi_int, method=ScoreMethod.STD),
+                )
+            scores[db] = (url, score)
+        return scores, rois
+
+    def load_datasets(self):
+        datasets_ = {}
+        for db, volume_identifier in self._db_reconstructions.items():
+            slice_url = None
+            # in case the try processing fails
+            try:
+                volume = VolumeFactory.create_tomo_object_from_identifier(
+                    volume_identifier
+                )
+                volumes_urls = tuple(volume.browse_data_urls())
+                if len(volumes_urls) > 1:
+                    _logger.warning(
+                        f"found a volume with mode that one url ({volumes_urls})"
+                    )
+                slice_url = volumes_urls[0]
+                data = get_data(slice_url)
+            except Exception as e:
+                _logger.error(
+                    f"Fail to compute a score for {volume_identifier}. Reason is {e}"
+                )
+                datasets_[db] = (slice_url, None)
+            else:
+                if data.ndim == 3:
+                    if data.shape[0] == 1:
+                        data = data.reshape(data.shape[1], data.shape[2])
+                    elif data.shape[2] == 1:
+                        data = data.reshape(data.shape[0], data.shape[1])
+                    else:
+                        raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
+                elif data.ndim == 2:
+                    pass
+                else:
+                    raise ValueError(f"Data is expected to be 2D. Not {data.ndim}D")
+
+                datasets_[db] = (slice_url, data)
+        return datasets_
+
+    def cancel(self):
+        self._cancelled = True
+
+
+class SADeltaBetaProcess(SADeltaBetaTask):
+    def __init__(
+        self,
+        process_id=None,
+        varinfo=None,
+        inputs=None,
+        node_id=None,
+        node_attrs=None,
+        execinfo=None,
+    ):
+        deprecated_warning(
+            name="tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta.SADeltaBetaProcess",
+            type_="class",
+            reason="improve readibility",
+            since_version="1.2",
+            replacement="SADeltaBetaTask",
+        )
+        super().__init__(process_id, varinfo, inputs, node_id, node_attrs, execinfo)