sp_forward.set_xlim(-0.3, 1.5)
centroids = np.array(centroid_list)
centroids_sig = np.array(centroid_list_sig)
centroids_sim = np.array(c_list_sim_old)
centroids_sim_new = np.array(c_list_sim)
offsets = np.array(offsets)
order = 3
def fit_func(offsets, wall, scale):
return 1 / (offsets - wall)**order * scale
for centroid_arr, err, label in [(centroids, centroids_sig * 1e3, 'Measured'),
(centroids_sim, None, 'Simulated 1d'),
(centroids_sim_new, None, 'Simulated 2d')]:
color = sp_centroid.errorbar(offsets * 1e3,
centroid_arr * 1e3,
label=label,
yerr=err)[0].get_color()
sp_centroid.legend()
sp_summary.legend(title='d [$\mu$m]')
sp_summary.set_xlim(-0.2, 1.2)
ms.saveall('/tmp/032d', empty_suptitle=True, ending='.pdf', trim=False)
plt.show()
final_chirp_list = np.array(final_chirp_list)
outp = final_chirp_list - final_chirp_list[0]
if plot:
sp_espread_fit.plot(gap_list * 1e3, outp / 1e6, label=label)
return outp
initial_guess = -1e8 / charge_xx.max()
fit_chirp = curve_fit(fit_initial_chirp,
gap_list,
espread_fwhm_plot,
p0=[initial_guess])
fit_chirp_yy0 = fit_initial_chirp(gap_list, fit_chirp[0])
for deds in np.array([0, 0.8, 1, 1.2]) * initial_guess:
fit_chirp_yy = fit_initial_chirp(gap_list, deds, plot=True)
sp_espread_fit.errorbar(gap_list * 1e3,
espread_fwhm_plot / 1e6,
yerr=yy_err / 1e6,
label='FWHM')
sp_espread.plot(gap_list * 1e3, fit_chirp_yy0 / 1e6, label='Fit')
for sp_ in sp_wf_res, sp_wf_surface, sp_wf_res_W, sp_wf_surface_W, sp_espread, sp_gap_effect, sp_chirp:
sp_.legend()
ms.saveall('~/pcloud_share/presentations/022_uwf/011_show_all_meas',
hspace=0.4,
wspace=0.3)
plt.show()
#print(gap_mm, '%.1e' % rel_eloss)
sp_wake_functions.plot(wf_calc.xx * 1e6,
eloss_dict['single_particle_wake'] * 1e-15,
label='%.1f' % gap_mm)
sp_wake_potentials.plot(wf_calc.xx * 1e6,
eloss_dict['wake_potential'] * 1e-15,
label='%.1f' % gap_mm)
eloss_model_list = np.array(eloss_model_list)
espread_model_list = np.array(espread_model_list)
sp_eloss.plot(gap_list,
-(eloss_model_list - eloss_model_list[0]),
label='Model')
yy_model = espread_model_list - espread_model_list[0]
sp_espread.plot(gap_list, yy_model, label='Model')
sp_espread.set_ylim(-1e-4, yy_model.max() * 1.2)
sp_wake_functions.legend(title='Gap [mm]')
sp_eloss.legend(loc='upper left')
sp_espread.legend(loc='upper right')
ms.saveall('~/Dropbox/plots/006_longitudinal_measurements',
ending='.pdf',
bottom=0.15,
wspace=0.3,
top=0.85)
plt.show()
beamsize0 = screen0.rms()
centroids = np.array(centroids)
rms = np.array(rms)
for y_arr, sp, fit_func in [(centroids, sp_centroids,
fit_func_centroid),
(rms, sp_rms, fit_func_rms)]:
p0 = [order0, y_arr.max() * distances.min()**order0]
p_opt, p_cov = curve_fit(fit_func, distances, y_arr, p0)
fit_order = p_opt[0]
fit_yy = fit_func(fit_xx, *p_opt)
_label = '%s %.2f %.2f' % (profile_label, scale_factor, fit_order)
color = sp.plot(distances * 1e6,
y_arr * 1e3,
label=_label,
marker=marker,
ls='None')[0].get_color()
sp.plot(fit_xx * 1e6, fit_yy * 1e3, color=color)
sp_profile.legend(title='rms')
sp_profile.set_xlim(-100, 100)
for sp_ in sp_centroids, sp_rms:
sp_.legend(title='Scale factor, fit scaling')
ms.saveall('/tmp/055_fit_model')
plt.show()
sp_single.plot(xx_space * 1e6, single_particle_wake * 1e-15, label=label)
wake_effect = np.convolve(yy_charge, single_particle_wake)[:len(xx_space)]
#wake_effect2 = np.zeros_like(xx_space)
#for n in range(len(xx_space)):
# for n2 in range(0,n):
# wake_effect2[n] += yy_charge[n2] * single_particle_wake[n-n2]
#assert np.all(wake_effect == wake_effect2)
sp_wake_effect.semilogy(xx_space * 1e6, wake_effect * 1e-6, label=label)
sp_wake_effect2.plot(xx_space * 1e6, wake_effect * 1e-6, label=label)
q = np.sum(yy_charge)
kick_factor = np.sum(wake_effect * yy_charge) / q
kick_list.append(kick_factor)
delta_x = kick_factor * Ls * 10 / energy_eV
delta_x_list.append(delta_x)
print(gap, delta_x)
sp_delta_x.plot(offset * 1e3,
delta_x * offset * 1e6,
marker='.',
label=label)
sp_kick_factor.plot(gap_list * 1e3, np.array(kick_list) * 1e-6, marker='.')
for sp_ in sp_wake_effect, sp_single, sp_delta_x:
sp_.legend(title='Gap size [mm]')
ms.saveall(storage_dir + '/plots/wakefield', wspace=0.3)
plt.show()
fit_lin,
marker='.',
label='Linear scaling with beam offset (exp)')
sp_11.plot(model_gap * 1e3,
fudge_factor * model_lin,
marker='.',
label='Linear scaling with beam offset (model)')
sp_11.plot(fit_xx * 1e3,
second_order_fit(fit_xx, *f2_fit),
ls='--',
label='Quadratic fit to scaling')
sp_11.plot(fit_xx * 1e3,
order_fit(fit_xx, *fg_fit),
ls='--',
label='1/g^n fit to scaling with n=%.1f' % fg_fit[1])
sp_11.plot(fit_xx * 1e3,
fudge_factor * order_fit(fit_xx, *fg_model),
ls='--',
label='1/g^n fit to model scaling with n=%.1f' %
fg_model[1])
sp_11.legend()
sp_scaling.legend()
ms.saveall('~/Dropbox/plots/003_trans_wake_first_order',
ending='.pdf',
bottom=0.15,
wspace=0.3)
plt.show()
slice_time = all_slice_dict['Lasing_off']['slice_x'][mask_current]
power_from_Eloss = lasing.power_Eloss(mean_current[mask_current], delta_E)
E_total = np.trapz(power_from_Eloss, slice_time)
power_from_Espread = lasing.power_Espread(slice_time,
mean_current[mask_current],
delta_std_sq, E_total)
E_total2 = np.trapz(power_from_Espread, slice_time)
sp_lasing.plot(slice_time * 1e15,
power_from_Eloss / 1e9,
marker='.',
label='$P_m$',
color='blue')
sp_lasing.plot(slice_time * 1e15,
power_from_Espread / 1e9,
marker='.',
label='$P_\sigma$',
color='green')
print('Energy from Eloss: %i [uJ]' % (E_total * 1e6))
print('Energy from Espread: %i [uJ]' % (E_total2 * 1e6))
for sp_ in sp_current, sp_mean, sp_sigma, sp_lasing:
sp_.legend()
ms.saveall('/tmp/045f_complete', hspace=.35, ending='.pdf', wspace=.35)
ms.plt.show()
label='%i fs' % (blmeas_profile.rms() * 1e15))
sp_rms.legend(title='Gap (mm)')
sp_centroid.legend(title='Gap (mm)')
sp_profile.legend()
if gauss_kwargs['method'] in ('rms', 'beamsize'):
gap = gap_arr[np.argmin(chi_sq_rms)]
elif gauss_kwargs['method'] == 'centroid':
gap = gap_arr[np.argmin(chi_sq_centroid)]
else:
gap = gap_arr[np.argmin(opt_values)]
print('Final gap: %.3f mm' % (gap * 1e3))
sc.gap0 = gap
sc.fit_gap = False
sc.fit()
sc.plot_streaker_calib(figsize=(20, 12))
ms.plt.suptitle('Final')
offset_list, gauss_dicts = sc.reconstruct_current(tracker, gauss_kwargs)
sc.plot_reconstruction(blmeas_profile=blmeas_profile, figsize=(20, 12))
ms.plt.suptitle('Final')
ms.saveall('./album060_v2/%s_file_%i_offset_%i' %
(method, file_index, offset_index),
empty_suptitle=False)
if not args.noshow:
ms.show()
x_axis,
True,
x_offset=screen_center)
screen.cutoff2(screen_cutoff)
screen.crop()
screen.reshape(len_profile)
if offset == 0:
for sp_screen in sp_screen_pos, sp_screen_neg:
screen.plot_standard(sp_screen, label=label)
continue
elif offset > 0:
sp_screen = sp_screen_pos
elif offset < 0:
sp_screen = sp_screen_neg
color = screen.plot_standard(sp_screen, label=label)[0].get_color()
beam_offsets = [0, -(offset - streaker_center)]
forward_dict = tracker.elegant_forward(blmeas, gaps, beam_offsets)
forward_screen = forward_dict['screen']
forward_screen.plot_standard(sp_screen, color=color, ls='--')
sp_profile.legend()
sp_screen_pos.legend()
sp_screen_neg.legend()
ms.saveall('/tmp/049a_', ending='.pdf')
plt.show()
n_streaker,
10e-3,
fit_gap=True,
fit_order=False,
proj_cutoff=tracker.screen_cutoff)
for scf in streaker_calib_files:
sc.add_file(scf)
s_dict = sc.fit_type('centroid')
streaker_offset = s_dict['streaker_offset']
sc.fit_gap = False
streaker = config.streaker_names[sc.beamline][sc.n_streaker]
self = sc
gap_arr = np.arange(9.90, 10.0001, 0.01) * 1e-3
tracker.set_simulator(self.meta_data)
gauss_kwargs['n_streaker'] = self.n_streaker
gauss_kwargs['method'] = method
gauss_kwargs['sig_t_range'] = np.exp(np.linspace(np.log(10), np.log(85),
15)) * 1e-15
gap_recon_dict = sc.gap_reconstruction2(gap_arr, tracker, gauss_kwargs,
streaker_offset)
sc.plot_gap_reconstruction(gap_recon_dict, streaker_offset, figsize=(20, 16))
ms.saveall('./album061/%s_file_%i' % (method, file_index),
empty_suptitle=False)
if not args.noshow:
ms.show()
for centroid_arr, err, label in [(centroids, centroids_sig * 1e3, 'Measured'),
(centroids_sim, None, 'Simulated')]:
color = sp_centroid.errorbar(offsets * 1e3,
centroid_arr * 1e3,
label=label,
yerr=err)[0].get_color()
try:
fit, _ = curve_fit(fit_func, offsets, centroid_arr,
(gaps[1] / 2., 1e-14))
reconstruction = fit_func(offsets, *fit)
sp_centroid.plot(offsets * 1e3,
reconstruction * 1e3,
color=color,
ls='--',
label='%.4f' % (fit[0] * 1e3))
except (RuntimeError, TypeError):
print('runtimerror')
pass
sp_centroid.legend()
sp_summary.legend(title='Measured')
sp_summary.set_xlim(-0.3, 1.5)
ms.saveall('/tmp/032c', ending='.pdf', trim=False)
plt.show()
slice_sigma = arr[n_image, 2, mask]
slice_eloss = lasing_input['Lasing Off']['mean'] - slice_mean
slice_Espread_sqr_increase = slice_sigma**2 - lasing_input['Lasing Off']['sigma']**2
p_eloss = lasing.power_Eloss(curr, slice_eloss)
E_eloss = np.trapz(p_eloss, slice_time2)
p_espread = lasing.power_Espread(slice_time2, curr, slice_Espread_sqr_increase, E_norm)
sp_mean.plot(slice_time2*1e15, p_eloss/1e9)
sp_sigma.plot(slice_time2*1e15, p_espread/1e9)
for ctr, (power, error, label, color, sp2) in enumerate([
(power_mean, power_mean_err, '$P_m$', 'red', sp_mean),
(power_sigma, power_sigma_err, '$P_\sigma$', 'blue', sp_sigma),
]):
gf = gaussfit.GaussFit(slice_time2, power, fit_const=False)
label2 = label+ ' $\sigma$=%.1f fs' % (gf.sigma*1e15)
for sp_, color2, lw in [(sp_lasing, color, None), (sp2, 'black', 3)]:
sp_.errorbar(slice_time2*1e15, power/1e9, yerr=error/1e9, label=label2, color=color2, lw=lw)
sp_lasing.legend()
ms.saveall('/tmp/lasing_analysis', ending='.pdf', hspace=.35, wspace=.35)
plt.show()
for ctr, (blmeas, charge) in enumerate(meas_charge):
label = ctr
meas = data_loader.load_blmeas(data_dir + blmeas)
xx = meas['time_profile1']*c
yy = meas['current1']
sp_current.plot(xx*1e6, yy/1e3, label=label)
print(ctr, '%.1e' % np.trapz(yy, xx))
if meas['time_profile2'] is not None:
xx = meas['time_profile2']*c
yy = meas['current2']
sp_current2.plot(xx*1e6, yy/1e3, label=label)
xlim = sp_current.get_xlim()
sp_current2.set_xlim(*xlim)
sp_current.legend()
sp_current2.legend()
ms.saveall('~/pcloud_share/presentations/022_uwf/011e_plot_all_current')
plt.show()
n_streaker,
streaker_offset,
delta_gap,
tracker_kwargs,
recon_kwargs=gauss_kwargs,
charge=charge,
subtract_median=True)
rec_obj.add_dict(data_dict)
if main_ctr == 1:
rec_obj.profile = las_rec_images['Lasing Off'].profile
rec_obj.process_data()
las_rec_images[title] = rec_obj
#rec_obj.plot_images('raw', title)
rec_obj.plot_images('tE', title)
ms.saveall('./album063d/%s_imagestE' %
os.path.basename(lasing_on_file),
empty_suptitle=False)
ms.closeall()
las_rec = lasing.LasingReconstruction(las_rec_images['Lasing Off'],
las_rec_images['Lasing On'],
pulse_energy,
current_cutoff=1.0e3)
las_rec.plot()
ms.saveall('./album063d/%s_lasing' % os.path.basename(lasing_on_file),
empty_suptitle=False)
ms.closeall()
ms.show()
xlabel=xlabel,
ylabel=ylabel2)
sp_ctr += 1
conversion_factor = 1e-3 * 1e-12
for gap, wf, wf2, err2, conv1, conv2 in zip(gap_list, wf_list, wf_list2,
wf_err_list2, conv_list,
conv_list2):
label = '%.1f' % (gap * 1e3)
sp_wf.plot(s_arr * 1e6, wf * conversion_factor, label=label)
sp_wf2.errorbar(s_arr * 1e6,
wf2 * conversion_factor,
label=label,
yerr=err2 * conversion_factor)
#conv1 = uwf_model.convolve(charge_profile, wf)
sp_wf_W.plot(s_arr * 1e6, conv1 * 1e-3, label=label)
#conv2 = uwf_model.convolve(charge_profile, wf2)
sp_wf2_W.plot(s_arr * 1e6, conv2 * 1e-3, label=label)
sp_wf.legend(title='Undulator gap')
sp_wf2.legend(title='Undulator gap')
sp_wf_W.legend(title='Undulator gap')
#sp_integrand = subplot(sp_ctr,
#sp_ctr += 1
ms.saveall('~/pcloud_share/presentations/022_uwf/008_test_uwf')
plt.show()
sp_wake.plot(xx_space * 1e6, wake * 1e-15, label='%.1e' % (gap_m * 1e3))
x_list = np.array(x_list)
sp_delta_x.loglog(gap_list * 1e3, x_list * 1e3, marker='.', label='Data')
def order_func(xx, const, order):
return const / xx**order
def quad_func(xx, const):
return order_func(xx, const, 2)
for (label, func) in [('Quadratic', quad_func), ('Scaling', order_func)]:
fit = opt.curve_fit(func, gap_list, x_list)[0]
gap_plot = np.linspace(gap_list.min(), gap_list.max(), 100)
if func == order_func:
label += ' n= %.1f' % fit[1]
sp_delta_x.loglog(gap_plot * 1e3, func(gap_plot, *fit) * 1e3, label=label)
sp_wake.legend(title='Gap [mm]')
sp_delta_x.legend()
ms.saveall('~/Dropbox/plots/004_model', ending='.pdf')
plt.show()
sp_11.plot(fit_gap * 1e3,
fit_lin,
marker='.',
label='Linear scaling with beam offset (exp)')
sp_11.plot(model_gap * 1e3,
fudge_factor * model_lin,
marker='.',
label='Linear scaling with beam offset (model)')
sp_11.plot(fit_xx * 1e3,
second_order_fit(fit_xx, *f2_fit),
ls='--',
label='Quadratic fit to scaling')
sp_11.plot(fit_xx * 1e3,
order_fit(fit_xx, *fg_fit),
ls='--',
label='1/g^n fit to scaling with n=%.1f' % fg_fit[1])
sp_11.plot(fit_xx * 1e3,
fudge_factor * order_fit(fit_xx, *fg_model),
ls='--',
label='1/g^n fit to model scaling with n=%.1f' %
fg_model[1])
sp_11.legend()
sp_scaling.legend()
ms.saveall('~/Dropbox/plots/003a_dipole_model',
ending='.pdf',
bottom=0.15,
wspace=0.3)
plt.show()
def save_lasing(lasing_file):
if 'Lasing_reconstruction' in lasing_file:
return
if os.path.basename(
lasing_file
) == '2021_05_18-18_11_27_Lasing_True_SARBD02-DSCR050.h5':
return
try:
#data_dict = h5_storage.loadH5Recursive(lasing_file)
with h5py.File(lasing_file, 'r') as data_dict:
for key in 'raw_data', 'pyscan_result':
if key in data_dict:
data_dict = data_dict[key]
#data_dict = h5_storage.loadH5Recursive(lasing_snapshot)['camera1']
if 'Calibration_SARUN' in lasing_file or 'Calibration_data_SARUN' in lasing_file:
x_axis = np.array(data_dict['x_axis']).squeeze()[0, 0]
y_axis = np.array(data_dict['y_axis']).squeeze()[0, 0]
images0 = np.array(data_dict['image']).squeeze()
shape = images0.shape
images = images0.reshape(
[shape[0] * shape[1], shape[2], shape[3]])
else:
x_axis = np.array(data_dict['x_axis']).squeeze()[0]
y_axis = np.array(data_dict['y_axis']).squeeze()[0]
images = np.array(data_dict['image']).squeeze()
except KeyError:
print('Error for file %s' % os.path.basename(lasing_file))
error_files.append(lasing_file)
return
extent = (x_axis[0], x_axis[-1], y_axis[-1], y_axis[0])
sp_ctr = np.inf
image_ctr = 1
figs = []
#if True:
# image = images
# n_image = 0
for n_image, image in enumerate(images):
if sp_ctr + 1 > ny * nx:
fig = Figure(figsize=(20, 16))
plt.suptitle(os.path.basename(lasing_file) + ' %i' % image_ctr)
fig.subplots_adjust(hspace=0.4)
image_ctr += 1
sp_ctr = 1
figs.append(fig)
sp0 = subplot(sp_ctr,
title='Image %i raw' % n_image,
xlabel='x ($\mu$m)',
ylabel='y ($\mu$m)')
sp_ctr += 1
sp1 = subplot(sp_ctr,
title='Image %i processed' % n_image,
xlabel='x ($\mu$m)',
ylabel='y ($\mu$m)')
sp_ctr += 1
min_index_x = np.argwhere(x_axis0 == x_axis[0]).squeeze()
max_index_x = np.argwhere(x_axis0 == x_axis[-1]).squeeze()
min_index_y = np.argwhere(y_axis0 == y_axis[0]).squeeze()
max_index_y = np.argwhere(y_axis0 == y_axis[-1]).squeeze()
image_recover = image.copy()
mask_dest = image == 0
image_recover += bg[min_index_y:max_index_y + 1,
min_index_x:max_index_x + 1]
image_recover[mask_dest] = 0
for im, sp in [(image, sp0), (image_recover, sp1)]:
image_float = im.astype(np.float64)
image_floored = image_float - np.median(image_float)
image_floored[image_floored < 0] = 0
image_normed = image_floored / np.max(image_floored)
colors = cmap(image_normed)
colors[mask_dest] = np.array([1, 0, 0, 1])
sp.imshow(colors, extent=extent, aspect='auto')
ms.saveall('./album_2021-05-18/%s' % os.path.basename(lasing_file))
for fig in figs:
fig.close()
# sp.set_ylabel(ylabel)
# sp.grid(True)
#
#plot_handles = sp_screen, sp_profile, sp_opt, sp_moments
#
#
#
#tracker_kwargs = config.get_default_tracker_settings()
#recon_kwargs = config.get_default_gauss_recon_settings()
#tracker = tracking.Tracker(**tracker_kwargs)
#tracker.set_simulator(lasing_off_dict_fb['meta_data_begin'])
#
#index = rec_obj_fb.median_meas_screen_index
#meas_screen = rec_obj_fb.meas_screens[index]
#meas_screen.cutoff2(tracker.screen_cutoff)
#meas_screen.crop()
#meas_screen.reshape(tracker.len_screen)
#
#recon_kwargs['gaps'] = [10e-3, 10e-3+delta_gap]
#recon_kwargs['beam_offsets'] = [0., rec_obj_fb.beam_offsets[index]]
#recon_kwargs['n_streaker'] = 1
#recon_kwargs['meas_screen'] = meas_screen
#
#outp = analysis.current_profile_rec_gauss(tracker, recon_kwargs, plot_handles, blmeas_file)
if not args.noshow:
ms.show()
if args.save:
ms.saveall(args.save, hspace, wspace, ending='.pdf')
wf_dict['dipole']['single_particle_wake'].max()))
kick = wf_dict['dipole']['kick']
kick_effect = wf_dict['dipole']['kick_effect']
index0 = np.argmin(xx_plot**2)
guessed0 = np.mean(x1_mean[index0 - 1:index0 + 1])
color = sp_raw.errorbar(xx_plot, (x1_mean - guessed0) * 1e3,
yerr=x1_err * 1e3,
label=bpm).lines[0].get_color()
sp_raw.plot(beam_offset_model * 1e3,
-kick_effect * 1e3,
ls='--',
color=color)
sp_rescaled.errorbar(xx_plot, (x1_mean - guessed0) / r12,
yerr=x1_err / r12,
label=bpm)
if n_bpm == 0:
sp_rescaled.plot(beam_offset_model * 1e3,
-kick,
ls='--',
color='black',
label='Model')
for sp in sp_raw, sp_rescaled:
sp.legend(title='BPM')
ms.saveall('/tmp/005b_include_other', ending='.png', bottom=0.15, wspace=0.3)
plt.show()
sp_single.plot(xx_space * 1e6, single_particle_wake * 1e-15, label=label)
wake_effect = np.convolve(yy_charge, single_particle_wake)[:len(xx_space)]
#wake_effect2 = np.zeros_like(xx_space)
#for n in range(len(xx_space)):
# for n2 in range(0,n):
# wake_effect2[n] += yy_charge[n2] * single_particle_wake[n-n2]
#assert np.all(wake_effect == wake_effect2)
sp_wake_effect.semilogy(xx_space * 1e6, wake_effect * 1e-6, label=label)
sp_wake_effect2.plot(xx_space * 1e6, wake_effect * 1e-6, label=label)
q = np.sum(yy_charge)
kick_factor = np.sum(wake_effect * yy_charge) / q
kick_list.append(kick_factor)
delta_x = kick_factor * Ls * 10 / energy_eV
delta_x_list.append(delta_x)
print(gap, delta_x)
sp_delta_x.plot(offset * 1e3,
delta_x * offset * 1e6,
marker='.',
label=label)
#sp_kick_factor.plot(gap_list*1e3, np.array(kick_list)*1e-6, marker='.')
for sp_ in sp_wake_effect, sp_single, sp_delta_x:
sp_.legend(title='Distance [mm]')
ms.saveall('/tmp/wakefield', wspace=0.3)
plt.show()
]:
color = get_color(label)
forward_dict = tracker.elegant_forward(bp, gaps, beam_offsets)
screen = forward_dict['screen']
screen.plot_standard(sp_screen, label=label, color=color)
for profile, label in [
(profile_meas, 'TDC measured'),
(profile_gauss, 'Gaussian'),
(bp_back, 'Back 1, using Gauss'),
(bp_back2, 'Back 2, using 1'),
#(bp_back3, 'Back 3, using 2'),
#(bp_back4, 'Back 4, using 3'),
]:
color = get_color(label)
if profile is profile_meas:
ls = '--'
else:
ls = None
profile.plot_standard(sp_profile, label=label, color=color, ls=ls)
sp_profile.legend()
sp_screen.legend()
sp_screen.set_xlim(-2.2, 0.3)
ms.saveall('/tmp/for_spie', hspace=0.35, ending='.pdf', trim=False)
plt.show()
sp.tick_params(axis='y', labelsize=fs_label)
for sp in bpm_sp_dict2.values():
sp.set_xlim(-5, 5)
sp.set_ylim(-0.2, 0.2)
offset_arr = np.array(offset_list) * 1e3
ms.figure('Summary')
subplot = ms.subplot_factory(1, 1)
sp = subplot(1,
title='Summary',
xlabel='Gap',
ylabel='Structure offset fit [$\mu$m]')
labelled_ctrs = set()
for gap, offset, bpm, bpm_ctr in zip(gap_list, offset_arr, bpm_plot_list,
bpm_plot_ctr_list):
if bpm_ctr not in labelled_ctrs:
label = bpm
labelled_ctrs.add(bpm_ctr)
else:
label = None
sp.scatter(gap, offset, color=ms.colorprog(bpm_ctr, bpm_list), label=label)
sp.axhline(offset_arr.mean(), color='black', ls='--')
sp.legend()
ms.saveall('/tmp/offset_for_paper', ending='.pdf')
plt.show()
color=color,
label=label)
gauss_dict = tracker.find_best_gauss(sig_t_range, tt_halfrange,
median_screen, gaps, beam_offsets,
n_streaker, charge)
bp_recon = gauss_dict['reconstructed_profile']
#scale_dict = tracker.scale_existing_profile(
screen_recon = gauss_dict['reconstructed_screen_no_smoothen']
screen_recon.smoothen(smoothen)
screen_recon.cutoff(screen_cutoff)
bp_recon.plot_standard(sp_recon, label=label, center=center)
#bp_recon.plot_standard(sp_tdc_meas, color=color, center=center, ls='--')
screen_recon.plot_standard(sp_recon_screen, label=label)
print('Difference for %s recon: %e' %
(label, median_screen.compare(screen_recon)))
all_screens['%s_recon' % label] = screen_recon
sp_backtrack_tdc_screen.legend()
sp_tdc_meas.legend()
sp_recon.legend()
sp_recon_screen.legend()
sp_back_forward.legend()
ms.saveall('/tmp/plot_for_paper', hspace=0.3, wspace=0.3)
plt.show()
sp_Wake.plot(wake_effect['t'] * 1e15, wake_effect['x'] * 1e3, label=label)
screen = tracker.matrix_forward(p, gaps, beam_offsets)['screen']
sp_screen.plot(screen.x * 1e3,
screen.intensity / screen.integral,
label=label)
bp_recon = tracker.track_backward(meas_screen, wake_effect)
sp_recon.plot(bp_recon.time * 1e15,
bp_recon.current / bp_recon.integral,
label=label + '/ %i' % (bp_recon.gaussfit.sigma * 1e15))
if True:
screen_forward = tracker.matrix_forward(bp_recon, gaps,
beam_offsets)['screen']
sp_screen.plot(screen_forward.x * 1e3,
screen_forward.intensity / screen_forward.integral,
label=label + ' rec',
ls='--')
sp_screen.set_ylim(0, 2e3)
sp_profile0.legend(title='Duration [fs]')
sp_screen.legend()
sp_Wake.legend()
sp_recon.legend(title='Duration [fs]')
ms.saveall('./group_metting_2020-11-17/explain')
plt.show()
