nabu 2024.1.1__py3-none-any.whl → 2024.1.3__py3-none-any.whl

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

@@ -1,425 +0,0 @@
-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/build/lib/build/lib/nabu/preproc/phase_cuda.py

@@ -1,143 +0,0 @@
-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/build/lib/build/lib/nabu/preproc/shift.py

@@ -1,95 +0,0 @@
-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