def calculate_spec_quantification():
als_spec = als_process2019.get_als_spectra()
lcls_specs = get_constant_absorbed_specs()
xmcd_norm = _integrate_range(als_spec['xmcd']['phot'],
als_spec['xmcd']['spec'], XMCD_RANGE)
energies = []
err_energies = []
xmcds = []
err_xmcds = []
fluences = []
for spec in lcls_specs:
holes_per_ev = spec['xas']['diff'] / D
energy_per_ev = holes_per_ev * (FERMI_ENERGY - spec['xas']['phot'])
energy_current = _integrate_range(spec['xas']['phot'], energy_per_ev,
ENERGIES_RANGE)
xmcd_current = _integrate_range(
spec['xmcd']['phot'], spec['xmcd']['spec'], XMCD_RANGE) / xmcd_norm
variance_energy_per_ev = ((spec['plus']['err'] / 2)**2 +
(spec['minus']['err'] / 2)**2) * (
FERMI_ENERGY - spec['xas']['phot'])**2
variance_energy_current = _integrate_range(spec['xas']['phot'],
variance_energy_per_ev,
ENERGIES_RANGE)
variance_xmcd_per_ev = (spec['plus']['err']**2 +
spec['minus']['err']**2) / (xmcd_norm**2)
variance_xmcd_current = _integrate_range(spec['xmcd']['phot'],
variance_xmcd_per_ev,
XMCD_RANGE)
err_energy_current = np.sqrt(variance_energy_current)
err_xmcd_current = np.sqrt(variance_xmcd_current)
energies.append(energy_current)
err_energies.append(err_energy_current)
xmcds.append(xmcd_current)
err_xmcds.append(err_xmcd_current)
fluences.append(spec['absorbed_fluence2'])
fluences = np.array(fluences)
absorbed_energies = fluences * FLUENCE2ABSORBEDENERGY
eV_to_meV = 1000
spec_energies = np.array(energies) * eV_to_meV
line_zero_offset = lambda x, slope: x * slope
fraction_within_2eV, unused = curve_fit(line_zero_offset,
absorbed_energies / 2,
spec_energies,
p0=0.8)
cascade_duration = calc_cascade_response.calculate_cascade_time(
fraction_within_2eV)
return {
'absorbed_fluences': fluences,
'absorbed_energies': absorbed_energies,
'pulse_averaged_absorbed_energies': absorbed_energies / 2,
'spec_energies': spec_energies,
'err_spec_energies': np.array(err_energies) * eV_to_meV,
'xmcds': np.array(xmcds),
'err_xmcds': np.array(err_xmcds),
'fraction_within_2eV': fraction_within_2eV,
'cascade_duration': cascade_duration
}
def get_absorbed_fluence(data):
als_spec = als_process2019.get_als_spectra()
absorbed_fluences = []
for ind in np.arange(len(data['phot'])):
if data['magnet_dir'][ind] == 1:
absorption = np.interp(data['phot'][ind], als_spec['plus']['phot'],
als_spec['plus']['spec'])
if data['magnet_dir'][ind] == -1:
absorption = np.interp(data['phot'][ind],
als_spec['minus']['phot'],
als_spec['minus']['spec'])
else:
absorption = np.interp(data['phot'][ind], als_spec['xas']['phot'],
als_spec['xas']['spec'])
absorb_fraction = 1 - np.exp(-1 * absorption)
absorbed_fluences.append(absorb_fraction * data['fluence_in'][ind])
return {'absorbed_fluence': np.array(absorbed_fluences)}
def get_source_data():
raw_mcp_and_andor = get_raw_mcp_and_andor_waveforms()
no_sample_data = get_no_sample_data()
als_spec = als_process2019.get_als_spectra()
lcls_specs = abs_get_processed_data.get_incident_specs()
source_data = {'Time (us)': raw_mcp_and_andor[b'mcp'][b'x'],
'Voltage (V)': raw_mcp_and_andor[b'mcp'][b'y'],
'Pixel': raw_mcp_and_andor[b'andor'][b'x'],
'Counts/1E3': raw_mcp_and_andor[b'andor'][b'y'],
'Raw I0': no_sample_data['Raw I0'],
'Raw I1': no_sample_data['Raw I1'],
'Corrected I0': no_sample_data['Corrected I0'],
'Corrected I1': no_sample_data['Corrected I1'],
'ALS Photon Energy': als_spec['xas']['phot'],
'ALS XAS': als_spec['xas']['spec'],
'2.7 mJ/cm^2 Photon Energy': lcls_specs[-3]['xas']['phot'],
'2.7 mJ/cm^2 XAS': lcls_specs[-3]['xas']['spec'],
'43 mJ/cm^2 Photon Energy': lcls_specs[-1]['xas']['phot'],
'43 mJ/cm^2 XAS': lcls_specs[-1]['xas']['spec']}
return source_data
# LCLS psana to read raw data
# (needs to be imported if loading raw data, otherwise can be
# commented out)
#import psana
import visualize.set_plot_params
visualize.set_plot_params.init_paper_small()
# To get processed data
import abs_hdf2rec
import abs_ana
import abs_get_processed_data
# Get ALS data
import als_process2019
ALS_SPEC = als_process2019.get_als_spectra()
# Short dash linestyle:
SD = (0, (3, 1.5))
RAW_MCP_AND_ANDOR_FILE = '../../data/raw/raw_mcp_and_andor.p'
def get_raw_mcp_and_andor_waveforms():
"""Return raw mcp and andor waveforms that were
saved from raw data
"""
pickle_out = open(RAW_MCP_AND_ANDOR_FILE, 'rb')
raw_mcp_and_andor = pickle.load(pickle_out, encoding='bytes')
pickle_out.close()
return raw_mcp_and_andor
