SignalProcessingTools 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

SignalProcessingTools/__version__.py

@@ -1,3 +1,3 @@
 __title__ = "SignalProcessingTools"
-__version__ = "1.2.2"
+__version__ = "1.2.4"
 __author__ = "Bruno Zuada Coelho, Aron Noordam"

SignalProcessingTools/space_signal.py

@@ -8,7 +8,11 @@ class SpaceSignalProcessing:
     """
     SignalProcessing class for processing signals in space.
     """
-    def __init__(self, x: npt.NDArray[np.float64], values: npt.NDArray[np.float64], Fs: Optional[float] = None):
+
+    def __init__(self,
+                 x: npt.NDArray[np.float64],
+                 values: npt.NDArray[np.float64],
+                 Fs: Optional[float] = None):
         """
         Initializes the ProcessSignal object.
 
@@ -40,7 +44,6 @@ class SpaceSignalProcessing:
         self.max_fast = None
         self.max_fast_Dx = None
 
-
     def compute_track_longitudinal_levels(self):
         """
         Computes the track longitudinal levels, following EN 13848-1:2006.
@@ -53,20 +56,34 @@ class SpaceSignalProcessing:
         - D3: 70m < lambda <= 150m (1/150 Hz < f <= 1/70 Hz)
         """
 
-        sig = TimeSignalProcessing(self.coordinates, self.signal_raw, Fs=self.fs)
-        sig.filter([1/5., 1.], 4, type_filter="bandpass", filter_design=FilterDesign.BUTTERWORTH)
+        sig = TimeSignalProcessing(self.coordinates,
+                                   self.signal_raw,
+                                   Fs=self.fs)
+        sig.filter([1 / 5., 1.],
+                   4,
+                   type_filter="bandpass",
+                   filter_design=FilterDesign.BUTTERWORTH)
         self.d0 = sig.signal
 
         sig.reset()
-        sig.filter([1/25., 1/3.], 4, type_filter="bandpass", filter_design=FilterDesign.BUTTERWORTH)
+        sig.filter([1 / 25., 1 / 3.],
+                   4,
+                   type_filter="bandpass",
+                   filter_design=FilterDesign.BUTTERWORTH)
         self.d1 = sig.signal
         sig.reset()
 
-        sig.filter([1/70., 1/25.], 4, type_filter="bandpass", filter_design=FilterDesign.BUTTERWORTH)
+        sig.filter([1 / 70., 1 / 25.],
+                   4,
+                   type_filter="bandpass",
+                   filter_design=FilterDesign.BUTTERWORTH)
         self.d2 = sig.signal
         sig.reset()
 
-        sig.filter([1/150., 1/70.], 4, type_filter="bandpass", filter_design=FilterDesign.BUTTERWORTH)
+        sig.filter([1 / 150., 1 / 70.],
+                   4,
+                   type_filter="bandpass",
+                   filter_design=FilterDesign.BUTTERWORTH)
         self.d3 = sig.signal
         sig.reset()
 
@@ -82,22 +99,23 @@ class SpaceSignalProcessing:
         """
 
         # octave bands used for the processing
-        one_third_octave_bands = [[.08, .10],
-                                  [.10, .126],
-                                  [.126, .16],
-                                  [.16, .20],
-                                  [.20, .253],
-                                  [.253, .32],
-                                  [.32, .40],
-                                  [.40, .50],
-                                  [.50, .63],
-                                  ]
-
+        one_third_octave_bands = [
+            [.08, .10],
+            [.10, .126],
+            [.126, .16],
+            [.16, .20],
+            [.20, .253],
+            [.253, .32],
+            [.32, .40],
+            [.40, .50],
+            [.50, .63],
+        ]
 
         # setting for the processing
         self.DXmaxFast = 1
         nb_fft_min = 256  # minimum number of samples for the power spectral density
