nabu 2024.2.14__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/preproc/tests/test_pcaflats.py

@@ -0,0 +1,154 @@
+import os
+import numpy as np
+import pytest
+
+import h5py
+from nabu.testutils import utilstest
+from nabu.preproc.flatfield import (
+    PCAFlatsDecomposer,
+    PCAFlatsNormalizer,
+)
+
+
+@pytest.fixture(scope="class")
+def bootstrap_pcaflats(request):
+    cls = request.cls
+    # TODO: these tolerances for having the tests passed should be tighter.
+    # Discrepancies between id11 code and nabu code are still mysterious.
+    cls.mean_abs_tol = 1e-1
+    cls.comps_abs_tol = 1e-2
+    cls.projs, cls.flats, cls.darks = get_pcaflats_data("test_pcaflats.npz")
+    cls.raw_projs = cls.projs.copy()  # Needed because flat correction is done inplace.
+    ref_data = get_pcaflats_refdata("ref_pcaflats.npz")
+    cls.mean = ref_data["mean"]
+    cls.components_3 = ref_data["components_3"]
+    cls.components_15 = ref_data["components_15"]
+    cls.dark = ref_data["dark"]
+    cls.normalized_projs_3 = ref_data["normalized_projs_3"]
+    cls.normalized_projs_15 = ref_data["normalized_projs_15"]
+    cls.normalized_projs_custom_mask = ref_data["normalized_projs_custom_mask"]
+    cls.test_normalize_projs_custom_prop = ref_data["normalized_projs_custom_prop"]
+
+    cls.h5_filename_3 = get_h5_pcaflats("pcaflat_3.h5")
+    cls.h5_filename_15 = get_h5_pcaflats("pcaflat_15.h5")
+
+
+def get_pcaflats_data(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    data = np.load(dataset_downloaded_path)
+    projs = data["projs"].astype(np.float32)
+    flats = data["flats"].astype(np.float32)
+    darks = data["darks"].astype(np.float32)
+
+    return projs, flats, darks
+
+
+def get_h5_pcaflats(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+
+    return dataset_downloaded_path
+
+
+def get_pcaflats_refdata(*dataset_path):
+    """
+    Get a dataset file from silx.org/pub/nabu/data
+    dataset_args is a list describing a nested folder structures, ex.
+    ["path", "to", "my", "dataset.h5"]
+    """
+    dataset_relpath = os.path.join(*dataset_path)
+    dataset_downloaded_path = utilstest.getfile(dataset_relpath)
+    data = np.load(dataset_downloaded_path)
+
+    return data
+
+
+def get_decomposition(filename):
+    with h5py.File(filename, "r") as f:
+        # Load the dataset
+        p_comps = f["entry0000/p_components"][()]
+        p_mean = f["entry0000/p_mean"][()]
+        dark = f["entry0000/dark"][()]
+    return p_comps, p_mean, dark
+
+
+@pytest.mark.usefixtures("bootstrap_pcaflats")
+class TestPCAFlatsDecomposer:
+    def test_decompose_flats(self):
+        # Build 3-sigma basis
+        pca = PCAFlatsDecomposer(self.flats, self.darks, nsigma=3)
+        message = f"Found a discrepency between computed mean flat and reference."
+        assert np.allclose(self.mean, pca.mean, atol=self.mean_abs_tol), message
+        message = f"Found a discrepency between computed components and reference ones if nsigma=3."
+        assert np.allclose(self.components_3, np.array(pca.components), atol=self.comps_abs_tol), message
+
+        # Build 1.5-sigma basis
+        pca = PCAFlatsDecomposer(self.flats, self.darks, nsigma=1.5)
+        message = f"Found a discrepency between computed components and reference ones, if nsigma=1.5."
+        assert np.allclose(self.components_15, np.array(pca.components), atol=self.comps_abs_tol), message
+
+    def test_save_load_decomposition(self):
+        pca = PCAFlatsDecomposer(self.flats, self.darks, nsigma=3)
+        tmp_path = os.path.join(os.path.dirname(self.h5_filename_3), "PCA_Flats.h5")
+        pca.save_decomposition(path=tmp_path)
+        p_comps, p_mean, dark = get_decomposition(tmp_path)
+        message = f"Found a discrepency between saved and loaded mean flat."
+        assert np.allclose(self.mean, p_mean, atol=self.mean_abs_tol), message
+        message = f"Found a discrepency between saved and loaded components if nsigma=3."
+        assert np.allclose(self.components_3, p_comps, atol=self.comps_abs_tol), message
+        message = f"Found a discrepency between saved and loaded dark."
+        assert np.allclose(self.dark, dark, atol=self.comps_abs_tol), message
+        # Clean up
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+
+@pytest.mark.usefixtures("bootstrap_pcaflats")
+class TestPCAFlatsNormalizer:
+    def test_load_pcaflats(self):
+        """Tests that the structure of the output PCAFlat h5 file is correct."""
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+        # Check the shape of the loaded data
+        assert p_comps.shape[1:] == p_mean.shape
+        assert p_comps.shape[1:] == dark.shape
+
+    def test_normalize_projs(self):
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs)
+        assert np.allclose(projs, self.normalized_projs_3, atol=1e-2)
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_15)
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs)
+        assert np.allclose(projs, self.normalized_projs_15, atol=1e-2)
+
+    def test_use_custom_mask(self):
+        mask = np.zeros(self.mean.shape, dtype=bool)
+        mask[:, :10] = True
+        mask[:, -10:] = True
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs, mask=mask)
+        assert np.allclose(projs, self.normalized_projs_custom_mask, atol=1e-2)
+
+    def test_change_mask_prop(self):
+        p_comps, p_mean, dark = get_decomposition(self.h5_filename_3)
+        pca = PCAFlatsNormalizer(p_comps, dark, p_mean)
+        projs = self.raw_projs.copy()
+        pca.normalize_radios(projs, prop=0.05)
+        assert np.allclose(projs, self.test_normalize_projs_custom_prop, atol=1e-2)

