Merge pull request #66 from DiamondLightSource/remove_paganin_savu

Remove paganin savu

Author: dkazanc

httomo_backends/methods_database/packages/backends/httomolibgpu/httomolibgpu.yaml

@@ -87,15 +87,6 @@ prep:
       memory_gpu:
         multiplier: None
         method: module
-    paganin_filter_savu:
-      pattern: projection
-      output_dims_change: False
-      implementation: gpu_cupy
-      save_result_default: False
-      padding: False
-      memory_gpu:
-        multiplier: None
-        method: module
   alignment:
     distortion_correction_proj_discorpy:
       pattern: projection

httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/prep/phase.py

@@ -27,70 +27,10 @@
 from httomo_backends.cufft import CufftType, cufft_estimate_2d
 
 __all__ = [
-    "_calc_memory_bytes_paganin_filter_savu",
     "_calc_memory_bytes_paganin_filter_tomopy",
 ]
 
 
-def _calc_memory_bytes_paganin_filter_savu(
-    non_slice_dims_shape: Tuple[int, int],
-    dtype: np.dtype,
-    **kwargs,
-) -> Tuple[int, int]:
-    pad_x = kwargs["pad_x"]
-    pad_y = kwargs["pad_y"]
-
-    # Input (unpadded)
-    unpadded_in_slice_size = np.prod(non_slice_dims_shape) * dtype.itemsize
-
-    # Padded input
-    padded_non_slice_dims_shape = (
-        non_slice_dims_shape[0] + 2 * pad_y,
-        non_slice_dims_shape[1] + 2 * pad_x,
-    )
-    padded_in_slice_size = (
-        padded_non_slice_dims_shape[0] * padded_non_slice_dims_shape[1] * dtype.itemsize
-    )
-
-    # Padded input cast to `complex64`
-    complex_slice = padded_in_slice_size / dtype.itemsize * np.complex64().nbytes
-
-    # Plan size for 2D FFT
-    fftplan_slice_size = cufft_estimate_2d(
-        nx=padded_non_slice_dims_shape[1],
-        ny=padded_non_slice_dims_shape[0],
-        fft_type=CufftType.CUFFT_C2C,
-    )
-
-    # Shape of 2D filter is the same as the padded `complex64` slice shape, so the size will be
-    # the same
-    filter_size = complex_slice
-
-    # Size of cropped/unpadded + cast to float32 result of 2D IFFT
-    cropped_float32_res_slice = np.prod(non_slice_dims_shape) * np.float32().nbytes
-
-    # If the FFT plan size is negligible for some reason, this changes where the peak GPU
-    # memory usage occurs. Hence, the if/else branching below for calculating the total bytes.
-    NEGLIGIBLE_FFT_PLAN_SIZE = 16
-    if fftplan_slice_size < NEGLIGIBLE_FFT_PLAN_SIZE:
-        tot_memory_bytes = int(
-            unpadded_in_slice_size + padded_in_slice_size + complex_slice
-        )
-    else:
-        tot_memory_bytes = int(
-            unpadded_in_slice_size
-            + padded_in_slice_size
-            + complex_slice
-            # The padded float32 array is deallocated when a copy is made when casting to complex64
-            # and the variable `padded_tomo` is reassigned to the complex64 version
-            - padded_in_slice_size
-            + fftplan_slice_size
-            + cropped_float32_res_slice
-        )
-
-    return (tot_memory_bytes, filter_size)
-
-
 def _calc_memory_bytes_paganin_filter_tomopy(
     non_slice_dims_shape: Tuple[int, int],
     dtype: np.dtype,

httomo_backends/methods_database/packages/backends/httomolibgpu/supporting_funcs/recon/algorithm.py

@@ -354,6 +354,7 @@ def add_to_memory_counters(amount, per_slice: bool):
 
     return (tot_memory_bytes * 1.05, fixed_amount + 250 * 1024 * 1024)
 
+
 def _calc_memory_bytes_SIRT3d_tomobar(
     non_slice_dims_shape: Tuple[int, int],
     dtype: np.dtype,

httomo_backends/scripts/yaml_pipelines_generator.py

@@ -235,7 +235,7 @@ def yaml_pipelines_generator(
                 pipeline_full[i]["parameters"].yaml_add_eol_comment(
                     key="detector_pad",
                     comment="Horizontal detector padding to minimise circle/arc-type artifacts in the reconstruction",
-                )                
+                )
                 pipeline_full[i]["parameters"].yaml_add_eol_comment(
                     key="recon_mask_radius",
                     comment="Zero pixels outside the mask-circle radius.",

tests/test_httomolibgpu.py

@@ -15,7 +15,7 @@
 
 from httomolibgpu.misc.morph import data_resampler, sino_360_to_180
 from httomolibgpu.prep.normalize import normalize
-from httomolibgpu.prep.phase import paganin_filter_tomopy, paganin_filter_savu
+from httomolibgpu.prep.phase import paganin_filter_tomopy
 from httomolibgpu.prep.alignment import distortion_correction_proj_discorpy
 from httomolibgpu.prep.stripe import (
     remove_stripe_based_sorting,
@@ -257,48 +257,6 @@ def test_paganin_filter_tomopy_memoryhook(slices, dim_x, dim_y, ensure_clean_mem
     assert percents_relative_maxmem <= 20
 
 
-@pytest.mark.cupy
-@pytest.mark.parametrize("slices", [64, 128])
-@pytest.mark.parametrize("dim_x", [81, 260, 320])
-@pytest.mark.parametrize("dim_y", [340, 135, 96])
-def test_paganin_filter_savu_memoryhook(slices, dim_x, dim_y, ensure_clean_memory):
-    data = cp.random.random_sample((slices, dim_x, dim_y), dtype=np.float32)
-    kwargs = {}
-    kwargs["ratio"] = 250.0
-    kwargs["energy"] = 53.0
-    kwargs["distance"] = 1.0
-    kwargs["resolution"] = 1.28
-    kwargs["pad_x"] = 20
-    kwargs["pad_y"] = 20
-    kwargs["pad_method"] = "edge"
-    kwargs["increment"] = 0.0
-    hook = MaxMemoryHook()
-    with hook:
-        data_filtered = paganin_filter_savu(data, **kwargs).get()
-
-    # The amount of bytes used by the method's processing according to the memory hook, plus
-    # the amount of bytes needed to hold the method's input in GPU memory
-    max_mem = hook.max_mem + data.nbytes
-
-    # now we estimate how much of the total memory required for this data
-    (estimated_memory_bytes, subtract_bytes) = _calc_memory_bytes_paganin_filter_savu(
-        (dim_x, dim_y), np.float32(), **kwargs
-    )
-    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
-    #
-    # make sure estimator function is within range (80% min, 100% max)
-    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 <= 20
-
-
 @pytest.mark.cupy
 @pytest.mark.parametrize("slices", [128, 190, 256])
 def test_distortion_correction_memoryhook(
@@ -719,12 +677,7 @@ def __test_recon_LPRec3d_tomobar_memoryhook_common(
     # 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
-    if slices <= 3:
-        assert percents_relative_maxmem <= 75
-    elif slices <= 5:
-        assert percents_relative_maxmem <= 63
-    else:
-        assert percents_relative_maxmem <= 50
+    assert percents_relative_maxmem <= 80
 
 
 @pytest.mark.cupy