[fix]: messing up between interpolated ACM and correlated samples.

[add]: function of generate_samples_from_acm, generate_interpolated_acm, generate_samples_from_acm, plot_interpolated_correlation
[del]: generate_wide_band_response, plot_correlated_samplesplot_interpolated

pafsim/signal_generator/signal_generator.py

@@ -54,14 +54,13 @@ def create_interpolater(iv, matrix, k=3):
     interpolater = interpolate.make_interp_spline(iv, matrix, k=k)
     return interpolater
 
-def generate_wide_band_response(dataset, length, signals, noises, rfis,
+def generate_interpolated_acm(dataset, signals, noises, rfis,
         frequencies, fft_frequencies):
     '''
-    Generate a wide band response
+    Interpolate the acm through frequencies.
 
     arguments:
         dataset: dataset contains matrixes of array correlation matrix
-        length: shape of the desired samples
         signals: array correlation matrix for signals
         noises: array correlation matrix for noises
         rfis: array correlation matrix for RFIs
@@ -69,7 +68,7 @@ def generate_wide_band_response(dataset, length, signals, noises, rfis,
         fft_frequencies: frequencies to be interpolated on
 
     returns:
-        wide band response
+        inteperolated acm
     '''
     signal_list = []
     noise_list = []
@@ -86,55 +85,58 @@ def generate_wide_band_response(dataset, length, signals, noises, rfis,
     element_num = signal_acm.shape[-1]
     # signal_acm = generate_complex_samples([length, element_num, element_num])
 
-    interpolater =  create_interpolater(frequencies, signal_acm)
+    acm_interpolater =  create_interpolater(frequencies, signal_acm)
     # interpolated = interpolater(fft_frequencies, extrapolate=False)
-    interpolated = interpolater(fft_frequencies)
+    interpolated_acm = acm_interpolater(fft_frequencies)
 
-    return interpolated
+    return interpolated_acm
 
-def plot_correlated_samples(interpolated, fft_frequencies, element_num, length):
+def generate_samples_from_acm(acm, length):
     '''
-    Plot correlated samples
+    Generate samples from given acm and length
 
     arguments:
-        interpolated: interpolated samples
-        fft_frequencies: interpolated frequencies
-        element_num: number of elements
-        length: length of the samples
+        acm: array correlation matrix
+        length: shape of the desired samples
 
     returns:
-        none
+        correlated samples
     '''
     random_complex = generate_complex_samples([length,])
     # np.pad(random_complex, 500, 'constant', constant_values=0)
     fourier_samples = np.fft.fft(random_complex)
     # fourier_samples  = np.ones(length*2).astype('float64').view(np.complex128)
-    fourier_samples_matrix = np.tile(fourier_samples, [element_num, 1])
+    element_num = acm.shape[-1]
 
+    fourier_samples_matrix = np.tile(fourier_samples, [element_num, 1])
 
+    #loop over the frequency bins
     for i in range(length):
-        eigenvalues, eigenvectors = get_eigen(interpolated[i])
+        eigenvalues, eigenvectors = get_eigen(acm[i])
         fourier_samples_matrix[:, i] = (eigenvectors @ np.sqrt(np.diag(eigenvalues))
                 @ fourier_samples_matrix[:, i, np.newaxis]).flatten()
 
-    correlated = np.empty([element_num, element_num, length], dtype=np.complex128)
-    for row, elem1 in enumerate(fourier_samples_matrix):
-        for col, elem2 in enumerate(fourier_samples_matrix):
-            correlated[row, col] = elem1 * np.conjugate(elem2)
+    time_series = np.fft.ifft(fourier_samples_matrix)
 
-    '''
-    dpi = 1080
-    fig = plt.figure(figsize=(4096/dpi, 4096/dpi), dpi=dpi)
+    return time_series
 
-    ax = fig.add_subplot()
-    ax.scatter(fft_frequencies, np.angle(interpolated[:, 7, 11]),
-            c='blue', alpha=0.5, marker='+')
-    ax.scatter(fft_frequencies, np.angle(correlated[7, 11, :]),
-            c='yellow', alpha=0.5)
 
-    plt.savefig("single_element.png")
+def plot_interpolated_correlation(correlated_samples, interpolated_acm,
+        fft_frequencies, element_num, length):
+    '''
+    Plot correlated samples
+
+    arguments:
+        correlated_samples: correlated samples
+        interpolated_acm: interpolated array correlation matrix
+        fft_frequencies: interpolated frequencies
+        element_num: number of elements
+        length: length of the samples
 
+    returns:
+        none
     '''
+
     # fig = plt.figure()
     matplotlib.rcParams['axes.linewidth'] = 0.2
     dpi = 1080
@@ -142,13 +144,14 @@ def plot_correlated_samples(interpolated, fft_frequencies, element_num, length):
     gs = fig.add_gridspec(element_num, element_num, hspace=0, wspace=0)
     ax = gs.subplots(sharex='col', sharey='row')
 
+    fourier_samples_matrix = np.fft.fft(correlated_samples)
     correlated = np.empty([element_num, element_num, length], dtype=np.complex128)
     for row, elem1 in enumerate(fourier_samples_matrix):
         for col, elem2 in enumerate(fourier_samples_matrix):
             correlated[row, col] = elem1 * np.conjugate(elem2)
 
             ax[row, col].scatter(fft_frequencies/1e9,
-                    np.angle(interpolated[:, row, col]),
+                    np.angle(interpolated_acm[:, row, col]),
                     c='blue', alpha=0.7, marker=',', s=0.01)
             ax[row, col].scatter(fft_frequencies/1e9,
                     np.angle(correlated[row, col, :]),
@@ -187,11 +190,14 @@ def main():
     center_freq = frequencies[0] + (frequencies[-1] - frequencies[0]) / 2
     fine_frequencies = np.fft.fftfreq(output_length, d = 1/(1e9)) + center_freq
 
-    interpolated_samples = generate_wide_band_response(acm_matrix, output_length,
-            [signal_path,] , None, None,frequencies, fine_frequencies)
-    plot_correlated_samples(interpolated_samples, fine_frequencies,
-            acm_signal.shape[-1], output_length)
+    interpolated_acm = generate_interpolated_acm(acm_matrix,
+            [signal_path,] , None, None, frequencies, fine_frequencies)
     acm_matrix.close()
 
+    correlated_samples = generate_samples_from_acm(interpolated_acm, output_length)
+    plot_interpolated_correlation(correlated_samples, interpolated_acm,
+            fine_frequencies, acm_signal.shape[-1], output_length)
+
+
 if __name__ == "__main__":
     main()