nabu 2022.3.0a1__py3-none-any.whl → 2023.1.0a2__py3-none-any.whl

nabu/pipeline/fullfield/computations.py

@@ -3,7 +3,7 @@ from silx.image.tomography import get_next_power
 from ...utils import check_supported
 
 
-def estimate_required_memory(process_config, delta_z=None, delta_a=None, max_mem_allocation_GB=None):
+def estimate_required_memory(process_config, delta_z=None, delta_a=None, max_mem_allocation_GB=None, debug=False):
     """
     Estimate the memory (RAM) needed for a reconstruction.
 
@@ -117,16 +117,17 @@ def estimate_required_memory(process_config, delta_z=None, delta_a=None, max_mem
             # That's big!
             total_memory_needed += 2 * data_volume_size
 
-    # print(
-    # "Mem for (delta_z=%s, delta_a=%s)  ==>  (Na=%d, Nz=%d, Nx=%d) : %.3f GB"
-    # % (delta_z, delta_a, Na, Nz, Nx, total_memory_needed / 1e9)
-    # )
+    if debug:
+        print(
+            "Mem for (delta_z=%s, delta_a=%s)  ==>  (Na=%d, Nz=%d, Nx=%d) : %.3f GB"
+            % (delta_z, delta_a, Na, Nz, Nx, total_memory_needed / 1e9)
+        )
 
     return total_memory_needed
 
 
 def estimate_max_chunk_size(
-    available_memory_GB, process_config, pipeline_part="full", n_rows=None, step=10, max_mem_allocation_GB=None
+    available_memory_GB, process_config, pipeline_part="all", n_rows=None, step=10, max_mem_allocation_GB=None
 ):
     """
     Estimate the maximum size of the data chunk that can be loaded in memory.

nabu/pipeline/fullfield/dataset_validator.py

@@ -32,7 +32,7 @@ class FullFieldDatasetValidator(DatasetValidatorBase):
         if rec_params["enable_halftomo"]:
             ny, nx = self._get_nx_ny()
         what = (("start_x", "end_x", nx), ("start_y", "end_y", nx), ("start_z", "end_z", nz))
-        for (start_name, end_name, numels) in what:
+        for start_name, end_name, numels in what:
             self._check_start_end_idx(
                 rec_params[start_name], rec_params[end_name], numels, start_name=start_name, end_name=end_name
             )

nabu/pipeline/fullfield/grouped_cuda.py

@@ -101,6 +101,8 @@ class CudaGroupedPipeline(GroupedPipeline):
         self._d_radios.get(ary=self._h_radios)
         self.radios = self._h_radios
         super()._write_data(data=self.radios)
+        self.process_config.single_tiff_initialized = False
+        self.process_config.hst_vol_initialized = False
 
 
 
@@ -138,3 +140,7 @@ class CudaSinoStackPipeline(SinoStackPipeline):
     def _write_data(self, data=None):
         recs = self._d_recs.get() # not ideal - use self.recs ?
         super()._write_data(data=recs)
+        # ?!
+        self.process_config.single_tiff_initialized = True
+        self.process_config.hst_vol_initialized = True
+        #

nabu/pipeline/fullfield/nabu_config.py

@@ -94,6 +94,18 @@ nabu_config = {
             "validator": float_validator,
             "type": "optional",
         },
