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

modulo_vki/modulo.py

@@ -1,48 +1,45 @@
-# Functional ones:
 import os
 import numpy as np
-from scipy import linalg
-from sklearn.metrics.pairwise import pairwise_kernels
-# To have fancy loading bar
+from numpy import linalg as LA
 from tqdm import tqdm
 
-# All the functions from the modulo package 
-from modulo_vki.core._dft import dft_fit
+from modulo_vki.core._k_matrix import CorrelationMatrix, spectral_filter, kernelized_K
+from modulo_vki.core.temporal_structures import dft, temporal_basis_mPOD, Temporal_basis_POD
+from modulo_vki.core.spatial_structures import Spatial_basis_POD, spatial_basis_mPOD
 from modulo_vki.core._dmd_s import dmd_s
-from modulo_vki.core._k_matrix import CorrelationMatrix
-from modulo_vki.core._mpod_space import spatial_basis_mPOD
-from modulo_vki.core._mpod_time import temporal_basis_mPOD
-from modulo_vki.core._pod_space import Spatial_basis_POD
-from modulo_vki.core._pod_time import Temporal_basis_POD
-from modulo_vki.core._spod_s import compute_SPOD_s
-from modulo_vki.core._spod_t import compute_SPOD_t
-from modulo_vki.utils._utils import switch_svds
 
-from modulo_vki.utils.read_db import ReadData
+from modulo_vki.core.utils import segment_and_fft, pod_from_dhat, apply_weights, switch_svds
+from sklearn.metrics.pairwise import pairwise_kernels
+
 
 class ModuloVKI:
     """
-    MODULO (MODal mULtiscale pOd) is a software developed at the von Karman Institute to perform Multiscale
-    Modal Analysis of numerical and experimental data using the Multiscale Proper Orthogonal Decomposition (mPOD).
-
-    Theoretical foundation can be found at:
-    https://arxiv.org/abs/1804.09646
-
-    Presentation of the MODULO framework available here:
-    https://arxiv.org/pdf/2004.12123.pdf
-
-    YouTube channel with hands-on tutorials can be found at:
-    https://youtube.com/playlist?list=PLEJZLD0-4PeKW6Ze984q08bNz28GTntkR
-
-    All the codes so far assume that the dataset is equally spaced both in space (i.e. along a Cartesian grid)
-    and in time. The extension to non-uniformly sampled data will be included in future releases.
-
-
+    MODULO (MODal mULtiscale pOd) is a software developed at the von Karman Institute
+    to perform Multiscale Modal Analysis using Multiscale Proper Orthogonal Decomposition (mPOD)
+    on numerical and experimental data.
+
+    References
+    ----------
+    - Theoretical foundation:
+      https://arxiv.org/abs/1804.09646
+
+    - MODULO framework presentation:
+      https://arxiv.org/pdf/2004.12123.pdf
+
+    - Hands-on tutorial videos:
+      https://youtube.com/playlist?list=PLEJZLD0-4PeKW6Ze984q08bNz28GTntkR
+
+    Notes
+    -----
+    MODULO operations assume the dataset is uniformly spaced in both space
+    (Cartesian grid) and time. For non-cartesian grids, the user must 
+    provide a weights vector `[w_1, w_2, ..., w_Ns]` where `w_i = area_cell_i / area_grid`.
     """
 
-    def __init__(self, data: np.array,
+    def __init__(self,
+                 data: np.ndarray,
                  N_PARTITIONS: int = 1,
-                 FOLDER_OUT='./',
+                 FOLDER_OUT: str = './',
                  SAVE_K: bool = False,
                  N_T: int = 100,
                  N_S: int = 200,
@@ -50,42 +47,50 @@ class ModuloVKI:
                  dtype: str = 'float32',
                  eig_solver: str = 'eigh',
                  svd_solver: str = 'svd_sklearn_truncated',
-                 weights: np.array = np.array([])):
+                 weights: np.ndarray = np.array([])):
         """
-        This function initializes the main parameters needed by MODULO.
-
-        Attributes:
-
-        :param data: This is the data matrix to factorize. It is a np.array with
-               shape ((N_S, N_T)). If the data has not yet been prepared in the form of a np.array,
-               the method ReadData in MODULO can be used (see ReadData). If the memory saving is active (N_PARTITIONS >1), the folder with partitions should be prepared.
-               If the memory saving is active, this entry = None. The data matrix is assumed to big to be saved and the
+        Initialize the MODULO analysis.
 
-        :param N_PARTITIONS: If memory saving feature is active, this parameter sets the number of partitions
-               that will be used to store the data matrices during the computations.
+        Parameters
+        ----------
+        data : np.ndarray
+            Data matrix of shape (N_S, N_T) to factorize. If not yet formatted, use the `ReadData`
+            method provided by MODULO. When memory saving mode (N_PARTITIONS > 1) is active,
+            set this parameter to None and use prepared partitions instead.
 
-        :param FOLDER_OUT: Folder in which the output will be stored.The output includes the matrices Phi, Sigma and Psi (optional) and temporary files
-               used for some of the calculations (e.g.: for memory saving).
+        N_PARTITIONS : int, default=1
+            Number of partitions used for memory-saving computation. If set greater than 1,
+            data must be partitioned in advance and `data` set to None.
 
-        :param  SAVE_K:  A flag deciding if the matrix will be stored in the disk (in FOLDER_OUT/correlation_matrix) or not.
-            Default option is 'False'.
+        FOLDER_OUT : str, default='./'
+            Directory path to store output (Phi, Sigma, Psi matrices) and intermediate
+            calculation files (e.g., partitions, correlation matrix).
 
-        :param N_T: Number of time steps, must be given when N_PARTITIONS >1
+        SAVE_K : bool, default=False
+            Whether to store the correlation matrix K to disk in
+            `FOLDER_OUT/correlation_matrix`.
 
-        :param N_S: Number of grid points, must be given when N_PARTITIONS >1
+        N_T : int, default=100
+            Number of temporal snapshots. Mandatory when using partitions (N_PARTITIONS > 1).
 
-        :param n_Modes: Number of Modes to be computed
+        N_S : int, default=200
+            Number of spatial grid points. Mandatory when using partitions (N_PARTITIONS > 1).
 
-        :param dtype: Cast "data" with type dtype
+        n_Modes : int, default=10
+            Number of modes to compute.
 
-        :param eig_solver: Numerical solver to compute the eigen values
+        dtype : str, default='float32'
+            Data type for casting input data.
 
-        :param svd_solver: Numerical solver to compute the Single Value Decomposition
-
-        :param weights: weight vector [w_i,....,w_{N_s}] where w_i = area_cell_i/area_grid
-               Only needed if grid is non-uniform.
+        eig_solver : str, default='eigh'
+            Solver for eigenvalue decomposition.
 
+        svd_solver : str, default='svd_sklearn_truncated'
+            Solver for Singular Value Decomposition (SVD).
 
+        weights : np.ndarray, default=np.array([])
+            Weights vector `[w_1, w_2, ..., w_Ns]` to account for non-uniform spatial grids.
+            Defined as `w_i = area_cell_i / area_grid`. Leave empty for uniform grids.
         """
 
         print("MODULO (MODal mULtiscale pOd) is a software developed at the von Karman Institute to perform "
@@ -95,6 +100,38 @@ class ModuloVKI:
             raise TypeError(
                 "Please check that your database is in an numpy array format. If D=None, then you must have memory saving (N_PARTITIONS>1)")
 
+        if N_PARTITIONS > 1:
+            self.MEMORY_SAVING = True
+        else:
+            self.MEMORY_SAVING = False
+
+            # Assign the number of modes
+        self.n_Modes = n_Modes
+        # If particular needs, override choice for svd and eigen solve
+        self.svd_solver = svd_solver.lower()
+        self.eig_solver = eig_solver.lower()
+        possible_svds = ['svd_numpy', 'svd_scipy_sparse', 'svd_sklearn_randomized', 'svd_sklearn_truncated']
+        possible_eigs = ['svd_sklearn_randomized', 'eigsh', 'eigh']
+
+        if self.svd_solver not in possible_svds:
+            raise NotImplementedError("The requested SVD solver is not implemented. Please pick one of the following:"
+                                      "which belongs to: \n {}".format(possible_svds))
+
+        if self.eig_solver not in possible_eigs:
+            raise NotImplementedError("The requested EIG solver is not implemented. Please pick one of the following: "
+                                      " \n {}".format(possible_eigs))
+
+        # if N_PARTITIONS >= self.N_T:
+        #     raise AttributeError("The number of requested partitions is greater of the total columns (N_T). Please,"
+        #                          "try again.")
+
+        self.N_PARTITIONS = N_PARTITIONS
+        self.FOLDER_OUT = FOLDER_OUT
+        self.SAVE_K = SAVE_K
+
+        if self.MEMORY_SAVING:
+            os.makedirs(self.FOLDER_OUT, exist_ok=True)
+        
         # Load the data matrix
         if isinstance(data, np.ndarray):
             # Number of points in time and space
@@ -106,8 +143,9 @@ class ModuloVKI:
             self.D = None  # D is never saved when N_partitions >1
             self.N_S = N_S  # so N_S and N_t must be given as parameters of modulo
             self.N_T = N_T
-
-        # Load and applied the weights to the D matrix
+        
+        '''If the grid is not cartesian, ensure inner product is properly defined using weights.'''
+        
         if weights.size != 0:
             if len(weights) == self.N_S:
                 print("The weights you have input have the size of the columns of D \n"
@@ -129,407 +167,299 @@ class ModuloVKI:
             else:
                 self.Dstar = None
         else:
+            
             print("Modulo assumes you have a uniform grid. "
                   "If not, please give the weights as parameters of MODULO!")
             self.weights = weights
             self.Dstar = self.D
-
-        if N_PARTITIONS > 1:
-            self.MEMORY_SAVING = True
-        else:
-            self.MEMORY_SAVING = False
-
-            # Assign the number of modes
-        self.n_Modes = n_Modes
-        # If particular needs, override choice for svd and eigen solve
-        self.svd_solver = svd_solver.lower()
-        self.eig_solver = eig_solver.lower()
-        possible_svds = ['svd_numpy', 'svd_scipy_sparse', 'svd_sklearn_randomized', 'svd_sklearn_truncated']
-        possible_eigs = ['svd_sklearn_randomized', 'eigsh', 'eigh']
-
-        if self.svd_solver not in possible_svds:
-            raise NotImplementedError("The requested SVD solver is not implemented. Please pick one of the following:"
-                                      "which belongs to: \n {}".format(possible_svds))
-
-        if self.eig_solver not in possible_eigs:
-            raise NotImplementedError("The requested EIG solver is not implemented. Please pick one of the following: "
-                                      " \n {}".format(possible_eigs))
-
-        # if N_PARTITIONS >= self.N_T:
-        #     raise AttributeError("The number of requested partitions is greater of the total columns (N_T). Please,"
-        #                          "try again.")
-
-        self.N_PARTITIONS = N_PARTITIONS
-
-        self.FOLDER_OUT = FOLDER_OUT
-
-        self.SAVE_K = SAVE_K
-
-        if self.MEMORY_SAVING:
-            os.makedirs(self.FOLDER_OUT, exist_ok=True)
-
-    def _temporal_basis_POD(self,
-                            SAVE_T_POD: bool = False):
+                         
+    
+    def DFT(self, F_S, SAVE_DFT=False):
         """
-        This method computes the temporal structure for the Proper Orthogonal Decomposition (POD) computation.
-        The theoretical background of the POD is briefly recalled here:
-
-        https://youtu.be/8fhupzhAR_M
-
-        The diagonalization of K is computed via Singular Value Decomposition (SVD).
-        A speedup is available if the user is on Linux machine, in which case MODULO
-        exploits the power of JAX and its Numpy implementation.
-
-        For more on JAX:
-
-        https://github.com/google/jax
-        https://jax.readthedocs.io/en/latest/jax.numpy.html
-
-        If the user is on a Win machine, Linux OS can be used using
-        the Windows Subsystem for Linux.
-
-        For more on WSL:
-        https://docs.microsoft.com/en-us/windows/wsl/install-win10
-
-        :param SAVE_T_POD: bool
-                Flag deciding if the results will be stored on the disk.
-                Default value is True, to limit the RAM's usage.
-                Note that this might cause a minor slowdown for the loading,
-                but the tradeoff seems worthy.
-                This attribute is passed to the MODULO class.
-
-
-        POD temporal basis are returned if MEMORY_SAVING is not active. Otherwise all the results are saved on disk.
-
-        :return Psi_P: np.array
-                POD Psis
-
-        :return Sigma_P: np.array
-                POD Sigmas. If needed, Lambdas can be easily computed recalling that: Sigma_P = np.sqrt(Lambda_P)
+        Computes the Discrete Fourier Transform (DFT) of the dataset.
+
+        For detailed guidance, see the tutorial video:
+        https://www.youtube.com/watch?v=8fhupzhAR_M&list=PLEJZLD0-4PeKW6Ze984q08bNz28GTntkR&index=2
+
+        Parameters
+        ----------
+        F_S : float
+                Sampling frequency in Hz.
+
+        SAVE_DFT : bool, default=False
+                If True, saves the computed DFT outputs to disk under:
+                `self.FOLDER_OUT/MODULO_tmp`.
+
+        Returns
+        -------
+        Phi_F : np.ndarray
+                Spatial DFT modes (spatial structures matrix).
+                
+        Psi_F : np.ndarray
+                Temporal DFT modes (temporal structures matrix).
+
+        Sigma_F : np.ndarray
+                Modal amplitudes.
         """
+        if self.D is None:
+            D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
+            SAVE_DFT = True
+            Phi_F, Psi_F, Sigma_F = dft(self.N_T, F_S, D, self.FOLDER_OUT, SAVE_DFT=SAVE_DFT)
 
-        if self.MEMORY_SAVING:
-            K = np.load(self.FOLDER_OUT + "/correlation_matrix/k_matrix.npz")['K']
-            SAVE_T_POD = True
         else:
-            K = self.K
-
-        Psi_P, Sigma_P = Temporal_basis_POD(K, SAVE_T_POD,
-                                            self.FOLDER_OUT, self.n_Modes, self.eig_solver)
-
-        del K
-        return Psi_P, Sigma_P if not self.MEMORY_SAVING else None
-
-    def _spatial_basis_POD(self, Psi_P, Sigma_P,
-                           SAVE_SPATIAL_POD: bool = True):
-        """
-        This method computes the spatial structure for the Proper Orthogonal Decomposition (POD) computation.
-        The theoretical background of the POD is briefly recalled here:
-
-        https://youtu.be/8fhupzhAR_M
-
-        :param Psi_P: np.array
-                POD temporal basis
-        :param Sigma_P: np.array
-                POD Sigmas
-        :param SAVE_SPATIAL_POD: bool
-                Flag deciding if the results will be stored on the disk.
-                Default value is True, to limit the RAM's usage.
-                Note that this might cause a minor slowdown for the loading,
-                but the tradeoff seems worthy.
-                This attribute is passed to the MODULO class.
-
-        :return Phi_P: np.array
-            POD Phis
-
-        """
-
-        self.SAVE_SPATIAL_POD = SAVE_SPATIAL_POD
-
-        if self.MEMORY_SAVING:
-            '''Loading temporal basis from disk. They're already in memory otherwise.'''
-            Psi_P = np.load(self.FOLDER_OUT + 'POD/temporal_basis.npz')['Psis']
-            Sigma_P = np.load(self.FOLDER_OUT + 'POD/temporal_basis.npz')['Sigmas']
-
-        Phi_P = Spatial_basis_POD(self.D, N_T=self.N_T, PSI_P=Psi_P, Sigma_P=Sigma_P,
-                                  MEMORY_SAVING=self.MEMORY_SAVING, FOLDER_OUT=self.FOLDER_OUT,
-                                  N_PARTITIONS=self.N_PARTITIONS, SAVE_SPATIAL_POD=SAVE_SPATIAL_POD)
-
-        return Phi_P if not self.MEMORY_SAVING else None
-
-    def _temporal_basis_mPOD(self, K, Nf, Ex, F_V, Keep, boundaries, MODE, dt, K_S=False):
-        """
-        This function computes the temporal structures of each scale in the mPOD, as in step 4 of the algorithm
-        ref: Multi-Scale Proper Orthogonal Decomposition of Complex Fluid Flows - M. A. Mendez et al.
-
-        :param K: np.array
-                Temporal correlation matrix
-        :param Nf: np.array
-                Order of the FIR filters that are used to isolate each of the scales
-        :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
-                Scale keep
-        :param boundaries: str -> {'nearest', 'reflect', 'wrap' or 'extrap'}
-                Define the boundary conditions for the filtering process, in order to avoid edge effects.
-                The available boundary conditions are the classic ones implemented for image processing:
-                nearest', 'reflect', 'wrap' or 'extrap'. See also https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html
-        :param MODE: str -> {‘reduced’, ‘complete’, ‘r’, ‘raw’}
-                A QR factorization is used to enforce the orthonormality of the mPOD basis, to compensate
-                for the non-ideal frequency response of the filters.
-                The option MODE from np.linalg.qr carries out this operation.
-
-        :return PSI_M: np.array
-                Multiscale POD temporal basis
-
-        """
-
-        if self.MEMORY_SAVING:
-            K = np.load(self.FOLDER_OUT + "/correlation_matrix/k_matrix.npz")['K']
-
-        PSI_M = temporal_basis_mPOD(K=K, Nf=Nf, Ex=Ex, F_V=F_V, Keep=Keep, boundaries=boundaries,
-                                    MODE=MODE, dt=dt, FOLDER_OUT=self.FOLDER_OUT,
-                                    n_Modes=self.n_Modes, K_S=False,
-                                    MEMORY_SAVING=self.MEMORY_SAVING, SAT=self.SAT, eig_solver=self.eig_solver)
-
-        return PSI_M if not self.MEMORY_SAVING else None
-
-    def _spatial_basis_mPOD(self, D, PSI_M, SAVE):
-        """
-        This function implements the last step of the mPOD algorithm:
-        completing the decomposition. Here we project from psis, to get phis and sigmas
-
-        :param D: np.array
-                data matrix
-        :param PSI_M: np.array
-                temporal basis for the mPOD. Remember that it is not possible to impose both basis matrices
-                phis and psis: given one of the two, the other is univocally determined.
-        :param SAVE: bool
-                if True, MODULO saves the results on disk.
-
-        :return Phi_M: np.array
-                mPOD Phis (Matrix of spatial structures)
-        :return Psi_M: np.array
-                mPOD Psis (Matrix of temporal structures)
-        :return Sigma_M: np.array
-                mPOD Sigmas (vector of amplitudes, i.e. the diagonal of Sigma_M)
-
-        """
-
-        Phi_M, Psi_M, Sigma_M = spatial_basis_mPOD(D, PSI_M, N_T=self.N_T, N_PARTITIONS=self.N_PARTITIONS,
-                                                   N_S=self.N_S, MEMORY_SAVING=self.MEMORY_SAVING,
-                                                   FOLDER_OUT=self.FOLDER_OUT,
-                                                   SAVE=SAVE)
-
-        return Phi_M, Psi_M, Sigma_M
-
-    def compute_mPOD(self, Nf, Ex, F_V, Keep, SAT, boundaries, MODE, dt, SAVE=False):
-        """
-        This function computes the temporal structures of each scale in the mPOD, as in step 4 of the algorithm
-        ref: Multi-Scale Proper Orthogonal Decomposition of Complex Fluid Flows - M. A. Mendez et al.
-
-        :param K: np.array
-                Temporal correlation matrix
-
-        :param Nf: np.array
-                Order of the FIR filters that are used to isolate each of the scales
-
-        :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
-                Scale keep
-
-        :param boundaries: str -> {'nearest', 'reflect', 'wrap' or 'extrap'}
-                Define the boundary conditions for the filtering process, in order to avoid edge effects.
-                The available boundary conditions are the classic ones implemented for image processing:
-                nearest', 'reflect', 'wrap' or 'extrap'. See also https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html
-
-        :param MODE: str -> {‘reduced’, ‘complete’, ‘r’, ‘raw’}
-                A QR factorization is used to enforce the orthonormality of the mPOD basis, to compensate
-                for the non-ideal frequency response of the filters.
-                The option MODE from np.linalg.qr carries out this operation.
-
-        :param SAT: Maximum number of modes per scale.
-                    Only used for mPOD (max number of modes per scale)
-
-        :param dt: float
-                temporal step
-
-        :return Phi_M: np.array
-                mPOD Phis (Matrix of spatial structures)
-        :return Psi_M: np.array
-                mPOD Psis (Matrix of temporal structures)
-        :return Sigma_M: np.array
-                mPOD Sigmas (vector of amplitudes, i.e. the diagonal of Sigma_M
+            Phi_F, Psi_F, Sigma_F = dft(self.N_T, F_S, self.D, 
+                                        self.FOLDER_OUT, SAVE_DFT=SAVE_DFT)
 
+        return Phi_F, Psi_F, Sigma_F
+    
+    def POD(self, SAVE_T_POD: bool = False, mode: str = 'K',verbose=True):
         """
-
-        print('Computing correlation matrix D matrix...')
-        self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS,
-                                   self.MEMORY_SAVING,
-                                   self.FOLDER_OUT, self.SAVE_K, D=self.Dstar)
-
-        if self.MEMORY_SAVING:
-            self.K = np.load(self.FOLDER_OUT + '/correlation_matrix/k_matrix.npz')['K']
-
-        print("Computing Temporal Basis...")
-
-        PSI_M = temporal_basis_mPOD(K=self.K, Nf=Nf, Ex=Ex, F_V=F_V, Keep=Keep, boundaries=boundaries,
-                                    MODE=MODE, dt=dt, FOLDER_OUT=self.FOLDER_OUT,
-                                    n_Modes=self.n_Modes, MEMORY_SAVING=self.MEMORY_SAVING, SAT=SAT,
-                                    eig_solver=self.eig_solver)
-
-        print("Done.")
-
-        if hasattr(self, 'D'):  # if self.D is available:
-            print('Computing Phi from D...')
-            Phi_M, Psi_M, Sigma_M = spatial_basis_mPOD(self.D, PSI_M, N_T=self.N_T, N_PARTITIONS=self.N_PARTITIONS,
-                                                       N_S=self.N_S, MEMORY_SAVING=self.MEMORY_SAVING,
-                                                       FOLDER_OUT=self.FOLDER_OUT,
-                                                       SAVE=SAVE)
-
-        else:  # if not, the memory saving is on and D will not be used. We pass a dummy D
-            print('Computing Phi from partitions...')
-            Phi_M, Psi_M, Sigma_M = spatial_basis_mPOD(np.array([1]), PSI_M, N_T=self.N_T,
-                                                       N_PARTITIONS=self.N_PARTITIONS,
-                                                       N_S=self.N_S, MEMORY_SAVING=self.MEMORY_SAVING,
-                                                       FOLDER_OUT=self.FOLDER_OUT,
-                                                       SAVE=SAVE)
-
-        print("Done.")
-
-        return Phi_M, Psi_M, Sigma_M
-
-    def compute_POD_K(self, SAVE_T_POD: bool = False):
+        Compute the Proper Orthogonal Decomposition (POD) of a dataset.
+
+        The POD is computed using the snapshot approach, working on the
+        temporal correlation matrix.  The eigenvalue solver for this
+        matrix is defined in the `eig_solver` attribute of the class.
+
+        Parameters
+        ----------
+        SAVE_T_POD : bool, optional
+                Flag to save time-dependent POD data. Default is False.
+        mode : str, optional
+                The mode of POD computation. Must be either 'K' or 'svd'.
+                'K' (default) uses the snapshot method on the temporal
+                correlation matrix.
+                'svd' uses the SVD decomposition (full dataset must fit in memory).
+
+        Returns
+        -------
+        Phi_P : numpy.ndarray
+                POD temporal modes.
+        Psi_P : numpy.ndarray
+                POD spatial modes.
+        Sigma_P : numpy.ndarray
+                POD singular values (eigenvalues are Sigma_P**2).
+        Raises
+        ------
+        ValueError
+                If `mode` is not 'k' or 'svd'.
+
+        Notes
+        -----
+        A brief recall of the theoretical background of the POD is
+        available at https://youtu.be/8fhupzhAR_M
         """
-        This method computes the Proper Orthogonal Decomposition (POD) of a dataset
-        using the snapshot approach, i.e. working on the temporal correlation matrix.
-        The eig solver for K is defined in 'eig_solver'
-        The theoretical background of the POD is briefly recalled here:
-
-        https://youtu.be/8fhupzhAR_M
-
-        :return Psi_P: np.array
-                POD Psis
-
-        :return Sigma_P: np.array
-                POD Sigmas. If needed, Lambdas can be easily computed recalling that: Sigma_P = np.sqrt(Lambda_P)
-
-        :return Phi_P: np.array
-                POD Phis
-        """
-
-        print('Computing correlation matrix...')
-        self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS,
-                                   self.MEMORY_SAVING,
-                                   self.FOLDER_OUT, self.SAVE_K, D=self.Dstar, weights=self.weights)
-
-        if self.MEMORY_SAVING:
-            self.K = np.load(self.FOLDER_OUT + '/correlation_matrix/k_matrix.npz')['K']
-
-        print("Computing Temporal Basis...")
-        Psi_P, Sigma_P = Temporal_basis_POD(self.K, SAVE_T_POD,
-                                            self.FOLDER_OUT, self.n_Modes, eig_solver=self.eig_solver)
-        print("Done.")
-        print("Computing Spatial Basis...")
-
-        if self.MEMORY_SAVING:  # if self.D is available:
-            print('Computing Phi from partitions...')
-            Phi_P = Spatial_basis_POD(np.array([1]), N_T=self.N_T,
-                             PSI_P=Psi_P,
-                             Sigma_P=Sigma_P,
-                             MEMORY_SAVING=self.MEMORY_SAVING,
-                             FOLDER_OUT=self.FOLDER_OUT,
-                             N_PARTITIONS=self.N_PARTITIONS)
-
-        else:  # if not, the memory saving is on and D will not be used. We pass a dummy D
-           print('Computing Phi from D...')
-           Phi_P = Spatial_basis_POD(self.D, N_T=self.N_T,
-                                    PSI_P=Psi_P,
-                                    Sigma_P=Sigma_P,
-                                    MEMORY_SAVING=self.MEMORY_SAVING,
-                                    FOLDER_OUT=self.FOLDER_OUT,
-                                    N_PARTITIONS=self.N_PARTITIONS)
-        print("Done.")
+        
+        mode = mode.lower()
+        assert mode in ('k', 'svd'), "POD mode must be either 'K', temporal correlation matrix, or 'svd'." 
+
+        if mode == 'k':
+                if verbose:
+                    print('Computing correlation matrix...')
+                self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS,
+                                        self.MEMORY_SAVING,
+                                        self.FOLDER_OUT, self.SAVE_K,
+                                        D=self.Dstar, weights=self.weights,
+                                        verbose=verbose)
+
+                if self.MEMORY_SAVING:
+                        self.K = np.load(self.FOLDER_OUT + '/correlation_matrix/k_matrix.npz')['K']
+                if verbose:
+                    print("Computing Temporal Basis...")
+                Psi_P, Sigma_P = Temporal_basis_POD(self.K, SAVE_T_POD,
+                                                self.FOLDER_OUT, self.n_Modes, eig_solver=self.eig_solver,verbose=verbose)
+
+                if verbose:
+                    print("Done.")
+                    print("Computing Spatial Basis...")
+
+                if self.MEMORY_SAVING:  # if self.D is available:
+                        if verbose:
+                            print('Computing Phi from partitions...')
+                        Phi_P = Spatial_basis_POD(np.array([1]), N_T=self.N_T,
+                                        PSI_P=Psi_P,
+                                        Sigma_P=Sigma_P,
+                                        MEMORY_SAVING=self.MEMORY_SAVING,
+                                        FOLDER_OUT=self.FOLDER_OUT,
+                                        N_PARTITIONS=self.N_PARTITIONS,
+                                        verbose=verbose)
+
+                else:  # if not, the memory saving is on and D will not be used. We pass a dummy D
+                        if verbose:
+                            print('Computing Phi from D...')
+                        Phi_P = Spatial_basis_POD(self.D, N_T=self.N_T,
+                                                PSI_P=Psi_P,
+                                                Sigma_P=Sigma_P,
+                                                MEMORY_SAVING=self.MEMORY_SAVING,
+                                                FOLDER_OUT=self.FOLDER_OUT,
+                                                N_PARTITIONS=self.N_PARTITIONS,
+                                                verbose=verbose)
+                        if verbose:
+                            print("Done.")
+        
+        else:  
+                if self.MEMORY_SAVING:
+                        
+                        if self.N_T % self.N_PARTITIONS != 0:
+                                tot_blocks_col = self.N_PARTITIONS + 1
+                        else:
+                                tot_blocks_col = self.N_PARTITIONS
+
+                        # Prepare the D matrix again
+                        D = np.zeros((self.N_S, self.N_T))
+                        R1 = 0
+
+                        # print(' \n Reloading D from tmp...')
+                        for k in tqdm(range(tot_blocks_col)):
+                                di = np.load(self.FOLDER_OUT + f"/data_partitions/di_{k + 1}.npz")['di']
+                                R2 = R1 + np.shape(di)[1]
+                                D[:, R1:R2] = di
+                                R1 = R2
+
+                        # Now that we have D back, we can proceed with the SVD approach
+                        Phi_P, Psi_P, Sigma_P = switch_svds(D, self.n_Modes, self.svd_solver)
+
+                else:  # self.MEMORY_SAVING:
+                        Phi_P, Psi_P, Sigma_P = switch_svds(self.D, self.n_Modes, self.svd_solver)    
 
         return Phi_P, Psi_P, Sigma_P
 
-    def compute_POD_svd(self, SAVE_T_POD: bool = False):
+    
+    def mPOD(self, Nf, Ex, F_V, Keep, SAT, boundaries, MODE, dt, SAVE=False, K_in=None, Sigma_type='accurate', conv_type: str = '1d', verbose=True):
         """
-        This method computes the Proper Orthogonal Decomposition (POD) of a dataset
-        using the SVD decomposition. The svd solver is defined by 'svd_solver'.
-        Note that in this case, the memory saving option is of no help, since
-        the SVD must be performed over the entire dataset.
-
-        https://youtu.be/8fhupzhAR_M
-
-        :return Psi_P: np.array
-            POD Psis
-
-        :return Sigma_P: np.array
-            POD Sigmas. If needed, Lambdas can be easily computed recalling that: Sigma_P = np.sqrt(Lambda_P)
-
-         :return Phi_P: np.array
-            POD Phis
+        Multi-Scale Proper Orthogonal Decomposition (mPOD) of a signal.
+
+        Parameters
+        ----------
+        Nf : np.array
+                Orders of the FIR filters used to isolate each scale. Must be of size len(F_V) + 1.
+        
+        Ex : int
+                Extension length at the boundaries to impose boundary conditions (must be at least as large as Nf).
+        
+        F_V : np.array
+                Frequency splitting vector, containing the cutoff frequencies for each scale. Units depend on the temporal step `dt`.
+        
+        Keep : np.array
+                Boolean array indicating scales to retain. Must be of size len(F_V) + 1.
+        
+        SAT : int
+                Maximum number of modes per scale.
+        
+        boundaries : {'nearest', 'reflect', 'wrap', 'extrap'}
+                Boundary conditions for filtering to avoid edge effects. Refer to:
+                https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html
+        
+        MODE : {'reduced', 'complete', 'r', 'raw'}
+                Mode option for QR factorization, used to enforce orthonormality of the mPOD basis to account for non-ideal filter responses.
+        
+        dt : float
+                Temporal step size between snapshots.
+        
+        SAVE : bool, default=False
+                Whether to save intermediate results to disk.
+
+        K_in : np.array, default = none
+                K matrix. If none, compute it with D.
+
+        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.
+
+        conv_type : {'1d', '2d'}
+            If 1d, compute Kf 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 Kf applying a 2d FIR filter on the extended K.
+
+        Returns
+        -------
+        Phi_M : np.array
+                Spatial mPOD modes (spatial structures matrix).
+        
+        Psi_M : np.array
+                Temporal mPOD modes (temporal structures matrix).
+        
+        Sigma_M : np.array
+                Modal amplitudes.
         """
-        # If Memory saving is active, we must load back the data.
-        # This process is memory demanding. Different SVD solver will handle this differently.
-
-        if self.MEMORY_SAVING:
-            if self.N_T % self.N_PARTITIONS != 0:
-                tot_blocks_col = self.N_PARTITIONS + 1
-            else:
-                tot_blocks_col = self.N_PARTITIONS
-
-            # Prepare the D matrix again
-            D = np.zeros((self.N_S, self.N_T))
-            R1 = 0
-
-            # print(' \n Reloading D from tmp...')
-            for k in tqdm(range(tot_blocks_col)):
-                di = np.load(self.FOLDER_OUT + f"/data_partitions/di_{k + 1}.npz")['di']
-                R2 = R1 + np.shape(di)[1]
-                D[:, R1:R2] = di
-                R1 = R2
-
-            # Now that we have D back, we can proceed with the SVD approach
-            Phi_P, Psi_P, Sigma_P = switch_svds(D, self.n_Modes, self.svd_solver)
-
-
-        else:  # self.MEMORY_SAVING:
-            Phi_P, Psi_P, Sigma_P = switch_svds(self.D, self.n_Modes, self.svd_solver)
+        
+        if K_in is None:
+                if verbose:
+                    print('Computing correlation matrix D matrix...')
+                self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS,
+                                        self.MEMORY_SAVING,
+                                        self.FOLDER_OUT, self.SAVE_K, D=self.Dstar,
+                                        verbose=verbose)
+
+                if self.MEMORY_SAVING:
+                        self.K = np.load(self.FOLDER_OUT + '/correlation_matrix/k_matrix.npz')['K']
+        else:
+                if verbose:
+                    print('Using K matrix provided by the user...')
+                self.K = K_in
+
+        if verbose:
+            print("Computing Temporal Basis...")
+        PSI_M,SIGMA_M = temporal_basis_mPOD(
+                K=self.K, Nf=Nf, Ex=Ex, F_V=F_V, Keep=Keep, boundaries=boundaries,
+                MODE=MODE, dt=dt, FOLDER_OUT=self.FOLDER_OUT,
+                n_Modes=self.n_Modes, MEMORY_SAVING=self.MEMORY_SAVING, SAT=SAT,
+                eig_solver=self.eig_solver, conv_type=conv_type, verbose=verbose
+        )
+        if verbose:
+            print("Temporal Basis computed.")
+
+        if hasattr(self, 'D'):
+                if verbose:
+                    print('Computing spatial modes Phi from D...')
+                Phi_M, Psi_M, Sigma_M = spatial_basis_mPOD(
+                self.D, PSI_M, N_T=self.N_T, N_PARTITIONS=self.N_PARTITIONS,
+                N_S=self.N_S, MEMORY_SAVING=self.MEMORY_SAVING,
+                FOLDER_OUT=self.FOLDER_OUT, SAVE=SAVE, SIGMA_TYPE=Sigma_type, SIGMA_M=SIGMA_M
+                )
+        else:
+                if verbose:
+                    print('Computing spatial modes Phi from partitions...')
+                Phi_M, Psi_M, Sigma_M = spatial_basis_mPOD(
+                np.array([1]), PSI_M, N_T=self.N_T,
+                N_PARTITIONS=self.N_PARTITIONS, N_S=self.N_S,
+                MEMORY_SAVING=self.MEMORY_SAVING,
+                FOLDER_OUT=self.FOLDER_OUT, SAVE=SAVE,SIGMA_TYPE=Sigma_type, SIGMA_M=SIGMA_M
+                )
+        if verbose:
+            print("Spatial modes computed.")
 
-        return Phi_P, Psi_P, Sigma_P
+        return Phi_M, Psi_M, Sigma_M
 
-    def compute_DMD_PIP(self, SAVE_T_DMD: bool = True, F_S=1):
+    def DMD(self, SAVE_T_DMD: bool = True, F_S: float = 1.0, verbose:  bool = True):
         """
-        This method computes the Dynamic Mode Decomposition of the data
-        using the algorithm in https://arxiv.org/abs/1312.0041, which is basically the same as
-        the PIP algorithm proposed in https://www.sciencedirect.com/science/article/abs/pii/0167278996001248
-        See v1 of this paper https://arxiv.org/abs/2001.01971 for more details (yes, reviewers did ask to omit this detail in v2).
-
-        :return Phi_D: np.array
-                DMD Phis. As for the DFT, these are complex.
-
-        :return Lambda_D: np.array
-                DMD Eigenvalues (of the reduced propagator). These are complex.
-
-        :return freqs: np.array
-                Frequencies (in Hz, associated to the DMD modes)
-
-        :return a0s: np.array
-                Initial Coefficients of the Modes
-
+        Compute the Dynamic Mode Decomposition (DMD) of the dataset.
+
+        This implementation follows the algorithm in Tu et al. (2014) [1]_, which is
+        essentially the same as Penland (1996) [2]_.  For
+        additional low-level details see v1 of Mendez et al. (2020) [3]_.
+
+        Parameters
+        ----------
+        SAVE_T_DMD : bool, optional
+                If True, save time-dependent DMD results to disk. Default is True.
+        F_S : float, optional
+                Sampling frequency in Hz. Default is 1.0.
+
+        Returns
+        -------
+        Phi_D : numpy.ndarray
+                Complex DMD modes.
+        Lambda_D : numpy.ndarray
+                Complex eigenvalues of the reduced-order propagator.
+        freqs : numpy.ndarray
+                Frequencies (Hz) associated with each DMD mode.
+        a0s : numpy.ndarray
+                Initial amplitudes (coefficients) of the DMD modes.
+
+        References
+        ----------
+        .. [1] https://arxiv.org/abs/1312.0041
+        .. [2] https://www.sciencedirect.com/science/article/pii/0167278996001248
+        .. [3] https://arxiv.org/abs/2001.01971
         """
 
         # If Memory saving is active, we must load back the data
@@ -552,277 +482,416 @@ class ModuloVKI:
 
             # Compute the DMD
             Phi_D, Lambda, freqs, a0s = dmd_s(D[:, 0:self.N_T - 1],
-                                              D[:, 1:self.N_T], self.n_Modes, F_S, svd_solver=self.svd_solver)
+                                              D[:, 1:self.N_T], self.n_Modes, F_S, svd_solver=self.svd_solver,verbose=verbose)
 
         else:
             Phi_D, Lambda, freqs, a0s = dmd_s(self.D[:, 0:self.N_T - 1],
                                               self.D[:, 1:self.N_T], self.n_Modes, F_S, SAVE_T_DMD=SAVE_T_DMD,
-                                              svd_solver=self.svd_solver, FOLDER_OUT=self.FOLDER_OUT)
+                                              svd_solver=self.svd_solver, FOLDER_OUT=self.FOLDER_OUT,verbose=verbose)
 
         return Phi_D, Lambda, freqs, a0s
 
-    def compute_DFT(self, F_S, SAVE_DFT=False):
+    def SPOD(
+        self,
+        mode: str,
+        F_S: float,
+        n_Modes: int = 10,
+        SAVE_SPOD: bool = True,
+        **kwargs
+    ):
         """
-        This method computes the Discrete Fourier Transform of your data.
-
-        Check out this tutorial: https://www.youtube.com/watch?v=8fhupzhAR_M&list=PLEJZLD0-4PeKW6Ze984q08bNz28GTntkR&index=2
-
-        :param F_S: float,
-                Sampling Frequency [Hz]
-        :param SAVE_DFT: bool,
-                If True, MODULO will save the output in self.FOLDER OUT/MODULO_tmp
-
-        :return: Sorted_Freqs: np.array,
-                    Sorted Frequencies
-        :return Phi_F: np.array,
-                    DFT Phis
-        :return Sigma_F: np.array,
-                    DFT Sigmas
+        Unified Spectral POD interface.
+
+        Parameters
+        ----------
+        mode : {'sieber', 'towne'}
+            Which SPOD algorithm to run.
+        F_S : float
+            Sampling frequency [Hz].
+        n_Modes : int, optional
+            Number of modes to compute, by default 10.
+        SAVE_SPOD : bool, optional
+            Whether to save outputs, by default True.
+        **kwargs
+            For mode='sieber', accepts:
+              - N_O (int): semi-order of the diagonal filter
+              - f_c (float): cutoff frequency
+            For mode='towne', accepts:
+              - L_B (int): block length
+              - O_B (int): block overlap
+              - n_processes (int): number of parallel workers
+
+        Returns
+        -------
+        Phi : ndarray
+            Spatial modes.
+        Sigma : ndarray
+            Modal amplitudes.
+        Aux : tuple
+            Additional outputs.
         """
-        if self.D is None:
-            D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
-            SAVE_DFT = True
-            Sorted_Freqs, Phi_F, SIGMA_F = dft_fit(self.N_T, F_S, D, self.FOLDER_OUT, SAVE_DFT=SAVE_DFT)
-
+        mode = mode.lower()
+        if mode == 'sieber':
+            N_O = kwargs.pop('N_O', 100)
+            f_c = kwargs.pop('f_c', 0.3)
+            
+            return self.compute_SPOD_s(
+                N_O=N_O,
+                f_c=f_c,
+                n_Modes=n_Modes,
+                SAVE_SPOD=SAVE_SPOD
+            )
+
+        elif mode == 'towne':
+            L_B = kwargs.pop('L_B', 500)
+            O_B = kwargs.pop('O_B', 250)
+            n_processes = kwargs.pop('n_processes', 1)
+
+            # Load or reuse data matrix
+            
+            if self.D is None:
+                D = np.load(f"{self.FOLDER_OUT}/MODULO_tmp/data_matrix/database.npz")['D']
+            else:
+                D = self.D
+
+            # Segment and FFT - fallback n_processes in case of misassignment
+            D_hat, freqs_pos, n_processes = segment_and_fft(
+                D=D,
+                F_S=F_S,
+                L_B=L_B,
+                O_B=O_B,
+                n_processes=n_processes
+                )
+
+            return self.compute_SPOD_t(D_hat=D_hat, 
+                                       freq_pos=freqs_pos,
+                                        n_Modes=n_Modes, 
+                                        SAVE_SPOD=SAVE_SPOD, 
+                                        svd_solver=self.svd_solver,
+                                        n_processes=n_processes)
+            
         else:
-            Sorted_Freqs, Phi_F, SIGMA_F = dft_fit(self.N_T, F_S, self.D, self.FOLDER_OUT, SAVE_DFT=SAVE_DFT)
+                raise ValueError("mode must be 'sieber' or 'towne'")
 
-        return Sorted_Freqs, Phi_F, SIGMA_F
 
-    def compute_SPOD_t(self, F_S, L_B=500, O_B=250, n_Modes=10, SAVE_SPOD=True):
+    def compute_SPOD_t(self, D_hat, freq_pos, n_Modes=10, SAVE_SPOD=True, svd_solver=None, 
+                       n_processes=1):
         """
-        This method computes the Spectral POD of your data. This is the one by Towne et al
-        (https://www.cambridge.org/core/journals/journal-of-fluid-mechanics/article/abs/spectral-proper-orthogonal-decomposition-and-its-relationship-to-dynamic-mode-decomposition-and-resolvent-analysis/EC2A6DF76490A0B9EB208CC2CA037717)
-
-        :param F_S: float,
-                Sampling Frequency [Hz]
-        :param L_B: float,
-                lenght of the chunks
-        :param O_B: float,
-                Overlapping between blocks in the chunk
-        :param n_Modes: float,
-               number of modes to be computed for each frequency
-        :param SAVE_SPOD: bool,
-                If True, MODULO will save the output in self.FOLDER OUT/MODULO_tmp
-        :return Psi_P_hat: np.array
-                Spectra of the SPOD Modes
-        :return Sigma_P: np.array
-                Amplitudes of the SPOD Modes.
-        :return Phi_P: np.array
-                SPOD Phis
-        :return freq: float
-                frequency bins for the Spectral POD
-
-
+        Compute the CSD-based Spectral POD (Towne et al.) from a precomputed FFT tensor.
+
+        Parameters
+        ----------
+        D_hat : ndarray, shape (n_s, n_freqs, n_blocks)
+                FFT of each block, only nonnegative frequencies retained.
+        freq_pos : ndarray, shape (n_freqs,)
+                Positive frequency values (Hz) corresponding to D_hat’s second axis.
+        n_Modes : int, optional
+                Number of SPOD modes per frequency bin. Default is 10.
+        SAVE_SPOD : bool, optional
+                If True, save outputs under `self.FOLDER_OUT/MODULO_tmp`. Default is True.
+        svd_solver : str or None, optional
+                Which SVD solver to use (passed to `switch_svds`), by default None.
+        n_processes : int, optional
+                Number of parallel workers for the POD step. Default is 1 (serial).
+
+        Returns
+        -------
+        Phi_SP : ndarray, shape (n_s, n_Modes, n_freqs)
+                Spatial SPOD modes at each positive frequency.
+        Sigma_SP : ndarray, shape (n_Modes, n_freqs)
+                Modal energies per frequency bin.
+        freq_pos : ndarray, shape (n_freqs,)
+                The positive frequency vector (Hz), returned unchanged.
         """
-        if self.D is None:
-            D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
-            Phi_SP, Sigma_SP, Freqs_Pos = compute_SPOD_t(D, F_S, L_B=L_B, O_B=O_B,
-                                                         n_Modes=n_Modes, SAVE_SPOD=SAVE_SPOD,
-                                                         FOLDER_OUT=self.FOLDER_OUT, possible_svds=self.svd_solver)
-        else:
-            Phi_SP, Sigma_SP, Freqs_Pos = compute_SPOD_t(self.D, F_S, L_B=L_B, O_B=O_B,
-                                                         n_Modes=n_Modes, SAVE_SPOD=SAVE_SPOD,
-                                                         FOLDER_OUT=self.FOLDER_OUT, possible_svds=self.svd_solver)
-
-        return Phi_SP, Sigma_SP, Freqs_Pos
-
-        # New Decomposition: SPOD f
-
-    def compute_SPOD_s(self, F_S, N_O=100, f_c=0.3, n_Modes=10, SAVE_SPOD=True):
+        # Perform the POD (parallel if requested)
+                # received D_hat_f, this is now just a POD on the transversal direction of the tensor,
+        # e.g. the frequency domain. 
+        n_freqs = len(freq_pos)
+        
+        # also here we can parallelize
+        Phi_SP, Sigma_SP = pod_from_dhat(D_hat=D_hat, n_modes=n_Modes, n_freqs=n_freqs, 
+                                         svd_solver=self.svd_solver, n_processes=n_processes)
+        
+        # Optionally save the results
+        if SAVE_SPOD:
+                folder_out = self.FOLDER_OUT + "MODULO_tmp/"
+                os.makedirs(folder_out, exist_ok=True)
+                np.savez(
+                folder_out + "spod_towne.npz",
+                Phi=Phi_SP,
+                Sigma=Sigma_SP,
+                freqs=freq_pos
+                )
+
+        return Phi_SP, Sigma_SP, freq_pos
+
+
+
+    def compute_SPOD_s(self, N_O=100, f_c=0.3, n_Modes=10, SAVE_SPOD=True):
         """
-        This method computes the Spectral POD of your data.
-        This is the one by Sieber
-        et al (https://www.cambridge.org/core/journals/journal-of-fluid-mechanics/article/abs/spectral-proper-orthogonal-decomposition/DCD8A6EDEFD56F5A9715DBAD38BD461A)
-
-        :param F_S: float,
-                Sampling Frequency [Hz]
-        :param N_o: float,
-                Semi-Order of the diagonal filter.
-                Note that the filter order will be 2 N_o +1 (to make sure it is odd)
-        :param f_c: float,
-                cut-off frequency of the diagonal filter
-        :param n_Modes: float,
-               number of modes to be computed
-        :param SAVE_SPOD: bool,
-                If True, MODULO will save the output in self.FOLDER OUT/MODULO_tmp
-        :return Psi_P: np.array
-                SPOD Psis
-        :return Sigma_P: np.array
-                SPOD Sigmas.
-        :return Phi_P: np.array
-                SPOD Phis
+        Compute the filtered‐covariance Spectral POD (Sieber _et al._) of your data.
+
+        This implementation follows Sieber et al. (2016), which applies a zero‐phase
+        diagonal filter to the time‐lag covariance and then performs a single POD
+        on the filtered covariance matrix.
+
+        Parameters
+        ----------
+        N_O : int, optional
+                Semi‐order of the diagonal FIR filter. The true filter length is
+                2*N_O+1, by default 100.
+        f_c : float, optional
+                Normalized cutoff frequency of the diagonal filter (0 < f_c < 0.5),
+                by default 0.3.
+        n_Modes : int, optional
+                Number of SPOD modes to compute, by default 10.
+        SAVE_SPOD : bool, optional
+                If True, save output under `self.FOLDER_OUT/MODULO_tmp`, by default True.
+
+        Returns
+        -------
+        Phi_sP : numpy.ndarray, shape (n_S, n_Modes)
+                Spatial SPOD modes.
+        Psi_sP : numpy.ndarray, shape (n_t, n_Modes)
+                Temporal SPOD modes (filtered).
+        Sigma_sP : numpy.ndarray, shape (n_Modes,)
+                Modal energies (eigenvalues of the filtered covariance).
         """
-
         if self.D is None:
-            D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
-
-            self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS, self.MEMORY_SAVING,
-                                       self.FOLDER_OUT, self.SAVE_K, D=D)
+                D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
+        else:
+                D = self.D 
+                
+        self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS, self.MEMORY_SAVING, 
+                                   self.FOLDER_OUT, self.SAVE_K, D=D)
+                
+        # additional step: diagonal spectral filter of K 
+        K_F = spectral_filter(self.K, N_o=N_O, f_c=f_c)
+        
+        # and then proceed with normal POD procedure
+        Psi_P, Sigma_P = Temporal_basis_POD(K_F, SAVE_SPOD, self.FOLDER_OUT, n_Modes)
+        
+        # but with a normalization aspect to handle the non-orthogonality of the SPOD modes
+        Phi_P = Spatial_basis_POD(D, N_T=self.K.shape[0], 
+                                        PSI_P=Psi_P, Sigma_P=Sigma_P,
+                                MEMORY_SAVING=self.MEMORY_SAVING, 
+                                FOLDER_OUT=self.FOLDER_OUT,
+                                N_PARTITIONS=self.N_PARTITIONS,rescale=True)
+                        
 
-            Phi_sP, Psi_sP, Sigma_sP = compute_SPOD_s(D, self.K, F_S, self.N_S, self.N_T, N_O, f_c,
-                                                      n_Modes, SAVE_SPOD, self.FOLDER_OUT, self.MEMORY_SAVING,
-                                                      self.N_PARTITIONS)
+        return Phi_P, Psi_P, Sigma_P
 
-        else:
-            self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS, self.MEMORY_SAVING,
-                                       self.FOLDER_OUT, self.SAVE_K, D=self.D)
-
-            Phi_sP, Psi_sP, Sigma_sP = compute_SPOD_s(self.D, self.K, F_S, self.N_S, self.N_T, N_O, f_c,
-                                                      n_Modes, SAVE_SPOD, self.FOLDER_OUT, self.MEMORY_SAVING,
-                                                      self.N_PARTITIONS)
-
-        # if self.D is None:
-        #     D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
-        #     SAVE_SPOD = True
-        #     # TODO : Lorenzo check this stuff
-        # else:
-        #     D = self.D
-        #
-        # n_s = self.N_S  # Repeat variable for debugging compatibility
-        # n_t = self.N_T
-        #
-        # print('Computing Correlation Matrix \n')
-        #
-        # # The first step is the same as the POD: we compute the correlation matrix
-        # K = CorrelationMatrix(self.N_T, self.N_PARTITIONS, self.MEMORY_SAVING,
-        #                       self.FOLDER_OUT, D=self.D)
-        #
-        # # 1. Initialize the extended
-        # 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
-        #
-        # # 2. We fill the edges ( a bit of repetition but ok.. )
-        #
-        # # Row-wise, Upper part
-        # for i in range(0, N_o):
-        #     K_e[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_e[i, i - n_t + 1:i + 1] = K[-1, :]
-        #
-        #     # Column-wise, left part
-        # for j in range(0, N_o):
-        #     K_e[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_e[j - n_t + 1:j + 1, j] = K[:, -1]
-        #
-        # # Now you create the diagonal kernel in 2D
-        # h_f = firwin(N_o, f_c)  # Kernel in 1D
-        # # This is also something that must be put in a separate file:
-        # # To cancel the phase lag we make this non-causal with a symmetric
-        # # shift, hence with zero padding as equal as possible on both sides
-        # n_padd_l = round((n_t - N_o) / 2);
-        # n_padd_r = n_t - N_o - n_padd_l
-        #
-        # h_f_pad = np.pad(h_f, (n_padd_l, n_padd_r))  # symmetrically padded kernel in 1D
-        # h_f_2 = np.diag(h_f_pad)
-        #
-        # # Finally the filtered K is just
-        # K_F = signal.fftconvolve(K_e, h_f_2, mode='same')[N_o:n_t + N_o, N_o:n_t + N_o]
-        # # plt.plot(np.diag(K),'b--'); plt.plot(np.diag(K_F_e),'r')
-        #
-        # # From now on it's just POD:
-        # Psi_P, Sigma_P = Temporal_basis_POD(K_F, SAVE_SPOD,
-        #                                     self.FOLDER_OUT, self.n_Modes)
-        #
-        # Phi_P = Spatial_basis_POD(self.D, N_T=self.N_T, PSI_P=Psi_P, Sigma_P=Sigma_P,
-        #                           MEMORY_SAVING=self.MEMORY_SAVING, FOLDER_OUT=self.FOLDER_OUT,
-        #                           N_PARTITIONS=self.N_PARTITIONS)
-
-        return Phi_sP, Psi_sP, Sigma_sP
-
-    def compute_kPOD(self, M_DIST=[1, 10], k_m=0.1, cent=True,
-                     n_Modes=10, alpha=1e-6, metric='rbf', K_out=False):
+    
+    def kPOD(self, M_DIST=[1, 10], 
+             k_m=0.1, cent=True,
+                n_Modes=10, 
+                alpha=1e-6, 
+                metric='rbf', 
+                K_out=False, SAVE_KPOD=False):
         """
-        This function implements the kernel PCA as described in the VKI course https://www.vki.ac.be/index.php/events-ls/events/eventdetail/552/-/online-on-site-hands-on-machine-learning-for-fluid-dynamics-2023
-
-        The computation of the kernel function is carried out as in https://arxiv.org/pdf/2208.07746.pdf.
-
-
-        :param M_DIST: array,
-                position of the two snapshots that will be considered to
-                estimate the minimal k. They should be the most different ones.
-        :param k_m: float,
-                minimum value for the kernelized correlation
-        :param alpha: float
-                regularization for K_zeta
-        :param cent: bool,
-                if True, the matrix K is centered. Else it is not
-        :param n_Modes: float,
-               number of modes to be computed
-        :param metric: string,
-               This identifies the metric for the kernel matrix. It is a wrapper to 'pairwise_kernels' from sklearn.metrics.pairwise
-               Note that different metrics would need different set of parameters. For the moment, only rbf was tested; use any other option at your peril !
-        :param K_out: bool,
-               If true, the matrix K is also exported as a fourth output.
-        :return Psi_xi: np.array
-               kPOD's Psis
-        :return Sigma_xi: np.array
-               kPOD's Sigmas.
-        :return Phi_xi: np.array
-               kPOD's Phis
-        :return K_zeta: np.array
-               Kernel Function from which the decomposition is computed.
-               (exported only if K_out=True)
-
+        Perform kernel PCA (kPOD) for snapshot data as in VKI Machine Learning for Fluid Dynamics course.
+
+        Parameters
+        ----------
+        M_DIST : array-like of shape (2,), optional
+                Indices of two snapshots used to estimate the minimal kernel value.
+                These should be the most “distant” snapshots in your dataset. Default is [1, 10].
+        k_m : float, optional
+                Minimum value for the kernelized correlation. Default is 0.1.
+        cent : bool, optional
+                If True, center the kernel matrix before decomposition. Default is True.
+        n_Modes : int, optional
+                Number of principal modes to compute. Default is 10.
+        alpha : float, optional
+                Regularization parameter for the modified kernel matrix \(K_{\zeta}\). Default is 1e-6.
+        metric : str, optional
+                Kernel function identifier (passed to `sklearn.metrics.pairwise.pairwise_kernels`).
+                Only 'rbf' has been tested; other metrics may require different parameters. Default is 'rbf'.
+        K_out : bool, optional
+                If True, also return the full kernel matrix \(K\). Default is False.
+        SAVE_KPOD : bool, optional
+                If True, save the computed kPOD results to disk. Default is False.
+
+        Returns
+        -------
+        Psi_xi : ndarray of shape (n_samples, n_Modes)
+                The kPOD principal component time coefficients.
+        Sigma_xi : ndarray of shape (n_Modes,)
+                The kPOD singular values (eigenvalues of the centered kernel).
+        Phi_xi : ndarray of shape (n_samples, n_Modes)
+                The mapped eigenvectors (principal modes) in feature space.
+        K_zeta : ndarray of shape (n_samples, n_samples)
+                The (regularized and centered) kernel matrix used for decomposition.
+                Only returned if `K_out` is True.
+
+        Notes
+        -----
+        - Follows the hands-on ML for Fluid Dynamics tutorial by VKI  
+        (https://www.vki.ac.be/index.php/events-ls/events/eventdetail/552).  
+        - Kernel computed as described in  
+        Horenko et al., *Machine learning for dynamics and model reduction*, arXiv:2208.07746.
 
         """
+        
         if self.D is None:
             D = np.load(self.FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
         else:
             D = self.D
 
         # Compute Eucledean distances
-        i, j = M_DIST;
-        n_s, n_t = np.shape(D)
+        i, j = M_DIST
+        
         M_ij = np.linalg.norm(D[:, i] - D[:, j]) ** 2
 
-        gamma = -np.log(k_m) / M_ij
-
-        K_zeta = pairwise_kernels(D.T, metric='rbf', gamma=gamma)
-        print('Kernel K ready')
-
-        # Compute the Kernel Matrix
-        n_t = np.shape(D)[1]
-        # 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
-            print('K_zeta centered')
-        # Diagonalize and Sort
-        lambdas, Psi_xi = linalg.eigh(K_zeta + alpha * np.eye(n_t), subset_by_index=[n_t - n_Modes, n_t - 1])
-        lambdas, Psi_xi = lambdas[::-1], Psi_xi[:, ::-1];
-        Sigma_xi = np.sqrt(lambdas);
-        print('K_zeta diagonalized')
-        # Encode
-        # Z_xi=np.diag(Sigma_xi)@Psi_xi.T
-        # We compute the spatial structures as projections of the data
-        # onto the Psi_xi!
-        R = Psi_xi.shape[1]
-        PHI_xi_SIGMA_xi = np.dot(D, (Psi_xi))
-        # Initialize the output
-        PHI_xi = np.zeros((n_s, R))
-        SIGMA_xi = np.zeros((R))
-
-        for i in tqdm(range(0, R)):
-            # Assign the norm as amplitude
-            SIGMA_xi[i] = np.linalg.norm(PHI_xi_SIGMA_xi[:, i])
-            # Normalize the columns of C to get spatial modes
-            PHI_xi[:, i] = PHI_xi_SIGMA_xi[:, i] / SIGMA_xi[i]
-
-        Indices = np.flipud(np.argsort(SIGMA_xi))  # find indices for sorting in decreasing order
-        Sorted_Sigmas = SIGMA_xi[Indices]  # Sort all the sigmas
-        Phi_xi = PHI_xi[:, Indices]  # Sorted Spatial Structures Matrix
-        Psi_xi = Psi_xi[:, Indices]  # Sorted Temporal Structures Matrix
-        Sigma_xi = Sorted_Sigmas  # Sorted Amplitude Matrix
-        print('Phi_xi computed')
+        K_r = kernelized_K(D=D, M_ij=M_ij, k_m=k_m, metric=metric, cent=cent, alpha=alpha)
+
+        Psi_xi, Sigma_xi = Temporal_basis_POD(K=K_r, n_Modes=n_Modes, eig_solver='eigh')
+
+        PHI_xi_SIGMA_xi = D @ Psi_xi
+        
+        Sigma_xi = np.linalg.norm(PHI_xi_SIGMA_xi, axis=0) # (R,)
+        Phi_xi   = PHI_xi_SIGMA_xi / Sigma_xi[None, :] # (n_s, R)
+        
+        sorted_idx = np.argsort(-Sigma_xi)
+
+        Phi_xi = Phi_xi[:, sorted_idx]  # Sorted Spatial Structures Matrix
+        Psi_xi = Psi_xi[:, sorted_idx]  # Sorted Temporal Structures Matrix
+        Sigma_xi = Sigma_xi[sorted_idx]
 
         if K_out:
-            return Phi_xi, Psi_xi, Sigma_xi, K_zeta
+            return Phi_xi, Psi_xi, Sigma_xi, K_r
         else:
-            return Phi_xi, Psi_xi, Sigma_xi
+            return Phi_xi, Psi_xi, Sigma_xi, None
+    
+    
+#     def kDMD(self, 
+#              F_S=1.0, 
+#              M_DIST=[1, 10], 
+#              k_m=0.1, cent=True, 
+#              n_Modes=10, 
+#              n_modes_latent=None,
+#              alpha=1e-6, 
+#              metric='rbf', K_out=False):
+#         """
+#         Perform kernel DMD (kDMD) for snapshot data as in VKI’s ML for Fluid Dynamics course.
+
+#         Parameters
+#         ----------
+#         M_DIST : array-like of shape (2,), optional
+#                 Indices of two snapshots used to estimate the minimal kernel value.
+#                 These should be the most “distant” snapshots in your dataset. Default is [1, 10].
+#         F_S: float, sampling frequency.
+#         k_m : float, optional
+#                 Minimum value for the kernelized correlation. Default is 0.1.
+#         cent : bool, optional
+#                 If True, center the kernel matrix before decomposition. Default is True.
+#         n_Modes : int, optional
+#                 Number of principal modes to compute. Default is 10.
+#         alpha : float, optional
+#                 Regularization parameter for the modified kernel matrix \(K_{\zeta}\). Default is 1e-6.
+#         metric : str, optional
+#                 Kernel function identifier (passed to `sklearn.metrics.pairwise.pairwise_kernels`).
+#                 Only 'rbf' has been tested; other metrics may require different parameters. Default is 'rbf'.
+#         K_out : bool, optional
+#                 If True, also return the full kernel matrix \(K\). Default is False.
+#         SAVE_KPOD : bool, optional
+#                 If True, save the computed kPOD results to disk. Default is False.
+
+#         Returns
+#         -------
+#         Psi_xi : ndarray of shape (n_samples, n_Modes)
+#                 The kPOD principal component time coefficients.
+#         Sigma_xi : ndarray of shape (n_Modes,)
+#                 The kPOD singular values (eigenvalues of the centered kernel).
+#         Phi_xi : ndarray of shape (n_samples, n_Modes)
+#                 The mapped eigenvectors (principal modes) in feature space.
+#         K_zeta : ndarray of shape (n_samples, n_samples)
+#                 The (regularized and centered) kernel matrix used for decomposition.
+#                 Only returned if `K_out` is True.
+
+#         Notes
+#         -----
+#         - Follows the hands-on ML for Fluid Dynamics tutorial by VKI  
+#         (https://www.vki.ac.be/index.php/events-ls/events/eventdetail/552).  
+#         - Kernel computed as described in  
+#         Horenko et al., *Machine learning for dynamics and model reduction*, arXiv:2208.07746.
+#         """
+#         # we need the snapshot matrix in memory for this decomposition 
+        
+#         if self.MEMORY_SAVING:
+#                 if self.N_T % self.N_PARTITIONS != 0:
+#                         tot_blocks_col = self.N_PARTITIONS + 1
+#                 else:
+#                         tot_blocks_col = self.N_PARTITIONS
+
+#                 # Prepare the D matrix again
+#                 D = np.zeros((self.N_S, self.N_T))
+#                 R1 = 0
+
+#                 # print(' \n Reloading D from tmp...')
+#                 for k in tqdm(range(tot_blocks_col)):
+#                         di = np.load(self.FOLDER_OUT + f"/data_partitions/di_{k + 1}.npz")['di']
+#                         R2 = R1 + np.shape(di)[1]
+#                         D[:, R1:R2] = di
+#                         R1 = R2
+#         else:
+#                 D = self.D 
+        
+#         n_s, n_t = D.shape 
+#         # as done with the classic dmd, we assume X = D_1 = D(0:n_t - 1) and 
+#         # Y = D_2 = D(1:n_t)
+        
+#         X = D[:, :-1]
+#         Y = D[:, 1:]
+        
+#         # we seek A = argmin_A ||Y - AX|| = YX^+ = Y(Psi_r Sigma_r^+ Phi^*)
+#         n_modes_latent = n_Modes if n_modes_latent is None else n_modes_latent
+        
+#         # leverage MODULO kPOD routine to compress the system instead of standard POD 
+#         # we are now in the kernel (feature) space, thus:
+#         i, j = M_DIST
+        
+#         # gamma needs to be the same for the feature spaces otherwise 
+#         # leads to inconsistent galerkin proj.! 
+         
+#         M_ij = np.linalg.norm(X[:, i] - X[:, j]) ** 2
+
+#         gamma = - np.log(k_m) / M_ij
+
+#         K_XX = pairwise_kernels(X.T, X.T, metric=metric, gamma=gamma)
+#         K_YX = pairwise_kernels(Y.T, X.T, metric=metric, gamma=gamma)
+
+#         # (optional) center feature‐space mean by centering K_XX only
+#         if cent:
+#                 n = K_XX.shape[0]
+#                 H = np.eye(n) - np.ones((n, n)) / n
+#                 K_XX = H @ K_XX @ H
+
+#         # add ridge to K_XX
+#         K_XX += alpha * np.eye(K_XX.shape[0])
+
+#         # kernel‐POD on the regularized, centered K_XX
+#         Psi_xi, sigma_xi = Temporal_basis_POD(K=K_XX, n_Modes=n_modes_latent, eig_solver='eigh')
+#         Sigma_inv = np.diag(1.0 / sigma_xi)
+
+#         # Galerkin projection using the **unmodified** K_YX
+#         A_r = Sigma_inv @ Psi_xi.T @ K_YX @ Psi_xi @ Sigma_inv
+        
+#         # eigendecomposition of A gives DMD modes
+#         dt = 1/F_S
+#         Lambda, Phi_Ar = LA.eig(A_r) 
+#         freqs = np.imag(np.log(Lambda)) / (2 * np.pi * dt)
+        
+#         # we can trace back the eigenvalues of the not-truncated A (Tu et al.)
+#         Phi_D = Y @ Psi_xi @ Sigma_inv @ Phi_Ar
+#         a0s = LA.pinv(Phi_D).dot(X[:, 0])
+        
+#         return Phi_D, Lambda, freqs, a0s, None
+        
+                
+
+                
+    
+
+
+