def reconstruct_all_lasing(self):
self.clear_all_lasing_plots()
screen_x0 = self.screen_x0
beamline, n_streaker = self.beamline, self.n_streaker
charge = self.charge
streaker_offset = self.streaker_means[n_streaker]
delta_gap = self.delta_gaps[n_streaker]
pulse_energy = float(self.LasingEnergyInput.text()) * 1e-6
slice_factor = int(self.LasingReconstructionSliceFactor.text())
file_on = self.LasingOnDataLoad.text()
file_off = self.LasingOffDataLoad.text()
lasing_off_dict = h5_storage.loadH5Recursive(file_off)
lasing_on_dict = h5_storage.loadH5Recursive(file_on)
tracker_kwargs = self.get_tracker_kwargs()
recon_kwargs = self.get_gauss_kwargs()
las_rec_images = {}
for main_ctr, (data_dict,
title) in enumerate([(lasing_off_dict, 'Lasing Off'),
(lasing_on_dict, 'Lasing On')]):
rec_obj = lasing.LasingReconstructionImages(
screen_x0,
beamline,
n_streaker,
streaker_offset,
delta_gap,
tracker_kwargs,
recon_kwargs=recon_kwargs,
charge=charge,
subtract_median=True,
slice_factor=slice_factor)
rec_obj.add_dict(data_dict)
if main_ctr == 1:
rec_obj.profile = las_rec_images['Lasing Off'].profile
rec_obj.ref_slice_dict = las_rec_images[
'Lasing Off'].ref_slice_dict
rec_obj.process_data()
las_rec_images[title] = rec_obj
#rec_obj.plot_images('raw', title)
#rec_obj.plot_images('tE', title)
las_rec = lasing.LasingReconstruction(las_rec_images['Lasing Off'],
las_rec_images['Lasing On'],
pulse_energy,
current_cutoff=1.5e3)
las_rec.plot(plot_handles=self.all_lasing_plot_handles)
self.all_lasing_canvas.draw()
def analyze_screen_calibration(filename_or_dict, do_plot=True, plot_handles=None):
if type(filename_or_dict) is dict:
data_dict = filename_or_dict
elif type(filename_or_dict) is str:
data_dict = h5_storage.loadH5Recursive(filename_or_dict)
else:
raise ValueError(type(filename_or_dict))
screen_data = data_dict['pyscan_result']
if 'x_axis_m' in screen_data:
x_axis = screen_data['x_axis_m']
else:
#print(screen_data['x_axis'].shape)
x_axis = screen_data['x_axis'].squeeze()*1e-6
if len(x_axis.shape) == 2:
x_axis = x_axis[0]
assert len(x_axis.squeeze().shape) == 1
if 'projx' in screen_data:
projx = screen_data['projx']
else:
images = screen_data['image'].astype(float).squeeze()
projx = images.sum(axis=-2)
all_mean = []
all_std = []
for proj in projx:
gf = gaussfit.GaussFit(x_axis, proj)
all_mean.append(gf.mean)
all_std.append(gf.sigma)
index_median = np.argsort(all_mean)[len(all_mean)//2]
projx_median = projx[index_median]
beamsize = np.mean(all_std)
projx_median -= projx_median.min()
x0 = gaussfit.GaussFit(x_axis, projx_median).mean
output = {
'raw_data': data_dict,
'x0': x0,
'beamsize': beamsize,
}
if not do_plot:
return output
if plot_handles is None:
fig, (sp_proj,) = screen_calibration_figure()
else:
(sp_proj, ) = plot_handles
for proj in projx:
sp_proj.plot(x_axis*1e3, proj-proj.min())
sp_proj.plot(x_axis*1e3, projx_median-projx_median.min(), lw=3)
sp_proj.axvline(x0*1e3)
return output
def load_calibration(self):
self.clear_calib_plots()
filename = self.LoadCalibrationFilename.text().strip()
saved_dict = h5_storage.loadH5Recursive(filename)
if 'raw_data' in saved_dict:
saved_dict = saved_dict['raw_data']
full_dict = self._analyze_streaker_calib(saved_dict)
streaker_offset = full_dict['meta_data']['streaker_offset']
self.updateStreakerCenter(streaker_offset)
#self.tabWidget.setCurrentIndex(self.streaker_calib_plot_tab_index)
if self.streaker_calib_canvas is not None:
self.streaker_calib_canvas.draw()
def streaker_set(self):
widgets = (self.SetStreakerDirectCheck, self.SetStreakerFromLiveCheck,
self.SetStreakerSaveCheck)
self._check_check(widgets, 'Check set streaker checkmarks')
if self.SetStreakerDirectCheck.isChecked():
meta_dict = None
elif self.SetStreakerFromLiveCheck.isChecked():
self.obtain_streaker_settings_from_live()
if daq is None:
raise RuntimeError('Cannot get settings from live!')
meta_dict = daq.get_meta_data(self.screen)
elif self.SetStreakerSaveCheck:
filename = self.ReconstructionDataLoad.text().strip()
dict_ = h5_storage.loadH5Recursive(filename)
if 'meta_data' in dict_:
meta_dict = dict_['meta_data']
elif 'meta_data_end' in dict_:
meta_dict = dict_['meta_data_end']
if meta_dict is not None:
streaker_dict = config.streaker_names[self.beamline]
for n_streaker, gap_widget, offset_widget in [
(0, self.StreakerGap0, self.StreakerOffset0),
(1, self.StreakerGap1, self.StreakerOffset1),
]:
streaker = streaker_dict[n_streaker]
offset_mm = meta_dict[streaker + ':CENTER']
gap_mm = meta_dict[streaker + ':GAP']
if offset_mm < .01 * gap_mm / 2:
offset_mm = 0
gap_widget.setText('%.4f' % gap_mm)
offset_widget.setText('%.4f' % offset_mm)
gaps = [
float(self.StreakerGap0.text()) * 1e-3,
float(self.StreakerGap1.text()) * 1e-3
]
# beam offset is negative of streaker offset
streaker_offsets = self.streaker_offsets
print('Streaker is set: gaps: %s, offsets: %s' %
(gaps, streaker_offsets))
return gaps, streaker_offsets
def gap_reconstruction(self):
self.clear_gap_recon_plots()
filename = self.LoadCalibrationFilename.text().strip()
saved_dict = h5_storage.loadH5Recursive(filename)
if 'raw_data' in saved_dict:
saved_dict = saved_dict['raw_data']
tracker = self.get_tracker(saved_dict['meta_data_begin'])
gauss_kwargs = self.get_gauss_kwargs()
gap_recon_dict = sc.reconstruct_gap(
saved_dict,
tracker,
gauss_kwargs,
plot_handles=self.gap_recon_plot_handles)
n_streaker = gap_recon_dict['n_streaker']
delta_gap = gap_recon_dict['delta_gap']
gap = gap_recon_dict['gap']
self.updateDeltaGap(delta_gap, n_streaker)
print('Reconstructed gap: %.3f mm' % (gap * 1e3))
self.gap_recon_canvas.draw()
import image_and_profile as iap
from h5_storage import loadH5Recursive
import elegant_matrix
import misc
import myplotstyle as ms
ms.plt.close('all')
archiver_dir = '/mnt/data/archiver_api_data/'
data_dir = '/mnt/data/data_2021-03-16/'
x0 = 0.0005552048387736093
lasing_on_file = data_dir + '20210316_202944_SARBD02-DSCR050_camera_snapshot.h5'
lasing_off_file = data_dir + '20210316_204139_SARBD02-DSCR050_camera_snapshot.h5'
lasing_on = loadH5Recursive(lasing_on_file)
lasing_off = loadH5Recursive(lasing_off_file)
x_axis = lasing_on['camera1']['x_axis'].astype(float) * 1e-6 - x0
y_axis = lasing_on['camera1']['y_axis'].astype(float) * 1e-6
image_on = lasing_on['camera1']['image'].astype(float)
image_off = lasing_off['camera1']['image'].astype(float)
if x_axis[1] < x_axis[0]:
x_axis = x_axis[::-1]
image_on = image_on[:, ::-1]
image_off = image_off[:, ::-1]
if y_axis[1] < y_axis[0]:
y_axis = y_axis[::-1]
def loadH5Recursive2(path):
return loadH5Recursive(
os.path.join(storage_dir + 'data_2020-02-03/',
os.path.basename(path)))
elif hostname == 'pc11292.psi.ch':
data_dir = '/sf/data/measurements/2021/05/19/'
elif hostname == 'pubuntu':
data_dir = '/mnt/data/data_2021-05-19/'
data_dir1 = data_dir.replace('19', '18')
tracker_kwargs = config.get_default_tracker_settings()
tracker_kwargs['len_screen'] = 1000
tracker_kwargs['n_particles'] = int(50e3)
recon_kwargs = config.get_default_gauss_recon_settings()
tracker = tracking.Tracker(**tracker_kwargs)
#data_file = data_dir+'2021_05_19-14_49_38_Lasing_False_SARBD02-DSCR050.h5'
#data_file = data_dir + '2021_05_19-14_24_05_Calibration_SARUN18-UDCP020.h5'
data_file = data_dir1 + '2021_05_18-23_07_20_Calibration_SARUN18-UDCP020.h5'
data_dict = h5_storage.loadH5Recursive(data_file)
raw_data = data_dict['raw_data']
meta_data = data_dict['meta_data']
offset_index = -1
gaps = [10e-3, 9.94e-3]
streaker_offset = 372e-6
beam_offsets = [0, -(meta_data['offsets'][offset_index] - streaker_offset)]
tracker.set_simulator(raw_data['meta_data_begin'])
projx = raw_data['pyscan_result']['image'][offset_index].astype(
np.float64).sum(axis=-2)
x_axis = raw_data['pyscan_result']['x_axis_m']
dirname1 = '/storage/data_2021-05-18/'
dirname2 = '/storage/data_2021-05-19/'
elif hostname == 'pc11292.psi.ch':
dirname1 = '/sf/data/measurements/2021/05/18/'
dirname2 = '/sf/data/measurements/2021/05/19/'
elif hostname == 'pubuntu':
dirname1 = '/home/work/data_2021-05-18/'
dirname2 = '/home/work/data_2021-05-19/'
with open('./bytes.pkl', 'rb') as f:
bytes = pickle.load(f)
arr0 = np.frombuffer(bytes, dtype=np.uint16)
bg = arr0.reshape([2160, 2560])
empty_snapshot = dirname2 + '20210519_121718_SARBD02-DSCR050_camera_snapshot.h5'
image_dict = h5_storage.loadH5Recursive(empty_snapshot)
x_axis0 = image_dict['camera1']['x_axis']
y_axis0 = image_dict['camera1']['y_axis']
lasing_files = glob.glob(dirname1 + '2021_*Lasing_*SARBD02*.h5')
lasing_files += glob.glob(dirname1 + '*Calibration*.h5')
ny, nx = 4, 4
subplot = ms.subplot_factory(ny, nx, grid=False)
cmap = cm.get_cmap('viridis', 12)
lasing_snapshot = dirname1 + '20210518_233946_SARBD02-DSCR050_camera_snapshot.h5'
error_files = []
for p in blmeas_profile1, blmeas_profile2:
p.cutoff2(5e-2)
p.crop()
p.reshape(int(1e3))
n_streaker = 1
screen_x0 = 4250e-6
tracker_kwargs = config.get_default_tracker_settings()
kwargs_recon = config.get_default_gauss_recon_settings()
kwargs_recon['delta_gap'] = [0, -62e-6]
streaker_offsets = [0., 374e-6]
lasing_off_dict = h5_storage.loadH5Recursive(lasing_off_file)
lasing_on_dict = h5_storage.loadH5Recursive(lasing_on_file)
ms.figure('Comparison Lasing On / Off')
subplot = ms.subplot_factory(2, 2)
sp_ctr = 1
sp_screen_comp = subplot(sp_ctr,
title='Measured projections',
xlabel='x (mm)',
ylabel='Intensity (arb. units)')
sp_ctr += 1
sp_profile_comp = subplot(sp_ctr,
title='Reconstructed profiles',
xlabel='x (mm)',
ylabel='I (kA)')
(2, gap_file2, (sp_x4, sp_x3)),
]:
for gap, files in gap_file:
if not files:
continue
xx_list = []
bpm1_list = []
bpm2_list = []
for file_ in files:
if socket.gethostname() == 'desktop':
file_ = os.path.join('/storage/data_2020-02-03',
os.path.basename(file_))
dict_ = loadH5Recursive(file_)
bpm_data1 = dict_['scan 1']['data']['SARBD02-DBPM040']['X1']
bpm_data2 = dict_['scan 1']['data']['SARBD02-DBPM010']['X1']
bpm1_list.append(bpm_data1)
bpm2_list.append(bpm_data2)
xx = dict_['scan 1']['method']['actuators']['SARUN18-UDCP%i00' %
gapnum]['CENTER']
xx_list.append(xx)
len2 = sum(x.shape[-1] for x in bpm1_list)
bpm1_data = np.zeros((len(xx_list[0]), len2))
bpm2_data = bpm1_data.copy()
blmeas_file = data_dir1 + '119325494_bunch_length_meas.h5'
blmeas_profile = iap.profile_from_blmeas(blmeas_file,
gauss_kwargs['tt_halfrange'],
gauss_kwargs['charge'], 0, True)
blmeas_profile.cutoff2(0.03)
blmeas_profile.crop()
blmeas_profile.reshape(1000)
ms.figure('Resolution', figsize=(10, 8))
ms.plt.subplots_adjust(hspace=0.4, wspace=0.8)
subplot = ms.subplot_factory(2, 3, grid=False)
sp_ctr = 1
image_file = data_dir1 + '2021_05_18-21_02_13_Lasing_False_SARBD02-DSCR050.h5'
image_dict = h5_storage.loadH5Recursive(image_file)
meta_data1 = image_dict['meta_data_begin']
screen_calib_file = data_dir1 + '2021_05_18-16_39_27_Screen_Calibration_SARBD02-DSCR050.h5'
screen_calib_dict = h5_storage.loadH5Recursive(screen_calib_file)
screen_calib_raw_image = screen_calib_dict['pyscan_result']['image'][0].astype(
float)
x_axis_calib = screen_calib_dict['pyscan_result']['x_axis_m']
screen_x0 = gaussfit.GaussFit(x_axis_calib,
screen_calib_raw_image.sum(axis=0)).mean
x_axis_calib -= screen_x0
y_axis_calib = screen_calib_dict['pyscan_result']['y_axis_m']
screen_calib_raw_image -= np.median(screen_calib_raw_image)
screen_calib_image = iap.Image(screen_calib_raw_image, x_axis_calib,
y_axis_calib)
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
#import analysis
import gaussfit
from h5_storage import loadH5Recursive
import myplotstyle as ms
plt.close('all')
filename = '/tmp/2021_03_16-20_22_26_Screen_data_SARBD02-DSCR050.h5'
dict_ = loadH5Recursive(filename)
ms.figure('Images')
subplot = ms.subplot_factory(3,3, grid=False)
sp_ctr = 1
sp_proj_x = subplot(sp_ctr, title='X')
sp_ctr += 1
sp_proj_y = subplot(sp_ctr, title='Y')
sp_ctr += 1
x_axis = dict_['pyscan_result']['x_axis'].astype(float)
y_axis = dict_['pyscan_result']['y_axis'].astype(float)
hostname = socket.gethostname()
if hostname == 'desktop':
save_directory = '/storage/data_2020-07-26/'
other = '/storage/data_2020-10-04/20201004_175405_undulator_wf.h5'
magnet_file = '/storage/Philipp_data_folder/archiver_api_data/2020-07-26.h5'
else:
save_directory = '/sf/data/measurements/2020/07/26/'
other = '/sf/data/measurements/2020/10/04/20201004_175405_undulator_wf.h5'
magnet_file = '/afs/psi.ch/intranet/SF/Beamdynamics/Philipp/data/archiver_api_data/2020-07-26.h5'
simulator = elegant_matrix.get_simulator(magnet_file)
timestamp = elegant_matrix.get_timestamp(2020, 7, 26, 17, 49, 0)
mat_dict, disp_dict = simulator.get_elegant_matrix(0, timestamp)
r12 = mat_dict['SARBD02.DSCR050'][0, 1]
other_dict = loadH5Recursive(other)
x_axis = other_dict['x_axis'].astype(np.float64) * 1e-6
y_axis = other_dict['y_axis'].astype(np.float64) * 1e-6
del other, other_dict
### Generate Gaussian beam to calculate initial wake potential
# approximate 40 fs beam
sig_t = 40e-15
time = np.linspace(0., 400e-15, 1000)
curr = np.exp(-(time - np.mean(time))**2 / (2 * sig_t**2))
curr[curr < 0.001 * curr.max()] = 0
curr = curr * 200e-12 / np.sum(curr)
wf_calc = wf_model.WakeFieldCalculator(time * c, curr, energy_eV, 1.)
import matplotlib.pyplot as plt
import socket
import h5_storage
import analysis
plt.close('all')
hostname = socket.gethostname()
if 'psi' in hostname or 'lc6a' in hostname or 'lc7a' in hostname:
default_dir = '/sf/data/measurements/2021/04/25/'
archiver_dir = '/afs/psi.ch/intranet/SF/Beamdynamics/Philipp/data/archiver_api_data/'
elif hostname == 'desktop':
default_dir = '/storage/data_2021-04-25/'
archiver_dir = '/storage/Philipp_data_folder/archiver_api_data/'
elif hostname == 'pubuntu':
default_dir = '/home/work/data_2021-04-25/'
archiver_dir = '/home/work/archiver_api_data/'
streaker_calib_file = default_dir + '2021_04_25-16_55_25_Calibration_SARUN18-UDCP020.h5'
data_dict = h5_storage.loadH5Recursive(streaker_calib_file)
analysis.analyze_streaker_calibration(data_dict['raw_data'])
plt.show()
archiver_dir = '/storage/Philipp_data_folder/'
elif hostname == 'pc11292.psi.ch':
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/'
magnet_file = archiver_dir + 'archiver_api_data/2020-10-03.h5'
blmeas38 = dirname1 + '129833611_bunch_length_meas.h5'
file0 = dirname1 + 'Passive_data_20201003T231958.mat'
dict0 = loadH5Recursive(file0 + '.h5')
subtract_min = True
def get_screen_from_proj(projX, x_axis, invert_x):
if invert_x:
xx, yy = (x_axis[::-1]).copy(), (projX[::-1]).copy()
else:
xx, yy = x_axis.copy(), projX.copy()
if subtract_min:
yy -= yy.min()
screen = tracking.ScreenDistribution(xx, yy)
screen.normalize()
screen.cutoff(screen_cutoff)
screen.reshape(len_profile)
lasing_on_files = [x[-1] for x in all_files if 'Lasing_True' in x[-1]]
lasing_off_files = []
for file1 in lasing_on_files:
for _a1, _a2, _a3, file2 in all_files:
if file2 == file1:
a1, a2, a3 = _a1, _a2, _a3
break
for _a1, _a2, _a3, file2 in all_files:
if (_a1, _a2, _a3) == (a1, a2, a3) and file1 != file2:
lasing_off_files.append(file2)
break
streaker_calib_file = data_dir1 + '/2021_05_18-22_11_36_Calibration_SARUN18-UDCP020.h5'
streaker_calib = h5_storage.loadH5Recursive(streaker_calib_file)['raw_data']
tracker_kwargs = config.get_default_tracker_settings()
gauss_kwargs = config.get_default_gauss_recon_settings()
charge = 200e-12
if False:
tracker = tracking.Tracker(**tracker_kwargs)
tracker.set_simulator(streaker_calib['meta_data_begin'])
calib_dict = streaker_calibration.reconstruct_gap(streaker_calib, tracker,
gauss_kwargs, charge)
streaker_offset = calib_dict['streaker_offset']
screen_x0_arr = calib_dict['screen_x0']
screen_x0 = screen_x0_arr[0]
delta_gap = calib_dict['delta_gap']
else:
delta_gap = 9.9929e-3 - 10e-3
def reconstruct_lasing(file_or_dict_on, file_or_dict_off, screen_center, structure_center, structure_length, file_current, r12, disp, energy_eV, charge, streaker, plot_handles, pulse_energy, n_slices, len_profile):
if type(file_or_dict_on) is dict:
dict_on = file_or_dict_on
else:
dict_on = h5_storage.loadH5Recursive(file_or_dict_on)
dict_on_p = dict_on['pyscan_result']
dict_on_m = dict_on['meta_data_end']
if type(file_or_dict_off) is dict:
dict_off = file_or_dict_off
else:
dict_off = h5_storage.loadH5Recursive(file_or_dict_off)
dict_off_p = dict_off['pyscan_result']
dict_off_m = dict_off['meta_data_end']
if energy_eV == 'file':
if 'SARBD01-MBND100:ENERGY-OP' in dict_on_m:
energy_eV = dict_on_m['SARBD01-MBND100:ENERGY-OP']*1e6
elif 'SARBD01-MBND100:P-SET' in dict_on_m:
energy_eV = dict_on_m['SARBD01-MBND100:P-SET']*1e6
else:
raise ValueError('No energy saved!')
input_dict = {
'file_or_dict_on': file_or_dict_on,
'file_or_dict_off': file_or_dict_off,
'screen_center': screen_center,
'structure_center': structure_center,
'structure_length': structure_length,
'file_current': file_current,
'r12': r12,
'disp': disp,
'energy_eV': energy_eV,
'charge': charge,
'streaker': streaker,
'pulse_energy': pulse_energy,
}
gaps, beam_offsets = [], []
for dict_ in dict_off_m, dict_on_m:
gaps.append(dict_[streaker+':GAP']*1e-3)
beam_offsets.append(-(dict_[streaker+':CENTER']*1e-3-structure_center))
if abs(gaps[0] - gaps[1]) > 1e-6:
print('Gaps not the same!', gaps)
if abs(beam_offsets[0] - beam_offsets[1]) > 1e-6:
print('Beam offsets not the same!', beam_offsets)
gap = np.mean(gaps)
beam_offset = np.mean(beam_offsets)
if pulse_energy is None:
try:
pulse_energy = dict_on_m[config.gas_monitor_pvs['Aramis']]*1e-6
except KeyError:
print('No pulse energy found! Use 100 uJ')
pulse_energy = 100e-6
images0 = dict_off_p['image'].astype(np.float64)
images0_on = dict_on_p['image'].astype(np.float64)
if 'x_axis_m' in dict_off_p:
x_axis0 = dict_off_p['x_axis_m'].astype(np.float64)
y_axis0 = dict_off_p['y_axis_m'].astype(np.float64)
else:
x_axis0 = dict_off_p['x_axis'].astype(np.float64)
y_axis0 = dict_off_p['y_axis'].astype(np.float64)
projx0 = images0.sum(axis=-2)
median_index = misc.get_median(projx0, output='index')
median_image_off = iap.Image(images0[median_index], x_axis0, y_axis0, x_offset=screen_center)
projx0_on = images0_on.sum(axis=-2)
median_index = misc.get_median(projx0_on, output='index')
median_image_on = iap.Image(images0_on[median_index], x_axis0, y_axis0, x_offset=screen_center)
current_dict = h5_storage.loadH5Recursive(file_current)
if 'gaussian_reconstruction' in current_dict:
wake_profile_dict = current_dict['gaussian_reconstruction']['reconstructed_profile']
wake_profile = iap.BeamProfile.from_dict(wake_profile_dict)
else:
wake_profile = iap.profile_from_blmeas(current_dict, 200e-15, charge, energy_eV, True)
wake_profile.cutoff2(0.1)
wake_profile.crop()
wake_profile.reshape(len_profile)
wake_t, wake_x = wake_profile.get_x_t(gap, beam_offset, structure_length, r12)
lasing_dict = lasing.obtain_lasing(median_image_off, median_image_on, n_slices, wake_x, wake_t, len_profile, disp, energy_eV, charge, pulse_energy=pulse_energy, debug=False)
if plot_handles is None:
plot_handles = lasing_figures()
(fig, (sp_profile, sp_wake, sp_off, sp_on, sp_off_cut, sp_on_cut, sp_off_tE, sp_on_tE)) = plot_handles[0]
(fig, (sp_power, sp_current, sp_centroid, sp_slice_size)) = plot_handles[1]
slice_time = lasing_dict['slice_time']
all_slice_dict = lasing_dict['all_slice_dict']
power_from_Eloss = lasing_dict['power_Eloss']
power_from_Espread = lasing_dict['power_Espread']
sp_current.plot(slice_time*1e15, all_slice_dict['Lasing_off']['slice_current'], label='Off')
sp_current.plot(slice_time*1e15, all_slice_dict['Lasing_on']['slice_current'], label='On')
lasing_dict['all_images']['Lasing_off']['image_tE'].plot_img_and_proj(sp_off_tE)
lasing_dict['all_images']['Lasing_on']['image_tE'].plot_img_and_proj(sp_on_tE)
lasing_dict['all_images']['Lasing_off']['image_cut'].plot_img_and_proj(sp_off_cut)
lasing_dict['all_images']['Lasing_on']['image_cut'].plot_img_and_proj(sp_on_cut)
for key, sp_tE in [('Lasing_off',sp_off_tE), ('Lasing_on',sp_on_tE)]:
slice_sigma = all_slice_dict[key]['slice_sigma']
slice_centroid = all_slice_dict[key]['slice_mean']
sp_slice_size.plot(slice_time*1e15, slice_sigma/1e6, label=key)
sp_centroid.plot(slice_time*1e15, slice_centroid/1e6, label=key)
lims = sp_tE.get_ylim()
sp_tE.errorbar(slice_time*1e15, slice_centroid/1e6, yerr=slice_sigma/1e6, ls='None', marker='+', color='red')
sp_tE.set_ylim(*lims)
sp_power.plot(slice_time*1e15, power_from_Eloss/1e9, label='$\Delta$E')
sp_power.plot(slice_time*1e15, power_from_Espread/1e9, label='$\Delta\sigma_E$')
sp_current.legend()
sp_power.legend()
sp_slice_size.legend()
sp_centroid.legend()
median_image_off.plot_img_and_proj(sp_off)
median_image_on.plot_img_and_proj(sp_on)
sp_wake.plot(wake_t*1e15, wake_x*1e3)
wake_profile.plot_standard(sp_profile)
if type(input_dict['file_or_dict_on']) is dict:
del input_dict['file_or_dict_on']
if type(input_dict['file_or_dict_off']) is dict:
del input_dict['file_or_dict_off']
output = {
'input': input_dict,
'lasing_dict': lasing_dict,
}
#import pdb; pdb.set_trace()
return output
len_profile = int(2e3)
data_files = [data_dir + os.path.basename(x) for x in data_files0]
#Lasing off
lasing_off_file0 = '/sf/data/measurements/2021/03/16/2021_03_16-20_42_57_Screen_data_SARBD02-DSCR050.h5'
lasing_off_file = data_dir + os.path.basename(lasing_off_file0)
median_indices = OrderedDict()
median_images = OrderedDict()
full_slice_dict = OrderedDict()
for ctr, (data_file, label) in enumerate([(lasing_off_file, 'Lasing Off'),
(data_files[-1], 'Lasing On')]):
data_dict = loadH5Recursive(data_file)
images = data_dict['pyscan_result']['image'].astype(np.float64)
x_axis = data_dict['pyscan_result']['x_axis'].astype(np.float64)
y_axis = data_dict['pyscan_result']['y_axis'].astype(np.float64)
projx = images.sum(axis=-2)
median_index = misc.get_median(projx, output='index')
median_indices[label] = median_index
print(label, median_index)
sp_ctr = np.inf
ny, nx = 3, 3
subplot = ms.subplot_factory(ny, nx)
full_slice_dict[label] = np.zeros([len(images), 5, n_slices])
def reconstruct_current(data_file_or_dict, n_streaker, beamline, tracker_kwargs_or_tracker, rec_mode, kwargs_recon, screen_x0, streaker_centers, blmeas_file=None, plot_handles=None, do_plot=True):
if type(tracker_kwargs_or_tracker) is dict:
tracker = tracking.Tracker(**tracker_kwargs_or_tracker)
elif type(tracker_kwargs_or_tracker) is tracking.Tracker:
tracker = tracker_kwargs_or_tracker
else:
raise ValueError(type(tracker_kwargs_or_tracker))
if type(data_file_or_dict) is dict:
screen_data = data_file_or_dict
else:
screen_data = h5_storage.loadH5Recursive(data_file_or_dict)
if 'meta_data' in screen_data:
meta_data = screen_data['meta_data']
elif 'meta_data_begin' in screen_data:
meta_data = screen_data['meta_data_begin']
else:
print(screen_data.keys())
raise ValueError
if 'pyscan_result' in screen_data:
pyscan_data = screen_data['pyscan_result']
else:
pyscan_data = screen_data
x_axis = pyscan_data['x_axis_m']
projx = pyscan_data['image'].sum(axis=-2)
if rec_mode == 'Median':
median_projx = misc.get_median(projx)
proj_list = [median_projx]
elif rec_mode == 'All':
proj_list = projx
tracker.set_simulator(meta_data)
if x_axis[1] < x_axis[0]:
revert = True
x_axis = x_axis[::-1]
else:
revert = False
output_dicts = []
for proj in proj_list:
if revert:
proj = proj[::-1]
meas_screen = tracking.ScreenDistribution(x_axis, proj)
kwargs_recon['meas_screen'] = meas_screen
#print('Analysing reconstruction')
kwargs = copy.deepcopy(kwargs_recon)
gaps, streaker_offsets = get_gap_and_offset(meta_data, beamline)
kwargs['meas_screen']._xx = kwargs['meas_screen']._xx - screen_x0
kwargs['beam_offsets'] = -(streaker_offsets - streaker_centers)
kwargs['gaps'] = gaps
kwargs['meas_screen'].cutoff2(tracker.screen_cutoff)
kwargs['meas_screen'].crop()
kwargs['meas_screen'].reshape(tracker.len_screen)
kwargs['n_streaker'] = n_streaker
# Only allow one streaker at the moment
for n in (0,1):
if n != kwargs['n_streaker']:
kwargs['beam_offsets'][n] = 0
gauss_dict = current_profile_rec_gauss(tracker, kwargs, plot_handles, blmeas_file, do_plot=do_plot)
output_dict = {
'input': {
'data_file_or_dict': data_file_or_dict,
'n_streaker': n_streaker,
'beamline': beamline,
'tracker_kwargs': tracker_kwargs_or_tracker,
'rec_mode': rec_mode,
'kwargs_recon': kwargs_recon,
'screen_x0': screen_x0,
'streaker_centers': streaker_centers,
'blmeas_file': blmeas_file,
},
'gauss_dict': gauss_dict,
}
output_dicts.append(output_dict)
if rec_mode == 'Median':
return output_dict
elif rec_mode == 'All':
return output_dicts
else:
print(rec_mode)
import matplotlib.pyplot as plt
import h5_storage
import analysis
plt.close('all')
file_on = '/sf/data/measurements/2021/05/18/2021_05_18-18_13_33_Lasing_True_SARBD02-DSCR050.h5'
file_off = '/sf/data/measurements/2021/05/18/2021_05_18-18_27_23_Lasing_False_SARBD02-DSCR050.h5'
dict_on = h5_storage.loadH5Recursive(file_on)
energy_eV = dict_on['meta_data_end']['SARBD01-MBND100:ENERGY-OP'] * 1e6
screen_center = 900e-6
structure_center = 370e-6
structure_length = 1
file_current = '/sf/data/measurements/2021/05/18/2021_05_18-19_26_41_PassiveReconstruction.h5'
r12 = 7.130170460315602
disp = 0.439423807827296
streaker = 'SARUN18-UDCP020'
pulse_energy = 600e-6
charge = 200e-12
obj = analysis.Reconstruction(screen_center, [0, structure_center])
analysis.reconstruct_lasing(file_on, file_off, screen_center, structure_center,
structure_length, file_current, r12, disp,
energy_eV, charge, streaker, None, pulse_energy)
5.06: '/sf/data/measurements/2021/04/25/2021_04_25-17_16_30_Lasing_False_SARBD02-DSCR050.h5',
5.04: '/sf/data/measurements/2021/04/25/2021_04_25-17_33_31_Lasing_False_SARBD02-DSCR050.h5',
5.02: '/sf/data/measurements/2021/04/25/2021_04_25-17_36_28_Lasing_False_SARBD02-DSCR050.h5',
5.00: '/sf/data/measurements/2021/04/25/2021_04_25-17_37_20_Lasing_False_SARBD02-DSCR050.h5',
-4.4: '/sf/data/measurements/2021/04/25/2021_04_25-17_40_15_Lasing_False_SARBD02-DSCR050.h5',
-4.42: '/sf/data/measurements/2021/04/25/2021_04_25-17_41_26_Lasing_False_SARBD02-DSCR050.h5',
-4.38: '/sf/data/measurements/2021/04/25/2021_04_25-17_42_51_Lasing_False_SARBD02-DSCR050.h5',
-4.36: '/sf/data/measurements/2021/04/25/2021_04_25-17_44_59_Lasing_False_SARBD02-DSCR050.h5',
}
screen_analysis = analysis.analyze_screen_calibration(screen_file)
screen_center = screen_analysis['x0']
print('Screen center module', screen_center*1e6, 'um')
calib_dict = h5_storage.loadH5Recursive(calib_file)
raw_data = calib_dict['raw_data']
result0 = analysis.analyze_streaker_calibration(raw_data, True)
print('Module streaker center', result0['meta_data']['streaker_offset']*1e6, 'um')
mask = np.logical_and(raw_data['streaker_offsets'] < 5.04e-3, raw_data['streaker_offsets'] > -0.0044)
#mask = np.ones_like(raw_data['streaker_offsets'], dtype=bool)
raw_data['streaker_offsets'] = raw_data['streaker_offsets'][mask]
raw_data['pyscan_result']['image'] = raw_data['pyscan_result']['image'][mask]
print(raw_data['streaker_offsets'])
ms.figure('Screen projections')
subplot = ms.subplot_factory(1,1)
sp_proj = subplot(1, title='Screen projections', xlabel='x (mm)', ylabel='Intensity (arb. units)')
def add_file(self, filename):
data_dict = h5_storage.loadH5Recursive(filename)
self.add_dict(data_dict)
files2 = [
data_dir2 + '2021_05_19-14_14_22_Calibration_SARUN18-UDCP020.h5',
data_dir2 + '2021_05_19-14_24_05_Calibration_SARUN18-UDCP020.h5',
]
files3 = [
data_dir +
'2021_05_19-00_13_25_Calibration_SARUN18-UDCP020.h5', # Bad data
data_dir +
'2021_05_19-00_24_47_Calibration_SARUN18-UDCP020.h5', # Bad data maybe
]
for files in files1, files2:
tracker_kwargs = config.get_default_tracker_settings()
dict1 = h5_storage.loadH5Recursive(files[0])
dict2 = h5_storage.loadH5Recursive(files[1])
dict1 = sc.analyze_streaker_calibration(dict1['raw_data'], False)
dict2 = sc.analyze_streaker_calibration(dict2['raw_data'], False)
magnet_data = dict1['raw_data']['meta_data_begin']
tracker_kwargs['magnet_file'] = magnet_data
tracker_kwargs['quad_wake'] = False
tracker = tracking.Tracker(**tracker_kwargs)
#tracker.wake2d = True
#tracker.split_streaker = 5
#tracker.set_simulator(magnet_data)
meta_data = sc.analyze_streaker_calibration_stitch_together(
dict1,
dict2,
load_compact = True
storage_dir = '/storage/'
if home_office:
def loadH5Recursive2(path):
return loadH5Recursive(
os.path.join(storage_dir + 'data_2020-02-03/',
os.path.basename(path)))
else:
loadH5Recursive2 = loadH5Recursive
bl_meas_structure = '/sf/data/measurements/2020/02/03/Bunch_length_meas_2020-02-03_15-51-34.h5'
if load_compact:
bl_meas_compact = loadH5Recursive('./example_current_profile.h5')
energy_eV = bl_meas_compact['energy_eV']
time_profile = bl_meas_compact['time_profile']
current = bl_meas_compact['current']
else:
bl_meas = loadH5Recursive2(bl_meas_structure)
time_profile, current = bl_meas['Meta_data'][
'Time axes'][::-1] * 1e-15, bl_meas['Meta_data'][
'Current profile'][::-1]
energy_eV = bl_meas['Input']['Energy'].squeeze() * 1e6
saveH5Recursive('./example_current_profile.h5', {
'time_profile': time_profile,
'current': current,
'energy_eV': energy_eV
})
import h5_storage
import image_and_profile as iap
file_ = '/home/work/tmp_reconstruction/2021_04_26-12_23_40_PassiveReconstruction.h5'
dd = h5_storage.loadH5Recursive(file_)
rec_profile = iap.BeamProfile.from_dict(
dd['gaussian_reconstruction']['reconstructed_profile'])
archiver_dir = '/home/work/'
magnet_file = archiver_dir + 'archiver_api_data/2020-10-03.h5'
blmeas38 = dirname1 + '129833611_bunch_length_meas.h5'
#blmeas25 = dirname2 + 'Bunch_length_meas_2020-10-04_14-43-30.h5'
#blmeas25 = dirname2 + '129918532_bunch_length_meas.h5'
blmeas25 = dirname2 + 'Bunch_length_meas_2020-10-04_14-53-46.h5'
file0 = dirname1 + 'Passive_data_20201003T231958.mat'
file38 = dirname1 + 'Passive_data_20201003T233852.mat'
file25 = dirname2 + 'Passive_data_20201004T172425.mat'
file25b = dirname2 + 'Passive_data_20201004T163828.mat'
dict38 = loadH5Recursive(file38 + '.h5')
dict25 = loadH5Recursive(file25 + '.h5')
dict0 = loadH5Recursive(file0 + '.h5')
dict25b = loadH5Recursive(file25b + '.h5')
subtract_min = True
def get_screen_from_proj(projX, x_axis, invert_x):
if invert_x:
xx, yy = (-x_axis[::-1]).copy(), (projX[::-1]).copy()
else:
xx, yy = x_axis.copy(), projX.copy()
if subtract_min:
yy -= yy.min()
def load_screen_data(filename_or_dict, key, index):
if type(filename_or_dict) is dict:
dict_ = filename_or_dict
elif filename_or_dict.endswith('.h5'):
dict_ = loadH5Recursive(filename_or_dict)
elif filename_or_dict.endswith('.mat'):
dict_ = loadmat(filename_or_dict)
else:
raise ValueError('Must be h5 or mat file. Is: %s' % filename_or_dict)
dict0 = dict_
if 'pyscan_result' in dict0:
dict_ = dict_['pyscan_result']
key = 'image'
else:
dict_ = dict0
if 'x_axis_m' not in dict_:
print(dict_.keys())
x_axis = dict_['x_axis_m']
data = dict_[key].astype(float)
if index not in ('None', None):
index = int(index)
data = data[index]
if len(data.shape) == 2:
# Assume saved data are already projections
projx = data
elif len(data.shape) == 3:
# Assume saved data are images
projx = np.zeros((data.shape[0], len(x_axis)))
for n_img, img in enumerate(data):
try:
projx[n_img, :] = img.sum(axis=0)
except:
import pdb
pdb.set_trace()
else:
raise ValueError('Expect shape of 2 or 3. Is: %i' % len(data.shape))
y_axis = dict_['y_axis_m'] if 'y_axis_m' in dict_ else None
if np.abs(x_axis.max()) > 1:
x_axis *= 1e-6
print('Converting x_axis from um to m')
if np.abs(y_axis.max()) > 1:
y_axis *= 1e-6
print('Converting y_axis from um to m')
# TBD
# - Add y information. Needed for lasing reconstruction.
if x_axis[1] < x_axis[0]:
x_axis = x_axis[::-1]
projx = projx[:, ::-1]
if y_axis[1] < y_axis[0]:
y_axis = y_axis[::-1]
output = {
'x_axis': x_axis,
'projx': projx,
'y_axis': y_axis,
}
if 'meta_data' in dict0:
output['meta_data'] = dict0['meta_data']
if 'meta_data_end' in dict0:
output['meta_data'] = dict0['meta_data_end']
return output
archiver_dir = '/home/work/'
magnet_file = archiver_dir + 'archiver_api_data/2020-10-03.h5'
blmeas38 = dirname1 + '129833611_bunch_length_meas.h5'
blmeas25 = dirname2 + '129918532_bunch_length_meas.h5'
blmeas25 = dirname2 + 'Bunch_length_meas_2020-10-04_14-43-30.h5'
blmeas13 = dirname2 + '129920069_bunch_length_meas.h5'
file0 = dirname1 + 'Passive_data_20201003T231958.mat'
file38 = dirname1 + 'Passive_data_20201003T233852.mat'
file25 = dirname2 + 'Passive_data_20201004T172425.mat'
file13 = dirname2 + 'Passive_data_20201004T221502.mat'
dict38 = loadH5Recursive(file38 + '.h5')
dict25 = loadH5Recursive(file25 + '.h5')
dict0 = loadH5Recursive(file0 + '.h5')
dict13_h5 = loadH5Recursive(file13 + '.h5')
dict13_h5['value'] = np.array(-4.25) # from archiver
#dict13_h5['x_axis'] = dict25['x_axis']
proj13 = dict13_h5['projx']
proj13_new = np.reshape(proj13,
(proj13.shape[0] * proj13.shape[1], proj13.shape[2]))
dict13_h5['projx'] = proj13_new
def get_screen_from_proj(projX, x_axis, invert_x):
if invert_x:
xx, yy = (-x_axis[::-1]).copy(), (projX[::-1]).copy()
def add_other_h5(self, file_):
new_dict = loadH5Recursive(file_)
assert len(set(new_dict.keys()).intersection(set(self.keys()))) == 0
self.update(new_dict)
