# Averaging the reconstructed profiles
all_profiles_time, all_profiles_current = [], []
for profile in all_profiles:
profile.shift('Right_fit')
#all_profiles_time.append(profile.time - profile.time[np.argmax(profile.current)])
all_profiles_time.append(profile.time)
new_time = np.linspace(min(x.min() for x in all_profiles_time), max(x.max() for x in all_profiles_time), len_profile)
for tt, profile in zip(all_profiles_time, all_profiles):
new_current = np.interp(new_time, tt, profile.current, left=0, right=0)
new_current *= charge/new_current.sum()
all_profiles_current.append(new_current)
all_profiles_current = np.array(all_profiles_current)
mean_profile = np.mean(all_profiles_current, axis=0)
std_profile = np.std(all_profiles_current, axis=0)
average_profile = tracking.BeamProfile(new_time, mean_profile, tracker.energy_eV, charge)
average_profile.plot_standard(sp_profile_comp, label='Reconstructed', norm=True, center='Right_fit')
ms.figure('Test averaging %s' % main_label)
sp = plt.subplot(1,1,1)
for yy in all_profiles_current:
sp.plot(new_time, yy/np.trapz(yy, new_time), lw=0.5)
to_plot = [
('Average', new_time, mean_profile, 'black', 3),
('+1 STD', new_time, mean_profile+std_profile, 'black', 1),
('-1 STD', new_time, mean_profile-std_profile, 'black', 1),
]
integral = np.trapz(mean_profile, new_time)
screen = copy.deepcopy(screen)
screen.reshape(n_particles)
t_interp0 = np.interp(screen.x, wake_x, wake_time)
charge_interp, hist_edges = np.histogram(t_interp0,
bins=n_particles // 100,
weights=screen.intensity,
density=True)
charge_interp[0] = 0
charge_interp[-1] = 0
t_interp = np.linspace(t_interp0[0], t_interp0[-1], len(charge_interp))
if t_interp[1] < t_interp[0]:
t_interp = t_interp[::-1]
charge_interp = charge_interp[::-1]
t_interp -= t_interp.min()
bp = tracking.BeamProfile(t_interp, charge_interp, 1, charge)
bp.plot_standard(sp_profile, label=label)
final_profile.plot_standard(sp_profile, label='From module')
profile_arr = np.interp(new_t_axis, final_profile.time, final_profile.current)
new_img_sum = new_img.sum(axis=-2)
new_img_sum[new_img_sum == 0] = np.inf
image3 = new_img / new_img_sum / profile_arr.sum() * profile_arr
image3 = image3 / image3.sum() * new_img.sum()
sp = subplot(sp_ctr, 'From profile', xlabel='time [fs]')
sp_ctr += 1
plot_img_and_proj(sp, image3, new_t_axis, y_axis, x_factor=1e15)
sp_screen.legend()
final_baf = tracker.back_and_forward(meas_screen, reconstructed_profile, gaps, beam_offsets, n_streaker)
final_bp = final_baf['beam_profile']
final_screen = final_baf['screen']
final_screen.normalize()
final_profile_list.append(final_bp)
final_bp.center()
sp_profile.plot(final_bp.time*1e15, final_bp.current/final_bp.integral, color=color)
label2 = 'Reconstructed' if n_bo == 0 else None
sp_screen.plot(final_screen.x*1e3, final_screen.intensity, color=color, ls='--', label=label2)
xx, yy = tracking.get_average_profile(final_profile_list)
avg_profile = tracking.BeamProfile(xx, yy, tracker.energy_eV, charge)
avg_profile.center()
sp_profile.plot(avg_profile.time*1e15, avg_profile.current/avg_profile.integral, label='Average', color='red')
sp_profile0.plot(avg_profile.time*1e15, avg_profile.current/avg_profile.integral, label='%i / %i' % (offset_error_s1*1e6, avg_profile.gaussfit.sigma*1e15))
total_diff = 0
for n_bo, beam_offsets0 in enumerate(beam_offset_list):
beam_offsets = np.array(beam_offsets0) + np.array(offset_error)
f_avg = tracker.matrix_forward(avg_profile, gaps, beam_offsets)
screen_avg = f_avg['screen']
diff = screen_avg.compare(meas_screen_dict[n_bo])
total_diff += diff
def main():
fig_paper = ms.figure('Comparison plots')
subplot = ms.subplot_factory(2, 2)
sp_ctr_paper = 1
#images0 = dict0['projx'][-1]
#x_axis = dict0['x_axis']*1e-6
#if np.diff(x_axis)[0] < 0:
# x_axis = x_axis[::-1]
# invert_x = True
#else:
# invert_x = False
process_dict = {
'Long': {
'filename': file38,
'main_dict': dict38,
'proj0': dict0['projx'][-1],
'x_axis0': dict0['x_axis'] * 1e-6,
'n_offset': None,
'filename0': file0,
'blmeas': blmeas38,
'flipx': False,
},
'Medium': {
'filename': file25,
'main_dict': dict25,
'proj0': dict25['projx'][7],
'x_axis0': dict25['x_axis'] * 1e-6,
'n_offset': 0,
'filename0': file25,
'blmeas': blmeas25,
'flipx': False,
},
}
for main_label, p_dict in process_dict.items():
#if main_label != 'Medium':
# continue
projx0 = p_dict['proj0']
x_axis0 = p_dict['x_axis0']
if np.diff(x_axis0)[0] < 0:
x_axis0 = x_axis0[::-1]
invert_x0 = True
all_mean = []
for proj in projx0:
screen = get_screen_from_proj(proj, x_axis0, invert_x0)
xx, yy = screen._xx, screen._yy
gf = gaussfit.GaussFit(xx, yy)
all_mean.append(gf.mean)
mean0 = np.mean(all_mean)
timestamp0 = misc.get_timestamp(os.path.basename(p_dict['filename0']))
tracker0 = tracking.Tracker(
archiver_dir + 'archiver_api_data/2020-10-03.h5', timestamp0,
struct_lengths, n_particles, n_emittances, screen_bins,
screen_cutoff, smoothen, profile_cutoff, len_profile)
bp_test = tracking.get_gaussian_profile(40e-15, tt_halfrange,
len_profile, charge,
tracker0.energy_eV)
screen_sim = tracker0.matrix_forward(bp_test, [10e-3, 10e-3],
[0, 0])['screen']
all_emittances = []
for proj in projx0:
screen_meas = get_screen_from_proj(proj, x_axis0, invert_x0)
emittance_fit = misc.fit_nat_beamsize(screen_meas, screen_sim,
n_emittances[0])
all_emittances.append(emittance_fit)
new_emittance = np.mean(all_emittances)
print(main_label, 'Emittance [nm]', new_emittance * 1e9)
n_emittances[0] = new_emittance
dict_ = p_dict['main_dict']
file_ = p_dict['filename']
x_axis = dict_['x_axis'] * 1e-6
y_axis = dict_['y_axis'] * 1e-6
n_offset = p_dict['n_offset']
if np.diff(x_axis)[0] < 0:
x_axis = x_axis[::-1]
invert_x = True
else:
invert_x = False
if np.diff(y_axis)[0] < 0:
y_axis = y_axis[::-1]
invert_y = True
else:
invert_y = False
timestamp = misc.get_timestamp(os.path.basename(file_))
tracker = tracking.Tracker(
archiver_dir + 'archiver_api_data/2020-10-03.h5', timestamp,
struct_lengths, n_particles, n_emittances, screen_bins,
screen_cutoff, smoothen, profile_cutoff, len_profile)
blmeas = p_dict['blmeas']
flip_measured = p_dict['flipx']
profile_meas = tracking.profile_from_blmeas(blmeas,
tt_halfrange,
charge,
tracker.energy_eV,
subtract_min=True)
profile_meas.reshape(len_profile)
profile_meas2 = tracking.profile_from_blmeas(blmeas,
tt_halfrange,
charge,
tracker.energy_eV,
subtract_min=True,
zero_crossing=2)
profile_meas2.reshape(len_profile)
if flip_measured:
profile_meas.flipx()
else:
profile_meas2.flipx()
profile_meas.cutoff(1e-2)
profile_meas2.cutoff(1e-2)
beam_offsets = [0., -(dict_['value'] * 1e-3 - mean_struct2)]
distance_um = (gaps[n_streaker] / 2. - beam_offsets[n_streaker]) * 1e6
if n_offset is not None:
distance_um = distance_um[n_offset]
beam_offsets = [beam_offsets[0], beam_offsets[1][n_offset]]
tdc_screen1 = tracker.matrix_forward(profile_meas, gaps,
beam_offsets)['screen']
tdc_screen2 = tracker.matrix_forward(profile_meas, gaps,
beam_offsets)['screen']
plt.figure(fig_paper.number)
sp_profile_comp = subplot(sp_ctr_paper,
title=main_label,
xlabel='t [fs]',
ylabel='Intensity (arb. units)')
sp_ctr_paper += 1
profile_meas.plot_standard(sp_profile_comp,
norm=True,
color='black',
label='TDC',
center='Right')
ny, nx = 2, 4
subplot = ms.subplot_factory(ny, nx)
sp_ctr = np.inf
all_profiles, all_screens = [], []
if n_offset is None:
projections = dict_['projx']
else:
projections = dict_['projx'][n_offset]
for n_image in range(len(projections)):
screen = get_screen_from_proj(projections[n_image], x_axis,
invert_x)
screen.crop()
screen._xx = screen._xx - mean0
gauss_dict = tracker.find_best_gauss(
sig_t_range,
tt_halfrange,
screen,
gaps,
beam_offsets,
n_streaker,
charge,
self_consistent=self_consistent)
best_screen = gauss_dict['reconstructed_screen']
best_screen.cutoff(1e-3)
best_screen.crop()
best_profile = gauss_dict['reconstructed_profile']
if n_image == 0:
screen00 = screen
bp00 = best_profile
best_screen00 = best_screen
best_gauss = gauss_dict['best_gauss']
if sp_ctr > (ny * nx):
ms.figure('All reconstructions Distance %i %s' %
(distance_um, main_label))
sp_ctr = 1
if n_image % 2 == 0:
sp_profile = subplot(sp_ctr, title='Reconstructions')
sp_ctr += 1
sp_screen = subplot(sp_ctr, title='Screens')
sp_ctr += 1
profile_meas.plot_standard(sp_profile,
color='black',
label='Measured',
norm=True,
center='Right')
tdc_screen1.plot_standard(sp_screen, color='black')
color = screen.plot_standard(sp_screen,
label=n_image)[0].get_color()
best_screen.plot_standard(sp_screen, color=color, ls='--')
best_profile.plot_standard(sp_profile,
label=n_image,
norm=True,
center='Right')
sp_profile.legend()
sp_screen.legend()
all_profiles.append(best_profile)
# Averaging the reconstructed profiles
all_profiles_time, all_profiles_current = [], []
for profile in all_profiles:
profile.shift('Right')
#all_profiles_time.append(profile.time - profile.time[np.argmax(profile.current)])
all_profiles_time.append(profile.time)
new_time = np.linspace(min(x.min() for x in all_profiles_time),
max(x.max() for x in all_profiles_time),
len_profile)
for tt, profile in zip(all_profiles_time, all_profiles):
new_current = np.interp(new_time,
tt,
profile.current,
left=0,
right=0)
new_current *= charge / new_current.sum()
all_profiles_current.append(new_current)
all_profiles_current = np.array(all_profiles_current)
mean_profile = np.mean(all_profiles_current, axis=0)
std_profile = np.std(all_profiles_current, axis=0)
average_profile = tracking.BeamProfile(new_time, mean_profile,
tracker.energy_eV, charge)
average_profile.plot_standard(sp_profile_comp,
label='Reconstructed',
norm=True,
center='Right')
ms.figure('Test averaging %s' % main_label)
sp = plt.subplot(1, 1, 1)
for yy in all_profiles_current:
sp.plot(new_time, yy / np.trapz(yy, new_time), lw=0.5)
to_plot = [
('Average', new_time, mean_profile, 'black', 3),
('+1 STD', new_time, mean_profile + std_profile, 'black', 1),
('-1 STD', new_time, mean_profile - std_profile, 'black', 1),
]
integral = np.trapz(mean_profile, new_time)
for pm, ctr, color in [(profile_meas, 1, 'red'),
(profile_meas2, 2, 'green')]:
#factor = integral/np.trapz(pm.current, pm.time)
#t_meas = pm.time-pm.time[np.argmax(pm.current)]
i_meas = np.interp(new_time, pm.time, pm.current)
bp = tracking.BeamProfile(new_time,
i_meas,
energy_eV=tracker.energy_eV,
charge=charge)
bp.shift('Right')
to_plot.append(('TDC %i' % ctr, bp.time, bp.current, color, 3))
for label, tt, profile, color, lw in to_plot:
gf = gaussfit.GaussFit(tt, profile)
width_fs = gf.sigma * 1e15
if label is None:
label = ''
label = (label + ' %i fs' % width_fs).strip()
factor = np.trapz(profile, tt)
sp.plot(tt, profile / factor, color=color, lw=lw, label=label)
sp.legend(title='Gaussian fit $\sigma$')
plt.show()
xlabel='t [fs]',
ylabel='$\Delta$ x',
scix=True,
sciy=True)
sp_ctr += 1
baf_tdc = tracker.back_and_forward(meas_screen, profile_meas, gaps,
beam_offsets, n_streaker)
bp_back_tdc = baf_tdc['beam_profile']
screen_tdc = baf_tdc['screen']
#bp_back_tdc = tracker.track_backward2(meas_screen, profile_meas, gaps, beam_offsets, n_streaker)
bp_back_tdc.plot_standard(sp_profile, norm=True, label='Use measured')
bp_back_tdc.plot_standard(sp_profile_rec, norm=True, ls='--')
mask = np.logical_and(bp_back_tdc.time > -1e-13, bp_back_tdc.time < 1e-13)
bp_back_tdc2 = tracking.BeamProfile(bp_back_tdc.time[mask],
bp_back_tdc.current[mask],
bp_back_tdc.energy_eV,
bp_back_tdc.charge)
sp_profile.legend()
for bp, label in [(best_profile, 'Use self'), (best_gauss, 'Best Gauss'),
(bp_back_tdc2, 'Use measured'),
(profile_meas, 'TDC measured')]:
wake_dict = bp.calc_wake(gaps[n_streaker], beam_offsets[n_streaker],
struct_lengths[n_streaker])
wake = wake_dict['dipole']['wake_potential']
wake_t = wake_dict['input']['charge_xx'] / c
sp_wake.plot(wake_t, wake / tracker.energy_eV * r12, label=label)
sp_wake.legend()
all_profiles.append(best_profile)
# Averaging the reconstructed profiles
all_profiles_time, all_profiles_current = [], []
for profile in all_profiles:
all_profiles_time.append(profile.time -
profile.time[np.argmax(profile.current)])
new_time = np.linspace(min(x.min() for x in all_profiles_time),
max(x.max() for x in all_profiles_time), len_profile)
for tt, profile in zip(all_profiles_time, all_profiles):
all_profiles_current.append(
np.interp(new_time, tt, profile.current, left=0, right=0))
all_profiles_current = np.array(all_profiles_current)
mean_profile = np.mean(all_profiles_current, axis=0)
std_profile = np.std(all_profiles_current, axis=0)
average_profile = tracking.BeamProfile(new_time, mean_profile, energy_eV,
charge)
average_profile.plot_standard(sp_profile_comp,
label='Reconstructed',
norm=True,
center_max=True)
ms.figure('Test averaging')
sp = plt.subplot(1, 1, 1)
for yy in all_profiles_current:
sp.plot(new_time, yy, lw=0.5)
to_plot = [
('Average', new_time, mean_profile, 'black', 3),
('+1 STD', new_time, mean_profile + std_profile, 'black', 1),
('-1 STD', new_time, mean_profile - std_profile, 'black', 1),
]
profile_meas.plot_standard(sp_profile, label='TDC', color='black', norm=True)
best_profile.plot_standard(sp_profile, norm=True, label='Use self')
color_rec = best_profile.plot_standard(sp_profile_rec, norm=True, label='%i' % distance_um)[0].get_color()
best_gauss.plot_standard(sp_profile, norm=True, label='Best Gauss')
sp_wake = subplot(sp_ctr, title='Wake effect', xlabel='t [fs]', ylabel='$\Delta$ x', scix=True, sciy=True)
sp_ctr += 1
baf_tdc = tracker.back_and_forward(meas_screen, profile_meas, gaps, beam_offsets, n_streaker)
bp_back_tdc = baf_tdc['beam_profile']
screen_tdc = baf_tdc['screen']
#bp_back_tdc = tracker.track_backward2(meas_screen, profile_meas, gaps, beam_offsets, n_streaker)
bp_back_tdc.plot_standard(sp_profile, norm=True, label='Use measured')
bp_back_tdc.plot_standard(sp_profile_rec, norm=True, ls='--')
mask = np.logical_and(bp_back_tdc.time > -1e-13, bp_back_tdc.time < 1e-13)
bp_back_tdc2 = tracking.BeamProfile(bp_back_tdc.time[mask], bp_back_tdc.current[mask], bp_back_tdc.energy_eV, bp_back_tdc.charge)
sp_profile.legend()
for bp, label in [(best_profile, 'Use self'), (best_gauss, 'Best Gauss'), (bp_back_tdc2, 'Use measured'), (profile_meas, 'TDC measured')]:
wake_dict = bp.calc_wake(gaps[n_streaker], beam_offsets[n_streaker], struct_lengths[n_streaker])
wake = wake_dict['dipole']['wake_potential']
wake_t = wake_dict['input']['charge_xx']/c
sp_wake.plot(wake_t, wake/tracker.energy_eV*r12, label=label)
sp_wake.legend()
meas_screen0.plot_standard(sp_screen, label='Measured 0')
meas_screen.plot_standard(sp_screen, label='Measured')
best_screen.plot_standard(sp_screen, label='Reconstructed')
dirname1 = '/sf/data/measurements/2020/10/03/'
dirname2 = '/sf/data/measurements/2020/10/04/'
elif hostname == 'pubuntu':
dirname1 = '/home/work/data_2020-10-03/'
dirname2 = '/home/work/data_2020-10-04/'
archiver_dir = '/home/work/'
bp_gauss = tracking.get_gaussian_profile(40e-15, 200e-15, len_profile, charge, energy_eV)
flat_current = np.zeros_like(bp_gauss.current)
flat_time = bp_gauss.time
flat_current[np.logical_and(flat_time > -40e-15, flat_time < 40e-15)] = 1
bp_flat = tracking.BeamProfile(flat_time, flat_current, energy_eV, charge)
sig = 5e-15
dhf_current = doublehornfit.DoublehornFit.fit_func(flat_time, -20e-15, 20e-15, sig, sig, sig, sig, 0.5, 1, 1)
dhf_current *= charge / dhf_current.sum()
bp_dhf = tracking.BeamProfile(flat_time, dhf_current, energy_eV, charge)
bp_dhf.cutoff(1e-3)
for bp, bp_label in [(bp_gauss, 'Gauss'), (bp_flat, 'Flat'), (bp_dhf, 'Double horn')]:
ms.figure('Test quadrupole wake %s emittance %i nm' % (bp_label, n_emittances[0]*1e9))
subplot = ms.subplot_factory(2,2)