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

modulo_vki/core/_spod_s.py

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

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