-        derivative = [0, 0, 0, 2, 2, 2, 2, 2, 2]  # number of times that each frequency band is derived
+        derivative = [0, 0, 0, 2, 2, 2, 2, 2,
+                      2]  # number of times that each frequency band is derived
 
         # RMS of the square root of the power spectral density
         self.rms_bands = np.zeros(len(one_third_octave_bands))
@@ -111,26 +129,34 @@ class SpaceSignalProcessing:
             self.signal = self.signal_raw * 1000
 
         # compute the power spectral density
-        n_fft = int(np.max([2 ** (np.ceil(np.log2(len(self.signal)))), nb_fft_min]))
+        n_fft = int(
+            np.max([2**(np.ceil(np.log2(len(self.signal)))), nb_fft_min]))
         # if signal is odd length, add a zero to make it even
         if len(self.signal) % 2 != 0:
             signal = np.append(self.signal, 0)
-            coordinates = np.append(self.coordinates, self.coordinates[-1] + (self.coordinates[1] - self.coordinates[0]))
+            coordinates = np.append(
+                self.coordinates, self.coordinates[-1] +
+                (self.coordinates[1] - self.coordinates[0]))
         else:
             signal = self.signal
             coordinates = self.coordinates
-        sig = TimeSignalProcessing(coordinates, signal, Fs=self.fs, window=Windows.HAMMING,
+        sig = TimeSignalProcessing(coordinates,
+                                   signal,
+                                   Fs=self.fs,
+                                   window=Windows.HAMMING,
                                    window_size=len(signal))
         sig.psd(nb_points=n_fft, detrend=False)
 
         # compute the rsm psd
-        self.__rms_effective(sig.frequency_Pxx, sig.Pxx, one_third_octave_bands, derivative)
+        self.__rms_effective(sig.frequency_Pxx, sig.Pxx,
+                             one_third_octave_bands, derivative)
         # compute the effective values
         self.__effective_values(one_third_octave_bands, derivative)
 
-
-    def __rms_effective(self, frequency: npt.NDArray[np.float64], Pxx: npt.NDArray[np.float64],
-                        one_third_octave_bands: List[Tuple[float, float]], derivative: List[int]):
+    def __rms_effective(self, frequency: npt.NDArray[np.float64],
+                        Pxx: npt.NDArray[np.float64],
+                        one_third_octave_bands: List[Tuple[float, float]],
+                        derivative: List[int]):
         """
         Computes RMS square root of power spectral density
 
@@ -148,10 +174,13 @@ class SpaceSignalProcessing:
         for i, band in enumerate(one_third_octave_bands):
             # find indexes where the bands exist
             idx = np.where((frequency >= band[0]) & (frequency < band[1]))[0]
-            Pxx[idx] = (2 * np.pi * frequency[idx]) ** (2 * derivative[i]) * Pxx[idx]
+            Pxx[idx] = (2 * np.pi * frequency[idx])**(2 *
+                                                      derivative[i]) * Pxx[idx]
             self.rms_bands[i] = np.sqrt(np.sum(Pxx[idx] * delta_f))
 
-    def __effective_values(self, one_third_octave_bands: List[Tuple[float, float]], derivative: List[int]):
+    def __effective_values(self, one_third_octave_bands: List[Tuple[float,
+                                                                    float]],
+                           derivative: List[int]):
         """
         Computes the effective values of the signal
 
@@ -170,8 +199,13 @@ class SpaceSignalProcessing:
 
         for i, band in enumerate(one_third_octave_bands):
             derivative_value = derivative[i]
-            sig = TimeSignalProcessing(self.coordinates, self.signal, Fs=self.fs)
-            sig.filter(np.array(band), N=3, type_filter="bandpass", filter_design=FilterDesign.BUTTERWORTH)
+            sig = TimeSignalProcessing(self.coordinates,
+                                       self.signal,
+                                       Fs=self.fs)
+            sig.filter(np.array(band),
+                       N=3,
+                       type_filter="bandpass",
+                       filter_design=FilterDesign.BUTTERWORTH)
             new_signal = sig.signal
 
             while derivative_value != 0:
@@ -181,7 +215,8 @@ class SpaceSignalProcessing:
             ksi = np.linspace(0, n * tau, int(n * tau / dx + 1))
             g = fout * np.exp(-ksi / tau)
 
-            convoluted_signal = np.sqrt(np.convolve(new_signal**2, g) * dx / tau)
+            convoluted_signal = np.sqrt(
+                np.convolve(new_signal**2, g) * dx / tau)
             self.max_fast[i] = np.max(convoluted_signal)
             idx = np.floor((len(self.signal) - np.floor(self.DXmaxFast / dx)) / 2) + \
                   np.linspace(0, np.floor(self.DXmaxFast / dx)-1, int(np.floor(self.DXmaxFast / dx)))

SignalProcessingTools/time_signal.py

@@ -14,6 +14,7 @@ class FilterDesign(Enum):
     CHEBYSHEV = 2
     ELLIPTIC = 3
 
+
 class IntegrationRules(Enum):
     """
     Integration rules
@@ -21,6 +22,7 @@ class IntegrationRules(Enum):
     TRAPEZOID = 1
     SIMPSON = 2
 
+
 class Windows(Enum):
     """
     Windows types
@@ -34,10 +36,12 @@ class Windows(Enum):
     RECTANGULAR = 'boxcar'
     TRIANG = 'triang'
 
+
 class TimeSignalProcessing:
     """
     Signal processing class for time signals
     """
+
     def __init__(self,
                  time: npt.NDArray[np.float64],
                  signal: npt.NDArray[np.float64],
@@ -71,8 +75,7 @@ class TimeSignalProcessing:
         self.Sxx = None
         self.frequency_Sxx = None
         self.time_Sxx = None
-        self.fft_settings = {"nb_points": None,
-                             "half_representation": False}
+        self.fft_settings = {"nb_points": None, "half_representation": False}
         # Track operations performed on the signal
         self.operations = []
 
@@ -93,25 +96,38 @@ class TimeSignalProcessing:
             self.use_window = False
         else:
             if window_size == 0:
-                raise ValueError("When using a window the `window_size` must be specified")
+                raise ValueError(
+                    "When using a window the `window_size` must be specified")
             if window_size % 2 != 0:
                 raise ValueError("Window length must be even")
             if window not in Windows:
-                raise ValueError(f"Window type {window} not supported. Available types: {list(Windows)}")
+                raise ValueError(
+                    f"Window type {window} not supported. Available types: {list(Windows)}"
+                )
             if window_size > signal_length:
-                raise ValueError(f"Window length ({window_size}) cannot be greater than signal length ({signal_length}).")
+                raise ValueError(
+                    f"Window length ({window_size}) cannot be greater than signal length ({signal_length})."
+                )
 
             self.window = self.__create_window(window, window_size)
             self.window_size = window_size
             self.window_type = window
-            self.nb_windows = int(np.ceil((signal_length / window_size) * 2 - 2))
+            self.nb_windows = int(
+                np.ceil((signal_length / window_size) * 2 - 2))
             self.use_window = True
 
             # pad signal at the end if necessary to get full windows
             if signal_length % window_size != 0:
-                self.signal = np.append(self.signal, np.zeros(window_size - (signal_length % window_size)))
-                self.time = np.append(self.time, np.zeros(window_size - (signal_length % window_size)))
-                self.operations.append(f"Signal padded with zeros (original length: {signal_length}, new length: {len(self.signal)})")
+                self.signal = np.append(
+                    self.signal,
+                    np.zeros(window_size - (signal_length % window_size)))
+                self.time = np.append(
+                    self.time, self.time[-1] + np.cumsum(
+                        np.ones(window_size - (signal_length % window_size)) *
+                        (1 / Fs)))
+                self.operations.append(
+                    f"Signal padded with zeros (original length: {signal_length}, new length: {len(self.signal)})"
+                )
 
     def __str__(self) -> str:
         """
@@ -148,7 +164,8 @@ class TimeSignalProcessing:
         return "\n".join(info)
 
     @staticmethod
-    def __create_window(window_type: Windows, size: int) -> npt.NDArray[np.float64]:
+    def __create_window(window_type: Windows,
+                        size: int) -> npt.NDArray[np.float64]:
         """
         Create a window array of specified type and size
 
@@ -234,10 +251,10 @@ class TimeSignalProcessing:
             # peak amplitude of stationary sinusoids.
             spectrum_w[:, w] = np.fft.fft(signal_w, nfft) / normalise_fct
 
-
         self.amplitude = np.mean(np.abs(spectrum_w), axis=1)
         # self.phase = np.unwrap(np.angle(np.mean(spectrum_w, axis=1)))
-        self.phase = np.angle(np.mean(np.exp(1j * np.angle(spectrum_w)), axis=1))
+        self.phase = np.angle(
+            np.mean(np.exp(1j * np.angle(spectrum_w)), axis=1))
 
         # compute frequency
         self.frequency = np.linspace(0, 1, nfft) * self.Fs
@@ -249,9 +266,11 @@ class TimeSignalProcessing:
             self.phase = self.phase[:int(nfft / 2)]
 
         # FFT settings: needed to perform inverse FFT
-        self.fft_settings = {"nb_points": nfft,
-                             "half_representation": half_representation,
-                             "odd_length": odd_length}
+        self.fft_settings = {
+            "nb_points": nfft,
+            "half_representation": half_representation,
+            "odd_length": odd_length
+        }
 
         # Add to operations list
         op_info = f"FFT (points: {nfft}, half representation: {half_representation})"
@@ -275,7 +294,8 @@ class TimeSignalProcessing:
             "Please compute FFT with full representation.")
 
         if self.use_window:
-            raise ValueError("Cannot perform inverse FFT on the windowed signal.")
+            raise ValueError(
+                "Cannot perform inverse FFT on the windowed signal.")
 
         # get FFT settings
         odd_length = self.fft_settings["odd_length"]
@@ -290,7 +310,8 @@ class TimeSignalProcessing:
         # inverse of the FFT signal
         self.signal_inv = np.real(spectrum_inv) * len(spectrum)
         # time from frequency
-        self.time_inv = np.cumsum(np.ones(len(spectrum)) * 1 / self.Fs) - 1 / self.Fs
+        self.time_inv = np.cumsum(
+            np.ones(len(spectrum)) * 1 / self.Fs) - 1 / self.Fs
 
         if odd_length:
             # remove last sample
@@ -298,11 +319,17 @@ class TimeSignalProcessing:
             self.time_inv = self.time_inv[:-1]
 
         # Add to operations list
-        self.operations.append("Inverse FFT" + (" with windowing" if self.use_window else ""))
-
-    def integrate(self, rule: IntegrationRules = IntegrationRules.TRAPEZOID,
-                  baseline: bool = False, moving: bool = False, hp: bool = False, ini_cond: float = 0.,
-                  fpass: float = 0.5, n: int = 6):
+        self.operations.append("Inverse FFT" +
+                               (" with windowing" if self.use_window else ""))
+
+    def integrate(self,
+                  rule: IntegrationRules = IntegrationRules.TRAPEZOID,
+                  baseline: bool = False,
+                  moving: bool = False,
+                  hp: bool = False,
+                  ini_cond: float = 0.,
+                  fpass: float = 0.5,
+                  n: int = 6):
         """
         Numerical integration of signal
 
@@ -322,9 +349,13 @@ class TimeSignalProcessing:
 
         # integration rule
         if rule == IntegrationRules.TRAPEZOID:
-            self.signal = integrate.cumulative_trapezoid(self.signal, self.time, initial=ini_cond)
+            self.signal = integrate.cumulative_trapezoid(self.signal,
+                                                         self.time,
+                                                         initial=ini_cond)
         elif rule == IntegrationRules.SIMPSON:
-            self.signal = integrate.cumulative_simpson(self.signal, x=self.time, initial=ini_cond)
+            self.signal = integrate.cumulative_simpson(self.signal,
+                                                       x=self.time,
+                                                       initial=ini_cond)
         else:
             sys.exit("Integration rule not supported")
 
@@ -346,13 +377,18 @@ class TimeSignalProcessing:
         if moving:
             op_details.append("moving average correction")
         if hp:
-            op_details.append(f"highpass filter (cutoff: {fpass} Hz, order: {n})")
+            op_details.append(
+                f"highpass filter (cutoff: {fpass} Hz, order: {n})")
 
         self.operations.append(f"Integration ({', '.join(op_details)})")
 
-
-    def filter(self, Fpass: float, N: int, filter_design: FilterDesign = FilterDesign.ELLIPTIC,
-               type_filter: str = "lowpass", rp: float = 0.01, rs: int = 60):
+    def filter(self,
+               Fpass: float,
+               N: int,
+               filter_design: FilterDesign = FilterDesign.ELLIPTIC,
+               type_filter: str = "lowpass",
+               rp: float = 0.01,
+               rs: int = 60):
         """
         Filter signal
 
@@ -377,11 +413,23 @@ class TimeSignalProcessing:
 
         # design filter
         if filter_design == FilterDesign.ELLIPTIC:
-            z, p, k = signal.ellip(N, rp, rs, np.array(Fpass) / (self.Fs / 2), btype=type_filter, output='zpk')
+            z, p, k = signal.ellip(N,
+                                   rp,
+                                   rs,
+                                   np.array(Fpass) / (self.Fs / 2),
+                                   btype=type_filter,
+                                   output='zpk')
         elif filter_design == FilterDesign.BUTTERWORTH:
-            z, p, k = signal.butter(N, np.array(Fpass) / (self.Fs / 2), btype=type_filter, output='zpk')
+            z, p, k = signal.butter(N,
+                                    np.array(Fpass) / (self.Fs / 2),
+                                    btype=type_filter,
+                                    output='zpk')
         elif filter_design == FilterDesign.CHEBYSHEV:
-            z, p, k = signal.cheby1(N, rp, np.array(Fpass) / (self.Fs / 2), btype=type_filter, output='zpk')
+            z, p, k = signal.cheby1(N,
+                                    rp,
+                                    np.array(Fpass) / (self.Fs / 2),
+                                    btype=type_filter,
+                                    output='zpk')
 
         sos = signal.zpk2sos(z, p, k)
 
@@ -389,8 +437,8 @@ class TimeSignalProcessing:
         self.signal = signal.sosfiltfilt(sos, self.signal)
 
         # Add to operations list
-        self.operations.append(f"Filter ({type_filter}, cutoff: {Fpass} Hz, order: {N})")
-
+        self.operations.append(
+            f"Filter ({type_filter}, cutoff: {Fpass} Hz, order: {N})")
 
     def psd(self, detrend: str = "linear", nb_points: Optional[int] = None):
         """
@@ -403,11 +451,15 @@ class TimeSignalProcessing:
         """
 
         if detrend not in ["linear", False]:
-            raise ValueError("Detrend method not supported. Available methods: ['linear', False]")
+            raise ValueError(
+                "Detrend method not supported. Available methods: ['linear', False]"
+            )
 
         # check if window is initialized
         if not self.use_window:
-            raise ValueError("No window defined. Please define a window when initialising SignalProcessing.")
+            raise ValueError(
+                "No window defined. Please define a window when initialising SignalProcessing."
+            )
 
         # if nb_points is None: nb_points is window length
         if nb_points is None:
@@ -416,12 +468,18 @@ class TimeSignalProcessing:
             nfft = nb_points
 
         # compute PSD using Welch method
-        self.frequency_Pxx, self.Pxx = signal.welch(self.signal, fs=self.Fs, nperseg=self.window_size, nfft=nfft,
-                                                    window=self.window_type.value, scaling='density', detrend=detrend)
+        self.frequency_Pxx, self.Pxx = signal.welch(
+            self.signal,
+            fs=self.Fs,
+            nperseg=self.window_size,
+            nfft=nfft,
+            window=self.window_type.value,
+            scaling='density',
+            detrend=detrend)
 
         # Add to operations list
-        self.operations.append(f"PSD (window: {self.window_type.name}, size: {self.window_size})")
-
+        self.operations.append(
+            f"PSD (window: {self.window_type.name}, size: {self.window_size})")
 
     def v_eff_SBR(self, n: int = 4, tau: float = 0.125):
         """
@@ -438,13 +496,12 @@ class TimeSignalProcessing:
         qsi = np.linspace(0, n * tau, int(n * tau * self.Fs + 1))
         g = fout * np.exp(-qsi / tau)
 
-
         # Frequency weighting parameters
         v0 = 1 / 1000  # Reference velocity [m/s]
-        f0 = 5.6       # Reference frequency [Hz]
+        f0 = 5.6  # Reference frequency [Hz]
 
         # Handle even/odd signal length for FFT
-        if self.signal.shape[0]  % 2 != 0:
+        if self.signal.shape[0] % 2 != 0:
             nv1 = int(self.signal.shape[0] / 2 + 0.5)
             nv2 = int(self.signal.shape[0] / 2 - 0.5)
         else:
@@ -456,25 +513,25 @@ class TimeSignalProcessing:
         freq = np.arange(df, (nv1 + 1) * df, df)
 
         # Create high-pass weighting filter (human perception curve)
-        Hv = (1 / v0) * 1 / (np.sqrt(1 + (f0 / freq) ** 2))
+        Hv = (1 / v0) * 1 / (np.sqrt(1 + (f0 / freq)**2))
         Hv = np.append(0, Hv)  # Add DC component
 
         # Create low-pass filter with 50 Hz cutoff
         cut_off_number = int(np.ceil(50 / df))
         if cut_off_number < nv1:
             Hv2 = np.zeros(Hv.shape[0])
-            Hv2[:cut_off_number+1] = 1
+            Hv2[:cut_off_number + 1] = 1
         else:
             Hv2 = np.ones(Hv.shape[0])
 
         # Applies the frequency weighting functions
         Fv = np.fft.fft(self.signal)
-        Fhv = Hv2 * Hv * Fv[:nv1+1]
+        Fhv = Hv2 * Hv * Fv[:nv1 + 1]
         Fv = np.append(Fhv, np.flipud(np.conj(Fhv[1:nv2])))
         v_eff = np.real(np.fft.ifft(Fv))
 
         # moving root-mean-square through convolution with the exponential decay function `g`
-        v_eff = np.sqrt( np.convolve(v_eff**2, g) * (1 / self.Fs) /tau)
+        v_eff = np.sqrt(np.convolve(v_eff**2, g) * (1 / self.Fs) / tau)
 
         self.v_eff = v_eff[:self.signal.shape[0]]
 
@@ -514,14 +571,19 @@ class TimeSignalProcessing:
         Compute spectrogram of signal
         """
         # compute spectrogram
-        f, t, Sxx = signal.spectrogram(self.signal, fs=self.Fs, window=self.window_type.value,
-                                       nperseg=self.window_size, noverlap=self.window_size // 8)
+        f, t, Sxx = signal.spectrogram(self.signal,
+                                       fs=self.Fs,
+                                       window=self.window_type.value,
+                                       nperseg=self.window_size,
+                                       noverlap=self.window_size // 8)
         self.Sxx = Sxx
         self.frequency_Sxx = f
         self.time_Sxx = t
 
         # Add to operations list
-        self.operations.append(f"Spectrogram (nperseg: {self.window_size}, noverlap: {self.window_size // 8})")
+        self.operations.append(
+            f"Spectrogram (nperseg: {self.window_size}, noverlap: {self.window_size // 8})"
+        )
 
     def one_third_octave_bands(self):
         """
@@ -534,24 +596,31 @@ class TimeSignalProcessing:
         # https://en.wikipedia.org/wiki/Octave_band
         initial_frequency_band_number = -20
         final_frequency_band_number = 33
-        names = ("10", "12.5", "16", "20", "25", "31.5", "40", "50", "63", "80", "100", "125", "160", "200", "250", "315", "400",
-                 "500", "630", "800", "1000", "1250", "1600", "2000", "2500", "3.150", "4000", "5000", "6300", "8000",
-                 "10000", "12500", "16000", "20000")
+        names = ("10", "12.5", "16", "20", "25", "31.5", "40", "50", "63",
+                 "80", "100", "125", "160", "200", "250", "315", "400", "500",
+                 "630", "800", "1000", "1250", "1600", "2000", "2500", "3.150",
+                 "4000", "5000", "6300", "8000", "10000", "12500", "16000",
+                 "20000")
 
         # compute centre frequencies of the bands
-        f_centre = 1000 * (2 ** (np.arange(initial_frequency_band_number, final_frequency_band_number) / 3))
-        f_upper = f_centre * (2 ** (1 / 6))
-        f_lower = f_centre / (2 ** (1 / 6))
+        f_centre = 1000 * (2**(np.arange(initial_frequency_band_number,
+                                         final_frequency_band_number) / 3))
+        f_upper = f_centre * (2**(1 / 6))
+        f_lower = f_centre / (2**(1 / 6))
 
         # sum the signal for the bands
         if (self.Pxx is None) and (self.amplitude is None):
-            raise ValueError("No PSD nor FFT computed. Please compute either first.")
+            raise ValueError(
+                "No PSD nor FFT computed. Please compute either first.")
 
         if self.Pxx is not None:
             # determine the frequency bands
-            idx = np.where((f_lower < np.max(self.frequency_Pxx)) & (f_upper > np.min(self.frequency_Pxx)))[0]
+            idx = np.where((f_lower < np.max(self.frequency_Pxx))
+                           & (f_upper > np.min(self.frequency_Pxx)))[0]
             if len(idx) == 0:
-                raise ValueError("No frequency bands found in the PSD. Please check the frequency bands.")
+                raise ValueError(
+                    "No frequency bands found in the PSD. Please check the frequency bands."
+                )
 
             delta_f = self.frequency_Pxx[1] - self.frequency_Pxx[0]
 
@@ -561,14 +630,19 @@ class TimeSignalProcessing:
 
             for i, val in enumerate(idx):
                 self.octave_bands_Pxx[i] = float(names[val])
-                mask = (self.frequency_Pxx >= f_lower[val]) & (self.frequency_Pxx < f_upper[val])
-                self.octave_bands_Pxx_power[i] = np.sum(self.Pxx[mask] * delta_f)
+                mask = (self.frequency_Pxx
+                        >= f_lower[val]) & (self.frequency_Pxx < f_upper[val])
+                self.octave_bands_Pxx_power[i] = np.sum(self.Pxx[mask] *
+                                                        delta_f)
 
         if self.amplitude is not None:
             # determine the frequency bands
-            idx = np.where((f_lower < np.max(self.frequency)) & (f_upper > np.min(self.frequency)))[0]
+            idx = np.where((f_lower < np.max(self.frequency))
+                           & (f_upper > np.min(self.frequency)))[0]
             if len(idx) == 0:
-                raise ValueError("No frequency bands found in the FFT. Please check the frequency bands.")
+                raise ValueError(
+                    "No frequency bands found in the FFT. Please check the frequency bands."
+                )
 
             # compute the FFT for the bands
             self.octave_bands_fft = np.zeros(len(idx))
@@ -576,5 +650,7 @@ class TimeSignalProcessing:
 
             for i, val in enumerate(idx):
                 self.octave_bands_fft[i] = float(names[val])
-                mask = (self.frequency >= f_lower[val]) & (self.frequency < f_upper[val])
-                self.octave_bands_fft_power[i] = np.sum(self.amplitude[mask]**2)
+                mask = (self.frequency >= f_lower[val]) & (self.frequency
+                                                           < f_upper[val])
+                self.octave_bands_fft_power[i] = np.sum(
+                    self.amplitude[mask]**2)

{signalprocessingtools-1.2.2.dist-info → signalprocessingtools-1.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SignalProcessingTools
-Version: 1.2.2
+Version: 1.2.4
 Summary: Signal processing tools
 Author: attr: SignalProcessingTools.__author__
 Author-email: bruno.zuadacoelho@deltares.nl, aron.noordam@deltares.nl
@@ -13,8 +13,9 @@ Requires-Dist: matplotlib>=3.10
 Requires-Dist: numpy>=2.2
 Requires-Dist: scipy>=1.15
 Provides-Extra: testing
-Requires-Dist: pytest>=8.3; extra == "testing"
-Requires-Dist: tox>=4.24; extra == "testing"
+Requires-Dist: pytest>=8.0; extra == "testing"
+Requires-Dist: tox>=4.13; extra == "testing"
+Requires-Dist: pre_commit>=4.2.0; extra == "testing"
 
 # SignalProcessingTools
 

signalprocessingtools-1.2.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+SignalProcessingTools/__init__.py,sha256=nMXg9GFsk8gCcyBnh1MAeUPvo4Zcuv3sdwGHZrxfpPE,36
+SignalProcessingTools/__version__.py,sha256=V_BrxIpTLkU66higGwyPgbY3Y9GEmDzhELMqlxzfhW0,106
+SignalProcessingTools/space_signal.py,sha256=GOg0gLkAZWDWqZiOMd9GJLF8pLuEvk21ub_PtD21AWs,8303
+SignalProcessingTools/time_signal.py,sha256=yeWnCW6CGOZGfhE9vv1OSSeroa14vdVP1RCpwlWz4EU,24324
+signalprocessingtools-1.2.4.dist-info/METADATA,sha256=sWUWxUJx3ETAvLfSJ0NHUIwXQhh6yh6uO34xga0efHg,4485
+signalprocessingtools-1.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+signalprocessingtools-1.2.4.dist-info/top_level.txt,sha256=BzkLqG2CNDmcYLCI_-5cmnV91uDRfxNGotNulq6m4pk,22
+signalprocessingtools-1.2.4.dist-info/RECORD,,

{signalprocessingtools-1.2.2.dist-info → signalprocessingtools-1.2.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

signalprocessingtools-1.2.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-SignalProcessingTools/__init__.py,sha256=nMXg9GFsk8gCcyBnh1MAeUPvo4Zcuv3sdwGHZrxfpPE,36
-SignalProcessingTools/__version__.py,sha256=Lucz6_GwEnJ-LUvdGCXZC1n22nCjuvH9BJ1r985KRbI,106
-SignalProcessingTools/space_signal.py,sha256=Pq_S2EimxSIjBWdz7pkaNDypOFdI6YXZE7PrsVbwueg,7572
-SignalProcessingTools/time_signal.py,sha256=GAlA34B6qjkuvwsANixYS8rC7VR4jedpyg3IoMwIwXM,22505
-signalprocessingtools-1.2.2.dist-info/METADATA,sha256=oBGbc0RGlUcw1j0S2ZNVyygKjmZsdWgdkVQzrBLMVp0,4432
-signalprocessingtools-1.2.2.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-signalprocessingtools-1.2.2.dist-info/top_level.txt,sha256=BzkLqG2CNDmcYLCI_-5cmnV91uDRfxNGotNulq6m4pk,22
-signalprocessingtools-1.2.2.dist-info/RECORD,,