modulo-vki 2.0.5__py3-none-any.whl

modulo_vki/core/_pod_space.py

@@ -0,0 +1,184 @@
+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):
+    """
+    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)
+            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_col) and (N_S - dim_row * N_PARTITIONS > 0):
+                    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[jj]
+                    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

modulo_vki/core/_pod_time.py

@@ -0,0 +1,48 @@
+import os
+import numpy as np
+from ..utils._utils import switch_eigs
+
+
+def Temporal_basis_POD(K, SAVE_T_POD=False, FOLDER_OUT='./', n_Modes=10,eig_solver: str = 'eigh'):
+    """
+    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
+    """
+    # Solver 1: Use the standard SVD
+    # Psi_P, Lambda_P, _ = np.linalg.svd(K)
+    # Sigma_P = np.sqrt(Lambda_P)
+
+    # Solver 2: Use randomized SVD ############## WARNING #################
+    # if svd_solver.lower() == 'svd_sklearn_truncated':
+    #     svd = TruncatedSVD(n_Modes)
+    #     svd.fit_transform(K)
+    #     Psi_P = svd.components_.T
+    #     Lambda_P = svd.singular_values_
+    #     Sigma_P = np.sqrt(Lambda_P)
+    # elif svd_solver.lower() == 'svd_numpy':
+    #     Psi_P, Lambda_P, _ = np.linalg.svd(K)
+    #     Sigma_P = np.sqrt(Lambda_P)
+    # elif svd_solver.lower() == 'svd_sklearn_randomized':
+    #     Psi_P, Lambda_P, _ = svds_RND(K, n_Modes)
+    #     Sigma_P = np.sqrt(Lambda_P)
+    # elif svd_solver.lower() == 'svd_scipy_sparse':
+    #     Psi_P, Lambda_P, _ = svds(K, k=n_Modes)
+    #     Sigma_P = np.sqrt(Lambda_P)
+
+    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

modulo_vki/core/_spod_s.py

@@ -0,0 +1,102 @@
+import numpy as np
+from scipy import signal
+from scipy.signal import firwin
+from ._pod_time import Temporal_basis_POD
+from ._pod_space import Spatial_basis_POD
+
+def compute_SPOD_s(D, K, F_S, n_s, n_t,N_o=100, f_c=0.3,n_Modes=10, SAVE_SPOD=True,
+                   FOLDER_OUT='./', MEMORY_SAVING=False, N_PARTITIONS=1):
+    """
+    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
+    :param FOLDER_OUT: string
+           Define where the out will be stored (ignored if SAVE_POD=False)
+    :param MEMORY SAVING: bool
+           Define if memory saving is active or not (reduntant; to be improved)
+           Currently left for compatibility with the rest of MODULO.
+    :param N_PARTITIONS: int
+           number of partitions (if memory saving = False, it should be 1). 
+           (reduntant; to be improved)
+           Currently left for compatibility with the rest of MODULO.           
+    :return Psi_P: np.array
+           SPOD Psis
+    :return Sigma_P: np.array
+           SPOD Sigmas.
+    :return Phi_P: np.array
+            SPOD Phis
+    """
+    # 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, FOLDER_OUT, n_Modes)
+    # but with a normalization aspect to be careful about!  
+    Phi_P = Spatial_basis_POD(D, N_T=n_t, PSI_P=Psi_P, Sigma_P=Sigma_P,
+                              MEMORY_SAVING=MEMORY_SAVING, FOLDER_OUT=FOLDER_OUT,
+                              N_PARTITIONS=N_PARTITIONS,rescale=True)
+
+    return Phi_P, Psi_P, Sigma_P

modulo_vki/core/_spod_t.py

@@ -0,0 +1,104 @@
+import numpy as np
+from modulo_vki.utils._utils import overlap
+from tqdm import tqdm
+import os
+
+from modulo_vki.utils._utils import switch_svds
+
+
+
+def compute_SPOD_t(D, F_S, L_B=500, O_B=250,n_Modes=10, SAVE_SPOD=True, FOLDER_OUT='/',
+                   possible_svds='svd_sklearn_truncated'):
+    """
+    This method computes the Spectral POD of your data.
+    This is the one by Town 
+    et al (https://www.cambridge.org/core/journals/journal-of-fluid-mechanics/article/spectral-proper-orthogonal-decomposition-and-its-relationship-to-dynamic-mode-decomposition-and-resolvent-analysis/EC2A6DF76490A0B9EB208CC2CA037717)
+    
+    :param D: array.
+      snapshot matrix to decompose, of size N_S,N_T 
+    :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 FOLDER OUT/MODULO_tmp
+    :param possible_svds: str,      
+      Svd solver to be used throughout the computation
+           
+    :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
+    """
+        
+    # if D is None:
+    #     D = np.load(FOLDER_OUT + '/MODULO_tmp/data_matrix/database.npz')['D']
+    #     SAVE_SPOD = True
+    # else:
+    #     D = D
+    #
+    # n_s = N_S  # Repeat variable for debugging compatibility
+    # n_t = N_T
+    #
+    # # First comput the PS in each point (this is very time consuming and should be parallelized)
+    # # Note: this can be improved a lot...! ok for the moment
+    print('Computing PSD at all points\n')
+    N_S,N_T=np.shape(D)
+
+    # Step 1 : Partition the data into blocks ( potentially overlapping)
+    Ind = np.arange(N_T)
+    Indices = overlap(Ind, len_chunk=L_B, len_sep=O_B)
+
+    N_B = np.shape(Indices)[1]
+    N_P = np.shape(Indices)[0]
+    print('Partitioned into blocks of length n_B=' + str(N_B))
+    print('Number of partitions retained is n_P=' + str(N_P))
+
+    # The frequency bins are thus defined:
+    Freqs = np.fft.fftfreq(N_B) * F_S  # Compute the frequency bins
+    Keep_IND = np.where(Freqs >= 0)
+    N_B2 = len(Keep_IND[0])  # indexes for positive frequencies
+    Freqs_Pos = Freqs[Keep_IND]  # positive frequencies
+
+    # Step 2 : Construct the D_hats in each partition
+    D_P_hat_Tens = np.zeros((N_S, N_B, N_P))
+    print('Computing DFTs in each partition')
+    for k in tqdm(range(0, N_P)):  # Loop over the partitions
+        D_p = D[:, Indices[k]]  # Take the portion of data
+        D_P_hat_Tens[:, :, k] = np.fft.fft(D_p, N_B, 1)
+
+    # This would be the mean over the frequencies
+    # D_hat_Mean=np.mean(D_P_hat_Tens,axis=1)
+
+    # Initialize the outputs
+    Sigma_SP = np.zeros((n_Modes, N_B2))
+    Phi_SP = np.zeros((N_S, n_Modes, N_B2))
+
+    # Step 3: Loop over frequencies to build the modes.
+    # Note: you only care about half of these frequencies.
+    # This is why you loop over N_B2, not N_B
+    print('Computing POD for each frequency')
+    for j in tqdm(range(0, N_B2)):
+        # Get D_hat of the chunk
+        D_hat_f = D_P_hat_Tens[:, j, :]
+        # Go for the SVD
+ 
+        U,V,Sigma=switch_svds(D_hat_f,n_Modes,svd_solver=possible_svds)
+
+        Phi_SP[:, :, j] = U
+        Sigma_SP[:, j] = Sigma / (N_S * N_B)
+
+    if SAVE_SPOD:
+        folder_dir = FOLDER_OUT + '/SPOD_T'
+        os.makedirs(folder_dir, exist_ok=True)
+        np.savez(folder_dir + '/spod_t.npz', Phi=Phi_SP, Sigma=Sigma_SP, Freqs=Freqs_Pos)
+
+    return Phi_SP, Sigma_SP, Freqs_Pos