nxtomomill 2.2.0.dev0__tar.gz → 2.2.0.dev2__tar.gz

{nxtomomill-2.2.0.dev0/nxtomomill.egg-info → nxtomomill-2.2.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxtomomill
-Version: 2.2.0.dev0
+Version: 2.2.0.dev2
 Summary: applications and library to convert raw format to NXtomo format
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
 License: 
@@ -58,7 +58,7 @@ Requires-Dist: silx>=2.0
 Requires-Dist: nxtomo>=3.1.0dev1
 Requires-Dist: pint
 Requires-Dist: packaging
-Requires-Dist: tomoscan[full]>=3.0.0dev0
+Requires-Dist: tomoscan>=3.0.0dev0
 Requires-Dist: tomobase>=0.0.0dev0
 Requires-Dist: tqdm
 Requires-Dist: pydantic

{nxtomomill-2.2.0.dev0 → nxtomomill-2.2.0.dev2}/nxtomomill/__main__.py

@@ -84,7 +84,7 @@ class Launcher(_Launcher):
                 replacement=deprecation_info.replacement,
                 since_version=deprecation_info.since,
             )
-        super().execute(argv=argv)
+        return super().execute(argv=argv)
 
     def print_help(self):
         """Print the help to stdout."""

{nxtomomill-2.2.0.dev0 → nxtomomill-2.2.0.dev2}/nxtomomill/app/h52nx.py