+        "detector_distortion_correction": {
+            "default": "",
+            "help": "Apply coordinate transformation on the raw data, at the reading stage. Default (empty) is None. Available are: None, identity(for testing the pipeline), map_xz. This latter method requires two URLs being passet by detector_distortion_correction_options: map_x and map_z pointing to two 2D arrays containing the position where each pixel can be interpolated at in the raw data",
+            "validator": detector_distortion_correction_validator,
+            "type": "advanced",
+        },
+        "detector_distortion_correction_options": {
+            "default": "",
+            "help": "Options for sinogram rings correction methods. The parameters are separated by commas and passed as 'name=value', for example: center_xz=(1000,100); angle_deg=5. Mind the semicolon separator (;).",
+            "validator": generic_options_validator,
+            "type": "advanced",
+        },
         "double_flatfield_enabled": {
             "default": "0",
             "help": "Whether to enable the 'double flat-field' filetering for correcting rings artefacts.",
@@ -151,7 +163,7 @@ nabu_config = {
         "sino_rings_options": {
             "default": "sigma=1.0 ; levels=10",
             "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 (;).",
-            "validator": cor_options_validator,
+            "validator": generic_options_validator,
             "type": "advanced",
         },
         "rotate_projections": {
@@ -251,7 +263,7 @@ nabu_config = {
         "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 (;).",
-            "validator": cor_options_validator,
+            "validator": generic_options_validator,
             "type": "advanced",
         },
         "cor_slice": {
@@ -408,7 +420,7 @@ nabu_config = {
         },
         "file_format": {
             "default": "hdf5",
-            "help": "Output file format. Available are: hdf5, tiff, jp2, edf",
+            "help": "Output file format. Available are: hdf5, tiff, jp2, edf, vol",
             "validator": output_file_format_validator,
             "type": "optional",
         },

nabu/pipeline/fullfield/processconfig.py

@@ -560,6 +560,7 @@ class ProcessConfig(ProcessConfigBase):
             )
             rec_options = options["reconstruction"]
             rec_options["rotation_axis_position"] = self.rotation_axis_position(binning=True)
+            rec_options["fbp_rotation_axis_position"] = rec_options["rotation_axis_position"]
             rec_options["enable_halftomo"] = self.do_halftomo
             rec_options["axis_correction"] = dataset_info.axis_correction
             if dataset_info.axis_correction is not None:
@@ -572,6 +573,10 @@ class ProcessConfig(ProcessConfigBase):
             # TODO improve halftomo handling
             if self.do_halftomo:
                 rec_options["angles"] = rec_options["angles"][: (rec_options["angles"].size + 1) // 2]
+                if rec_options["rotation_axis_position"] < (self.radio_shape(binning=True)[-1] - 1) / 2.0:
+                    rec_options["fbp_rotation_axis_position"] = (
+                        self.radio_shape(binning=True)[-1] - rec_options["rotation_axis_position"]
+                    )
             # ---
             # New key
             rec_options["cor_estimated_auto"] = isinstance(nabu_config["reconstruction"]["rotation_axis_position"], str)

nabu/pipeline/fullfield/reconstruction.py

@@ -496,13 +496,11 @@ class FullFieldReconstructor:
             )
 
     def _get_chunk_length(self, task):
-
         if self._pipeline_mode == "helical":
             (start_z, end_z) = task["sub_region"]
             return end_z - start_z
 
         else:
-
             (start_angle, end_angle), (start_z, end_z), _ = task["sub_region"]
 
             if self._pipeline_mode == "chunked":
@@ -524,6 +522,7 @@ class FullFieldReconstructor:
         kwargs = {}
         if self.backend == "cuda":
             kwargs["cuda_options"] = self.cuda_options
+        kwargs["use_grouped_mode"] = self._pipeline_mode == "grouped"
         pipeline = self._pipeline_cls(*args, logger=self.logger, margin=task["margin"], **kwargs)
         self.pipeline = pipeline
 

nabu/pipeline/helical/gridded_accumulator.py

@@ -167,7 +167,6 @@ class GriddedAccumulator:
         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]
         ):
-
             data_token = data * weight
             self.gridded_radios[i0] += data_token * (1 - epsilon)
             self.gridded_radios[i1] += data_token * epsilon
@@ -186,7 +185,6 @@ class GriddedAccumulator:
                 # 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:
                         # 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
@@ -197,7 +195,6 @@ class GriddedAccumulator:
                         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:
@@ -224,13 +221,11 @@ 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):
-
         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]
 
             if self.flats is not None:
-
                 for i, idx in enumerate(reframing_infos.subchunk_file_indexes):
                     flat = self._get_flat(idx, slice(reframing_infos.dtasrc_start_z, reframing_infos.dtasrc_end_z))
                     if self.dark is not None:
@@ -249,7 +244,7 @@ class GriddedAccumulator:
         else:
             take_data_from_this = data_raw
 
