tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/core/process/control/nxtomoconcatenate.py

@@ -5,10 +5,10 @@ from tomoscan.serie import Serie
 from ewokscore.missing_data import is_missing_data
 
 from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 
-from nxtomomill.nexus.nxtomo import NXtomo
-from nxtomomill.nexus.utils import concatenate as nx_concatenate
+from nxtomo.application.nxtomo import NXtomo
+from nxtomomill.utils.nexus import concatenate as nx_concatenate
 
 _logger = logging.getLogger(__name__)
 
@@ -28,7 +28,7 @@ class ConcatenateNXtomoTask(
     output_names=("data",),
 ):
     """
-    Task used to concatenate a list of NXtomo (HDF5TomoScan) into a single NXtomo
+    Task used to concatenate a list of NXtomo (NXtomoScan) into a single NXtomo
     """
 
     def run(self):
@@ -43,17 +43,17 @@ class ConcatenateNXtomoTask(
             file_path=self.inputs.output_file, serie=scans_serie
         )
 
-        # cast scan from HDF5tomoScan to NXtomo
-        def cast_scan_to_nxtomo(obj: HDF5TomoScan):
-            # convert HDF5Tomoscan to NXtomo as we expect to get HDF5TomoScan
-            if isinstance(obj, HDF5TomoScan):
+        # cast scan from NXtomoScan to NXtomo
+        def cast_scan_to_nxtomo(obj: NXtomoScan):
+            # convert NXtomoScan to NXtomo as we expect to get NXtomoScan
+            if isinstance(obj, NXtomoScan):
                 return NXtomo().load(
                     file_path=obj.master_file,
                     data_path=obj.entry,
                 )
             else:
                 raise TypeError(
-                    f"nxtomos are supposed to be instances of {NXtomo} or {HDF5TomoScan}. Get {type(obj)}"
+                    f"nxtomos are supposed to be instances of {NXtomo} or {NXtomoScan}. Get {type(obj)}"
                 )
 
         scans_serie = tuple([cast_scan_to_nxtomo(nxtomo) for nxtomo in scans_serie])
@@ -68,8 +68,8 @@ class ConcatenateNXtomoTask(
             overwrite=self.inputs.overwrite,
         )
 
