modulo-vki 2.0.7__py3-none-any.whl → 2.1.1__py3-none-any.whl

modulo_vki/core/spatial_structures.py

@@ -0,0 +1,367 @@
+import math
+import numpy as np
+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,
+                      rescale=False, verbose=True):
+    """
+    This function computs the POD spatial basis from the temporal basis,
+
+    :param D: np.array. 
+         matrix on which to project the temporal basis
+    :param PSI_P: np.array. 
+          POD's Psis
+    :param Sigma_P: np.array. 
+          POD's Sigmas
+    :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 N_T: int. 
+         Number of temporal snapshots
+    :param FOLDER_OUT: str. 
+         Folder in which the results are saved if SAVE_SPATIAL_POD = True
+    :param N_PARTITIONS: int. 
+         Number of partitions to be loaded. If D has been partitioned using MODULO, this parameter is automatically inherited from the main class. To be specified otherwise.
+
+    :param SAVE_SPATIAL_POD: bool. 
+         If True, results are saved on disk and released from memory
+
+    :param rescale: bool. 
+          If False, the Sigmas are used for the normalization. If True, these are ignored and the normalization is carried out.
+          For the standard POD, False is the way to go. 
+          However, for other decompositions (eg. the SPOD_s) you must use rescale=True                        
+
+    :return Phi_P: np.array. 
+          POD's Phis
+    """
+
+    R = PSI_P.shape[1]
+
+    if not MEMORY_SAVING:
+        N_S = D.shape[0]
+
+        if rescale:
+            # The following is the general normalization approach.
+            # not needed for POD for required for SPOD
+            Phi_P = np.zeros((N_S, R))
+            # N_S = D.shape[0] unused variable
+            PHI_P_SIGMA_P = np.dot(D, PSI_P)
+            if verbose:
+                print("Completing Spatial Structures Modes: \n")
+
+            for i in tqdm(range(0, R)):
+                # Normalize the columns of C to get spatial modes
+                Phi_P[:, i] = PHI_P_SIGMA_P[:, i] / Sigma_P[i]
+
+        else:
+            # We take only the first R modes.
+            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)
+            # Here is the one shot projection:
+            Phi_P = np.linalg.multi_dot([D, PSI_P[:, 0:R], Sigma_P_Inv])
+
+            if SAVE_SPATIAL_POD:
+                os.makedirs(FOLDER_OUT + 'POD', exist_ok=True)
+                np.savez(FOLDER_OUT + '/POD/pod_spatial_basis', phis=Phi_P)
+                # removed PHI_P_SIGMA_P=PHI_P_SIGMA_P, not present if not rescale and not needed (?)
+
+        return Phi_P
+
+    else:
+
+        N_S = np.shape(np.load(FOLDER_OUT + "/data_partitions/di_1.npz")['di'])[0]
+        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
+
+        # --- Loading Psi_P
+        fixed = 0
+        R1 = 0
+        R2 = 0
+        C1 = 0
+        C2 = 0
+
+        for i in range(1, tot_blocks_row + 1):
+
+            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 b in range(1, tot_blocks_col + 1):
+                di = np.load(FOLDER_OUT + f"/data_partitions/di_{b}.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
+
+                if (b == tot_blocks_col) and (N_T - dim_col * N_PARTITIONS > 0):
+                    C1 = C2
+                    C2 = C1 + (N_T - dim_col * N_PARTITIONS)
+                else:
+                    C1 = (b - 1) * dim_col
+                    C2 = b * dim_col
+
+                np.copyto(dr[:, C1:C2], di[R1:R2, :])
+
+            PHI_SIGMA_BLOCK = np.dot(dr, PSI_P)
+            np.savez(FOLDER_OUT + f"/PHI_SIGMA_{i}",
+                     phi_sigma=PHI_SIGMA_BLOCK)
+
+        # 3 - Converting partitions R to partitions C and get Sigmas
+        dim_col = math.floor(R / N_PARTITIONS)
+        dim_row = math.floor(N_S / N_PARTITIONS)
+        dps = np.zeros((N_S, dim_col))
+        Phi_P = np.zeros((N_S, R))
+
+        if R % N_PARTITIONS != 0:
+            tot_blocks_col = N_PARTITIONS + 1
+        else:
+            tot_blocks_col = N_PARTITIONS
+
+        fixed = 0
+
+        for i in range(1, tot_blocks_col + 1):
+
+            if (i == 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 b in range(1, tot_blocks_row + 1):
+
+                PHI_SIGMA_BLOCK = np.load(FOLDER_OUT + f"/PHI_SIGMA_{b}.npz")['phi_sigma']
+
+                if (i == 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 = (i - 1) * dim_col
+                    R2 = i * dim_col
+
+                if (b == tot_blocks_row) and (N_S - dim_row * N_PARTITIONS > 0): # Change here
+                    C1 = C2
+                    C2 = C1 + (N_S - dim_row * N_PARTITIONS)
+                else:
+                    C1 = (b - 1) * dim_row
+                    C2 = b * dim_row
+
+                dps[C1:C2, :] = PHI_SIGMA_BLOCK[:, R1:R2]
+
+            # Computing Sigmas and Phis
+            if rescale:
+                for j in range(R1, R2):
+                    jj = j - R1
+                    Sigma_P[jj] = np.linalg.norm(dps[:, jj])
+                    Phi_P = dps[:, jj] / Sigma_P[jj]
+                    np.savez(FOLDER_OUT + f"/phi_{j + 1}", phi_p=Phi_P)
+            else:
+                for j in range(R1, R2):
+                    jj = j - R1
+                    Phi_P = dps[:, jj] / Sigma_P[j] # Change here
+                    np.savez(FOLDER_OUT + f"/phi_{j + 1}", phi_p=Phi_P)
+
+        Phi_P_M = np.zeros((N_S, R))
+        for j in range(R):
+            Phi_P_V = np.load(FOLDER_OUT + f"/phi_{j + 1}.npz")['phi_p']
+            Phi_P_M[:, j] = Phi_P_V
+
+        return Phi_P_M
+
+
+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([]), SIGMA_TYPE: str = "accurate", SIGMA_M: 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
+    :param Sigma_type : {'accurate', 'fast'}
+        If accurate, recompute the Sigmas after QR polishing. Slightly slower than the fast option in which the Sigmas are not recomputed.
+    :param SIGMA_M: np.array.:
+        The mPOD Sigmas before the QR polishing, tentatively assembled from all scales
+    :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))
+
+        # Re-compute the sigma after the qr polishing
+        SIGMA_TYPE = SIGMA_TYPE.lower()
+        if SIGMA_TYPE != 'fast':
+            if SIGMA_TYPE != 'accurate':
+                print('Warning: MODULO continues to run although SIGMA_TYPE was wrongly defined. Please set it to \'accurate\' or \'fast\' ')
+            if weights.size == 0:
+                SIGMA_M = np.linalg.norm(PHI_M_SIGMA_M, axis=0)
+            else:
+                SIGMA_M = np.linalg.norm(PHI_M_SIGMA_M*np.sqrt(weights), axis=0)
+
+
+        # Normalize the columns of C to get spatial modes
+        PHI_M = PHI_M_SIGMA_M / SIGMA_M
+
+        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/temporal_structures.py

@@ -0,0 +1,241 @@
+import os
+import numpy as np
+from scipy.signal import firwin  # To create FIR kernels
+from tqdm import tqdm
+from modulo_vki.utils import conv_m, conv_m_2D, 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', conv_type: str = '1d', verbose: bool = True):
+    '''
+    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. 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, 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. 
+        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.
+    :param conv_type: {'1d', '2d'}
+        If 1d, compute K_hat applying 1d FIR filters to the columns and then rows of the extended K.
+        More robust against windowing effects but more expensive (useful for modes that are slow compared to the observation time).
+        If 2d, compute K_hat applying a 2d FIR filter on the extended K.
+    :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.0 / dt
+    nyq = fs / 2.0
+    
+    cuts = np.asarray(F_V) / nyq 
+    edges = np.concatenate(([0], cuts, [1]))  
+    M = len(edges) - 1
+    
+    assert len(Nf) == M, "Nf must be of size M+1, where M is the number of scales. Instead got sizes {}, {}".format(len(Nf), M+1)
+    assert len(F_V) == M-1, "F_V must be of size M, where M is the number of scales. Instead got sizes {}, {}".format(len(F_V), M)
+    assert len(Keep) == M, "Keep must be of size M+1, where M is the number of scales. Instead got sizes {}, {}".format(len(Keep), M+1)
+    
+    n_t = K.shape[1]
+    
+    # DFT-trick below: computing frequency bins.
+    freqs = np.fft.fftfreq(n_t) #* fs
+    
+    # init modes accumulators
+    Psi_M = np.empty((n_t, 0))
+    Sigma_M = np.empty((0,))
+    
+    def _design_filter_and_mask(m):
+        # use normalized firwin in agreement to normalized freqs above
+        low, high = edges[m], edges[m+1]
+        if m == 0:
+            # low-pass
+            h = firwin(numtaps=Nf[m], cutoff=high, #fs=Fs,
+                       window='hamming', pass_zero=True)
+            mask = lambda f: np.abs(f) <= high/2
+        elif m == M - 1:
+            # high-pass
+            h = firwin(numtaps=Nf[m], cutoff=low, #fs=Fs,
+                       window='hamming', pass_zero=False)
+            mask = lambda f: np.abs(f) >= low/2
+        else:
+            # band-pass
+            h = firwin(numtaps=Nf[m], cutoff=[low, high], #fs=Fs,
+                       window='hamming', pass_zero=False)
+            mask = lambda f: (np.abs(f) >= low/2) & (np.abs(f) <= high/2)
+        return h, mask
+    
+    for m in range(M):
+        if not Keep[m]:
+            if verbose:
+                print(f"Skipping band {m+1}/{M}")
+            continue
+
+        # design filter & mask
+        h, mask_fn = _design_filter_and_mask(m)
+        band_label = f"{edges[m]*nyq:.2f}–{edges[m+1]*nyq:.2f} Hz"
+        if verbose:
+            print(f"\nFiltering band {m+1}/{M}: {band_label}")
+
+        # rank estimate
+        mask_idxs = mask_fn(freqs)
+
+        R_K = min(np.count_nonzero(mask_idxs), SAT, n_Modes)
+        if verbose:
+            print(f" → estimating {R_K} modes from {mask_idxs.sum()} freq bins")
+        
+        if R_K == 0:
+            print(f"skipping")
+            continue
+
+        # apply filter to correlation matrix
+        conv_type = conv_type.lower()
+        if conv_type == '2d':
+            Kf = conv_m_2D(K, h, Ex, boundaries)
+        else:
+            Kf = conv_m(K, h, Ex, boundaries)
+
+        # diagonalize
+        Psi_P, Sigma_P = switch_eigs(Kf, R_K, eig_solver)
+
+        # append
+        Psi_M    = np.hstack((Psi_M,    Psi_P))
+        Sigma_M = np.concatenate((Sigma_M, Sigma_P))
+
+    # 5) Sort modes by energy and QR-polish
+    order = np.argsort(Sigma_M)[::-1]
+    Psi_M = Psi_M[:, order]
+    if verbose:
+        print("\nQR polishing...")
+    PSI_M, _ = np.linalg.qr(Psi_M, mode=MODE)
+
+    Sigma_M = Sigma_M[order] # potentially used if effect of qr polishing is negligible on PSI_M
+
+
+    
+    if MEMORY_SAVING:
+        os.makedirs(FOLDER_OUT + '/mPOD', exist_ok=True)
+        np.savez(FOLDER_OUT + '/mPOD/Psis', Psis=PSI_M)
+
+    return PSI_M[:, :n_Modes], Sigma_M[:n_Modes]
+
+    
+
+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.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
+
+
+def Temporal_basis_POD(K, SAVE_T_POD=False, FOLDER_OUT='./', 
+                       n_Modes=10,eig_solver: str = 'eigh',verbose=True):
+    """
+    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
+
+    :param FOLDER_OUT: str. Folder in which the results will be saved (if SAVE_T_POD=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 throughout the computation
+    :return: Psi_P: np.array. POD's Psis
+    :return: Sigma_P: np.array. POD's Sigmas
+    """
+    if verbose:
+        print("Diagonalizing K...")
+    Psi_P, Sigma_P = switch_eigs(K, n_Modes, eig_solver)
+    
+
+    if SAVE_T_POD:
+        os.makedirs(FOLDER_OUT + "/POD/", exist_ok=True)
+        print("Saving POD temporal basis")
+        np.savez(FOLDER_OUT + '/POD/temporal_basis', Psis=Psi_P, Sigmas=Sigma_P)
+
+    return Psi_P, Sigma_P