@@ -10,12 +10,14 @@ For a complete tutorial you can have a look at: :ref:`Tomoh52nx`
 """
 
 import argparse
+import cProfile
 import logging
+import os
 
 from tqdm import tqdm
 
 from nxtomomill import utils
-from nxtomomill.converter import from_h5_to_nx
+from nxtomomill.converter.hdf5.hdf5converter import _H5ToNxConverter
 from nxtomomill.io.config.confighandler import (
     SETTABLE_PARAMETERS_UNITS,
     TomoHDF5ConfigHandler,
@@ -317,12 +319,49 @@ def main(argv):
         "Sometime relative link cannot be solved (GPFS vs NFS). "
         "In this case you might be forced to use absolute path.",
     )
+    parser.add_argument(
+        "--no-resolve-vds",
+        "--no-resolve-vds-links",
+        "--no_resolve_vds",
+        dest="resolve_vds",
+        action="store_false",
+        default=None,
+        help="Do not resolve external links and virtual datasets (VDS) down to "
+        "their final source when building the output NXtomo. Can speed up the "
+        "conversion for datasets with many nested links, at the cost of the "
+        "output file containing VDS pointing to other VDS instead of direct "
+        "links to the raw data. Defaults to the 'NXTOMOMILL_RESOLVE_VDS' "
+        "environment variable if set, else resolving is enabled.",
+    )
+    parser.add_argument(
+        "--profiling",
+        "--profile",
+        help="Profile the conversion with 'cProfile' and dump the statistics "
+        "to a file (see '--profiling-output-file').",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--profiling-output-file",
+        "--profiling_output_file",
+        default="profiling.out",
+        help="Output file to dump the 'cProfile' statistics to when "
+        "'--profiling' is provided. If this file already exists the "
+        "conversion won't be launched (default: 'profiling.out').",
+    )
     options = parser.parse_args(argv[1:])
     if options.request_input:
         callback_det_sel = _ask_for_selecting_detector
     else:
         callback_det_sel = None
 
+    if options.profiling and os.path.exists(options.profiling_output_file):
+        _logger.error(
+            f"Profiling output file already exists: '{options.profiling_output_file}'. "
+            "Remove it or provide another one with '--profiling-output-file'."
+        )
+        return 1
+
     try:
         configuration_handler = TomoHDF5ConfigHandler(options)
     except Exception:
@@ -335,9 +374,21 @@ def main(argv):
             configuration_handler.configuration.log_level
         )
         with tqdm(desc="h52nx", delay=1, bar_format="{l_bar}{bar}") as progress:
-            from_h5_to_nx(
+            converter = _H5ToNxConverter(
                 configuration=configuration_handler.configuration,
                 progress=progress,
                 input_callback=None,
                 detector_sel_callback=callback_det_sel,
             )
+            if options.profiling:
+                profiler = cProfile.Profile()
+                profiler.enable()
+                try:
+                    converter.convert()
+                finally:
+                    profiler.disable()
+                    profiler.dump_stats(options.profiling_output_file)
+            else:
+                converter.convert()
+            if converter.has_failed_acquisitions:
+                return 1

{nxtomomill-2.2.0.dev0 → nxtomomill-2.2.0.dev2}/nxtomomill/converter/hdf5/acquisition/baseacquisition.py

@@ -12,7 +12,9 @@ import copy
 
 import h5py
 
+import nxtomomill
 from nxtomo.application.nxtomo import NXtomo
+from nxtomo.io import HDF5File
 from nxtomomill.utils.h5pyutils import from_data_url_to_virtual_source
 from nxtomomill.utils.hdf5 import EntryReader
 from nxtomomill.utils.utils import embed_url  # noqa F401
@@ -30,8 +32,9 @@ from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
 
 from nxtomomill.models.h52nx.h52nx import H52nxModel
-from .utils._keys import keys_to_str_tuple
-from .utils._context import read_key, MissingValue
+from nxtomomill.models.h52nx._context import _Key
+from .utils._keys import keys_to_str_tuple, split_keys_by_priority
+from .utils._context import read_key, MissingValue, InvalidValue
 
 _ureg = pint.get_application_registry()
 _logger = logging.getLogger(__name__)
@@ -300,7 +303,14 @@ class BaseAcquisition:
                 file_path=output_file,
                 data_path=data_path,
                 use_abs_path_for_vds=self.configuration.use_abs_path_for_vds,
+                overwrite=self.configuration.overwrite,
             )
+            # record the nxtomomill version used to create this NXtomo as attributes
+            # on the NXtomo entry group itself
+            with HDF5File(output_file, mode="a") as h5f:
+                entry_grp = h5f[data_path]
+                entry_grp.attrs["creator"] = "nxtomomill"
+                entry_grp.attrs["creator_version"] = nxtomomill.__version__
             # check rotation angle
             if nx_tomo.sample.rotation_angle is not None:
                 unique_angles = numpy.unique(
@@ -408,6 +418,12 @@ class BaseAcquisition:
                     except MissingValue:
                         # skip values containing '*DIS*'
                         continue
+                    except InvalidValue:
+                        # dataset reports an 'ERR' value: skip it and try the next key
+                        _logger.warning(
+                            f"{info_retrieve} reports an 'ERR' value for {node.name} - {key}. This key will be skipped."
+                        )
+                        continue
                     except KeyError as e:
                         _logger.info(
                             f"Cannot solve key {key}. Most likely one dataset is not there. Error is {e}"
@@ -613,6 +629,55 @@ class BaseAcquisition:
 
             return None
 
+    @staticmethod
+    def _get_values_from_nodes(
+        nodes: tuple[h5py.Group | None, ...],
+        n_frame: int | None,
+        keys: tuple[_Key, ...],
+        info_retrieve: str,
+        expected_unit: pint.Unit,
+    ) -> pint.Quantity | None:
+        """
+        Look for the values of 'keys' in 'nodes'.
+
+        Keys resolved from the bliss-tomo 'tomoconfig' are looked at first (on all nodes, arrays
+        first then scalars). The other keys (default keys) are only used as a fallback if none of
+        the 'tomoconfig' keys could be found.
+
+        :return: values as a pint.Quantity or None if no key could be found.
+        """
+        tomo_config_keys, fallback_keys = split_keys_by_priority(keys)
+
+        def look_for_keys(keys_to_check: tuple[str, ...]) -> pint.Quantity | None:
+            for node in nodes:
+                if node is None:
+                    continue
+                try:
+                    values, unit = BaseAcquisition._get_node_values_for_frame_array(
+                        node=node,
+                        n_frame=n_frame,
+                        keys=keys_to_check,
+                        info_retrieve=info_retrieve,
+                        expected_unit=expected_unit,
+                    )
+                except (ValueError, KeyError):
+                    pass
+                else:
+                    return values * unit
+            return None
+
+        if len(tomo_config_keys) > 0:
+            result = look_for_keys(tomo_config_keys)
+            if result is not None:
+                return result
+            _logger.warning(
+                f"Unable to find {info_retrieve} from the bliss-tomo 'tomoconfig' datasets {tomo_config_keys}. "
+                f"Will look at the fallback datasets {fallback_keys}."
+            )
+        if len(fallback_keys) > 0:
+            return look_for_keys(fallback_keys)
+        return None
+
     def _get_rotation_angle(self, root_node: h5py.Group, n_frame: int) -> pint.Quantity:
         """
         return the list of rotation angle for each frame.
