tomwer 1.3.27__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

tomwer/core/process/reconstruction/nabu/test/test_castvolume.py

@@ -0,0 +1,116 @@
+# coding: utf-8
+from __future__ import annotations
+
+import os
+
+import numpy
+import pytest
+
+from tomwer.core.process.reconstruction.nabu.castvolume import CastVolumeTask
+from tomwer.core.process.reconstruction.output import NabuOutputFileFormat
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.volume.edfvolume import EDFVolume
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.core.volume.tiffvolume import TIFFVolume
+
+
+def test_cast_volume_32bitstiff_to_16bits_tiff(tmp_path):
+    """test 32 bits tiffs to 16 bits works"""
+    dir_test = tmp_path / "test_dir"
+    dir_test.mkdir()
+    save_dir = tmp_path / "output_dir"
+    save_dir.mkdir()
+
+    vol_data = numpy.random.random(20 * 100 * 100) * 3600.4
+    vol_data = vol_data.reshape(20, 100, 100)
+    vol_data = vol_data.astype(numpy.float32)
+    volume = TIFFVolume(
+        folder=dir_test,
+        volume_basename="test_dir_vol_",
+        data=vol_data,
+    )
+    volume.save()
+
+    # test with output datadir as None
+    with pytest.raises(ValueError):
+        CastVolumeTask(
+            inputs={
+                "volume": volume,
+                "configuration": {
+                    "output_file_path": None,
+                    "output_file_format": NabuOutputFileFormat.EDF,
+                    "output_data_type": numpy.uint16,
+                },
+            },
+        ).run()
+
+    # test providing save dir and tiff
+    assert len(os.listdir(save_dir)) == 0
+    task = CastVolumeTask(
+        inputs={
+            "volume": volume,
+            "configuration": {
+                "output_dir": str(save_dir),
+                "output_file_format": NabuOutputFileFormat.EDF,
+                "output_data_type": numpy.uint16,
+            },
+        }
+    )
+    task.run()
+
+    assert len(os.listdir(save_dir)) == 20, "no files have been generated"
+    assert task.outputs.volume.load_data().shape == (20, 100, 100)
+    assert task.outputs.volume.load_data().dtype == numpy.uint16
+
+    # test providing save dir, a scan and hdf5
+    scan = NXtomoScan(scan=os.sep.join([str(tmp_path), "scan"]), entry="entry0000")
+    task = CastVolumeTask(
+        inputs={
+            "volume": volume,
+            "configuration": {
+                "output_dir": str(save_dir),
+                "output_file_format": NabuOutputFileFormat.HDF5,
+                "output_data_type": numpy.float32,
+            },
+            "scan": scan,
+        },
+    )
+    task.run()
+    assert task.outputs.volume.load_data().shape == (20, 100, 100)
+    assert task.outputs.volume.load_data().dtype == numpy.float32
+
+    # test providing a volume as output volume
+    output_volume = HDF5Volume(
+        file_path=os.path.join(str(tmp_path), "my_volume.hdf5"), data_path="entry0002"
+    )
+    task = CastVolumeTask(
+        inputs={
+            "volume": volume,
+            "configuration": {
+                "output_dir": str(save_dir),
+                "output_file_format": NabuOutputFileFormat.HDF5,
+                "output_data_type": numpy.uint8,
+            },
+            "output_volume": output_volume,
+        },
+    )
+    task.run()
+    assert task.outputs.volume.load_data().shape == (20, 100, 100)
+    assert task.outputs.volume.load_data().dtype == numpy.uint8
+
+    # test providing a volume us as output volume
+    output_volume = EDFVolume(folder=os.path.join(str(tmp_path), "my_edf_vol"))
+    task = CastVolumeTask(
+        inputs={
+            "volume": volume,
+            "configuration": {
+                "output_dir": str(save_dir),
+                "output_file_format": NabuOutputFileFormat.HDF5,
+                "output_data_type": numpy.int16,
+            },
+            "output_volume": output_volume.get_identifier().to_str(),
+        },
+    )
+    task.run()
+    assert task.outputs.volume.load_data().shape == (20, 100, 100)
+    assert task.outputs.volume.load_data().dtype == numpy.int16

