modulo-vki 2.0.6__py3-none-any.whl → 2.1.0__py3-none-any.whl

modulo_vki/__init__.py

@@ -1,23 +1 @@
-
-#from ._version import get_versions
-#__version__ = get_versions()['version']
-#del get_versions
-
-
-# from .utils.read_db import *
-# from .utils._utils import *
-# from .utils._plots import *
-# from .utils.others import *
-
-# from .core._k_matrix import *
-# from .core._dft import *
-# from .core._dmd_s import *
-# from .core._k_matrix import *
-# from .core._mpod_time import *
-# from .core._mpod_space import *
-# from .core._pod_time import *
-# from .core._pod_space import *
-# from .core._spod_s import *
-# from .core._spod_t import *
-
 from modulo_vki.modulo import ModuloVKI

modulo_vki/core/__init__.py

@@ -1,9 +1,9 @@
-from ._dft import *
-from ._dmd_s import *
-from ._k_matrix import *
-from ._mpod_space import *
-from ._mpod_time import *
-from ._pod_space import *
-from ._pod_time import *
-from ._spod_s import *
-from ._spod_t import *
+from ._dft import *
+from ._dmd_s import *
+from ._k_matrix import *
+from ._mpod_space import *
+from ._mpod_time import *
+from ._pod_space import *
+from ._pod_time import *
+from ._spod_s import *
+from ._spod_t import *

modulo_vki/core/_dft.py