@@ -623,23 +688,19 @@ class BaseAcquisition:
         if not isinstance(root_node, h5py.Group):
             raise TypeError("root_node is expected to be a h5py.Group")
 
-        for grp in (
-            self._get_positioners_node(root_node),
-            root_node,
-            self._get_measurement_node(root_node),
-        ):
-            try:
-                angles, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.rotation_angle_keys),
-                    info_retrieve="rotation angle",
-                    expected_unit=_ureg.degree,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return angles * unit
+        angles = self._get_values_from_nodes(
+            nodes=(
+                self._get_positioners_node(root_node),
+                root_node,
+                self._get_measurement_node(root_node),
+            ),
+            n_frame=n_frame,
+            keys=self.configuration.rotation_angle_keys,
+            info_retrieve="rotation angle",
+            expected_unit=_ureg.degree,
+        )
+        if angles is not None:
+            return angles
 
         mess = f"Unable to find rotation angle for {root_node.name}"
         if self.raise_error_if_issue:
@@ -651,19 +712,15 @@ class BaseAcquisition:
 
     def _get_sample_x(self, root_node, n_frame) -> pint.Quantity:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                x_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.sample_x_keys),
-                    info_retrieve="sample x translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return x_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.sample_x_keys,
+            info_retrieve="sample x translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find sample x for {root_node.name}"
         if self.raise_error_if_issue:
@@ -675,19 +732,15 @@ class BaseAcquisition:
 
     def _get_sample_y(self, root_node, n_frame) -> pint.Quantity:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                y_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.sample_y_keys),
-                    info_retrieve="sample y translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return y_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.sample_y_keys,
+            info_retrieve="sample y translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find sample y for {root_node.name}"
         if self.raise_error_if_issue:
@@ -697,21 +750,17 @@ class BaseAcquisition:
             _logger.warning(mess)
             return ([0] * n_frame) * _ureg.meter
 
-    def _get_translation_x(self, root_node, n_frame) -> pint.quantity:
+    def _get_translation_x(self, root_node, n_frame) -> pint.Quantity | None:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                x_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.translation_x_keys),
-                    info_retrieve="x base translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return x_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.translation_x_keys,
+            info_retrieve="x base translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find translation x for {root_node.name}"
         if self.raise_error_if_issue:
@@ -721,21 +770,17 @@ class BaseAcquisition:
             _logger.warning(mess)
             return ([0] * n_frame) * _ureg.meter
 
-    def _get_translation_y(self, root_node, n_frame) -> pint.quantity:
+    def _get_translation_y(self, root_node, n_frame) -> pint.Quantity | None:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                y_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.translation_y_keys),
-                    info_retrieve="y base translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return y_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.translation_y_keys,
+            info_retrieve="y base translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find translation y for {root_node.name}"
         if self.raise_error_if_issue:
@@ -748,20 +793,16 @@ class BaseAcquisition:
     @staticmethod
     def get_translation_z_frm(
         root_node, n_frame: int, configuration: H52nxModel
-    ) -> pint.Quantity:
-        for grp in BaseAcquisition._get_positioners_node(root_node), root_node:
-            try:
-                z_tr, unit = BaseAcquisition._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(configuration.translation_z_keys),
-                    info_retrieve="z translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return z_tr * unit
+    ) -> pint.Quantity | None:
+        translation = BaseAcquisition._get_values_from_nodes(
+            nodes=(BaseAcquisition._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=configuration.translation_z_keys,
+            info_retrieve="z translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find translation z on node {root_node.name}"
         if configuration.raises_error:
@@ -771,7 +812,7 @@ class BaseAcquisition:
             _logger.warning(mess)
             return ([0] * n_frame) * _ureg.meter
 
-    def _get_translation_z(self, root_node, n_frame) -> pint.Quantity:
+    def _get_translation_z(self, root_node, n_frame) -> pint.Quantity | None:
         """return the list of translation z for each frame"""
         return self.get_translation_z_frm(
             root_node=root_node,
@@ -804,7 +845,7 @@ class BaseAcquisition:
         else:
             mess += "default value will be set. (0)"
             _logger.warning(mess)
-            return 0 * _ureg.second
+            return numpy.zeros(n_frame) * _ureg.second
 
     def get_axis_scale_types(self):
         """

{nxtomomill-2.2.0.dev0 → nxtomomill-2.2.0.dev2}/nxtomomill/converter/hdf5/acquisition/standardacquisition.py

@@ -65,6 +65,10 @@ from .utils._keys import keys_to_str_tuple
 _ureg = pint.get_application_registry()
 _logger = logging.getLogger(__name__)
 
+_MAX_VDS_SOURCES_TO_RESOLVE = 100
+"""If a camera dataset virtual source relies on that many (or more) distinct files, skip
+resolving external links / virtual dataset sources for it."""
+
 
 __all__ = ["StandardAcquisition"]
 
@@ -346,20 +350,35 @@ class StandardAcquisition(BaseAcquisition):
         image_key_control = frame_type.to_image_key_control()
         self._image_key_control.extend([image_key_control.value] * n_frame)
 
-        try:
-            solved_camera_dataset_urls = resolve_link(
-                dataset_url=camera_dataset_url,
-                dataset=data_dataset,
-                dataset_link=data_dataset_link,
-                open_mode_for_reading=self.configuration.open_mode_for_reading,
-            )
-        except OSError as e:
-            # This can happen if one fine cannot be found. In test for example where we are only using the master file
-            # and low level bliss / tango .h5 files are not existing
+        n_vds_files = (
+            len({vs_info.file_name for vs_info in data_dataset.virtual_sources()})
+            if data_dataset.is_virtual
+            else 0
+        )
+        if n_vds_files >= _MAX_VDS_SOURCES_TO_RESOLVE:
             _logger.warning(
-                "Fail to solve camera dataset links and VDS. Error is %s", e
+                f"{camera_dataset_url.path()} relies on {n_vds_files} files "
+                f"(>= {_MAX_VDS_SOURCES_TO_RESOLVE}). Skip external link / VDS "
+                "resolution to avoid opening too many files."
             )
             solved_camera_dataset_urls = (camera_dataset_url,)
+        elif self.configuration.resolve_vds:
+            try:
+                solved_camera_dataset_urls = resolve_link(
+                    dataset_url=camera_dataset_url,
+                    dataset=data_dataset,
+                    dataset_link=data_dataset_link,
+                    open_mode_for_reading=self.configuration.open_mode_for_reading,
+                )
+            except OSError as e:
+                # This can happen if one fine cannot be found. In test for example where we are only using the master file
+                # and low level bliss / tango .h5 files are not existing
+                _logger.warning(
+                    "Fail to solve camera dataset links and VDS. Error is %s", e
+                )
+                solved_camera_dataset_urls = (camera_dataset_url,)
+        else:
+            solved_camera_dataset_urls = (camera_dataset_url,)
 
         n_total_frame_solved = 0
         for solved_camera_dataset_url in solved_camera_dataset_urls:

nxtomomill-2.2.0.dev2/nxtomomill/converter/hdf5/acquisition/tests/test_acquisition.py

@@ -0,0 +1,188 @@
+# coding: utf-8
+
+import os
+import tempfile
+
+import logging
+
+import h5py
+import numpy
+import pytest
+from silx.io.url import DataUrl
+
+from nxtomo.io import HDF5File
+from nxtomomill.converter.hdf5.acquisition.baseacquisition import (
+    BaseAcquisition,
+    get_dataset_name_from_motor,
+)
+from nxtomomill.io.config import TomoHDF5Config
+from nxtomomill.models.h52nx._context import _Key
+from nxtomomill.tests.datasets import GitlabDataset
+from nxtomomill import converter
+from nxtomo.application.nxtomo import NXtomo
+from nxtomo.nxobject.nxtransformations import get_lr_flip, get_ud_flip
+
+
+def test_BaseAquisition():
+    """simple test of the BaseAcquisition class"""
+
+    with tempfile.TemporaryDirectory() as folder:
+        file_path = os.path.join(folder, "test.h5")
+        with HDF5File(file_path, mode="w") as h5f:
+            h5f["/data/toto/dataset"] = 12
+
+        url = DataUrl(file_path=file_path, data_path="/data/toto", scheme="silx")
+        std_acq = BaseAcquisition(
+            root_url=url,
+            configuration=TomoHDF5Config(),
+            detector_sel_callback=None,
+            start_index=0,
+        )
+        with std_acq.read_entry() as entry:
+            assert "dataset" in entry
+
+
+def test_get_dataset_name_from_motor():
+    """test get_dataset_name_from_motor function"""
+    set_1 = ["rotation", "test1", "alias"]
+    assert get_dataset_name_from_motor(set_1, "rotation") == "test1"
+    assert get_dataset_name_from_motor(set_1, "my motor") is None
+
+    set_2 = ["rotation", "test1", "alias", "x translation", "m2", "test1"]
+    assert get_dataset_name_from_motor(set_2, "rotation") == "test1"
+    assert get_dataset_name_from_motor(set_2, "x translation") == "m2"
+
+    set_3 = ["rotation"]
+    with pytest.raises(ValueError):
+        get_dataset_name_from_motor(set_3, "rotation")
+
+
+@pytest.mark.parametrize("raises_error", (True, False))
+def test_translation_with_err_value(tmp_path, raises_error):
+    """
+    Test that translation datasets reporting an 'ERR' value are skipped:
+    the next valid key is used and, if none is valid, it behaves as if the
+    translation was not found (raises or default to 0).
+    """
+    file_path = os.path.join(tmp_path, "test.h5")
+    with HDF5File(file_path, mode="w") as h5f:
+        h5f["/entry/instrument/positioners/tx"] = "ERR"
+        h5f["/entry/instrument/positioners/ty"] = "ERR"
+        h5f["/entry/instrument/positioners/tz"] = "ERR"
+        h5f["/entry/instrument/positioners/sz"] = 2.0
+        h5f["/entry/instrument/positioners/sz"].attrs["units"] = "mm"
+
+    config = TomoHDF5Config()
+    config.raises_error = raises_error
+    config.translation_x_keys = ("tx",)
+    config.translation_y_keys = ("ty",)
+    config.translation_z_keys = ("tz", "sz")
+
+    url = DataUrl(file_path=file_path, data_path="/entry", scheme="silx")
+    std_acq = BaseAcquisition(
+        root_url=url,
+        configuration=config,
+        detector_sel_callback=None,
+        start_index=0,
+    )
+    with h5py.File(file_path, mode="r") as h5f:
+        root_node = h5f["/entry"]
+        # 'tz' reports 'ERR': fall back to 'sz'
+        z_tr = std_acq._get_translation_z(root_node=root_node, n_frame=1)
+        assert z_tr.to("mm").magnitude.tolist() == [2.0]
+
+        # no valid key: same behavior as a missing translation
+        if raises_error:
+            with pytest.raises(ValueError):
+                std_acq._get_translation_x(root_node=root_node, n_frame=1)
+            with pytest.raises(ValueError):
+                std_acq._get_translation_y(root_node=root_node, n_frame=1)
+        else:
+            x_tr = std_acq._get_translation_x(root_node=root_node, n_frame=1)
+            assert x_tr.magnitude.tolist() == [0]
+            y_tr = std_acq._get_translation_y(root_node=root_node, n_frame=1)
+            assert y_tr.magnitude.tolist() == [0]
+
+
+def test_tomo_config_keys_priority(tmp_path, caplog):
+    """
+    Test that keys resolved from the bliss-tomo 'tomoconfig' are looked at first (array then scalar)
+    and that the default keys are only used as fallback.
+    """
+    n_frame = 3
+    file_path = os.path.join(tmp_path, "test.h5")
+    with HDF5File(file_path, mode="w") as h5f:
+        # tomoconfig motor is static (scalar) while a default key records an array
+        h5f["/entry/instrument/positioners/real_sx"] = 1.0
+        h5f["/entry/instrument/positioners/samx"] = numpy.array([5.0, 6.0, 7.0])
+        # tomoconfig motor only exists in root_node while a default key exists in positioners
+        h5f["/entry/real_sy"] = numpy.array([1.0, 2.0, 3.0])
+        h5f["/entry/instrument/positioners/samy"] = numpy.array([5.0, 6.0, 7.0])
+        # tomoconfig motor doesn't exist: fallback on the default key
+        h5f["/entry/instrument/positioners/sz"] = numpy.array([5.0, 6.0, 7.0])
+
+    config = TomoHDF5Config()
+    config.sample_x_keys = (
+        _Key(dataset="real_sx", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="samx", contexts=set()),
+    )
+    config.sample_y_keys = (
+        _Key(dataset="real_sy", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="samy", contexts=set()),
+    )
+    config.translation_z_keys = (
+        _Key(dataset="real_tz", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="sz", contexts=set()),
+    )
+
+    url = DataUrl(file_path=file_path, data_path="/entry", scheme="silx")
+    std_acq = BaseAcquisition(
+        root_url=url,
+        configuration=config,
+        detector_sel_callback=None,
+        start_index=0,
+    )
+    with h5py.File(file_path, mode="r") as h5f:
+        root_node = h5f["/entry"]
+        sample_x = std_acq._get_sample_x(root_node=root_node, n_frame=n_frame)
+        assert sample_x.magnitude.tolist() == [1.0] * n_frame
+        sample_y = std_acq._get_sample_y(root_node=root_node, n_frame=n_frame)
+        assert sample_y.magnitude.tolist() == [1.0, 2.0, 3.0]
+        with caplog.at_level(logging.WARNING):
+            z_tr = std_acq._get_translation_z(root_node=root_node, n_frame=n_frame)
+        assert z_tr.magnitude.tolist() == [5.0, 6.0, 7.0]
+        assert "Will look at the fallback datasets" in caplog.text
+
+
+def test_frame_flips(tmp_path, monkeypatch):
+    # make sure the result is obtained by using the "instrument/{active_config_tomo_detector}/data_axes" path.
+    monkeypatch.setattr(
+        "nxtomomill.converter.hdf5.acquisition.baseacquisition.BaseAcquisition._FRAME_FLIP_PATHS",
+        ("instrument/{active_config_tomo_detector}/data_axes",),
+    )
+
+    scan_dir = GitlabDataset.get_dataset("h5_datasets")
+    if scan_dir is None:
+        raise FileNotFoundError("Unable to download h5_datasets not found")
+
+    configuration = TomoHDF5Config()
+    configuration.input_file = os.path.join(
+        scan_dir, "frame_flip/quartz_nscope_pct_basler.h5"
+    )
+    configuration.output_file = os.path.join(tmp_path, "quartz.nx")
+    configuration.single_file = True
+
+    result = converter.from_h5_to_nx(configuration=configuration)
+    assert os.path.exists(configuration.output_file)
+    assert len(result) == 1
+
+    nxtomo = NXtomo().load(*result[0])
+
+    lr_flips = get_lr_flip(nxtomo.instrument.detector.transformations)
+    assert len(lr_flips) == 1
+    lr_flip = lr_flips[0]
+    assert lr_flip is not None and lr_flip.transformation_values == 0
+    ud_flips = get_ud_flip(nxtomo.instrument.detector.transformations)
+    assert len(ud_flips) == 1
+    ud_flip = ud_flips[0]
+    assert ud_flip is not None and ud_flip.transformation_values == 0