nabu 2024.1.0rc1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

nabu/estimation/tests/test_cor.py

@@ -439,25 +439,34 @@ class TestCorOctaveAccurate:
         assert np.isclose(self.cor_pos_abs_blc12781, cor_position, atol=self.abs_tol), message
 
 
-@pytest.mark.usefixtures("bootstrap_cor_fourier")
+@pytest.mark.usefixtures("bootstrap_cor_fourier", "bootstrap_cor_win")
 class TestCorFourierAngle:
-    def test_proj_center_axis_cen(self):
-        detector_width = self.sinos.shape[1]
-        nb_angles = len(self.angles)
-        img_1 = self.sinos[: nb_angles // 2, :]
-        img_2 = self.sinos[nb_angles // 2 :]
-        if img_2.shape[0] != img_1.shape[0]:  # handle odd number of projections.
-            img_2 = img_2[:-1, :]
+    def test_sino_right_axis_with_near_pos(self):
+        sino1 = self.data_ha_sino[0, :, :]
+        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
+        start_angle = np.pi / 4
+        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
 
-        cor_options = {"near_pos": self.estimated_cor_from_motor, "refine": True}
+        cor_options = {"side": 740, "refine": True}
 
         CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
-        cor_position = CoR_calc.find_shift(
-            img_1,
-            np.fliplr(img_2),
-            self.angles,
-        )
-        cor_position = cor_position + detector_width / 2
-        assert np.isscalar(cor_position), f"cor_position expected to be a scalar, {type(cor_position)} returned"
-        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.true_cor
-        assert np.isclose(self.true_cor, cor_position, atol=self.abs_tol), message
+        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
+        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
+
+        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
+        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message
+
+    def test_sino_right_axis_with_ignore(self):
+        sino1 = self.data_ha_sino[0, :, :]
+        sino2 = np.fliplr(self.data_ha_sino[1, :, :])
+        start_angle = np.pi / 4
+        angles = np.linspace(start_angle, start_angle + 2 * np.pi, 2 * sino1.shape[0])
+
+        cor_options = {"side": "ignore", "refine": True}
+
+        CoR_calc = CenterOfRotationFourierAngles(cor_options=cor_options)
+        cor_position = CoR_calc.find_shift(sino1, sino2, angles, side="right")
+        assert np.isscalar(cor_position), f"cor_position expected to be a scale, {type(cor_position)} returned"
+
+        message = "Computed CoR %f " % cor_position + " and expected CoR %f do not coincide" % self.cor_ha_sn_pix
+        assert np.isclose(self.cor_ha_sn_pix, cor_position, atol=self.abs_tol * 3), message

nabu/io/writer.py

@@ -795,15 +795,15 @@ class HSTVolWriter(Writer):
         super().__init__(fname)
         self.append = append
         self._vol_writer = RawVolume(fname, overwrite=True, append=append)
+        self._hst_metadata = kwargs.get("hst_metadata", {})
 
-    @staticmethod
-    def generate_metadata(data, **kwargs):
+    def generate_metadata(self, data, **kwargs):
         n_z, n_y, n_x = data.shape
         metadata = {
             "NUM_X": n_x,
             "NUM_Y": n_y,
             "NUM_Z": n_z,
-            "voxelSize": kwargs.get("voxelSize", 40.0),
+            "voxelSize": 40.0,
             "BYTEORDER": "LOWBYTEFIRST",
             "ValMin": kwargs.get("ValMin", 0.0),
             "ValMax": kwargs.get("ValMin", 1.0),
@@ -812,6 +812,8 @@ class HSTVolWriter(Writer):
             "S1": 0.0,
             "S2": 0.0,
         }
+        for key, default_val in metadata.items():
+            metadata[key] = kwargs.get(key, None) or self._hst_metadata.get(key, None) or default_val
         return metadata
 
     @staticmethod

nabu/pipeline/estimators.py

@@ -124,42 +124,72 @@ class CORFinderBase:
         if isinstance(cor_options, dict):
             self.cor_options.update(cor_options)
 
-        # Priority is given to the cor estimate given by user in conf file rather than motor (in NX).
-        # NB : this applies only when "rotation_axis_position" is set to a string i.e. an algo to estimate the cor,
-        # Then, the "near_pos" value set in the cor_options is used as a first guess.
+        # tomotools internal meeting 07 feb 2024: Merge of options 'near_pos' and 'side'.
+        # See [minutes](https://gitlab.esrf.fr/tomotools/minutes/-/blob/master/minutes-20240207.md?ref_type=heads)
+
         detector_width = self.dataset_info.radio_dims[0]
-        if "near_pos" not in self.cor_options.keys():
-            self.cor_options.update({"near_pos": "ignore"})
+        default_lookup_side = "right" if self.dataset_info.is_halftomo else "center"
+        near_init = self.cor_options.get("side", None)
+
+        if near_init is None:
+            near_init = default_lookup_side
 
-        if self.cor_options["near_pos"] == "from_file":
+        if near_init == "from_file":
             try:
                 near_pos = self.dataset_info.dataset_scanner.estimated_cor_frm_motor  # relative pos in pixels
                 if isinstance(near_pos, Real):
+                    # near_pos += detector_width // 2  # Field in NX is relative.
                     self.cor_options.update({"near_pos": int(near_pos)})
                 else:
-                    self.cor_options.update({"near_pos": "ignore"})
+                    near_init = default_lookup_side
             except:
-                self.cor_options.update({"near_pos": "ignore"})
                 self.logger.warning(
                     "COR estimation from motor position absent from NX file. Global search is performed."
                 )
-        if isinstance(self.cor_options["near_pos"], Real):
-            # estimated_cor_frm_motor value is supposed to be relative. Since the config documentation expects the "near_pos" options
-            # to be given as an absolute COR estimate, a conversion is needed.
-            self.cor_options["near_pos"] += detector_width // 2  # converted in absolute nb of pixels.
-            if self.cor_options["near_pos"] > detector_width:
+                near_init = default_lookup_side
+        elif isinstance(near_init, Real):
+            self.cor_options.update({"near_pos": near_init})
+            near_init = "near"  # ???
+        elif near_init == "near":  # Legacy
+            if not isinstance(self.cor_options["near_pos"], Real):
+                self.logger.warning("Side option set to 'near' but no 'near_pos' option set.")
+                self.logger.warning("Set side to right if HA, center otherwise.")
+                near_init = default_lookup_side
+        elif near_init in ("left", "right", "center", "all"):
+            pass
+        else:
+            self.logger.warning(
+                f"COR option 'side' received {near_init} and should be either 'from_file' (default), 'left', 'right', 'center', 'near' or a number."
+            )
+
+        if isinstance(self.cor_options.get("near_pos", None), Real):
+            # Check validity of near_pos
+            if np.abs(self.cor_options["near_pos"]) > detector_width / 2:
                 self.logger.warning(
-                    f"Absolute COR passed is greater than the size of the detector. Did you enter a relative COR position?"
+                    f"Relative COR passed is greater than half the size of the detector. Did you enter a absolute COR position?"
                 )
                 self.logger.warning("Instead, the center of the detector is used.")
+                self.cor_options["near_pos"] = 0
 
-            # Set side
-            if self.cor_options["near_pos"] < detector_width // 2:
+            # Set side from near_pos if passed.
+            if self.cor_options["near_pos"] < 0.0:
                 self.cor_options.update({"side": "left"})
+                near_init = "left"
             else:
                 self.cor_options.update({"side": "right"})
-        if not (isinstance(self.cor_options["near_pos"], Real) or self.cor_options["near_pos"] == "ignore"):
-            self.cor_options.update({"near_pos": "ignore"})
+                near_init = "right"
+
+        self.cor_options.update({"side": near_init})
+
+        # At this stage : side is set to one of left, right, center near.
+        # and near_pos to a numeric value.
+
+        # if isinstance(self.cor_options["near_pos"], Real):
+        #    # estimated_cor_frm_motor value is supposed to be relative. Since the config documentation expects the "near_pos" options
+        #    # to be given as an absolute COR estimate, a conversion is needed.
+        #    self.cor_options["near_pos"] += detector_width // 2  # converted in absolute nb of pixels.
+        # if not (isinstance(self.cor_options["near_pos"], Real) or self.cor_options["near_pos"] == "ignore"):
+        #    self.cor_options.update({"near_pos": "ignore"})
 
         # At this stage, cor_options["near_pos"] is either
         #   - 'ignore':
@@ -168,11 +198,11 @@ class CORFinderBase:
         cor_class = self.search_methods[method]["class"]
         self.cor_finder = cor_class(logger=self.logger, cor_options=self.cor_options)
 
-        default_lookup_side = "right" if self.dataset_info.is_halftomo else "center"
         lookup_side = self.cor_options.get("side", default_lookup_side)
+
+        # OctaveAccurate
         if cor_class == CenterOfRotationOctaveAccurate:
             lookup_side = "center"
-
         angles = self.dataset_info.rotation_angles
 
         self.cor_exec_args = []
@@ -185,6 +215,7 @@ class CORFinderBase:
                 self.cor_exec_args[0] = lookup_side
             elif cor_class in (CenterOfRotationFourierAngles,):
                 self.cor_exec_args[0] = angles
+                self.cor_exec_args[1] = lookup_side
         #
         self.cor_exec_kwargs = update_func_kwargs(self.cor_finder.find_shift, self.cor_options)
 
@@ -297,7 +328,7 @@ class SinoCORFinder(CORFinderBase):
         "sino-growing-window": {
             "class": CenterOfRotationGrowingWindow,
         },
-        "fourier-angles": {"class": CenterOfRotationFourierAngles, "default_args": [None]},
+        "fourier-angles": {"class": CenterOfRotationFourierAngles, "default_args": [None, "center"]},
     }
 
     def __init__(
@@ -413,7 +444,7 @@ class SinoCORFinder(CORFinderBase):
 SinoCOREstimator = SinoCORFinder
 
 
-class CompositeCORFinder:
+class CompositeCORFinder(CORFinderBase):
     """
     Class and method to prepare sinogram and calculate COR
     The pseudo sinogram is built with shrinked radios taken every theta_interval degres
@@ -430,6 +461,11 @@ class CompositeCORFinder:
            by several order of magnitude without modifing the final result
     """
 
+    search_methods = {
+        "composite-coarse-to-fine": {
+            "class": CenterOfRotation,  # Hack. Not used. Everything is done in the find_cor() func.
+        }
+    }
     _default_cor_options = {"low_pass": 0.4, "high_pass": 10, "side": "center", "near_pos": 0, "near_width": 20}
 
     def __init__(
@@ -444,6 +480,9 @@ class CompositeCORFinder:
         logger=None,
         norm_order=1,
     ):
+        super().__init__(
+            "composite-coarse-to-fine", dataset_info, do_flatfield=True, cor_options=cor_options, logger=logger
+        )
         if norm_order not in [1, 2]:
             raise ValueError(
                 f""" the norm order (nom_order parameter) must be either 1 or 2. You passed {norm_order}
@@ -455,6 +494,12 @@ class CompositeCORFinder:
         self.dataset_info = dataset_info
         self.logger = LoggerOrPrint(logger)
 
+        self.sx, self.sy = self.dataset_info.radio_dims
+
+        default_cor_options = self._default_cor_options.copy()
+        default_cor_options.update(self.cor_options)
+        self.cor_options = default_cor_options
+
         # the algorithm can work for angular ranges larger than 1.2*pi
         # up to an arbitrarily number of turns as it is the case in helical scans
         self.spike_threshold = spike_threshold
@@ -465,8 +510,6 @@ class CompositeCORFinder:
         self.angle_min = self.unwrapped_rotation_angles.min()
         self.angle_max = self.unwrapped_rotation_angles.max()
 
-        self.sx, self.sy = self.dataset_info.radio_dims
-
         if (self.angle_max - self.angle_min) < 1.2 * np.pi:
             useful_span = None
             raise ValueError(
@@ -481,7 +524,7 @@ class CompositeCORFinder:
             if useful_span < np.pi:
                 theta_interval = theta_interval * useful_span / np.pi
 
-        self._get_cor_options(cor_options)
+        # self._get_cor_options(cor_options)
 
         self.take_log = take_log
         self.ovs = oversampling
@@ -541,7 +584,6 @@ class CompositeCORFinder:
         # initialize sinograms and radios arrays
         self.sino = np.zeros([2 * self.nprobed * n_subsampling_y, (self.sx - 1) * self.ovs + 1], "f")
         self._loaded = False
-
         self.high_pass = self.cor_options["high_pass"]
         img_filter = fourier_filters.get_bandpass_filter(
             (self.sino.shape[0] // 2, self.sino.shape[1]),
@@ -742,10 +784,10 @@ class CompositeCORFinder:
             if min_error == error:
                 best_overlap = z
                 best_error = min_error
-            self.logger.debug(
-                "testing an overlap of %.2f pixels, actual best overlap is %.2f pixels over %d\r"
-                % (z / self.ovs, best_overlap / self.ovs, ovsd_sx / self.ovs),
-            )
+            # self.logger.debug(
+            #     "testing an overlap of %.2f pixels, actual best overlap is %.2f pixels over %d\r"
+            #     % (z / self.ovs, best_overlap / self.ovs, ovsd_sx / self.ovs),
+            # )
 
         offset = (ovsd_sx - best_overlap) / self.ovs / 2
         cor_abs = (self.sx - 1) / 2 + offset

nabu/pipeline/fullfield/chunked.py

@@ -611,6 +611,7 @@ class ChunkedPipeline:
             "float_clip_values": options["float_clip_values"],
             "tiff_single_file": options.get("tiff_single_file", False),
             "single_output_file_initialized": getattr(self.process_config, "single_output_file_initialized", False),
+            "raw_vol_metadata": {"voxelSize": self.dataset_info.pixel_size},  # legacy...
         }
         writer_extra_options.update(extra_options)
         self.writer = WriterManager(
@@ -751,8 +752,11 @@ class ChunkedPipeline:
 
     @pipeline_step("writer", "Saving data")
     def _write_data(self, data=None):
-        if data is None:
+        if data is None and self.reconstruction is not None:
             data = self.recs
+        if data is None:
+            self.logger.info("No data to write")
+            return
         self.writer.write_data(data)
         self.logger.info("Wrote %s" % self.writer.fname)
         self._write_histogram()

nabu/pipeline/fullfield/computations.py

@@ -230,7 +230,7 @@ def estimate_max_chunk_size(
             break
         if delta_a is not None and delta_a > process_config.n_angles():
             break
-        if delta_z is not None and delta_z > process_config.radio_shape()[1]:
+        if delta_z is not None and delta_z > process_config.radio_shape()[0]:
             break
         last_valid_delta_a, last_valid_delta_z = delta_a, delta_z
         if pipeline_part == "radios":
@@ -242,7 +242,7 @@ def estimate_max_chunk_size(
 
     if pipeline_part != "radios":
         if mem / 1e9 < available_memory_GB:
-            res = min(delta_z, process_config.radio_shape()[1])
+            res = min(delta_z, process_config.radio_shape()[0])
         else:
             res = last_valid_delta_z
     else:

nabu/pipeline/fullfield/nabu_config.py

@@ -77,7 +77,7 @@ nabu_config = {
             "type": "advanced",
         },
         "normalize_srcurrent": {
-            "default": "0",
+            "default": "1",
             "help": "Whether to normalize frames with Synchrotron Current. This can correct the effect of a beam refill not taken into account by flats.",
             "validator": boolean_validator,
             "type": "advanced",
@@ -259,13 +259,13 @@ nabu_config = {
         },
         "rotation_axis_position": {
             "default": "sliding-window",
-            "help": "Rotation axis position. It can be a number or the name of an estimation method (empty value means the middle of the detector).\nThe following methods are available to find automatically the Center of Rotation (CoR):\n - centered : a fast and simple auto-CoR method. It only works when the CoR is not far from the middle of the detector. It does not work for half-tomography.\n - global : a slow but robust auto-CoR.\n - sliding-window : semi-automatically find the CoR with a sliding window. You have to specify on which side the CoR is (left, center, right). Please see the 'cor_options' parameter.\n - growing-window : automatically find the CoR with a sliding-and-growing window. You can tune the option with the parameter 'cor_options'.\n - sino-coarse-to-fine: Estimate CoR from sinogram. Only works for 360 degrees scans.\n - composite-coarse-to-fine: Estimate CoR from composite multi-angle images. Only works for 360 degrees scans.",
+            "help": "Rotation axis position. It can be a number or the name of an estimation method (empty value means the middle of the detector).\nThe following methods are available to find automatically the Center of Rotation (CoR):\n - centered : a fast and simple auto-CoR method. It only works when the CoR is not far from the middle of the detector. It does not work for half-tomography.\n - global : a slow but robust auto-CoR.\n - sliding-window : semi-automatically find the CoR with a sliding window. You have to specify on which side the CoR is (left, center, right). Please see the 'cor_options' parameter.\n - growing-window : automatically find the CoR with a sliding-and-growing window. You can tune the option with the parameter 'cor_options'.\n - sino-coarse-to-fine: Estimate CoR from sinogram. Only works for 360 degrees scans.\n - composite-coarse-to-fine: Estimate CoR from composite multi-angle images. Only works for 360 degrees scans.\n - fourier-angles: Estimate CoR from sino based on an angular correlation analysis. You can tune the option with the parameter 'cor_options'.\n - octave-accurate: Legacy from octave accurate COR estimation algorithm. It first estimates the COR with global fourier-based correlation, then refines this estimation with local correlation based on the variance of the difference patches. You can tune the option with the parameter 'cor_options'.",
             "validator": cor_validator,
             "type": "required",
         },
         "cor_options": {
-            "default": "",
-            "help": "Options for methods finding automatically the rotation axis position. The parameters are separated by commas and passed as 'name=value'.\nFor example: low_pass=1; high_pass=20; side='near'. Mind the semicolon separator (;) and the '' for string values that are strings.\nIf 'near_pos' is set, it is expected to be an absolute CoR position in pixels.\nIt will override the CoR position taken from motor position.",
+            "default": "side='from_file'",
+            "help": "Options for methods finding automatically the rotation axis position. The parameters are separated by commas and passed as 'name=value'.\nFor example: low_pass=1; high_pass=20. Mind the semicolon separator (;) and the '' for string values that are strings.\nIf 'side' is set, it is expected to be either:\n - 'from_file' (to pick the value in the NX file.)\n - or an relative CoR position in pixels (if so, it overrides the value in the NX file), \n or any of 'left', 'center', 'right', 'all', 'near'.\n The default value for 'side' is 'from_file'.",
             "validator": generic_options_validator,
             "type": "advanced",
         },

nabu/pipeline/helical/gridded_accumulator.py

@@ -105,7 +105,14 @@ class GriddedAccumulator:
         self.double_flat = double_flat
 
     def extract_preprocess_with_flats(
-        self, subchunk_slice, subchunk_file_indexes, chunk_info, subr_start_end, dtasrc_start_end, data_raw
+        self,
+        subchunk_slice,
+        subchunk_file_indexes,
+        chunk_info,
+        subr_start_end,
+        dtasrc_start_end,
+        data_raw,
+        radios_angular_range_slicing,
     ):
         """
         This functions is meant to be called providing, each time, a subset of the data
@@ -149,6 +156,13 @@ class GriddedAccumulator:
             They indicated, vertically, the detector portion the data_raw data correspond to
         data_raw: np.array 3D
             the data which correspond to a limited detector stripe and a limited angular subset
+        radios_angular_range_slicing:
+            my_subsampled_indexes  is important in order to compare the
+            radios positions with respect to the flat position, and these position
+            are given as the sequential acquisition number which counts everything ( flats, darks, radios )
+            Insteqd, in order to access array which spans only the radios, we need to have an idea of where we are.
+            this is provided by radios_angular_range_slicing which addresses the radios domain
+
         """
 
         # the object below is going to containing some auxiliary variable that are use to reframe the data.
@@ -170,7 +184,9 @@ class GriddedAccumulator:
         )
 
         # extraction of the data
-        self._extract_preprocess_with_flats(data_raw, reframing_infos, chunk_info, radios_subset)
+        self._extract_preprocess_with_flats(
+            data_raw, reframing_infos, chunk_info, radios_subset, radios_angular_range_slicing
+        )
 
         if self.weights is not None:
             # ... and, if required, extraction of the associated weights
@@ -310,7 +326,9 @@ class GriddedAccumulator:
 
             self.floating_subregion = None, None, floating_start_z, floating_end_z
 
-    def _extract_preprocess_with_flats(self, data_raw, reframing_infos, chunk_info, output, it_is_weight=False):
+    def _extract_preprocess_with_flats(
+        self, data_raw, reframing_infos, chunk_info, output, radios_angular_range_slicing=None, it_is_weight=False
+    ):
         if not it_is_weight:
             if self.dark is not None:
                 data_raw = data_raw - self.dark[reframing_infos.dtasrc_start_z : reframing_infos.dtasrc_end_z]
@@ -322,7 +340,7 @@ class GriddedAccumulator:
                         flat = flat - self.dark[reframing_infos.dtasrc_start_z : reframing_infos.dtasrc_end_z]
 
                     if self.radios_srcurrent is not None:
-                        factor = self.nominal_current / self.radios_srcurrent[idx]
+                        factor = self.nominal_current / self.radios_srcurrent[radios_angular_range_slicing.start + i]
                     else:
                         factor = 1
 

nabu/pipeline/helical/helical_chunked_regridded.py

@@ -995,19 +995,24 @@ class HelicalChunkedRegriddedPipeline:
 
         self.chunk_reader.load_data(overwrite=True, sub_total_prange_slice=sub_total_prange_slice)
         if self.chunk_reader.dataset_subsampling > 1:
-            subsampling_file_slice = self._expand_slice(sub_total_prange_slice)
+            radios_angular_range_slicing = self._expand_slice(sub_total_prange_slice)
         else:
-            subsampling_file_slice = sub_total_prange_slice
-        my_subsampled_indexes = self.chunk_reader._sorted_files_indices[subsampling_file_slice]
+            radios_angular_range_slicing = sub_total_prange_slice
+        my_subsampled_indexes = self.chunk_reader._sorted_files_indices[radios_angular_range_slicing]
         data_raw = self.chunk_reader.data[: len(my_subsampled_indexes)]
 
         self.regular_accumulator.extract_preprocess_with_flats(
             subchunk_slice,
-            my_subsampled_indexes,
+            my_subsampled_indexes,  # these are indexes pointing within the global domain sequence which is composed of darks flats radios
             chunk_info,
             np.array((subr_start_z, subr_end_z), "i"),
             np.array((dtasrc_start_z, dtasrc_end_z), "i"),
             data_raw,
+            radios_angular_range_slicing  # my_subsampled_indexes  is important in order to compare the
+            # radios positions with respect to the flat position, and these position
+            # are given as the sequential acquisition number which counts everything ( flats, darks, radios )
+            # Insteqd, in order to access array which spans only the radios, we need to have an idea of where we are.
+            # this is provided by radios_angular_range_slicing which addresses the radios domain
         )
 
     def binning_expanded(self, region):

nabu/pipeline/helical/tests/test_accumulator.py

@@ -153,4 +153,5 @@ class TestGriddedAccumulator:
             np.array((subr_start_z, subr_end_z), "i"),
             np.array((dtasrc_start_z, dtasrc_end_z), "i"),
             data_raw,
+            sub_total_prange_slice,
         )

nabu/pipeline/params.py

@@ -119,6 +119,9 @@ cor_methods = {
     "composite-coarse-to-fine": "composite-coarse-to-fine",
     "near": "composite-coarse-to-fine",
     "fourier-angles": "fourier-angles",
+    "fourier angles": "fourier-angles",
+    "fourier-angle": "fourier-angles",
+    "fourier angle": "fourier-angles",
     "octave-accurate": "octave-accurate",
 }
 

nabu/pipeline/tests/test_estimators.py

@@ -26,7 +26,7 @@ def bootstrap(request):
     cls.cor_pix = 1321.625
     cls.abs_tol = 0.0001
     cls.dataset_info = HDF5DatasetAnalyzer(dataset_downloaded_path)
-    cls.cor_options = """side="near"; near_pos = 300.0;  near_width = 20.0 """
+    cls.cor_options = extract_parameters("""side="near"; near_pos = 300.0;  near_width = 20.0 """, sep=";")
 
 
 @pytest.mark.skipif(not (__do_long_tests__), reason="Need NABU_LONG_TESTS=1 for this test")
@@ -75,13 +75,13 @@ class TestCorNearPos:
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
-        cor_options["near_pos"] = "from_file"
+        cor_options.update({"side": "from_file"})
         finder = CORFinder("sliding-window", self.ds_std, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
-        cor_options["near_pos"] = "ignore"
+        cor_options.update({"side": "center"})
         finder = CORFinder("sliding-window", self.ds_std, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
@@ -95,14 +95,13 @@ class TestCorNearPos:
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
         # Checks that it works though no data in NX
-        cor_options["near_pos"] = "from_file"
+        cor_options.update({"side": "from_file"})
         finder = SinoCORFinder("fourier-angles", self.ds_std, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
-        cor_options["near_pos"] = "ignore"
-        cor_options["side"] = "center"
+        cor_options.update({"side": "center"})
         finder = SinoCORFinder("fourier-angles", self.ds_std, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
@@ -116,15 +115,14 @@ class TestCorNearPos:
         print(message)
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
-        cor_options["near_pos"] = "from_file"
+        cor_options.update({"side": "from_file"})
         finder = CORFinder("sliding-window", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
         print(message)
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
-        cor_options["near_pos"] = "ignore"
-        cor_options["side"] = "center"
+        cor_options.update({"side": "center"})
         finder = CORFinder("sliding-window", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
@@ -138,13 +136,13 @@ class TestCorNearPos:
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
         # Checks that it works though no data in NX
-        cor_options["near_pos"] = "from_file"
+        cor_options.update({"side": "from_file"})
         finder = SinoCORFinder("fourier-angles", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."
         assert np.isclose(self.true_cor, cor, atol=self.abs_tol), message
 
-        cor_options["near_pos"] = "ignore"
+        cor_options.update({"side": "center"})
         finder = SinoCORFinder("fourier-angles", self.ds_bliss, do_flatfield=True, cor_options=cor_options)
         cor = finder.find_cor()
         message = f"Computed CoR {cor} and expected CoR {self.true_cor} do not coincide. Near_pos options was set to {cor_options.get('near_pos',None)}."

nabu/pipeline/writer.py

@@ -136,6 +136,7 @@ class WriterManager:
                 ),
                 "overwrite": self.overwrite,
                 "append": self.extra_options.get("single_output_file_initialized", False),
+                "hst_metadata": self.extra_options.get("raw_vol_metadata", {}),
             }
         else:
             raise ValueError("Unsupported file format: %s" % self.file_format)

nabu/stitching/config.py

@@ -152,7 +152,7 @@ SLURM_OTHER_OPTIONS = "other_options"
 
 SLURM_PREPROCESSING_COMMAND = "python_venv"
 
-SLURM_MODULES_TO_LOADS = "modules_to_load"
+SLURM_MODULES_TO_LOADS = "modules"
 
 SLURM_CLEAN_SCRIPTS = "clean_scripts"
 
@@ -450,7 +450,7 @@ class SlurmConfig:
     n_cpu_per_task: int = 4
 
     def __post_init__(self) -> None:
-        # make sure either 'modules_to_load' or 'preprocessing_command' is provided
+        # make sure either 'modules' or 'preprocessing_command' is provided
         if len(self.modules_to_load) > 0 and self.preprocessing_command not in (None, ""):
             raise ValueError(
                 f"Either modules {SLURM_MODULES_TO_LOADS} or preprocessing_command {SLURM_PREPROCESSING_COMMAND} can be provided. Not both."