tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

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

@@ -35,12 +35,20 @@ import os
 import gc
 from tomwer.io.utils import format_stderr_stdout
 from silx.utils.deprecation import deprecated, deprecated_warning
+from silx.io.utils import open as open_hdf5
 
 from processview.core.manager.manager import ProcessManager, DatasetState
 
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.utils.scanutils import data_identifier_to_scan
 from tomwer.core.utils.slurm import is_slurm_available
+from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
+from tomwer.core.process.reconstruction.nabu.utils import slice_index_to_int
+from tomwer.core.process.icat.gallery import (
+    IcatScreenshots,
+    deduce_dataset_gallery_location,
+)
+from tomwer.core.volume.volumefactory import VolumeFactory
 
 try:
     from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
@@ -77,11 +85,10 @@ from processview.core.superviseprocess import SuperviseProcess
 from silx.io.dictdump import h5todict
 from silx.io.utils import h5py_read_dataset
 from silx.utils.enum import Enum as _Enum
-from tomoscan.io import HDF5File
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.io.utils.h5pyutils import EntryReader
@@ -166,14 +173,6 @@ def run_slices_reconstruction(
 
     # handle special cases like several db...
     nabu_configurations = interpret_tomwer_configuration(config, scan=scan)
-    if "phase" in config and "delta_beta" in config["phase"]:
-        db_list = utils.retrieve_lst_of_value_from_str(
-            config["phase"]["delta_beta"], type_=float
-        )
-    else:
-        db_list = ()
-    ask_sinogram_registration = len(db_list) > 0
-    ask_sinogram_load = False
     output_urls = []
     stderrs = []
     stdouts = []
@@ -192,9 +191,8 @@ def run_slices_reconstruction(
             scan=scan,
             slice_index=slice_index,
             dry_run=dry_run,
-            ask_sinogram_registration=ask_sinogram_registration,
-            ask_sinogram_load=ask_sinogram_load,
             instanciate_class_only=instanciate_classes_only,
+            axis=config.get("reconstruction", {}).get("slice_plane", "XY"),
         )
 
         # specific treatments of results
@@ -210,7 +208,7 @@ def run_slices_reconstruction(
             assert not is_cluster_job, "cluster job should not return ResultsLocalRun"
             stderrs.append(result.std_err)
             stdouts.append(result.std_out)
-            output_urls.extend(result.results_urls)
+            output_urls.extend(result.results_identifiers)
             # if slice_index is None this mean that we are simply creating the
             # .cfg file for nabu full volume.
         elif isinstance(result, ResultSlurmRun):
@@ -230,9 +228,6 @@ def run_slices_reconstruction(
             final_configs.append(result.config)
             all_succeed = all_succeed and result.success
 
-        if ask_sinogram_registration:
-            ask_sinogram_load = True
-            ask_sinogram_registration = False
         if advancement is not None:
             advancement.increaseAdvancement(1)
 
@@ -263,11 +258,7 @@ class NabuSlicesTask(
         "dry_run",
         "serialize_output_data",
     ),
-    output_names=(
-        "data",
-        "nabu_params",
-        "future_tomo_obj",
-    ),
+    output_names=("data", "nabu_params", "future_tomo_obj", "screenshots"),
 ):
     """
     Definition of the nabu reconstruction volume reconstruction process
@@ -313,7 +304,7 @@ class NabuSlicesTask(
         assert isinstance(configuration, dict), "configuration is expected to be a dict"
 
         entry = "entry"
-        if isinstance(scan, HDF5TomoScan):
+        if isinstance(scan, NXtomoScan):
             entry = scan.entry
 
         output_urls = []
@@ -358,7 +349,7 @@ class NabuSlicesTask(
                 ), "cluster job should not return ResultsLocalRun"
                 stderrs.append(result.std_err)
                 stdouts.append(result.std_out)
-                output_urls.extend(result.results_urls)
+                output_urls.extend(result.results_identifiers)
                 # if slice_index is None this mean that we are simply creating the
                 # .cfg file for nabu full volume.
             elif isinstance(result, ResultSlurmRun):
@@ -392,6 +383,21 @@ class NabuSlicesTask(
             scan.set_latest_reconstructions(output_urls)
             future_tomo_obj = None
 
+        volume_urls = []
+        for rec_identifier in scan.latest_reconstructions:
+            volume_urls.extend(
+                VolumeFactory.from_identifier_to_vol_urls(rec_identifier)
+            )
+
+        self.outputs.screenshots = IcatScreenshots(
+            data_dir=deduce_dataset_gallery_location(scan),
+            screenshots={
+                os.path.splitext(os.path.basename(url.file_path()))[0]: url
+                for url in volume_urls
+            },
+            scan=scan,
+        )
+
         process_index = scan.pop_process_index()
         # update processes information / registration
         gc.collect()
@@ -426,15 +432,14 @@ class NabuSlicesTask(
         )
 
         # register result
-        with scan.acquire_process_file_lock():
-            self.register_process(
-                process_file=scan.process_file,
-                entry=entry,
-                configuration=configuration,
-                results={},
-                process_index=process_index,
-                overwrite=True,
-            )
+        self.register_process(
+            process_file=scan.process_file,
+            entry=entry,
+            configuration=configuration,
+            results={},
+            process_index=process_index,
+            overwrite=True,
+        )
         if self.get_input_value("serialize_output_data", True):
             self.outputs.data = scan.to_dict()
         else:
@@ -476,7 +481,7 @@ class NabuSlicesTask(
         :rtype:dict
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=True) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = NabuSlicesTask._get_process_nodes(
                     root_node=h5f, process=NabuSlicesTask
                 )
@@ -492,7 +497,7 @@ class NabuSlicesTask(
         configuration_path = None
         res = {}
 
-        with HDF5File(process_file, "r", swmr=True) as h5f:
+        with open_hdf5(process_file) as h5f:
             nabu_nodes = NabuSlicesTask._get_process_nodes(
                 root_node=h5f[entry], process=NabuSlicesTask
             )
@@ -570,7 +575,13 @@ def interpret_tomwer_configuration(
         return nabu_config
 
     if "tomwer_slices" in config and scan is not None:
-        slices = list(NabuSliceMode.getSlices(config["tomwer_slices"], scan))
+        slices = list(
+            NabuSliceMode.getSlices(
+                config["tomwer_slices"],
+                scan=scan,
+                axis=config.get("reconstruction", {}).get("slice_plane", "XY"),
+            )
+        )
     else:
         slices = []
 
@@ -614,9 +625,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         config: dict,
         dry_run: bool,
         slice_index: Union[int, str, None],
+        axis: NabuPlane,
         target: Target,
-        ask_sinogram_registration: bool,
-        ask_sinogram_load: bool,
         cluster_config: Optional[dict],
         process_name: str,
         add_to_latest_reconstructions: bool = True,
@@ -627,13 +637,12 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             target=target,
             cluster_config=cluster_config,
             process_name=process_name,
+            axis=axis,
         )
         self._slice_index = slice_index
         if not isinstance(config, dict):
             raise TypeError(f"config is expected to be a dictionary not {type(dict)}")
         self._config = config
-        self._ask_sinogram_registration = ask_sinogram_registration
-        self._ask_sinogram_load = ask_sinogram_load
         self._add_to_latest_reconstructions = add_to_latest_reconstructions
 
     @property
@@ -644,14 +653,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
     def config(self):
         return self._config
 
-    @property
-    def ask_sinogram_load(self):
-        return self._ask_sinogram_load
-
-    @property
-    def ask_sinogram_registration(self):
-        return self._ask_sinogram_registration
-
     @property
     def add_to_latest_reconstructions(self):
         return self._add_to_latest_reconstructions
@@ -668,12 +669,11 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         :raise: TIMEOUT_SLURM_JOB_SUBMISSION if not all workers spwan
         """
         if isinstance(self.slice_index, str):
-            if self.slice_index == "middle":
-                self._slice_index = self.scan.dim_2 // 2
-            else:
-                raise ValueError(
-                    f"slice index is expected to an int or 'middle' and not {type(self.slice_index)}"
-                )
+            self._slice_index = slice_index_to_int(
+                slice_index=self.slice_index,
+                scan=self.scan,
+                axis=self.axis,
+            )
         elif (
             isinstance(self.slice_index, float)
             and int(self.slice_index) == self.slice_index
@@ -696,32 +696,26 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         # force overwrite results
         if "output" not in config:
             config["output"] = {}
-        # handle nabu sinogram step
-        if self.scan.process_file is not None:
-            steps_file_basename, _ = os.path.splitext(self.scan.process_file)
-            steps_file_basename = "_".join(
-                ("steps_file_basename", "nabu", "sinogram", "save", "step")
-            )
-            steps_file_basename = steps_file_basename + ".hdf5"
-            steps_file = os.path.join(
-                os.path.dirname(self.scan.process_file), steps_file_basename
-            )
-        else:
-            steps_file = ""
 
         config["output"].update({"overwrite_results": 1})
-        config["pipeline"] = {
-            "save_steps": "sinogram" if self.ask_sinogram_registration else "",
-            "resume_from_step": "sinogram" if self.ask_sinogram_load else "",
-            "steps_file": steps_file,
-        }
 
         config, cfg_folder = self._treateOutputSliceConfig(config)
         # the policy is to save nabu .cfg file at the same location as the
         # force overwrite results
         if self.slice_index is not None:
-            config["reconstruction"]["start_z"] = self.slice_index
-            config["reconstruction"]["end_z"] = self.slice_index
+            if self.axis is NabuPlane.YZ:
+                config["reconstruction"]["start_x"] = self.slice_index
+                config["reconstruction"]["end_x"] = self.slice_index
+            elif self.axis is NabuPlane.XZ:
+                config["reconstruction"]["start_y"] = self.slice_index
+                config["reconstruction"]["end_y"] = self.slice_index
+            elif self.axis is NabuPlane.XY:
+                config["reconstruction"]["start_z"] = self.slice_index
+                config["reconstruction"]["end_z"] = self.slice_index
+            else:
+                raise ValueError(
+                    f"self.axis has an invalid value: {self.axis} when expected to be in {NabuPlane.values()}"
+                )
 
         if self.slice_index is not None:
             os.makedirs(config["output"]["location"], exist_ok=True)
@@ -749,8 +743,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 self._process_config(
                     config_to_dump=config_to_dump,
                     config_file=conf_file,
-                    start_z=None,
-                    end_z=None,
                     info="nabu slice reconstruction",
                     file_format=config_to_dump["output"]["file_format"],
                     process_name=self.process_name,
@@ -784,9 +776,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 file_format=file_format,
                 scan=self.scan,
                 slice_index=None,
-                start_z=None,
-                end_z=None,
-                expects_single_slice=True,
+                axis=self.axis,
             )
 
             return (CallBack(callback, self.scan),)
@@ -795,18 +785,25 @@ class SingleSliceRunner(_NabuBaseReconstructor):
 
     @staticmethod
     def get_file_basename_reconstruction(
-        scan, pag, ctf, db, slice_index: Union[str, int]
+        scan,
+        pag,
+        ctf,
+        db,
+        slice_index: Union[str, int],
+        axis: NabuPlane,
     ):
+        axis = NabuPlane.from_value(axis)
         if pag:
             assert db is not None, "if paganin defined, db should not be None"
-        if slice_index == "middle":
-            slice_index = scan.dim_2 // 2
+        if slice_index is not None:
+            slice_index = slice_index_to_int(slice_index, scan=scan, axis=axis)
+
         assert type(db) in (int, type(None))
-        if isinstance(scan, HDF5TomoScan):
+        if isinstance(scan, NXtomoScan):
             basename, _ = os.path.splitext(scan.master_file)
             basename = os.path.basename(basename)
             try:
-                with HDF5File(scan.master_file, mode="r") as h5f:
+                with open_hdf5(scan.master_file) as h5f:
                     if len(h5f.keys()) > 1:
                         # if there is more than one entry in the file append the entry name to the file basename
                         basename = "_".join((basename, scan.entry.lstrip("/")))
@@ -828,6 +825,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                         basename + "slice_pag",
                         str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
+                        "plane",
+                        axis.value,
                     )
                 )
             elif ctf:
@@ -836,13 +835,22 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                         basename + "slice_ctf",
                         str(slice_index).zfill(6),
                         "db" + str(db).zfill(4),
+                        "plane",
+                        axis.value,
                     )
                 )
             else:
-                return "_".join((basename + "slice", str(slice_index).zfill(6)))
+                return "_".join(
+                    (
+                        basename + "slice",
+                        str(slice_index).zfill(6),
+                        "plane",
+                        axis.value,
+                    )
+                )
 
     @docstring(_NabuBaseReconstructor)
-    def _get_file_basename_reconstruction(self, pag, db, ctf):
+    def _get_file_basename_reconstruction(self, pag, db, ctf, axis):
         """
 
         :param TomwerScanBase scan: scan reconstructed
@@ -854,7 +862,12 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         :return: basename of the file reconstructed (without any extension)
         """
         return self.get_file_basename_reconstruction(
-            scan=self.scan, db=db, pag=pag, slice_index=self.slice_index, ctf=ctf
+            scan=self.scan,
+            db=db,
+            pag=pag,
+            slice_index=self.slice_index,
+            ctf=ctf,
+            axis=axis,
         )
 
 
@@ -863,12 +876,11 @@ def run_single_slice_reconstruction(
     nabu_config,
     dry_run,
     slice_index: Union[int, str, None],
-    ask_sinogram_registration: bool,
-    ask_sinogram_load: bool,
     process_id: Optional[int] = None,
     cluster_config: Optional[dict] = None,
     add_to_latest_reconstructions=True,
     instanciate_class_only=False,
+    axis: NabuPlane = NabuPlane.XY,
 ) -> Optional[ResultsRun]:
     """
     # TODO: might need something like a context or an option "keep" slice in memory
@@ -882,8 +894,6 @@ def run_single_slice_reconstruction(
     :param local:
     :param stdout: file to redirect stdout
     :param stderr: file to redirect stderr
-    :param bool ask_sinogram_registration: should we ask nabu to register sinogram
-    :param bool ask_sinogram_load: should we ask nabu to load sinogram
     :param bool add_to_latest_reconstructions: if true add reconstructed slice to the latest reconstruction.
                                                We wan't to avoid this treatment for saaxis and sadeltebeta for example
     :param bool instanciate_class_only: if we don't want to run the SingleSliceRunner but only return them. Use case: we want to keep a hand on processing and it can be cancelled
@@ -892,6 +902,12 @@ def run_single_slice_reconstruction(
     """
     # TODO: remove local from the function signature
     target = Target.SLURM if cluster_config not in ({}, None) else Target.LOCAL
