tomwer 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

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

@@ -36,18 +36,28 @@ from processview.core.manager.manager import ProcessManager
 
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.utils.slurm import is_slurm_available
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 try:
-    from nabu.pipeline.fullfield.local_reconstruction import (  # noqa F401
-        ChunkedReconstructor,
+    from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
+        FullFieldReconstructor,
     )
 except (ImportError, OSError) as e:
-    # import of cufft library can bring an OSError if cuda not install
-    has_nabu = False
     _err_import_nabu = e
+    try:
+        from nabu.pipeline.fullfield.local_reconstruction import (  # noqa F401
+            ChunkedReconstructor,
+        )
+    except (ImportError, OSError):
+        # import of cufft library can bring an OSError if cuda not install
+        has_nabu = False
+    else:
+        has_nabu = True
+        _err_import_nabu = None
 else:
     has_nabu = True
     _err_import_nabu = None
+
 from silx.utils.enum import Enum as _Enum
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
@@ -128,6 +138,9 @@ def run_slices_reconstruction(
             "job on cluster requested but no access to slurm cluster found"
         )
 
+    # beam shape is not directly used by nabu (uses ctf_geometry directly)
+    config.get("phase", {}).pop("beam_shape", None)
+
     # if scan contains some center of position copy it to nabu
     if scan.axis_params is not None and scan.axis_params.relative_cor_value is not None:
         if "reconstruction" in config:
@@ -258,7 +271,7 @@ class NabuSlices(
         self._dry_run = inputs.get("dry_run", False)
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         self.outputs.nabu_params = None
         if scan is None:
             self.outputs.data = None
@@ -298,9 +311,6 @@ class NabuSlices(
         if "dry_run" in configuration:
             self.set_dry_run(bool(configuration["dry_run"]))
 
-    def pathReceived(self, scan):
-        return self.process(scan=scan)
-
     # TODO: those get / set configuration should be removed now that Task is used
     def get_configuration(self):
         return self._settings
@@ -423,9 +433,9 @@ def interpret_tomwer_configuration(
         slices = []
 
     if "phase" in config and "delta_beta" in config["phase"]:
-        pag_dbs = utils.retrieve_lst_of_value_from_str(
-            config["phase"]["delta_beta"], type_=float
-        )
+        pag_dbs = config["phase"]["delta_beta"]
+        if isinstance(pag_dbs, str):
+            pag_dbs = utils.retrieve_lst_of_value_from_str(pag_dbs, type_=float)
         if len(pag_dbs) == 0:
             pag_dbs = (None,)
     else:
@@ -511,6 +521,11 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                 raise ValueError(
                     f"slice index is expected to an int or 'middle' and not {type(self.slice_index)}"
                 )
+        elif (
+            isinstance(self.slice_index, float)
+            and int(self.slice_index) == self.slice_index
+        ):
+            self._slice_index = int(self.slice_index)
         elif not isinstance(self.slice_index, (int, type(None))):
             raise TypeError(
                 f"slice index is expected to an int or 'middle' or None and not {type(self.slice_index)}"
@@ -628,7 +643,9 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             return super()._get_futures_slurm_callback(config_to_dump)
 
     @staticmethod
-    def get_file_basename_reconstruction(scan, pag, db, slice_index: Union[str, int]):
+    def get_file_basename_reconstruction(
+        scan, pag, ctf, db, slice_index: Union[str, int]
+    ):
         if pag:
             assert db is not None, "if paganin defined, db should not be None"
         if slice_index == "middle":
@@ -642,6 +659,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         if slice_index is None:
             if pag:
                 return "_".join((basename + "pag", "db" + str(db).zfill(4)))
+            elif ctf:
+                return "_".join((basename + "ctf", "db" + str(db).zfill(4)))
             else:
                 return basename
         else:
@@ -653,11 +672,19 @@ class SingleSliceRunner(_NabuBaseReconstructor):
                         "db" + str(db).zfill(4),
                     )
                 )
+            elif ctf:
+                return "_".join(
+                    (
+                        basename + "slice_ctf",
+                        str(slice_index).zfill(4),
+                        "db" + str(db).zfill(4),
+                    )
+                )
             else:
                 return "_".join((basename + "slice", str(slice_index).zfill(4)))
 
     @docstring(_NabuBaseReconstructor)
-    def _get_file_basename_reconstruction(self, pag, db):
+    def _get_file_basename_reconstruction(self, pag, db, ctf):
         """
 
         :param TomwerScanBase scan: scan reconstructed
@@ -669,7 +696,7 @@ 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
+            scan=self.scan, db=db, pag=pag, slice_index=self.slice_index, ctf=ctf
         )
 
 

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

@@ -36,6 +36,7 @@ from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from . import utils
 from . import settings
 from nabu.pipeline.config import generate_nabu_configfile
@@ -94,15 +95,18 @@ def run_volume_reconstruction(
     else:
         target = Target.SLURM
 
+    # beam shape is not directly used by nabu (uses ctf_geometry directly)
+    config.get("phase", {}).pop("beam_shape", None)
+
     config_volume = copy.copy(config)
     config_nabu_slices = copy.deepcopy(scan.nabu_recons_params)
     if "tomwer_slices" in config_nabu_slices:
         del config_nabu_slices["tomwer_slices"]
 
     if "phase" in config_nabu_slices and "delta_beta" in config_nabu_slices["phase"]:
-        pag_dbs = utils.retrieve_lst_of_value_from_str(
-            config_nabu_slices["phase"]["delta_beta"], type_=float
-        )
+        pag_dbs = config_nabu_slices["phase"]["delta_beta"]
+        if isinstance(pag_dbs, str):
+            pag_dbs = utils.retrieve_lst_of_value_from_str(pag_dbs, type_=float)
         if len(pag_dbs) > 1:
             raise ValueError(
                 "Several value of delta / beta found for volume reconstruction"
@@ -336,7 +340,7 @@ class VolumeRunner(_NabuBaseReconstructor):
         return config_s, extra_opts
 
     @docstring(_NabuBaseReconstructor)
-    def _get_file_basename_reconstruction(self, pag, db):
+    def _get_file_basename_reconstruction(self, pag, db, ctf):
         """
 
         :param TomwerScanBase scan: scan reconstructed
@@ -348,6 +352,7 @@ class VolumeRunner(_NabuBaseReconstructor):
         :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):
             basename, _ = os.path.splitext(self.scan.master_file)
             basename = os.path.basename(basename)
@@ -355,14 +360,19 @@ class VolumeRunner(_NabuBaseReconstructor):
             basename = os.path.basename(self.scan.path)
         if pag:
             return "_".join((basename + "pag", "db" + str(db).zfill(4), "vol"))
+        elif ctf:
+            return "_".join((basename + "ctf", "db" + str(db).zfill(4), "vol"))
         else:
             return "_".join((basename, "vol"))
 
 
 class NabuVolume(
     Task,
-    input_names=("data", "nabu_params"),
-    optional_input_names=("nabu_volume_params",),
+    input_names=("data",),
+    optional_input_names=(
+        "nabu_params",
+        "nabu_volume_params",
+    ),
     output_names=("data", "volumes"),
 ):
     def __init__(
@@ -379,12 +389,13 @@ class NabuVolume(
         self._dry_run = inputs.get("dry_run", False)
 
     def run(self):
-        scan = self.inputs.data
-        if self.inputs.nabu_params is None:
-            raise ValueError("nabu params should be provided")
+        scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
             self.outputs.data = None
             return
+        nabu_params = self.inputs.nabu_params
+        if nabu_params is None:
+            nabu_params = scan.nabu_params
         if isinstance(scan, TomwerScanBase):
             scan = scan
         elif isinstance(scan, dict):
@@ -398,6 +409,7 @@ class NabuVolume(
                 'registered. Did you process "Nabu slices" '
                 "already ?"
             )
+        print("configuration params to be used are", scan.nabu_recons_params)
 
         run_volume_reconstruction(
             scan=scan,
@@ -440,9 +452,6 @@ class NabuVolume(
     def dry_run(self):
         return self._dry_run
 
-    def pathReceived(self, scan):
-        return self.process(scan=scan)
-
     @staticmethod
     def retrieve_last_relative_cor(scan):
         with EntryReader(scan.process_file_url) as h5f:

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

@@ -78,7 +78,10 @@ def retrieve_lst_of_value_from_str(my_string: str, type_) -> tuple:
     :param str mystring:
     :return: list of single value
     """
-    assert type(my_string) is str, "work on string only"
+    if not isinstance(my_string, str):
+        raise TypeError(
+            f"my_string is expected to be a string. {type(my_string)} provided"
+        )
     res = []
     my_string = my_string.replace("(", "")
     my_string = my_string.replace(")", "")
@@ -360,12 +363,20 @@ class _NabuPhaseMethod(_Enum):
     """
 
     PAGANIN = "Paganin"
+    CTF = "CTF"
     NONE = "None"
 
     @classmethod
     def from_value(cls, value):
         if value in (None, ""):
             return _NabuPhaseMethod.NONE
+        elif isinstance(value, str):
+            if value.lower() == "paganin":
+                return _NabuPhaseMethod.PAGANIN
+            elif value.lower() == "none":
+                return _NabuPhaseMethod.NONE
+            elif value.lower() == "ctf":
+                return _NabuPhaseMethod.CTF
         else:
             return super().from_value(value=value)
 

tomwer/core/process/reconstruction/normalization/normalization.py

@@ -34,22 +34,23 @@ __license__ = "MIT"
 __date__ = "25/06/2021"
 
 
+import numpy
+import logging
+import functools
+from silx.io.url import DataUrl
+import tomwer.version
 from tomwer.core.process.task import Task
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 from .params import (
     SinoNormalizationParams,
     _ValueCalculationFct,
     _ValueSource,
 )
 from tomoscan.normalization import Method as NormMethod
-from processview.core.superviseprocess import SuperviseProcess
-from silx.io.url import DataUrl
-from processview.core.dataset import DatasetIdentifier
 import tomoscan.esrf.scan.utils
-import tomwer.version
 from tomoscan.esrf.scan.utils import get_data
-import functools
-import numpy
-import logging
+from processview.core.dataset import DatasetIdentifier
+from processview.core.superviseprocess import SuperviseProcess
 
 
 _logger = logging.getLogger(__name__)
@@ -94,7 +95,7 @@ class SinoNormalizationTask(
         self.set_properties(configuration)
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
             return
         extra_infos = scan.intensity_normalization.get_extra_infos()

tomwer/core/process/reconstruction/saaxis/saaxis.py

@@ -32,15 +32,26 @@ __license__ = "MIT"
 __date__ = "10/02/2021"
 
 
+import os
+import copy
+import h5py
+import numpy
+import logging
+from typing import Iterable, Optional
 from silx.io.url import DataUrl
+from tomoscan.io import HDF5File
+from processview.core.manager import ProcessManager, DatasetState
+from processview.core.superviseprocess import SuperviseProcess
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.core.scan.scanfactory import ScanFactory
 from tomwer.core.process.reconstruction.nabu.nabuslices import (
     SingleSliceRunner,
     interpret_tomwer_configuration,
 )
-from typing import Iterable, Optional
-
 from tomwer.core.utils.slurm import is_slurm_available
 from tomwer.core.volume.volumefactory import VolumeFactory
 from tomwer.io.utils.utils import get_slice_data
@@ -50,25 +61,18 @@ from .params import ReconstructionMode
 from .params import SAAxisParams
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils import logconfig
-from processview.core.manager import ProcessManager, DatasetState
-from processview.core.superviseprocess import SuperviseProcess
 from tomwer.core.process.task import Task
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
-from tomoscan.io import HDF5File
 import tomwer.version
-import numpy
 from tomwer.core.progress import Progress
 from tomwer.core.process.reconstruction.axis import AxisRP
-import os
-import logging
-import copy
-import h5py
 from tomwer.core.process.reconstruction.scores import compute_score
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores import get_disk_mask_radius, apply_roi
 from tomwer.core.process.reconstruction.nabu.nabuscores import (
     run_nabu_one_slice_several_config,
 )
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 
 _logger = logging.getLogger(__name__)
@@ -145,12 +149,16 @@ def one_slice_several_cor(
         output_dir = os.path.join(scan.path, DEFAULT_RECONS_FOLDER)
 
     db = None
-    pag = None
+    pag = False
+    ctf = False
     if "phase" in nabu_config:
-        if "method" in nabu_config["phase"] and nabu_config["phase"]["method"] != "":
-            if "delta_beta" in nabu_config["phase"]:
-                pag = True
-                db = round(float(nabu_config["phase"]["delta_beta"]))
+        phase_method = nabu_config["phase"].get("method", "").lower()
+        if phase_method in ("pag", "paganin"):
+            pag = True
+        elif phase_method in ("ctf",):
+            ctf = True
+        if "delta_beta" in nabu_config["phase"]:
+            db = round(float(nabu_config["phase"]["delta_beta"]))
 
     for cor, future_tomo_obj in future_tomo_objs.items():
         future_tomo_obj.results()
@@ -159,7 +167,11 @@ def one_slice_several_cor(
             continue
         else:
             _file_name = SingleSliceRunner.get_file_basename_reconstruction(
-                scan=scan, slice_index=slice_index, pag=pag, db=db
+                scan=scan,
+                slice_index=slice_index,
+                pag=pag,
+                db=db,
+                ctf=ctf,
             )
             file_prefix = "cor_{}_{}".format(_file_name, cor)
 
@@ -256,7 +268,7 @@ def one_slice_several_cor(
                 urls = tuple(volume.browse_data_urls())
                 if len(urls) != 1:
                     raise ValueError(
-                        "volume is expected to have at most one url (single slice volume)"
+                        f"volume is expected to have at most one url (single slice volume). get {len(urls)}"
                     )
                 url = urls[0]
                 if not isinstance(url, (DataUrl, str)):
@@ -463,7 +475,7 @@ class SAAxisProcess(
             )
 
     @staticmethod
-    def autofocus(scan):
+    def autofocus(scan) -> Optional[float]:
         scores = scan.saaxis_params.scores
         if scores is None:
             return
@@ -482,9 +494,10 @@ class SAAxisProcess(
             scan.axis_params = AxisRP()
         scan.axis_params.frame_width = scan.dim_1
         scan.axis_params.set_relative_value(best_cor)
+        return best_cor
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
             self.outputs.data = None
             return
@@ -535,7 +548,20 @@ class SAAxisProcess(
             process_id=self.process_id,
         )
         scan.saaxis_params.scores = cors_res
-        self.autofocus(scan=scan)
+        best_relative_cor = self.autofocus(scan=scan)
+
+        # store nabu settings to be used later like in the volume reconstruction
+        config = self.get_configuration()["nabu_params"]
+        # beam shape is not directly used by nabu (uses ctf_geometry directly)
+        config.get("phase", {}).pop("beam_shape", None)
+
+        # update nabu recons_params used
+        sc_config = get_default_nabu_config(nabu_fullfield_default_config)
+        sc_config.update(config)
+        scan.nabu_recons_params = sc_config
+        if best_relative_cor is not None:
+            scan.axis_params.relative_cor_values = best_relative_cor
+
         self._process_end(scan=scan, cors_res=cors_res, score_rois=rois)
         self.outputs.data = scan
 

tomwer/core/process/reconstruction/sadeltabeta/sadeltabeta.py

@@ -32,7 +32,18 @@ __license__ = "MIT"
 __date__ = "28/10/2021"
 
 
+import os
+import logging
+import h5py
+import numpy
 from copy import copy
+from typing import Optional, Union
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
+from processview.core.manager import ProcessManager, DatasetState
+from processview.core.superviseprocess import SuperviseProcess
 from tomwer.core.process.reconstruction.nabu.nabucommon import (
     ResultSlurmRun,
     ResultsLocalRun,
@@ -42,8 +53,6 @@ from tomwer.core.scan.scanfactory import ScanFactory
 from .params import SADeltaBetaParams
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.utils import logconfig
-from processview.core.manager import ProcessManager, DatasetState
-from processview.core.superviseprocess import SuperviseProcess
 from tomwer.core.process.task import Task
 from tomwer.core.scan.hdf5scan import HDF5TomoScan
 from tomoscan.io import HDF5File
@@ -54,11 +63,6 @@ from tomwer.core.process.reconstruction.nabu.nabuslices import (
 )
 from tomwer.core.process.reconstruction.nabu.nabucommon import ResultsRun
 from tomwer.core.progress import Progress
-from typing import Optional, Union
-import os
-import logging
-import h5py
-import numpy
 from ..nabu import utils as nabu_utils
 from tomwer.core.process.reconstruction.scores import compute_score
 from tomwer.core.process.reconstruction.scores import ScoreMethod
@@ -66,6 +70,7 @@ from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores import get_disk_mask_radius, apply_roi
 from tomwer.core.process.reconstruction.nabu.nabuslices import SingleSliceRunner
 from tomwer.core.volume.volumefactory import VolumeFactory
+from tomwer.core.utils.scanutils import data_identifier_to_scan
 
 _logger = logging.getLogger(__name__)
 
@@ -156,7 +161,9 @@ def one_slice_several_db(
         config["output"]["file_format"] = "hdf5"
         if "phase" not in config:
             config["phase"] = {}
-        config["phase"]["delta_beta"] = db
+        config["phase"]["delta_beta"] = (
+            db,
+        )  # warning: at this tage delta_beta expects a list of value
         config["phase"]["method"] = "Paganin"
         res = run_single_slice_reconstruction(
             nabu_config=config,
@@ -185,9 +192,13 @@ def one_slice_several_db(
             advancement.increaseAdvancement(1)
 
     pag = False
+    ctf = False
     if "phase" in config:
-        if "method" in config["phase"] and config["phase"]["method"] != "":
+        phase_method = config["phase"].get("method", "").lower()
+        if phase_method in ("pag", "paganin"):
             pag = True
+        elif phase_method in ("ctf",):
+            ctf = True
 
     # treat future.
     for db, future_tomo_obj_list in future_tomo_objs.items():
@@ -203,6 +214,7 @@ def one_slice_several_db(
             slice_index=slice_index,
             pag=pag,
             db=int(db) if db is not None else None,
+            ctf=ctf,
         )
         # retrieve url
         volume_identifier = nabu_utils.get_recons_volume_identifier(
@@ -371,7 +383,7 @@ class SADeltaBetaProcess(
             )
 
     @staticmethod
-    def autofocus(scan):
+    def autofocus(scan) -> Optional[float]:
         scores = scan.sa_delta_beta_params.scores
         if scores is None:
             return
@@ -387,9 +399,10 @@ class SADeltaBetaProcess(
                 best_db, best_score = cor, score
         scan.sa_delta_beta_params.autofocus = best_db
         scan.sa_delta_beta_params.value = best_db
+        return best_db
 
     def run(self):
-        scan = self.inputs.data
+        scan = data_identifier_to_scan(self.inputs.data)
         if scan is None:
             self.outputs.data = scan
             return
@@ -418,7 +431,20 @@ class SADeltaBetaProcess(
             process_id=self.process_id,
         )
         scan.sa_delta_beta_params.scores = db_res
-        self.autofocus(scan=scan)
+        best_db = self.autofocus(scan=scan)
+        # store nabu recons parameters to be used within the nabu volume for example.
+        config = self.get_configuration()["nabu_params"]
+        # beam shape is not directly used by nabu (uses ctf_geometry directly)
+        config.get("phase", {}).pop("beam_shape", None)
+        sc_config = get_default_nabu_config(nabu_fullfield_default_config)
+        sc_config.update(config)
+        if best_db is not None:
+            sc_config["phase"]["delta_beta"] = (
+                best_db,
+            )  # warning: at this tage delta_beta expects a list of value
+        scan.nabu_recons_params = sc_config
+
+        # end processing
         self._process_end(scan=scan, db_res=db_res, score_rois=rois)
         self.outputs.data = scan
 

tomwer/core/process/reconstruction/test/__init__.py

@@ -1,39 +0,0 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2017 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.
-#
-# ###########################################################################*/
-
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "02/08/2017"
-
-import unittest
-
-from . import test_saaxis
-
-
-def suite():
-    test_suite = unittest.TestSuite()
-    test_suite.addTest(test_saaxis.suite())
-
-    return test_suite

tomwer/core/process/reconstruction/test/test_axis_params.py

@@ -1,6 +1,9 @@
 import os
 import pytest
-from tomwer.core.process.reconstruction.axis.params import AxisResource
+from tomwer.core.process.reconstruction.axis.params import (
+    AxisResource,
+    AxisCalculationInput,
+)
 from tomwer.core.utils.scanutils import MockHDF5
 import numpy
 
@@ -22,7 +25,8 @@ def test_axis_resource(tmp_path):
     first_proj = list(scan.projections.keys())[0]
     data_url = scan.projections[first_proj]
 
-    axis_resource = AxisResource(data_url)
+    axis_resource = AxisResource(url=data_url)
+    assert axis_resource.data is not None
 
     with pytest.raises(TypeError):
         axis_resource.normalize_data(scan=None, log_=True)
@@ -34,4 +38,22 @@ def test_axis_resource(tmp_path):
 
     assert isinstance(axis_resource.normalized_data_paganin, numpy.ndarray)
 
-    assert isinstance(axis_resource.normalized_data_paganin, numpy.ndarray)
+    assert isinstance(str(axis_resource), str)
+    axis_resource.data = None
+    assert axis_resource is not None
+
+
+def test_AxisCalculationInput():
+    """test all class AxisCalculationInput which is a bit 'malformed'"""
+    assert (
+        AxisCalculationInput.from_value("transmission_withpag")
+        is AxisCalculationInput.transmission_pag
+    )
+    assert (
+        AxisCalculationInput.from_value("transmission_nopag")
+        is AxisCalculationInput.transmission
+    )
+    assert (
+        AxisCalculationInput.from_value("transmission")
+        is AxisCalculationInput.transmission
+    )