nabu 2023.2.1__py3-none-any.whl → 2024.1.0rc3__py3-none-any.whl

nabu/pipeline/fullfield/nabu_config.py

@@ -40,14 +40,14 @@ nabu_config = {
         },
         "projections_subsampling": {
             "default": "1",
-            "help": "Projections subsampling factor: take one projection out of 'projection_subsampling'",
-            "validator": binning_validator,
+            "help": "Projections subsampling factor: take one projection out of 'projection_subsampling'. The format can be an integer (take 1 projection out of N), or N:M (take 1 projection out of N, start with the projection number M)\nFor example: 2 (or 2:0) to reconstruct from even projections, 2:1 to reconstruct from odd projections.",
+            "validator": projections_subsampling_validator,
             "type": "advanced",
         },
         "exclude_projections": {
             "default": "",
-            "help": "Path to a file name containing projections to exclude (projection indices).",
-            "validator": optional_file_location_validator,
+            "help": "Projection to exclude from the reconstruction. It can be:\n-indices = exclude_projections_indices.txt : Path to a text file with one integer per line. Each corresponding projection INDEX will be ignored.\n-angles = exclude_projections_angles.txt : Path to a text file with angle in DEGREES, one per line. The corresponding angles will be ignored\n-angular_range = [a, b] : ignore angles belonging to angular range [a, b] in degrees, with b included.",
+            "validator": exclude_projections_validator,
             "type": "advanced",
         },
         "overwrite_metadata": {
@@ -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",
@@ -159,13 +159,13 @@ nabu_config = {
         },
         "sino_rings_correction": {
             "default": "",
-            "help": "Sinogram rings removal method. Default (empty) is None. Available are: None, munch. See also: sino_rings_options",
+            "help": "Sinogram rings removal method. Default (empty) is None. Available are: None, munch, vo, mean-subtraction, mean-division. See also: sino_rings_options",
             "validator": sino_deringer_methods,
             "type": "optional",
         },
         "sino_rings_options": {
-            "default": "sigma=1.0 ; levels=10 ; padding=False",
-            "help": "Options for sinogram rings correction methods. The parameters are separated by commas and passed as 'name=value', for example: sigma=1.0;levels=10. Mind the semicolon separator (;).",
+            "default": "",
+            "help": "Options for sinogram rings correction methods. The parameters are separated by commas and passed as 'name=value'. Mind the semicolon separator (;). The default options are the following:\n-For munch: sigma=1.0 ; levels=10 ; padding=False\n-For vo: snr=3.0; la_size=51; sm_size=21; dim=1\n-For mean-subtraction and mean-division: filter_cutoff=(0, 30)",
             "validator": generic_options_validator,
             "type": "advanced",
         },
@@ -189,7 +189,7 @@ nabu_config = {
         },
         "autotilt_options": {
             "default": "",
-            "help": "Options for methods computing automatically the detector tilt. The parameters are separated by commas and passed as 'name=value', for example: low_pass=1; high_pass=20. Mind the semicolon separator (;).",
+            "help": "Options for methods computing automatically the detector tilt. The parameters are separated by commas and passed as 'name=value', for example: low_pass=1; high_pass=20. Mind the semicolon separator (;). Use 'value' ('') for values that are strings",
             "validator": generic_options_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', for example: low_pass=1; high_pass=20. Mind the semicolon separator (;).",
+            "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",
         },
@@ -336,7 +336,7 @@ nabu_config = {
             "type": "optional",
         },
         "centered_axis": {
-            "default": "0",
+            "default": "1",
             "help": "If set to true, the reconstructed region is centered on the rotation axis, i.e the center of the image will be the rotation axis position.",
             "validator": boolean_validator,
             "type": "optional",

nabu/pipeline/fullfield/processconfig.py

@@ -1,7 +1,6 @@
 import os
 import posixpath
 import numpy as np
-from typing import Optional
 from silx.io import get_data
 from silx.io.url import DataUrl
 from ...utils import copy_dict_items, compare_dicts
@@ -10,12 +9,11 @@ from ...io.reader import import_h5_to_dict
 from ...resources.utils import extract_parameters, get_values_from_file
 from ...resources.nxflatfield import update_dataset_info_flats_darks
 from ...resources.utils import get_quantities_and_units
-from ...reconstruction.sinogram import get_extended_sinogram_width
 from ..estimators import estimate_cor
 from ..processconfig import ProcessConfigBase
 from .nabu_config import nabu_config, renamed_keys
 from .dataset_validator import FullFieldDatasetValidator
-from tomoscan.esrf.scan.hdf5scan import ImageKey
+from nxtomo.nxobject.nxdetector import ImageKey
 
 
 class ProcessConfig(ProcessConfigBase):
@@ -447,6 +445,8 @@ class ProcessConfig(ProcessConfigBase):
             options["double_flatfield"] = {
                 "sigma": nabu_config["preproc"]["dff_sigma"],
                 "processes_file": nabu_config["preproc"]["processes_file"],
+                "log_min_clip": nabu_config["preproc"]["log_min_clip"],
+                "log_max_clip": nabu_config["preproc"]["log_max_clip"],
             }
         #
         # Radios rotation (do it here if possible)
@@ -481,7 +481,11 @@ class ProcessConfig(ProcessConfigBase):
         #
         # Unsharp
         #
-        if nabu_config["phase"]["unsharp_method"] is not None and nabu_config["phase"]["unsharp_coeff"] > 0:
+        if (
+            nabu_config["phase"]["unsharp_method"] is not None
+            and nabu_config["phase"]["unsharp_coeff"] > 0
+            and nabu_config["phase"]["unsharp_sigma"] > 0
+        ):
             tasks.append("unsharp_mask")
             options["unsharp_mask"] = copy_dict_items(
                 nabu_config["phase"], ["unsharp_coeff", "unsharp_sigma", "unsharp_method"]
@@ -525,6 +529,7 @@ class ProcessConfig(ProcessConfigBase):
         if nabu_config["preproc"]["sino_rings_correction"]:
             tasks.append("sino_rings_correction")
             options["sino_rings_correction"] = {
+                "method": nabu_config["preproc"]["sino_rings_correction"],
                 "user_options": nabu_config["preproc"]["sino_rings_options"],
             }
         #
@@ -568,7 +573,7 @@ class ProcessConfig(ProcessConfigBase):
             )  # pix size is in microns in dataset_info
 
             # x/y/z position information
-            def get_mean_pos(position_array: Optional[np.ndarray]) -> Optional[float]:
+            def get_mean_pos(position_array):
                 if position_array is None:
                     return None
                 else:

nabu/pipeline/fullfield/reconstruction.py

@@ -13,7 +13,7 @@ from ...resources.utils import is_hdf5_extension
 from ...io.writer import merge_hdf5_files, NXProcessWriter
 from ...cuda.utils import collect_cuda_gpus, __has_pycuda__
 from ...preproc.phase import compute_paganin_margin
-from ...misc.histogram import PartialHistogram, add_last_bin, hist_as_2Darray
+from ...processing.histogram import PartialHistogram, add_last_bin, hist_as_2Darray
 from .chunked import ChunkedPipeline
 from .computations import estimate_max_chunk_size
 
@@ -321,7 +321,6 @@ class FullFieldReconstructor:
                 delta_beta=phase_options["delta_beta"],
                 pixel_size=phase_options["pixel_size_m"],
                 padding=phase_options["padding_type"],
-                use_rfft=False,  # disable fftw here
             )
         elif phase_options["method"] == "CTF":
             # The whole projection has to be processed!

nabu/pipeline/helical/fbp.py

@@ -18,6 +18,11 @@ class BackprojectorHelical(Backprojector):
          *
     """
 
+    def __init__(self, *args, **kwargs):
+        """This became needed after the _d_sino allocation was removed from the base class"""
+        super().__init__(*args, **kwargs)
+        self._d_sino = self._processing.allocate_array("d_sino", self.sino_shape, "f")
+
     def set_custom_angles_and_axis_corrections(self, angles_rad, x_per_proj):
         """To arbitrarily change angles
         Parameters

nabu/pipeline/helical/filtering.py

@@ -1,9 +1,8 @@
 # pylint: disable=too-many-arguments
-import math
 import numpy as np
 from ...utils import get_cuda_srcfile, updiv
 from ...reconstruction.filtering import get_next_power
-from ...reconstruction.filtering_cuda import CudaSinoFilter, CudaKernel, garray
+from ...reconstruction.filtering_cuda import CudaSinoFilter
 
 # pylint: disable=too-many-arguments,too-many-instance-attributes,too-many-function-args
 
@@ -65,35 +64,39 @@ class HelicalSinoFilter(CudaSinoFilter):
 
         self.kern_args = (self.d_sino_f, self.d_filter_f)
         self.kern_args += self.d_sino_f.shape[::-1]
-        self._pad_mirror_edges_kernel = CudaKernel(
+        self._pad_mirror_edges_kernel = self.cuda.kernel(
             "padding",
             filename=get_cuda_srcfile("helical_padding.cu"),
             signature="PPfiiiii",
             options=[str("-DMIRROR_EDGES")],
         )
-        self._pad_mirror_constant_kernel = CudaKernel(
+        self._pad_mirror_constant_kernel = self.cuda.kernel(
             "padding",
             filename=get_cuda_srcfile("helical_padding.cu"),
             signature="PPfiiiiiff",
             options=[str("-DMIRROR_CONSTANT")],
         )
 
-        self._pad_mirror_edges_variable_rot_pos_kernel = CudaKernel(
+        self._pad_mirror_edges_variable_rot_pos_kernel = self.cuda.kernel(
             "padding",
             filename=get_cuda_srcfile("helical_padding.cu"),
             signature="PPPiiiii",
             options=[str("-DMIRROR_EDGES_VARIABLE_ROT_POS")],
         )
-        self._pad_mirror_constant_variable_rot_pos_kernel = CudaKernel(
+        self._pad_mirror_constant_variable_rot_pos_kernel = self.cuda.kernel(
             "padding",
             filename=get_cuda_srcfile("helical_padding.cu"),
             signature="PPPiiiiiff",
             options=[str("-DMIRROR_CONSTANT_VARIABLE_ROT_POS")],
         )
 
-        self.d_mirror_indexes = garray.zeros((self.sino_padded_shape[-2],), np.int32)
-        self.d_variable_rot_pos = garray.zeros((self.sino_padded_shape[-2],), np.float32)
-        self._pad_edges_kernel = CudaKernel(
+        self.d_mirror_indexes = self.cuda.allocate_array(
+            "d_mirror_indexes", (self.sino_padded_shape[-2],), dtype=np.int32
+        )
+        self.d_variable_rot_pos = self.cuda.allocate_array(
+            "d_variable_rot_pos", (self.sino_padded_shape[-2],), dtype=np.float32
+        )
+        self._pad_edges_kernel = self.cuda.kernel(
             "padding_edge", filename=get_cuda_srcfile("padding.cu"), signature="Piiiiiiii"
         )
         self._pad_block = (32, 32, 1)

nabu/pipeline/helical/gridded_accumulator.py

@@ -5,6 +5,8 @@ import math
 
 
 class GriddedAccumulator:
+    nominal_current = 0.2
+
     def __init__(
         self,
         gridded_radios,
@@ -12,11 +14,16 @@ class GriddedAccumulator:
         diagnostic_radios,
         diagnostic_weights,
         diagnostic_angles,
+        diagnostic_searched_angles_rad_clipped,
+        diagnostic_zpix_transl,
+        diag_zpro_run=0,
         dark=None,
         flat_indexes=None,
         flats=None,
         weights=None,
         double_flat=None,
+        radios_srcurrent=None,
+        flats_srcurrent=None,
     ):
         """
         This class creates, for a selected volume slab, a standard set of radios from an helical dataset.
@@ -33,22 +40,34 @@ class GriddedAccumulator:
         gridded_weights : 3d np.array
            same shape as gridded_radios, but it will accumulate the weights, during calls to
            extract_preprocess_with_flats
-        diagnostic_radios   : 3d np.array,  a stack composed of two radios
+        diag_zpro_run: int
+           if > 0 then only the diagnostics are filled, and no accumulation is done
+
+        diagnostic_searched_angles_rad_clipped:
+           the angles between 0 and 2pi. The contributions to diagnostic will be searched for these angles
+           plus for the same angles + 2pi ( following turn)
+
+        diagnostic_radios   : 3d np.array,  a stack composed of
            each radio must have the same size as a radio of the gridded_radios argument.
            During the calls to extract_preprocess_with_flats methods,
-           the first radio will collect the transformed data for angle=0 ( and the neighbouring ones
-           according to angular interpolation coefficients) and this only for the first occurring turn.
-           The second radio will be initialised  at the second turn, if any. These array are meant to be used
-           to  check the translation step over one turn.
+           the  radios will collect the transformed data for the angles given by diagnostic_searched_angles_rad_clipped and redundancy
         diagnostic_weights: 3d np.array  a stack composed of two radios
            Same shape as diagnostic_radios. The weigths for diagnostic radios ( will be zero on pixel
            where no data is available, or where the weight is null)
         diagnostic_angles : 1D np.array
-           Must have shape==(2,). The two entries will be filled with the angles at which the contributions
+           Must have shape==(2*len(diagnostic_searched_angles_rad_clipped),). The entries will be filled with the angles at which the contributions
            to diagnostic_radios have been summed.
-        dark =  None or 2D np.array
+        diagnostic_zpix_transl: 1D np.array
+           same as for diagnostic_angles, but for vertical translation in pixels
+        dark:  None or 2D np.array
            must have the shape of the detector ( generally larger that a radio of gridded_radios)
            If given, the dark will be subtracted from data and flats.
+        radios_srcurrent: 1D np.array
+             the machine current for every radio
+        flats_srcurrent: 1D np.array
+             the machine current for every flat
+
+
         flat_indexes: None or a list of integers
            the projection index corresponding to the flats
         flats   : None or 3D np.array
@@ -61,12 +80,22 @@ class GriddedAccumulator:
            If given, the double flat will be applied (division by double_flat)
            Must have  the same shape as the detector.
         """
+        self.diag_zpro_run = diag_zpro_run
         self.gridded_radios = gridded_radios
         self.gridded_weights = gridded_weights
         self.diagnostic_radios = diagnostic_radios
         self.diagnostic_weights = diagnostic_weights
         self.diagnostic_angles = diagnostic_angles
+
+        self.diagnostic_zpix_transl = diagnostic_zpix_transl
+        self.diagnostic_searched_angles_rad_clipped = diagnostic_searched_angles_rad_clipped
+
         self.dark = dark
+
+        self.radios_srcurrent = radios_srcurrent
+
+        self.flats_srcurrent = flats_srcurrent
+
         self.flat_indexes = flat_indexes
         self.flat_indexes_reverse_map = dict(
             [(global_index, local_index) for (local_index, global_index) in enumerate(flat_indexes)]
@@ -76,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
@@ -120,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.
@@ -141,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
@@ -156,7 +201,9 @@ class GriddedAccumulator:
         # and the remaining part is a simple projection over the accumulators,  for
         # the data and for the weights
         my_angles = chunk_info.angles_rad[subchunk_slice]
+
         n_gridded_angles = self.gridded_radios.shape[0]
+
         my_i_float = my_angles * (n_gridded_angles / (2 * math.pi))
 
         tmp_i_rounded = np.floor(my_i_float).astype(np.int32)
@@ -164,17 +211,52 @@ class GriddedAccumulator:
         my_i0 = np.mod(tmp_i_rounded, n_gridded_angles)
         my_i1 = np.mod(my_i0 + 1, n_gridded_angles)
 
-        for i0, epsilon, i1, data, weight, original_angle in zip(
-            my_i0, my_epsilon, my_i1, radios_subset, radios_weights_subset, chunk_info.angles_rad[subchunk_slice]
+        if self.diag_zpro_run:
+            # these are used only when collection the diagnostics
+
+            # an estimation of the angular step
+            my_angle_step_rad = abs(np.diff(chunk_info.angles_rad[subchunk_slice]).mean())
+            my_angles_02pi = np.mod(my_angles, 2 * np.pi)
+            # bins are delimited by ticks
+            ticks = np.empty(2 * len(self.diagnostic_searched_angles_rad_clipped), "f")
+            ticks[::2] = self.diagnostic_searched_angles_rad_clipped - my_angle_step_rad / 2
+            ticks[1::2] = ticks[::2] + my_angle_step_rad
+
+        for i0, epsilon, i1, data, weight, original_angle, original_zpix_transl in zip(
+            my_i0,
+            my_epsilon,
+            my_i1,
+            radios_subset,
+            radios_weights_subset,
+            chunk_info.angles_rad[subchunk_slice],
+            chunk_info.z_pix_per_proj[subchunk_slice],
         ):
             data_token = data * weight
-            self.gridded_radios[i0] += data_token * (1 - epsilon)
-            self.gridded_radios[i1] += data_token * epsilon
 
-            self.gridded_weights[i0] += weight * (1 - epsilon)
-            self.gridded_weights[i1] += weight * epsilon
+            if not self.diag_zpro_run:
+                self.gridded_radios[i0] += data_token * (1 - epsilon)
+                self.gridded_radios[i1] += data_token * epsilon
+
+                self.gridded_weights[i0] += weight * (1 - epsilon)
+                self.gridded_weights[i1] += weight * epsilon
+
+        # building the intervals around the diagnostic angles
+
+        if self.diag_zpro_run:
+            my_i0 = np.searchsorted(ticks, my_angles_02pi)
+
+            for i0, a02pi, data, weight, original_angle, original_zpix_transl in zip(
+                my_i0,
+                my_angles_02pi,
+                radios_subset,
+                radios_weights_subset,
+                chunk_info.angles_rad[subchunk_slice],
+                chunk_info.z_pix_per_proj[subchunk_slice],
+            ):
+                if i0 % 2 == 0:
+                    # not in an intervals
+                    continue
 
-            if i0 == 0 or i1 == 0:
                 # There is a contribution to the first regridded radio ( the one indexed by 0)
                 # We build  two diagnostics for the contributions to this radio.
                 # The first for the first pass (i_diag=0)
@@ -183,25 +265,49 @@ class GriddedAccumulator:
                 # To discriminate we introduce
                 # An angular margin beyond which we know that a possible contribution
                 # is coming from another turn
-                safe_angular_margin = 3.14 / 10
-                for i_diag in range(2):
-                    if original_angle < self.diagnostic_angles[i_diag] + safe_angular_margin:
+
+                safe_angular_margin = 3.14 / 40
+
+                my_dist = abs(
+                    a02pi - self.diagnostic_searched_angles_rad_clipped[(i0 - 1) // 2 : (i0 - 1) // 2 + 1].mean()
+                )
+
+                # print(" i0 ", i0, " original_angle ",  original_angle, "  a02pi" , a02pi, " my_dist " , my_dist)
+
+                # consider fist pass and second possible pass. There might be further passes which we dont consider here
+                i_diag_list = [(i0 - 1) // 2, (i0 - 1) // 2 + len(self.diagnostic_searched_angles_rad_clipped)]
+                for i_redundancy, i_diag in enumerate(i_diag_list):
+                    # print("IRED ", i_redundancy)
+                    if i_redundancy:
+                        # to avoid, in z_stages with >360 range for one single stage, to fill the second items which should instead be filled by another stage.
+                        if abs(original_zpix_transl - self.diagnostic_zpix_transl[i_diag_list[0]]) < 2.0:
+                            # print( " >>>>>> stesso z" , i_redundancy )
+                            continue
+
+                    if np.isnan(self.diagnostic_angles[i_diag]) or (
+                        abs(original_angle) < abs(self.diagnostic_angles[i_diag] + safe_angular_margin)
+                    ):
                         # we are searching for the first contributions ( the one at the lowest angle)
                         # for the two diagnostics. With the constraint that the second is at an higher angle
                         # than the first. So if we are here this means that we have found an occurrence with
                         # lower angle and we discard what we could have previously found.
+
                         self.diagnostic_radios[i_diag][:] = 0
                         self.diagnostic_weights[i_diag][:] = 0
                         self.diagnostic_angles[i_diag] = original_angle
 
-                    if abs(original_angle - self.diagnostic_angles[i_diag]) < safe_angular_margin:
-                        if i0 == 0:
-                            factor = 1 - epsilon
-                        else:
-                            factor = epsilon
+                        self.diagnostic_zpix_transl[i_diag] = original_zpix_transl
+                    else:
+                        continue
+
+                    if abs(my_dist) <= my_angle_step_rad * 1.1:
+                        factor = 1 - abs(my_dist) / (my_angle_step_rad)
+
                         self.diagnostic_radios[i_diag] += data_token * factor
                         self.diagnostic_weights[i_diag] += weight * factor
                         break
+                    else:
+                        pass
 
     class _ReframingInfos:
         def __init__(self, chunk_info, subchunk_slice, subr_start_end, dtasrc_start_end, subchunk_file_indexes):
@@ -220,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]
@@ -231,7 +339,12 @@ class GriddedAccumulator:
                     if self.dark is not None:
                         flat = flat - self.dark[reframing_infos.dtasrc_start_z : reframing_infos.dtasrc_end_z]
 
-                    data_raw[i] = data_raw[i] / flat
+                    if self.radios_srcurrent is not None:
+                        factor = self.nominal_current / self.radios_srcurrent[radios_angular_range_slicing.start + i]
+                    else:
+                        factor = 1
+
+                    data_raw[i] = data_raw[i] * factor / flat
 
             if self.double_flat is not None:
                 data_raw = data_raw / self.double_flat[reframing_infos.dtasrc_start_z : reframing_infos.dtasrc_end_z]
@@ -271,12 +384,35 @@ class GriddedAccumulator:
             flat_data = self.flats[self.flat_indexes_reverse_map[prev_next[0]]][slice_y, slice_x]
         else:  # interpolate
             prev_idx, next_idx = prev_next
-            flat_data_prev = self.flats[self.flat_indexes_reverse_map[prev_idx]][slice_y, slice_x]
-            flat_data_next = self.flats[self.flat_indexes_reverse_map[next_idx]][slice_y, slice_x]
+
+            n_prev = self.flat_indexes_reverse_map[prev_idx]
+            n_next = self.flat_indexes_reverse_map[next_idx]
+
+            flat_data_prev = self.flats[n_prev][slice_y, slice_x]
+            flat_data_next = self.flats[n_next][slice_y, slice_x]
+
+            if self.flats_srcurrent is not None:
+                prev_current_factor = self.nominal_current / self.flats_srcurrent[n_prev]
+                next_current_factor = self.nominal_current / self.flats_srcurrent[n_next]
+            else:
+                prev_current_factor = 1
+                next_current_factor = 1
+
             delta = next_idx - prev_idx
             w1 = 1 - (idx - prev_idx) / delta
             w2 = 1 - (next_idx - idx) / delta
-            flat_data = w1 * flat_data_prev + w2 * flat_data_next
+
+            if self.dark is not None:
+                dark = self.dark[slice_y, slice_x]
+            else:
+                dark = 0
+
+            flat_data = (
+                dark
+                + w1 * (flat_data_prev - dark) * prev_current_factor
+                + w2 * (flat_data_next - dark) * next_current_factor
+            )
+
         if flat_data.dtype != dtype:
             flat_data = np.ascontiguousarray(flat_data, dtype=dtype)
         return flat_data
@@ -364,7 +500,7 @@ def padding_logic(subr_start_z, subr_end_z, dtasrc_start_z, dtasrc_end_z):
 
 
 def get_reconstruction_space(span_info, min_scanwise_z, end_scanwise_z, phase_margin_pix):
-    """Utility function which, given the span_info object, creates the auxiliary collection arrays
+    """Utility function, so far used only by the unit test, which, given the span_info object, creates the auxiliary collection arrays
     and initialises the  my_z_min, my_z_end variable keeping into account the scan direction
     and the min_scanwise_z, end_scanwise_z input arguments
     Parameters
@@ -404,9 +540,17 @@ def get_reconstruction_space(span_info, min_scanwise_z, end_scanwise_z, phase_ma
     # the accumulators
     gridded_radios = np.zeros([n_gridded_angles, radios_h, span_info.detector_shape_vh[1]], np.float32)
     gridded_cumulated_weights = np.zeros([n_gridded_angles, radios_h, span_info.detector_shape_vh[1]], np.float32)
-    diagnostic_radios = np.zeros((2,) + gridded_radios.shape[1:], np.float32)
-    diagnostic_weights = np.zeros((2,) + gridded_radios.shape[1:], np.float32)
-    diagnostic_proj_angle = np.zeros([2], "f")
+
+    # this utility function is meant for testing the reconstruction only, not the diagnostic collection.
+    # However we build diagnostic targets all the same to feed something through the API
+    # which contemplates the diagnostics. So that the unit test runs correctly
+
+    diagnostic_radios = np.zeros((4,) + gridded_radios.shape[1:], np.float32)
+    diagnostic_weights = np.zeros((4,) + gridded_radios.shape[1:], np.float32)
+    diagnostic_proj_angle = np.zeros([4], "f")
+
+    diagnostic_searched_angles_rad_clipped = (0.5 + np.arange(2)) * (2 * np.pi / (2))
+    diagnostic_zpix_transl = np.zeros([4], "f")
 
     gridded_angles_rad = np.arange(n_gridded_angles) * 2 * np.pi / n_gridded_angles
     gridded_angles_deg = np.rad2deg(gridded_angles_rad)
@@ -422,6 +566,8 @@ def get_reconstruction_space(span_info, min_scanwise_z, end_scanwise_z, phase_ma
             "diagnostic_radios": diagnostic_radios,
             "diagnostic_weights": diagnostic_weights,
             "diagnostic_proj_angle": diagnostic_proj_angle,
+            "diagnostic_searched_angles_rad_clipped": diagnostic_searched_angles_rad_clipped,
+            "diagnostic_zpix_transl": diagnostic_zpix_transl,
             "gridded_angles_rad": gridded_angles_rad,
             "gridded_angles_deg": gridded_angles_deg,
         },