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

tomwer/core/scan/scanbase.py

@@ -40,10 +40,12 @@ import functools
 import numpy
 from silx.io.url import DataUrl
 from silx.utils.enum import Enum as _Enum
+from silx.io.utils import open as open_hdf5
+
 from tomoscan.identifier import VolumeIdentifier
-from tomoscan.io import HDF5File
 from tomoscan.normalization import IntensityNormalization
 from tomoscan.volumebase import VolumeBase
+from tomoscan.identifier import BaseIdentifier
 
 from tomwer.core.tomwer_object import TomwerObject
 from tomwer.core.utils.ftseriesutils import orderFileByLastLastModification
@@ -64,8 +66,6 @@ class TomwerScanBase(TomwerObject):
 
     _DICT_DARK_REF_KEYS = "dark_ref_params"
 
-    _DICT_LAMINO_RP_KEY = "lamino_params"
-
     _DICT_NABU_RP_KEY = "nabu_params"
 
     _DICT_AXIS_KEYS = "axis_params"
@@ -87,8 +87,6 @@ class TomwerScanBase(TomwerObject):
 
         self._nabu_params = None
         """nabu reconstruction parameters"""
-        self._lamino_params = None
-        """Set of reconstructions parameters for laminography"""
         self._axis_params = None
         """Axis parameters"""
         self._saaxis_params = None
@@ -113,6 +111,7 @@ class TomwerScanBase(TomwerObject):
         self._latest_vol_reconstructions = []
         """list of url related to latest volume reconstruction from nabu"""
         self._reconstruction_paths = set()
+        self._proposal_name = None
 
     def _clear_heavy_cache(self):
         """For scan for now we don't want to remove any information from the cache.
@@ -133,7 +132,7 @@ class TomwerScanBase(TomwerObject):
             and self.process_file is not None
             and os.path.exists(self.process_file)
         ):
-            with HDF5File(self.process_file, mode="r", swmr=True) as h5s:
+            with open_hdf5(self.process_file) as h5s:
                 self._process_index = len(h5s.items())
         else:
             self._process_index = 0
@@ -166,7 +165,7 @@ class TomwerScanBase(TomwerObject):
 
         if dark is None:
             if self._notify_ffc_rsc_missing:
-                logger.error("cannot make flat field correction, dark not found")
+                logger.warning("cannot make flat field correction, dark not found")
             can_process = False
 
         if dark is not None and dark.ndim != 2:
@@ -177,7 +176,7 @@ class TomwerScanBase(TomwerObject):
 
         if flat1 is None:
             if self._notify_ffc_rsc_missing:
-                logger.error("cannot make flat field correction, flat not found")
+                logger.warning("cannot make flat field correction, flat not found")
             can_process = False
         else:
             if flat1.ndim != 2:
@@ -251,14 +250,6 @@ class TomwerScanBase(TomwerObject):
     def nabu_recons_params(self, recons_params):
         self._nabu_params = recons_params
 
-    @property
-    def lamino_recons_params(self):
-        return self._lamino_params
-
-    @lamino_recons_params.setter
-    def lamino_recons_params(self, recons_params):
-        self._lamino_params = recons_params
-
     @property
     def axis_params(self):
         return self._axis_params
@@ -446,8 +437,6 @@ class TomwerScanBase(TomwerObject):
         # process index
         res[self._DICT_PROCESS_INDEX_KEY] = self._process_index
 
-        # lamino reconstruction parameters
-        res[self._DICT_LAMINO_RP_KEY] = self.lamino_recons_params
         return res
 
     def load_from_dict(self, desc):
@@ -466,8 +455,6 @@ class TomwerScanBase(TomwerObject):
             raise ValueError("Description is not an EDFScan json description")
 
         assert self.DICT_PATH_KEY in data  # pylint: disable=E1101
-        assert self._DICT_LAMINO_RP_KEY in data
-        self.lamino_recons_params = data[self._DICT_LAMINO_RP_KEY]
         # load axis reconstruction parameters
         axis_params = data.get(self._DICT_AXIS_KEYS, None)
         if axis_params is not None:
@@ -518,7 +505,6 @@ class TomwerScanBase(TomwerObject):
             isinstance(other, self.__class__)
             or isinstance(self, other.__class__)
             and self.type == other.type  # pylint: disable=E1101
-            and self.lamino_recons_params == other.lamino_recons_params
             and self.nabu_recons_params == other.nabu_recons_params
             and self.path == other.path  # pylint: disable=E1101
         )
@@ -600,8 +586,19 @@ class TomwerScanBase(TomwerObject):
         :return: list of urls that contains reconstruction from nabu
         :rtype: list
         """
