# Path: blond/toolbox/next_regular.py
# def next_regular(target):
#     """
#     Find the next regular number greater than or equal to target.
#     Regular numbers are composites of the prime factors 2, 3, and 5.
#     Also known as 5-smooth numbers or Hamming numbers, these are the optimal
#     size for inputs to FFTPACK.
# 
#     Target must be a positive integer.
#     """
#     if target <= 6:
#         return target
# 
#     # Quickly check if it's already a power of 2
#     if not (target & (target-1)):
#         return target
#     
#     target = -(-target // 2)
#     
#     match = float('inf') # Anything found will be smaller
#     p5 = 1
#     while p5 < target:
#         p35 = p5
#         while p35 < target:
#             # Ceiling integer division, avoiding conversion to float
#             # (quotient = ceil(target / p35))
#             quotient = -(-target // p35)
# 
#             # Quickly find next power of 2 >= quotient
#             try:
#                 p2 = 2**((quotient - 1).bit_length())
#             except AttributeError:
#                 # Fallback for Python <2.7
#                 p2 = 2**(len(bin(quotient - 1)) - 2)
# 
#             N = p2 * p35
#             if N == target:
#                 return N * 2
#             elif N < match:
#                 match = N
#             p35 *= 3
#             if p35 == target:
#                 return p35 * 2
#         if p35 < match:
#             match = p35
#         p5 *= 5
#         if p5 == target:
#             return p5 * 2
#     if p5 < match:
#         match = p5
#     
#     return match * 2
# 
# Path: blond/utils/bmath.py
# def use_mpi():
# def mpiMode():
# def use_fftw():
# def use_precision(_precision='double'):
# def update_active_dict(new_dict):


from builtins import range, object
from ctypes import c_uint, c_double, c_void_p
from scipy.constants import e
from ..toolbox.next_regular import next_regular
from ..utils import bmath as bm
import numpy as np
        _InducedVoltage.process(self)

        # Number of points for the FFT. The next regular number is used for
        # speed, therefore the frequency resolution is always equal or finer
        # than the input value
        if self.use_regular_fft:
            self.n_fft = next_regular(self.n_induced_voltage)
        else:
            self.n_fft = self.n_induced_voltage

        self.profile.beam_spectrum_freq_generation(self.n_fft)

        # Frequency array and resolution of the impedance in Hz
        self.freq = self.profile.beam_spectrum_freq
        self.frequency_resolution = 1 / (self.n_fft * self.profile.bin_size)
        
        # Length of the front wake in frequency domain calculations
        if self.front_wake_length:
            self.front_wake_buffer = int(np.ceil(
                np.max(self.front_wake_length) / self.profile.bin_size))

        # Processing the impedances
        self.sum_impedances(self.freq)

    def sum_impedances(self, freq):
        """
        Summing all the wake contributions in one total impedance.
        """

        self.total_impedance = np.zeros(

# Path: blond/toolbox/next_regular.py
# def next_regular(target):
#     """
#     Find the next regular number greater than or equal to target.
#     Regular numbers are composites of the prime factors 2, 3, and 5.
#     Also known as 5-smooth numbers or Hamming numbers, these are the optimal
#     size for inputs to FFTPACK.
# 
#     Target must be a positive integer.
#     """
#     if target <= 6:
#         return target
# 
#     # Quickly check if it's already a power of 2
#     if not (target & (target-1)):
#         return target
#     
#     target = -(-target // 2)
#     
#     match = float('inf') # Anything found will be smaller
#     p5 = 1
#     while p5 < target:
#         p35 = p5
#         while p35 < target:
#             # Ceiling integer division, avoiding conversion to float
#             # (quotient = ceil(target / p35))
#             quotient = -(-target // p35)
# 
#             # Quickly find next power of 2 >= quotient
#             try:
#                 p2 = 2**((quotient - 1).bit_length())
#             except AttributeError:
#                 # Fallback for Python <2.7
#                 p2 = 2**(len(bin(quotient - 1)) - 2)
# 
#             N = p2 * p35
#             if N == target:
#                 return N * 2
#             elif N < match:
#                 match = N
#             p35 *= 3
#             if p35 == target:
#                 return p35 * 2
#         if p35 < match:
#             match = p35
#         p5 *= 5
#         if p5 == target:
#             return p5 * 2
#     if p5 < match:
#         match = p5
#     
#     return match * 2
# 
# Path: blond/utils/bmath.py
# def use_mpi():
# def mpiMode():
# def use_fftw():
# def use_precision(_precision='double'):
# def update_active_dict(new_dict):


# Path: blond/impedances/impedance.py
from builtins import range, object
from ctypes import c_uint, c_double, c_void_p
from scipy.constants import e
from ..toolbox.next_regular import next_regular
from ..utils import bmath as bm
import numpy as np

        _InducedVoltage.process(self)

        # Number of points for the FFT. The next regular number is used for
        # speed, therefore the frequency resolution is always equal or finer
        # than the input value
        if self.use_regular_fft:
            self.n_fft = next_regular(self.n_induced_voltage)
        else:
            self.n_fft = self.n_induced_voltage

        self.profile.beam_spectrum_freq_generation(self.n_fft)

        # Frequency array and resolution of the impedance in Hz
        self.freq = self.profile.beam_spectrum_freq
        self.frequency_resolution = 1 / (self.n_fft * self.profile.bin_size)
        
        # Length of the front wake in frequency domain calculations
        if self.front_wake_length:
            self.front_wake_buffer = int(np.ceil(
                np.max(self.front_wake_length) / self.profile.bin_size))

        # Processing the impedances
        self.sum_impedances(self.freq)

    def sum_impedances(self, freq):
        """
        Summing all the wake contributions in one total impedance.
        """

        self.total_impedance = np.zeros(

            freq.shape, dtype=bm.precision.complex_t, order='C')