@@ -1,61 +1,132 @@
-import os
-
-import numpy as np
-from tqdm import tqdm
-
-
-def dft_fit(N_T, F_S, D, FOLDER_OUT, SAVE_DFT=False):
-    """
-    This function computes the DFT form the dataset D.
-    Currently, this does not handle the memory saving feature.
-    
-    :param N_T: int.
-        number of snapshots 
-    :param F_S:
-        Sampling frequency (in Hz)
-    :param D:
-        Snapshot matrix
-    :param FOLDER_OUT:
-        Folder in which the results are saved if SAVE_SPATIAL_POD = True
-    :param SAVE_DFT:
-        If True, results are saved on disk and released from memory
-        
-    :return: Sorted_Freqs, np.array
-        Frequency bins, in Hz. 
-    :return: Phi_F, np.array
-        (Complex) Spatial structures for each mode
-    :return: SIGMA_F, np.array
-         (real) amplitude of each modes
-    
-    """
-    n_t = int(N_T)
-    Freqs = np.fft.fftfreq(n_t) * F_S  # Compute the frequency bins
-    # PSI_F = np.conj(np.fft.fft(np.eye(n_t)) / np.sqrt(n_t))  # Prepare the Fourier Matrix.
-
-    # Method 1 (didactic!)
-    # PHI_SIGMA = np.dot(D, np.conj(PSI_F))  # This is PHI * SIGMA
-
-    # Method 2
-    PHI_SIGMA = (np.fft.fft(D, n_t, 1)) / (n_t ** 0.5)
-
-    PHI_F = np.zeros((D.shape[0], n_t), dtype=complex)  # Initialize the PHI_F MATRIX
-    SIGMA_F = np.zeros(n_t)  # Initialize the SIGMA_F MATRIX
-
-    # Now we proceed with the normalization. This is also intense so we time it
-    for r in tqdm(range(0, n_t)):  # Loop over the PHI_SIGMA to normalize
-        # MEX = 'Proj ' + str(r + 1) + ' /' + str(n_t)
-        # print(MEX)
-        SIGMA_F[r] = abs(np.vdot(PHI_SIGMA[:, r], PHI_SIGMA[:, r])) ** 0.5
-        PHI_F[:, r] = PHI_SIGMA[:, r] / SIGMA_F[r]
-
-    Indices = np.flipud(np.argsort(SIGMA_F))  # find indices for sorting in decreasing order
-    Sorted_Sigmas = SIGMA_F[Indices]  # Sort all the sigmas
-    Sorted_Freqs = Freqs[Indices]  # Sort all the frequencies accordingly.
-    Phi_F = PHI_F[:, Indices]  # Sorted Spatial Structures Matrix
-    SIGMA_F = Sorted_Sigmas  # Sorted Amplitude Matrix (vector)
-
-    if SAVE_DFT:
-        os.makedirs(FOLDER_OUT + 'DFT', exist_ok=True)
-        np.savez(FOLDER_OUT + 'DFT/dft_fitted', Freqs=Sorted_Freqs, Phis=Phi_F, Sigmas=SIGMA_F)
-
-    return Sorted_Freqs, Phi_F, SIGMA_F
+import os
+
+import numpy as np
+from tqdm import tqdm
+
+
+def dft_fit(N_T, F_S, D, FOLDER_OUT, SAVE_DFT=False):
+    """
+    Computes the Discrete Fourier Transform (DFT) from the provided dataset.
+
+    Note
+    ----
+    Memory saving feature is currently not supported by this function.
+
+    Parameters
+    ----------
+    N_T : int
+        Number of temporal snapshots.
+
+    F_S : float
+        Sampling frequency in Hz.
+
+    D : np.ndarray
+        Snapshot matrix.
+
+    FOLDER_OUT : str
+        Directory path where results are saved if `SAVE_DFT` is True.
+
+    SAVE_DFT : bool, default=False
+        If True, computed results are saved to disk and released from memory.
+
+    Returns
+    -------
+    Sorted_Freqs : np.ndarray
+        Frequency bins in Hz, sorted in ascending order.
+
+    Phi_F : np.ndarray
+        Complex spatial structures corresponding to each frequency mode.
+
+    SIGMA_F : np.ndarray
+        Real amplitudes associated with each frequency mode.
+    """
+    n_t = int(N_T)
+    Freqs = np.fft.fftfreq(n_t) * F_S  # Compute the frequency bins
+    # PSI_F = np.conj(np.fft.fft(np.eye(n_t)) / np.sqrt(n_t))  # Prepare the Fourier Matrix.
+
+    # Method 1 (didactic!)
+    # PHI_SIGMA = np.dot(D, np.conj(PSI_F))  # This is PHI * SIGMA
+
+    # Method 2
+    PHI_SIGMA = (np.fft.fft(D, n_t, 1)) / (n_t ** 0.5)
+
+    PHI_F = np.zeros((D.shape[0], n_t), dtype=complex)  # Initialize the PHI_F MATRIX
+    SIGMA_F = np.zeros(n_t)  # Initialize the SIGMA_F MATRIX
+
+    # Now we proceed with the normalization. This is also intense so we time it
+    for r in tqdm(range(0, n_t)):  # Loop over the PHI_SIGMA to normalize
+        # MEX = 'Proj ' + str(r + 1) + ' /' + str(n_t)
+        # print(MEX)
+        SIGMA_F[r] = abs(np.vdot(PHI_SIGMA[:, r], PHI_SIGMA[:, r])) ** 0.5
+        PHI_F[:, r] = PHI_SIGMA[:, r] / SIGMA_F[r]
+
+    Indices = np.flipud(np.argsort(SIGMA_F))  # find indices for sorting in decreasing order
+    Sorted_Sigmas = SIGMA_F[Indices]  # Sort all the sigmas
+    Sorted_Freqs = Freqs[Indices]  # Sort all the frequencies accordingly.
+    Phi_F = PHI_F[:, Indices]  # Sorted Spatial Structures Matrix
+    SIGMA_F = Sorted_Sigmas  # Sorted Amplitude Matrix (vector)
+
+    if SAVE_DFT:
+        os.makedirs(FOLDER_OUT + 'DFT', exist_ok=True)
+        np.savez(FOLDER_OUT + 'DFT/dft_fitted', Freqs=Sorted_Freqs, Phis=Phi_F, Sigmas=SIGMA_F)
+
+    return Sorted_Freqs, Phi_F, SIGMA_F
+
+def dft(N_T, F_S, D, FOLDER_OUT, SAVE_DFT=False):
+    """
+    Computes the Discrete Fourier Transform (DFT) from the provided dataset.
+
+    Note
+    ----
+    Memory saving feature is currently not supported by this function.
+
+    Parameters
+    ----------
+    N_T : int
+        Number of temporal snapshots.
+
+    F_S : float
+        Sampling frequency in Hz.
+
+    D : np.ndarray
+        Snapshot matrix.
+
+    FOLDER_OUT : str
+        Directory path where results are saved if `SAVE_DFT` is True.
+
+    SAVE_DFT : bool, default=False
+        If True, computed results are saved to disk and released from memory.
+
+    Returns
+    -------
+    Phi_F : np.ndarray
+        Complex spatial structures corresponding to each frequency mode.
+        
+    Sorted_Freqs : np.ndarray
+        Frequency bins in Hz, sorted in ascending order.
+
+    SIGMA_F : np.ndarray
+        Real amplitudes associated with each frequency mode.
+    """
+    n_t = int(N_T)
+    Freqs = np.fft.fftfreq(n_t) * F_S  # Compute the frequency bins
+    
+    # FFT along the snapshot axis
+    PHI_SIGMA = np.fft.fft(D, axis=1) / np.sqrt(n_t)
+    sigma_F = np.linalg.norm(PHI_SIGMA, axis=0)  # Compute the norm of each column
+    
+    # make phi_F orthonormal 
+    Phi_F = PHI_SIGMA / sigma_F
+    
+    # Sort  
+    Indices = np.flipud(np.argsort(sigma_F))  # find indices for sorting in decreasing order
+    Sorted_Sigmas = sigma_F[Indices]  # Sort all the sigmas
+    Sorted_Freqs = Freqs[Indices]  # Sort all the frequencies accordingly.
+    Phi_F = Phi_F[:, Indices]  # Sorted Spatial Structures Matrix
+    sigma_F = Sorted_Sigmas  # Sorted Amplitude Matrix (vector)
+    
+    if SAVE_DFT:
+        os.makedirs(FOLDER_OUT + 'DFT', exist_ok=True)
+        np.savez(FOLDER_OUT + 'DFT/dft_fitted', Freqs=Sorted_Freqs, Phis=Phi_F, Sigmas=SIGMA_F)
+        
+    return Phi_F, Sorted_Freqs, sigma_F

