modulo-vki 2.0.5__py3-none-any.whl

modulo_vki/__init__.py

@@ -0,0 +1,23 @@
+
+#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

@@ -0,0 +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 *

modulo_vki/core/_dft.py

@@ -0,0 +1,61 @@
+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

modulo_vki/core/_dmd_s.py

@@ -0,0 +1,72 @@
+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

modulo_vki/core/_k_matrix.py

@@ -0,0 +1,81 @@
+import os
+from tqdm import tqdm
+import numpy as np
+import math
+
+
+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.
+    """
+
+    if not MEMORY_SAVING:
+        print("\n Computing Temporal correlation matrix K ...")
+        K = np.dot(D.T, D)
+        print("\n Done.")
+
+    else:
+        SAVE_K = True
+        print("\n Using Memory Saving feature...")
+        K = np.zeros((N_T, N_T))
+        dim_col = math.floor(N_T / N_PARTITIONS)
+
+        if N_T % N_PARTITIONS != 0:
+            tot_blocks_col = N_PARTITIONS + 1
+        else:
+            tot_blocks_col = N_PARTITIONS
+
+        for k in tqdm(range(tot_blocks_col)):
+
+            di = np.load(FOLDER_OUT + f"/data_partitions/di_{k + 1}.npz")['di']
+            if weights.size != 0:
+                di = np.transpose(np.transpose(di) * np.sqrt(weights))
+
+            ind_start = k * dim_col
+            ind_end = ind_start + dim_col
+
+            if (k == tot_blocks_col - 1) and (N_T - dim_col * N_PARTITIONS > 0):
+                dim_col = N_T - dim_col * N_PARTITIONS
+                ind_end = ind_start + dim_col
+
+            K[ind_start:ind_end, ind_start:ind_end] = np.dot(di.transpose(), di)
+
+            block = k + 2
+
+            while block <= tot_blocks_col:
+                dj = np.load(FOLDER_OUT + f"/data_partitions/di_{block}.npz")['di']
+                if weights.size != 0:
+                    dj = np.transpose(np.transpose(dj) * np.sqrt(weights))
+
+                ind_start_out = (block - 1) * dim_col
+                ind_end_out = ind_start_out + dim_col
+
+                if (block == tot_blocks_col) and (N_T - dim_col * N_PARTITIONS > 0):
+                    dim_col = N_T - dim_col * N_PARTITIONS
+                    ind_end_out = ind_start_out + dim_col
+                    dj = dj[:, :dim_col]
+
+                K[ind_start:ind_end, ind_start_out:ind_end_out] = np.dot(di.T, dj)
+
+                K[ind_start_out:ind_end_out, ind_start:ind_end] = K[ind_start:ind_end, ind_start_out:ind_end_out].T
+
+                block += 1
+
+                dim_col = math.floor(N_T / N_PARTITIONS)
+
+    if SAVE_K:
+        os.makedirs(FOLDER_OUT + '/correlation_matrix', exist_ok=True)
+        np.savez(FOLDER_OUT + "/correlation_matrix/k_matrix", K=K)
+
+    return K if not MEMORY_SAVING else None

modulo_vki/core/_mpod_space.py

@@ -0,0 +1,180 @@
+import numpy as np
+import os
+from tqdm import tqdm
+import math
+
+
+def spatial_basis_mPOD(D, PSI_M, N_T, N_PARTITIONS, N_S, MEMORY_SAVING, FOLDER_OUT, SAVE: bool = False,weights: np.array = np.array([])):
+    """
+    Given the temporal basis of the mPOD now the spatial ones are computed
+    
+    :param D: 
+        Snapshot matrix D: if memory savig is active, this is ignored.    
+    :param PSI_M: np.array.: 
+        The mPOD temporal basis Psi tentatively assembled from all scales
+    :param N_T: int. 
+        Number of snapshots
+    :param N_PARTITIONS: int. 
+        Number of partitions in the memory saving
+    :param N_S: int. 
+        Number of grid points in space
+    :param MEMORY_SAVING: bool. 
+        Inherited from main class, if True turns on the MEMORY_SAVING feature, loading the partitions and starting the proper algorithm  
+    :param FOLDER_OUT: str. 
+        Folder in which the results are saved if SAVE_SPATIAL_POD = True
+    :param SAVE_SPATIAL_POD: bool.
+        If True, results are saved on disk and released from memory
+    :param weights:  np.array
+        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: Phi_M, Psi_M, Sigma_M: np.arrays. The final (sorted) mPOD decomposition
+    """
+    
+    R1 = 0; R2 = 0
+    if MEMORY_SAVING:
+        SAVE = True
+        os.makedirs(FOLDER_OUT + '/mPOD/', exist_ok=True)
+        dim_col = math.floor(N_T / N_PARTITIONS)
+        dim_row = math.floor(N_S / N_PARTITIONS)
+        dr = np.zeros((dim_row, N_T))
+
+        # 1 --- Converting partitions dC to dR
+        if N_S % N_PARTITIONS != 0:
+            tot_blocks_row = N_PARTITIONS + 1
+        else:
+            tot_blocks_row = N_PARTITIONS
+
+        if N_T % N_PARTITIONS != 0:
+            tot_blocks_col = N_PARTITIONS + 1
+        else:
+            tot_blocks_col = N_PARTITIONS
+
+        fixed = 0
+
+        for i in range(1, tot_blocks_row + 1):
+            # --- Check if dim_row has to be fixed:
+            if i == tot_blocks_row and (N_S - dim_row * N_PARTITIONS > 0):
+                dim_row_fix = N_S - dim_row * N_PARTITIONS
+                dr = np.zeros((dim_row_fix, N_T))
+
+            for cont in range(1, tot_blocks_col + 1):
+                di = np.load(FOLDER_OUT + f"/data_partitions/di_{cont}.npz")['di']
+
+                if i == tot_blocks_row and (N_S - dim_row * N_PARTITIONS > 0) and fixed == 0:
+                    R1 = R2
+                    R2 = R1 + (N_S - dim_row * N_PARTITIONS)
+                    fixed = 1
+                elif fixed == 0:
+                    R1 = (i - 1) * dim_row
+                    R2 = i * dim_row
+
+                # Same as before, but we don't need the variable fixed because if
+                #         % the code runs this loop, it will be the last time
+
+                if cont == tot_blocks_col and (N_T - dim_col * N_PARTITIONS > 0):
+                    C1 = C2
+                    C2 = C1 + (N_T - dim_col * N_PARTITIONS)
+                else:
+                    C1 = (cont - 1) * dim_col
+                    C2 = cont * dim_col
+
+                dr[:, C1:C2] = di[R1:R2, :]
+
+            # 2 --- Computing partitions R of PHI_SIGMA
+            PHI_SIGMA_BLOCK = dr @ PSI_M
+            np.savez(FOLDER_OUT + f'/mPOD/phi_sigma_{i}', PHI_SIGMA_BLOCK)
+
+        # 3 --- Convert partitions R to partitions C and get SIGMA
+        R = PSI_M.shape[1]
+        dim_col = math.floor(R / N_PARTITIONS)
+        dim_row = math.floor(N_S / N_PARTITIONS)
+        dps = np.zeros((N_S, dim_col))
+        SIGMA_M = []
+        PHI_M = []
+
+        if R % N_PARTITIONS != 0:
+            tot_blocks_col = N_PARTITIONS + 1
+        else:
+            tot_blocks_col = N_PARTITIONS
+
+        fixed = 0
+
+        # Here we apply the same logic of the loop before
+
+        for j in range(1, tot_blocks_col + 1):
+
+            if j == tot_blocks_col and (R - dim_col * N_PARTITIONS > 0):
+                dim_col_fix = R - dim_col * N_PARTITIONS
+                dps = np.zeros((N_S, dim_col_fix))
+
+            for k in range(1, tot_blocks_row + 1):
+                PHI_SIGMA_BLOCK = np.load(FOLDER_OUT + f"/mPOD/phi_sigma_{k}.npz")['arr_0']
+
+                if j == tot_blocks_col and (R - dim_col * N_PARTITIONS > 0) and fixed == 0:
+                    R1 = R2
+                    R2 = R1 + (R - dim_col * N_PARTITIONS)
+                    fixed = 1
+                elif fixed == 0:
+                    R1 = (j - 1) * dim_col
+                    R2 = j * dim_col
+
+                if k == tot_blocks_row and (N_S - dim_row * N_PARTITIONS > 0):
+                    C1 = C2
+                    C2 = C1 + (N_S - dim_row * N_PARTITIONS)
+                else:
+                    C1 = (k - 1) * dim_row
+                    C2 = k * dim_row
+
+                dps[C1:C2, :] = PHI_SIGMA_BLOCK[:, R1:R2]
+
+            # Getting sigmas and phis
+            for z in range(R1, R2):
+                zz = z - R1
+                if weights.size == 0:
+                    SIGMA_M.append(np.linalg.norm(dps[:, zz]))
+                else:
+                    SIGMA_M.append(np.linalg.norm(dps[:, zz]*np.sqrt(weights)))
+                tmp = dps[:, zz] / SIGMA_M[z]
+                #print(f'Shape tmp = {np.shape(tmp)}')
+                PHI_M.append(tmp)
+                np.savez(FOLDER_OUT + f'/mPOD/phi_{z + 1}', tmp)
+
+        Indices = np.argsort(SIGMA_M)[::-1]  # find indices for sorting in decreasing order
+        SIGMA_M = np.asarray(SIGMA_M)
+        PHI_M = np.asarray(PHI_M).T
+        PSI_M = np.asarray(PSI_M)
+        Sorted_Sigmas = SIGMA_M[Indices]  # Sort all the sigmas
+        Phi_M = PHI_M[:, Indices]  # Sorted Spatial Structures Matrix
+        Psi_M = PSI_M[:, Indices]  # Sorted Temporal Structures Matrix
+        Sigma_M = Sorted_Sigmas  # Sorted Amplitude Matrix
+
+    else:
+        R = PSI_M.shape[1]
+        PHI_M_SIGMA_M = np.dot(D, (PSI_M))
+        # Initialize the output
+        PHI_M = np.zeros((N_S, R))
+        SIGMA_M = np.zeros((R))
+
+        for i in tqdm(range(0, R)):
+            # print('Completing mPOD Mode ' + str(i))
+            # Assign the norm as amplitude
+            if weights.size == 0:
+                SIGMA_M[i] = np.linalg.norm(PHI_M_SIGMA_M[:, i])
+            else:
+                SIGMA_M[i] = np.linalg.norm(PHI_M_SIGMA_M[:, i]*np.sqrt(weights))
+            # Normalize the columns of C to get spatial modes
+            PHI_M[:, i] = PHI_M_SIGMA_M[:, i] / SIGMA_M[i]
+
+        Indices = np.flipud(np.argsort(SIGMA_M))  # find indices for sorting in decreasing order
+        Sorted_Sigmas = SIGMA_M[Indices]  # Sort all the sigmas
+        Phi_M = PHI_M[:, Indices]  # Sorted Spatial Structures Matrix
+        Psi_M = PSI_M[:, Indices]  # Sorted Temporal Structures Matrix
+        Sigma_M = Sorted_Sigmas  # Sorted Amplitude Matrix
+
+    if SAVE:
+        '''Saving results in MODULO tmp proper folder'''
+        os.makedirs(FOLDER_OUT + '/mPOD/', exist_ok=True)
+        np.savez(FOLDER_OUT + "/mPOD/sorted_phis", Phi_M)
+        np.savez(FOLDER_OUT + "/mPOD/sorted_psis", Psi_M)
+        np.savez(FOLDER_OUT + "/mPOD/sorted_sigma", Sorted_Sigmas)
+
+    return Phi_M, Psi_M, Sigma_M

modulo_vki/core/_mpod_time.py

@@ -0,0 +1,154 @@
+import os
+import numpy as np
+from scipy.signal import firwin  # To create FIR kernels
+from tqdm import tqdm
+from modulo_vki.utils._utils import conv_m, switch_eigs
+
+
+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.
+    
+    :param K: 
+        np.array  Temporal correlation matrix
+    :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.
+    :param Ex: int.
+        Extension at the boundaries of K to impose the boundary conditions (see boundaries). It must be at least as Nf.
+    :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. 
+        Vector defining which scale to keep.
+    :param boundaries: str -> {'nearest', 'reflect', 'wrap' or 'extrap'}. 
+        In order to avoid 'edge effects' if the time correlation matrix is not periodic, several boundary conditions can be used. Options are (from scipy.ndimage.convolve):
+        ‘reflect’ (d c b a | a b c d | d c b a)    The input is extended by reflecting about the edge of the last pixel.
+        ‘nearest’ (a a a a | a b c d | d d d d)    The input is extended by replicating the last pixel.
+        ‘wrap’ (a b c d | a b c d | a b c d)       The input is extended by wrapping around to the opposite edge.
+    :param MODE: tr -> {‘reduced’, ‘complete’, ‘r’, ‘raw’}
+        As a final step of this algorithm, the orthogonality is imposed via a QR-factorization. This parameterd define how to perform such factorization, according to numpy.
+        Options: this is a wrapper to np.linalg.qr(_, mode=MODE). Check numpy's documentation.
+        if ‘reduced’ The final basis will not necessarely be full. If ‘complete’ The final basis will always be full
+    :param FOLDER_OUT: str. 
+        This is the directory where intermediate results will be stored if the memory saving is active.It will be ignored if MEMORY_SAVING=False.              
+    :param MEMORY_SAVING: Bool. 
+        If memory saving is active, the results will be saved locally.  Nevertheless, since Psi_M is usually not expensive, it will be returned.        
+    :param SAT: int.
+        Maximum number of modes per scale. The user can decide how many modes to compute; otherwise, modulo set the default SAT=100.
+    :param n_Modes: int. 
+        Total number of modes that will be finally exported   
+    :param eig_solver: str. 
+        This is the eigenvalue solver that will be used. Refer to eigs_swith for the options.      
+    :return PSI_M: np.array. 
+        The mPOD PSIs. Yet to be sorted ! 
+    '''
+
+    if Ex < np.max(Nf):
+        raise RuntimeError("For the mPOD temporal basis computation Ex must be larger than or equal to Nf")
+
+    #Converting F_V in radiants and initialise number of scales M
+    Fs = 1 / dt
+    F_Bank_r = F_V * 2 / Fs
+    M = len(F_Bank_r)
+
+    # Loop over the scales to show the transfer functions
+    Psi_M = np.array([])
+    Lambda_M = np.array([])
+    n_t = K.shape[1]
+    
+   # if K_S:
+   #     Ks = np.zeros((n_t, n_t, M + 1))
+
+    #DFT-trick below: computing frequency bins.
+    Freqs = np.fft.fftfreq(n_t) * Fs
+
+    print("Filtering and Diagonalizing H scale: \n")
+
+    #Filtering and computing eigenvectors
+
+    for m in tqdm(range(0, M)):
+        # 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
+            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')
+        elif m > 0 and m < M - 1:
+            if Keep[m] == 1:
+                # print(m)
+                print('\n Working on Scale '+str(m)+'/'+str(M))
+                # This is the 1d Kernel for Band pass
+                h1d_H = firwin(Nf[m], [F_Bank_r[m], F_Bank_r[m + 1]], pass_zero=False)  # Band-pass
+                F_CUT1 = F_Bank_r[m] * Fs / 2
+                F_CUT2 = F_Bank_r[m + 1] * Fs / 2
+                Indices = np.argwhere((np.abs(Freqs) > F_CUT1) & (np.abs(Freqs) < F_CUT2))
+                R_K = np.min([len(Indices), SAT])  # number of frequencies here
+                print(str(len(Indices)) + ' Modes Estimated')
+                # print('Filtering H Scale ' + str(m + 1) + '/' + str(M))
+                K_H = conv_m(K, h1d_H, Ex, boundaries)
+                # Ks[:, :, m + 1] = K_H  # Intermediate band-pass
+                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
+                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)
+            else:
+                print('\n Scale '+str(m)+' jumped (keep['+str(m)+']=0)')  
+      
+        else: # this is the case m=M: this is a high pass
+            if Keep[m] == 1:
+                print('Working on Scale '+str(m)+'/'+str(M))
+                # This is the 1d Kernel for High Pass (last scale)
+                h1d_H = firwin(Nf[m], F_Bank_r[m], pass_zero=False)
+                F_CUT1 = F_Bank_r[m] * Fs / 2
+                Indices = np.argwhere((np.abs(Freqs) > F_CUT1))
+                R_K = len(Indices)
+                R_K = np.min([len(Indices), SAT])  # number of frequencies here
+                print(str(len(Indices)) + ' Modes Estimated')
+                print('Filtering H Scale ' + str(m + 1) + '/ ' + str(M))
+                K_H = conv_m(K, h1d_H, Ex, boundaries)
+                # Ks[:, :, m + 1] = K_H  # Last (high pass) scale
+                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
+                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)')  
+
+    # Now Order the Scales
+    Indices = np.flip(np.argsort(Lambda_M))  # find indices for sorting in decreasing order
+    Psi_M = Psi_M[:, Indices]  # Sort the temporal structures
+    #print(f"Size psis in mpodtime = {np.shape(Psi_M)}")
+    # Now we complete the basis via re-orghotonalization
+    print('\n QR Polishing...')
+    PSI_M, R = np.linalg.qr(Psi_M, mode=MODE)
+    print('Done!')
+
+    if MEMORY_SAVING:
+        os.makedirs(FOLDER_OUT + '/mPOD', exist_ok=True)
+        np.savez(FOLDER_OUT + '/mPOD/Psis', Psis=PSI_M)
+    
+    return PSI_M[:,0:n_Modes]