nabu 2024.1.0rc4__py3-none-any.whl → 2024.1.1__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/preproc/phase.py

@@ -0,0 +1,425 @@
+from math import pi
+from bisect import bisect
+import numpy as np
+from scipy.fft import rfft2, irfft2, fft2, ifft2
+from ..utils import generate_powers, get_decay, check_supported, get_num_threads, deprecation_warning
+
+#
+from .ctf import CTFPhaseRetrieval
+
+#
+
+
+def lmicron_to_db(Lmicron, energy, distance):
+    """
+    Utility to convert the "Lmicron" parameter of PyHST
+    to a value of delta/beta.
+
+    Parameters
+    -----------
+    Lmicron: float
+        Length in microns, values of the parameter "PAGANIN_Lmicron"
+        in PyHST2 parameter file.
+    energy: float
+        Energy in keV.
+    distance: float
+        Sample-detector distance in microns
+
+    Notes
+    --------
+    The conversion is done using the formula
+
+    .. math::
+       L^2 = \\pi \\lambda D \\frac{\\delta}{\\beta}
+
+    """
+    L2 = Lmicron**2
+    wavelength = 1.23984199e-3 / energy
+    return L2 / (pi * wavelength * distance)
+
+
+class PaganinPhaseRetrieval:
+    available_padding_modes = ["zeros", "mean", "edge", "symmetric", "reflect"]
+    powers = generate_powers()
+
+    def __init__(
+        self,
+        shape,
+        distance=0.5,
+        energy=20,
+        delta_beta=250.0,
+        pixel_size=1e-6,
+        padding="edge",
+        margin=None,
+        use_rfft=True,
+        use_R2C=None,
+        fftw_num_threads=None,
+        fft_num_threads=None,
+    ):
+        """
+        Paganin Phase Retrieval for an infinitely distant point source.
+        Formula (10) in [1].
+
+        Parameters
+        ----------
+        shape: int or tuple
+            Shape of each radio, in the format (num_rows, num_columns), i.e
+            (size_vertical, size_horizontal).
+            If an integer is provided, the shape is assumed to be square.
+        distance : float, optional
+            Propagation distance in meters.
+        energy : float, optional
+            Energy in keV.
+        delta_beta: float, optional
+            delta/beta ratio, where n = (1 - delta) + i*beta is the complex
+            refractive index of the sample.
+        pixel_size : float, optional
+            Detector pixel size in meters. Default is 1e-6 (one micron)
+        padding : str, optional
+            Padding method. Available are "zeros", "mean", "edge", "sym",
+            "reflect". Default is "edge".
+            Please refer to the "Padding" section below for more details.
+        margin: tuple, optional
+            The user may provide integers values U, D, L, R as a tuple under the
+            form ((U, D), (L, R)) (same syntax as numpy.pad()).
+            The resulting filtered radio will have a size equal to
+            (size_vertic - U - D, size_horiz - L - R).
+            These values serve to create a "margin" for the filtering process,
+            where U, D, L R are the margin of the Up, Down, Left and Right part,
+            respectively.
+            The filtering is done on a subset of the input radio. The subset
+            size is (Nrows - U - D, Ncols - R - L).
+            The margins is used to do the padding for the rest of the padded
+            array.
+
+            For example in one dimension, where ``padding="edge"``::
+
+               <------------------------------ padded_size --------------------------->
+               [padding=edge | padding=data | radio data | padding=data | padding=edge]
+               <------ N2 ---><----- L -----><- (N-L-R)--><----- R -----><----- N2 --->
+
+            Some or all the values U, D, L, R can be 0. In this case,
+            the padding of the parts related to the zero values will
+            fall back to the one of "padding" parameter.
+            For example, if padding="edge" and L, R are 0, then
+            the left and right parts will be padded with the edges, while
+            the Up and Down parts will be padded using the the user-provided
+            margins of the radio, and the final data will have shape
+            (Nrows - U - D, Ncols).
+            Some or all the values U, D, L, R can be the string "auto".
+            In this case, the values of U, D, L, R are automatically computed
+            as a function of the Paganin filter width.
+        use_rfft: bool, optional
+            Whether to use Real-to-Complex (R2C) transform instead of
+            standard Complex-to-Complex transform, providing better performances
+        use_R2C: bool, optional
+            DEPRECATED, use use_rfft instead
+        fftw_num_threads: bool or None or int, optional
+            DEPRECATED - please use fft_num_threads
+        fft_num_threads: bool or None or int, optional
+            Number of threads for FFT.
+            Default is to use all available threads. You can pass a negative number
+            to use N - fft_num_threads cores.
+
+        Important
+        ----------
+        Mind the units! Distance and pixel size are in meters, and energy is in keV.
+
+
+        Notes
+        ------
+
+        **Padding methods**
+
+        The phase retrieval is a convolution done in Fourier domain using FFT,
+        so the Fourier transform size has to be at least twice the size of
+        the original data. Mathematically, the data should be padded with zeros
+        before being Fourier transformed. However, in practice, this can lead
+        to artefacts at the edges (Gibbs effect) if the data does not go to
+        zero at the edges.
+        Apart from applying an apodization (Hamming, Blackman, etc), a common
+        strategy to avoid these artefacts is to pad the data.
+        In tomography reconstruction, this is usually done by replicating the
+        last(s) value(s) of the edges ; but one can think of other methods:
+
+           - "zeros": the data is simply padded with zeros.
+           - "mean": the upper side of extended data is padded with the mean of
+             the first row, the lower side with the mean of the last row, etc.
+           - "edge": the data is padded by replicating the edges.
+             This is the default mode.
+           - "sym": the data is padded by mirroring the data with respect
+             to its edges. See ``numpy.pad()``.
+           - "reflect": the data is padded by reflecting the data with respect
+             to its edges, including the edges. See ``numpy.pad()``.
+
+
+        **Formulas**
+
+        The radio is divided, in the Fourier domain, by the original "Paganin filter" `[1]`.
+
+        .. math::
+
+          F = 1 + \\frac{\\delta}{\\beta} \\lambda D \\pi |k|^2
+
+        where k is the wave vector.
+
+
+        References
+        -----------
+        [1] D. Paganin Et Al, "Simultaneous phase and amplitude extraction
+            from a single defocused image of a homogeneous object",
+            Journal of Microscopy, Vol 206, Part 1, 2002
+        """
+        self._init_parameters(distance, energy, pixel_size, delta_beta, padding)
+        self._calc_shape(shape, margin)
+        # COMPAT.
+        if use_R2C is not None:
+            deprecation_warning("'use_R2C' is replaced with 'use_rfft'", func_name="pag_r2c")
+        if fftw_num_threads is not None:
+            deprecation_warning("'fftw_num_threads' is replaced with 'fft_num_threads'", func_name="pag_fftw")
+            fft_num_threads = fftw_num_threads
+        # ---
+        self._get_fft(use_rfft, fft_num_threads)
+        self.compute_filter()
+
+    def _init_parameters(self, distance, energy, pixel_size, delta_beta, padding):
+        self.distance_cm = distance * 1e2
+        self.distance_micron = distance * 1e6
+        self.energy_kev = energy
+        self.pixel_size_micron = pixel_size * 1e6
+        self.delta_beta = delta_beta
+        self.wavelength_micron = 1.23984199e-3 / self.energy_kev
+        self.padding = padding
+        self.padding_methods = {
+            "zeros": self._pad_zeros,
+            "mean": self._pad_mean,
+            "edge": self._pad_edge,
+            "symmetric": self._pad_sym,
+            "reflect": self._pad_reflect,
+        }
+
+    def _get_fft(self, use_rfft, fft_num_threads):
+        self.use_rfft = use_rfft
+        self.use_R2C = use_rfft  # Compat.
+        self.fft_num_threads = get_num_threads(fft_num_threads)
+        if self.use_rfft:
+            self.fft_func = rfft2
+            self.ifft_func = irfft2
+        else:
+            self.fft_func = fft2
+            self.ifft_func = ifft2
+
+    def _calc_shape(self, shape, margin):
+        if np.isscalar(shape):
+            shape = (shape, shape)
+        else:
+            assert len(shape) == 2
+        self.shape = shape
+        self._set_margin_value(margin)
+        self._calc_padded_shape()
+
+    def _set_margin_value(self, margin):
+        self.margin = margin
+        if margin is None:
+            self.shape_inner = self.shape
+            self.use_margin = False
+            self.margin = ((0, 0), (0, 0))
+            return
+        self.use_margin = True
+        try:
+            ((U, D), (L, R)) = margin
+        except ValueError:
+            raise ValueError("Expected margin in the format ((U, D), (L, R))")
+        for val in [U, D, L, R]:
+            if isinstance(val, str) and val != "auto":
+                raise ValueError("Expected either an integer, or 'auto'")
+            if int(val) != val or val < 0:
+                raise ValueError("Expected positive integers for margin values")
+        self.shape_inner = (self.shape[0] - U - D, self.shape[1] - L - R)
+
+    def _calc_padded_shape(self):
+        """
+        Compute the padded shape.
+        If margin = 0, length_padded = next_power(2*length).
+        Otherwise : length_padded = next_power(2*(length - margins))
+
+        Principle
+        ----------
+
+        <--------------------- nx_p --------------------->
+        |         |        original data       |         |
+        < -- Pl - ><-- L -->< -- nx --><-- R --><-- Pr -->
+                   <----------- nx0 ----------->
+
+        Pl, Pr : left/right padding length
+        L, R : left/right margin
+        nx : length of inner data (and length of final result)
+        nx0 : length of original data
+        nx_p : total length of padded data
+        """
+        n_y, n_x = self.shape_inner
+        n_y0, n_x0 = self.shape
+        n_y_p = self._get_next_power(max(2 * n_y, n_y0))
+        n_x_p = self._get_next_power(max(2 * n_x, n_x0))
+        self.shape_padded = (n_y_p, n_x_p)
+        self.data_padded = np.zeros((n_y_p, n_x_p), dtype=np.float64)
+
+        ((U, D), (L, R)) = self.margin
+        n_y0, n_x0 = self.shape
+        self.pad_top_len = (n_y_p - n_y0) // 2
+        self.pad_bottom_len = n_y_p - n_y0 - self.pad_top_len
+        self.pad_left_len = (n_x_p - n_x0) // 2
+        self.pad_right_len = n_x_p - n_x0 - self.pad_left_len
+
+    def _get_next_power(self, n):
+        """
+        Given a number, get the closest (upper) number p such that
+        p is a power of 2, 3, 5 and 7.
+        """
+        idx = bisect(self.powers, n)
+        if self.powers[idx - 1] == n:
+            return n
+        return self.powers[idx]
+
+    def compute_filter(self):
+        nyp, nxp = self.shape_padded
+        fftfreq = np.fft.rfftfreq if self.use_rfft else np.fft.fftfreq
+        fy = np.fft.fftfreq(nyp, d=self.pixel_size_micron)
+        fx = fftfreq(nxp, d=self.pixel_size_micron)
+        self._coords_grid = np.add.outer(fy**2, fx**2)
+        #
+        k2 = self._coords_grid
+        D = self.distance_micron
+        L = self.wavelength_micron
+        db = self.delta_beta
+        self.paganin_filter = 1.0 / (1 + db * L * D * pi * k2)
+
+    def pad_with_values(self, data, top_val=0, bottom_val=0, left_val=0, right_val=0):
+        """
+        Pad the data into `self.padded_data` with values.
+
+        Parameters
+        ----------
+        data: numpy.ndarray
+            data (radio)
+        top_val: float or numpy.ndarray, optional
+            Value(s) to fill the top of the padded data with.
+        bottom_val: float or numpy.ndarray, optional
+            Value(s) to fill the bottom of the padded data with.
+        left_val: float or numpy.ndarray, optional
+            Value(s) to fill the left of the padded data with.
+        right_val: float or numpy.ndarray, optional
+            Value(s) to fill the right of the padded data with.
+        """
+        self.data_padded.fill(0)
+        Pu, Pd = self.pad_top_len, self.pad_bottom_len
+        Pl, Pr = self.pad_left_len, self.pad_right_len
+        self.data_padded[:Pu, :] = top_val
+        self.data_padded[-Pd:, :] = bottom_val
+        self.data_padded[:, :Pl] = left_val
+        self.data_padded[:, -Pr:] = right_val
+        self.data_padded[Pu:-Pd, Pl:-Pr] = data
+        # Transform the data to the FFT layout
+        self.data_padded = np.roll(self.data_padded, (-Pu, -Pl), axis=(0, 1))
+
+    def _pad_zeros(self, data):
+        return self.pad_with_values(data, top_val=0, bottom_val=0, left_val=0, right_val=0)
+
+    def _pad_mean(self, data):
+        """
+        Pad the data at each border with a different constant value.
+        The value depends on the padding size:
+          - On the left, value = mean(first data column)
+          - On the right, value = mean(last data column)
+          - On the top, value = mean(first data row)
+          - On the bottom, value = mean(last data row)
+        """
+        return self.pad_with_values(
+            data,
+            top_val=np.mean(data[0, :]),
+            bottom_val=np.mean(data[-1, :]),
+            left_val=np.mean(data[:, 0]),
+            right_val=np.mean(data[:, -1]),
+        )
+
+    def _pad_numpy(self, data, mode):
+        data_padded = np.pad(
+            data, ((self.pad_top_len, self.pad_bottom_len), (self.pad_left_len, self.pad_right_len)), mode=mode
+        )
+        # Transform the data to the FFT layout
+        Pu, Pl = self.pad_top_len, self.pad_left_len
+        return np.roll(data_padded, (-Pu, -Pl), axis=(0, 1))
+
+    def _pad_edge(self, data):
+        self.data_padded = self._pad_numpy(data, mode="edge")
+
+    def _pad_sym(self, data):
+        self.data_padded = self._pad_numpy(data, mode="symmetric")
+
+    def _pad_reflect(self, data):
+        self.data_padded = self._pad_numpy(data, mode="reflect")
+
+    def pad_data(self, data, padding_method=None):
+        padding_method = padding_method or self.padding
+        check_supported(padding_method, self.available_padding_modes, "padding mode")
+        if padding_method not in self.padding_methods:
+            raise ValueError(
+                "Unknown padding method %s. Available are: %s"
+                % (padding_method, str(list(self.padding_methods.keys())))
+            )
+        pad_func = self.padding_methods[padding_method]
+        pad_func(data)
+        return self.data_padded
+
+    def apply_filter(self, radio, padding_method=None, output=None):
+        self.pad_data(radio, padding_method=padding_method)
+        radio_f = self.fft_func(self.data_padded, workers=self.fft_num_threads)
+        radio_f *= self.paganin_filter
+        radio_filtered = self.ifft_func(radio_f, workers=self.fft_num_threads).real
+        s0, s1 = self.shape_inner
+        ((U, _), (L, _)) = self.margin
+        if output is None:
+            return radio_filtered[U : U + s0, L : L + s1]
+        else:
+            output[:, :] = radio_filtered[U : U + s0, L : L + s1]
+            return output
+
+    def lmicron_to_db(self, Lmicron):
+        """
+        Utility to convert the "Lmicron" parameter of PyHST
+        to a value of delta/beta.
+        Please see the doc of nabu.preproc.phase.lmicron_to_db()
+        """
+        return lmicron_to_db(Lmicron, self.energy_kev, self.distance_micron)
+
+    __call__ = apply_filter
+
+    retrieve_phase = apply_filter
+
+
+def compute_paganin_margin(shape, cutoff=1e3, **pag_kwargs):
+    """
+    Compute the convolution margin to use when calling PaganinPhaseRetrieval class.
+
+    Parameters
+    -----------
+    shape: tuple
+        Detector shape in the form (n_z, n_x)
+    """
+    P = PaganinPhaseRetrieval(shape, **pag_kwargs)
+
+    ifft_func = np.fft.irfft2 if P.use_rfft else np.fft.ifft2
+    conv_kernel = ifft_func(P.paganin_filter)
+
+    vmax = conv_kernel[0, 0]
+
+    v_margin = get_decay(conv_kernel[:, 0], cutoff=cutoff, vmax=vmax)
+    h_margin = get_decay(conv_kernel[0, :], cutoff=cutoff, vmax=vmax)
+    # If the Paganin filter is very narrow, then the corresponding convolution
+    # kernel is constant, and np.argmax() gives 0 (when it should give the max value)
+    if v_margin == 0:
+        v_margin = shape[0]
+    if h_margin == 0:
+        h_margin = shape[1]
+
+    return v_margin, h_margin

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/preproc/phase_cuda.py

