modulo-vki 2.0.7__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/_dft.py

@@ -6,27 +6,39 @@ 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
-    
+    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
@@ -59,3 +71,62 @@ def dft_fit(N_T, F_S, D, FOLDER_OUT, SAVE_DFT=False):
         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

@@ -5,63 +5,72 @@ 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'):
+          SAVE_T_DMD: bool = False,
+          FOLDER_OUT: str = './',
+          svd_solver: str = 'svd_sklearn_truncated',
+          verbose=True):
     """
-    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
-    """   
+    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)
-    print('SVD of D1 rdy')
+    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])
-    print('reduced propagator rdy')
+    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)
-    print(' lambdas and freqs rdy')
+    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])
-    print('Phi_D rdy')
+    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])
-    print('Sigma_D rdy')
+    if verbose:
+        print('Sigma_D rdy')
 
     if SAVE_T_DMD:
         os.makedirs(FOLDER_OUT + "/DMD/", exist_ok=True)

modulo_vki/core/_k_matrix.py

@@ -2,32 +2,70 @@ import os
 from tqdm import tqdm
 import numpy as np
 import math
+from scipy.signal import firwin
+from scipy import signal
+from sklearn.metrics.pairwise import pairwise_kernels
+
+def CorrelationMatrix(N_T,
+                      N_PARTITIONS=1,
+                      MEMORY_SAVING=False,
+                      FOLDER_OUT='./',
+                      SAVE_K=False,
+                      D=None,
+                      weights=np.array([]),
+                      verbose=True):
+    """
+    Computes the temporal correlation matrix from the provided data matrix.
 
+    If MEMORY_SAVING is active, computation is split into partitions to reduce memory load.
+    If data matrix D has been computed using MODULO, parameters like dimensions and number of partitions
+    will automatically be inferred.
 
-def CorrelationMatrix(N_T, N_PARTITIONS=1, MEMORY_SAVING=False, FOLDER_OUT='./', SAVE_K=False, D=None,weights = np.array([])):
-    """
-    This method computes the temporal correlation matrix, given a data matrix as input. It's possible to use memory saving
-    then splitting the computing in different tranches if computationally heavy. If D has been computed using MODULO
-    then the dimension dim_col and N_PARTITIONS is automatically loaded
-
-    :param N_T: int. Number of temporal snapshots
-    :param D: np.array. Data matrix
-    :param SAVE_K: bool. If SAVE_K=True, the matrix K is saved on disk. If the MEMORY_SAVING feature is active, this is done by default.
-    :param MEMORY_SAVING: bool. If MEMORY_SAVING = True, the computation of the correlation matrix is done by steps. It requires the data matrix to be partitioned, following algorithm in MODULO._data_processing.
-    :param FOLDER_OUT: str. Folder in which the temporal correlation matrix will be stored
-    :param N_PARTITIONS: int. Number of partitions to be read in computing the correlation matrix. If _data_processing is used to partition the data matrix, this is inherited from the main class
-    :param weights: weight vector [w_i,....,w_{N_s}] where w_i = area_cell_i/area_grid. Only needed if grid is non-uniform & MEMORY_SAVING== True
-    :return: K (: np.array) if the memory saving is not active. None type otherwise.
+    Parameters
+    ----------
+    N_T : int
+        Number of temporal snapshots.
+
+    N_PARTITIONS : int, default=1
+        Number of partitions for memory-saving computation.
+        Inherited automatically if using MODULO's partitioning.
+
+    MEMORY_SAVING : bool, default=False
+        Activates partitioned computation of the correlation matrix to reduce memory usage.
+        Requires pre-partitioned data according to MODULO's `_data_processing`.
+
+    FOLDER_OUT : str, default='./'
+        Output directory where the temporal correlation matrix will be saved if required.
+
+    SAVE_K : bool, default=False
+        Flag to save the computed correlation matrix K to disk. Automatically enforced
+        if MEMORY_SAVING is active.
+
+    D : np.ndarray, optional
+        Data matrix used to compute the correlation matrix. Required if MEMORY_SAVING is False.
+
+    weights : np.ndarray, default=np.array([])
+        Weight vector `[w_1, w_2, ..., w_Ns]` defined as `w_i = area_cell_i / area_grid`.
+        Needed only for non-uniform grids when MEMORY_SAVING is True.
+
+    Returns
+    -------
+    K : np.ndarray or None
+        Temporal correlation matrix if MEMORY_SAVING is False; otherwise returns None,
+        as matrix is managed via disk storage in partitioned computations.
     """
 
     if not MEMORY_SAVING:
-        print("\n Computing Temporal correlation matrix K ...")
+        if verbose:
+            print("Computing Temporal correlation matrix K ...")
         K = np.dot(D.T, D)
-        print("\n Done.")
+        if verbose:
+            print("Done.")
 
     else:
         SAVE_K = True
-        print("\n Using Memory Saving feature...")
+        if verbose:
+            print("\n Using Memory Saving feature...")
         K = np.zeros((N_T, N_T))
         dim_col = math.floor(N_T / N_PARTITIONS)
 
@@ -79,3 +117,93 @@ def CorrelationMatrix(N_T, N_PARTITIONS=1, MEMORY_SAVING=False, FOLDER_OUT='./',
         np.savez(FOLDER_OUT + "/correlation_matrix/k_matrix", K=K)
 
     return K if not MEMORY_SAVING else None
+
+
+def spectral_filter(K: np.ndarray, N_o:int, f_c: float) -> np.ndarray:
+    """
+    Zero‐phase band‐pass filter of the correlation matrix K along its diagonals.
+    Used for the SPOD proposed by Sieber  et al.
+
+    Parameters
+    ----------
+    K : (n_t, n_t) array
+        Original temporal correlation matrix.
+    N_o : int
+        Semi‐order of the FIR filter (true filter length = 2*N_o+1).
+    f_c : float
+        Normalized cutoff frequency (0 < f_c < 0.5).
+
+    Returns
+    -------
+    K_F : (n_t, n_t) array
+        The filtered correlation matrix.
+    """
+    n_t = K.shape[0]
+    
+    # extend K for edge-padding
+    K_ext = np.pad(
+            K,
+            pad_width=((N_o, N_o), (N_o, N_o)),
+            mode='constant',           # or 'edge', 'reflect', etc.
+            constant_values=0
+    )
+
+    # Fill the edges ( a bit of repetition but ok.. )
+    # Row-wise, Upper part
+    for i in range(0, N_o):
+        K_ext[i, i:i + n_t] = K[0, :]
+
+    # Row-wise, bottom part
+    for i in range(N_o + n_t, n_t + 2 * N_o):
+        K_ext[i, i - n_t + 1:i + 1] = K[-1, :]
+
+        # Column-wise, left part
+    for j in range(0, N_o):
+        K_ext[j:j + n_t, j] = K[:, 0]
+
+        # Column-wise, right part
+    for j in range(N_o + n_t, 2 * N_o + n_t):
+        K_ext[j - n_t + 1:j + 1, j] = K[:, -1]
+
+    # K_e = np.zeros((n_t + 2 * N_o, n_t + 2 * N_o))
+    # From which we clearly know that:
+    # K_e[N_o:n_t + N_o, N_o:n_t + N_o] = K
+    
+    # create 2D kernel for FIR 
+    h1d = firwin(N_o, f_c)
+    L = K_ext.shape[0]
+    
+    pad_l = (L - N_o) // 2
+    pad_r = L - N_o - pad_l
+    
+    # symmetrically padded kernel in 1D
+    h1d_pad = np.pad(h1d, (pad_l, pad_r))
+    
+    # we make it 2D diagonal
+    h2d = np.diag(h1d_pad)
+    
+    # finally filter K_ext and return the trimmed filtered without boundaries
+    K_ext_filt = signal.fftconvolve(K_ext, h2d, mode='same')
+    K_F = K_ext_filt[N_o : N_o + n_t, N_o : N_o + n_t]
+    
+    return K_F
+
+def kernelized_K(D, M_ij, k_m, metric, cent, alpha):
+    
+    n_s, n_t = D.shape 
+    
+    gamma = - np.log(k_m) / M_ij
+    K_zeta = pairwise_kernels(D.T, metric=metric, gamma=gamma) # kernel substitute of the inner product 
+
+    # Center the Kernel Matrix (if cent is True):
+    if cent:
+        H = np.eye(n_t) - 1 / n_t * np.ones_like(K_zeta)
+        K_zeta = H @ K_zeta @ H.T
+        
+    # add `Ridge term` to enforce strictly pos. def. eigs and well-conditioning
+    K_r = K_zeta + alpha * np.eye(n_t)
+    
+    return K_r 
+        
+    
+    

modulo_vki/core/_mpod_time.py

@@ -4,8 +4,11 @@ from scipy.signal import firwin  # To create FIR kernels
 from tqdm import tqdm
 from modulo_vki.utils._utils import conv_m, switch_eigs
 
+# TODO: instead of computing the min of modes between SAT and the number of frequencies, we should compute the number of modes between SAT and the number of requested modes by the user.
 
-def temporal_basis_mPOD(K, Nf, Ex, F_V, Keep, boundaries, MODE='reduced', dt=1,FOLDER_OUT: str = "./", MEMORY_SAVING: bool = False,SAT: int = 100,n_Modes=10, eig_solver: str = 'svd_sklearn_randomized'):
+def temporal_basis_mPOD(K, Nf, Ex, F_V, Keep, boundaries, MODE='reduced', 
+                        dt=1,FOLDER_OUT: str = "./", MEMORY_SAVING: bool = False,SAT: int = 100,
+                        n_Modes=10, eig_solver: str = 'svd_sklearn_randomized'):
     '''
     This function computes the PSIs for the mPOD. In this implementation, a "dft-trick" is proposed, in order to avoid
     expansive SVDs. Randomized SVD is used by default for the diagonalization.
@@ -15,9 +18,11 @@ def temporal_basis_mPOD(K, Nf, Ex, F_V, Keep, boundaries, MODE='reduced', dt=1,F
     :param dt: float.   
         1/fs, the dt between snapshots. Units in seconds.
     :param Nf: 
-        np.array. Vector collecting the order of the FIR filters used in each scale.
+        np.array. Vector collecting the order of the FIR filters used in each scale. It must be of size len(F_V) + 1, where the first element defines 
+        the low pass filter, and the last one is the high pass filter. The rest are for the band-pass filters.
     :param Ex: int.
-        Extension at the boundaries of K to impose the boundary conditions (see boundaries). It must be at least as Nf.
+        Extension at the boundaries of K to impose the boundary conditions (see boundaries). It must be at least as Nf, and of size len(F_V) + 1, where the first
+        element is the low pass filter, and the last one is the high pass filter. The rest are band-pass filters.
     :param F_V: np.array. 
         Frequency splitting vector, containing the frequencies of each scale (see article). If the time axis is in seconds, these frequencies are in Hz.
     :param Keep: np.array. 
@@ -51,6 +56,16 @@ def temporal_basis_mPOD(K, Nf, Ex, F_V, Keep, boundaries, MODE='reduced', dt=1,F
     #Converting F_V in radiants and initialise number of scales M
     Fs = 1 / dt
     F_Bank_r = F_V * 2 / Fs
+    
+    # repeat first entry to ensure all scales are covered
+    F_Bank_r = np.concatenate(([F_Bank_r[0]], F_Bank_r))
+    # TODO: update tutorials to reflect this change!
+
+    assert len(F_Bank_r) == len(Nf), "Frequencies and filter orders must have the same length. Remember that given M scales, Nf must have M+1 elements"
+    assert len(F_Bank_r) == len(Keep), "Frequencies and keep must have the same length. Remember that given M scales, keep must have M+1 elements"
+    # Nf = np.concatenate(([Nf[0]], Nf))
+    # Keep = np.concatenate(([Keep[0]], Keep))
+    
     M = len(F_Bank_r)
 
     # Loop over the scales to show the transfer functions
@@ -72,26 +87,29 @@ def temporal_basis_mPOD(K, Nf, Ex, F_V, Keep, boundaries, MODE='reduced', dt=1,F
         # Generate the 1d filter for this
         if m < 1:
             if Keep[m] == 1:
-             # Low Pass Filter
-             h_A = firwin(Nf[m], F_Bank_r[m], window='hamming')
-             # Filter K_LP
-             print('\n Filtering Largest Scale')
-             K_L = conv_m(K=K, h=h_A, Ex=Ex, boundaries=boundaries)
-             # R_K = np.linalg.matrix_rank(K_L, tol=None, hermitian=True)
-             '''We replace it with an estimation based on the non-zero freqs the cut off frequency of the scale is '''
-             F_CUT = F_Bank_r[m] * Fs / 2
-             Indices = np.argwhere(np.abs(Freqs) < F_CUT)
-             R_K = np.min([len(Indices), SAT])
-             print(str(len(Indices)) + ' Modes Estimated')
-             print('\n Diagonalizing Largest Scale')
-             Psi_P, Lambda_P = switch_eigs(K_L, R_K, eig_solver) #svds_RND(K_L, R_K)
-             Psi_M=Psi_P; Lambda_M=Lambda_P
+                # Low Pass Filter
+                h_A = firwin(Nf[m], F_Bank_r[m], window='hamming')
+                # Filter K_LP
+                print('\n Filtering Largest Scale')
+                K_L = conv_m(K=K, h=h_A, Ex=Ex, boundaries=boundaries)
+                # R_K = np.linalg.matrix_rank(K_L, tol=None, hermitian=True)
+                '''We replace it with an estimation based on the non-zero freqs the cut off frequency of the scale is '''
+                F_CUT = F_Bank_r[m] * Fs / 2
+                Indices = np.argwhere(np.abs(Freqs) < F_CUT) 
+                
+                # R_K = np.min([len(Indices), SAT]) 
+                # R_K = np.min(R_K, n_Modes) # we take the min between the number of frequencies and the number of modes requested 
+                R_K = min(len(Indices), SAT, n_Modes) 
+                
+                print(str(len(Indices)) + ' Modes Estimated')
+                print('\n Diagonalizing Largest Scale')
+                
+                Psi_P, Lambda_P = switch_eigs(K_L, R_K, eig_solver) #svds_RND(K_L, R_K)
+                Psi_M=Psi_P
+                Lambda_M=Lambda_P
             else:
-             print('\n Scale '+str(m)+' jumped (keep['+str(m)+']=0)')  
-            # if K_S:
-            #     Ks[:, :, m] = K_L  # First large scale
-                         
-            # method = signal.choose_conv_method(K, h2d, mode='same')
+                print('\n Scale '+str(m)+' jumped (keep['+str(m)+']=0)')  
+
         elif m > 0 and m < M - 1:
             if Keep[m] == 1:
                 # print(m)
@@ -109,11 +127,14 @@ def temporal_basis_mPOD(K, Nf, Ex, F_V, Keep, boundaries, MODE='reduced', dt=1,F
                 print('Diagonalizing H Scale ' + str(m + 1) + '/' + str(M))
                 # R_K = np.linalg.matrix_rank(K_H, tol=None, hermitian=True)
                 Psi_P, Lambda_P = switch_eigs(K_H, R_K, eig_solver) #svds_RND(K_H, R_K)  # Diagonalize scale
+                
                 if np.shape(Psi_M)[0]==0: # if this is the first contribute to the basis
-                 Psi_M=Psi_P; Lambda_M=Lambda_P
+                    Psi_M=Psi_P
+                    Lambda_M=Lambda_P
                 else:                    
-                 Psi_M = np.concatenate((Psi_M, Psi_P), axis=1)  # append to the previous
-                 Lambda_M = np.concatenate((Lambda_M, Lambda_P), axis=0)
+                    Psi_M = np.concatenate((Psi_M, Psi_P), axis=1)  # append to the previous
+                    Lambda_M = np.concatenate((Lambda_M, Lambda_P), axis=0)
+                    
             else:
                 print('\n Scale '+str(m)+' jumped (keep['+str(m)+']=0)')  
       

modulo_vki/core/_pod_space.py

@@ -4,7 +4,8 @@ from tqdm import tqdm
 import os
 
 
-def Spatial_basis_POD(D, PSI_P, Sigma_P, MEMORY_SAVING, N_T, FOLDER_OUT='./', N_PARTITIONS=1, SAVE_SPATIAL_POD=False,
+def Spatial_basis_POD(D, PSI_P, Sigma_P, MEMORY_SAVING, 
+                      N_T, FOLDER_OUT='./', N_PARTITIONS=1, SAVE_SPATIAL_POD=False,
                       rescale=False):
     """
     This function computs the POD spatial basis from the temporal basis,
@@ -55,7 +56,7 @@ def Spatial_basis_POD(D, PSI_P, Sigma_P, MEMORY_SAVING, N_T, FOLDER_OUT='./', N_
 
         else:
             # We take only the first R modes.
-            Sigma_P_t = Sigma_P[0:R];
+            Sigma_P_t = Sigma_P[0:R]
             Sigma_P_Inv_V = 1 / Sigma_P_t
             # So we have the inverse
             Sigma_P_Inv = np.diag(Sigma_P_Inv_V)

modulo_vki/core/_pod_time.py

@@ -3,7 +3,8 @@ import numpy as np
 from ..utils._utils import switch_eigs
 
 
-def Temporal_basis_POD(K, SAVE_T_POD=False, FOLDER_OUT='./', n_Modes=10,eig_solver: str = 'eigh'):
+def Temporal_basis_POD(K, SAVE_T_POD=False, FOLDER_OUT='./', 
+                       n_Modes=10,eig_solver: str = 'eigh'):
     """
     This method computes the POD basis. For some theoretical insights, you can find the theoretical background of the proper orthogonal decomposition in a nutshell here: https://youtu.be/8fhupzhAR_M