tomwer/core/process/reconstruction/nabu/test/test_nabu_utils.py

@@ -0,0 +1,277 @@
+import pytest
+
+from tomwer.core.process.reconstruction.nabu.utils import (
+    get_recons_volume_identifier,
+    get_multi_cor_recons_volume_identifiers,
+    nabu_std_err_has_error,
+)
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+
+_scans = (
+    NXtomoScan(
+        scan="/my_scan_file.nx",
+        entry="entry_test",
+    ),
+    EDFTomoScan("/my_scan_folder"),
+)
+
+
+@pytest.mark.parametrize("scan", _scans)
+@pytest.mark.parametrize("axis", ("YZ", "XZ", "XY"))
+def test_get_recons_volume_identifier(scan, axis):
+    """
+    test get_recons_volume_identifier behavior
+    """
+
+    entry = scan.entry if isinstance(scan, NXtomoScan) else "entry"
+    # check some exceptions
+    with pytest.raises(ValueError):
+        get_recons_volume_identifier(
+            file_prefix="volume_rec",
+            location="/this/is/a/test",
+            file_format="toto",
+            slice_index=1080,
+            scan=scan,
+            axis=axis,
+        )
+
+    # check hdf5 reconstructions
+    id_rec_vols = get_recons_volume_identifier(
+        file_prefix="volume_rec",
+        location="/this/is/a/test",
+        file_format="hdf5",
+        slice_index="1080",
+        scan=scan,
+        axis=axis,
+    )
+    assert len(id_rec_vols) == 1
+    assert (
+        id_rec_vols[0].to_str()
+        == f"hdf5:volume:/this/is/a/test/volume_rec_plane_{axis}_001080.hdf5?path={entry}/reconstruction"
+    )
+
+    # check edf and jp2k slice reconstructions (are expected to have the same behavior)
+    id_rec_vols = get_recons_volume_identifier(
+        file_prefix="volume_rec",
+        location="/this/is/a/test",
+        file_format="edf",
+        slice_index="1080",
+        scan=scan,
+        axis=axis,
+    )
+    assert len(id_rec_vols) == 1
+    assert (
+        id_rec_vols[0].to_str() == "edf:volume:/this/is/a/test?file_prefix=volume_rec"
+    )
+
+    id_rec_vols = get_recons_volume_identifier(
+        file_prefix="volume_recslice",
+        location="/this/is/a/test",
+        file_format="jp2k",
+        slice_index="1080",
+        scan=scan,
+        axis=axis,
+    )
+    assert len(id_rec_vols) == 1
+    assert (
+        id_rec_vols[0].to_str()
+        == "jp2k:volume:/this/is/a/test?file_prefix=volume_recslice"
+    )
+
+    # check tiff slice reconstructions
+    id_rec_vols = get_recons_volume_identifier(
+        file_prefix="volume_rec",
+        location="/this/is/a/test",
+        file_format="tiff",
+        slice_index="1080",
+        scan=scan,
+        axis=axis,
+    )
+    assert len(id_rec_vols) == 1
+    assert (
+        id_rec_vols[0].to_str() == "tiff:volume:/this/is/a/test?file_prefix=volume_rec"
+    )
+
+
+@pytest.mark.parametrize("scan", _scans)
+def test_get_multi_cor_recons_volume_identifier(scan):
+    """
+    test the get_multi_cor_recons_volume_identifier function
+    """
+    entry = scan.entry if isinstance(scan, NXtomoScan) else "entry"
+
+    # dummy test with hdf5
+    id_rec_vols = get_multi_cor_recons_volume_identifiers(
+        scan=scan,
+        slice_index="middle",
+        location="/this/is/a/test",
+        file_prefix="rec",
+        cors=(10, 12),
+        file_format="hdf5",
+    )
+    assert isinstance(id_rec_vols, dict)
+    assert len(id_rec_vols) == 2
+    assert 10 in id_rec_vols.keys()
+    assert 12 in id_rec_vols.keys()
+    assert (
+        id_rec_vols[10].to_str()
+        == f"hdf5:volume:/this/is/a/test/rec_10.000_01024.hdf5?path={entry}/reconstruction"
+    )
+
+    # dummy test with tiff
+    id_rec_vols = get_multi_cor_recons_volume_identifiers(
+        scan=scan,
+        slice_index="middle",
+        location="/this/is/a/test",
+        file_prefix="rec",
+        cors=(10, 12),
+        file_format="tiff",
+    )
+    assert isinstance(id_rec_vols, dict)
+    assert len(id_rec_vols) == 2
+    assert 10 in id_rec_vols.keys()
+    assert 12 in id_rec_vols.keys()
+    assert id_rec_vols[10].to_str() == "tiff:volume:/this/is/a?file_prefix=test"
+
+
+def test_nabu_std_err_has_error():
+    assert nabu_std_err_has_error(None) is False
+    assert nabu_std_err_has_error(b"") is False
+    assert nabu_std_err_has_error(b"this is an error") is True
+    assert (
+        nabu_std_err_has_error(
+            b"warnings.warn('creating CUBLAS context to get version num"
+        )
+        is False
+    )
+    assert (
+        nabu_std_err_has_error(
+            b"warnings.warn('creating CUBLAS context to get version num\n this is an error"
+        )
+        is True
+    )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""/nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/skcuda/cublas.py:284: UserWarning: creating CUBLAS context to get version number
+            warnings.warn('creating CUBLAS context to get version number')
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/pycuda/elementwise.py:47: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            return SourceModule(
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/pycuda/elementwise.py:47: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            return SourceModule(
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            kernel.cu(111): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+            /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.8.0//bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+            kernel.cu(112): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+            /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.8.0//bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+            kernel.cu(113): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+            /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.8.0//bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+            kernel.cu(114): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+            /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.8.0//bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+            self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+            /nobackup/lbs0511/tomotools/venvs/2023_10_04/lib/python3.8/site-packages/pycuda/elementwise.py:47: UserWarning: The CUDA compiler succeeded, but said the following:
+            nvcc warning : The 'compute_35', 'compute_37', 'sm_35', and 'sm_37' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
+            return SourceModule("""
+        )
+        is False
+    )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""/cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_02_26/lib/python3.11/site-packages/cupyx/jit/_interface.py:173: FutureWarning: cupyx.jit.rawkernel is experimental. The interface can change in the future.
+        cupy._util.experimental('cupyx.jit.rawkernel')
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_02_26/lib/python3.11/site-packages/skcuda/cublas.py:284: UserWarning: creating CUBLAS context to get version number
+        warnings.warn('creating CUBLAS context to get version number')"""
+        )
+        is False
+    )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""/cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_09/lib/python3.11/site-packages/cupyx/jit/_interface.py:173: FutureWarning: cupyx.jit.rawkernel is experimental. The interface can change in the future.
+        cupy._util.experimental('cupyx.jit.rawkernel')
+        z_translation Not supported for EDF
+        y_translation Not supported for EDF
+        x_translation Not supported for EDF
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_09/lib/python3.11/site-packages/skcuda/cublas.py:284: UserWarning: creating CUBLAS context to get version number
+        warnings.warn('creating CUBLAS context to get version number')
+        unable to load metadata from /lbsram/data/id16b/inhouse1/comm_24apr/tomwerUpdate/testTomwer04/reconstructed_volumes/testTomwer04slice_pag_001080_db0500_plane_XY.vol.info"""
+        )
+        is False
+    )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""/cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_19/lib/python3.11/site-packages/cupyx/jit/_interface.py:173: FutureWarning: cupyx.jit.rawkernel is experimental. The interface can change in the future.
+        cupy._util.experimental('cupyx.jit.rawkernel')
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_19/lib/python3.11/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+        kernel.cu(228): warning #177-D: variable "x_stop_other" was declared but never referenced
+
+        kernel.cu(230): warning #177-D: variable "y_stop_other" was declared but never referenced
+
+
+        self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_19/lib/python3.11/site-packages/skcuda/cublas.py:284: UserWarning: creating CUBLAS context to get version number
+        warnings.warn('creating CUBLAS context to get version number')
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_19/lib/python3.11/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+        kernel.cu(228): warning #177-D: variable "x_stop_other" was declared but never referenced
+
+        kernel.cu(230): warning #177-D: variable "y_stop_other" was declared but never referenced
+
+
+        self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_19/lib/python3.11/site-packages/nabu/cuda/kernel.py:49: UserWarning: The CUDA compiler succeeded, but said the following:
+        kernel.cu(131): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+        /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.7.1/bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+
+        kernel.cu(132): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+        /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.7.1/bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+
+        kernel.cu(133): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+        /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.7.1/bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+
+        kernel.cu(134): warning #1215-D: function "tex2D(texture<T, 2, cudaReadModeElementType>, float, float) [with T=float]"
+        /cvmfs/hpc.esrf.fr/software/packages/ubuntu20.04/x86_64/cuda/11.7.1/bin/../targets/x86_64-linux/include/texture_fetch_functions.h(198): here was declared deprecated
+
+        kernel.cu(21): warning #177-D: function "linear_interpolation" was declared but never referenced
+
+
+        self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_04_19/lib/python3.11/site-packages/cupy/cuda/compiler.py:233: PerformanceWarning: Jitify is performing a one-time only warm-up to populate the persistent cache, this may take a few seconds and will be improved in a future release...
+        jitify._init_module()"""
+        )
+        is False
+    )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""pytools.persistent_dict: unable to import 'siphash24.siphash13', """
+        )
+        is False
+    )
+
+    assert (
+        nabu_std_err_has_error(
+            b"""CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.
+        _create_built_program_from_source_cached(
+        /cvmfs/tomo.esrf.fr/software/packages/linux/x86_64/tomotools/2024_09_06/lib/python3.11/site-packages/pyopencl/cache.py:499: CompilerWarning: Non-empty compiler output encountered. Set the environment variable PYOPENCL_COMPILER_OUTPUT=1 to see more.
+        prg.build(options_bytes, devices)"""
+        )
+        is False
+    )

tomwer/core/process/reconstruction/nabu/test/test_nabunormalization.py

@@ -0,0 +1,199 @@
+# coding: utf-8
+from __future__ import annotations
+
+import configparser
+from collections import namedtuple
+
+import numpy
+import pytest
+from silx.io.url import DataUrl
+from tomoscan.io import HDF5File
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
+from tomwer.core.process.reconstruction.nabu import settings as nabu_settings
+from tomwer.core.process.reconstruction.nabu.nabuslices import NabuSlicesTask
+from tomwer.core.process.reconstruction.normalization.normalization import (
+    SinoNormalizationTask,
+)
+from tomwer.core.process.reconstruction.normalization.params import (
+    SinoNormalizationParams,
+)
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.core.process.reconstruction.output import (
+    PROCESS_FOLDER_RECONSTRUCTED_SLICES,
+)
+
+try:
+    import nabu
+except ImportError:
+    has_nabu = False
+else:
+    has_nabu = True
+import os
+
+_norm_setting = namedtuple("_norm_setting", ["method", "source", "extra_infos"])
+
+_nabu_norm_field = namedtuple(
+    "_nabu_norm_field",
+    ["sino_normalization", "has_sino_normalization_file"],
+)
+
+
+normalization_config_test = (
+    # no normalization
+    (
+        _norm_setting(method="none", source=None, extra_infos=None),
+        _nabu_norm_field(
+            sino_normalization="",
+            has_sino_normalization_file=False,
+        ),
+    ),
+    # chebyshev normalization
+    (
+        _norm_setting(method="chebyshev", source=None, extra_infos=None),
+        _nabu_norm_field(
+            sino_normalization="chebyshev",
+            has_sino_normalization_file=False,
+        ),
+    ),
+    # divide by a scalar
+    (
+        _norm_setting(method="division", source="scalar", extra_infos={"value": 12.0}),
+        _nabu_norm_field(
+            sino_normalization="division",
+            has_sino_normalization_file=True,
+        ),
+    ),
+    # substract a roi
+    (
+        _norm_setting(
+            method="subtraction",
+            source="manual ROI",
+            extra_infos={
+                "start_x": 0.0,
+                "end_x": 1.0,
+                "start_y": 0.0,
+                "end_y": 1.0,
+                "calc_fct": "mean",
+                "calc_area": "volume",
+                "calc_method": "scalar",
+            },
+        ),
+        _nabu_norm_field(
+            sino_normalization="subtraction",
+            has_sino_normalization_file=True,
+        ),
+    ),
+    # substract from a dataset
+    (
+        _norm_setting(
+            method="subtraction",
+            source="from dataset",
+            extra_infos={
+                "dataset_url": DataUrl(
+                    file_path="random_dataset.hdf5",
+                    data_path="data",
+                    scheme="silx",
+                ),
+                "calc_fct": "median",
+                "calc_area": "volume",
+                "calc_method": "scalar",
+            },
+        ),
+        _nabu_norm_field(
+            sino_normalization="subtraction",
+            has_sino_normalization_file=True,
+        ),
+    ),
+)
+
+
+@pytest.mark.skipif(
+    (not has_nabu or nabu.version < "2022.2"),
+    reason="nabu not available or the current version doesn't handle sino normlaization yet",
+)
+@pytest.mark.parametrize(
+    "norm_setting, expected_nabu_conf", [item for item in normalization_config_test]
+)
+def test_normalization(norm_setting, expected_nabu_conf, tmp_path):
+    """
+    Insure normalization is correctly provided to nabu configuration file
+    For this run a normalization process followed by a nabu process.
+    """
+    scan_dir = tmp_path / "scan"
+    scan_dir.mkdir()
+
+    nabu_cfg_folders = os.path.join(scan_dir, nabu_settings.NABU_CFG_FILE_FOLDER)
+    os.makedirs(nabu_cfg_folders, exist_ok=True)
+
+    random_dataset_file = os.path.join(nabu_cfg_folders, "random_dataset.hdf5")
+
+    # create a random dataset if necessary
+    with HDF5File(random_dataset_file, mode="w") as h5f:
+        h5f["data"] = numpy.ones((20, 20))
+
+    mock = MockNXtomo(
+        scan_path=scan_dir,
+        n_proj=10,
+        n_ini_proj=10,
+        scan_range=180,
+        dim=20,
+    )
+    scan = mock.scan
+
+    cfg_folder = os.path.join(
+        str(scan_dir), PROCESS_FOLDER_RECONSTRUCTED_SLICES, "nabu_cfg_files"
+    )
+    cfg_file = os.path.join(cfg_folder, "entry_scan.cfg")
+    assert not os.path.exists(cfg_file)
+    norm_params = SinoNormalizationParams(
+        method=norm_setting.method,
+        source=norm_setting.source,
+        extra_infos=norm_setting.extra_infos,
+    )
+
+    normalization = SinoNormalizationTask(
+        inputs={
+            "data": scan,
+            "configuration": norm_params.to_dict(),
+            "serialize_output_data": False,
+        },
+        varinfo=None,
+    )
+    normalization.run()
+
+    # insure the method is style valid
+    assert scan.intensity_normalization.method.value == norm_setting.method
+    assert (
+        "tomwer_processing_res_code" in scan.intensity_normalization.get_extra_infos()
+    )
+
+    process = NabuSlicesTask(
+        inputs={
+            "data": scan,
+            "dry_run": True,
+            "nabu_params": get_default_nabu_config(nabu_fullfield_default_config),
+            "serialize_output_data": False,
+        },
+        varinfo=None,
+    )
+    process.run()
+    assert os.path.exists(cfg_file)
+
+    configuration = configparser.ConfigParser(allow_no_value=True)
+    configuration.read(cfg_file)
+
+    preproc_section = configuration["preproc"]
+    sino_normalization = preproc_section.get("sino_normalization", "")
+    sino_normalization_file = preproc_section.get("sino_normalization_file", "")
+    assert sino_normalization == expected_nabu_conf.sino_normalization
+    if expected_nabu_conf.has_sino_normalization_file:
+        url = DataUrl(path=sino_normalization_file)
+        assert url.is_valid()
+    else:
+        assert sino_normalization_file == ""
+    assert (
+        "tomwer_processing_res_code" in scan.intensity_normalization.get_extra_infos()
+    )