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)