-        # cast back nxtomomill NXtomo to HDF5TomoScan (reference object for tomwer)
-        scan = HDF5TomoScan(
+        # cast back nxtomomill NXtomo to NXtomoScan (reference object for tomwer)
+        scan = NXtomoScan(
             scan=output_file,
             entry=self.inputs.output_entry,
         )
@@ -84,14 +84,14 @@ def format_output_location(file_path, serie: Serie):
     format possible keys from the location like {scan_dir} or {scan_path}
 
     :param file_path:
-    :param serie: serie of HDF5TomoScan
+    :param serie: serie of NXtomoScan
     :return:
     """
     if serie is None:
         _logger.warning("scan is !none, enable to format the nabu output location")
 
     for scan in serie:
-        if not isinstance(scan, HDF5TomoScan):
+        if not isinstance(scan, NXtomoScan):
             raise TypeError
 
     def get_common_path():

tomwer/core/process/control/nxtomomill.py

@@ -23,6 +23,8 @@
 #
 # ###########################################################################*/
 
+from __future__ import annotations
+
 __authors__ = ["H. Payno"]
 __license__ = "MIT"
 __date__ = "30/07/2020"
@@ -32,34 +34,33 @@ import logging
 import os
 import pathlib
 
+from tomoscan.serie import Serie
+
 from nxtomomill import converter as nxtomomill_converter
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
 from nxtomomill.io.config import TomoHDF5Config as HDF5Config
-from nxtomomill.converter.hdf5.utils import get_default_output_file
+from nxtomomill.converter.hdf5.utils import (
+    get_default_output_file,
+)
 
+from tomwer.io.utils.raw_and_processed_data import to_raw_data_path
+from tomwer.core.process.output import ProcessDataOutputDirMode
 from tomwer.core.process.task import TaskWithProgress
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.utils.scanutils import format_output_location
 
-from silx.utils.enum import Enum as _Enum
-
 _logger = logging.getLogger(__name__)
 
 
-class NXtomomillNXDefaultOutput(_Enum):
-    NEAR_INPUT_FILE = "near input"
-    PROCESSED_DATA = "processed data dir"
-
-
 class H5ToNxProcess(
     TaskWithProgress,
     input_names=("h5_to_nx_configuration",),
     optional_input_names=(
         "progress",
-        "hdf5_scan",
+        "bliss_scan",
         "serialize_output_data",
     ),
-    output_names=("data",),
+    output_names=("data", "serie"),
 ):
     """
     Task to convert from a bliss dataset to a nexus compliant dataset
@@ -67,21 +68,29 @@ class H5ToNxProcess(
 
     @staticmethod
     def deduce_output_file_path(master_file_name, scan, entry, outputdir):
-        assert isinstance(outputdir, str), "outputdir is expected to be a str"
-
-        master_file_name = os.path.realpath(master_file_name)
+        master_file_name = os.path.abspath(master_file_name)
         # step 1: get output dir
         try:
-            outputdir = NXtomomillNXDefaultOutput.from_value(outputdir)
+            outputdir = ProcessDataOutputDirMode.from_value(outputdir)
         except ValueError:
+            # case path provided directly
             output_folder = format_output_location(outputdir, scan=scan)
         else:
-            if outputdir is NXtomomillNXDefaultOutput.PROCESSED_DATA:
+            if outputdir is ProcessDataOutputDirMode.OTHER:
+                raise ValueError(
+                    f"When output dir mode is {ProcessDataOutputDirMode.OTHER} we expect to received the output dir directly"
+                )
+            if outputdir is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
                 path = pathlib.Path(
                     get_default_output_file(input_file=master_file_name)
                 )
                 output_folder = str(path.parent)
-            elif outputdir is NXtomomillNXDefaultOutput.NEAR_INPUT_FILE:
+            elif outputdir is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+                path = pathlib.Path(
+                    get_default_raw_data_output_file(input_file=master_file_name)
+                )
+                output_folder = str(path.parent)
+            elif outputdir is ProcessDataOutputDirMode.IN_SCAN_FOLDER:
                 output_folder = os.path.dirname(master_file_name)
             else:
                 raise RuntimeError(f"output dir {outputdir} not handled")
@@ -119,20 +128,22 @@ class H5ToNxProcess(
         if len(convs) == 0:
             return
 
-        if len(convs) > 1:
-            raise RuntimeError(
-                f"the H5ToNxProcess expects to create at most one NXtomo. {len(convs)} created"
+        serie = []
+        for conv in convs:
+            conv_file, conv_entry = conv
+            scan_converted = NXtomoScan(scan=conv_file, entry=conv_entry)
+            _logger.processSucceed(
+                f"{config.input_file} {config.entries} has been translated to {scan_converted}"
             )
-
-        conv_file, conv_entry = convs[0]
-        scan_converted = HDF5TomoScan(scan=conv_file, entry=conv_entry)
-        _logger.processSucceed(
-            f"{config.input_file} {config.entries} has been translated to {scan_converted}"
+            if self.get_input_value("serialize_output_data", True):
+                data = scan_converted.to_dict()
+            else:
+                data = scan_converted
+            serie.append(data)
+        self.outputs.serie = Serie(
+            name=f"serie created from {config.input_file}", iterable=serie
         )
-        if self.get_input_value("serialize_output_data", True):
-            self.outputs.data = scan_converted.to_dict()
-        else:
-            self.outputs.data = scan_converted
+        self.outputs.data = serie[-1] if len(serie) > 0 else None
 
 
 class EDFToNxProcess(
@@ -157,23 +168,70 @@ class EDFToNxProcess(
             raise TypeError(
                 "edf_to_nx_configuration should be a dict or an instance of {TomoEDFConfig}"
             )
+        os.makedirs(os.path.dirname(config.output_file), exist_ok=True)
         file_path, entry = nxtomomill_converter.from_edf_to_nx(
             configuration=config, progress=self.progress
         )
-        scan = HDF5TomoScan(entry=entry, scan=file_path)
+        scan = NXtomoScan(entry=entry, scan=file_path)
         if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
             self.outputs.data = scan
 
     @staticmethod
-    def deduce_output_file_path(folder_path, output_dir, scan):
-        if output_dir in (None, NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value):
+    def deduce_output_file_path(
+        folder_path, output_dir: ProcessDataOutputDirMode | str, scan
+    ):
+        try:
+            output_dir = ProcessDataOutputDirMode.from_value(output_dir)
+        except Exception:
+            pass
+
+        if output_dir is ProcessDataOutputDirMode.OTHER:
+            raise ValueError("if mode is other, we expect 'output_dir' to be the path")
+        elif output_dir in (None, ProcessDataOutputDirMode.IN_SCAN_FOLDER):
             output_folder = os.path.dirname(folder_path)
-        elif output_dir == NXtomomillNXDefaultOutput.PROCESSED_DATA.value:
+        elif output_dir is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
             path = pathlib.Path(get_default_output_file(folder_path))
             output_folder = str(path.parent)
+        elif output_dir is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+            path = pathlib.Path(get_default_raw_data_output_file(folder_path))
+            output_folder = str(path.parent)
         else:
+            # else we expect people to provide output location
             output_folder = format_output_location(output_dir, scan=scan)
-        print("output output_folder is", output_folder)
         return os.path.join(output_folder, os.path.basename(folder_path) + ".nx")
+
+
+def get_default_raw_data_output_file(
+    input_file: str, output_file_extension: str = ".nx"
+) -> str:
+    """
+    Policy: look for any 'RAW_DATA' in file directory. If find any (before any 'PROCESSED_DATA' directory) replace it "RAW_DATA".
+    Then replace input_file by the expected file_extension and make sure the output file is different than the input file. Else append _nxtomo to it.
+
+    :param str input_file: file to be converted from bliss to NXtomo
+    :param str output_file_extension:
+    :return: default output file according to policy
+    """
+    if isinstance(input_file, pathlib.Path):
+        input_file = str(input_file)
+    if not isinstance(input_file, str):
+        raise TypeError(
+            f"input_file is expected to be an instance of str. {type(input_file)} provided"
+        )
+    if not isinstance(output_file_extension, str):
+        raise TypeError("output_file_extension is expected to be a str")
+    if not output_file_extension.startswith("."):
+        output_file_extension = "." + output_file_extension
+
+    input_file = os.path.abspath(input_file)
+    input_file_no_ext, _ = os.path.splitext(input_file)
+
+    output_path = to_raw_data_path(input_file_no_ext)
+    output_file = output_path + output_file_extension
+    if output_file == input_file:
+        # to be safer if the default output file is the same as the input file (if the input file has a .nx extension and not in any 'RAw_DATA' directory)
+        return output_path + "_nxtomo" + output_file_extension
+    else:
+        return output_file

tomwer/core/process/control/scantransfer.py

@@ -1,52 +1,29 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "05/07/2017"
-
-
 import fnmatch
 import logging
 import os
 import shutil
-from silx.utils.deprecation import deprecated_warning
+from tomwer.core.utils.deprecation import deprecated_warning
 
 import tomwer.version
 from tomwer.core.process.reconstruction.nabu.settings import NABU_CFG_FILE_FOLDER
 from tomwer.core.process.reconstruction.nabu.utils import update_cfg_file_after_transfer
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.settings import get_dest_path, get_lbsram_path
 from tomwer.core.signal import Signal
-from tomwer.core.utils import logconfig, rebaseParFile
+from tomwer.core.utils import logconfig
+from tomwer.core.utils.spec import rebaseParFile
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.io.utils import get_linked_files_with_entry
+from tomwer.core.process.reconstruction.saaxis.saaxis import (
+    DEFAULT_RECONS_FOLDER as MULTI_COR_DEFAULT_FOLDER,
+)
+from tomwer.core.process.reconstruction.sadeltabeta.sadeltabeta import (
+    DEFAULT_RECONS_FOLDER as MULTI_DB_DEFAULT_FOLDER,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -103,7 +80,7 @@ class ScanTransferTask(
         self._copying = inputs.get("copying", False)
         force_sync = inputs.get("force_sync", None)
         if force_sync is not None:
-            from silx.utils.deprecation import deprecated_warning
+            from tomwer.core.utils.deprecation import deprecated_warning
 
             deprecated_warning(
                 type_="Parameter",
@@ -190,7 +167,7 @@ class ScanTransferTask(
             else:
                 output_scan = scan._deduce_transfert_scan(outputdir)
                 try:
-                    output_scan._update_latest_recons_urls(
+                    output_scan._update_latest_recons_identifiers(
                         old_path=scan.path, new_path=output_scan.path
                     )
                 except Exception as e:
@@ -211,7 +188,7 @@ class ScanTransferTask(
             self._signalCopying(scanID=source, outputdir=target)
             output_scan = scan._deduce_transfert_scan(outputdir)
             try:
-                output_scan._update_latest_recons_urls(
+                output_scan._update_latest_recons_identifiers(
                     old_path=scan.path, new_path=output_scan.path
                 )
             except Exception as e:
@@ -242,7 +219,7 @@ class ScanTransferTask(
         )
 
     def _get_hdf5_sample_file_or_nx_dst(self, bliss_sample_file):
-        bliss_sample_file = os.path.realpath(bliss_sample_file)
+        bliss_sample_file = os.path.abspath(bliss_sample_file)
         if self._destDir is not None:
             rel_path = os.path.join(*bliss_sample_file.split(os.sep)[-2:])
             return os.path.join(self._destDir, rel_path)
@@ -266,7 +243,7 @@ class ScanTransferTask(
         return self._getOutputDirSpec() or self._getOutputDirLBS(bliss_sample_file)
 
     def _process_hdf5_scan(self, scan) -> TomwerScanBase:
-        assert isinstance(scan, HDF5TomoScan)
+        assert isinstance(scan, NXtomoScan)
         from tomwer.core.process.control.datalistener import DataListener
 
         files_sources = []
@@ -339,7 +316,7 @@ class ScanTransferTask(
             files_sources.append(scan.master_file)
             files_dest.append(new_nx_file)
             delete_opt.append(True)
-            output_scan = HDF5TomoScan(scan=new_nx_file, entry=scan.entry)
+            output_scan = NXtomoScan(scan=new_nx_file, entry=scan.entry)
         else:
             output_scan = None
 
@@ -397,8 +374,8 @@ class ScanTransferTask(
         patterns = [
             NABU_CFG_FILE_FOLDER,
             "*slice*",
-            "saaxis_results",
-            "sadeltabeta_results",
+            MULTI_COR_DEFAULT_FOLDER,
+            MULTI_DB_DEFAULT_FOLDER,
             "steps_file_basename_nabu_sinogram_save_step",
         ]
         for folder_ in os.listdir(dir_name):
@@ -482,7 +459,7 @@ class ScanTransferTask(
                 overwrite=self.get_input_value("overwrite", True),
                 noRsync=self._noRsync,
             )
-        elif isinstance(scan, HDF5TomoScan):
+        elif isinstance(scan, NXtomoScan):
             if self._move is True:
                 raise NotImplementedError("move option not implemented")
             if self._noRsync is True:
@@ -530,7 +507,7 @@ class ScanTransferTask(
 
         results = {"input_scan": str(input_scan), "output_scan": str(output_scan)}
         entry = "entry"
-        if isinstance(output_scan, HDF5TomoScan):
+        if isinstance(output_scan, NXtomoScan):
             entry = output_scan.entry
         self.register_process(
             process_file=output_scan.process_file,

tomwer/core/process/control/scanvalidator.py

@@ -31,7 +31,8 @@ import logging
 
 from ewokscore.task import Task as EwoksTask
 
-from tomwer.core import settings, utils
+from tomwer.core import settings
+from tomwer.core.utils.lbsram import is_low_on_memory
 from tomwer.core.process.task import BaseProcessInfo
 from tomwer.core.scan.scanbase import TomwerScanBase, _TomwerBaseDock
 from tomwer.core.scan.scanfactory import ScanFactory
@@ -98,7 +99,7 @@ class ScanValidator(BaseProcessInfo):
 
     def _freeStackIfNeeded(self):
         # if we are low in memory in lbsram: we will automatically validate the current scan
-        isLowMemoryLbs = utils.isLowOnMemory(settings.get_lbsram_path()) is True
+        isLowMemoryLbs = is_low_on_memory(settings.get_lbsram_path()) is True
         if not self.isValidationManual():
             self._validateStack()
         elif isLowMemoryLbs:

tomwer/core/process/control/test/test_concatenate_nxtomos.py

@@ -5,15 +5,15 @@ from tomwer.core.process.control.nxtomoconcatenate import (
     ConcatenateNXtomoTask,
     format_output_location,
 )
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockNXtomo
 
 
 def test_concatenate_nx_tomo_task(tmp_path):
     """
-    test execution of ConcatenateNXtomoTask with two HDF5TomoScan
+    test execution of ConcatenateNXtomoTask with two NXtomoScan
     """
-    scan_1 = MockHDF5(
+    scan_1 = MockNXtomo(
         scan_path=os.path.join(tmp_path, "scan1"),
         n_proj=10,
         n_ini_proj=10,
@@ -21,7 +21,7 @@ def test_concatenate_nx_tomo_task(tmp_path):
         dim=20,
         energy=12.3,
     ).scan
-    scan_2 = MockHDF5(
+    scan_2 = MockNXtomo(
         scan_path=os.path.join(tmp_path, "scan2"),
         n_proj=10,
         n_ini_proj=10,
@@ -42,18 +42,18 @@ def test_concatenate_nx_tomo_task(tmp_path):
         }
     )
     task.run()
-    assert isinstance(task.outputs.data, HDF5TomoScan)
+    assert isinstance(task.outputs.data, NXtomoScan)
     assert os.path.exists(output_scan_file)
     # note: correct processing of the concatenation is done at nxtomomill
 
 
 def test_format_output_location():
     """test behavior of format_output_location"""
-    scan1 = HDF5TomoScan(
+    scan1 = NXtomoScan(
         "/path/to/scan_1.nx",
         entry="entry0000",
     )
-    scan2 = HDF5TomoScan(
+    scan2 = NXtomoScan(
         "/path/to/scan_2.nx",
         entry="entry0001",
     )
@@ -65,7 +65,7 @@ def test_format_output_location():
     )
 
     assert format_output_location(
-        "concatenate.nx", Serie([scan1, scan2])
+        "concatenate.nx", Serie("my_serie", [scan1, scan2])
     ) == os.path.abspath("concatenate.nx")
 
     assert (

tomwer/core/process/control/test/test_email.py

@@ -1,7 +1,7 @@
 import os
 import numpy
-from tomwer.core.process.control.email import format_email_info, _ls_tomo_obj
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.process.control.emailnotifier import format_email_info, _ls_tomo_obj
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.volume.hdf5volume import HDF5Volume
 from tomwer.core.utils.scanutils import HDF5MockContext
 
@@ -11,11 +11,11 @@ def test__ls_tomo_obj(tmp_path):
     for i in range(2):
         open(os.path.join(tmp_path, f"{i}.nx"), "a").close()
 
-    scan = HDF5TomoScan(
+    scan = NXtomoScan(
         scan=os.path.join(tmp_path, "1.nx"),
         entry="entry0000",
     )
-    assert isinstance(scan, HDF5TomoScan)
+    assert isinstance(scan, NXtomoScan)
 
     assert len(_ls_tomo_obj(scan)) == 2
 

tomwer/core/process/control/test/test_h52nx_process.py

@@ -1,11 +1,12 @@
 import os
 from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.process.output import ProcessDataOutputDirMode
 from tomwer.core.process.control.nxtomomill import (
     EDFToNxProcess,
     H5ToNxProcess,
-    NXtomomillNXDefaultOutput,
+    get_default_raw_data_output_file,
 )
-from tomwer.core.utils.scanutils import MockHDF5, MockEDF
+from tomwer.core.utils.scanutils import MockNXtomo, MockEDF
 from nxtomomill.converter.hdf5.utils import PROCESSED_DATA_DIR_NAME, RAW_DATA_DIR_NAME
 
 
@@ -14,14 +15,14 @@ def test_h52nx_process_deduce_output_file_path(tmp_path):
     scan_path = str(tmp_path / "path" / RAW_DATA_DIR_NAME / "my_scan")
     os.makedirs(scan_path)
 
-    scan = MockHDF5(scan_path=scan_path, n_proj=0).scan
+    scan = MockNXtomo(scan_path=scan_path, n_proj=0).scan
 
     # test H52NXDefaultOutput.PROCESSED_DATA
     assert H5ToNxProcess.deduce_output_file_path(
         master_file_name=scan.master_file,
         scan=scan,
         entry=scan.entry,
-        outputdir=NXtomomillNXDefaultOutput.PROCESSED_DATA.value,
+        outputdir=ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER.value,
     ) == str(
         tmp_path
         / "path"
@@ -35,7 +36,7 @@ def test_h52nx_process_deduce_output_file_path(tmp_path):
         master_file_name=scan.master_file,
         scan=scan,
         entry=scan.entry,
-        outputdir=NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value,
+        outputdir=ProcessDataOutputDirMode.IN_SCAN_FOLDER.value,
     ) == str(
         tmp_path / "path" / RAW_DATA_DIR_NAME / "my_scan" / f"my_scan_{scan.entry}.nx"
     )
@@ -77,14 +78,14 @@ def test_edf2nx_process_deduce_output_file_path(tmp_path):
     # test NEAR_INPUT_FILE
     assert EDFToNxProcess.deduce_output_file_path(
         folder_path=scan_path,
-        output_dir=NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value,
+        output_dir=ProcessDataOutputDirMode.IN_SCAN_FOLDER.value,
         scan=scan,
     ) == os.path.join(tmp_path, "path", RAW_DATA_DIR_NAME, "my_edf_scan.nx")
 
     # test PROCESSED_DATA
     assert EDFToNxProcess.deduce_output_file_path(
         folder_path=scan_path,
-        output_dir=NXtomomillNXDefaultOutput.PROCESSED_DATA.value,
+        output_dir=ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER.value,
         scan=scan,
     ) == os.path.join(tmp_path, "path", PROCESSED_DATA_DIR_NAME, "my_edf_scan.nx")
 
@@ -104,3 +105,54 @@ def test_edf2nx_process_deduce_output_file_path(tmp_path):
         )
         == "/tmp/output/my_edf_scan.nx"
     )
+
+
+def test_get_default_raw_data_output_file():
+    """test 'get_default_raw_data_output_file' function"""
+    assert get_default_raw_data_output_file("/tmp/path/file.h5") == "/tmp/path/file.nx"
+    assert (
+        get_default_raw_data_output_file(f"/tmp/{PROCESSED_DATA_DIR_NAME}/file.h5")
+        == f"/tmp/{RAW_DATA_DIR_NAME}/file.nx"
+    )
+
+    assert (
+        get_default_raw_data_output_file(
+            f"/tmp/path/{PROCESSED_DATA_DIR_NAME}/toto/file.h5"
+        )
+        == f"/tmp/path/{RAW_DATA_DIR_NAME}/toto/file.nx"
+    )
+    # note: _RAW_DATA_DIR_NAME part of the path but not a folder
+    assert (
+        get_default_raw_data_output_file(f"/tmp/path_{RAW_DATA_DIR_NAME}/toto/file.h5")
+        == f"/tmp/path_{RAW_DATA_DIR_NAME}/toto/file.nx"
+    )
+
+    # 2. advance test
+    # 2.1 use case: '_RAW_DATA_DIR_NAME' is present twice in the path -> replace the deeper one
+    assert (
+        get_default_raw_data_output_file(
+            f"/tmp/{PROCESSED_DATA_DIR_NAME}/path/{RAW_DATA_DIR_NAME}/toto/file.h5"
+        )
+        == f"/tmp/{PROCESSED_DATA_DIR_NAME}/path/{RAW_DATA_DIR_NAME}/toto/file.nx"
+    )
+
+    # 2.2 use case: contains both '_RAW_DATA_DIR_NAME' and '_PROCESSED_DATA_DIR_NAME' in the path
+    assert (
+        get_default_raw_data_output_file(
+            f"/tmp/{PROCESSED_DATA_DIR_NAME}/path/{RAW_DATA_DIR_NAME}/toto/file.h5"
+        )
+        == f"/tmp/{PROCESSED_DATA_DIR_NAME}/path/{RAW_DATA_DIR_NAME}/toto/file.nx"
+    )
+
+    assert (
+        get_default_raw_data_output_file(
+            f"/tmp/{RAW_DATA_DIR_NAME}/path/{PROCESSED_DATA_DIR_NAME}/toto/file.h5"
+        )
+        == f"/tmp/{RAW_DATA_DIR_NAME}/path/{RAW_DATA_DIR_NAME}/toto/file.nx"
+    )
+
+    # 2.3 use case: expected output file is the input file. Make sure append '_nxtomo'
+    assert (
+        get_default_raw_data_output_file("/tmp/path/file.nx")
+        == "/tmp/path/file_nxtomo.nx"
+    )