+        from tomwer.core.process.reconstruction.output import (
+            PROCESS_FOLDER_NAME,
+        )  # avoid cyclic import
+
         all_recons_urls = set()
         recons_paths = self.reconstruction_paths
+        if self.working_directory:
+            recons_paths.add(
+                os.path.join(
+                    self.working_directory,
+                    PROCESS_FOLDER_NAME,
+                )
+            )
         for path in recons_paths:
             all_recons_urls.update(self.get_reconstructions_urls_from_path(path))
         return all_recons_urls
@@ -610,6 +607,17 @@ class TomwerScanBase(TomwerObject):
         if path is None or not os.path.isdir(path):
             return []
         else:
+
+            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,
+            )
+            from tomwer.core.process.reconstruction.nabu.settings import (
+                NABU_CFG_FILE_FOLDER,
+            )
+
             res = set()
             for f in os.listdir(path):
                 current_path = os.path.join(path, f)
@@ -624,10 +632,10 @@ class TomwerScanBase(TomwerObject):
                     f
                     in (
                         "matlab",
-                        "saaxis_results",
-                        "sadeltabeta_results",
                         "steps_file_basename_nabu_sinogram_save_step",
-                        "nabu_cfg_files",
+                        MULTI_COR_DEFAULT_FOLDER,
+                        MULTI_DB_DEFAULT_FOLDER,
+                        NABU_CFG_FILE_FOLDER,
                     )
                     or f.endswith("_vol")
                     or "slice" not in f
@@ -681,29 +689,43 @@ class TomwerScanBase(TomwerObject):
                 f"url should be a {VolumeIdentifier} or a string reprenseting a {VolumeIdentifier}. {type(url)} provided instead"
             )
 
-    def set_latest_vol_reconstructions(self, urls: typing.Iterable):
-        if urls is None:
+    def set_latest_vol_reconstructions(self, volume_identifiers: typing.Iterable):
+        if volume_identifiers is None:
             self._latest_vol_reconstructions = None
         else:
             self._latest_vol_reconstructions = list(
-                [self._process_volume_url(url) for url in urls]
+                [self._process_volume_url(url) for url in volume_identifiers]
             )
 
-    def add_latest_vol_reconstructions(self, urls):
-        self._latest_vol_reconstructions.extend(urls)
-
-    def _update_latest_recons_urls(self, old_path, new_path):
-        new_urls = []
-        for recons_url in self._latest_reconstructions:
-            new_urls.append(
-                DataUrl(
-                    file_path=recons_url.path().replace(old_path, new_path, 1),
-                    data_path=recons_url.data_path(),
-                    data_slice=recons_url.data_slice(),
-                    scheme=recons_url.scheme(),
-                )
-            )
-        self._latest_reconstructions = new_urls
+    def add_latest_vol_reconstructions(self, volume_identifiers: tuple):
+        assert isinstance(
+            volume_identifiers, tuple
+        ), "volume_identifiers is expected to be a tuple"
+        self._latest_vol_reconstructions.extend(
+            self._process_volume_url(volume_identifier)
+            for volume_identifier in volume_identifiers
+        )
+
+    def _update_latest_recons_identifiers(self, old_path, new_path):
+        def update_identifier(identifier):
+            assert isinstance(
+                identifier, BaseIdentifier
+            ), f"identifier is expected to be an instance of {BaseIdentifier}"
+            # small hack as this is not much used: simply try to replace a path by another. this is only used by the data transfer and EDF / SPEC
+            # this time is almost over
+            # FIXME: correct way to do this would be to recreate the volume, modify file or folder path and
+            # recreate the new identifier
+            identifier.replace(old_path, new_path, 1)
+
+        self._latest_reconstructions = [
+            update_identifier(identifier=identifier)
+            for identifier in self._latest_reconstructions
+        ]
+
+        self._latest_vol_reconstructions = [
+            update_identifier(identifier=identifier)
+            for identifier in self._latest_vol_reconstructions
+        ]
 
     def get_url_proj_index(self, url):
         """Return the index in the acquisition from the url"""
@@ -735,7 +757,7 @@ class TomwerScanBase(TomwerObject):
         from tomwer.core.process.task import Task
 
         if os.path.exists(self.process_file):
-            with HDF5File(self.process_file, mode="r") as h5s:
+            with open_hdf5(self.process_file) as h5s:
                 if not hasattr(self, "entry"):
                     entry = "entry"
                 else:
@@ -764,6 +786,12 @@ class TomwerScanBase(TomwerObject):
         """Return the equivalent DatasetAnalyzer for nabu"""
         raise NotImplementedError("Base class")
 
+    def get_proposal_name(self) -> Optional[str]:
+        return self._proposal_name
+
+    def set_proposal_name(self, proposal_name: str) -> None:
+        self._proposal_name = proposal_name
+
 
 class _TomwerBaseDock(object):
     """
@@ -837,7 +865,7 @@ def _get_reconstructed_single_file_volume(
 
                 if check_url is True:
                     try:
-                        with HDF5File(os.path.abspath(file_), "r", swmr=True) as h5f:
+                        with open_hdf5(os.path.abspath(file_)) as h5f:
                             if entry not in h5f:
                                 logger.info("{volume} does not exists")
                                 return None

tomwer/core/scan/scanfactory.py

@@ -36,17 +36,17 @@ from urllib.parse import urlparse
 
 import h5py
 from tomoscan.esrf.identifier.url_utils import split_path
-from tomoscan.esrf.scan.hdf5scan import HDF5TomoScan as _oHDF5TomoScan
 from tomoscan.factory import Factory as _oScanFactory
 from tomoscan.identifier import BaseIdentifier, ScanIdentifier, VolumeIdentifier
 from tomoscan.scanbase import TomoScanBase
 from tomoscan.tomoobject import TomoObject
+from nxtomo.application.nxtomo import NXtomo
 
 from tomwer.utils import docstring
 
 from .blissscan import BlissScan
 from .edfscan import EDFTomoScan, EDFTomoScanIdentifier
-from .hdf5scan import HDF5TomoScan, HDF5TomoScanIdentifier
+from .hdf5scan import NXtomoScan, NXtomoScanIdentifier
 
 _logger = logging.getLogger(__name__)
 
@@ -93,7 +93,7 @@ class ScanFactory(object):
                 if scheme == "edf":
                     identifier = EDFTomoScanIdentifier.from_str(identifier=identifier)
                 elif scheme == "hdf5":
-                    identifier = HDF5TomoScanIdentifier.from_str(identifier=identifier)
+                    identifier = NXtomoScanIdentifier.from_str(identifier=identifier)
                 else:
                     raise ValueError(f"Scheme {scheme} not recognized")
             else:
@@ -111,7 +111,7 @@ class ScanFactory(object):
                 raise NotImplementedError()
         elif scheme == "hdf5":
             if tomo_type == ScanIdentifier.TOMO_TYPE:
-                return HDF5TomoScan.from_identifier(identifier=identifier)
+                return NXtomoScan.from_identifier(identifier=identifier)
             else:
                 raise NotImplementedError()
         else:
@@ -135,7 +135,7 @@ class ScanFactory(object):
         if entry is not None and not entry.startswith("/"):
             entry = "/" + entry
         if os.path.isfile(scan_path) and ScanFactory.is_hdf5_tomo(scan_path):
-            valid_entries = _oHDF5TomoScan.get_valid_entries(scan_path)
+            valid_entries = NXtomo.get_valid_entries(scan_path)
             if entry is None:
                 if len(valid_entries) > 1:
                     _logger.warning(
@@ -148,7 +148,7 @@ class ScanFactory(object):
                     f"entry {entry} is invalid. Does it exists ? Is the "
                     f"file NXTomo compliant ?. Valid entry are {valid_entries}"
                 )
-            return HDF5TomoScan(scan=scan_path, entry=entry)
+            return NXtomoScan(scan=scan_path, entry=entry)
         elif ScanFactory.is_edf_tomo(scan_path):
             return EDFTomoScan(scan=scan_path)
         elif accept_bliss_scan and BlissScan.is_bliss_file(scan_path):
@@ -169,12 +169,12 @@ class ScanFactory(object):
         scan_path = scan_path.rstrip(os.path.sep)
         if EDFTomoScan.is_tomoscan_dir(scan_path):
             return (EDFTomoScan(scan=scan_path),)
-        elif HDF5TomoScan.is_tomoscan_dir(scan_path):
+        elif NXtomoScan.is_tomoscan_dir(scan_path):
             scans = []
-            master_file = HDF5TomoScan.get_master_file(scan_path=scan_path)
-            entries = HDF5TomoScan.get_valid_entries(master_file)
+            master_file = NXtomoScan.get_master_file(scan_path=scan_path)
+            entries = NXtomo.get_valid_entries(master_file)
             for entry in entries:
-                scans.append(HDF5TomoScan(scan=scan_path, entry=entry, index=None))
+                scans.append(NXtomoScan(scan=scan_path, entry=entry, index=None))
             return tuple(scans)
         elif accept_bliss_scan and BlissScan.is_bliss_file(scan_path):
             scans = []
@@ -201,8 +201,8 @@ class ScanFactory(object):
             )
         elif _dict[TomoScanBase.DICT_TYPE_KEY] == EDFTomoScan._TYPE:
             return EDFTomoScan(scan=None).load_from_dict(_dict)
-        elif _dict[TomoScanBase.DICT_TYPE_KEY] == HDF5TomoScan._TYPE:
-            return HDF5TomoScan.from_dict(_dict)
+        elif _dict[TomoScanBase.DICT_TYPE_KEY] == NXtomoScan._TYPE:
+            return NXtomoScan.from_dict(_dict)
         else:
             raise ValueError(
                 f"Scan type {_dict[TomoScanBase.DICT_TYPE_KEY]} is not managed"
@@ -253,4 +253,4 @@ class ScanFactory(object):
         if os.path.isfile(scan_path):
             return h5py.is_hdf5(scan_path)
         else:
-            return HDF5TomoScan.directory_contains_scan(scan_path)
+            return NXtomoScan.directory_contains_scan(scan_path)

tomwer/core/scan/test/test_edf.py

@@ -48,6 +48,6 @@ def test_working_directory():
     scan = EDFTomoScan(scan=None)
     assert scan.working_directory is None
     scan = EDFTomoScan(scan="my_folder")
-    assert scan.working_directory == os.path.realpath("my_folder")
+    assert scan.working_directory == os.path.abspath("my_folder")
     scan = EDFTomoScan(scan="/full/path/to/my/folder")
-    assert scan.working_directory == os.path.realpath("/full/path/to/my/folder")
+    assert scan.working_directory == os.path.abspath("/full/path/to/my/folder")

tomwer/core/scan/test/test_future_scan.py

@@ -33,17 +33,17 @@ import asyncio
 import os
 
 from tomwer.core.futureobject import FutureTomwerObject
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 
 
 def test_simple_future_tomo_obj(tmpdir):
     """Simple test of the FutureTomwerScan API"""
-    scan = MockHDF5(
+    scan = MockNXtomo(
         scan_path=os.path.join(tmpdir, "scan_test"),
         n_proj=10,
         n_ini_proj=10,
         create_ini_dark=False,
-        create_ini_ref=False,
+        create_ini_flat=False,
         dim=10,
     ).scan
     future = asyncio.Future()

tomwer/core/scan/test/test_h5.py

@@ -33,9 +33,9 @@ import shutil
 import tempfile
 import unittest
 
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomwer.core.utils.scanutils import MockHDF5
-from tomwer.tests.utils import UtilsTest
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.tests.datasets import TomwerCIDatasets
 
 
 class TestHDF5Scan(unittest.TestCase):
@@ -46,11 +46,13 @@ class TestHDF5Scan(unittest.TestCase):
         self._tmp_dir = tempfile.mkdtemp()
         self.dataset_file = os.path.join(self._tmp_dir, "frm_edftomomill_twoentries.nx")
         shutil.copyfile(
-            UtilsTest.getH5Dataset(folderID="frm_edftomomill_twoentries.nx"),
+            TomwerCIDatasets.get_dataset(
+                "h5_datasets/frm_edftomomill_twoentries.nx",
+            ),
             self.dataset_file,
         )
         assert os.path.isfile(self.dataset_file)
-        self.scan = HDF5TomoScan(scan=self.dataset_file, entry="entry0000")
+        self.scan = NXtomoScan(scan=self.dataset_file, entry="entry0000")
 
     def test_scan_dir(self):
         assert self.scan.scan_dir_name() == self._tmp_dir.split(os.sep)[-1]
@@ -58,27 +60,27 @@ class TestHDF5Scan(unittest.TestCase):
     def testFFInterval(self):
         """test the call to ff_interval"""
         scan_path = os.path.join(self._tmp_dir, "my_scan_1")
-        scan_1 = MockHDF5(
+        scan_1 = MockNXtomo(
             scan_path=scan_path,
             n_ini_proj=20,
             n_proj=20,
             n_alignement_proj=2,
-            create_final_ref=True,
+            create_final_flat=True,
             create_ini_dark=True,
-            create_ini_ref=True,
+            create_ini_flat=True,
             n_refs=5,
         ).scan
         self.assertEqual(scan_1.ff_interval, 20)
 
         scan_path2 = os.path.join(self._tmp_dir, "my_scan_2")
-        scan_2 = MockHDF5(
+        scan_2 = MockNXtomo(
             scan_path=scan_path2,
             n_ini_proj=10,
             n_proj=10,
             n_alignement_proj=2,
-            create_final_ref=False,
+            create_final_flat=False,
             create_ini_dark=True,
-            create_ini_ref=True,
+            create_ini_flat=True,
             n_refs=1,
         ).scan
         self.assertEqual(scan_2.ff_interval, 0)
@@ -86,9 +88,9 @@ class TestHDF5Scan(unittest.TestCase):
 
 def test_working_directory():
     """test behavior of the working directory function"""
-    scan = HDF5TomoScan(scan=None, entry="my_entry")
+    scan = NXtomoScan(scan=None, entry="my_entry")
     assert scan.working_directory is None
-    scan = HDF5TomoScan(scan="/full/path/my_file.sh", entry="my_entry")
-    assert scan.working_directory == os.path.realpath("/full/path")
-    scan = HDF5TomoScan(scan="my_file.sh", entry="my_entry")
-    assert scan.working_directory == os.path.realpath(".")
+    scan = NXtomoScan(scan="/full/path/my_file.sh", entry="my_entry")
+    assert scan.working_directory == os.path.abspath("/full/path")
+    scan = NXtomoScan(scan="my_file.sh", entry="my_entry")
+    assert scan.working_directory == os.path.abspath(".")

tomwer/core/scan/test/test_process_registration.py

@@ -32,10 +32,10 @@ import shutil
 import tempfile
 import unittest
 
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.process.task import Task
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 
 
 class TestProcessRegistration(unittest.TestCase):
@@ -62,7 +62,7 @@ class TestProcessRegistration(unittest.TestCase):
 
     def setUp(self):
         self.tmp_dir = tempfile.mkdtemp()
-        self.scan = MockHDF5(scan_path=self.tmp_dir, n_proj=2).scan
+        self.scan = MockNXtomo(scan_path=self.tmp_dir, n_proj=2).scan
 
     def tearDown(self):
         shutil.rmtree(self.tmp_dir)
@@ -85,42 +85,6 @@ class TestProcessRegistration(unittest.TestCase):
         )
         self.assertEqual(cor_value, 19)
 
-    def testGetDarks(self):
-        from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
-
-        for i in range(20):
-            results = {"darks": {"0": i * 2}, "flats": {"1": i}}
-            Task._register_process(
-                self.scan.process_file,
-                process=DarkRefsTask,
-                entry=self.scan.entry,
-                configuration=None,
-                results=results,
-                process_index=i,
-            )
-        flats = DarkRefsTask.get_darks_frm_process_file(
-            self.scan.process_file, entry=self.scan.entry
-        )
-        self.assertEqual(flats[list(flats.keys())[0]], 19 * 2)
-
-    def testGetFlats(self):
-        from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
-
-        for i in range(20):
-            results = {"darks": {"0": i}, "flats": {"1": i}}
-            Task._register_process(
-                self.scan.process_file,
-                process=DarkRefsTask,
-                entry=self.scan.entry,
-                configuration=None,
-                results=results,
-                process_index=i,
-            )
-        flats = DarkRefsTask.get_flats_frm_process_file(
-            self.scan.process_file, entry=self.scan.entry
-        )
-        self.assertEqual(flats[list(flats.keys())[0]], 19)
-
     def testGetProcessNodes(self):
         """insure it return the last dark process based on the processing index"""
 
@@ -134,7 +98,7 @@ class TestProcessRegistration(unittest.TestCase):
                 process_index=i,
             )
 
-        with HDF5File(self.scan.process_file, "r", swmr=True) as h5f:
+        with HDF5File(self.scan.process_file, "r", swmr=get_swmr_mode()) as h5f:
             nodes = Task._get_process_nodes(
                 root_node=h5f[self.scan.entry], process=self.DummyProcess
             )

tomwer/core/scan/test/test_scan.py

@@ -1,49 +1,18 @@
-# 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__ = "24/01/2017"
-
 import contextlib
 import logging
 import os
 import shutil
 import tempfile
 import unittest
-from multiprocessing import Process
 
 import fabio.edfimage
 import numpy
 
 from tomwer.core.process.reconstruction.nabu import nabuslices
-from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.utils.scanutils import MockEDF
-from tomwer.tests.utils import UtilsTest
+from tomwer.tests.datasets import TomwerCIDatasets
 
 logging.disable(logging.INFO)
 
@@ -59,7 +28,9 @@ class TestScanFactory(unittest.TestCase):
             ScanFactory.create_scan_object(scan_dir)
 
     def test_scan_edf(self):
-        scan_dir = UtilsTest.getEDFDataset("test10")
+        scan_dir = TomwerCIDatasets.get_dataset(
+            "edf_datasets/test10",
+        )
         scan = ScanFactory.create_scan_object(scan_dir)
         self.assertTrue(isinstance(scan, EDFTomoScan))
 
@@ -101,8 +72,8 @@ class TestScanValidatorFindNabuFiles(unittest.TestCase):
                             pag=pag if delta_beta is not None else False,
                             ctf=ctf if delta_beta is not None else False,
                             db=delta_beta,
+                            axis="XY",
                         )
-                        print("file_name is", file_name)
                         with self.subTest(
                             slice_index=slice_index,
                             pag_db=delta_beta,
@@ -400,47 +371,3 @@ def test_get_sinogram(tmp_path):
         sinogram_1,
         numpy.array([[2, 3], [6, 7], [10, 11], [14, 15]]),
     )
-
-
-class TestSeveralWriteWithThreading(unittest.TestCase):
-    class DummyProcess(Task):
-        @staticmethod
-        def program_name():
-            """Name of the program used for this processing"""
-            return "dummy program"
-
-        @staticmethod
-        def program_version():
-            """version of the program used for this processing"""
-            return "0.0.0"
-
-        @staticmethod
-        def definition():
-            """definition of the process"""
-            return "no definition"
-
-    def setUp(self):
-        self.tmp_dir = tempfile.mkdtemp()
-        self._file = os.path.join(self.tmp_dir, "XXXtomwer_processes.h5")
-
-    def tearDown(self):
-        shutil.rmtree(self.tmp_dir)
-
-    def testSeveralWrite(self):
-        processes = []
-        for i in range(20):
-            args = (
-                self._file,
-                TestSeveralWriteWithThreading.DummyProcess,
-                "entry0000",
-                {"info": "no configuration"},
-                {"data": numpy.random.random(2000)},
-                i,
-                None,
-                True,
-            )
-            processes.append(Process(target=Task._register_process, args=args))
-        for process in processes:
-            process.start()
-        for process in processes:
-            process.join()