httomo-backends 1.0.1__tar.gz → 1.1.0__tar.gz

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomo-backends
-Version: 1.0.1
+Version: 1.1.0
 Summary: Supplementary files for HTTomo backends.
 Author: Garry ODonnell, Jacob Williamson
 Author-email: Daniil Kazantsev <daniil.kazantsev@diamond.ac.uk>, Yousef Moazzam <yousef.moazzam@diamond.ac.uk>, Jessica Verschoyle <jessica.verschoyle@diamond.ac.uk>, Naman Gera <naman.gera@diamond.ac.uk>, scientificsoftware@diamond.ac.uk

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/cufft.py

@@ -2,7 +2,6 @@ import ctypes
 import sys
 from enum import Enum
 
-
 if "linux" not in sys.platform:
     raise RuntimeError("Linux is currently the only supported platform")
 

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/httomolibgpu.yaml

@@ -227,6 +227,15 @@ recon:
       memory_gpu:
         multiplier: None
         method: module
+    ADMM3d_tomobar:
+      pattern: sinogram
+      output_dims_change: True
+      implementation: gpu_cupy
+      save_result_default: True
+      padding: True
+      memory_gpu:
+        multiplier: None
+        method: module
   rotation:
     find_center_vo:
       pattern: projection

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/misc/corr.py

@@ -1,5 +1,7 @@
+import inspect
 from typing import Tuple
 