-        for (data_read, list_subr_start_z, list_subr_end_z, fract_shift, x_shift, data_target) in zip(
+        for data_read, list_subr_start_z, list_subr_end_z, fract_shift, x_shift, data_target in zip(
             take_data_from_this,
             reframing_infos.subr_start_z_list,
             reframing_infos.subr_end_z_list,
@@ -257,7 +252,6 @@ class GriddedAccumulator:
             reframing_infos.x_shifts_list,
             output,
         ):
-
             _fill_in_chunk_by_shift_crop_data(
                 data_target,
                 data_read,
@@ -299,7 +293,6 @@ def _fill_in_chunk_by_shift_crop_data(
     x_shift=0.0,
     extension_padding=True,
 ):
-
     data_read_precisely_shifted = nd.shift(data_read, (-fract_shift, x_shift), order=1, mode="nearest")[:-1]
 
     target_central_slicer, dtasrc_central_slicer = overlap_logic(

nabu/pipeline/helical/helical_chunked_regridded.py

@@ -22,6 +22,10 @@ from ...reconstruction.sinogram import SinoBuilder, SinoNormalization
 from ...misc.unsharp import UnsharpMask
 from ...misc.histogram import PartialHistogram, hist_as_2Darray
 from ..utils import use_options, pipeline_step
+
+from ...resources.utils import extract_parameters
+from ..detector_distortion_provider import DetectorDistortionProvider
+
 from .utils import (
     WriterConfiguratorHelical as WriterConfigurator,
 )  # .utils is the same as ..utils but internally we retouch the key associated to "tiffwriter" of Writers to
@@ -120,7 +124,6 @@ class HelicalChunkedRegriddedPipeline:
         self._init_pipeline()
 
     def _set_params(self, process_config, sub_region, extra_options, phase_margin):
-
         self.process_config = process_config
         self.dataset_info = self.process_config.dataset_info
 
@@ -131,6 +134,9 @@ class HelicalChunkedRegriddedPipeline:
 
         self.chunk_size = sub_region[-1] - sub_region[-2]
         self.radios_buffer = None
+
+        self._set_detector_distortion_correction()
+
         self.set_subregion(sub_region)
 
         self._set_phase_margin(phase_margin)
@@ -240,7 +246,7 @@ class HelicalChunkedRegriddedPipeline:
         fname, ext = path.splitext(fname_full)
         dirname, file_prefix = path.split(fname)
         output_dir = path.join(dirname, file_prefix)
-        file_prefix += str("_%04d" % self._get_image_start_index())
+        file_prefix += str("_%06d" % self._get_image_start_index())
 
         self.logger.info("omitting config in  data_dump because of too slow nexus writer ")
 
@@ -474,7 +480,6 @@ class HelicalChunkedRegriddedPipeline:
     #
 
     def _init_pipeline(self):
-
         self._get_size_of_a_raw_radio()
 
         self._init_reader()
@@ -498,8 +503,17 @@ class HelicalChunkedRegriddedPipeline:
 
         self._configure_regular_accumulator()
 
-    def _configure_regular_accumulator(self):
+    def _set_detector_distortion_correction(self):
+        if self.process_config.nabu_config["preproc"]["detector_distortion_correction"] is None:
+            self.detector_corrector = None
+        else:
+            self.detector_corrector = DetectorDistortionProvider(
+                detector_full_shape_vh=self.process_config.dataset_info.radio_dims[::-1],
+                correction_type=self.process_config.nabu_config["preproc"]["detector_distortion_correction"],
+                options=self.process_config.nabu_config["preproc"]["detector_distortion_correction_options"],
+            )
 
+    def _configure_regular_accumulator(self):
         accumulator_cls = gridded_accumulator.GriddedAccumulator
 
         self.regular_accumulator = accumulator_cls(
@@ -549,7 +563,8 @@ class HelicalChunkedRegriddedPipeline:
         # dummy initialisation, it will be _set_subregion'ed and set_data_buffer'ed in the loops
         self.chunk_reader = ChunkReaderHelical(
             options["files"],
-            sub_region=self.sub_region,
+            sub_region=None,  # setting of subregion will be already done by calls to set_subregion
+            detector_corrector=self.detector_corrector,
             convert_float=True,
             binning=options["binning"],
             dataset_subsampling=options["dataset_subsampling"],
@@ -584,6 +599,7 @@ class HelicalChunkedRegriddedPipeline:
             distortion_correction=distortion_correction,
             radios_srcurrent=options["radios_srcurrent"],
             flats_srcurrent=options["flats_srcurrent"],
+            detector_corrector=self.detector_corrector,
             ## every flat will be read at a different heigth
             ### sub_region=self.sub_region,
             binning=options["binning"],
@@ -608,17 +624,19 @@ class HelicalChunkedRegriddedPipeline:
         self.double_flatfield = None
 
         if options["processes_file"] not in (None, ""):
-
             file_path = options["processes_file"]
             data_path = (self.dataset_info.hdf5_entry or "entry") + "/double_flatfield/results/data"
 
             if path.exists(file_path) and (data_path in h5py.File(file_path, "r")):
-
                 result_url = DataUrl(file_path=file_path, data_path=data_path)
                 self.logger.info("Loading double flatfield from %s" % result_url.file_path())
 
                 self.double_flatfield = self.DoubleFlatFieldClass(
-                    self._get_shape("double_flatfield"), result_url=result_url, binning_x=binning_x, binning_z=binning_z
+                    self._get_shape("double_flatfield"),
+                    result_url=result_url,
+                    binning_x=binning_x,
+                    binning_z=binning_z,
+                    detector_corrector=self.detector_corrector,
                 )
 
     def _init_weights_field(self):
@@ -630,21 +648,18 @@ class HelicalChunkedRegriddedPipeline:
         self.weights_field = None
 
         if options["processes_file"] not in (None, ""):
-
             file_path = options["processes_file"]
             data_path = (self.dataset_info.hdf5_entry or "entry") + "/weights_field/results/data"
 
             if path.exists(file_path) and (data_path in h5py.File(file_path, "r")):
-
                 result_url = DataUrl(file_path=file_path, data_path=data_path)
-                self.logger.info("Loading wegights_field from %s" % result_url.file_path())
+                self.logger.info("Loading weights_field from %s" % result_url.file_path())
 
                 self.weights_field = self.DoubleFlatFieldClass(
                     self._get_shape("double_flatfield"), result_url=result_url, binning_x=binning_x, binning_z=binning_z
                 )
 
     def _init_ccd_corrections(self):
-
         if "ccd_correction" not in self.processing_steps:
             return
 
@@ -690,11 +705,11 @@ class HelicalChunkedRegriddedPipeline:
             self.unsharp_coeff = 0.0
             self.unsharp_method = "log"
         else:
+            options = self.processing_options["unsharp_mask"]
             self.unsharp_sigma = options["unsharp_sigma"]
             self.unsharp_coeff = options["unsharp_coeff"]
             self.unsharp_method = options["unsharp_method"]
 
-            options = self.processing_options["unsharp_mask"]
             self.unsharp_mask = self.UnsharpMaskClass(
                 self._get_shape("unsharp_mask"),
                 options["unsharp_sigma"],
@@ -755,9 +770,7 @@ class HelicalChunkedRegriddedPipeline:
         start_y, end_y, start_x, end_x = self._rec_roi
 
         if self.HBPClass is not None:
-
             fan_source_distance_meters = self.process_config.nabu_config["reconstruction"]["fan_source_distance_meters"]
-            fan_voxels_size_micron = self.process_config.nabu_config["reconstruction"]["fan_voxels_size_micron"]
 
             self.reconstruction_hbp = self.HBPClass(
                 self._get_shape("one_sino_slim"),
@@ -766,7 +779,7 @@ class HelicalChunkedRegriddedPipeline:
                 rot_center=rot_center,
                 extra_options={"axis_correction": np.zeros(self.radios.shape[0], "f")},
                 axis_source_meters=fan_source_distance_meters,
-                voxel_size_microns=fan_voxels_size_micron,
+                voxel_size_microns=options["pixel_size_cm"] * 1.0e4,
                 scale_factor=1.0 / options["pixel_size_cm"],
             )
 
@@ -785,6 +798,7 @@ class HelicalChunkedRegriddedPipeline:
             extra_options={
                 "scale_factor": 1.0 / options["pixel_size_cm"],
                 "axis_correction": np.zeros(self.radios.shape[0], "f"),
+                "clip_outer_circle": options["clip_outer_circle"],
             },  #  "padding_mode": options["padding_type"],         },
         )
 
@@ -823,7 +837,7 @@ class HelicalChunkedRegriddedPipeline:
 
         if self._hdf5_output:
             fname_start_index = None
-            file_prefix += str("_%04d" % self._get_slice_start_index())
+            file_prefix += str("_%06d" % self._get_slice_start_index())
             entry = getattr(self.dataset_info.dataset_scanner, "entry", None)
             nx_info = {
                 "process_name": self._get_process_name(),
@@ -861,7 +875,6 @@ class HelicalChunkedRegriddedPipeline:
         return t
 
     def _expand_slice(self, subchunk_slice):
-
         start, stop, step = subchunk_slice.start, subchunk_slice.stop, subchunk_slice.step
         if step is None:
             step = 1
@@ -901,7 +914,6 @@ class HelicalChunkedRegriddedPipeline:
         data_raw = self.chunk_reader.data[: len(my_indexes)]
 
         if (self.flatfield is not None) or (self.double_flatfield is not None):
-
             sub_regions_per_radio = [self.trimmed_floating_subregion] * len(my_indexes)
 
             if self.flatfield is not None:
@@ -920,7 +932,6 @@ class HelicalChunkedRegriddedPipeline:
         for data_read, list_subr_start_z, list_subr_end_z, fract_shit, x_shift, data_target in zip(
             data_raw, subr_start_z_list, subr_end_z_list, fract_complement_shifts_v, x_shifts_list, output
         ):
-
             _fill_in_chunk_by_shift_crop_data(
                 data_target,
                 data_read,
@@ -933,7 +944,6 @@ class HelicalChunkedRegriddedPipeline:
             )
 
     def _read_data_and_apply_flats(self, sub_total_prange_slice, subchunk_slice, chunk_info):
-
         my_integer_shifts_v = chunk_info.integer_shift_v[subchunk_slice]
         fract_complement_shifts_v = chunk_info.fract_complement_to_integer_shift_v[subchunk_slice]
         x_shifts_list = chunk_info.x_pix_per_proj[subchunk_slice]
@@ -1015,7 +1025,6 @@ class HelicalChunkedRegriddedPipeline:
                 radios[i][:] = _tmp_radio[:]
 
     def _retrieve_phase(self):
-
         if "unsharp_mask" in self.processing_steps:
             for i in range(self.gridded_radios.shape[0]):
                 self.gridded_radios[i] = self.phase_retrieval.apply_filter(self.gridded_radios[i])
@@ -1024,7 +1033,6 @@ class HelicalChunkedRegriddedPipeline:
                 self.radios[i] = self.phase_retrieval.apply_filter(self.gridded_radios[i])
 
     def _nophase_put_to_radios(self, target, source):
-
         ((up_margin, down_margin), (left_margin, right_margin)) = self.phase_margin
 
         zslice = slice(up_margin or None, -down_margin or None)
@@ -1034,7 +1042,6 @@ class HelicalChunkedRegriddedPipeline:
             target[i] = source[i][zslice, xslice]
 
     def _apply_unsharp():
-
         ((up_margin, down_margin), (left_margin, right_margin)) = self._phase_margin
 
         zslice = slice(up_margin or None, -down_margin or None)
@@ -1075,7 +1082,6 @@ class HelicalChunkedRegriddedPipeline:
         self.sinos = self.radios_slim
 
     def _reconstruct(self, sinos=None, chunk_info=None, i_slice=0):
-
         if sinos is None:
             sinos = self.sinos
 
@@ -1115,7 +1121,6 @@ class HelicalChunkedRegriddedPipeline:
             data = self.recs_stack
         my_kw_args = copy.copy(self._writer_exec_kwargs)
         if "config" in my_kw_args:
-
             self.logger.info("omitting config in  writer because of too slow nexus writer ")
             my_kw_args["config"] = {"test": counter[0]}
             counter[0] += 1
@@ -1148,13 +1153,29 @@ class HelicalChunkedRegriddedPipeline:
         writer.write_data(data)
 
     def balance_weights(self):
-
         options = self.processing_options["reconstruction"]
 
         rot_center = options["rotation_axis_position"]
 
         self.radios_weights[:] = rebalance(self.radios_weights, self.my_angles_rad, rot_center)
 
+        # When standard scans are incomplete, due to motors errors, some angular range
+        #  is missing short of 360 degrees.
+        # The weight accounting correctly deal with it, but still the padding
+        # procedure with theta+180 data may fall on empty data
+        # and this may cause problems, coming from the ramp filter,
+        # in half tomo.
+        # To correct this we complete with what we have at hand from the nearest
+        # non empty data
+        #
+        to_be_filled = []
+        for i in range(len(self.radios_weights) - 1, 0, -1):
+            if self.radios_weights[i].sum():
+                break
+            to_be_filled.append(i)
+        for i in to_be_filled:
+            self.radios[i] = self.radios[to_be_filled[-1] - 1]
+
     def _post_primary_data_reduction(self, i_slice):
         """This will be used in the derived class to transfer data to gpu"""
         self.radios_slim[:] = self.radios[:, i_slice, :]
@@ -1200,7 +1221,6 @@ class HelicalChunkedRegriddedPipeline:
         self.gridded_radios[:] = 0
 
         for pnum_start, pnum_end in zip(pnum_start_list, pnum_end_list):
-
             start_in_chunk = pnum_start - my_first_pnum
             end_in_chunk = pnum_end - my_first_pnum
 
@@ -1252,7 +1272,6 @@ class HelicalChunkedRegriddedPipeline:
         self._dump_sinogram()
 
         if "reconstruction" in self.processing_steps:
-
             for i_slice in range(num_slices):
                 self._post_primary_data_reduction(i_slice)  # charge on self.radios_slim
 
@@ -1273,7 +1292,6 @@ class HelicalChunkedRegriddedPipeline:
         n_provided_angles = self.radios_slim.shape[0]
 
         for first_angle_index in range(0, n_provided_angles, self.num_weight_radios_per_app):
-
             end_angle_index = min(n_provided_angles, first_angle_index + self.num_weight_radios_per_app)
             self._d_radios_weights[: end_angle_index - first_angle_index].set(
                 self.radios_weights[first_angle_index:end_angle_index, i_slice]
@@ -1367,7 +1385,6 @@ class HelicalChunkedRegriddedPipeline:
         # ---------------
         reconstructed_volume_size = 0
         if "reconstruction" in processing_steps:
-
             ##  radios_slim is used to process one slice at once, It will be on the gpu
             ##  and cannot be reduced further, therefore no need to estimate it.
             ##  Either it passes or it does not.
@@ -1445,7 +1462,6 @@ def _fill_in_chunk_by_shift_crop_data(
     x_shift=0.0,
     extension_padding=True,
 ):
-
     """given a freshly read cube of data, it dispatches every slice to its proper vertical  position and proper radio by shifting, cropping, and extending if necessary"""
     data_read_precisely_shifted = nd.interpolation.shift(data_read, (-fract_shit, x_shift), order=1, mode="nearest")[
         :-1
@@ -1509,7 +1525,6 @@ def rebalance(radios_weights, angles, ax_pos):
         angle = angles[i]
 
         for i_half_turn in range(-n_span - 1, n_span + 2):
-
             if i_half_turn == 0:
                 w_res[:] += radios_weights[i]
                 continue

nabu/pipeline/helical/helical_reconstruction.py

@@ -108,7 +108,6 @@ class HelicalReconstructorRegridded:
         z_max_mm = rec_cfg["end_z_mm"]
 
         if z_min_mm != 0.0 or z_max_mm != 0.0:
-
             z_min_mm += self.z_offset_mm
             z_max_mm += self.z_offset_mm
 
@@ -171,7 +170,6 @@ class HelicalReconstructorRegridded:
 
     # Gpu required memory size does not depend on the number of slices
     def _compute_max_chunk_size(self):
-
         cpu_mem = self.resources["mem_avail_GB"] * self.cpu_mem_fraction
 
         user_max_chunk_size = self.extra_options["max_chunk_size"]
@@ -230,7 +228,6 @@ class HelicalReconstructorRegridded:
 
     # different because of dry_run
     def _build_tasks(self):
-
         if self.dry_run:
             self.tasks = []
         else:
@@ -261,7 +258,6 @@ class HelicalReconstructorRegridded:
             my_z_min = z_start
             my_z_end = z_end
         else:
-
             if self.z_max <= self.z_min:
                 message = f"""" The input file provide start_z end_z {self.z_min,self.z_max}
                 but it is necessary that  start_z < end_z
@@ -413,11 +409,7 @@ class HelicalReconstructorRegridded:
         self.logger.info(f"Creating SpanStrategy object for helical in {duration} seconds")
         if self.dry_run:
             info_string = self._span_info.get_informative_string()
-            print(" SPAN_INFO informations ")
-            print(info_string)
-
-            info_string = self._span_info.get_informative_string()
-            print(" SPAN_INFO informations ")
+            print(" Informations about the doable vertical span")
             print(info_string)
             return
 

nabu/pipeline/helical/nabu_config.py

@@ -1,5 +1,5 @@
 from ..fullfield.nabu_config import *
-
+import copy
 
 ## keep the text below for future inclusion in the documentation
 # start_z, end_z , start_z_mm, end_z_mm
@@ -33,13 +33,16 @@ help_start_end_z = """ If both start_z_mm and end_z_mm are seto to zero, then st
 otherwhise the slices whose height above the sample stage, in millimiters, between start_z_mm and end_z_mm are reconstructed
 """
 
+# we need to deepcopy this in order not to mess the original nabu_config of the full-field pipeline
+nabu_config = copy.deepcopy(nabu_config)
 
 nabu_config["preproc"]["processes_file"] = {
     "default": "",
-    "help": "Path to the file where some operations should be stored for later use. By default it is 'xxx_nabu_processes.h5'",
+    "help": "Path tgo the file where some operations should be stored for later use. By default it is 'xxx_nabu_processes.h5'",
     "validator": optional_file_location_validator,
-    "type": "advanced",
+    "type": "required",
 }
+nabu_config["preproc"]["double_flatfield_enabled"]["default"] = 1
 
 
 nabu_config["reconstruction"].update(
@@ -92,32 +95,26 @@ nabu_config["reconstruction"].update(
             "validator": float_validator,
             "type": "optional",
         },
-        "fan_voxels_size_micron": {
-            "default": 1.0,
-            "help": "For HBP, for the description of the fan geometry, the size of the voxel. Defaults to a small value which implies parallel geometry",
-            "validator": float_validator,
-            "type": "optional",
-        },
         "start_z_mm": {
-            "default": "",
+            "default": "0",
             "help": help_start_end_z,
             "validator": float_validator,
             "type": "optional",
         },
         "end_z_mm": {
-            "default": "",
+            "default": "0",
             "help": " To determine the reconstructed vertical range: the height in millimiters above the stage below which slices are reconstructed ",
             "validator": float_validator,
             "type": "optional",
         },
         "start_z": {
-            "default": "",
+            "default": "0",
             "help": "the first slice of the reconstructed range. Numbered going in the direction of the scan and starting with number zero for the first doable slice",
             "validator": slice_num_validator,
             "type": "optional",
         },
         "end_z": {
-            "default": "",
+            "default": "-1",
             "help": "the "
             "end"
             " slice of the reconstructed range. Numbered going in the direction of the scan and starting with number zero for the first doable slice",
@@ -139,7 +136,7 @@ nabu_config["pipeline"].update(
 nabu_config["reconstruction"].update(
     {
         "angular_tolerance_steps": {
-            "default": "0.0",
+            "default": "3.0",
             "help": "the angular tolerance, an angular width expressed in units of an angular step, which is tolerated in the criteria for deciding if a slice is reconstructable or not",
             "validator": float_validator,
             "type": "advanced",