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

modulo_vki/core/_k_matrix.py

@@ -1,81 +1,209 @@
-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
+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.
+
+    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:
+        if verbose:
+            print("Computing Temporal correlation matrix K ...")
+        K = np.dot(D.T, D)
+        if verbose:
+            print("Done.")
+
+    else:
+        SAVE_K = True
+        if verbose:
+            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
+
+
+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_space.py

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