+from httomolibgpu.misc.corr import median_filter, remove_outlier
 
 __all__ = [
     "_calc_padding_remove_outlier",
@@ -8,10 +10,18 @@ __all__ = [
 
 
 def _calc_padding_remove_outlier(**kwargs) -> Tuple[int, int]:
+    if "kernel_size" not in kwargs:
+        params = inspect.signature(remove_outlier).parameters
+        kwargs["kernel_size"] = params["kernel_size"].default
+
     kernel_size = kwargs["kernel_size"]
     return (kernel_size // 2, kernel_size // 2)
 
 
 def _calc_padding_median_filter(**kwargs) -> Tuple[int, int]:
+    if "kernel_size" not in kwargs:
+        params = inspect.signature(median_filter).parameters
+        kwargs["kernel_size"] = params["kernel_size"].default
+
     kernel_size = kwargs["kernel_size"]
     return (kernel_size // 2, kernel_size // 2)

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/misc/denoise.py

@@ -1,6 +1,5 @@
 from typing import Tuple
 
-
 __all__ = [
     "_calc_padding_total_variation_ROF",
     "_calc_padding_total_variation_PD",

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/misc/morph.py

@@ -20,10 +20,13 @@
 # ---------------------------------------------------------------------------
 """Modules for memory estimation for morph functions"""
 
+import inspect
 import math
 from typing import Tuple
 import numpy as np
 
+from httomolibgpu.misc.morph import data_resampler, sino_360_to_180
+
 __all__ = [
     "_calc_memory_bytes_data_resampler",
     "_calc_output_dim_data_resampler",
@@ -42,6 +45,10 @@ def _calc_memory_bytes_data_resampler(
     **kwargs,
 ) -> Tuple[int, int]:
     newshape = kwargs["newshape"]
+
+    if "interpolation" not in kwargs:
+        params = inspect.signature(data_resampler).parameters
+        kwargs["interpolation"] = params["interpolation"].default
     interpolation = kwargs["interpolation"]
 
     input_size = np.prod(non_slice_dims_shape) * dtype.itemsize
@@ -62,7 +69,9 @@ def _calc_output_dim_sino_360_to_180(
     non_slice_dims_shape: Tuple[int, int],
     **kwargs,
 ) -> Tuple[int, int]:
-    assert "overlap" in kwargs, "Expected overlap in method parameters"
+    if "overlap" not in kwargs:
+        params = inspect.signature(sino_360_to_180).parameters
+        kwargs["overlap"] = params["overlap"].default
     overlap: float = kwargs["overlap"]
 
     original_sino_width = non_slice_dims_shape[1]
@@ -75,7 +84,9 @@ def _calc_memory_bytes_sino_360_to_180(
     dtype: np.dtype,
     **kwargs,
 ) -> Tuple[int, int]:
-    assert "overlap" in kwargs, "Expected overlap in method parameters"
+    if "overlap" not in kwargs:
+        params = inspect.signature(sino_360_to_180).parameters
+        kwargs["overlap"] = params["overlap"].default
     overlap: float = kwargs["overlap"]
 
     original_sino_width = non_slice_dims_shape[1]

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/misc/rescale.py

@@ -1,6 +1,9 @@
+import inspect
 from typing import Tuple
 import numpy as np
 
+from httomolibgpu.misc.rescale import rescale_to_int
+
 __all__ = [
     "_calc_memory_bytes_rescale_to_int",
 ]
@@ -11,6 +14,9 @@ def _calc_memory_bytes_rescale_to_int(
     dtype: np.dtype,
     **kwargs,
 ) -> Tuple[int, int]:
+    if "bits" not in kwargs:
+        params = inspect.signature(rescale_to_int).parameters
+        kwargs["bits"] = params["bits"].default
     bits: int = kwargs["bits"]
     if bits == 8:
         itemsize = 1

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/prep/normalize.py

@@ -1,7 +1,6 @@
 from typing import Tuple
 import numpy as np
 
-
 __all__ = [
     "_calc_memory_bytes_dark_flat_field_correction",
 ]

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/prep/stripe.py

@@ -20,13 +20,13 @@
 # ---------------------------------------------------------------------------
 """Modules for memory estimation for stripe removal methods"""
 
+import inspect
 import math
 from typing import Tuple
 import numpy as np
 
 from httomo_backends.cufft import CufftType, cufft_estimate_1d
-from httomolibgpu.prep.stripe import remove_stripe_fw
-
+from httomolibgpu.prep.stripe import raven_filter, remove_stripe_fw
 
 __all__ = [
     "_calc_memory_bytes_for_slices_remove_stripe_fw",
@@ -87,7 +87,14 @@ def _calc_memory_bytes_raven_filter(
     **kwargs,
 ) -> Tuple[int, int]:
 
+    if "pad_x" not in kwargs:
+        params = inspect.signature(raven_filter).parameters
+        kwargs["pad_x"] = params["pad_x"].default
     pad_x = kwargs["pad_x"]
+
+    if "pad_y" not in kwargs:
+        params = inspect.signature(raven_filter).parameters
+        kwargs["pad_y"] = params["pad_y"].default
     pad_y = kwargs["pad_y"]
 
     # Unpadded input

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/recon/algorithm.py

@@ -24,6 +24,7 @@ import math
 from typing import Tuple
 import numpy as np
 from httomo_backends.cufft import CufftType, cufft_estimate_1d, cufft_estimate_2d
+from httomolibgpu.recon.algorithm import ADMM3d_tomobar
 
 __all__ = [
     "_calc_memory_bytes_FBP3d_tomobar",
@@ -31,13 +32,16 @@ __all__ = [
     "_calc_memory_bytes_SIRT3d_tomobar",
     "_calc_memory_bytes_CGLS3d_tomobar",
     "_calc_memory_bytes_FISTA3d_tomobar",
+    "_calc_memory_bytes_ADMM3d_tomobar",
     "_calc_output_dim_FBP2d_astra",
     "_calc_output_dim_FBP3d_tomobar",
     "_calc_output_dim_LPRec3d_tomobar",
     "_calc_output_dim_SIRT3d_tomobar",
     "_calc_output_dim_CGLS3d_tomobar",
     "_calc_output_dim_FISTA3d_tomobar",
+    "_calc_output_dim_ADMM3d_tomobar",
     "_calc_padding_FISTA3d_tomobar",
+    "_calc_padding_ADMM3d_tomobar",
 ]
 
 
@@ -45,6 +49,10 @@ def _calc_padding_FISTA3d_tomobar(**kwargs) -> Tuple[int, int]:
     return (5, 5)
 
 
+def _calc_padding_ADMM3d_tomobar(**kwargs) -> Tuple[int, int]:
+    return (5, 5)
+
+
 def __calc_output_dim_recon(non_slice_dims_shape, **kwargs):
     """Function to calculate output dimensions for all reconstructors.
     The change of the dimension depends either on the user-provided "recon_size"
@@ -52,7 +60,7 @@ def __calc_output_dim_recon(non_slice_dims_shape, **kwargs):
 
     """
     DetectorsLengthH = non_slice_dims_shape[1]
-    recon_size = kwargs["recon_size"]
+    recon_size = kwargs.get("recon_size", None)
     if recon_size is None:
         recon_size = DetectorsLengthH
     output_dims = (recon_size, recon_size)
@@ -83,6 +91,10 @@ def _calc_output_dim_FISTA3d_tomobar(non_slice_dims_shape, **kwargs):
     return __calc_output_dim_recon(non_slice_dims_shape, **kwargs)
 
 
+def _calc_output_dim_ADMM3d_tomobar(non_slice_dims_shape, **kwargs):
+    return __calc_output_dim_recon(non_slice_dims_shape, **kwargs)
+
+
 def _calc_memory_bytes_FBP3d_tomobar(
     non_slice_dims_shape: Tuple[int, int],
     dtype: np.dtype,
@@ -604,6 +616,58 @@ def _calc_memory_bytes_FISTA3d_tomobar(
     return (tot_memory_bytes, 0)
 
 
+def _calc_memory_bytes_ADMM3d_tomobar(
+    non_slice_dims_shape: Tuple[int, int],
+    dtype: np.dtype,
+    **kwargs,
+) -> Tuple[int, int]:
+    detector_pad = 0
+    if "detector_pad" in kwargs:
+        detector_pad = kwargs["detector_pad"]
+    if detector_pad is True:
+        detector_pad = __estimate_detectorHoriz_padding(non_slice_dims_shape[1])
+    elif detector_pad is False:
+        detector_pad = 0
+
+    anglesnum = non_slice_dims_shape[0]
+    DetectorsLengthH_padded = non_slice_dims_shape[1] + 2 * detector_pad
+
+    # calculate the output shape
+    output_dims = _calc_output_dim_FISTA3d_tomobar(non_slice_dims_shape, **kwargs)
+    recon_data_size_original = (
+        np.prod(output_dims) * dtype.itemsize
+    )  # recon user-defined size
+
+    in_data_siz_pad = (anglesnum * DetectorsLengthH_padded) * dtype.itemsize
+    output_dims_larger_grid = (DetectorsLengthH_padded, DetectorsLengthH_padded)
+
+    out_data_size = np.prod(output_dims_larger_grid) * dtype.itemsize
+    x0 = out_data_size
+    x = out_data_size
+    z = out_data_size
+    u = out_data_size
+    grad_data = out_data_size
+    grad_admm = out_data_size
+    arithmetic = 3 * out_data_size
+
+    admm_part = (
+        recon_data_size_original
+        + in_data_siz_pad
+        + x0
+        + x
+        + z
+        + u
+        + grad_data
+        + grad_admm
+        + out_data_size
+        + arithmetic
+    )
+    regul_part = 8 * np.prod(output_dims_larger_grid) * dtype.itemsize
+
+    tot_memory_bytes = int(admm_part + regul_part)
+    return (tot_memory_bytes, 0)
+
+
 def __estimate_detectorHoriz_padding(detX_size) -> int:
     det_half = detX_size // 2
     padded_value_exact = int(np.sqrt(2 * (det_half**2))) - det_half

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/methods_database/packages/backends/tomopy/supporting_funcs/recon/algorithm.py

@@ -23,7 +23,6 @@
 from typing import Tuple
 import numpy as np
 
-
 __all__ = [
     "_calc_output_dim_recon",
 ]

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends/scripts/yaml_templates_generator.py

@@ -24,6 +24,7 @@
 Please run the generator as:
     python -m yaml_templates_generator -i /path/to/modules.yml -o /path/to/output/
 """
+
 import argparse
 import importlib
 import inspect

httomo_backends-1.1.0/httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.recon.algorithm/ADMM3d_tomobar.yaml

@@ -0,0 +1,17 @@
+- method: ADMM3d_tomobar
+  module_path: httomolibgpu.recon.algorithm
+  parameters:
+    center: ${{centering.side_outputs.centre_of_rotation}}
+    detector_pad: false
+    recon_size: null
+    recon_mask_radius: 0.95
+    iterations: 3
+    subsets_number: 24
+    initialisation: FBP
+    ADMM_rho_const: 1.0
+    ADMM_relax_par: 1.7
+    regularisation_type: PD_TV
+    regularisation_parameter: 0.0025
+    regularisation_iterations: 40
+    regularisation_half_precision: true
+    nonnegativity: false

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: httomo-backends
-Version: 1.0.1
+Version: 1.1.0
 Summary: Supplementary files for HTTomo backends.
 Author: Garry ODonnell, Jacob Williamson
 Author-email: Daniil Kazantsev <daniil.kazantsev@diamond.ac.uk>, Yousef Moazzam <yousef.moazzam@diamond.ac.uk>, Jessica Verschoyle <jessica.verschoyle@diamond.ac.uk>, Naman Gera <naman.gera@diamond.ac.uk>, scientificsoftware@diamond.ac.uk

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/httomo_backends.egg-info/SOURCES.txt

@@ -88,6 +88,7 @@ httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.prep.stripe/remove_all_
 httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.prep.stripe/remove_stripe_based_sorting.yaml
 httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.prep.stripe/remove_stripe_fw.yaml
 httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.prep.stripe/remove_stripe_ti.yaml
+httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.recon.algorithm/ADMM3d_tomobar.yaml
 httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.recon.algorithm/CGLS3d_tomobar.yaml
 httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.recon.algorithm/FBP2d_astra.yaml
 httomo_backends/yaml_templates/httomolibgpu/httomolibgpu.recon.algorithm/FBP3d_tomobar.yaml

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/pyproject.toml

@@ -24,7 +24,7 @@ dev_template = "{tag}"
 
 [project]
 name = "httomo-backends"
-version = "1.0.1"
+version = "1.1.0"
 description = "Supplementary files for HTTomo backends."
 readme = "README.rst"
 license = {text = "BSD-3-Clause"}

{httomo_backends-1.0.1 → httomo_backends-1.1.0}/tests/test_httomolibgpu.py

@@ -32,9 +32,11 @@ from httomolibgpu.recon.algorithm import (
     LPRec3d_tomobar,
     CGLS3d_tomobar,
     FISTA3d_tomobar,
+    ADMM3d_tomobar,
 )
 from httomolibgpu.misc.rescale import rescale_to_int
 
+from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_funcs.misc.corr import *
 from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_funcs.misc.morph import *
 from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_funcs.prep.phase import *
 from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_funcs.prep.stripe import *
@@ -43,7 +45,6 @@ from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_
 from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_funcs.misc.rescale import *
 from httomo_backends.methods_database.packages.backends.httomolibgpu.supporting_funcs.prep.normalize import *
 
-
 module_mem_path = "httomo.methods_database.packages.external."
 
 
@@ -99,7 +100,7 @@ def test_dark_flat_field_correction_memoryhook(
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = (
+    estimated_memory_bytes, subtract_bytes = (
         _calc_memory_bytes_dark_flat_field_correction(data.shape[1:], dtype=data.dtype)
     )
 
@@ -430,7 +431,7 @@ def test_remove_stripe_ti_memoryhook(slices, ensure_clean_memory):
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_remove_stripe_ti(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_remove_stripe_ti(
         (dim_x, dim_y), dtype=np.float32()
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -494,7 +495,7 @@ def test_raven_filter_memoryhook(projections, ensure_clean_memory):
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_raven_filter(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_raven_filter(
         (projections, horiz_det), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(vert_det * estimated_memory_bytes / (1024**2), 2)
@@ -527,7 +528,7 @@ def test_remove_all_stripe_memoryhook(angles, dim_x_slices, dim_y, ensure_clean_
     max_mem_mb = round(max_mem / (1024**2), 2)  # now in mbs
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_remove_all_stripe(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_remove_all_stripe(
         (angles, dim_y), dtype=np.float32()
     )
     estimated_memory_mb = round(dim_x_slices * estimated_memory_bytes / (1024**2), 2)
@@ -565,7 +566,7 @@ def test_data_sampler_memoryhook(slices, newshape, interpolation, ensure_clean_m
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_data_resampler(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_data_resampler(
         (recon_size, recon_size), dtype=np.float32(), **kwargs
     )
     # as this is slice-by-slice implementation we should be adding slices number
@@ -623,7 +624,7 @@ def test_recon_FBP3d_tomobar_memoryhook(
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_FBP3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_FBP3d_tomobar(
         (projections, detectorX), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -779,7 +780,7 @@ def __test_recon_LPRec3d_tomobar_memoryhook_common(
     input_data_type = np.float32()
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_LPRec3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_LPRec3d_tomobar(
         non_slice_dims_shape, dtype=input_data_type, **kwargs
     )
 
@@ -830,7 +831,7 @@ def test_recon_SIRT3d_tomobar_memoryhook(slices, recon_size_it, ensure_clean_mem
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_SIRT3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_SIRT3d_tomobar(
         (1801, 2560), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -877,7 +878,7 @@ def test_recon_SIRT3d_tomobar_autopad_memoryhook(
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_SIRT3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_SIRT3d_tomobar(
         (angles_tot, det_size), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -922,7 +923,7 @@ def test_recon_CGLS3d_tomobar_memoryhook(slices, recon_size_it, ensure_clean_mem
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_CGLS3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_CGLS3d_tomobar(
         (angles_tot, det_size), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -969,7 +970,7 @@ def test_recon_CGLS3d_tomobar_autopad_memoryhook(
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_CGLS3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_CGLS3d_tomobar(
         (angles_tot, det_size), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -1018,7 +1019,7 @@ def test_recon_FISTA3d_tomobar_nonOS_memoryhook(
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_FISTA3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_FISTA3d_tomobar(
         (angles_total, detX_size), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -1034,6 +1035,65 @@ def test_recon_FISTA3d_tomobar_nonOS_memoryhook(
     assert percents_relative_maxmem <= 100
 
 
+@pytest.mark.cupy
+@pytest.mark.parametrize("slices", [3, 5])
+@pytest.mark.parametrize("recon_size_it", [2560])
+@pytest.mark.parametrize("padding", [0, 100, 200, True])
+@pytest.mark.parametrize("subsets", [1, 6])
+@pytest.mark.parametrize("initialisation", ["FBP", None])
+def test_recon_ADMM3d_tomobar_memoryhook(
+    slices, recon_size_it, padding, subsets, initialisation, ensure_clean_memory
+):
+    angles_total = 901
+    detX_size = 2560
+    data = cp.random.random_sample((angles_total, slices, detX_size), dtype=np.float32)
+
+    hook = MaxMemoryHook()
+    with hook:
+        recon_data = ADMM3d_tomobar(
+            cp.copy(data),
+            np.linspace(0.0 * np.pi / 180.0, 180.0 * np.pi / 180.0, data.shape[0]),
+            center=1200,
+            recon_size=recon_size_it,
+            iterations=1,
+            subsets_number=subsets,
+            regularisation_iterations=2,
+            nonnegativity=True,
+            detector_pad=padding,
+            initialisation=initialisation,
+        )
+
+    # make sure estimator function is within range (80% min, 100% max)
+    max_mem = (
+        hook.max_mem
+    )  # the amount of memory in bytes needed for the method according to memoryhook
+
+    # now we estimate how much of the total memory required for this data
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_ADMM3d_tomobar(
+        (angles_total, detX_size),
+        dtype=np.float32(),
+        center=1200,
+        recon_size=recon_size_it,
+        iterations=1,
+        subsets_number=subsets,
+        regularisation_iterations=2,
+        nonnegativity=True,
+        detector_pad=padding,
+        initialisation=initialisation,
+    )
+    estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
+    max_mem -= subtract_bytes
+    max_mem_mb = round(max_mem / (1024**2), 2)
+
+    # now we compare both memory estimations
+    difference_mb = abs(estimated_memory_mb - max_mem_mb)
+    percents_relative_maxmem = round((difference_mb / max_mem_mb) * 100)
+    # the estimated_memory_mb should be LARGER or EQUAL to max_mem_mb
+    # the resulting percent value should not deviate from max_mem on more than 20%
+    assert estimated_memory_mb >= max_mem_mb
+    assert percents_relative_maxmem <= 50
+
+
 @pytest.mark.cupy
 @pytest.mark.parametrize("slices", [3, 5])
 @pytest.mark.parametrize("recon_size_it", [2560])
@@ -1066,7 +1126,7 @@ def test_recon_FISTA3d_tomobar_OS_memoryhook(
     )  # the amount of memory in bytes needed for the method according to memoryhook
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_FISTA3d_tomobar(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_FISTA3d_tomobar(
         (angles_total, detX_size), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -1105,7 +1165,7 @@ def test_rescale_to_int_memoryhook(
     max_mem_mb = round(max_mem / (1024**2), 2)
 
     # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_rescale_to_int(
+    estimated_memory_bytes, subtract_bytes = _calc_memory_bytes_rescale_to_int(
         (data.shape[0], data.shape[2]), dtype=np.float32(), **kwargs
     )
     estimated_memory_mb = round(slices * estimated_memory_bytes / (1024**2), 2)
@@ -1140,7 +1200,7 @@ def test_sino_360_to_180_memoryhook(
         sino_360_to_180(cp.copy(data), overlap)
 
     # Call memory estimator to estimate memory usage
-    (estimated_bytes, subtract_bytes) = _calc_memory_bytes_sino_360_to_180(
+    estimated_bytes, subtract_bytes = _calc_memory_bytes_sino_360_to_180(
         non_slice_dims_shape=(shape[0], shape[2]),
         dtype=np.float32(),
         overlap=overlap,
@@ -1166,3 +1226,94 @@ def test_FBP2d_astra_output_dim():
         recon_size=recon_size,
     )
     assert output_dims == (recon_size, recon_size)
+
+
+def test_remove_outlier_padding_calculator_fetches_default_param_value():
+    try:
+        _calc_padding_remove_outlier(**{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_median_filter_padding_calculator_fetches_default_param_value():
+    try:
+        _calc_padding_median_filter(**{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_data_resampler_memory_estimator_fetches_default_param_value():
+    try:
+        _calc_memory_bytes_data_resampler((2, 2), np.float32(), **{"newshape": (1, 1)})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_sino_360_to_180_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_sino_360_to_180((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_sino_360_to_180_memory_estimator_fetches_default_param_value():
+    try:
+        _calc_memory_bytes_sino_360_to_180((1, 1), np.float32(), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_rescale_to_int_memory_estimator_fetches_default_param_value():
+    try:
+        _calc_memory_bytes_rescale_to_int((1, 1), np.float32(), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_raven_filter_memory_estimator_fetches_default_param_value():
+    try:
+        _calc_memory_bytes_raven_filter((1, 1), np.float32(), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_FBP2d_astra_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_FBP2d_astra((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_FBP3d_tomobar_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_FBP3d_tomobar((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_LPRec3d_tomobar_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_LPRec3d_tomobar((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_SIRT3d_tomobar_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_SIRT3d_tomobar((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_CGLS3d_tomobar_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_CGLS3d_tomobar((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")
+
+
+def test_FISTA3d_tomobar_output_dims_calculator_fetches_default_param_value():
+    try:
+        _calc_output_dim_FISTA3d_tomobar((1, 1), **{})
+    except KeyError as e:
+        pytest.fail(f"Failed to get default value for {e} parameter")