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

orangecontrib/tomwer/widgets/__init__.py

@@ -22,8 +22,6 @@
 #
 #############################################################################
 
-import sysconfig
-
 try:
     from orangecanvas.utils.pkgmeta import get_distribution
 except ImportError:
@@ -57,10 +55,9 @@ WIDGET_HELP_PATH = (
     # You still need to build help pages using
     # make htmlhelp
     # inside doc folder
-    (
-        "/home/payno/Documents/dev/tomography/tomwer/build/html/canvas/widgets/widgets.html",
-        None,
-    ),
-    (f"{sysconfig.get_path('data')}/help/tomwer/index.html", None),
-    ("https://readthedocs.org/projects/tomwer/1.3/", None),
+    # (
+    #     "/home/payno/Documents/dev/tomography/tomwer/build/html/canvas/widgets/widgets.html",
+    #     None,
+    # ),
+    ("https://tomwer.readthedocs.io/en/latest/canvas/widgets/widgets.html", None),
 )

orangecontrib/tomwer/widgets/control/NXTomomillOW.py

@@ -163,11 +163,11 @@ class NXTomomillOW(
         """
         # for now we want to avoid propagation any processing.
         # task will be executed only when the user validates the dialog
-        h5_scan = super().get_task_inputs().get("hdf5_scan", None)
-        if h5_scan is not None:
-            if not isinstance(h5_scan, H5ToNxProcess):
-                raise TypeError("hdf5_scan is expected to be an instance of NXtomoScan")
-            self.add(h5_scan.path)
+        bliss_scan = super().get_task_inputs().get("bliss_scan", None)
+        if bliss_scan is not None:
+            if not isinstance(bliss_scan, BlissScan):
+                raise TypeError("bliss_scan is expected to be an instance of BlissScan")
+            self.add(bliss_scan.master_file)
 
     def _convertAndSend(self, bliss_url: str):
         """

tomwer/core/process/control/datalistener/datalistener.py

@@ -102,6 +102,11 @@ class DataListener(BaseProcessInfo):
     TIMOUT_READ_FILE = 30
     "When the event 'scan_ended' is received all data might not have been write" " yet"
 
+    SWMR_MODE = None
+    """The bliss writer is not using the swmr mode. This class has independant behavior regarding the tomoscan / nxotmo get_swmr_mode which is
+    dedicated to the internal tomotools behavior
+    """
+
     def __init__(self):
         super().__init__()
         self._host = settings.JSON_RPC_HOST
@@ -224,7 +229,7 @@ class DataListener(BaseProcessInfo):
         """Return the list of scans dir for this bliss_file / entry"""
 
         def get_scan_indexes():
-            with HDF5File(bliss_file, "r", swmr=True) as h5f:
+            with HDF5File(bliss_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
                 entry_node = h5f[entry]
                 if _SCAN_NUMBER_PATH in entry_node:
                     return h5py_read_dataset(entry_node[_SCAN_NUMBER_PATH])
@@ -249,7 +254,7 @@ class DataListener(BaseProcessInfo):
         """Return the proposal file of the experimentation if registred by the
         data listener"""
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -264,7 +269,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -306,7 +311,7 @@ class DataListener(BaseProcessInfo):
         """Return the proposal file of the experimentation if registred by the
         data listener"""
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -321,7 +326,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -355,7 +360,7 @@ class DataListener(BaseProcessInfo):
         """Return the proposal file of the experimentation if registred by the
         data listener"""
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -370,7 +375,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -405,7 +410,7 @@ class DataListener(BaseProcessInfo):
         specific sequence data
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -420,7 +425,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -498,7 +503,7 @@ class DataListener(BaseProcessInfo):
         # write
         def sequence_is_finished():
             try:
-                with HDF5File(bliss_file, "r", swmr=True) as h5f:
+                with HDF5File(bliss_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
                     end_scan_path = "/".join((entry, "end_time"))
                     return end_scan_path in h5f
             except Exception:

tomwer/core/process/control/nxtomomill.py

@@ -57,7 +57,7 @@ class H5ToNxProcess(
     input_names=("h5_to_nx_configuration",),
     optional_input_names=(
         "progress",
-        "hdf5_scan",
+        "bliss_scan",
         "serialize_output_data",
     ),
     output_names=("data", "serie"),

tomwer/core/process/edit/imagekeyeditor.py

@@ -83,7 +83,7 @@ def change_image_key_control(scan: NXtomoScan, config: dict) -> TomwerScanBase:
             filter(lambda item: item[1] is image_key_type, modifications.items())
         )
         frame_indexes = tuple(frame_indexes_dict.keys())
-        _logger.warning(f"will modify {frame_indexes} to {image_key_type}")
+        _logger.info(f"will modify {frame_indexes} to {image_key_type}")
         _change_image_key_control(
             file_path=scan.master_file,
             entry=scan.entry,

tomwer/core/process/reconstruction/axis/axis.py

@@ -40,7 +40,7 @@ from nabu.estimation.cor import (
     CenterOfRotationSlidingWindow,
     CenterOfRotationOctaveAccurate,
 )
-from nabu.pipeline.estimators import SinoCORFinder
+from nabu.pipeline.estimators import SinoCORFinder, CORFinder
 from nabu.resources.nxflatfield import update_dataset_info_flats_darks
 from processview.core.manager import DatasetState, ProcessManager
 from processview.core.superviseprocess import SuperviseProcess
@@ -76,7 +76,7 @@ else:
     has_composite_cor_finder = True
 from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 _logger = logging.getLogger(__name__)
 if not has_composite_cor_finder:
@@ -174,6 +174,50 @@ def compute_cor_nabu_growing_window(
         return res
 
 
+def compute_cor_nabu_growing_window_radios(
+    scan: TomwerScanBase,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="growing-window",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()  # Returns absolute cor
+    if isinstance(res, numpy.ndarray):
+        if len(res) == 1:
+            res = res[0]
+        else:
+            raise ValueError(
+                "nabu rsult is expected to be a scalar, numpy array found. Please upgrade nabu this issue is expected to be solved"
+            )
+
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_cor_nabu_growing_window_sinogram(
     scan: TomwerScanBase,
 ):
@@ -322,13 +366,7 @@ def compute_scan_cor_nabu_growing_window(scan):
     if scan.axis_params.use_sinogram:
         return compute_cor_nabu_growing_window_sinogram(scan=scan)
     else:
-        return compute_cor_nabu_growing_window(
-            radio_1=radio_1.copy(),
-            radio_2=radio_2.copy(),
-            side=scan.axis_params.side,
-            padding_mode=scan.axis_params.padding_mode,
-            flip_frame_2_lr=scan.axis_params.flip_lr,
-        )
+        return compute_cor_nabu_growing_window_radios(scan=scan)
 
 
 def compute_cor_nabu_sliding_window(
@@ -367,6 +405,42 @@ def compute_cor_nabu_sliding_window(
     return res
 
 
+def compute_cor_nabu_sliding_window_radios(
+    scan,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="sliding-window",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()  # Returns absolute cor.
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_cor_nabu_sliding_window_sinogram(
     scan,
 ):
@@ -422,13 +496,7 @@ def compute_scan_cor_nabu_sliding_window(scan):
     if scan.axis_params.use_sinogram:
         return compute_cor_nabu_sliding_window_sinogram(scan=scan)
     else:
-        return compute_cor_nabu_sliding_window(
-            radio_1=radio_1.copy(),
-            radio_2=radio_2.copy(),
-            side=scan.axis_params.side,
-            padding_mode=scan.axis_params.padding_mode,
-            flip_frame_2_lr=scan.axis_params.flip_lr,
-        )
+        return compute_cor_nabu_sliding_window_radios(scan=scan)
 
 
 def compute_scan_fourier_angles(scan):
@@ -453,6 +521,45 @@ def compute_scan_fourier_angles(scan):
     )
 
 
+def compute_scan_octave_accurate_radios(
+    scan,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="octave-accurate",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_scan_octave_accurate(scan):
     """
     Compute center of rotation from `octave-accurate` algorithm
@@ -478,6 +585,42 @@ def compute_scan_octave_accurate(scan):
     return res
 
 
+def compute_cor_nabu_centered_radios(
+    scan,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="centered",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_cor_nabu_centered(
     radio_1: numpy.ndarray,
     radio_2: numpy.ndarray,
@@ -532,12 +675,7 @@ def compute_scan_cor_nabu_centered(scan):
         "mode %s" % scan.axis_params.padding_mode
     )
 
-    return compute_cor_nabu_centered(
-        radio_1=radio_1.copy(),
-        radio_2=radio_2.copy(),
-        padding_mode=scan.axis_params.padding_mode,
-        flip_frame_2_lr=scan.axis_params.flip_lr,
-    )
+    return compute_cor_nabu_centered_radios(scan)
 
 
 def compute_cor_nabu_global(
@@ -567,6 +705,42 @@ def compute_cor_nabu_global(
     )
 
 
+def compute_cor_nabu_global_radios(
+    scan: TomwerScanBase,
+):
+    """
+    Call nabu.preproc.alignement.CenterOfRotationGrowingWindow.find_shift
+
+    :param TomwerScanBase scan:
+
+    :return:
+    """
+    has_darks = scan.reduced_darks is not None and len(scan.reduced_darks) > 0
+    has_flats = scan.reduced_flats is not None and len(scan.reduced_flats) > 0
+
+    projection_angles = scan.get_proj_angle_url()
+    projection_angles_i = {
+        value.path(): key for key, value in projection_angles.items()
+    }
+    url_radio_1, url_radio_2 = AxisTask.get_inputs_urls(scan=scan)
+    angle_radio_1 = float(projection_angles_i[url_radio_1.url.path()])
+    angle_radio_2 = float(projection_angles_i[url_radio_2.url.path()])
+    radio_angles = tuple(numpy.radians((angle_radio_1, angle_radio_2)))
+
+    corfinder = CORFinder(
+        dataset_info=adapt_tomwer_scan_to_nabu(scan),
+        method="global",
+        do_flatfield=has_darks and has_flats,
+        cor_options=scan.axis_params.get_nabu_cor_options_as_dict(),
+        radio_angles=radio_angles,
+        logger=_logger,
+    )
+    res = corfinder.find_cor()
+    return _absolute_pos_to_relative_with_warning(
+        absolute_pos=res, det_width=scan.dim_1
+    )
+
+
 def compute_scan_cor_nabu_global(scan):
     """
     Call to nabu.preproc.alignment.CenterOfRotation from the scan axis_params
@@ -585,13 +759,7 @@ def compute_scan_cor_nabu_global(scan):
         "compute scan axis from nabu CenterOfRotation with padding "
         "mode %s" % scan.axis_params.padding_mode
     )
-
-    return compute_cor_nabu_global(
-        radio_1=radio_1.copy(),
-        radio_2=radio_2.copy(),
-        padding_mode=scan.axis_params.padding_mode,
-        flip_frame_2_lr=scan.axis_params.flip_lr,
-    )
+    return compute_cor_nabu_global_radios(scan)
 
 
 def get_stdmax_column(x: numpy.ndarray) -> float:
@@ -996,7 +1164,7 @@ class AxisTask(
         :return:
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
                 entries = AxisTask._get_process_nodes(root_node=h5f, process=AxisTask)
                 if len(entries) == 0:
                     _logger.info("unable to find a Axis process in %s" % process_file)
@@ -1007,7 +1175,7 @@ class AxisTask(
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
             axis_nodes = AxisTask._get_process_nodes(
                 root_node=h5f[entry], process=AxisTask
             )

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

@@ -905,14 +905,17 @@ class AxisRP:
             self.side = "near"
         request_side = len(AXIS_MODE_METADATAS[self.mode].valid_sides) > 0
         if request_side:
-            options["side"] = self.side
+
+            if self.side == "near":
+                options["side"] = self.composite_options.get(
+                    "near_pos", self.estimated_cor
+                )
+            else:
+                options["side"] = self.side
+
         if self.side == "near":
-            near_pos = self.composite_options.get("near_pos", 0.0)
             near_width = self.composite_options.get("near_width", 20.0)
-            options["near_pos"] = near_pos
             options["near_width"] = near_width
-        else:
-            options["near_pos"] = "ignore"
 
         # append "extra_cor_options" to already handled cor options
         extra_cor_options = self.extra_cor_options.replace(" ", "")

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

@@ -45,7 +45,7 @@ import numpy
 from silx.io.url import DataUrl
 from sluurp.executor import submit as submit_to_slurm_cluster
 from sluurp.job import SBatchScriptJob
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 from tomoscan.normalization import Method as INormMethod
 from tomoscan.identifier import VolumeIdentifier
 
@@ -582,7 +582,7 @@ class _NabuBaseReconstructor:
                     dataset_url = DataUrl(path=dataset_url)
                     if os.path.exists(dataset_url.file_path()):
                         with HDF5File(
-                            dataset_url.file_path(), mode="r", swmr="True"
+                            dataset_url.file_path(), mode="r", swmr=get_swmr_mode()
                         ) as h5f:
                             if dataset_url.data_path() not in h5f:
                                 dataset_url = None

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

@@ -84,7 +84,7 @@ from processview.core.superviseprocess import SuperviseProcess
 from silx.io.dictdump import h5todict
 from silx.io.utils import h5py_read_dataset
 from silx.utils.enum import Enum as _Enum
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
@@ -494,7 +494,7 @@ class NabuSlicesTask(
         :rtype:dict
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
                 entries = NabuSlicesTask._get_process_nodes(
                     root_node=h5f, process=NabuSlicesTask
                 )
@@ -510,7 +510,7 @@ class NabuSlicesTask(
         configuration_path = None
         res = {}
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
             nabu_nodes = NabuSlicesTask._get_process_nodes(
                 root_node=h5f[entry], process=NabuSlicesTask
             )
@@ -845,7 +845,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             basename, _ = os.path.splitext(scan.master_file)
             basename = os.path.basename(basename)
             try:
-                with HDF5File(scan.master_file, mode="r", swmr=True) as h5f:
+                with HDF5File(scan.master_file, mode="r", swmr=get_swmr_mode()) as h5f:
                     if len(h5f.keys()) > 1:
                         # if there is more than one entry in the file append the entry name to the file basename
                         basename = "_".join((basename, scan.entry.lstrip("/")))

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

@@ -45,7 +45,7 @@ from processview.core.superviseprocess import SuperviseProcess
 from silx.io.utils import h5py_read_dataset
 from tomwer.core.utils.deprecation import deprecated_warning
 
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
@@ -352,7 +352,9 @@ class VolumeRunner(_NabuBaseReconstructor):
             basename = os.path.basename(basename)
             try:
                 # if there is more than one entry in the file append the entry name to the file basename
-                with HDF5File(self.scan.master_file, mode="r", swmr=True) as h5f:
+                with HDF5File(
+                    self.scan.master_file, mode="r", swmr=get_swmr_mode()
+                ) as h5f:
                     if len(h5f.keys()) > 1:
                         basename = "_".join((basename, self.scan.entry.strip("/")))
             except Exception:

tomwer/core/process/task.py

@@ -46,7 +46,7 @@ from ewokscore.task import Task as _EwoksTask
 from ewokscore.taskwithprogress import TaskWithProgress as _EwoksTaskWithProgress
 from silx.io.dictdump import dicttoh5, h5todict
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 from tomwer.core.utils.locker import FileLockerManager
 
 
@@ -376,7 +376,7 @@ class BaseProcessInfo:
         :rtype: list
         """
         # retrieve process to load
-        with HDF5File(process_file, mode="r", swmr=True) as h5f:
+        with HDF5File(process_file, mode="r", swmr=get_swmr_mode()) as h5f:
             if entry is None:
                 if len(h5f.keys()) > 0:
                     root = h5f[list(h5f.keys())[0]]

tomwer/core/process/test/test_axis.py

@@ -34,6 +34,7 @@ import tempfile
 import unittest
 
 import h5py
+from tomoscan.io import get_swmr_mode
 import numpy
 from silx.io.utils import h5py_read_dataset
 
@@ -131,7 +132,7 @@ class TestAxis(unittest.TestCase):
         axis_process.run()
         self.assertTrue(os.path.exists(scan.process_file))
 
-        with h5py.File(scan.process_file, "r", swmr=True) as h5f:
+        with h5py.File(scan.process_file, "r", swmr=get_swmr_mode()) as h5f:
             self.assertTrue("entry" in h5f)
             self.assertTrue("tomwer_process_0" in h5f["entry"])
             group_axis = h5f["entry"]["tomwer_process_0"]
@@ -183,7 +184,7 @@ class TestAxis(unittest.TestCase):
         # make sure center of position has been computed
         self.assertTrue(os.path.exists(scan.process_file))
 
-        with h5py.File(scan.process_file, "r", swmr=True) as h5f:
+        with h5py.File(scan.process_file, "r", swmr=get_swmr_mode()) as h5f:
             self.assertTrue("entry" in h5f)
             self.assertTrue("tomwer_process_0" in h5f["entry"])
             group_axis = h5f["entry"]["tomwer_process_0"]

tomwer/core/process/test/test_data_transfer.py

@@ -42,7 +42,7 @@ from nxtomomill.converter import from_h5_to_nx
 from nxtomomill.io.config.hdf5config import TomoHDF5Config
 from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 from tomoscan.validator import is_valid_for_reconstruction
 
 from tomwer.core.process.control.datalistener import DataListener
@@ -335,9 +335,9 @@ class NXTomoDataTransferBase(unittest.TestCase):
         dst_scan = process.outputs.data
         assert dst_scan.master_file != self.nexus_file_path
         assert is_valid_for_reconstruction(dst_scan, check_values=True)
-        with HDF5File(src_scan.master_file, mode="r", swmr=True) as h5s_src:
+        with HDF5File(src_scan.master_file, mode="r", swmr=get_swmr_mode()) as h5s_src:
             src_dataset = h5s_src["entry0000/detector/data"][...]
-        with HDF5File(dst_scan.master_file, mode="r", swmr=True) as h5s_dst:
+        with HDF5File(dst_scan.master_file, mode="r", swmr=get_swmr_mode()) as h5s_dst:
             dst_dataset = h5s_dst["entry0000/detector/data"][...]
         assert numpy.array_equal(src_dataset, dst_dataset)
 

tomwer/core/scan/blissscan.py

@@ -54,7 +54,7 @@ import logging
 from typing import Optional
 
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File
+from tomoscan.io import HDF5File, get_swmr_mode
 
 _logger = logging.getLogger(__name__)
 
@@ -203,7 +203,7 @@ class BlissScan:
                     return True
             return False
 
-        with HDF5File(file_path, mode="r", swmr=True) as h5s:
+        with HDF5File(file_path, mode="r", swmr=get_swmr_mode()) as h5s:
             if not isinstance(h5s, h5py.Group) or not isinstance(
                 h5s[entry], h5py.Group
             ):
@@ -227,7 +227,7 @@ class BlissScan:
             return tuple()
         else:
             res = []
-            with HDF5File(file_path, mode="r", swmr=True) as h5s:
+            with HDF5File(file_path, mode="r", swmr=get_swmr_mode()) as h5s:
                 for entry in h5s:
                     if BlissScan.is_bliss_valid_entry(file_path=file_path, entry=entry):
                         res.append(entry)