def two_antennas_time_max_dif(exp_num, file_nums, pts): print(f'Experiment {exp_num}') test = ProcessSignal(str(exp_num)) nums_mtrx = np.reshape(np.asarray(file_nums), (int(len(file_nums) / 2), 2)) print(nums_mtrx) central_freq = 2.714E9 compare_pts = [pts[i] * 1E-9 for i in range(len(pts))] for pt in compare_pts: for j in range(nums_mtrx.shape[0]): for i in range(nums_mtrx.shape[1]): print(nums_mtrx[j, i], 'pt=', np.round(pt / 1e-9, 1)) file_num = f'{nums_mtrx[j, i]}' file_name = f'str{file_num}.csv' data = test.open_file(file_name, reduced=False) filt_freq_min, filt_freq_max = central_freq - 15e6, central_freq + 15e6 if int(nums_mtrx[j, i]) % 2 == 0: t, u = data['time'], data['voltage'] - np.mean( data['voltage']) #plt.plot(t, u) #plt.show() #plt.close() #pl_density = test.read_excel(file_name)['dicts'][file_num]['Ток плазмы, А'] ind_mask = np.logical_and(t >= pt, t <= pt + 1E-9) t, u = t[ind_mask], u[ind_mask] peak_dict = find_zeros(t, u) time_max, volt_max, time_min, volt_min = peak_dict[ 'time_max'], peak_dict['volt_max'], peak_dict[ 'time_min'], peak_dict['volt_min'] time_max_ch_1 = time_max print('volt_max =', volt_max, 'time_max', np.round(time_max / 1e-9, 3)) plt.plot(t, u) plt.plot(time_max, volt_max, marker='o') else: t, u = data['time'], (data['voltage'] - np.mean(data['voltage'])) #plt.plot(t, u) #plt.show() #plt.close() ind_mask = np.logical_and(t >= pt, t <= pt + 1E-9) t, u = t[ind_mask], u[ind_mask] peak_dict = find_zeros(t, u) time_max, volt_max, time_min, volt_min = peak_dict[ 'time_max'], peak_dict['volt_max'], peak_dict[ 'time_min'], peak_dict['volt_min'] time_max_ch_2 = time_max print('volt_max =', volt_max, 'time_max', np.round(time_max / 1e-9, 3)) plt.plot(t, u) plt.plot(time_max, volt_max, marker='o') #plt.plot(t, u_filt) #plt.plot(time_min_filt, volt_min_filt, marker='o') #plt.plot(time_max_filt, volt_max_filt, marker='o') plt.show() u_dif = time_max_ch_2 - time_max_ch_1 print('raw_u_dif', u_dif / 1e-12) print('time_dif =', np.round(u_dif / 1e-12))
def fft_reb_noise(exp_num, table=False): proc = ProcessSignal(f'{exp_num}') types = proc.read_type_file() csv_signal_nums = types['signal_nums'] excel_results = proc.read_excel(csv_signal_nums)['numbers'] noise_nums = excel_results['noise'] print(excel_results)
def oscillograms(): test = ProcessSignal('191106') csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = test.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] for signal in csv_signals: file = test.open_file(signal, reduced=True) u = file['voltage'] t = file['time'] dt = file['time_resolution'] u_filt = test.bandpass_filter(t, u, 2.725e9, 2.755e9) num = signal[3:6] if int(num) < 66: absorbers = '№2, 3' elif 66 <= int(num) < 125 and num in magnetron_nums: absorbers = 0 elif 125 <= int(num) <= 184 and num in magnetron_nums: absorbers = '№2, 3, A' else: absorbers = 0 pl_d_nums = test.read_excel(csv_signal_nums)['dicts'].keys() if num in pl_d_nums: pl_density = test.read_excel(csv_signal_nums)['dicts'][num]['Ток плазмы, А'] test.oscill_picture(num, t, u, u_filt, pl_density, absorbers, save=True)
def load_red_csv(): test = ProcessSignal('191001') types = test.read_type_file() csv_signals = types['signal_files'] for signal in csv_signals: open_dict = test.open_file(signal, reduced=True) t = open_dict['time'] u = open_dict['voltage'] plt.plot(t, u) plt.show()
def write_2_antennas_osc_csv(exp_num, file_nums): print(f'Experiment {exp_num}') test = ProcessSignal(str(exp_num)) nums_mtrx = np.reshape(np.asarray(file_nums), (int(len(file_nums) / 2), 2)) central_freq = 2.714E9 for j in range(nums_mtrx.shape[0]): antennas_data_dict = {} for i in range(nums_mtrx.shape[1]): file_num = f'{nums_mtrx[j, i]}' file_name = f'str{file_num}.csv' data = test.open_file(file_name, reduced=False) filt_freq_min, filt_freq_max = central_freq - 15e6, central_freq + 15e6 if int(nums_mtrx[j, i]) % 2 == 0: t, u = data['time'], data['voltage'] - np.mean(data['voltage']) u_filt = test.fft_filter(t, u, filt_freq_min, filt_freq_max) antennas_data_dict['t_main'], antennas_data_dict[ 'u_main'] = t, u antennas_data_dict['u_filt_main'] = u_filt plt.plot(t, u) else: #t, u = data['time'], (data['voltage'] - np.mean(data['voltage'])) / 3.16 t, u = data['time'], (data['voltage'] - np.mean(data['voltage'])) u_filt = test.fft_filter(t, u, filt_freq_min, filt_freq_max) antennas_data_dict['t'], antennas_data_dict['u'] = t, u antennas_data_dict['u_filt'] = u_filt plt.plot(t + 4.347E-9, u) plt.show() print(f'Writing {nums_mtrx[j, i]} csv file...') print(antennas_data_dict.keys()) dif_file_path = test.exp_file_path / '2_antennas_CSV' dif_file_path.mkdir(parents=True, exist_ok=True) file = open(str(dif_file_path / f'{nums_mtrx[j, 0]}_{nums_mtrx[j, 1]}.csv'), 'w', newline='') with file: writer = csv.writer(file) writer.writerow([ 't_main(s)', 'V_main(V)', 'V_main_filt(V)', 't(s)', 'V(V)', 'V_filt(V)' ]) for i in range( 1, max(len(antennas_data_dict['t_main']), len(antennas_data_dict['t']))): writer.writerow([ antennas_data_dict['t_main'][i], antennas_data_dict['u_main'][i], antennas_data_dict['u_filt_main'][i], antennas_data_dict['t'][i], antennas_data_dict['u'][i], antennas_data_dict['u_filt'][i] ])
def magnetron_exp(exp_num): proc = ProcessSignal(str(exp_num)) csv_types = proc.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = proc.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] lists = [magnetron_nums] dict_list = [ magnetron_integrals_bloc(exp_num, lists[i]) for i in range(len(lists)) ] fill_excel_table(exp_num, dict_list, proc)
def m_signals_classification(magnetron_in_vals, magnetron_nums): test = ProcessSignal('200925') m_classif_dict = {} for val in magnetron_in_vals: file_numbers = [] for m_num in magnetron_nums: magnetron_in = test.read_excel(m_num)['dicts'][m_num]['Входное напряжение магнетрона, В'] if magnetron_in == val: file_numbers.append(m_num) else: pass m_classif_dict[val] = file_numbers return m_classif_dict
def energy_4_experiments(): exps = [210119, 210204, 210211, 210304] l_col = [19.5, 26.5, 34.5, 20.5] n_low, n_max = 9, 11 fig = plt.figure(num=1, dpi=300) ax1 = fig.add_subplot(211) ax2 = fig.add_subplot(212) colors = ['orange', 'mediumblue', 'limegreen', 'red'] for i, exp in enumerate(exps): proc = ProcessSignal(str(exp)) csv_types = proc.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = proc.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] magnetron_dict = magnetron_integrals_bloc(exp, magnetron_nums) nums = magnetron_dict['nums'] dens_vals = magnetron_dict['density'] noise = magnetron_dict['full_ints'] - magnetron_dict['peak_ints'] peak = magnetron_dict['peak_ints'] noise_to_full = noise / magnetron_dict['full_ints'] exp_nums = magnetron_dict['exp_nums'] ind_mask = np.logical_and(dens_vals >= n_low, dens_vals <= n_max) dens_vals, noise_to_full, exp_num = dens_vals[ind_mask], noise_to_full[ ind_mask], exp_nums[0] peak = peak[ind_mask] print(f'Creating plot for experiment {exp}...') col_len = [l_col[i]] * noise_to_full.size print(col_len) ax2.plot(col_len, peak, marker='.', linestyle=' ', color=colors[i]) ax1.plot(col_len, noise_to_full, marker='.', linestyle=' ', color=colors[i]) ax1.grid(which='both', axis='both') ax1.set_ylabel(r'$W_{1} / W$') ax1.set_xlim(left=17) ax2.grid(which='both', axis='both') ax2.set_xlabel(r'$L_{кол}, см$') ax2.set_ylabel(r'$W_{f0}$') ax2.set_xlim(left=17) ax1.set_title(r' Плотности {} - {} отн.ед.'.format(n_low, n_max)) fig_path = Path( r'C:\Users\d_Nice\Documents\SignalProcessing\2021\210423\Pictures') png_name = fig_path / f'4_exp_energy(17)' fig.savefig(png_name) plt.close(fig) plt.show()
def fft_amp_test(): test = ProcessSignal('191011') types = test.read_type_file() csv_signals = types['signal_files'] for signal in csv_signals: open_dict = test.open_file(signal, reduced=True) t = open_dict['time'] u = open_dict['voltage'] dt = open_dict['time_resolution'] amp_dict = test.fft_amplitude(t, u, dt) freq = amp_dict['frequency'] amp = amp_dict['amplitude'] plt.plot(freq, amp) plt.show()
def amp_max(): test = ProcessSignal('191001') csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = test.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] m_1_nums = [] m_2_nums = [] m_3_nums = [] for num in magnetron_nums: if 35 <= int(num) < 79: m_1_nums.append(num) elif 79 <= int(num) < 111: m_2_nums.append(num) elif 127 <= int(num) <= 150: m_3_nums.append(num) m_lists = [m_1_nums, m_2_nums, m_3_nums] labels_list = ['№2, 3', '№2, 3, A, Б, В', '№2, 3, A', 'Шум'] fig = plt.figure(num=1, dpi=200, figsize=[11.69, 8.27]) ax = fig.add_subplot(111) ax.set_prop_cycle(color=['blue', 'green', 'deepskyblue']) for i, list in enumerate(m_lists): u_maxs = [] pl_ds = [] for csv_signal in csv_signals: csv_num = csv_signal[3:6] for num in list: if csv_num == num: file = test.open_file(csv_signal) u = file['voltage'] t = file['time'] red_dict = test.proc_part_130_290(t, u) red_u = red_dict['part_u'] red_t = red_dict['part_t'] u_filt = test.bandpass_filter(red_t, red_u, 2.709e9, 2.769e9) u_max = np.max(np.array(u_filt)) pl_d = test.read_excel(csv_signal_nums)['dicts'][num]['Ток плазмы, А'] u_maxs.append(u_max) pl_ds.append(pl_d) sorted_inds = np.argsort(np.array(pl_ds)) pl_ds = np.array(pl_ds) pl_ds = pl_ds[sorted_inds] u_maxs = np.array(u_maxs) u_maxs = u_maxs[sorted_inds] line, = plt.plot(pl_ds, u_maxs, marker='o', linewidth=2) line.set_label('{}'.format(labels_list[i])) ax.set_ylim(bottom=0) ax.set_xlim(left=4, right=9) ax.set_xlabel(r'$Plasma\/density, arb.units $', fontsize=14) ax.set_ylabel(r'$Max\/amplitude$', fontsize=14) ax.grid(which='both', axis='both') ax.legend(loc='best', fontsize=16) ax.set_title('Max amplitude', fontsize=20) png_name = test.pics_path / 'max_amp.png' plt.savefig(png_name) plt.show()
def pulse_duration(): test = ProcessSignal('190925') csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] pl_d_nums = test.read_excel(csv_signal_nums)['dicts'].keys() t_difs = [] pl_ds = [] for signal in csv_signals: file = test.open_file(signal) u = file['voltage'] t = file['time'] dt = file['time_resolution'] envelope = test.useful_part(t, u, dt) t_use, u_use = envelope['signal_time'], envelope['signal_voltage'] t_dif = t_use[-1] - t_use[0] t_difs.append(t_dif) num = signal[3:6] if num in pl_d_nums: pl_density = test.read_excel(csv_signal_nums)['dicts'][num]['Ток плазмы, А'] pl_ds.append(pl_density) pl_ds = np.array(pl_ds) t_difs = np.array(t_difs) sorted_inds = np.argsort(pl_ds) pl_ds_sorted = pl_ds[sorted_inds] t_difs_sorted = t_difs[sorted_inds] plt.plot(pl_ds_sorted, t_difs_sorted) #plt.plot(t_use, u_use) plt.show()
def noise_integrals_block(exp_num, file_nums): proc = ProcessSignal(str(exp_num)) shot_nums, density_vals, full_ints = [], [], [] for num in file_nums: file_name = f'str{num}.csv' file = proc.open_file(file_name, reduced=True) u = file['voltage'] t = file['time'] dt_2 = (t[-1] - t[0])**2 pl_density = proc.read_excel(file_name)['dicts'][num]['Ток плазмы, А'] freqs, amps = proc.fft_amplitude(t, u)['frequency'], proc.fft_amplitude( t, u)['amplitude'] full_int = np.round(dt_2 * proc.e_square(freqs, amps) / 2e-8, 3) density_vals.append(pl_density) shot_nums.append(num) full_ints.append(full_int) sorted_inds = np.argsort(density_vals) density_vals = np.asarray(density_vals)[sorted_inds] shot_nums = np.asarray(shot_nums)[sorted_inds] full_ints = np.asarray(full_ints)[sorted_inds] integrals_dict = { 'nums': shot_nums, 'density': density_vals, 'full_ints': full_ints } return integrals_dict
def multi_integral_excel(exp_num): proc = ProcessSignal(str(exp_num)) csv_types = proc.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = proc.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] magnetron_nums = [ csv_signal_nums[i] for i in range(len(csv_signal_nums)) if int(csv_signal_nums[i]) % 2 == 0 ] print(magnetron_nums) list_1 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 6 < int(magnetron_nums[i]) < 31 ] list_2 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 30 < int(magnetron_nums[i]) < 49 ] list_3 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 48 < int(magnetron_nums[i]) < 67 ] list_4 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 66 < int(magnetron_nums[i]) < 89 ] list_5 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 88 < int(magnetron_nums[i]) < 107 ] list_6 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 106 < int(magnetron_nums[i]) < 123 ] list_7 = [ magnetron_nums[i] for i in range(len(magnetron_nums)) if 122 < int(magnetron_nums[i]) < 136 ] lists = [list_1, list_2, list_3, list_4, list_5, list_6, list_7] dict_list = [ magnetron_integrals_bloc(exp_num, lists[i]) for i in range(len(lists)) ] fill_excel_table(exp_num, dict_list, proc)
def intgrals_calc_25(): #magnetron_in_vals = [8.7, 10.7, 13] test = ProcessSignal('201008') csv_files_list = os.listdir(test.csv_files_path) csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = test.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] reb_nums = excel_dicts['noise'] #m_classif_dict = m_signals_classification(magnetron_in_vals, magnetron_nums) magnetron_dict = {} reb_dict = {} for csv_signal in csv_signals: if csv_signal in csv_files_list: num = csv_signal[3:6] file = test.open_file(csv_signal, reduced=True) t, u = file['time'], file['voltage'] pl_density = test.read_excel(csv_signal)['dicts'][num]['Ток плазмы, А'] full_integral = np.round(test.e_square(t, u) / 1e-8, 3) if num in reb_nums: reb_dict[num] = {'n': pl_density, 'full_integral': full_integral, 'num': num} else: len_t = len(t) dt = np.abs(t[1] - t[0]) fft_u = rfft(u) freqs_fft = rfftfreq(len_t, dt) ind_mask = np.logical_and(2.695e9 < freqs_fft, freqs_fft < 2.725e9) u_empty = np.zeros(len(ind_mask)) u_empty[ind_mask] = fft_u[ind_mask] fft_filtered_u = irfft(u_empty) #plt.plot(t, u, color='k') #plt.plot(t, fft_filtered_u) #plt.show() absorbers = test.read_excel(csv_signal)['dicts'][num]['Поглотители в тракте магнетрона'] filtered_integral = np.round(test.e_square(t, fft_filtered_u) / 1e-8, 3) pedestal_integral = full_integral - filtered_integral magnetron_dict[num] = {'n': pl_density, 'full_integral': full_integral, 'peak_integral': filtered_integral, 'pedestal_integral': pedestal_integral, 'abs': absorbers, 'num': num} plt.plot(pl_density, full_integral, color='blue', marker='o') plt.plot(pl_density, filtered_integral, color='red', marker='o', linestyle='-') return reb_dict, magnetron_dict
def rename_csv_files(exp_num, old_part, new_part): proc = ProcessSignal(f'{exp_num}') all_files_list = os.listdir(proc.exp_file_path) csv_files_list = [all_files_list[i] for i in range(len(all_files_list)) if 'csv' in all_files_list[i]] #csv_files_list = [all_files_list[i] for i in range(len(all_files_list)) if 'csv' in all_files_list[i] and len(all_files_list[i])==13] print(csv_files_list) for file in csv_files_list: new_file_name = file.replace(old_part, new_part) old_file_path = proc.exp_file_path / file new_file_path = proc.exp_file_path / new_file_name os.rename(old_file_path, new_file_path)
def two_exp_integrals(exp_num, table=False, data=True): test = ProcessSignal('{}'.format(exp_num)) csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] pl_densities = np.zeros(len(csv_signals)) integrals = np.zeros(len(csv_signals)) nums = np.zeros(len(csv_signals)) csv_path = test.csv_files_path csv_dir_files = os.listdir(csv_path) test.reduce_fft() for i, csv_signal in enumerate(csv_signals): csv_signal_num = csv_signal[3:6] if csv_signal in csv_dir_files: file = test.open_file(csv_signal, reduced=True) pl_density = test.read_excel(csv_signal)['dicts'][csv_signal_num]['Ток плазмы, А'] pl_densities[i] = pl_density nums[i] = csv_signal_num t, u, dt = file['time'], file['voltage'], file['time_resolution'] plt.plot(t, u) integrals[i] = np.round(test.e_square(t, u) / 1e-7, 2) print(csv_signal_num, integrals[i]) plt.title("№ {}, e^2 = {}".format(csv_signal_num, integrals[i])) #plt.show() sorted_inds = np.argsort(pl_densities) pl_densities = pl_densities[sorted_inds] integrals = integrals[sorted_inds] nums = nums[sorted_inds] if table: ex_table = excel.Workbook() ex_table.create_sheet(title='Integral', index=0) sheet = ex_table['Integral'] sheet['A1'] = 'Номер' sheet['B1'] = 'Плотность плазмы, отн.ед.' sheet['C1'] = 'Интеграл, *10-8' table_size = integrals.size for k in range(table_size): cell = sheet.cell(row=k+2, column=1) cell.value = nums[k] cell = sheet.cell(row=k+2, column=2) cell.value = pl_densities[k] cell = sheet.cell(row=k+2, column=3) cell.value = integrals[k] path = test.excel_folder_path / 'Integral_{}.xlsx'.format(exp_num) ex_table.save(path) if data: integral_dict = {'pl_ds': pl_densities, 'integral_vals': integrals, 'shot_nums': nums} return integral_dict
def absorber_classification(exp_number, magnetron_dicts): test = ProcessSignal(str(exp_number)) types = test.read_type_file() csv_signal_nums = types['signal_nums'] magnetron_nums = test.read_excel(csv_signal_nums)['numbers']['magnetron'] dicts = test.read_excel(csv_signal_nums)['dicts'] absorbers_list = []*(len(magnetron_nums)) for num in magnetron_nums: absorbers_list.append(dicts[num]['Поглотители в тракте магнетрона']) uniq_abs = set(absorbers_list) print(uniq_abs) abs_dict = {} for element in uniq_abs: nums_list = [] for dict_num in magnetron_dicts: absorbers = magnetron_dicts[dict_num]['abs'] if absorbers == element: nums_list.append(magnetron_dicts[dict_num]) abs_dict[element] = nums_list return abs_dict
def peak_mean_freq_calc(exp_num, central_freq=2.714e9, band_half_width=50e6): proc = ProcessSignal(f'{exp_num}') types = proc.read_type_file() csv_signals, csv_signal_nums = types['signal_files'], types['signal_nums'] excel_results = proc.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_results['magnetron'] m_nums, m_plasma_dens, m_mean_freqs = [], [], [] for num in magnetron_nums: file_name = f'str{num}.csv' file_data = proc.open_file(file_name, reduced=True) t, u, dt = file_data['time'], file_data['voltage'], file_data['time_resolution'] pl_density = proc.read_excel(file_name)['dicts'][num]['Ток плазмы, А'] fft_results = proc.fft_amplitude(t, u) freqs, amps = fft_results['frequency'], fft_results['amplitude'] left_boundary, right_boundary = central_freq - band_half_width, central_freq + band_half_width noise_base_inds = np.logical_and(freqs >= left_boundary, freqs <= right_boundary) noise_base_freqs, noise_base_amps = freqs[noise_base_inds], amps[noise_base_inds] mean_freq = proc.mean_frequency(noise_base_freqs, noise_base_amps) spectrum_mean_freq = mean_freq['mean_freq'] m_nums.append(num), m_plasma_dens.append(pl_density), m_mean_freqs.append(spectrum_mean_freq) m_sorted_inds = np.argsort(np.asarray(m_plasma_dens)) m_nums_sort = np.asarray(m_nums)[m_sorted_inds] m_plasma_dens_sort = np.asarray(m_plasma_dens)[m_sorted_inds] m_mean_freqs_sort = np.asarray(m_mean_freqs)[m_sorted_inds] ex_table = xl.Workbook() ex_table.create_sheet(title='Mean_freq', index=0) sheet = ex_table['Mean_freq'] sheet['A1'] = 'Номер' sheet['B1'] = 'Плотность плазмы, отн.ед.' sheet['C1'] = 'Средняя частота, ГГц' for k in range(m_nums_sort.size): cell = sheet.cell(row=k + 2, column=1) cell.value = int(m_nums_sort[k]) cell = sheet.cell(row=k + 2, column=2) cell.value = m_plasma_dens_sort[k] cell = sheet.cell(row=k + 2, column=3) cell.value = m_mean_freqs_sort[k] path = proc.excel_folder_path / f'Mean_freq_{exp_num}_test.xlsx' ex_table.save(path) #peak_mean_freq_calc(210322)
def magnetron_integrals_bloc(exp_num, file_nums, central_freq=2.714, band_half_width=0.05): proc = ProcessSignal(str(exp_num)) shot_nums, density_vals, full_ints, peak_ints, exp_nums = [], [], [], [], [] for num in file_nums: file_name = f'str{num}.csv' file = proc.open_file(file_name, reduced=True) u = file['voltage'] t = file['time'] f_low = (central_freq - band_half_width) * 1e9 f_high = (central_freq + band_half_width) * 1e9 dt_2 = (t[-1] - t[0])**2 #pl_num = f'{(int(num) - 1):03d}' pl_density = proc.read_excel(file_name)['dicts'][num]['Ток плазмы, А'] freqs, amps = proc.fft_amplitude(t, u)['frequency'], proc.fft_amplitude( t, u)['amplitude'] peak_inds = np.logical_and(freqs >= f_low, freqs <= f_high) p_freqs, p_amps = freqs[peak_inds], amps[peak_inds] full_int = np.round(dt_2 * proc.e_square(freqs, amps) / 2e-8, 3) peak_int = np.round(dt_2 * proc.e_square(p_freqs, p_amps) / 2e-8, 3) density_vals.append(pl_density) shot_nums.append(num) full_ints.append(full_int) peak_ints.append(peak_int) exp_nums.append(exp_num) sorted_inds = np.argsort(density_vals) density_vals = np.asarray(density_vals)[sorted_inds] shot_nums = np.asarray(shot_nums)[sorted_inds] full_ints, peak_ints = np.asarray(full_ints)[sorted_inds], np.asarray( peak_ints)[sorted_inds] integrals_dict = { 'nums': shot_nums, 'density': density_vals, 'full_ints': full_ints, 'peak_ints': peak_ints, 'exp_nums': exp_nums } return integrals_dict
def left_right_noise(): test = ProcessSignal('191106') noise_dict = noise_signal_plot(191106, type='amp_freq', left_right=True) pl_d = noise_dict['pl_ds'] r_power = noise_dict['r_power'] l_power = noise_dict['l_power'] full_power = noise_dict['e_integs'] plasma_nums = noise_dict['plasma_nums'] fig = plt.figure(num=1, dpi=300) ax = fig.add_subplot(111) line_r, = ax.plot(pl_d, r_power, marker='^', linewidth=0.9, color='blue', ms=3) line_l, = ax.plot(pl_d, l_power, marker='o', linewidth=0.9, color='red', ms=3) line_l.set_label(r'$f < 2.725\/GHz$') line_r.set_label(r'$f > 2.755\/GHz$') ax.set_xlabel('Plasma density, arb.units', fontsize=12) ax.set_ylabel(r'$K\int A^2 df $', fontsize=12) ax.set_ylim(bottom=0) ax.legend() ax.set_title(r'$191106. P_{in}=0 $') ax.grid(which='both', axis='both') png_name = test.pics_path / 'noise_power' fig.savefig(png_name) test.left_right_table(plasma_nums, full_power, l_power, r_power, pl_d, 'noise')
def series_fft(exp_num): fft_test = ProcessSignal(f'{exp_num}') types = fft_test.read_type_file() csv_signals = types['signal_files'] #csv_signals = ['str097.csv'] csv_signal_nums = types['signal_nums'] excel_results = fft_test.read_excel(csv_signal_nums)['numbers'] noise_nums = excel_results['noise'] #magnetron_nums = excel_results['magnetron'] magnetron_nums = [f'{i:03d}' for i in range(131, 187, 1)] print('Magnetron nums are', magnetron_nums) print('Noise nums are:', noise_nums) fft_test.part_fft(csv_signals, interest_nums=magnetron_nums, part_nums=noise_nums, fft_type='full', block_full=False, block_part=False, peak=True, noise=False)
def integrals_for_different_conditions(exp_num): proc = ProcessSignal(str(exp_num)) wb = excel.load_workbook(proc.main_excel_path) sheet = wb['Лист1'] rows = sheet.max_row cols = sheet.max_column row_min = 1 col_max = 1 for i in range(1, rows): cell = sheet.cell(row=i, column=1) cell_row_val = cell.value if cell_row_val == 'Номер файла' and row_min == 1: row_min = i for m in range(1, cols + 1): cell = sheet.cell(row=row_min, column=m) cell_col_val = cell.value if cell_col_val == 'Комментарий': col_max = m print(row_min, col_max) #integrals_for_different_conditions(210407)
def e_square_spectra(exp_num, signal_type='magnetron', scale='log'): proc = ProcessSignal(f'{exp_num}') types = proc.read_type_file() csv_signals, csv_signal_nums = types['signal_files'], types['signal_nums'] excel_results = proc.read_excel(csv_signal_nums)['numbers'] if signal_type == 'magnetron': nums_for_proc = excel_results['magnetron'] elif signal_type == 'noise': nums_for_proc = excel_results['noise'] for num in nums_for_proc: file_name = f'str{num}.csv' file_data = proc.open_file(file_name, True) t, u = file_data['time'], file_data['voltage'] fft_data = proc.fft_amplitude(t, u * u) freqs, amps = fft_data['frequency'][2::], fft_data['amplitude'][2::] inds = freqs <= 4e9 freqs_4, amps_4 = freqs[inds], amps[inds] pl_dens = proc.read_excel(file_name)['dicts'][num]['Ток плазмы, А'] fig = plt.figure(num=1, dpi=300) ax = fig.add_subplot(111) line, = ax.plot(freqs_4, amps_4) ax.set_xlim(left=1e9, right=4e9) if scale == 'log': ax.set_yscale('log') ax.set_ylim(bottom=10**(-5)) pic_name = r'Спектр квадрата напряжения\Логарифмический\ u_2_log_{}'.format(num) else: ax.set_ylim(bottom=0) pic_name = r'Спектр квадрата напряжения\Обычный\ u_2_{}'.format(num) ax.grid(which='both', axis='both') ax.set_title(r'$№={}, n={}$'.format(num, pl_dens)) png_name = proc.fft_pics_path / pic_name fig.savefig(png_name) plt.close(fig) plt.show()
import numpy as np from scipy.fftpack import rfft, irfft, rfftfreq from ProcessClass_10 import ProcessSignal import matplotlib.pyplot as plt import os test = ProcessSignal('201026') csv_signals = os.listdir(test.exp_file_path) def file_classification(signals): magnetron_files = [] signal_files = [] voltage_files = [] for signal in signals: if 'csv' in signal: file = test.open_file(signal, reduced=False) t, u = file['time'], file['voltage'] dt = np.abs(t[1] - t[0]) env_curv = test.signal_envelope(t, u, dt) u_env_curv = env_curv['env_voltage'] part_env_data = test.useful_part(t, u, dt, max_part=0.45) try: u_env, t_env = np.asarray(part_env_data['signal_voltage']), np.asarray(part_env_data['signal_time']) delta_time = t_env[-1] - t_env[0] if delta_time > 400e-9 and np.mean(u_env_curv) > 1: magnetron_files.append(signal) plt.plot(t, u) plt.title(signal[3:6]) plt.show() elif np.mean(u) < 0:
import numpy as np import openpyxl as excel import matplotlib.pyplot as plt from ProcessClass_10 import ProcessSignal test = ProcessSignal('200924') test.files_classification() csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = test.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] plasma_nums = excel_dicts['noise'] print('Magnetron nums are:', magnetron_nums, 'REB nums are:', plasma_nums) pl_densities = np.zeros(len(csv_signals)) integrals = np.zeros(len(csv_signals)) nums = np.zeros(len(csv_signals)) test.reduce_fft() for i, csv_signal in enumerate(csv_signals): csv_signal_num = csv_signal[3:6] file = test.open_file(csv_signal, reduced=True) pl_density = test.read_excel( csv_signal)['dicts'][csv_signal_num]['Ток плазмы, А'] pl_densities[i] = pl_density time = file['time'] voltage = file['voltage'] t, u, dt = file['time'], file['voltage'], file['time_resolution'] fft = test.fft_amplitude(t, u, dt) freqs = fft['frequency'] amps = fft['amplitude'] n_dt_2 = (t[-1] - t[0])**2
u_empty = np.zeros(len(fft_u)) bandpass_filter = np.zeros(len(fft_u)) bandpass_filter[ind_mask] = 1 b_filt_u = irfft(fft_u * bandpass_filter) u_empty[ind_mask] = fft_u[ind_mask] fft_filtered_u = irfft(u_empty) #plt.plot(freqs_fft, bandpass_filter) plt.plot(t, u) plt.plot(t, fft_filtered_u) plt.plot(t, b_filt_u) #plt.xlim(left=2.675e9, right=2.75e9) plt.show() return fft_filtered_u test = ProcessSignal('201008') csv_files_list = os.listdir(test.csv_files_path) csv_types = test.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = test.read_excel(csv_signal_nums)['numbers'] magnetron_nums = excel_dicts['magnetron'] reb_nums = excel_dicts['noise'] print(reb_nums) reb_dict = {} ambigous_nums = [] dt_list = [] for csv_signal in csv_signals: if csv_signal in csv_files_list: num = csv_signal[3:6] if num in magnetron_nums or num in reb_nums:
import numpy as np import openpyxl as excel import matplotlib.pyplot as plt from ProcessClass_10 import ProcessSignal nums, n_s, mean_freqs = [], [], [] noise_freqs, noise_ns, n_nums = [], [], [] for signal in csv_signals:proc = ProcessSignal('201110') csv_types = proc.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = proc.read_excel(csv_signal_nums)['numbers'] noise_nums = excel_dicts['noise'] magnetron_nums = excel_dicts['magnetron'][:18:] num = signal[3:6] if num in magnetron_nums: file = proc.open_file(signal, reduced=True) u = file['voltage'] t = file['time'] u_filt = proc.fft_filter(t, u, 2.695e9, 2.725e9, filt_type='bandstop') dt = file['time_resolution'] dt_2 = (t[-1] - t[0]) ** 2 pl_density = proc.read_excel(signal)['dicts'][num]['Ток плазмы, А'] fft_data = proc.fft_amplitude(t, u_filt) freqs, amps = fft_data['frequency'], fft_data['amplitude'] mean_freq = proc.mean_frequency(freqs, amps)['mean_freq'] nums.append(num)
import numpy as np from scipy.fftpack import rfft, irfft, rfftfreq from ProcessClass_10 import ProcessSignal import matplotlib.pyplot as plt import os import openpyxl as excel proc = ProcessSignal('201026') short_delay_signals = np.arange(29, 67, 2) long_delay_signals = np.arange(85, 109, 2) signal_list = [short_delay_signals, long_delay_signals] print(long_delay_signals) full_ints = [] peak_ints = [] ns = [] m_delays = [] nums = [] for signal in signal_list[1]: signal_file = f'str{signal:03d}.csv' file = proc.open_file(signal_file, reduced=False) t, u = file['time'], file['voltage'] if signal < 95: t_min, t_max = 960e-9, 1222e-9 else: t_min, t_max = 60e-9, 322e-9 cut_inds = np.logical_and(t >= t_min, t <= t_max) t_cut = t[cut_inds] u_cut = u[cut_inds] print(t[0])
import numpy as np import openpyxl as excel from ProcessClass_10 import ProcessSignal test = ProcessSignal('191120') file_name = 'str018.csv' file = test.open_file(file_name, reduced=True) t, u, dt = file['time'], file['voltage'], file['time_resolution'] fft = test.fft_amplitude(t, u, dt) freqs = fft['frequency'] amps = fft['amplitude'] n_dt_2 = (t[-1] - t[0])**2 full_integral = 2 * n_dt_2 * test.e_square(freqs, amps) / 1e-8 print(full_integral) df_s = np.arange(5, 105, 5) * 1e6 noise_integrals = np.zeros(len(df_s)) peak_integrals = np.zeros(len(df_s)) magnetron_freq = 2.74e9 for i, df in enumerate(df_s): low_freq = magnetron_freq - df high_freq = magnetron_freq + df noise_inds_l = freqs < low_freq noise_inds_r = freqs > high_freq peak_inds = np.logical_and(freqs > low_freq, freqs < high_freq) noise_freqs_l, noise_amps_l = freqs[noise_inds_l], amps[noise_inds_l] noise_freqs_r, noise_amps_r = freqs[noise_inds_r], amps[noise_inds_r] peak_freqs, peak_amps = freqs[peak_inds], amps[peak_inds]
import numpy as np import openpyxl as excel import matplotlib.pyplot as plt from ProcessClass_10 import ProcessSignal proc = ProcessSignal('201113') csv_types = proc.read_type_file() csv_signals = csv_types['signal_files'] csv_signal_nums = csv_types['signal_nums'] excel_dicts = proc.read_excel(csv_signal_nums)['numbers'] noise_nums = excel_dicts['noise'][:12:] magnetron_nums = excel_dicts['magnetron'][0:0:] nums, n_s, l_ints, r_ints = [], [], [], [] l_noise_ints, r_noise_ints, noise_ns, n_nums = [], [], [], [] for signal in csv_signals: num = signal[3:6] file = proc.open_file(signal, reduced=True) u = file['voltage'] t = file['time'] dt = file['time_resolution'] dt_2 = (t[-1] - t[0])**2 fft_data = proc.fft_amplitude(t, u) freqs, amps = fft_data['frequency'][1::], fft_data['amplitude'][1::] left_inds = freqs <= 2.71e9 - 50e6 l_freqs = freqs[left_inds] l_amps = amps[left_inds] l_int = np.round(dt_2 * proc.e_square(l_freqs, l_amps) / 2e-8, 3) r_inds = freqs >= 2.71e9 + 50e6 r_freqs = freqs[r_inds] r_amps = amps[r_inds] r_int = np.round(dt_2 * proc.e_square(r_freqs, r_amps) / 2e-8, 3)