def job_rayleigh_length(T):
beam_diameter_val = 3.5e-3
beam_diameter_err = 0.5e-3
refractive_index = 2.2
wavelength = 987e-9
length = 5e-3
distance = 60e-3
beam_radius_val = beam_diameter_val / 2
beam_radius_err = beam_diameter_err / 2
T['beam_radius'] = siunitx(beam_radius_val, beam_radius_err)
beam_radius_dist = bootstrap.make_dist(beam_radius_val, beam_diameter_err)
theta_dist = [
np.arctan(beam_radius / distance)
for beam_radius in beam_radius_dist
]
theta_val, theta_err = bootstrap.average_and_std_arrays(theta_dist)
T['theta'] = siunitx(theta_val, theta_err)
bootstrap.save_hist(theta_dist, '_build/dist-theta.pdf')
waist_dist = [
wavelength / (np.pi * theta)
for theta in theta_dist
]
waist_val, waist_err = bootstrap.average_and_std_arrays(waist_dist)
T['waist_mum'] = siunitx(waist_val / 1e-6, waist_err / 1e-6)
bootstrap.save_hist(waist_dist, '_build/dist-waist.pdf')
rayleigh_length_dist = list(itertools.filterfalse(np.isnan, [
refractive_index * np.pi * waist**2 / wavelength
for waist in waist_dist
]))
rayleigh_length_val, rayleigh_length_err = bootstrap.average_and_std_arrays(rayleigh_length_dist)
T['rayleigh_length_mm'] = siunitx(rayleigh_length_val / 1e-3, rayleigh_length_err / 1e-3, error_digits=2)
bootstrap.save_hist(rayleigh_length_dist, '_build/dist-rayleigh_length.pdf')
normalized_length_dist = list([
length / (2 * rayleigh_length)
for rayleigh_length in rayleigh_length_dist
])
normalized_length_val, normalized_length_err = bootstrap.average_and_std_arrays(normalized_length_dist)
T['normalized_length'] = siunitx(normalized_length_val, normalized_length_err, error_digits=2)
bootstrap.save_hist(normalized_length_dist, '_build/dist-normalized_length.pdf')
t = (normalized_length_val - 2.84) / normalized_length_err
T['boyd_kleinman_ttest_t'] = siunitx(t)
optimal_focal_length_dist = list([
get_optimal_focal_length(beam_radius, refractive_index, wavelength, length)
for beam_radius in beam_radius_dist
])
optimal_focal_length_val, optimal_focal_length_err = bootstrap.average_and_std_arrays(optimal_focal_length_dist)
T['optimal_focal_length_mm'] = siunitx(optimal_focal_length_val / 1e-3, optimal_focal_length_err / 1e-3, error_digits=2)
def job_harmonic_power(T, extinction_dist, input_popt_dist):
data = np.loadtxt('Data/harmonic_splitter.tsv')
angle = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = data[:, 2] * 1e-6
T['harmonic_splitter_table'] = list(zip(
siunitx(angle),
siunitx(power_val*1e6, power_err*1e6),
))
power_dist = bootstrap.make_dist(power_val, power_err)
fit_x = np.linspace(np.min(angle), np.max(angle), 200)
fit_y_dist = []
angle_offset_dist = []
a_dist = []
b_dist = []
popt_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(cos_quartic, angle, power, p0=[1.5e-5, 0, 0])
fit_y_dist.append(cos_quartic(fit_x, *popt))
angle_offset_dist.append(popt[1])
a = popt[0]
b = popt[2]
a_dist.append(a)
b_dist.append(b)
popt_dist.append(popt)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
angle_offset_val, angle_offset_err = bootstrap.average_and_std_arrays(angle_offset_dist)
a_val, a_err = bootstrap.average_and_std_arrays(a_dist)
b_val, b_err = bootstrap.average_and_std_arrays(b_dist)
np.savetxt('_build/xy/harmonic-splitter-data.tsv',
np.column_stack([angle, power_val, power_err]))
np.savetxt('_build/xy/harmonic-splitter-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/harmonic-splitter-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['splitter_angle_offset'] = siunitx(angle_offset_val, angle_offset_err)
T['splitter_a'] = siunitx(a_val, a_err)
T['splitter_b'] = siunitx(b_val, b_err)
efficiency_dist = []
efficiency_sq_dist = []
for extinction, input_popt, popt in zip(extinction_dist, input_popt_dist, popt_dist):
efficiency = popt[0] / (input_popt[0] * extinction)
efficiency_dist.append(efficiency)
efficiency_sq = popt[0] / (input_popt[0] * extinction)**2
efficiency_sq_dist.append(efficiency_sq)
efficiency_val, efficiency_err = bootstrap.average_and_std_arrays(efficiency_dist)
efficiency_sq_val, efficiency_sq_err = bootstrap.average_and_std_arrays(efficiency_sq_dist)
T['efficiency'] = siunitx(efficiency_val, efficiency_err)
T['efficiency_sq'] = siunitx(efficiency_sq_val, efficiency_sq_err)
def job_variable_attenuator(T, extinction_dist):
data = np.loadtxt('Data/variable.tsv')
angle = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = np.ones(power_val.shape) * 1e-6
T['variable_attenuator_table'] = list(
zip(
siunitx(angle),
siunitx(power_val * 1e6, power_err * 1e6),
))
power_dist = bootstrap.make_dist(power_val,
power_err,
n=len(extinction_dist))
fit_x = np.linspace(np.min(angle), np.max(angle), 200)
fit_y_dist = []
angle_offset_dist = []
a_dist = []
b_dist = []
popt_dist = []
extinction_ratio_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(cos_squared, angle, power, p0=[1.5, 0, 0])
fit_y_dist.append(cos_squared(fit_x, *popt))
angle_offset_dist.append(popt[1])
a = popt[0]
b = popt[2]
a_dist.append(a)
b_dist.append(b)
popt_dist.append(popt)
extinction_ratio_dist.append((a + b) / b)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
angle_offset_val, angle_offset_err = bootstrap.average_and_std_arrays(
angle_offset_dist)
a_val, a_err = bootstrap.average_and_std_arrays(a_dist)
b_val, b_err = bootstrap.average_and_std_arrays(b_dist)
extinction_ratio_val, extinction_ratio_err = bootstrap.average_and_std_arrays(
extinction_ratio_dist)
np.savetxt('_build/xy/variable-data.tsv',
np.column_stack([angle, power_val, power_err]))
np.savetxt('_build/xy/variable-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/variable-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['variable_angle_offset'] = siunitx(angle_offset_val, angle_offset_err)
T['variable_a'] = siunitx(a_val, a_err)
T['variable_b'] = siunitx(b_val, b_err)
T['extinction_ratio'] = siunitx(extinction_ratio_val, extinction_ratio_err)
return popt_dist
def job_variable_attenuator(T, extinction_dist):
data = np.loadtxt('Data/variable.tsv')
angle = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = np.ones(power_val.shape) * 1e-6
T['variable_attenuator_table'] = list(zip(
siunitx(angle),
siunitx(power_val*1e6, power_err*1e6),
))
power_dist = bootstrap.make_dist(power_val, power_err, n=len(extinction_dist))
fit_x = np.linspace(np.min(angle), np.max(angle), 200)
fit_y_dist = []
angle_offset_dist = []
a_dist = []
b_dist = []
popt_dist = []
extinction_ratio_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(cos_squared, angle, power, p0=[1.5, 0, 0])
fit_y_dist.append(cos_squared(fit_x, *popt))
angle_offset_dist.append(popt[1])
a = popt[0]
b = popt[2]
a_dist.append(a)
b_dist.append(b)
popt_dist.append(popt)
extinction_ratio_dist.append((a + b) / b)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
angle_offset_val, angle_offset_err = bootstrap.average_and_std_arrays(angle_offset_dist)
a_val, a_err = bootstrap.average_and_std_arrays(a_dist)
b_val, b_err = bootstrap.average_and_std_arrays(b_dist)
extinction_ratio_val, extinction_ratio_err = bootstrap.average_and_std_arrays(extinction_ratio_dist)
np.savetxt('_build/xy/variable-data.tsv',
np.column_stack([angle, power_val, power_err]))
np.savetxt('_build/xy/variable-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/variable-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['variable_angle_offset'] = siunitx(angle_offset_val, angle_offset_err)
T['variable_a'] = siunitx(a_val, a_err)
T['variable_b'] = siunitx(b_val, b_err)
T['extinction_ratio'] = siunitx(extinction_ratio_val, extinction_ratio_err)
return popt_dist
def job_grating_resolution(T):
lines_per_m = 600e3
diameter_val = 3.5e-3 / 2
diameter_err = 0.5e-3 / 2
diameter_dist = bootstrap.make_dist(diameter_val, diameter_err)
illuminated_dist = [diameter * lines_per_m for diameter in diameter_dist]
illuminated_val, illuminated_err = bootstrap.average_and_std_arrays(
illuminated_dist)
T['illuminated'] = siunitx(illuminated_val, illuminated_err)
rel_error_dist = [1 / illuminated for illuminated in illuminated_dist]
rel_error_val, rel_error_err = bootstrap.average_and_std_arrays(
rel_error_dist)
T['rel_error'] = siunitx(rel_error_val, rel_error_err)
def job_input_polarization(T):
data = np.loadtxt('Data/harmonic_bare.tsv')
angle = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = data[:, 2] * 1e-6
power_dist = bootstrap.make_dist(power_val, power_err)
T['harmonic_bare_table'] = list(
zip(
siunitx(angle),
siunitx(power_val * 1e6, power_err * 1e6),
))
fit_x = np.linspace(np.min(angle), np.max(angle), 200)
fit_y_dist = []
angle_offset_dist = []
a_dist = []
b_dist = []
popt_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(cos_quartic,
angle,
power,
p0=[1.5e-5, 0, 0])
fit_y_dist.append(cos_quartic(fit_x, *popt))
angle_offset_dist.append(popt[1])
a = popt[0]
b = popt[2]
a_dist.append(a)
b_dist.append(b)
popt_dist.append(popt)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
angle_offset_val, angle_offset_err = bootstrap.average_and_std_arrays(
angle_offset_dist)
a_val, a_err = bootstrap.average_and_std_arrays(a_dist)
b_val, b_err = bootstrap.average_and_std_arrays(b_dist)
np.savetxt('_build/xy/harmonic-bare-data.tsv',
np.column_stack([angle, power_val, power_err]))
np.savetxt('_build/xy/harmonic-bare-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/harmonic-bare-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['bare_angle_offset'] = siunitx(angle_offset_val, angle_offset_err)
T['bare_a'] = siunitx(a_val, a_err)
T['bare_b'] = siunitx(b_val, b_err)
def job_grating_resolution(T):
lines_per_m = 600e3
diameter_val = 3.5e-3 / 2
diameter_err = 0.5e-3 / 2
diameter_dist = bootstrap.make_dist(diameter_val, diameter_err)
illuminated_dist = [
diameter * lines_per_m
for diameter in diameter_dist
]
illuminated_val, illuminated_err = bootstrap.average_and_std_arrays(illuminated_dist)
T['illuminated'] = siunitx(illuminated_val, illuminated_err)
rel_error_dist = [
1 / illuminated
for illuminated in illuminated_dist
]
rel_error_val, rel_error_err = bootstrap.average_and_std_arrays(rel_error_dist)
T['rel_error'] = siunitx(rel_error_val, rel_error_err)
def job_temperature_dependence(T):
data = np.loadtxt('Data/temperature.tsv')
temp = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = np.ones(power_val.shape) * 1e-6
power_dist = bootstrap.make_dist(power_val, power_err)
T['temperature_table'] = list(
zip(
siunitx(temp),
siunitx(power_val * 1e6, power_err * 1e6),
))
p0 = [36.5, 1, 36 - 6, 2e-6]
fit_x = np.linspace(np.min(temp), np.max(temp), 300)
popt_dist = []
fit_y_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(sinc, temp, power, p0=p0)
fit_y_dist.append(sinc(fit_x, *popt))
popt_dist.append(popt)
center_dist, width_dist, amplitude_dist, offset_dist = zip(*popt_dist)
center_val, center_err = bootstrap.average_and_std_arrays(center_dist)
width_val, width_err = bootstrap.average_and_std_arrays(width_dist)
amplitude_val, amplitude_err = bootstrap.average_and_std_arrays(
amplitude_dist)
offset_val, offset_err = bootstrap.average_and_std_arrays(offset_dist)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
np.savetxt('_build/xy/temperature-data.tsv',
np.column_stack([temp, power_val, power_err]))
np.savetxt('_build/xy/temperature-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/temperature-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['temp_center'] = siunitx(center_val, center_err)
T['temp_width'] = siunitx(width_val, width_err)
T['temp_amplitude'] = siunitx(amplitude_val, amplitude_err)
T['temp_offset'] = siunitx(offset_val, offset_err)
def job_input_polarization(T):
data = np.loadtxt('Data/harmonic_bare.tsv')
angle = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = data[:, 2] * 1e-6
power_dist = bootstrap.make_dist(power_val, power_err)
T['harmonic_bare_table'] = list(zip(
siunitx(angle),
siunitx(power_val*1e6, power_err*1e6),
))
fit_x = np.linspace(np.min(angle), np.max(angle), 200)
fit_y_dist = []
angle_offset_dist = []
a_dist = []
b_dist = []
popt_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(cos_quartic, angle, power, p0=[1.5e-5, 0, 0])
fit_y_dist.append(cos_quartic(fit_x, *popt))
angle_offset_dist.append(popt[1])
a = popt[0]
b = popt[2]
a_dist.append(a)
b_dist.append(b)
popt_dist.append(popt)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
angle_offset_val, angle_offset_err = bootstrap.average_and_std_arrays(angle_offset_dist)
a_val, a_err = bootstrap.average_and_std_arrays(a_dist)
b_val, b_err = bootstrap.average_and_std_arrays(b_dist)
np.savetxt('_build/xy/harmonic-bare-data.tsv',
np.column_stack([angle, power_val, power_err]))
np.savetxt('_build/xy/harmonic-bare-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/harmonic-bare-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['bare_angle_offset'] = siunitx(angle_offset_val, angle_offset_err)
T['bare_a'] = siunitx(a_val, a_err)
T['bare_b'] = siunitx(b_val, b_err)
def job_temperature_dependence(T):
data = np.loadtxt('Data/temperature.tsv')
temp = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = np.ones(power_val.shape) * 1e-6
power_dist = bootstrap.make_dist(power_val, power_err)
T['temperature_table'] = list(zip(
siunitx(temp),
siunitx(power_val*1e6, power_err*1e6),
))
p0 = [36.5, 1, 36-6, 2e-6]
fit_x = np.linspace(np.min(temp), np.max(temp), 300)
popt_dist = []
fit_y_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(sinc, temp, power, p0=p0)
fit_y_dist.append(sinc(fit_x, *popt))
popt_dist.append(popt)
center_dist, width_dist, amplitude_dist, offset_dist = zip(*popt_dist)
center_val, center_err = bootstrap.average_and_std_arrays(center_dist)
width_val, width_err = bootstrap.average_and_std_arrays(width_dist)
amplitude_val, amplitude_err = bootstrap.average_and_std_arrays(amplitude_dist)
offset_val, offset_err = bootstrap.average_and_std_arrays(offset_dist)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
np.savetxt('_build/xy/temperature-data.tsv',
np.column_stack([temp, power_val, power_err]))
np.savetxt('_build/xy/temperature-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/temperature-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['temp_center'] = siunitx(center_val, center_err)
T['temp_width'] = siunitx(width_val, width_err)
T['temp_amplitude'] = siunitx(amplitude_val, amplitude_err)
T['temp_offset'] = siunitx(offset_val, offset_err)
def main():
options = _parse_args()
R = 300
# Read in the data from the paper.
a_inv_val = 1616
a_inv_err = 20
a_inv_dist = bootstrap.make_dist(a_inv_val, a_inv_err, n=R)
aml, ams, l, t, trajectories, ampi_val, ampi_err, amk_val, amk_err, f_k_f_pi_val, f_k_f_pi_err = util.load_columns(
'physical_point/gmor.txt')
ampi_dist = bootstrap.make_dist(ampi_val, ampi_err, n=R)
amk_dist = bootstrap.make_dist(amk_val, amk_err, n=R)
mpi_dist = [ampi * a_inv for ampi, a_inv in zip(ampi_dist, a_inv_dist)]
mk_dist = [amk * a_inv for amk, a_inv in zip(amk_dist, a_inv_dist)]
# Convert the data in lattice units into physical units.
mpi_dist = [a_inv * ampi for ampi, a_inv in zip(ampi_dist, a_inv_dist)]
mpi_val, mpi_avg, mpi_err = bootstrap.average_and_std_arrays(mpi_dist)
mpi_sq_dist = [mpi**2 for mpi in mpi_dist]
mpi_sq_val, mpi_sq_avg, mpi_sq_err = bootstrap.average_and_std_arrays(
mpi_sq_dist)
ampi_sq_dist = [ampi**2 for ampi in ampi_dist]
ampi_sq_val, ampi_sq_avg, ampi_sq_err = bootstrap.average_and_std_arrays(
ampi_sq_dist)
# Do a GMOR fit in order to extract `a B` and `a m_cr`.
popt_dist = [
op.curve_fit(gmor_pion, aml, ampi_sq)[0] for ampi_sq in ampi_sq_dist
]
aB_dist = [popt[0] for popt in popt_dist]
amcr_dist = [popt[1] for popt in popt_dist]
aB_val, aB_avg, aB_err = bootstrap.average_and_std_arrays(aB_dist)
amcr_val, amcr_avg, amcr_err = bootstrap.average_and_std_arrays(amcr_dist)
print('aB =', siunitx(aB_val, aB_err))
print('am_cr =', siunitx(amcr_val, amcr_err))
ams_paper = -0.057
ams_phys = ams_paper - amcr_val
ams_red = 0.9 * ams_phys
ams_bare_red = ams_red + amcr_val
print(ams_paper, ams_phys, ams_red, ams_bare_red)
print()
print('Mass preconditioning masses:')
amlq = aml - amcr_val
for i in range(3):
amprec = amlq * 10**i + amcr_val
kappa = 1 / (amprec * 2 + 8)
print('a m_prec:', amprec)
print('κ', kappa)
exit()
diff_dist = [
np.sqrt(2) * np.sqrt(mk**2 - 0.5 * mpi**2)
for mpi, mk in zip(mpi_dist, mk_dist)
]
diff_val, diff_avg, diff_err = bootstrap.average_and_std_arrays(diff_dist)
popt_dist = [
op.curve_fit(linear, mpi, diff)[0]
for mpi, diff in zip(mpi_dist, diff_dist)
]
fit_x = np.linspace(np.min(mpi_dist), np.max(mpi_dist), 100)
fit_y_dist = [linear(fit_x, *popt) for popt in popt_dist]
fit_y_val, fit_y_avg, fit_y_err = bootstrap.average_and_std_arrays(
fit_y_dist)
# Physical meson masses from FLAG paper.
mpi_phys_dist = bootstrap.make_dist(134.8, 0.3, R)
mk_phys_dist = bootstrap.make_dist(494.2, 0.3, R)
mpi_phys_val, mpi_phys_avg, mpi_phys_err = bootstrap.average_and_std_arrays(
mpi_phys_dist)
ampi_phys_dist = [
mpi_phys / a_inv for a_inv, mpi_phys in zip(a_inv_dist, mpi_phys_dist)
]
amk_phys_dist = [
mk_phys / a_inv for a_inv, mk_phys in zip(a_inv_dist, mk_phys_dist)
]
ampi_phys_val, ampi_phys_avg, ampi_phys_err = bootstrap.average_and_std_arrays(
ampi_phys_dist)
amk_phys_val, amk_phys_avg, amk_phys_err = bootstrap.average_and_std_arrays(
amk_phys_dist)
print('aM_pi phys =', siunitx(ampi_phys_val, ampi_phys_err))
print('aM_k phys =', siunitx(amk_phys_val, amk_phys_err))
new_b_dist = [
np.sqrt(mk_phys**2 - 0.5 * mpi_phys**2) - popt[0] * mpi_phys for
mpi_phys, mk_phys, popt in zip(mpi_phys_dist, mk_phys_dist, popt_dist)
]
diff_sqrt_phys_dist = [
np.sqrt(mk_phys**2 - 0.5 * mpi_phys**2)
for mpi_phys, mk_phys in zip(mpi_phys_dist, mk_phys_dist)
]
diff_sqrt_phys_val, diff_sqrt_phys_avg, diff_sqrt_phys_err = bootstrap.average_and_std_arrays(
diff_sqrt_phys_dist)
ex_x = np.linspace(120, 700, 100)
ex_y_dist = [
linear(ex_x, popt[0], b) for popt, b in zip(popt_dist, new_b_dist)
]
ex_y_val, ex_y_avg, ex_y_err = bootstrap.average_and_std_arrays(ex_y_dist)
ams_art_dist = [
linear(mpi, popt[0], b)**2 / a_inv**2 / aB - amcr
for mpi, popt, b, a_inv, aB, amcr in zip(
mpi_dist, popt_dist, new_b_dist, a_inv_dist, aB_dist, amcr_dist)
]
ams_art_val, ams_art_avg, ams_art_err = bootstrap.average_and_std_arrays(
ams_art_dist)
print('a m_s with artifacts', siunitx(ams_art_val, ams_art_err))
fig, ax = util.make_figure()
ax.fill_between(fit_x,
fit_y_val + fit_y_err,
fit_y_val - fit_y_err,
color='red',
alpha=0.2)
ax.plot(fit_x, fit_y_val, label='Fit', color='red')
ax.fill_between(ex_x,
ex_y_val + ex_y_err,
ex_y_val - ex_y_err,
color='orange',
alpha=0.2)
ax.plot(ex_x, ex_y_val, label='Extrapolation', color='orange')
ax.errorbar(mpi_val,
diff_val,
xerr=mpi_err,
yerr=diff_err,
linestyle='none',
label='Data (Dürr 2010)')
ax.errorbar([mpi_phys_val], [diff_sqrt_phys_val],
xerr=[mpi_phys_err],
yerr=[diff_sqrt_phys_err],
label='Physical Point (Aoki)')
util.save_figure(fig, 'test')
np.savetxt('artifact-bmw-data.tsv',
np.column_stack([mpi_val, diff_val, mpi_err, diff_err]))
np.savetxt('artifact-bmw-fit.tsv', np.column_stack([fit_x, fit_y_val]))
np.savetxt('artifact-bmw-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
np.savetxt(
'artifact-phys-data.tsv',
np.column_stack([[mpi_phys_val], [diff_sqrt_phys_val], [mpi_phys_err],
[diff_sqrt_phys_err]]))
np.savetxt('artifact-phys-fit.tsv', np.column_stack([ex_x, ex_y_val]))
np.savetxt('artifact-phys-band.tsv',
bootstrap.pgfplots_error_band(ex_x, ex_y_val, ex_y_err))
np.savetxt('artifact-ms.tsv',
np.column_stack([mpi_val, ams_art_val, mpi_err, ams_art_err]))
# Compute the strange quark mass that is needed to obtain a physical meson
# mass difference, ignoring lattice artifacts.
ams_phys_dist = [(amk_phys**2 - 0.5 * ampi_phys**2) / aB - amcr
for ampi_phys, amk_phys, aB, amcr in zip(
ampi_phys_dist, amk_phys_dist, aB_dist, amcr_dist)]
ams_phys_cen, ams_phys_val, ams_phys_err = bootstrap.average_and_std_arrays(
ams_phys_dist)
print('M_K = {} MeV <== am_s ='.format(siunitx(494.2, 0.3)),
siunitx(ams_phys_cen, ams_phys_err))
aml_phys_dist = [
op.newton(lambda aml: gmor_pion(aml, *popt) - ampi_phys**2,
np.min(aml))
for popt, ampi_phys in zip(popt_dist, ampi_phys_dist)
]
fit_x = np.linspace(np.min(aml_phys_dist), np.max(aml), 100)
fit_y_dist = [
np.sqrt(gmor_pion(fit_x, *popt)) * a_inv
for popt, a_inv in zip(popt_dist, a_inv_dist)
]
fit_y_cen, fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(
fit_y_dist)
np.savetxt('physical_point/mpi-vs-aml-data.tsv',
np.column_stack([aml, mpi_val, mpi_err]))
np.savetxt('physical_point/mpi-vs-aml-fit.tsv',
np.column_stack([fit_x, fit_y_cen]))
np.savetxt('physical_point/mpi-vs-aml-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_cen, fit_y_err))
aml_phys_val, aml_phys_avg, aml_phys_err = bootstrap.average_and_std_arrays(
aml_phys_dist)
mpi_cen, mpi_val, mpi_err = bootstrap.average_and_std_arrays(mpi_dist)
#aml_240_val, aml_240_avg, aml_240_err = bootstrap.average_and_std_arrays(aml_240_dist)
print('M_pi = {} MeV <== am_l ='.format(siunitx(134.8, 0.3)),
siunitx(aml_phys_val, aml_phys_err))
#print('M_pi = 240 MeV <== am_l =', siunitx(aml_240_val, aml_240_err))
fig = pl.figure()
ax = fig.add_subplot(2, 1, 1)
ax.fill_between(fit_x,
fit_y_val - fit_y_err,
fit_y_val + fit_y_err,
color='0.8')
ax.plot(fit_x, fit_y_val, color='black', label='GMOR Fit')
ax.errorbar(aml,
mpi_val,
yerr=mpi_err,
color='blue',
marker='+',
linestyle='none',
label='Data')
ax.errorbar([aml_phys_val], [135],
xerr=[aml_phys_err],
marker='+',
color='red',
label='Extrapolation')
#ax.errorbar([aml_240_val], [240], xerr=[aml_240_err], marker='+', color='red')
ax.set_title('Extrapolation to the Physical Point')
ax.set_xlabel(r'$a m_\mathrm{ud}$')
ax.set_ylabel(r'$M_\pi / \mathrm{MeV}$')
util.dandify_axes(ax)
ax = fig.add_subplot(2, 1, 2)
ax.hist(aml_phys_dist - aml_phys_val, bins=50)
ax.locator_params(nbins=6)
ax.set_title('Bootstrap Bias')
ax.set_xlabel(
r'$(a m_\mathrm{ud}^\mathrm{phys})^* - a m_\mathrm{ud}^\mathrm{phys}$')
util.dandify_axes(ax)
util.dandify_figure(fig)
fig.savefig('physical_point/GMOR.pdf')
np.savetxt('physical_point/ampi-sq-vs-aml.tsv',
np.column_stack([aml, ampi_sq_val, ampi_sq_err]))
np.savetxt('physical_point/mpi-sq-vs-aml.tsv',
np.column_stack([aml, mpi_sq_val, mpi_sq_err]))
def job_power(T):
data = np.loadtxt('Data/diode.tsv')
norm_current = data[:, 0] * 1e-3
norm_power_val = data[:, 1] * 1e-3
norm_power_err = np.ones(norm_power_val.shape) * 1e-6
norm_power_dist = bootstrap.make_dist(norm_power_val, norm_power_err)
data = np.loadtxt('Data/diode_damped.tsv')
damp_current = data[:, 0] * 1e-3
damp_power_val = data[:, 1] * 1e-3
damp_power_err = data[:, 2] * 1e-3
damp_power_dist = bootstrap.make_dist(damp_power_val, damp_power_err)
np.savetxt('_build/xy/diode_normal-data.tsv',
np.column_stack([norm_current, norm_power_val, norm_power_err]))
np.savetxt('_build/xy/diode_damped-data.tsv',
np.column_stack([damp_current, damp_power_val, damp_power_err]))
T['diode_normal_table'] = list(zip(
siunitx(norm_current*1e3),
siunitx(norm_power_val*1e6, norm_power_err*1e6, allowed_hang=6),
))
T['diode_damped_table'] = list(zip(
siunitx(damp_current*1e3),
siunitx(damp_power_val*1e6, damp_power_err*1e6),
))
hbar_omega = 6.626e-34 * 3e8 / 987e-9
electron_charge = 1.609e-19
# Find the threshold current.
sel = norm_power_val > 1e-3
slope_dist = []
quantum_efficiency_dist = []
threshold_dist = []
threshold_fit_x = np.linspace(0.05, 0.09, 100)
threshold_fit_y_dist = []
# Jackknife fit to find root.
for i in range(len(norm_power_val[sel])):
x = np.delete(norm_current[sel], i)
y_val = np.delete(norm_power_val[sel], i)
y_err = np.delete(norm_power_err[sel], i)
popt, pconv = op.curve_fit(linear, x, y_val, sigma=y_err)
a, b = popt
root = -b / a
threshold_dist.append(root)
threshold_fit_y_dist.append(linear(threshold_fit_x, *popt))
slope_dist.append(a)
quantum_efficiency_dist.append(a * electron_charge / hbar_omega)
threshold_val, threshold_err = bootstrap.average_and_std_arrays(threshold_dist)
threshold_fit_y_val, threshold_fit_y_err = bootstrap.average_and_std_arrays(threshold_fit_y_dist)
differential_efficiency_val, differential_efficiency_err = bootstrap.average_and_std_arrays(slope_dist)
quantum_efficiency_val, quantum_efficiency_err = bootstrap.average_and_std_arrays(quantum_efficiency_dist)
T['threshold'] = siunitx(threshold_val, threshold_err)
T['differential_efficiency'] = siunitx(differential_efficiency_val, differential_efficiency_err)
T['quantum_efficiency'] = siunitx(quantum_efficiency_val, quantum_efficiency_err)
np.savetxt('_build/xy/diode_normal-band.tsv',
bootstrap.pgfplots_error_band(threshold_fit_x, threshold_fit_y_val, threshold_fit_y_err))
# Compare ratios of damped and normal power in the overlap range.
ratio_dist = []
x = np.linspace(70.1e-3, 86.9e-3, 20)
for norm_power, damp_power in zip(norm_power_dist, damp_power_dist):
norm_inter = scipy.interpolate.interp1d(norm_current, norm_power)
damp_inter = scipy.interpolate.interp1d(damp_current, damp_power)
a = norm_inter(x)
b = damp_inter(x)
ratio = a / b
ratio_dist.append(ratio)
ratio_val, ratio_err = bootstrap.average_and_std_arrays(ratio_dist)
extinction_dist = np.array(ratio_dist).flatten()
extinction_val, extinction_err = np.mean(ratio_dist), np.std(ratio_dist)
T['extinction'] = siunitx(extinction_val, extinction_err)
np.savetxt('_build/xy/diode-ratio-line.tsv',
np.column_stack([x, ratio_val]))
np.savetxt('_build/xy/diode-ratio-band.tsv',
bootstrap.pgfplots_error_band(x, ratio_val, ratio_err))
return extinction_dist
def job_power(T):
data = np.loadtxt('Data/diode.tsv')
norm_current = data[:, 0] * 1e-3
norm_power_val = data[:, 1] * 1e-3
norm_power_err = np.ones(norm_power_val.shape) * 1e-6
norm_power_dist = bootstrap.make_dist(norm_power_val, norm_power_err)
data = np.loadtxt('Data/diode_damped.tsv')
damp_current = data[:, 0] * 1e-3
damp_power_val = data[:, 1] * 1e-3
damp_power_err = data[:, 2] * 1e-3
damp_power_dist = bootstrap.make_dist(damp_power_val, damp_power_err)
np.savetxt('_build/xy/diode_normal-data.tsv',
np.column_stack([norm_current, norm_power_val, norm_power_err]))
np.savetxt('_build/xy/diode_damped-data.tsv',
np.column_stack([damp_current, damp_power_val, damp_power_err]))
T['diode_normal_table'] = list(
zip(
siunitx(norm_current * 1e3),
siunitx(norm_power_val * 1e6, norm_power_err * 1e6,
allowed_hang=6),
))
T['diode_damped_table'] = list(
zip(
siunitx(damp_current * 1e3),
siunitx(damp_power_val * 1e6, damp_power_err * 1e6),
))
hbar_omega = 6.626e-34 * 3e8 / 987e-9
electron_charge = 1.609e-19
# Find the threshold current.
sel = norm_power_val > 1e-3
slope_dist = []
quantum_efficiency_dist = []
threshold_dist = []
threshold_fit_x = np.linspace(0.05, 0.09, 100)
threshold_fit_y_dist = []
# Jackknife fit to find root.
for i in range(len(norm_power_val[sel])):
x = np.delete(norm_current[sel], i)
y_val = np.delete(norm_power_val[sel], i)
y_err = np.delete(norm_power_err[sel], i)
popt, pconv = op.curve_fit(linear, x, y_val, sigma=y_err)
a, b = popt
root = -b / a
threshold_dist.append(root)
threshold_fit_y_dist.append(linear(threshold_fit_x, *popt))
slope_dist.append(a)
quantum_efficiency_dist.append(a * electron_charge / hbar_omega)
threshold_val, threshold_err = bootstrap.average_and_std_arrays(
threshold_dist)
threshold_fit_y_val, threshold_fit_y_err = bootstrap.average_and_std_arrays(
threshold_fit_y_dist)
differential_efficiency_val, differential_efficiency_err = bootstrap.average_and_std_arrays(
slope_dist)
quantum_efficiency_val, quantum_efficiency_err = bootstrap.average_and_std_arrays(
quantum_efficiency_dist)
T['threshold'] = siunitx(threshold_val, threshold_err)
T['differential_efficiency'] = siunitx(differential_efficiency_val,
differential_efficiency_err)
T['quantum_efficiency'] = siunitx(quantum_efficiency_val,
quantum_efficiency_err)
np.savetxt(
'_build/xy/diode_normal-band.tsv',
bootstrap.pgfplots_error_band(threshold_fit_x, threshold_fit_y_val,
threshold_fit_y_err))
# Compare ratios of damped and normal power in the overlap range.
ratio_dist = []
x = np.linspace(70.1e-3, 86.9e-3, 20)
for norm_power, damp_power in zip(norm_power_dist, damp_power_dist):
norm_inter = scipy.interpolate.interp1d(norm_current, norm_power)
damp_inter = scipy.interpolate.interp1d(damp_current, damp_power)
a = norm_inter(x)
b = damp_inter(x)
ratio = a / b
ratio_dist.append(ratio)
ratio_val, ratio_err = bootstrap.average_and_std_arrays(ratio_dist)
extinction_dist = np.array(ratio_dist).flatten()
extinction_val, extinction_err = np.mean(ratio_dist), np.std(ratio_dist)
T['extinction'] = siunitx(extinction_val, extinction_err)
np.savetxt('_build/xy/diode-ratio-line.tsv',
np.column_stack([x, ratio_val]))
np.savetxt('_build/xy/diode-ratio-band.tsv',
bootstrap.pgfplots_error_band(x, ratio_val, ratio_err))
return extinction_dist
def job_harmonic_power(T, extinction_dist, input_popt_dist):
data = np.loadtxt('Data/harmonic_splitter.tsv')
angle = data[:, 0]
power_val = data[:, 1] * 1e-6
power_err = data[:, 2] * 1e-6
T['harmonic_splitter_table'] = list(
zip(
siunitx(angle),
siunitx(power_val * 1e6, power_err * 1e6),
))
power_dist = bootstrap.make_dist(power_val, power_err)
fit_x = np.linspace(np.min(angle), np.max(angle), 200)
fit_y_dist = []
angle_offset_dist = []
a_dist = []
b_dist = []
popt_dist = []
for power in power_dist:
popt, pconv = op.curve_fit(cos_quartic,
angle,
power,
p0=[1.5e-5, 0, 0])
fit_y_dist.append(cos_quartic(fit_x, *popt))
angle_offset_dist.append(popt[1])
a = popt[0]
b = popt[2]
a_dist.append(a)
b_dist.append(b)
popt_dist.append(popt)
fit_y_val, fit_y_err = bootstrap.average_and_std_arrays(fit_y_dist)
angle_offset_val, angle_offset_err = bootstrap.average_and_std_arrays(
angle_offset_dist)
a_val, a_err = bootstrap.average_and_std_arrays(a_dist)
b_val, b_err = bootstrap.average_and_std_arrays(b_dist)
np.savetxt('_build/xy/harmonic-splitter-data.tsv',
np.column_stack([angle, power_val, power_err]))
np.savetxt('_build/xy/harmonic-splitter-fit.tsv',
np.column_stack([fit_x, fit_y_val]))
np.savetxt('_build/xy/harmonic-splitter-band.tsv',
bootstrap.pgfplots_error_band(fit_x, fit_y_val, fit_y_err))
T['splitter_angle_offset'] = siunitx(angle_offset_val, angle_offset_err)
T['splitter_a'] = siunitx(a_val, a_err)
T['splitter_b'] = siunitx(b_val, b_err)
efficiency_dist = []
efficiency_sq_dist = []
for extinction, input_popt, popt in zip(extinction_dist, input_popt_dist,
popt_dist):
efficiency = popt[0] / (input_popt[0] * extinction)
efficiency_dist.append(efficiency)
efficiency_sq = popt[0] / (input_popt[0] * extinction)**2
efficiency_sq_dist.append(efficiency_sq)
efficiency_val, efficiency_err = bootstrap.average_and_std_arrays(
efficiency_dist)
efficiency_sq_val, efficiency_sq_err = bootstrap.average_and_std_arrays(
efficiency_sq_dist)
T['efficiency'] = siunitx(efficiency_val, efficiency_err)
T['efficiency_sq'] = siunitx(efficiency_sq_val, efficiency_sq_err)
def job_rayleigh_length(T):
beam_diameter_val = 3.5e-3
beam_diameter_err = 0.5e-3
refractive_index = 2.2
wavelength = 987e-9
length = 5e-3
distance = 60e-3
beam_radius_val = beam_diameter_val / 2
beam_radius_err = beam_diameter_err / 2
T['beam_radius'] = siunitx(beam_radius_val, beam_radius_err)
beam_radius_dist = bootstrap.make_dist(beam_radius_val, beam_diameter_err)
theta_dist = [
np.arctan(beam_radius / distance) for beam_radius in beam_radius_dist
]
theta_val, theta_err = bootstrap.average_and_std_arrays(theta_dist)
T['theta'] = siunitx(theta_val, theta_err)
bootstrap.save_hist(theta_dist, '_build/dist-theta.pdf')
waist_dist = [wavelength / (np.pi * theta) for theta in theta_dist]
waist_val, waist_err = bootstrap.average_and_std_arrays(waist_dist)
T['waist_mum'] = siunitx(waist_val / 1e-6, waist_err / 1e-6)
bootstrap.save_hist(waist_dist, '_build/dist-waist.pdf')
rayleigh_length_dist = list(
itertools.filterfalse(np.isnan, [
refractive_index * np.pi * waist**2 / wavelength
for waist in waist_dist
]))
rayleigh_length_val, rayleigh_length_err = bootstrap.average_and_std_arrays(
rayleigh_length_dist)
T['rayleigh_length_mm'] = siunitx(rayleigh_length_val / 1e-3,
rayleigh_length_err / 1e-3,
error_digits=2)
bootstrap.save_hist(rayleigh_length_dist,
'_build/dist-rayleigh_length.pdf')
normalized_length_dist = list([
length / (2 * rayleigh_length)
for rayleigh_length in rayleigh_length_dist
])
normalized_length_val, normalized_length_err = bootstrap.average_and_std_arrays(
normalized_length_dist)
T['normalized_length'] = siunitx(normalized_length_val,
normalized_length_err,
error_digits=2)
bootstrap.save_hist(normalized_length_dist,
'_build/dist-normalized_length.pdf')
t = (normalized_length_val - 2.84) / normalized_length_err
T['boyd_kleinman_ttest_t'] = siunitx(t)
optimal_focal_length_dist = list([
get_optimal_focal_length(beam_radius, refractive_index, wavelength,
length) for beam_radius in beam_radius_dist
])
optimal_focal_length_val, optimal_focal_length_err = bootstrap.average_and_std_arrays(
optimal_focal_length_dist)
T['optimal_focal_length_mm'] = siunitx(optimal_focal_length_val / 1e-3,
optimal_focal_length_err / 1e-3,
error_digits=2)