modulo_vki/core/_dmd_s.py

@@ -1,72 +1,81 @@
-import os
-import numpy as np
-from numpy import linalg as LA
-from ..utils._utils import switch_svds
-
-
-def dmd_s(D_1, D_2, n_Modes, F_S,
-          SAVE_T_DMD=False,
-          FOLDER_OUT='./',
-          svd_solver: str = 'svd_sklearn_truncated'):
-    """
-    This method computes the Dynamic Mode Decomposition (DMD) using hte PIP algorithm from Penland.    
-    
-    :param D_1: np.array 
-           First portion of the data, i.e. D[:,0:n_t-1]            
-    :param D_2: np.array
-           Second portion of the data, i.e. D[:,1:n_t]
-    :param Phi_P, Psi_P, Sigma_P: np.arrays
-           POD decomposition of D1
-    :param F_S: float
-           Sampling frequency in Hz
-    :param FOLDER_OUT: str
-           Folder in which the results will be saved (if SAVE_T_DMD=True)
-    :param K: np.array
-           Temporal correlation matrix
-    :param SAVE_T_POD: bool
-           A flag deciding whether the results are saved on disk or not. If the MEMORY_SAVING feature is active, it is switched True by default.
-    :param n_Modes: int
-           number of modes that will be computed
-    :param svd_solver: str,
-           svd solver to be used 
-          
-     
-    :return1 Phi_D: np.array. 
-          DMD's complex spatial structures
-    :return2 Lambda_D: np.array. 
-          DMD Eigenvalues (of the reduced propagator)
-    :return3 freqs: np.array. 
-          Frequencies (in Hz, associated to the DMD modes)
-    :return4 a0s: np.array. 
-          Initial Coefficients of the Modes
-    """   
-    
-    Phi_P, Psi_P, Sigma_P = switch_svds(D_1, n_Modes, svd_solver)
-    print('SVD of D1 rdy')
-    Sigma_inv = np.diag(1 / Sigma_P)
-    dt = 1 / F_S
-    # %% Step 3: Compute approximated propagator
-    P_A = LA.multi_dot([np.transpose(Phi_P), D_2, Psi_P, Sigma_inv])
-    print('reduced propagator rdy')
-
-    # %% Step 4: Compute eigenvalues of the system
-    Lambda, Q = LA.eig(P_A) # not necessarily symmetric def pos! Avoid eigsh, eigh
-    freqs = np.imag(np.log(Lambda)) / (2 * np.pi * dt)
-    print(' lambdas and freqs rdy')
-
-    # %% Step 5: Spatial structures of the DMD in the PIP style
-    Phi_D = LA.multi_dot([D_2, Psi_P, Sigma_inv, Q])
-    print('Phi_D rdy')
-
-    # %% Step 6: Compute the initial coefficients
-    # a0s=LA.lstsq(Phi_D, D_1[:,0],rcond=None)
-    a0s = LA.pinv(Phi_D).dot(D_1[:, 0])
-    print('Sigma_D rdy')
-
-    if SAVE_T_DMD:
-        os.makedirs(FOLDER_OUT + "/DMD/", exist_ok=True)
-        print("Saving DMD results")
-        np.savez(FOLDER_OUT + '/DMD/dmd_decomposition',
-                 Phi_D=Phi_D, Lambda=Lambda, freqs=freqs, a0s=a0s)
-
-    return Phi_D, Lambda, freqs, a0s
+import os
+import numpy as np
+from numpy import linalg as LA
+from ..utils._utils import switch_svds
+
+
+def dmd_s(D_1, D_2, n_Modes, F_S,
+          SAVE_T_DMD: bool = False,
+          FOLDER_OUT: str = './',
+          svd_solver: str = 'svd_sklearn_truncated',
+          verbose=True):
+    """
+    Compute the Dynamic Mode Decomposition (DMD) using the PIP algorithm.
+
+    This implementation follows the Penland & Sardeshmukh PIP approach and
+    recovers the same modes as the exact DMD of Tu et al. (2014).
+
+    Parameters
+    ----------
+    D_1 : ndarray, shape (n_features, n_time-1)
+        First snapshot matrix (columns 0 to n_t-2 of the full data).
+    D_2 : ndarray, shape (n_features, n_time-1)
+        Second snapshot matrix (columns 1 to n_t-1 of the full data).
+    n_Modes : int
+        Number of DMD modes to compute.
+    F_S : float
+        Sampling frequency in Hz.
+    SAVE_T_DMD : bool, optional
+        If True, save time‐series DMD results to disk. Default is False.
+    FOLDER_OUT : str, optional
+        Directory in which to save outputs when SAVE_T_DMD is True. Default is './'.
+    svd_solver : str, optional
+        SVD solver to use for the low‐rank approximation. Default is
+        'svd_sklearn_truncated'.
+
+    Returns
+    -------
+    Phi_D : ndarray, shape (n_features, n_Modes)
+        Complex spatial DMD modes.
+    Lambda_D : ndarray, shape (n_Modes,)
+        Complex eigenvalues of the reduced propagator.
+    freqs : ndarray, shape (n_Modes,)
+        Frequencies (Hz) associated with each DMD mode.
+    a0s : ndarray, shape (n_Modes,)
+        Initial amplitudes (coefficients) of the DMD modes.
+    """ 
+    
+    Phi_P, Psi_P, Sigma_P = switch_svds(D_1, n_Modes, svd_solver)
+    if verbose:
+        print('SVD of D1 rdy')
+    Sigma_inv = np.diag(1 / Sigma_P)
+    dt = 1 / F_S
+    # %% Step 3: Compute approximated propagator
+    P_A = LA.multi_dot([np.transpose(Phi_P), D_2, Psi_P, Sigma_inv])
+    if verbose:
+        print('reduced propagator rdy')
+
+    # %% Step 4: Compute eigenvalues of the system
+    Lambda, Q = LA.eig(P_A) # not necessarily symmetric def pos! Avoid eigsh, eigh
+    freqs = np.imag(np.log(Lambda)) / (2 * np.pi * dt)
+    if verbose:
+        print(' lambdas and freqs rdy')
+
+    # %% Step 5: Spatial structures of the DMD in the PIP style
+    Phi_D = LA.multi_dot([D_2, Psi_P, Sigma_inv, Q])
+    if verbose:
+        print('Phi_D rdy')
+
+    # %% Step 6: Compute the initial coefficients
+    # a0s=LA.lstsq(Phi_D, D_1[:,0],rcond=None)
+    a0s = LA.pinv(Phi_D).dot(D_1[:, 0])
+    if verbose:
+        print('Sigma_D rdy')
+
+    if SAVE_T_DMD:
+        os.makedirs(FOLDER_OUT + "/DMD/", exist_ok=True)
+        print("Saving DMD results")
+        np.savez(FOLDER_OUT + '/DMD/dmd_decomposition',
+                 Phi_D=Phi_D, Lambda=Lambda, freqs=freqs, a0s=a0s)
+
+    return Phi_D, Lambda, freqs, a0s