nabu/preproc/tests/test_vshift.py

@@ -70,4 +70,7 @@ class TestVerticalShift:
         Shifter_neg_cuda = CudaVerticalShift(d_radios.shape, -self.shifts)
         Shifter_neg_cuda.apply_vertical_shifts(d_radios2, self.indexes)
         err_max = np.max(np.abs(d_radios2.get() - radios2))
-        assert err_max < 1e-6, "Something wrong for negative translations: max error = %.2e" % err_max
+        #
+        # FIXME tolerance was downgraded from 1e-6 to 8e-6 when switching to numpy 2
+        #
+        assert err_max < 8e-6, "Something wrong for negative translations: max error = %.2e" % err_max

nabu/processing/azim.py

@@ -96,8 +96,11 @@ def do_radial_distribution(ip, X0, Y0, mR, nBins=None, use_calibration=False, ca
     Accumulator = np.zeros((2, nBins))
 
     # Define the bounding box
-    xmin, xmax = X0 - mR, X0 + mR
-    ymin, ymax = Y0 - mR, Y0 + mR
+    height, width = ip.shape
+    xmin = max(int(X0 - mR), 0)
+    xmax = min(int(X0 + mR), width)
+    ymin = max(int(Y0 - mR), 0)
+    ymax = min(int(Y0 + mR), height)
 
     # Create grid of coordinates
     x = np.arange(xmin, xmax)
@@ -112,10 +115,11 @@ def do_radial_distribution(ip, X0, Y0, mR, nBins=None, use_calibration=False, ca
     bins = np.clip(bins - 1, 0, nBins - 1)  # Adjust bins to be in range [0, nBins-1]
 
     # Accumulate values
+    sub_image = ip[xmin:xmax, ymin:ymax]  # prevent issue on non-square images
     for b in range(nBins):
         mask = bins == b
         Accumulator[0, b] = np.sum(mask)
-        Accumulator[1, b] = np.sum(ip[mask])
+        Accumulator[1, b] = np.sum(sub_image[mask])
 
     # Normalize integrated intensity
     Accumulator[1] /= Accumulator[0]
@@ -123,11 +127,11 @@ def do_radial_distribution(ip, X0, Y0, mR, nBins=None, use_calibration=False, ca
     if use_calibration and cal is not None:
         # Apply calibration if units are provided
         radii = cal.pixel_width * mR * (np.arange(1, nBins + 1) / nBins)
-        units = cal.units
+        # units = cal.units
     else:
         # Use pixel units
         radii = mR * (np.arange(1, nBins + 1) / nBins)
-        units = "pixels"
+        # units = "pixels"
 
     if return_radii:
         return radii, Accumulator[1]

nabu/processing/convolution_cuda.py

@@ -159,7 +159,7 @@ class Convolution:
             self.d_kernel = self.cuda.to_device("d_kernel", self.kernel)
         else:
             if not (isinstance(self.kernel, self.cuda.array_class)):
-                raise ValueError("kernel must be either numpy array or pycuda array")
+                raise TypeError("kernel must be either numpy array or pycuda array")
             self.d_kernel = self.kernel
         self._old_input_ref = None
         self._old_output_ref = None
@@ -185,7 +185,7 @@ class Convolution:
         self._c_conv_mode = mp[self.mode]
 
     def _init_kernels(self):
-        if self.kernel_ndim > 1:
+        if self.kernel_ndim > 1:  # noqa: SIM102
             if np.abs(np.diff(self.kernel.shape)).max() > 0:
                 raise NotImplementedError("Non-separable convolution with non-square kernels is not implemented yet")
         # Compile source module
@@ -290,7 +290,7 @@ class Convolution:
         return ndim
 
     def _check_array(self, arr):
-        if not (isinstance(arr, self.cuda.array_class) or isinstance(arr, np.ndarray)):
+        if not (isinstance(arr, self.cuda.array_class) or isinstance(arr, np.ndarray)):  # noqa: SIM101
             raise TypeError("Expected either pycuda.gpuarray or numpy.ndarray")
         if arr.dtype != np.float32:
             raise TypeError("Data must be float32")
@@ -305,7 +305,7 @@ class Convolution:
             self._old_input_ref = self.data_in
             self.data_in = array
         data_in_ref = self.data_in
-        if output is not None:
+        if output is not None:  # noqa: SIM102
             if not (isinstance(output, np.ndarray)):
                 self._old_output_ref = self.data_out
                 self.data_out = output
@@ -324,11 +324,13 @@ class Convolution:
         cuda_kernel = self.cuda_kernels[axis]
         cuda_kernel_args = self._configure_kernel_args(self.kernel_args, input_ref, output_ref)
         ev = cuda_kernel.prepared_call(*cuda_kernel_args)
+        return ev
 
     def _nd_convolution(self):
         assert len(self.use_case_kernels) == 1
         cuda_kernel = self._module.get_function(self.use_case_kernels[0])
         ev = cuda_kernel.prepared_call(*self.kernel_args)
+        return ev
 
     def _recover_arrays_references(self):
         if self._old_input_ref is not None:

nabu/processing/fft_base.py

@@ -35,7 +35,7 @@ class _BaseFFT:
                 the transform is unitary. Both FFT and IFFT are scaled with 1/sqrt(N).
               * "none": no normalizatio is done : IFFT(FFT(data)) = data*N
 
-        Other parameters
+        Other Parameters
         -----------------
         backend_options: dict, optional
             Parameters to pass to CudaProcessing or OpenCLProcessing class.
@@ -93,6 +93,10 @@ class _BaseFFT:
         pass
 
 
+def raise_base_class_error(slf, *args, **kwargs):
+    raise ValueError
+
+
 class _BaseVKFFT(_BaseFFT):
     """
     FFT using VKFFT backend
@@ -101,7 +105,7 @@ class _BaseVKFFT(_BaseFFT):
     implem = "vkfft"
     backend = "none"
     ProcessingCls = BaseClassError
-    vkffs_cls = BaseClassError
+    get_fft_obj = raise_base_class_error
 
     def _configure_batched_transform(self):
         if self.axes is not None and len(self.shape) == len(self.axes):
@@ -128,7 +132,7 @@ class _BaseVKFFT(_BaseFFT):
         self._vkfft_ndim = None
 
     def _compute_fft_plans(self):
-        self._vkfft_plan = self.vkffs_cls(
+        self._vkfft_plan = self.get_fft_obj(
             self.shape,
             self.dtype,
             ndim=self._vkfft_ndim,

nabu/processing/fft_cuda.py

@@ -1,148 +1,33 @@
 import os
 import warnings
+from functools import lru_cache
 from multiprocessing import get_context
 from multiprocessing.pool import Pool
-import numpy as np
-from ..utils import check_supported
-from .fft_base import _BaseFFT, _BaseVKFFT
+from ..utils import BaseClassError, check_supported, no_decorator
+from .fft_base import _BaseVKFFT
 
 try:
-    from pyvkfft.cuda import VkFFTApp as vk_cufft
+    from pyvkfft.cuda import VkFFTApp as CudaVkFFTApp
 
     __has_vkfft__ = True
 except (ImportError, OSError):
     __has_vkfft__ = False
-    vk_cufft = None
+    CudaVkFFTApp = BaseClassError
 from ..cuda.processing import CudaProcessing
 
-Plan = None
-cu_fft = None
-cu_ifft = None
-__has_skcuda__ = None
+n_cached_ffts = int(os.getenv("NABU_FFT_CACHE", "0"))
 
 
-def init_skcuda():
-    # This needs to be done here, because scikit-cuda creates a Cuda context at import,
-    # which can mess things up in some cases.
-    # Ugly solution to an ugly problem.
-    global __has_skcuda__, Plan, cu_fft, cu_ifft
-    try:
-        from skcuda.fft import Plan
-        from skcuda.fft import fft as cu_fft
-        from skcuda.fft import ifft as cu_ifft
+maybe_cached = lru_cache(maxsize=n_cached_ffts) if n_cached_ffts > 0 else no_decorator
 
-        __has_skcuda__ = True
-    except ImportError:
-        __has_skcuda__ = False
 
+@maybe_cached
+def _get_vkfft_cuda(*args, **kwargs):
+    return CudaVkFFTApp(*args, **kwargs)
 
-class SKCUFFT(_BaseFFT):
-    implem = "skcuda"
-    backend = "cuda"
-    ProcessingCls = CudaProcessing
 
-    def _configure_batched_transform(self):
-        if __has_skcuda__ is None:
-            init_skcuda()
-        if not (__has_skcuda__):
-            raise ImportError("Please install pycuda and scikit-cuda to use the CUDA back-end")
-
-        self.cufft_batch_size = 1
-        self.cufft_shape = self.shape
-        self._cufft_plan_kwargs = {}
-        if (self.axes is not None) and (len(self.axes) < len(self.shape)):
-            # In the easiest case, the transform is computed along the fastest dimensions:
-            #  - 1D transforms of lines of 2D data
-            #  - 2D transforms of images of 3D data (stacked along slow dim)
-            #  - 1D transforms of 3D data along fastest dim
-            # Otherwise, we have to configure cuda "advanced memory layout".
-            data_ndims = len(self.shape)
-
-            if data_ndims == 2:
-                n_y, n_x = self.shape
-                along_fast_dim = self.axes[0] == 1
-                self.cufft_shape = n_x if along_fast_dim else n_y
-                self.cufft_batch_size = n_y if along_fast_dim else n_x
-                if not (along_fast_dim):
-                    # Batched vertical 1D FFT on 2D data need advanced data layout
-                    # http://docs.nvidia.com/cuda/cufft/#advanced-data-layout
-                    self._cufft_plan_kwargs = {
-                        "inembed": np.int32([0]),
-                        "istride": n_x,
-                        "idist": 1,
-                        "onembed": np.int32([0]),
-                        "ostride": n_x,
-                        "odist": 1,
-                    }
-
-            if data_ndims == 3:
-                # TODO/FIXME - the following work for C2C but not R2C ?!
-                # fast_axes = [(1, 2), (2, 1), (2,)]
-                fast_axes = [(2,)]
-                if self.axes not in fast_axes:
-                    raise NotImplementedError(
-                        "With the CUDA backend, batched transform on 3D data is only supported along fastest dimensions"
-                    )
-                self.cufft_batch_size = self.shape[0]
-                self.cufft_shape = self.shape[1:]
-                if len(self.axes) == 1:
-                    # 1D transform on 3D data: here only supported along fast dim, so batch_size is Nx*Ny
-                    self.cufft_batch_size = np.prod(self.shape[:2])
-                    self.cufft_shape = (self.shape[-1],)
-                if len(self.cufft_shape) == 1:
-                    self.cufft_shape = self.cufft_shape[0]
-
-    def _configure_normalization(self, normalize):
-        self.normalize = normalize
-        if self.normalize == "ortho":
-            # TODO
-            raise NotImplementedError("Normalization mode 'ortho' is not implemented with CUDA backend yet.")
-        self.cufft_scale_inverse = self.normalize == "rescale"
-
-    def _compute_fft_plans(self):
-        self.plan_forward = Plan(  # pylint: disable = E1102
-            self.cufft_shape,
-            self.dtype,
-            self.dtype_out,
-            batch=self.cufft_batch_size,
-            stream=self.processing.stream,
-            **self._cufft_plan_kwargs,
-            # cufft extensible plan API is only supported after 0.5.1
-            # (commit 65288d28ca0b93e1234133f8d460dc6becb65121)
-            # but there is still no official 0.5.2
-            # ~ auto_allocate=True # cufft extensible plan API
-        )
-        self.plan_inverse = Plan(  # pylint: disable = E1102
-            self.cufft_shape,  # not shape_out
-            self.dtype_out,
-            self.dtype,
-            batch=self.cufft_batch_size,
-            stream=self.processing.stream,
-            **self._cufft_plan_kwargs,
-            # cufft extensible plan API is only supported after 0.5.1
-            # (commit 65288d28ca0b93e1234133f8d460dc6becb65121)
-            # but there is still no official 0.5.2
-            # ~ auto_allocate=True
-        )
-
-    def fft(self, array, output=None):
-        if output is None:
-            output = self.output_fft = self.processing.allocate_array(
-                "output_fft", self.shape_out, dtype=self.dtype_out
-            )
-        cu_fft(array, output, self.plan_forward, scale=False)  # pylint: disable = E1102
-        return output
-
-    def ifft(self, array, output=None):
-        if output is None:
-            output = self.output_ifft = self.processing.allocate_array("output_ifft", self.shape, dtype=self.dtype)
-        cu_ifft(  # pylint: disable = E1102
-            array,
-            output,
-            self.plan_inverse,
-            scale=self.cufft_scale_inverse,
-        )
-        return output
+def get_vkfft_cuda(slf, *args, **kwargs):
+    return _get_vkfft_cuda(*args, **kwargs)
 
 
 class VKCUFFT(_BaseVKFFT):
@@ -153,7 +38,7 @@ class VKCUFFT(_BaseVKFFT):
     implem = "vkfft"
     backend = "cuda"
     ProcessingCls = CudaProcessing
-    vkffs_cls = vk_cufft
+    get_fft_obj = get_vkfft_cuda
 
     def _init_backend(self, backend_options):
         super()._init_backend(backend_options)
@@ -167,13 +52,14 @@ def _has_vkfft(x):
 
         if not __has_vkfft__:
             return False
-        vk = VKCUFFT((16,), "f")
+        _ = VKCUFFT((16,), "f")
         avail = True
     except (ImportError, RuntimeError, OSError, NameError):
         avail = False
     return avail
 
 
+@lru_cache(maxsize=2)
 def has_vkfft(safe=True):
     """
     Determine whether pyvkfft is available.
@@ -184,44 +70,20 @@ def has_vkfft(safe=True):
     """
     if not safe:
         return _has_vkfft(None)
-    ctx = get_context("spawn")
-    with Pool(1, context=ctx) as p:
-        v = p.map(_has_vkfft, [1])[0]
-    return v
-
-
-def _has_skfft(x):
-    # should be run from within a Process
     try:
-        from nabu.processing.fft_cuda import SKCUFFT
-
-        sk = SKCUFFT((16,), "f")
-        avail = True
-    except (ImportError, RuntimeError, OSError, NameError):
-        avail = False
-    return avail
-
-
-def has_skcuda(safe=True):
-    """
-    Determine whether scikit-cuda/CUFFT is available.
-    Currently, scikit-cuda will create a Cuda context for Cublas, which can mess up the current execution.
-    Do it in a separate thread.
-    """
-    if not safe:
-        return _has_skfft(None)
-    ctx = get_context("spawn")
-    with Pool(1, context=ctx) as p:
-        v = p.map(_has_skfft, [1])[0]
+        ctx = get_context("spawn")
+        with Pool(1, context=ctx) as p:
+            v = p.map(_has_vkfft, [1])[0]
+    except AssertionError:
+        # Can get AssertionError: daemonic processes are not allowed to have children
+        # if the calling code is already a subprocess
+        return _has_vkfft(None)
     return v
 
 
+@lru_cache(maxsize=2)
 def get_fft_class(backend="vkfft"):
     backends = {
-        "scikit-cuda": SKCUFFT,
-        "skcuda": SKCUFFT,
-        "cufft": SKCUFFT,
-        "scikit": SKCUFFT,
         "vkfft": VKCUFFT,
         "pyvkfft": VKCUFFT,
     }
@@ -237,7 +99,7 @@ def get_fft_class(backend="vkfft"):
 
     avail_fft_implems = get_available_fft_implems()
     if len(avail_fft_implems) == 0:
-        raise RuntimeError("Could not any Cuda FFT implementation. Please install either scikit-cuda or pyvkfft")
+        raise RuntimeError("Could not any Cuda FFT implementation. Please install pyvkfft")
     if backend not in avail_fft_implems:
         warnings.warn("Could not get FFT backend '%s'" % backend, RuntimeWarning)
         backend = avail_fft_implems[0]
@@ -245,10 +107,9 @@ def get_fft_class(backend="vkfft"):
     return get_fft_cls(backend)
 
 
+@lru_cache(maxsize=1)
 def get_available_fft_implems():
     avail_implems = []
     if has_vkfft(safe=True):
         avail_implems.append("vkfft")
-    if has_skcuda(safe=True):
-        avail_implems.append("skcuda")
     return avail_implems

nabu/processing/fft_opencl.py

@@ -1,15 +1,32 @@
+from functools import lru_cache
+import os
 from multiprocessing import get_context
 from multiprocessing.pool import Pool
+
+from ..utils import BaseClassError, no_decorator
 from .fft_base import _BaseVKFFT
 from ..opencl.processing import OpenCLProcessing
 
 try:
-    from pyvkfft.opencl import VkFFTApp as vk_clfft
+    from pyvkfft.opencl import VkFFTApp as OpenCLVkFFTApp
 
     __has_vkfft__ = True
 except (ImportError, OSError):
     __has_vkfft__ = False
     vk_clfft = None
+    OpenCLVkFFTApp = BaseClassError
+
+n_cached_ffts = int(os.getenv("NABU_FFT_CACHE", "0"))
+maybe_cached = lru_cache(maxsize=n_cached_ffts) if n_cached_ffts > 0 else no_decorator
+
+
+@maybe_cached
+def _get_vkfft_opencl(*args, **kwargs):
+    return OpenCLVkFFTApp(*args, **kwargs)
+
+
+def get_vkfft_opencl(slf, *args, **kwargs):
+    return _get_vkfft_opencl(*args, **kwargs)
 
 
 class VKCLFFT(_BaseVKFFT):
@@ -20,7 +37,7 @@ class VKCLFFT(_BaseVKFFT):
     implem = "vkfft"
     backend = "opencl"
     ProcessingCls = OpenCLProcessing
-    vkffs_cls = vk_clfft
+    get_fft_obj = get_vkfft_opencl
 
     def _init_backend(self, backend_options):
         super()._init_backend(backend_options)
@@ -34,7 +51,7 @@ def _has_vkfft(x):
 
         if not __has_vkfft__:
             return False
-        vk = VKCLFFT((16,), "f")
+        _ = VKCLFFT((16,), "f")
         avail = True
     except (RuntimeError, OSError):
         avail = False
@@ -48,7 +65,12 @@ def has_vkfft(safe=True):
     """
     if not safe:
         return _has_vkfft(None)
-    ctx = get_context("spawn")
-    with Pool(1, context=ctx) as p:
-        v = p.map(_has_vkfft, [1])[0]
+    try:
+        ctx = get_context("spawn")
+        with Pool(1, context=ctx) as p:
+            v = p.map(_has_vkfft, [1])[0]
+    except AssertionError:
+        # Can get AssertionError: daemonic processes are not allowed to have children
+        # if the calling code is already a subprocess
+        return _has_vkfft(None)
     return v

nabu/processing/fftshift.py

@@ -25,7 +25,7 @@ class FFTshiftBase:
         axes: tuple, optional
             Axes over which to shift.  Default is None, which shifts all axes.
 
-        Other parameters
+        Other Parameters
         ----------------
         backend_options:
             named arguments to pass to CudaProcessing or OpenCLProcessing

nabu/processing/histogram.py

@@ -146,7 +146,7 @@ class PartialHistogram:
         elif self.bin_width == "uint16":
             return self._bin_width_u16(dmin, dmax)
         else:
-            raise ValueError()
+            raise ValueError
 
     def _compute_histogram_fixed_bw(self, data, data_range=None):
         dmin, dmax = data.min(), data.max() if data_range is None else data_range

nabu/processing/muladd.py

@@ -1,4 +1,3 @@
-import numpy as np
 from .processing_base import ProcessingBase
 
 

nabu/processing/padding_base.py

@@ -23,7 +23,7 @@ class PaddingBase:
         mode: str
             Padding mode
 
-        Other parameters
+        Other Parameters
         ----------------
         constant_values: tuple
             Tuple containing the values to fill when mode="constant" (as in numpy.pad)

nabu/processing/padding_cuda.py

@@ -1,7 +1,6 @@
 import numpy as np
 from ..utils import get_cuda_srcfile, updiv
 from ..cuda.processing import CudaProcessing
-from ..cuda.utils import __has_pycuda__
 from .padding_base import PaddingBase
 
 
@@ -12,7 +11,6 @@ class CudaPadding(PaddingBase):
 
     backend = "cuda"
 
-    # TODO docstring from base class
     def __init__(self, shape, pad_width, mode="constant", cuda_options=None, **kwargs):
         super().__init__(shape, pad_width, mode=mode, **kwargs)
         self.cuda_processing = self.processing = CudaProcessing(**(cuda_options or {}))