@@ -0,0 +1,143 @@
+import numpy as np
+import pycuda.driver as cuda
+from ..utils import get_cuda_srcfile, check_supported, docstring
+from ..cuda.processing import CudaProcessing
+from ..processing.fft_cuda import get_fft_class
+from .phase import PaganinPhaseRetrieval
+
+
+class CudaPaganinPhaseRetrieval(PaganinPhaseRetrieval):
+    supported_paddings = ["zeros", "constant", "edge"]
+
+    @docstring(PaganinPhaseRetrieval)
+    def __init__(
+        self,
+        shape,
+        distance=0.5,
+        energy=20,
+        delta_beta=250.0,
+        pixel_size=1e-6,
+        padding="edge",
+        margin=None,
+        cuda_options=None,
+        fftw_num_threads=None,  # COMPAT.
+        fft_num_threads=None,
+        fft_backend="skcuda",
+    ):
+        """
+        Please refer to the documentation of
+        nabu.preproc.phase.PaganinPhaseRetrieval
+        """
+        padding = self._check_padding(padding)
+        self.cuda_processing = CudaProcessing(**(cuda_options or {}))
+        super().__init__(
+            shape,
+            distance=distance,
+            energy=energy,
+            delta_beta=delta_beta,
+            pixel_size=pixel_size,
+            padding=padding,
+            margin=margin,
+            use_rfft=True,
+            fft_num_threads=False,
+        )
+        self._init_gpu_arrays()
+        self._init_fft(fft_backend)
+        self._init_padding_kernel()
+        self._init_mult_kernel()
+
+    def _check_padding(self, padding):
+        check_supported(padding, self.supported_paddings, "padding")
+        if padding == "zeros":
+            padding = "constant"
+        return padding
+
+    def _init_gpu_arrays(self):
+        self.d_paganin_filter = self.cuda_processing.to_device(
+            "d_paganin_filter", np.ascontiguousarray(self.paganin_filter, dtype=np.float32)
+        )
+
+    # overwrite parent method, don't initialize any FFT plan
+    def _get_fft(self, use_rfft, fft_num_threads):
+        self.use_rfft = use_rfft
+
+    def _init_fft(self, fft_backend):
+        fft_cls = get_fft_class(backend=fft_backend)
+        self.cufft = fft_cls(shape=self.data_padded.shape, dtype=np.float32, r2c=True)
+        self.d_radio_padded = self.cuda_processing.allocate_array("d_radio_padded", self.cufft.shape, "f")
+        self.d_radio_f = self.cuda_processing.allocate_array("d_radio_f", self.cufft.shape_out, np.complex64)
+
+    def _init_padding_kernel(self):
+        kern_signature = {"constant": "Piiiiiiiiffff", "edge": "Piiiiiiii"}
+        self.padding_kernel = self.cuda_processing.kernel(
+            "padding_%s" % self.padding,
+            filename=get_cuda_srcfile("padding.cu"),
+            signature=kern_signature[self.padding],
+        )
+        Ny, Nx = self.shape
+        Nyp, Nxp = self.shape_padded
+        self.padding_kernel_args = [
+            self.d_radio_padded,
+            Nx,
+            Ny,
+            Nxp,
+            Nyp,
+            self.pad_left_len,
+            self.pad_right_len,
+            self.pad_top_len,
+            self.pad_bottom_len,
+        ]
+        # TODO configurable constant values
+        if self.padding == "constant":
+            self.padding_kernel_args.extend([0, 0, 0, 0])
+
+    def _init_mult_kernel(self):
+        self.cpxmult_kernel = self.cuda_processing.kernel(
+            "inplace_complexreal_mul_2Dby2D",
+            filename=get_cuda_srcfile("ElementOp.cu"),
+            signature="PPii",
+        )
+        self.cpxmult_kernel_args = [
+            self.d_radio_f,
+            self.d_paganin_filter,
+            self.shape_padded[1] // 2 + 1,
+            self.shape_padded[0],
+        ]
+
+    def set_input(self, data):
+        assert data.shape == self.shape
+        assert data.dtype == np.float32
+        # Rectangular memcopy
+        # TODO profile, and if needed include this copy in the padding kernel
+        if isinstance(data, np.ndarray) or isinstance(data, self.cuda_processing.array_class):
+            self.d_radio_padded[: self.shape[0], : self.shape[1]] = data[:, :]
+        elif isinstance(data, cuda.DeviceAllocation):
+            # TODO manual memcpy2D
+            raise NotImplementedError("pycuda buffers are not supported yet")
+        else:
+            raise ValueError("Expected either numpy array, pycuda array or pycuda buffer")
+
+    def get_output(self, output):
+        s0, s1 = self.shape_inner
+        ((U, _), (L, _)) = self.margin
+        if output is None:
+            # copy D2H
+            return self.d_radio_padded[U : U + s0, L : L + s1].get()
+        assert output.shape == self.shape_inner
+        assert output.dtype == np.float32
+        output[:, :] = self.d_radio_padded[U : U + s0, L : L + s1]
+        return output
+
+    def apply_filter(self, radio, output=None):
+        self.set_input(radio)
+
+        self.padding_kernel(*self.padding_kernel_args)
+        self.cufft.fft(self.d_radio_padded, output=self.d_radio_f)
+        self.cpxmult_kernel(*self.cpxmult_kernel_args)
+        self.cufft.ifft(self.d_radio_f, output=self.d_radio_padded)
+
+        return self.get_output(output)
+
+    __call__ = apply_filter
+
+    retrieve_phase = apply_filter

build/lib/build/lib/build/lib/build/lib/build/lib/build/lib/nabu/preproc/shift.py

@@ -0,0 +1,95 @@
+from math import floor
+import numpy as np
+
+
+class VerticalShift:
+    def __init__(self, radios_shape, shifts):
+        """
+        This class is used when a vertical translation (along the tomography
+        rotation axis) occurred.
+
+        These translations are meant "per projection" and can be due either to
+        mechanical errors, or can be applied purposefully with known motor movements
+        to smear rings artefacts.
+
+        The object is initialised with an array of shifts: one shift for each projection.
+        A positive shifts means that the axis has moved in the positive Z direction.
+        The interpolation is done taking for a pixel (y,x) the pixel found at (y+shft,x)
+        in the recorded images.
+
+        The method apply_vertical_shifts performs the correctionson the radios.
+
+        Parameters
+        ----------
+        radios_shape: tuple
+            Shape of the radios chunk, in the form (n_radios, n_y, n_x)
+        shifts: sequence of floats
+            one shift for each projection
+
+        Notes
+        ------
+        During the acquisition, there might be other translations, each of them
+        orthogonal to the rotation axis.
+          - A "horizontal" translation in the detector plane: this is handled
+            directly in the Backprojection operation.
+          - A translation along the beam direction: this one is of no concern
+            for parallel-beam geometry
+        """
+        self.radios_shape = radios_shape
+        self.shifts = shifts
+        self._init_interp_coefficients()
+
+    def _init_interp_coefficients(self):
+        self.interp_infos = []
+        for s in self.shifts:
+            s0 = int(floor(s))
+            f = s - s0
+            self.interp_infos.append([s0, f])
+
+    def _check(self, radios, iangles):
+        assert np.min(iangles) >= 0
+        assert np.max(iangles) < len(self.interp_infos)
+        assert len(iangles) == radios.shape[0]
+
+    def apply_vertical_shifts(self, radios, iangles, output=None):
+        """
+        Parameters
+        ----------
+        radios: a sequence of np.array
+            The input radios. If the optional parameter is not given, they are modified in-place
+        iangles:  a sequence of integers
+            Must have the same lenght as radios.
+            It contains the index at which the shift is found in `self.shifts`
+            given by `shifts` argument in the initialisation of the object.
+        output: a sequence of np.array, optional
+            If given, it will be modified to contain the shifted radios.
+            Must be of the same shape of `radios`.
+        """
+        self._check(radios, iangles)
+
+        newradio = np.zeros_like(radios[0])
+        for radio, ia in zip(radios, iangles):
+            newradio[:] = 0
+            S0, f = self.interp_infos[ia]
+            s0 = S0
+
+            if s0 > 0:
+                newradio[:-s0] = radio[s0:] * (1 - f)
+            elif s0 == 0:
+                newradio[:] = radio[s0:] * (1 - f)
+            else:
+                newradio[-s0:] = radio[:s0] * (1 - f)
+
+            s0 = S0 + 1
+
+            if s0 > 0:
+                newradio[:-s0] += radio[s0:] * f
+            elif s0 == 0:
+                newradio[:] += radio[s0:] * f
+            else:
+                newradio[-s0:] += radio[:s0] * f
+
+            if output is None:
+                radios[ia] = newradio
+            else:
+                output[ia] = newradio