+    axis = NabuPlane.from_value(axis)
+    # FIXEME: nabu fails if outer_circle activated and if the axis != z
+    if axis != NabuPlane.XY and nabu_config.get("reconstruction", {}).get(
+        "clip_outer_circle", False
+    ):
+        nabu_config["reconstruction"]["clip_outer_circle"] = False
 
     if process_id is not None:
         try:
@@ -906,9 +922,8 @@ def run_single_slice_reconstruction(
         config=nabu_config,
         dry_run=dry_run,
         slice_index=slice_index,
+        axis=axis,
         target=target,
-        ask_sinogram_registration=ask_sinogram_registration,
-        ask_sinogram_load=ask_sinogram_load,
         cluster_config=cluster_config,
         add_to_latest_reconstructions=add_to_latest_reconstructions,
         process_name=process_name,
@@ -931,7 +946,7 @@ class NabuSliceMode(_Enum):
     OTHER = "other"
 
     @staticmethod
-    def getSlices(slices, scan) -> tuple:
+    def getSlices(slices, scan, axis=NabuPlane.XY) -> tuple:
         res = []
         try:
             mode = NabuSliceMode.from_value(slices)
@@ -942,7 +957,13 @@ class NabuSliceMode(_Enum):
                 pass
         else:
             if mode == mode.MIDDLE:
-                n_slice = scan.dim_2 or 2048
+                axis = NabuPlane.from_value(axis)
+                if axis is NabuPlane.XY:
+                    n_slice = scan.dim_2 or 2048
+                elif axis in (NabuPlane.YZ, NabuPlane.XZ):
+                    n_slice = scan.dim_1 or 2048
+                else:
+                    raise NotImplementedError(f"unknow axis {axis}")
                 res.append(n_slice // 2)
             else:
                 raise ValueError(

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

@@ -43,21 +43,27 @@ from processview.core.manager.manager import ProcessManager, DatasetState
 from processview.core.superviseprocess import SuperviseProcess
 
 from silx.io.utils import h5py_read_dataset
-from silx.utils.deprecation import deprecated_warning
-
-from tomoscan.io import HDF5File
+from silx.io.utils import open as open_hdf5
+from tomwer.core.utils.deprecation import deprecated_warning
 
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
+from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
 from tomwer.core.process.task import Task
+from tomwer.core.process.icat.gallery import (
+    IcatScreenshots,
+    deduce_dataset_gallery_location,
+    select_screenshot_from_volume,
+)
 from tomwer.core.scan.edfscan import EDFTomoScan
-from tomwer.core.scan.hdf5scan import HDF5TomoScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.dictutils import concatenate_dict
 from tomwer.core.utils.scanutils import data_identifier_to_scan
+from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.io.utils.h5pyutils import EntryReader
 from tomwer.utils import docstring
-from tomwer.core.utils import concatenate_dict
 from tomwer.io.utils import format_stderr_stdout
 
 from . import settings, utils
@@ -143,8 +149,8 @@ def run_volume_reconstruction(
         assert len(results) == 1, "only one volume should be reconstructed"
         res = results[0]
         # tag latest reconstructions
-        if isinstance(res, ResultsLocalRun) and res.results_urls is not None:
-            scan.set_latest_vol_reconstructions(res.results_urls)
+        if isinstance(res, ResultsLocalRun) and res.results_identifiers is not None:
+            scan.set_latest_vol_reconstructions(res.results_identifiers)
         # create future if needed
         if isinstance(res, ResultSlurmRun):
             future_tomo_obj = FutureTomwerObject(
@@ -269,8 +275,6 @@ class VolumeRunner(_NabuBaseReconstructor):
                     self._process_config(
                         config_to_dump=config_to_dump,
                         config_file=conf_file,
-                        start_z=config_to_dump["reconstruction"]["start_z"],
-                        end_z=config_to_dump["reconstruction"]["end_z"],
                         info="nabu volume reconstruction",
                         file_format=config_slices["output"]["file_format"],
                         process_name=self.process_name,
@@ -292,8 +296,8 @@ class VolumeRunner(_NabuBaseReconstructor):
             def process(self, fn):
                 if fn.done() and not (fn.cancelled() or fn.exception()):
                     # update reconstruction urls only if processing succeed.
-                    recons_urls = self.f_partial()
-                    self.scan.add_latest_vol_reconstructions(recons_urls)
+                    recons_identifiers = self.f_partial()
+                    self.scan.add_latest_vol_reconstructions(recons_identifiers)
 
         file_format = config_to_dump["output"]["file_format"]
         callback = functools.partial(
@@ -303,9 +307,7 @@ class VolumeRunner(_NabuBaseReconstructor):
             file_format=file_format,
             scan=self.scan,
             slice_index=None,
-            start_z=config_to_dump["reconstruction"]["start_z"],
-            end_z=config_to_dump["reconstruction"]["end_z"],
-            expects_single_slice=False,
+            axis=NabuPlane.XY,  # for volume we always reconstruct along XY plane
         )
 
         return (CallBack(callback, self.scan),)
@@ -323,17 +325,16 @@ class VolumeRunner(_NabuBaseReconstructor):
         if "postproc" in config:
             config["postproc"] = config["postproc"]
 
-        if "start_z" in config:
-            config["reconstruction"]["start_z"] = config["start_z"]
-            del config["start_z"]
-        if "end_z" in config:
-            config["reconstruction"]["end_z"] = config["end_z"]
-            del config["end_z"]
+        # make sure start_[x] and end_[x] come from config
+        for key in ("start_x", "end_x", "start_y", "end_y", "start_z", "end_z"):
+            if key in config:
+                config["reconstruction"][key] = config[key]
+                del config[key]
 
         return config, nabu_cfg_folder
 
     @docstring(_NabuBaseReconstructor)
-    def _get_file_basename_reconstruction(self, pag, db, ctf):
+    def _get_file_basename_reconstruction(self, pag, db, ctf, axis):
         """
 
         :param TomwerScanBase scan: scan reconstructed
@@ -342,16 +343,17 @@ class VolumeRunner(_NabuBaseReconstructor):
                                             entire volume
         :param bool pag: is it a paganin reconstruction
         :param int db: delta / beta parameter
+        :param axis: axis over which the reconstruction goes. For volume always expected to be z. So ignored in the function
         :return: basename of the file reconstructed (without any extension)
         """
         assert type(db) in (int, type(None))
         assert not pag == ctf == True, "cannot ask for both pag and ctf active"
-        if isinstance(self.scan, HDF5TomoScan):
+        if isinstance(self.scan, NXtomoScan):
             basename, _ = os.path.splitext(self.scan.master_file)
             basename = os.path.basename(basename)
             try:
                 # if there is more than one entry in the file append the entry name to the file basename
-                with HDF5File(self.scan.master_file, mode="r") as h5f:
+                with open_hdf5(self.scan.master_file) as h5f:
                     if len(h5f.keys()) > 1:
                         basename = "_".join((basename, self.scan.entry.strip("/")))
             except Exception:
@@ -371,7 +373,7 @@ class NabuVolumeTask(
     Task,
     SuperviseProcess,
     input_names=("data", "nabu_params"),
-    output_names=("data", "volumes", "future_tomo_obj"),
+    output_names=("data", "volumes", "future_tomo_obj", "screenshots"),
     optional_input_names=(
         "dry_run",
         "nabu_extra_params",  # some parameter that must update 'nabu_params' before launching the reconstruction. Such as z range...
@@ -462,8 +464,8 @@ class NabuVolumeTask(
             future_tomo_obj = None
         else:
             # tag latest reconstructions
-            if isinstance(res, ResultsLocalRun) and res.results_urls is not None:
-                scan.set_latest_vol_reconstructions(res.results_urls)
+            if isinstance(res, ResultsLocalRun) and res.results_identifiers is not None:
+                scan.set_latest_vol_reconstructions(res.results_identifiers)
             # create future if needed
             if isinstance(res, ResultSlurmRun):
                 future_tomo_obj = FutureTomwerObject(
@@ -527,6 +529,31 @@ class NabuVolumeTask(
         self.outputs.volumes = scan.latest_vol_reconstructions
         self.outputs.future_tomo_obj = future_tomo_obj
 
+        # build screenshots
+        if scan.latest_vol_reconstructions is not None:
+            try:
+                screenshots = {}
+                [
+                    screenshots.update(
+                        select_screenshot_from_volume(
+                            VolumeFactory.create_tomo_object_from_identifier(
+                                rec_identifier
+                            )
+                        )
+                    )
+                    for rec_identifier in scan.latest_vol_reconstructions
+                ]
+            except Exception as e:
+                _logger.error(f"screenshot creation failed. Error is {e}")
+            else:
+                self.outputs.screenshots = IcatScreenshots(
+                    data_dir=deduce_dataset_gallery_location(scan),
+                    screenshots=screenshots,
+                    scan=scan,
+                )
+        else:
+            self.outputs.screenshots = tuple()
+
     def set_configuration(self, configuration: dict) -> None:
         Task.set_configuration(self, configuration=configuration)
         if "dry_run" in configuration:
@@ -552,7 +579,7 @@ class NabuVolumeTask(
         with EntryReader(scan.process_file_url) as h5f:
             latest_nabu_node = Task.get_most_recent_process(h5f, NabuVolumeTask)
             path = "configuration/reconstruction/rotation_axis_position"
-            if path in latest_nabu_node:
+            if latest_nabu_node is not None and path in latest_nabu_node:
                 return h5py_read_dataset(latest_nabu_node[path])
 
     def cancel(self):

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

@@ -0,0 +1,9 @@
+"""Define nabu Axis"""
+
+from silx.utils.enum import Enum as _Enum
+
+
+class NabuPlane(_Enum):
+    YZ = "YZ"
+    XZ = "XZ"
+    XY = "XY"

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

@@ -33,8 +33,6 @@ import logging
 _logger = logging.getLogger(__name__)
 
 
-NABU_FILE_PER_GROUP = 100
-
 NABU_CONFIG_FILE_EXTENSION = ".cfg"
 
 NABU_CFG_FILE_FOLDER = "nabu_cfg_files"
@@ -60,3 +58,5 @@ else:
 
 
 NABU_CAST_APP_PATH = "nabu.app.cast_volume"
+
+NABU_MULTICOR_PATH = "nabu.app.multicor"