Modal-Decomposition 0.0.4__tar.gz → 0.1.0__tar.gz

{modal_decomposition-0.0.4 → modal_decomposition-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Modal-Decomposition
-Version: 0.0.4
+Version: 0.1.0
 Summary: a package for modal decomposition
 Author-email: Mao_HaoChuan <2215269365@qq.com>
 License: Apache-2.0
@@ -22,6 +22,7 @@ Requires-Dist: scipy
 Requires-Dist: antropy
 Requires-Dist: tqdm
 Requires-Dist: vmdpy
+Requires-Dist: psutil
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black; extra == "dev"
@@ -97,6 +98,7 @@ This lib's dependence are:
 - [numpy](https://github.com/numpy/numpy)
 - [scipy](https://github.com/scipy/scipy)
 - [vmdpy](https://github.com/vrcarva/vmdpy)
+- [psutil](https://github.com/giampaolo/psutil)
 
 *Other dependence please read "requirements.txt"*
 

{modal_decomposition-0.0.4 → modal_decomposition-0.1.0}/README.md

@@ -66,6 +66,7 @@ This lib's dependence are:
 - [numpy](https://github.com/numpy/numpy)
 - [scipy](https://github.com/scipy/scipy)
 - [vmdpy](https://github.com/vrcarva/vmdpy)
+- [psutil](https://github.com/giampaolo/psutil)
 
 *Other dependence please read "requirements.txt"*
 

{modal_decomposition-0.0.4 → modal_decomposition-0.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Modal-Decomposition"
-version = "0.0.4"
+version = "0.1.0"
 requires-python = ">=3.8"
 
 authors = [
@@ -28,7 +28,8 @@ dependencies = [
     "scipy",
     "antropy",
     "tqdm",
-    "vmdpy"
+    "vmdpy",
+    "psutil"
 ]
 optional-dependencies = {"dev"=["pytest>=7.0", "black"], "plot"=["matplotlib"]}
 

modal_decomposition-0.1.0/src/Modal_Decomposition/CEEFD.py

@@ -0,0 +1,132 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    EMD-S - 1.9.0
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the CEEFD and CEEMDAN.
+
+Modify:  (must)
+    2026.3.25 - Create
+    2026.3.30 - Desperate the CEEMDAN and the CEEFD, and rename the Cyclic_CEEFD as CEEFD, del the origin CEEFD.
+"""
+
+import numpy as np
+from typing import Union, Tuple
+
+
+class ceefd:
+    """CEEFD: Cyclic Envelop Empirical Fourier Decomposition"""
+
+    def __init__(self, fs=1.0, min_peak_distance=10, envelop_iter=3):
+        self.fs = fs
+        self.min_peak_distance = min_peak_distance
+        self.envelop_iter = envelop_iter
+
+    def __call__(self, S):
+        return self.decompose(S)
+
+    def _compute_spectral_envelope(self, mag_spectrum):
+        from scipy.signal import windows
+
+        n = len(mag_spectrum)
+        envelope = np.copy(mag_spectrum)
+        window_size = int(0.05 * n)
+        window = windows.boxcar(window_size)
+
+        for _ in range(self.envelop_iter):
+            envelope = np.convolve(envelope, window, mode='same') / window_size
+            envelope = np.maximum(envelope, mag_spectrum)
+        return envelope
+
+    def _extract_imf(self, signal, freq_bins):
+        N = len(signal)
+        fft_signal = np.fft.fft(signal)
+
+        mask = np.zeros(N, dtype=bool)
+        mask[freq_bins] = True
+        mask[N - np.array(freq_bins)] = True
+
+        imf_fft = fft_signal * mask
+        imf = np.fft.ifft(imf_fft).real
+
+        return imf, mask
+
+    def decompose(self, S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        CEEFD: Cyclic Envelope Empirical Fourier Decomposition
+
+        :param S: Signal
+        :param T: Time-axis, accepted formation is Unix array. Default uniformly sample.
+        :return: IMFs (2-dim), Res (1-dim)
+        """
+
+        from scipy.signal import find_peaks
+
+        if not isinstance(S, np.ndarray):
+            S = np.array(S)
+
+        if S.ndim == 0:
+            raise ValueError("The dim of the S must be 1-dim, not 0")
+
+        elif S.ndim > 1:
+            if 1 in S.shape:
+                S = S.reshape(-1)
+
+            else:
+                raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
+
+        N = len(S)
+
+        if T is None:  # if T is None, default generate uniform T-axis.
+            T = np.arange(N)  # default fs = 1
+            print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+
+        else:
+            if not isinstance(T, np.ndarray):
+                T = np.array(T)
+
+        fft_signal = np.fft.fft(S)
+        mag_spectrum = np.abs(fft_signal[:N // 2 + 1])
+
+        envelope = self._compute_spectral_envelope(mag_spectrum)
+
+        peaks, properties = find_peaks(envelope, distance=self.min_peak_distance)
+
+        if len(peaks) == 0:
+            return [S], []
+
+        boundaries = [0]
+        for i in range(len(peaks) - 1):
+            boundary = (peaks[i] + peaks[i + 1]) // 2
+            boundaries.append(boundary)
+        boundaries.append(N // 2)
+
+        imfs = []
+        freq_masks = []
+
+        for i in range(len(boundaries) - 1):
+            start_bin = boundaries[i]
+            end_bin = boundaries[i + 1]
+
+            if end_bin - start_bin < 2:
+                continue
+
+            freq_bins = list(range(start_bin, end_bin))
+            imf, mask = self._extract_imf(S, freq_bins)
+            imfs.append(imf)
+            freq_masks.append(mask)
+
+        residual = S.copy()
+        for imf in imfs:
+            residual -= imf
+
+        if np.abs(residual).max() > 1e-10:
+            imfs.append(residual)
+
+        return np.array(imfs), residual

modal_decomposition-0.1.0/src/Modal_Decomposition/CEEMD.py

@@ -0,0 +1,135 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+	time - 1.39.2
+	tqdm - 4.67.3
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the CEEMD.
+
+Modify:  (must)
+    2026.3.25 - Create
+    2026.4.2  - Finish the Optimization of the CEEMD.
+"""
+
+from typing import Union, Tuple, Optional
+from time import sleep
+import numpy as np
+from .EMD import emd
+from .Utils import monotonic_increasing, monotonic_decreasing
+from tqdm import tqdm
+from warnings import warn
+
+
+def ceemd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, N_whitenoise=37, beta=0.3, max_imf: Optional[int]=None, dead_line: int=10, verbose: bool=False) \
+        -> Tuple[np.ndarray, np.ndarray]:
+    """
+    CEEMD: Complementary Ensemble Empirical Mode Decomposition
+
+    :param S: Signal (1-dim)
+    :param T: the time axis.
+    :param N_whitenoise: the num of the added whitenoise.
+    :param beta:
+    :param max_imf: -1, None or other int | -1 means decompose completely, None means give a int auto, other int means the num of the IMFs
+    :param dead_line: Sometime it'll be in unuseful cycle, when the average of the N's sequence with added whitenoise is empty([]). It'll be forced exit when the time of the cycle above the deadline.
+    :param verbose:
+    :return: IMFs (n_IMFs, N), Res (N,)
+    """
+    if beta <= 0:
+        raise ValueError("The beta should > 0")
+
+    if N_whitenoise <= 0 or not isinstance(N_whitenoise, int):
+        raise TypeError("N_whitenoise must be int type or > 0")
+
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
+    if S.ndim == 0:
+        raise ValueError("The dim of the S must be 1-dim, not 0")
+
+    elif S.ndim > 1:
+        if 1 in S.shape:
+            S = S.reshape(-1)
+
+        else:
+            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
+
+    N = len(S)
+
+    if T is None:  # if T is None, default generate uniform T-axis.
+        T = np.arange(N)  # default fs = 1
+        print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+
+    else:
+        if not isinstance(T, np.ndarray):
+            T = np.array(T)
+
+        if len(T) != len(S):
+            raise ValueError("The length of T must be equal to Signal.")
+
+        if not np.all(np.diff(T) > 0):
+            raise ValueError("T should be monotonic increasing!")
+
+        if np.any(np.allclose(np.diff(np.diff(T)))):
+            warn("The T is not uniform! Some error may happen.")
+
+    if max_imf is None:
+        max_imf = int(np.log2(len(S))) + 2
+
+    Res = S
+    IMFs = []
+
+    # std_dev = np.std(S)
+
+    count = 0
+    dead_cycle = 0
+    while True:
+        std_dev = np.std(Res)
+
+        _IMFs = []
+        for n in range(N_whitenoise):
+            white_noise = np.random.normal(0, std_dev * beta, N)
+            S_plus = Res + white_noise
+            S_minus = Res - white_noise
+            _IMFs_plus, _ = emd(S_plus, T, max_imf=1)
+            _IMFs_minus, _ = emd(S_minus, T, max_imf=1)
+
+            if not _IMFs_plus or not _IMFs_minus:
+                continue
+
+            _IMFs.append((_IMFs_plus[0] + _IMFs_minus[0]) / 2.0)
+
+        if not _IMFs:
+            dead_cycle += 1
+            continue
+
+        if dead_cycle >= dead_line:
+            raise RuntimeError("Trapped in a vicious cycle")
+        else:
+            dead_cycle = 0
+
+        IMF = np.mean(_IMFs, axis=0)
+
+        IMFs.append(IMF)
+
+        Res -= IMF
+        count += 1
+
+        if verbose:
+            if count % 10 == 0:
+                print(f"has get {count} IMFs...")
+                sleep(1)
+
+        if max_imf != -1:
+            if count >= max_imf or monotonic_increasing(Res) or monotonic_decreasing(Res):
+                return np.array(IMFs), np.array(Res)
+
+        else:
+            if monotonic_increasing(Res) or monotonic_decreasing(Res):
+                return np.array(IMFs), np.array(Res)

modal_decomposition-0.1.0/src/Modal_Decomposition/CEEMDAN.py

@@ -0,0 +1,92 @@
+from typing import Union, Tuple
+import numpy as np
+
+def ceemdan \
+    (
+        S: Union[list, np.ndarray], T: Union[list, np.ndarray] = None,
+        max_imf: int = -1,
+        trials=10,
+        noise_width=0.05,  # default: 0.05-0.3
+        noise_seed=42,  # seed
+        spline_kind='cubic',
+        nbsym=2,  # Number of boundary symmetry points
+        extrema_detection='parabol',
+        parallel=False,
+        processes=None,  # None = auto, int >= 1
+        random_state=42,
+        noise_scale=1.0,  # scale factor of noise
+        noise_kind='normal',  # noise kind: 'normal', 'uniform'
+        range_thr=0.01,  # Stop threshold
+        total_power_thr=0.005
+    ) -> Tuple[np.ndarray, np.ndarray]:
+
+    """
+    CEEMDAN: Complete Ensemble Empirical Mode Decomposition with Adaptive Noise
+
+    :param S: Signal (1-dim)
+    :param T: Time axis (1-dim). Default uniform, or input the Unix.
+    :param max_imf: the num of the decomposed IMFs. | -1 means all.
+    :param trials:
+    :param noise_width:
+    :param noise_seed:
+    :param spline_kind:
+    :param nbsym:
+    :param extrema_detection:
+    :param parallel:
+    :param processes:
+    :param random_state:
+    :param noise_scale:
+    :param noise_kind:
+    :param range_thr:
+    :param total_power_thr:
+    :return: IMFs (n_IMFs, N), Res (N,)
+    """
+
+    from PyEMD import CEEMDAN
+
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
+    if S.ndim == 0:
+        raise ValueError("The dim of the S must be 1-dim, not 0")
+
+    elif S.ndim > 1:
+        if 1 in S.shape:
+            S = S.reshape(-1)
+
+        else:
+            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
+
+    N = len(S)
+
+    if T is None:  # if T is None, default generate uniform T-axis.
+        T = np.arange(N)  # default fs = 1
+        print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+
+    else:
+        if not isinstance(T, np.ndarray):
+            T = np.array(T)
+
+    CEEMDAN = CEEMDAN \
+    (
+        trials=trials,
+        noise_width=noise_width,
+        noise_seed=noise_seed,
+        spline_kind=spline_kind,
+        nbsym=nbsym,
+        extrema_detection=extrema_detection,
+        parallel=parallel,
+        processes=processes,
+        random_state=random_state,
+        noise_scale=noise_scale,
+        noise_kind=noise_kind,
+        range_thr=range_thr,
+        total_power_thr=total_power_thr
+    )
+
+    IMF_Residue = CEEMDAN.ceemdan(S, T, max_imf)
+
+    IMFs = IMF_Residue[:-1, :]  # shape [n_imfs, len(S)]
+    Res = IMF_Residue[-1, :]
+
+    return IMFs, Res

modal_decomposition-0.1.0/src/Modal_Decomposition/EEMD.py

@@ -0,0 +1,130 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    EMD-S - 1.9.0
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the EEMD.
+
+Modify:  (must)
+    2026.3.25 - Create.
+    2026.3.27 - Change the EEMD class' usage. EEMD(parallel=True) (default) -> EEMD(parallel=False). Now, it will not use parallel default.
+    2026.4.2  - Finish the Optimization of the EEMD. Correct the logic.
+"""
+
+import numpy as np
+from typing import Union, Tuple, Optional
+from .Utils import monotonic_increasing, monotonic_decreasing
+from .Error import CycleError
+from time import sleep
+from warnings import warn
+from .EMD import emd
+
+
+def eemd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, N_whitenoise=300, beta=0.3, max_imf: Optional[int]=None, dead_line: int=10, verbose: bool=False) \
+        -> Tuple[np.ndarray, np.ndarray]:
+    """
+    EEMD: Ensemble Empirical Mode Decomposition
+
+    :param S: Signal (1-dim)
+    :param T: the time axis.
+    :param N_whitenoise: the num of the added whitenoise.
+    :param beta:
+    :param max_imf: -1, None or other int | -1 means decompose completely, None means give a int auto, other int means the num of the IMFs
+    :param dead_line: Sometime it'll be in unuseful cycle, when the average of the N's sequence with added whitenoise is empty([]). It'll be forced exit when the time of the cycle above the deadline.
+    :param verbose:
+    :return: IMFs (n_IMFs, N), Res (N,)
+    """
+    if beta <= 0:
+        raise ValueError("The beta should > 0")
+
+    if N_whitenoise <= 0 or not isinstance(N_whitenoise, int):
+        raise TypeError("N_whitenoise must be int type or > 0")
+
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
+    if S.ndim == 0:
+        raise ValueError("The dim of the S must be 1-dim, not 0")
+
+    elif S.ndim > 1:
+        if 1 in S.shape:
+            S = S.reshape(-1)
+
+        else:
+            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
+
+    N = len(S)
+
+    if T is None:  # if T is None, default generate uniform T-axis.
+        T = np.arange(N)  # default fs = 1
+        print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+
+    else:
+        if not isinstance(T, np.ndarray):
+            T = np.array(T)
+
+        if len(T) != len(S):
+            raise ValueError("The length of T must be equal to Signal.")
+
+        if not np.all(np.diff(T) > 0):
+            raise ValueError("T should be monotonic increasing!")
+
+        if np.any(np.allclose(np.diff(np.diff(T)))):
+            warn("The T is not uniform! Some error may happen.")
+
+    if max_imf is None:
+        max_imf = int(np.log2(len(S))) + 2
+
+    Res = S
+    IMFs = []
+
+    # std_dev = np.std(S)
+
+    count = 0
+    dead_cycle = 0
+    while True:
+        std_dev = np.std(Res)
+
+        _IMFs = []
+        for n in range(N_whitenoise):
+            white_noise = np.random.normal(0, std_dev * beta, N)
+            _S = Res + white_noise
+            _IMFs_, _ = emd(_S, T, max_imf=1)
+            if not _IMFs_:
+                continue
+            _IMFs.append(_IMFs_[0])
+
+        if not _IMFs:
+            dead_cycle += 1
+            continue
+
+        if dead_cycle >= dead_line:
+            raise RuntimeError("Trapped in a vicious cycle")
+        else:
+            dead_cycle = 0
+
+        IMF = np.mean(_IMFs, axis=0)
+
+        IMFs.append(IMF)
+
+        Res -= IMF
+        count += 1
+
+        if verbose:
+            if count % 10 == 0:
+                print(f"has get {count} IMFs...")
+                sleep(1)
+
+        if max_imf != -1:
+            if count >= max_imf or monotonic_increasing(Res) or monotonic_decreasing(Res):
+                return np.array(IMFs), np.array(Res)
+
+        else:
+            if monotonic_increasing(Res) or monotonic_decreasing(Res):
+                return np.array(IMFs), np.array(Res)

modal_decomposition-0.1.0/src/Modal_Decomposition/EFD.py

@@ -0,0 +1,143 @@
+"""
+Python version:  (must)
+    3.10.11
+
+Lib and Version:  (if None write None)
+    numpy - 2.2.6
+	scipy - 1.15.3
+	matplotlib - 3.10.8
+
+Only accessed by:  (must)
+    Only __init__.py
+
+Description: (if None write None)
+    Realize the EFD.
+    Optimize the use of scipy.S
+
+Modify:  (must)
+    2026.3.25 - Create
+    2026.4.2  - Finish the Optimization of the EFD. Del the origin efd function.
+"""
+
+import numpy as np
+from .COLOR import printc
+from typing import Union, Tuple
+
+
+def efd(S: Union[list, np.ndarray], T: Union[list, np.ndarray]=None, max_IMFs: int=-1) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    EFD: Empirical Fourier Decomposition
+
+    :param S: Signal (1-dim)
+    :param T: Time axis (1-dim)
+    :param max_IMFs: the num of the IMFs. -1 means return all IMFs
+    :return: IMFs (n_IMFs, N), Res: (N,)
+    """
+
+    from scipy.signal import argrelmax
+
+    if not isinstance(max_IMFs, int):
+        raise TypeError("The type of the max_IMFs must be int!")
+
+    if max_IMFs != -1 and max_IMFs <= 0:
+        if max_IMFs <= 0:
+            raise ValueError("Invalid value! Do you want use -1?")
+
+    if not isinstance(S, np.ndarray):
+        S = np.array(S)
+
+    if S.ndim == 0:
+        raise ValueError("The dim of the S must be 1-dim, not 0")
+
+    elif S.ndim > 1:
+        if 1 in S.shape:
+            S = S.reshape(-1)
+
+        else:
+            raise ValueError(f"The dim of S must be 1-dim, not {S.ndim}")
+
+    N = len(S)
+
+    if T is None:  # if T is None, default generate uniform T-axis.
+        T = np.arange(N)  # default fs = 1
+        print(f"Warn: T is None，default T = [0, 1, 2, ..., {N - 1}]")
+
+    else:
+        if not isinstance(T, np.ndarray):
+            T = np.array(T)
+
+    if len(T) != N:
+        raise ValueError(f"len of T: ({len(T)}) doesn't match ({N})")
+
+    dt = np.diff(T)
+    if not np.allclose(dt, dt[0], rtol=1e-10, atol=1e-14):
+        raise ValueError("Time series should be uniform intervals")
+
+    # make seq 0-mean value
+    MEAN = np.mean(S)
+    S: np.ndarray = S - np.mean(S)
+
+    F = np.fft.fft(S)
+    # fs = np.fft.fftfreq(N // 2 + 1, d=T[1]-T[0])  # only positive freq arr
+    magnitude = np.abs(F)
+    phase = np.angle(F)
+
+    edge_magnitude = magnitude[: N // 2 + 1].copy()[1:] * 2  # filter the dc(loc[0])
+    uniform_freq = np.linspace(0, np.pi, N // 2)
+    freq_N = len(uniform_freq)
+
+    local_maximum_points = argrelmax(edge_magnitude)
+    local_maximum = edge_magnitude[local_maximum_points]
+
+    if max_IMFs != -1:
+        local_maximum_zip = [(point, value) for point, value in zip(local_maximum_points, local_maximum)]
+
+        local_maximum_zip = sorted(local_maximum_zip, reverse=True, key=lambda x: x[1])
+
+        local_maximum_points = list(map(lambda x: x[0], local_maximum_zip[:max_IMFs]))
+
+    local_maximum_points = np.concatenate(([0], local_maximum_points, [freq_N - 1]))
+
+    local_maximum_points = np.unique(local_maximum_points)
+    local_maximum_points = np.sort(local_maximum_points)
+
+    wn = []  # the zero phase filter
+    for p in range(len(local_maximum_points) - 1):
+        next_point = local_maximum_points[p + 1]
+        current_point = local_maximum_points[p]
+
+        if edge_magnitude[current_point] == edge_magnitude[next_point]:
+            wn.append(current_point)
+
+        else:
+            # wn.append(np.argmin(edge_magnitude[current_point:next_point + 1]))
+            wn.append(current_point + np.argmin(edge_magnitude[current_point:next_point + 1]))
+    wn = np.concatenate(([0], wn, freq_N - 1))
+
+    filters_arr = []
+    for edge in range(1, len(wn)):
+        filter_single = np.zeros(freq_N)
+
+        current_point = wn[edge]
+        last_point = wn[edge - 1]
+
+        filter_single[last_point: current_point + 1] = 1
+        filters_arr.append(filter_single)
+
+    IMFs = []
+    M = N // 2 + 1
+    # the spectrum is symmetry, so we just need positive, and next, only need concentrate symmetrically.
+    for _filter in filters_arr:
+        filtered_magnitude = np.zeros(M, dtype=float)
+        filtered_magnitude[1:] = magnitude[1:M] * _filter
+        temp_spectrum = filtered_magnitude * np.exp(1j * phase[:M])
+
+        full_spectrum = np.zeros(N, dtype=complex)
+        full_spectrum[:M] = temp_spectrum  # complex temp_spectrum
+        for i in range(1, M - 1):
+            full_spectrum[N - i] = np.conj(temp_spectrum[i])
+
+        IMFs.append(np.fft.ifft(full_spectrum).real)
+
+    IMFs = np.array(IMFs)
+    return IMFs, S - np.sum(IMFs, axis=0) + MEAN