tomwer 1.2.9__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

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

@@ -1,36 +1,3 @@
-# coding: utf-8
-###########################################################################
-# Copyright (C) 2016 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-#############################################################################
-
-"""contain utils for score process
-"""
-
-__authors__ = [
-    "H.Payno",
-]
-__license__ = "MIT"
-__date__ = "28/10/2021"
-
 try:
     from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
         FullFieldReconstructor,
@@ -50,12 +17,15 @@ else:
 import logging
 import os
 from copy import deepcopy
+import subprocess
 from typing import Iterable, Optional, Union
 
 from nabu.pipeline.fullfield.nabu_config import (
     nabu_config as nabu_fullfield_default_config,
 )
 from processview.core.manager.manager import ProcessManager
+from sluurp.job import SBatchScriptJob
+from sluurp.executor import submit as submit_to_slurm_cluster
 
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.process.reconstruction.nabu.nabuslices import (
@@ -63,15 +33,20 @@ from tomwer.core.process.reconstruction.nabu.nabuslices import (
     _NabuBaseReconstructor,
     generate_nabu_configfile,
 )
+from tomwer.core.process.reconstruction.nabu.utils import (
+    slice_index_to_int,
+    get_nabu_multicor_file_prefix,
+)
 from tomwer.core.process.reconstruction.nabu.target import Target
 from tomwer.core.progress import Progress
 from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.core.utils.slurm import is_slurm_available
+from tomwer.core.utils.slurm import get_slurm_script_name, is_slurm_available
 from tomwer.utils import docstring
+from tomwer.core.process.reconstruction.nabu.utils import nabu_std_err_has_error
 
 from ..nabu import settings as nabu_settings
-from . import utils
-from .nabucommon import ResultsLocalRun, ResultSlurmRun, ResultsWithStd
+from . import utils, settings
+from .nabucommon import ResultsLocalRun, ResultSlurmRun, ResultsWithStd, ResultsRun
 
 _logger = logging.getLogger(__name__)
 
@@ -156,7 +131,7 @@ def run_nabu_one_slice_several_config(
                 std_outs.append(res.std_out)
                 std_errs.append(res.std_err)
             if isinstance(res, ResultsLocalRun):
-                recons_urls[var_value] = res.results_urls
+                recons_urls[var_value] = res.results_identifiers
             if isinstance(res, ResultSlurmRun):
                 future_tomo_obj = FutureTomwerObject(
                     tomo_obj=scan,
@@ -167,6 +142,77 @@ def run_nabu_one_slice_several_config(
         return success, recons_urls, std_outs, std_errs, future_tomo_objs
 
 
+def run_nabu_multicor(
+    scan: TomwerScanBase,
+    nabu_config: dict,
+    cors: tuple,
+    cluster_config: Optional[dict],
+    dry_run: bool,
+    slice_index: Union[int, str],
+    file_format: str,
+    process_id: Optional[int] = None,
+    instanciate_classes_only: bool = False,
+    output_file_prefix_pattern=None,
+):
+    if cluster_config in (None, {}):
+        target = Target.LOCAL
+    elif isinstance(cluster_config, dict):
+        if not is_slurm_available():
+            raise RuntimeError("Slurm computation requested but unvailable")
+        target = Target.SLURM
+    else:
+        raise TypeError(
+            f"cluster_config should be None or a dict not {type(cluster_config)}"
+        )
+
+    if process_id is not None:
+        try:
+            process_name = ProcessManager().get_process(process_id=process_id).name
+        except KeyError:
+            process_name = "unknow"
+    else:
+        process_name = ""
+
+    reconstructor = _ReconstructorMultiCor(
+        scan=scan,
+        nabu_config=nabu_config,
+        cors=cors,
+        slice_index=slice_index,
+        target=target,
+        dry_run=dry_run,
+        file_format=file_format,
+        cluster_config=cluster_config,
+        process_name=process_name,
+        output_file_prefix_pattern=output_file_prefix_pattern,
+    )
+    if instanciate_classes_only:
+        return reconstructor
+
+    try:
+        result = reconstructor.run()
+    except TimeoutError as e:
+        _logger.error(e)
+        return None
+    else:
+        recons_urls = {}
+        std_outs = []
+        std_errs = []
+
+        success = result.success
+        if isinstance(result, ResultsWithStd):
+            std_outs.append(result.std_out)
+            std_errs.append(result.std_err)
+        if isinstance(result, ResultsLocalRun):
+            recons_urls = result.results_identifiers
+        if isinstance(result, ResultSlurmRun):
+            future_tomo_obj = FutureTomwerObject(
+                tomo_obj=scan,
+                process_requester_id=process_id,
+                futures=result.future_slurm_jobs,
+            )
+        return success, recons_urls, (future_tomo_obj,), std_outs, std_errs
+
+
 class _Reconstructor(_NabuBaseReconstructor):
     def __init__(
         self,
@@ -207,14 +253,9 @@ class _Reconstructor(_NabuBaseReconstructor):
 
     @docstring(_NabuBaseReconstructor)
     def run(self) -> Iterable:
-        if self.slice_index == "middle":
-            if self.scan.dim_2 is not None:
-                self.slice_index = self.scan.dim_2 // 2
-            else:
-                _logger.warning(
-                    "scan.dim_2 returns None, unable to deduce middle " "pick 1024"
-                )
-                self.slice_index = 1024
+        self.slice_index = slice_index_to_int(
+            slice_index=self.slice_index, scan=self.scan
+        )
 
         results = {}
         if self.advancement:
@@ -222,24 +263,11 @@ class _Reconstructor(_NabuBaseReconstructor):
         for var_value, config in self.nabu_configs.items():
             if self._cancelled:
                 break
-
-            # in 1.2 there is some strange pipes. But this is rework on the next version so just fixe pipelines in this version
-            if "nabu_params" in config:
-                nabu_config = deepcopy(config["nabu_params"])
-                nabu_config["output"].update(config["output"])
-                if "pipeline" not in nabu_config:
-                    nabu_config["pipeline"] = {}
-                nabu_config["pipeline"].update(config.get("pipeline", {}))
-                nabu_config["reconstruction"].update(config.get("reconstruction", {}))
-                # end work around 1.2
-            else:
-                nabu_config = deepcopy(config)
-
-            nabu_config, conf_file = self.preprocess_config(nabu_config, var_value)
+            config, conf_file = self.preprocess_config(deepcopy(config), var_value)
 
             # add some tomwer metadata and save the configuration
             # note: for now the section is ignored by nabu but shouldn't stay that way
-            with utils.TomwerInfo(nabu_config) as config_to_dump:
+            with utils.TomwerInfo(config) as config_to_dump:
                 generate_nabu_configfile(
                     conf_file,
                     nabu_fullfield_default_config,
@@ -327,7 +355,7 @@ class _Reconstructor(_NabuBaseReconstructor):
         _config["reconstruction"]["end_z"] = self.slice_index
         return _config, file_prefix
 
-    def preprocess_config(self, config, value: float):
+    def preprocess_config(self, config, value) -> tuple:
         dataset_params = self.scan.get_nabu_dataset_info()
         if "dataset" in config:
             dataset_params.update(config["dataset"])
@@ -355,3 +383,301 @@ class _Reconstructor(_NabuBaseReconstructor):
             cfg_folder, file_prefix + nabu_settings.NABU_CONFIG_FILE_EXTENSION
         )
         return config, conf_file
+
+
+class _ReconstructorMultiCor(_NabuBaseReconstructor):
+    def __init__(
+        self,
+        nabu_config: dict,
+        cors: tuple,
+        file_format,
+        slice_index: Union[int, str] = "middle",
+        output_file_prefix_pattern=None,
+        *args,
+        **kwargs,
+    ):
+        if not isinstance(cors, tuple):
+            raise TypeError(
+                f"cors are expected to be an instance of tuple. Get {type(cors)} instead"
+            )
+        self.__cors = cors
+        self.__slice_index = slice_index
+        self.__nabu_config = nabu_config
+        self.file_format = file_format
+        self._output_file_prefix_pattern = output_file_prefix_pattern
+
+        super().__init__(*args, **kwargs)
+
+    @property
+    def cors(self) -> tuple:
+        return self.__cors
+
+    @property
+    def slice_index(self) -> Union[int, str]:
+        return self.__slice_index
+
+    @property
+    def nabu_config(self) -> dict:
+        return self.__nabu_config
+
+    def _process_config(
+        self,
+        config_to_dump: dict,
+        config_file: str,
+        file_format: str,
+        info: Optional[str],
+        process_name: str,
+    ):
+        """
+        process provided configuration
+
+        :param str info:
+        """
+        if self.dry_run is True or self.only_create_config_file():
+            return ResultsRun(
+                success=True,
+                config=config_to_dump,
+            )
+        elif self.target is Target.LOCAL:
+            _logger.info(f"run {info} for {self.scan} with {config_to_dump}")
+            return self._run_nabu_multicor_locally(
+                conf_file=config_file,
+                file_format=file_format,
+                config_to_dump=config_to_dump,
+            )
+        elif self.target is Target.SLURM:
+            _logger.info(
+                f"run {info} on slurm for {self.scan.path} with {config_to_dump}"
+            )
+            return self._run_nabu_multicor_on_slurm(
+                conf_file=config_file,
+                config_to_dump=config_to_dump,
+                cluster_config=self.cluster_config.to_dict(),
+                process_name=process_name,
+                info=info,
+            )
+        else:
+            raise ValueError(f"{self.target} is not recognized as a valid target")
+
+    @staticmethod
+    def convert_cor_from_rel_to_abs(scan, cor):
+        if scan.dim_1 is not None:
+            return cor + scan.dim_1 / 2.0
+        else:
+            _logger.warning("enable to get image half width. Set it to 1024")
+            return cor + 1024
+
+    @staticmethod
+    def convert_cor_from_abs_to_rel(scan, cor):
+        if scan.dim_1 is not None:
+            return cor - scan.dim_1 / 2.0
+        else:
+            _logger.warning("enable to get image half width. Set it to 1024")
+            return cor - 1024
+
+    def _run_nabu_multicor_locally(
+        self,
+        conf_file: str,
+        file_format: str,
+        config_to_dump: dict,
+    ) -> ResultsLocalRun:
+        """
+        run locally nabu for a single configuration file.
+
+        :param str conf_file: path to the nabu .cfg file
+        :param str file_format: format of the generated file
+        :param dict config_to_dump: configuration saved in the .cfg as a dictionary
+        :return: results of the local run
+        :rtype: ResultsLocalRun
+        """
+        if not has_nabu:
+            raise ImportError("Fail to import nabu")
+        slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
+
+        cor_in_nabu_ref = tuple(
+            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
+        )
+        cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
+        command = " ".join(
+            (
+                "python3",
+                "-m",
+                settings.NABU_MULTICOR_PATH,
+                conf_file,  # input file
+                f"{slice_index}",  # slice
+                f"{cor_in_nabu_ref}",  # cor
+            )
+        )
+        _logger.info(f'call nabu from "{command}"')
+
+        self._process = subprocess.Popen(
+            command,
+            shell=True,
+            cwd=self.scan.path,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        try:
+            outs, errs = self._process.communicate()
+        except (TimeoutError, KeyboardInterrupt):
+            self._process.kill()
+            outs, errs = self._process.communicate()
+
+        file_prefix = get_nabu_multicor_file_prefix(self.scan)
+
+        recons_vol_identifiers = utils.get_multi_cor_recons_volume_identifiers(
+            slice_index=slice_index,
+            location=config_to_dump["output"]["location"],
+            file_prefix=file_prefix,
+            scan=self.scan,
+            file_format=file_format,
+            cors=[
+                self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors
+            ],
+        )
+        # convert back from abs ref to rel ref
+        recons_vol_identifiers = {
+            self.convert_cor_from_abs_to_rel(self.scan, cor): identifiers
+            for cor, identifiers in recons_vol_identifiers.items()
+        }
+        return ResultsLocalRun(
+            success=not nabu_std_err_has_error(errs),
+            results_identifiers=recons_vol_identifiers,
+            std_out=outs,
+            std_err=errs,
+            config=config_to_dump,  # config_slices,
+        )
+
+    def _run_nabu_multicor_on_slurm(
+        self,
+        conf_file: str,
+        config_to_dump: dict,
+        cluster_config: dict,
+        process_name: str,
+        info: str,
+    ) -> ResultSlurmRun:
+        """
+        Run a nabu reconstruction on slurm of a single configuration
+
+        :return: results of the slurm run
+        :rtype: ResultSlurmRun
+        """
+        if not isinstance(conf_file, str):
+            raise TypeError(f"conf_file is expected to be a strg not {type(conf_file)}")
+        if not isinstance(config_to_dump, dict):
+            raise TypeError(
+                f"config_to_dump is expected to be a strg not {type(config_to_dump)}"
+            )
+        if not is_slurm_available():
+            raise RuntimeError("slurm not available")
+        if not isinstance(cluster_config, dict):
+            raise ValueError(
+                f"cluster config is expected to be a dict not {type(cluster_config)}"
+            )
+
+        # create slurm cluster
+        project_name = cluster_config.get(
+            "job_name", "tomwer_{scan}_-_{process}_-_{info}"
+        )
+        project_name = project_name.format(
+            scan=str(self.scan), process=process_name, info=info
+        )
+        # project name should not contain any spaces as it will be integrated in a script and interpreted.
+        project_name = project_name.replace(" ", "_")
+        cluster_config["job_name"] = project_name
+
+        slice_index = slice_index_to_int(self.slice_index, scan=self.scan)
+        cor_in_nabu_ref = tuple(
+            [self.convert_cor_from_rel_to_abs(self.scan, cor) for cor in self.cors]
+        )
+        cor_in_nabu_ref = ",".join([str(cor) for cor in cor_in_nabu_ref])
+
+        # submit job
+        script_name = get_slurm_script_name(prefix="nabu")
+        # for now force job name
+        cluster_config["job_name"] = f"tomwer-nabu {conf_file}"
+        job = SBatchScriptJob(
+            slurm_config=cluster_config,
+            script=(
+                f"python3 -m {settings.NABU_MULTICOR_PATH} {conf_file} {slice_index} {cor_in_nabu_ref}",
+            ),
+            script_path=os.path.join(self.scan.path, "slurm_scripts", script_name),
+            clean_script=False,
+            working_directory=self.scan.working_directory,
+        )
+        future_slurm_job = submit_to_slurm_cluster(job)
+
+        callbacks = self._get_futures_slurm_callback(config_to_dump)
+        assert isinstance(
+            callbacks, tuple
+        ), f"callbacks is expected to an instance of tuple and not {type(callbacks)}"
+        for callback in callbacks:
+            future_slurm_job.add_done_callback(callback.process)
+
+        return ResultSlurmRun(
+            success=True,
+            config=config_to_dump,
+            future_slurm_jobs=(future_slurm_job,),
+            std_out=None,
+            std_err=None,
+            job_id=job.job_id,
+        )
+
+    def preprocess_config(self, config):
+        dataset_params = self.scan.get_nabu_dataset_info()
+        if "dataset" in config:
+            dataset_params.update(config["dataset"])
+        config["dataset"] = dataset_params
+
+        config["resources"] = utils.get_nabu_resources_desc(
+            scan=self.scan, workers=1, method="local"
+        )
+        # force overwrite results
+        if "output" not in config:
+            config["output"] = {}
+        config["output"].update({"overwrite_results": 1})
+
+        cfg_folder = os.path.join(
+            config["output"]["location"],
+            nabu_settings.NABU_CFG_FILE_FOLDER,
+        )
+        os.makedirs(cfg_folder, exist_ok=True)
+
+        cfg_folder = os.path.join(
+            self.nabu_config["output"]["location"],
+            nabu_settings.NABU_CFG_FILE_FOLDER,
+        )
+        os.makedirs(cfg_folder, exist_ok=True)
+
+        conf_file = os.path.join(
+            cfg_folder,
+            f"{self.scan.get_dataset_basename()}_multi_cor"
+            + nabu_settings.NABU_CONFIG_FILE_EXTENSION,
+        )
+        return config, conf_file
+
+    def run(self) -> Iterable:
+        nabu_config, conf_file = self.preprocess_config(deepcopy(self.nabu_config))
+
+        # the policy is to save nabu .cfg file at the same location as the
+        # force overwrite results
+
+        # add some tomwer metadata and save the configuration
+        # note: for now the section is ignored by nabu but shouldn't stay that way
+        with utils.TomwerInfo(nabu_config) as config_to_dump:
+            generate_nabu_configfile(
+                conf_file,
+                nabu_fullfield_default_config,
+                config=config_to_dump,
+                options_level="advanced",
+            )
+
+        results = self._process_config(
+            config_to_dump=nabu_config,
+            config_file=conf_file,
+            file_format=self.file_format,
+            info="nabu sa-axis reconstruction",
+            process_name=self.process_name,
+        )
+
+        return results

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

@@ -41,6 +41,12 @@ 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.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
@@ -81,7 +87,7 @@ 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
@@ -210,7 +216,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):
@@ -263,11 +269,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 +315,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 +360,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 +394,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()
@@ -668,12 +685,9 @@ 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
+            )
         elif (
             isinstance(self.slice_index, float)
             and int(self.slice_index) == self.slice_index
@@ -784,9 +798,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 file_format=file_format,
                 scan=self.scan,
                 slice_index=None,
-                start_z=None,
-                end_z=None,
-                expects_single_slice=True,
             )
 
             return (CallBack(callback, self.scan),)
@@ -799,10 +810,11 @@ class SingleSliceRunner(_NabuBaseReconstructor):
     ):
         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)
+
         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: