modulo-vki 2.1.4__py3-none-any.whl → 2.1.5__py3-none-any.whl

modulo_vki/core/spatial_structures.py

@@ -51,9 +51,8 @@ def Spatial_basis_POD(D, PSI_P, Sigma_P, MEMORY_SAVING,
             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]
+            Sigma_P[:] = np.linalg.norm(PHI_P_SIGMA_P, axis=0)
+            Phi_P = PHI_P_SIGMA_P / Sigma_P
 
         else:
             # We take only the first R modes.
@@ -156,7 +155,7 @@ def Spatial_basis_POD(D, PSI_P, Sigma_P, MEMORY_SAVING,
                     R1 = (i - 1) * dim_col
                     R2 = i * dim_col
 
-                if (b == tot_blocks_row) and (N_S - dim_row * N_PARTITIONS > 0): # Change here
+                if (b == tot_blocks_row) and (N_S - dim_row * N_PARTITIONS > 0):
                     C1 = C2
                     C2 = C1 + (N_S - dim_row * N_PARTITIONS)
                 else:
@@ -169,13 +168,13 @@ def Spatial_basis_POD(D, PSI_P, Sigma_P, MEMORY_SAVING,
             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]
+                    Sigma_P[j] = np.linalg.norm(dps[:, jj])
+                    Phi_P = dps[:, jj] / Sigma_P[j]
                     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
+                    Phi_P = dps[:, jj] / Sigma_P[j] 
                     np.savez(FOLDER_OUT + f"/phi_{j + 1}", phi_p=Phi_P)
 
         Phi_P_M = np.zeros((N_S, R))

modulo_vki/modulo.py

@@ -660,14 +660,13 @@ class ModuloVKI:
         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']
-        else:
-                D = self.D 
-                
+
         self.K = CorrelationMatrix(self.N_T, self.N_PARTITIONS, self.MEMORY_SAVING, 
-                                   self.FOLDER_OUT, self.SAVE_K, D=D)
-                
+                                   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']
+        
         # additional step: diagonal spectral filter of K 
         K_F = spectral_filter(self.K, N_o=N_O, f_c=f_c)
         
@@ -675,7 +674,7 @@ class ModuloVKI:
         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], 
+        Phi_P = Spatial_basis_POD(self.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,

{modulo_vki-2.1.4.dist-info → modulo_vki-2.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modulo_vki
-Version: 2.1.4
+Version: 2.1.5
 Summary: MODULO (MODal mULtiscale pOd) is a software developed at the von Karman Institute to perform Multiscale Modal Analysis of numerical and experimental data.
 Home-page: https://github.com/mendezVKI/MODULO/tree/master/modulo_python_package/
 Author: ['R. Poletti', 'L. Schena', 'D. Ninni', 'M. A. Mendez']
@@ -48,7 +48,8 @@ While the discontinued MATLAB version of MODULO is accessible in the “Old_Matl
 it is no longer maintained. The latest decomposition techniques are exclusively available in the current Python version (`Poletti et al. (2024) <https://joss.theoj.org/papers/10.21105/joss.06753>`_).
 
 As a part of the MODULO project, we provide a series of lectures on data-driven modal decomposition, and its applications.
-These are available at the `MODULO YouTube channel <https://www.youtube.com/@modulompod5682>`_.
+These are available at the `MODULO YouTube channel <https://www.youtube.com/@modulompod5682>`_. 
+The full package documentation can be found at: `MODULO ReadTheDocs <https://lorenzoschena.github.io/MODULO/intro.html>`_.
 
 .. contents:: Table of contents
 

{modulo_vki-2.1.4.dist-info → modulo_vki-2.1.5.dist-info}/RECORD

@@ -1,5 +1,5 @@
 modulo_vki/__init__.py,sha256=AOjmeFjHj69m45iZzfTHM6-SLUelgKdGeu3VdSg9hIo,39
-modulo_vki/modulo.py,sha256=bpevQHd6fGwd1fIn3VSEHKgBxc9oa1Q8Fpr_qzVeqA0,38517
+modulo_vki/modulo.py,sha256=XbPyzd5sugYHtgKsPZ220BoWT0L3iqi-JDYXlcFTu0g,38478
 modulo_vki/modulo_old.py,sha256=3r_BBYQfbmZWGDyPukyJTVYVVcAVuEE0CmREEJkzsxU,59413
 modulo_vki/core/__init__.py,sha256=y9mIqtmSg3o8TXMqFxoiMCoMSle6mK0LBrvNJCVM1Zg,226
 modulo_vki/core/_dft.py,sha256=W98vC4HR1fivZjYRQXrFKV7RBa-O3RSRwq-nCKoxqjQ,4374
@@ -11,7 +11,7 @@ modulo_vki/core/_pod_space.py,sha256=A3dfv4Nzs9fx3qwOdlJR5HwyyfI-QcVer8P83xqa_C4
 modulo_vki/core/_pod_time.py,sha256=JtiFGYFV-tBKTWHWHW8zynMoLt2q8bD1bd1LP9pyvjo,2169
 modulo_vki/core/_spod_s.py,sha256=rxXSsNdSTLv3sjvlUErw3xjHk0eF8H7IkSJr5nMQ8Vo,4149
 modulo_vki/core/_spod_t.py,sha256=csftCPRSqs-OghQa8l0mRDL7cy5eXXSCnW8O4pnXTCY,3866
-modulo_vki/core/spatial_structures.py,sha256=65xh3zD3ekjRYUeRd2KcOYzPurpua7qDf0AysY-X8hE,14712
+modulo_vki/core/spatial_structures.py,sha256=XRdhcZM0TdUW0PRaRKU8BU3u74H36WGEIx1YHLjrPs4,14620
 modulo_vki/core/temporal_structures.py,sha256=0DQEdE9ssTnnfIC86VZPsNlym6fsjRAboPHHnv-9CI4,10645
 modulo_vki/core/utils.py,sha256=Ac9Im9knlbZRByP6Qgv-LCDt5zEC8PbyidqXzVdeYtQ,17889
 modulo_vki/utils/__init__.py,sha256=F5yy5R19dONK9oaBEpKzylorVJNcjT2kiJ5Og-ZX1ek,94
@@ -19,11 +19,8 @@ modulo_vki/utils/_plots.py,sha256=m43t08cVq-TY0BW0YPqT71hN-54hBphIYKZEn8Kw16E,14
 modulo_vki/utils/_utils.py,sha256=WFD7nwjSzVHpevVwTEvMdjAmcbeqwoXT9M48tIIniJw,14355
 modulo_vki/utils/others.py,sha256=9yZzD0_rZIOWYjV2Hbi74N5oXEYct7o5h9ZjNkmxHPw,17338
 modulo_vki/utils/read_db.py,sha256=lJFauxJxS0_mYoxrbn-43UqZjOkr-qb9f6RTUq4IxZU,15149
-modulo_vki-2.1.4.dist-info/licenses/LICENSE,sha256=5TivriXFErrYrJgBq3M72kHNHqtSiCft3xESM1zHc0k,1091
-modulo_vki_2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modulo_vki_2/modulo.py,sha256=JhQFHsoyQ3Bp0FZ80M0WOq9hYMVkMV1lMoEnxwf2Vng,7861
-modulo_vki_2/utils.py,sha256=9Zwikg7x7MtvIK1Om1JKKnCH1OQd0nf3m76APjOIyas,858
-modulo_vki-2.1.4.dist-info/METADATA,sha256=5S4EkRJbdLMriyOTNqb3jjcxPj8SEaglfHGbmXWYNn8,16733
-modulo_vki-2.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-modulo_vki-2.1.4.dist-info/top_level.txt,sha256=xP1gbt8FGvhIM5-zQagZXO7ut-yjUI4cXuM2GeypNuw,24
-modulo_vki-2.1.4.dist-info/RECORD,,
+modulo_vki-2.1.5.dist-info/licenses/LICENSE,sha256=5TivriXFErrYrJgBq3M72kHNHqtSiCft3xESM1zHc0k,1091
+modulo_vki-2.1.5.dist-info/METADATA,sha256=J0fY2NItK7F6s1XfraHXgbRKjjxa5EIMstXUUoFs7ns,16857
+modulo_vki-2.1.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+modulo_vki-2.1.5.dist-info/top_level.txt,sha256=4PA4AmafKU6M7us7gvt_Q976Khx3qjNUEThRRM5zxeA,11
+modulo_vki-2.1.5.dist-info/RECORD,,

{modulo_vki-2.1.4.dist-info → modulo_vki-2.1.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

modulo_vki-2.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+modulo_vki

modulo_vki-2.1.4.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-modulo_vki
-modulo_vki_2

modulo_vki_2/modulo.py

@@ -1,187 +0,0 @@
-import numpy as np 
-import os 
-
-
-
-class ModuloVKI:
-    """
-    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.ndarray,
-                 N_PARTITIONS: int = 1,
-                 FOLDER_OUT: str = './',
-                 SAVE_K: bool = False,
-                 N_T: int = 100,
-                 N_S: int = 200,
-                 n_Modes: int = 10,
-                 dtype: str = 'float32',
-                 eig_solver: str = 'eigh',
-                 svd_solver: str = 'svd_sklearn_truncated',
-                 weights: np.ndarray = np.array([])):
-        """
-        Initialize the MODULO analysis.
-
-        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.
-
-        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.
-
-        FOLDER_OUT : str, default='./'
-            Directory path to store output (Phi, Sigma, Psi matrices) and intermediate
-            calculation files (e.g., partitions, correlation matrix).
-
-        SAVE_K : bool, default=False
-            Whether to store the correlation matrix K to disk in
-            `FOLDER_OUT/correlation_matrix`.
-
-        N_T : int, default=100
-            Number of temporal snapshots. Mandatory when using partitions (N_PARTITIONS > 1).
-
-        N_S : int, default=200
-            Number of spatial grid points. Mandatory when using partitions (N_PARTITIONS > 1).
-
-        n_Modes : int, default=10
-            Number of modes to compute.
-
-        dtype : str, default='float32'
-            Data type for casting input data.
-
-        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 "
-              "data driven modal decomposition of numerical and experimental data. \n")
-
-        if not isinstance(data, np.ndarray) and N_PARTITIONS == 1:
-            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
-            self.N_T = data.shape[1]
-            self.N_S = data.shape[0]
-            # Check the data type
-            self.D = data.astype(dtype)
-        else:
-            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
-        
-        '''If the grid is not cartesian, ensure inner product is properly defined using weights.'''
-        
-        if weights.size == 0:
-                print('Modulo assumes you have a uniform grid. If not, please provide weights as parameters.')
-        else: 
-                if len(weights) == self.N_S:
-                        print("The weights you have input have the size of the columns of D \n"
-                                  "MODULO has considered that you have already duplicated the dimensions of the weights "
-                                  "to match the dimensions of the D columns \n")
-                        self.weights = weights
-                elif len(weights) == 2 * self.N_S:
-                        print("Assuming 2D domain. Automatically duplicating the weights to match the dimension of the D columns \n")
-                        self.weights = np.concatenate((weights, weights))
-                else:
-                        raise AttributeError("Make sure the size of the weight array is twice smaller than the size of D")
-                
-                if isinstance(data, np.ndarray):
-                        # Apply the weights only if D exist.
-                        # If not (i.e. N_partitions >1), weights are applied in _k_matrix.py when loading partitions of D
-                        self.Dstar = np.transpose(np.transpose(self.D) * np.sqrt(self.weights))
-                else:
-                        self.Dstar = None
-                        
-    def compute(
-        self,
-        kind: str,
-        **engine_kwargs
-        ) -> tuple:
-        """
-        Unified entry point for all decompositions: POD, SPOD, kPOD, DMD, DFT.
-        Any engine‐specific parameters (e.g. F_S, L_B, gamma…) can be passed here
-        and will be forwarded to the chosen engine’s constructor.
-        """
-        engine_cls = self._engines.get(kind.lower())
-        if engine_cls is None:
-            raise ValueError(f"Unknown decomposition '{kind}'")
-
-        # pick the right data array
-        D_use = self.Dstar  # or self.D if you want un-weighted
-
-        engine = engine_cls(
-            D=D_use,
-            folder_out=self.FOLDER_OUT,
-            save_k=self.SAVE_K,
-            memory_saving=self.MEMORY_SAVING,
-            n_partitions=self.N_PARTITIONS,
-            **engine_kwargs
-        )
-        return engine.run()
-                        

modulo_vki_2/utils.py

@@ -1,22 +0,0 @@
-import numpy as np
-
-def apply_weights(D: np.ndarray, weights: np.ndarray) -> np.ndarray:
-    """
-    If `weights` is empty, return D unchanged.
-    If `weights` has length n_s, assume 1D grid and tile automatically.
-    If `weights` has length 2*n_s, assume 2D grid and use directly.
-    Returns D_star = D * sqrt(w) applied column-wise.
-    """
-    n_s, n_t = D.shape
-    if weights.size == 0:
-        return D
-    w = np.asarray(weights, dtype=D.dtype)
-    if w.size == n_s:
-        # 1D grid: automatically broadcast each weight to full time series
-        w_full = np.repeat(w, n_t//n_s)  # or tile as needed for time dims
-    elif w.size == 2*n_s:
-        w_full = w
-    else:
-        raise ValueError(f"weights must be length {n_s} or {2*n_s}, got {w.size}")
-    # apply weights: scale each row i by sqrt(w_full[i])
-    return (D.T * np.sqrt(w_full)).T