def print_batch_values(self, int_keys):
"""Prints all of the batch/ensemble values."""
beta_int_key_list = zip(self.batch_names_sorted, int_keys)
values_header = [r"$\beta$", r"$L/a$", r"$t_0/a^2$",
r"$\langle Q^2 \rangle$", r"$\langle Q^4 \rangle$",
r"$\langle Q^4 \rangle_C$", r"$R$"]
values_table = [
[self.beta_values[bn] for bn in self.batch_names],
["{:.2f}".format(self.data_values[bn][k]["aL"])
for bn, k in beta_int_key_list],
[sciprint(self.data_values[bn][k]["Q2"],
self.data_values[bn][k]["Q2Err"])
for bn, k in beta_int_key_list],
[sciprint(self.t0[bn]["t0"], self.t0[bn]["t0err"])
for bn, k in beta_int_key_list],
[sciprint(self.data_values[bn][k]["Q4"],
self.data_values[bn][k]["Q4Err"])
for bn, k in beta_int_key_list],
[sciprint(self.data_values[bn][k]["Q4C"],
self.data_values[bn][k]["Q4CErr"])
for bn, k in beta_int_key_list],
[sciprint(self.data_values[bn][k]["R"],
self.data_values[bn][k]["RErr"])
for bn, k in beta_int_key_list],
]
values_table_printer = TablePrinter(values_header, values_table)
values_table_printer.print_table(width=15)
def print_batch_values(self):
"""Prints all of the batch/ensemble values."""
values_header = [
r"Ensemble", r"$L/a$", r"$t_0/a^2$", r"$\langle Q^2 \rangle$",
r"$\langle Q^4 \rangle$", r"$\langle Q^4 \rangle_C$", r"$R$"
]
values_table = [
[self.ensemble_names[bn] for bn in self.sorted_batch_names],
[
"{:.2f}".format(self.data_values[bn]["aL"])
for bn in self.sorted_batch_names
],
[
sciprint(self.t0[bn]["t0"], self.t0[bn]["t0err"])
for bn in self.sorted_batch_names
],
[
sciprint(self.data_values[bn]["Q2"],
self.data_values[bn]["Q2Err"])
for bn in self.sorted_batch_names
],
[
sciprint(self.data_values[bn]["Q4"],
self.data_values[bn]["Q4Err"])
for bn in self.sorted_batch_names
],
[
sciprint(self.data_values[bn]["Q4C"],
self.data_values[bn]["Q4CErr"])
for bn in self.sorted_batch_names
],
[
sciprint(self.data_values[bn]["R"],
self.data_values[bn]["RErr"])
for bn in self.sorted_batch_names
],
]
values_table_printer = TablePrinter(values_header, values_table)
values_table_printer.print_table(width=15)
print "Reference scale: "
def _print_data(self, atype="bootstrap"):
"""Prints data."""
article_param_header = [
r"Lattice",
r"$\beta$",
r"$L/a$",
r"$L[\fm]$",
r"$a[\fm]$",
r"$t_0/{a^2}$",
r"$t_0/{r_0^2}$",
]
art_flat = self.article_flattened
article_param_table = [
art_flat.keys(),
[art_flat[k]["beta"] for k in art_flat],
[art_flat[k]["L"] for k in art_flat],
[art_flat[k]["aL"] for k in art_flat],
[art_flat[k]["a"] for k in art_flat],
[
sciprint(art_flat[k]["t0"], art_flat[k]["t0err"], prec=4)
for k in art_flat
],
[
sciprint(art_flat[k]["t0r02"],
art_flat[k]["t0r02err"],
prec=4,
force_prec=True) for k in art_flat
],
]
art_param_table_printer = TablePrinter(article_param_header,
article_param_table,
clean_column_duplicates=[1])
art_param_table_printer.print_table(width=15,
row_seperator=r"\addlinespace",
row_seperator_positions=[5, 7, 9])
article_values_header = [
r"Lattice", r"$\langle Q^2 \rangle$", r"$\langle Q^4 \rangle$",
r"$\langle Q^4 \rangle_C$", r"$R$"
]
article_values_table = [
art_flat.keys(),
[
sciprint(art_flat[k]["Q2"], art_flat[k]["Q2Err"], prec=3)
for k in art_flat
],
[
sciprint(art_flat[k]["Q4"], art_flat[k]["Q4Err"], prec=2)
for k in art_flat
],
[
sciprint(art_flat[k]["Q4C"], art_flat[k]["Q4CErr"], prec=3)
for k in art_flat
],
[
sciprint(art_flat[k]["R"], art_flat[k]["RErr"], prec=3)
for k in art_flat
],
]
art_values_table_printer = TablePrinter(article_values_header,
article_values_table)
art_values_table_printer.print_table(width=15,
row_seperator=r"\addlinespace",
row_seperator_positions=[5, 7, 9])
article_normed_header = [
r"Lattice", r"$\langle Q^2 \rangle_\text{normed}$",
r"$\langle Q^4 \rangle_\text{normed}$",
r"$\langle Q^4 \rangle_{C,\text{normed}}$", r"$R_\text{normed}$"
]
article_normed_table = [
art_flat.keys(),
[
sciprint(art_flat[k]["Q2_norm"],
art_flat[k]["Q2Err_norm"],
prec=3) for k in art_flat
],
[
sciprint(art_flat[k]["Q4_norm"],
art_flat[k]["Q4Err_norm"],
prec=3) for k in art_flat
],
[
sciprint(art_flat[k]["Q4C_norm"],
art_flat[k]["Q4CErr_norm"],
prec=3) for k in art_flat
],
[
sciprint(art_flat[k]["R_norm"],
art_flat[k]["RErr_norm"],
prec=3) for k in art_flat
],
]
art_normed_table_printer = TablePrinter(article_normed_header,
article_normed_table)
art_normed_table_printer.print_table(width=15,
row_seperator=r"\addlinespace",
row_seperator_positions=[5, 7, 9])
ratio_header = [
r"Lattice", r"Ensemble", r"$\text{Ratio}(\langle Q^2 \rangle)$",
r"$\text{Ratio}(\langle Q^4 \rangle)$",
r"$\text{Ratio}(\langle Q^4 \rangle_C)$", r"$\text{Ratio}(R)$"
]
ratio_table = []
for fk in self.article_flattened:
for bn in self.sorted_batch_names:
sub_list = []
sub_list.append(fk)
sub_list.append(self.ensemble_names[bn])
sub_list.append(
sciprint(self.data_ratios[fk][bn]["Q2"],
self.data_ratios[fk][bn]["Q2Err"]))
sub_list.append(
sciprint(self.data_ratios[fk][bn]["Q4"],
self.data_ratios[fk][bn]["Q4Err"]))
sub_list.append(
sciprint(self.data_ratios[fk][bn]["Q4C"],
self.data_ratios[fk][bn]["Q4CErr"]))
sub_list.append(
sciprint(self.data_ratios[fk][bn]["R"],
self.data_ratios[fk][bn]["RErr"]))
ratio_table.append(sub_list)
ratio_table = np.asarray(ratio_table).T.tolist()
ratio_tab_pos = (4 * np.arange(len(self.article_flattened))) - 1
ratio_table_printer = TablePrinter(ratio_header,
ratio_table,
clean_column_duplicates=[0, 1])
ratio_table_printer.print_table(width=15,
row_seperator=r"\addlinespace",
row_seperator_positions=ratio_tab_pos)
print "Reference scale t0(my data): %s" % self.t0
def _print_data(self, int_keys, atype="bootstrap"):
"""Prints data."""
article_param_header = [
r"Lattice",
r"$\beta$",
r"$L/a$",
r"$L[\fm]$",
r"$a[\fm]$",
r"$t_0/{a^2}$",
r"$t_0/{r_0^2}$",
]
art_flat = self.article_flattened
article_param_table = [
art_flat.keys(),
[art_flat[k]["beta"] for k in art_flat],
[art_flat[k]["L"] for k in art_flat],
[art_flat[k]["aL"] for k in art_flat],
[art_flat[k]["a"] for k in art_flat],
[
sciprint(art_flat[k]["t0"], art_flat[k]["t0err"], prec=4)
for k in art_flat
],
[
sciprint(art_flat[k]["t0r02"],
art_flat[k]["t0r02err"],
prec=4,
force_prec=True) for k in art_flat
],
]
art_param_table_printer = TablePrinter(article_param_header,
article_param_table)
art_param_table_printer.print_table(width=15,
row_seperator_positions=[5, 7, 9])
article_values_header = [
r"Lattice", r"$\langle Q^2 \rangle$", r"$\langle Q^4 \rangle$",
r"$\langle Q^4 \rangle_C$", r"$R$"
]
article_values_table = [
art_flat.keys(),
[
sciprint(art_flat[k]["Q2"], art_flat[k]["Q2Err"], prec=3)
for k in art_flat
],
[
sciprint(art_flat[k]["Q4"], art_flat[k]["Q4Err"], prec=2)
for k in art_flat
],
[
sciprint(art_flat[k]["Q4C"], art_flat[k]["Q4CErr"], prec=3)
for k in art_flat
],
[
sciprint(art_flat[k]["R"], art_flat[k]["RErr"], prec=3)
for k in art_flat
],
]
art_values_table_printer = TablePrinter(article_values_header,
article_values_table)
art_values_table_printer.print_table(width=15,
row_seperator_positions=[5, 7, 9])
article_normed_header = [
r"Lattice", r"$\langle Q^2 \rangle_\text{normed}$",
r"$\langle Q^4 \rangle_\text{normed}$",
r"$\langle Q^4 \rangle_{C,\text{normed}}$", r"$R_\text{normed}$"
]
article_normed_table = [
art_flat.keys(),
[
sciprint(art_flat[k]["Q2_norm"],
art_flat[k]["Q2Err_norm"],
prec=3) for k in art_flat
],
[
sciprint(art_flat[k]["Q4_norm"],
art_flat[k]["Q4Err_norm"],
prec=3) for k in art_flat
],
[
sciprint(art_flat[k]["Q4C_norm"],
art_flat[k]["Q4CErr_norm"],
prec=3) for k in art_flat
],
[
sciprint(art_flat[k]["R_norm"],
art_flat[k]["RErr_norm"],
prec=3) for k in art_flat
],
]
art_normed_table_printer = TablePrinter(article_normed_header,
article_normed_table)
art_normed_table_printer.print_table(width=15,
row_seperator_positions=[5, 7, 9])
beta_int_key_list = zip(self.beta_values, int_keys)
values_header = [
r"$\beta$", r"$L/a$", r"$t_0/a^2$", r"$\langle Q^2 \rangle$",
r"$\langle Q^4 \rangle$", r"$\langle Q^4 \rangle_C$", r"$R$"
]
values_table = [
[b for b in self.beta_values],
[
"{:.2f}".format(self.data_values[b][k]["aL"])
for b, k in beta_int_key_list
],
[
sciprint(self.data_values[b][k]["Q2"],
self.data_values[b][k]["Q2Err"])
for b, k in beta_int_key_list
],
[
sciprint(self.t0[b]["t0"], self.t0[b]["t0err"])
for b, k in beta_int_key_list
],
[
sciprint(self.data_values[b][k]["Q4"],
self.data_values[b][k]["Q4Err"])
for b, k in beta_int_key_list
],
[
sciprint(self.data_values[b][k]["Q4C"],
self.data_values[b][k]["Q4CErr"])
for b, k in beta_int_key_list
],
[
sciprint(self.data_values[b][k]["R"],
self.data_values[b][k]["RErr"])
for b, k in beta_int_key_list
],
]
values_table_printer = TablePrinter(values_header, values_table)
values_table_printer.print_table(width=15)
ratio_header = [
r"Lattice", r"$\beta$", r"$\text{Ratio}(\langle Q^2 \rangle)$",
r"$\text{Ratio}(\langle Q^4 \rangle)$",
r"$\text{Ratio}(\langle Q^4 \rangle_C)$", r"$\text{Ratio}(R)$"
]
ratio_table = []
for fk in self.article_flattened:
for b, k in beta_int_key_list:
sub_list = []
sub_list.append(fk)
sub_list.append(b)
sub_list.append(
sciprint(self.data_ratios[fk][b][k]["Q2"],
self.data_ratios[fk][b][k]["Q2Err"]))
sub_list.append(
sciprint(self.data_ratios[fk][b][k]["Q4"],
self.data_ratios[fk][b][k]["Q4Err"]))
sub_list.append(
sciprint(self.data_ratios[fk][b][k]["Q4C"],
self.data_ratios[fk][b][k]["Q4CErr"]))
sub_list.append(
sciprint(self.data_ratios[fk][b][k]["R"],
self.data_ratios[fk][b][k]["RErr"]))
ratio_table.append(sub_list)
ratio_table = np.asarray(ratio_table).T.tolist()
ratio_tab_pos = (4 * np.arange(len(self.article_flattened))) - 1
ratio_table_printer = TablePrinter(ratio_header, ratio_table)
ratio_table_printer.print_table(width=15,
row_seperator_positions=ratio_tab_pos)
print "Reference scale t0(my data): %s" % self.t0
def get_w0_scale(self, extrapolation_method="bootstrap", W0=0.3, **kwargs):
"""
Method for retrieving the w0 reference scale setting, based on paper:
http://xxx.lanl.gov/pdf/1203.4469v2
"""
if self.verbose:
print "Scale w0 extraction method: " + extrapolation_method
print "Scale w0 extraction data: " + self.analysis_data_type
# Retrieves t0 values from data
a_values = []
a_values_err = []
w0_values = []
w0err_values = []
w0a_values = []
w0aerr_values = []
# Since we are slicing tau int, and it will only be ignored
# if it is None in extract_fit_targets, we set it manually
# if we have provided it.
for bn in self.sorted_batch_names:
bval = self.plot_values[bn]
# Sets correct tau int to pass to fit extraction
if "blocked" in self.analysis_data_type:
_tmp_tau_int = None
_tmp_tau_int_err = None
else:
_tmp_tau_int = bval["tau_int"][1:-1]
_tmp_tau_int_err = bval["tau_int_err"][1:-1]
y0, t_w0, t_w0_err, _, _ = extract_fit_target(
W0,
bval["tder"],
bval["W"],
y_err=bval["W_err"],
y_raw=bval["W_raw"],
tau_int=_tmp_tau_int,
tau_int_err=_tmp_tau_int_err,
extrapolation_method=extrapolation_method,
plateau_size=10,
inverse_fit=True,
**kwargs)
# NOTE: w0 has units of [fm].
# t_w0 = a^2 * t_f / r0^2
# Returns t_w0 = (w0)^2 / r0^2.
# Lattice spacing
a_values.append(bval["a"]**2)
a_values_err.append(2 * bval["a_err"] * bval["a"])
# Plain w_0 retrieval
w0_values.append(np.sqrt(t_w0))
w0err_values.append(0.5 * t_w0_err / np.sqrt(t_w0))
# w_0 / a
w0a_values.append(np.sqrt(t_w0) / bval["a"])
w0aerr_values.append(
np.sqrt((t_w0_err / (2 * np.sqrt(t_w0)) / bval["a"])**2 +
(np.sqrt(t_w0) * bval["a_err"] / bval["a"]**2)**2))
# Reverse lists and converts them to arrays
a_values = np.asarray(a_values[::-1])
a_values_err = np.asarray(a_values_err[::-1])
w0_values = np.asarray(w0_values[::-1])
w0err_values = np.asarray(w0err_values[::-1])
w0a_values, w0aerr_values = map(np.asarray,
(w0a_values, w0aerr_values))
# Extrapolates t0 to continuum
N_cont = 1000
a_squared_cont = np.linspace(-0.00025, a_values[-1] * 1.1, N_cont)
# Fits to continuum and retrieves values to be plotted
continuum_fit = LineFit(a_values, w0_values, y_err=w0err_values)
y_cont, y_cont_err, fit_params, chi_squared = \
continuum_fit.fit_weighted(a_squared_cont)
res = continuum_fit(0, weighted=True)
self.w0_cont = res[0][0]
self.w0_cont_error = (res[1][-1][0] - res[1][0][0]) / 2
# self.sqrt8w0_cont = np.sqrt(8*self.w0_cont)
# self.sqrt8w0_cont_error = 4*self.w0_cont_error/np.sqrt(8*self.w0_cont)
# Creates continuum extrapolation plot
fname = os.path.join(
self.output_folder_path,
"post_analysis_extrapmethod%s_w0reference_continuum_%s.pdf" %
(extrapolation_method, self.analysis_data_type))
self.plot_continuum_fit(a_squared_cont,
y_cont,
y_cont_err,
chi_squared,
a_values,
a_values_err,
w0_values,
w0err_values,
0,
0,
self.w0_cont,
self.w0_cont_error,
r"w_{0,\mathrm{cont}}",
fname,
r"$w_0[\mathrm{fm}]$",
r"$a^2[\mathrm{GeV}^{-2}]$",
y_limits=[0.1625, 0.1750],
cont_label_unit=" fm")
# Reverses values for storage.
a_values, a_values_err, w0_values, w0err_values, = map(
lambda k: np.flip(k, 0),
(a_values, a_values_err, w0_values, w0err_values))
# Populates dictionary with w0 values for each batch
_tmp_batch_dict = {
bn: {
"w0":
w0_values[i],
"w0err":
w0err_values[i],
"w0a":
w0a_values[i],
"w0aerr":
w0aerr_values[i],
"w0r0":
w0_values[i] / self.r0,
"w0r0err":
w0err_values[i] / self.r0,
"aL":
self.plot_values[bn]["a"] * self.lattice_sizes[bn][0],
"aLerr":
(self.plot_values[bn]["a_err"] * self.lattice_sizes[bn][0]),
"L":
self.lattice_sizes[bn][0],
"a":
self.plot_values[bn]["a"],
"a_err":
self.plot_values[bn]["a_err"],
}
for i, bn in enumerate(self.sorted_batch_names)
}
# Populates dictionary with continuum w0 value
w0_dict = {
"w0cont": self.w0_cont,
"w0cont_err": self.w0_cont_error,
}
w0_dict.update(_tmp_batch_dict)
if self.verbose:
print "w0 reference values table: "
print "w0 = %.16f +/- %.16f" % (self.w0_cont, self.w0_cont_error)
print "chi^2/dof = %.16f" % chi_squared
for bn in self.sorted_batch_names:
msg = "beta = %.2f" % self.beta_values[bn]
msg += " || w0 = %10f +/- %-10f" % (w0_dict[bn]["w0"],
w0_dict[bn]["w0err"])
msg += " || w0/a = %10f +/- %-10f" % (w0_dict[bn]["w0a"],
w0_dict[bn]["w0aerr"])
msg += " || w0/r0 = %10f +/- %-10f" % (w0_dict[bn]["w0r0"],
w0_dict[bn]["w0r0err"])
print msg
if self.print_latex:
# Header:
# beta w0 a^2 L/a L a
header = [
r"Ensemble",
r"$w_0[\fm]$",
# r"$a^2[\mathrm{GeV}^{-2}]$",
r"$w_0/a$",
r"$L/a$",
r"$L[\fm]$",
r"$a[\fm]$"
]
bvals = self.sorted_batch_names
tab = [
[r"{0:s}".format(self.ensemble_names[bn]) for bn in bvals],
[
r"{0:s}".format(
sciprint.sciprint(w0_dict[bn]["w0"],
w0_dict[bn]["w0err"]))
for bn in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(w0_dict[bn]["w0a"],
w0_dict[bn]["w0aerr"]))
for bn in bvals
],
# [r"{0:s}".format(sciprint.sciprint(
# self.plot_values[bn]["a"]**2,
# self.plot_values[bn]["a_err"]*2*self.plot_values[bn]["a"]))
# for bn in bvals],
[r"{0:d}".format(self.lattice_sizes[bn][0]) for bn in bvals],
[
r"{0:s}".format(
sciprint.sciprint(
self.lattice_sizes[bn][0] *
self.plot_values[bn]["a"],
self.lattice_sizes[bn][0] *
self.plot_values[bn]["a_err"])) for bn in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(self.plot_values[bn]["a"],
self.plot_values[bn]["a_err"]))
for bn in bvals
],
]
table_filename = "energy_w0_" + self.analysis_data_type
table_filename += "-".join(self.batch_names) + ".txt"
ptab = TablePrinter(header, tab)
ptab.print_table(latex=True, width=15, filename=table_filename)
return w0_dict
def get_t0_scale(self,
extrapolation_method="plateau_mean",
E0=0.3,
**kwargs):
"""
Method for retrieveing reference value t0 based on Luscher(2010),
Properties and uses of the Wilson flow in lattice QCD.
t^2<E_t>|_{t=t_0} = 0.3
Will return t0 values and make a plot of the continuum value
extrapolation.
Args:
extrapolation_method: str, optional. Method of t0 extraction.
Default is plateau_mean.
E0: float, optional. Default is 0.3.
Returns:
t0: dictionary of t0 values for each of the batches, and a
continuum value extrapolation.
"""
if self.verbose:
print "Scale t0 extraction method: " + extrapolation_method
print "Scale t0 extraction data: " + self.analysis_data_type
# Retrieves t0 values from data
a_values = []
a_values_err = []
t0_values = []
t0err_values = []
for bn in self.sorted_batch_names:
bval = self.plot_values[bn]
y0, t0, t0_err, _, _ = extract_fit_target(
E0,
bval["t"],
bval["y"],
y_err=bval["y_err"],
y_raw=bval[self.analysis_data_type],
tau_int=bval["tau_int"],
tau_int_err=bval["tau_int_err"],
extrapolation_method=extrapolation_method,
plateau_size=10,
inverse_fit=True,
**kwargs)
a_values.append(bval["a"]**2 / t0)
a_values_err.append(
np.sqrt((2 * bval["a_err"] * bval["a"] / t0)**2 +
(bval["a"]**2 * t0_err / t0**2)**2))
t0_values.append(t0)
t0err_values.append(t0_err)
a_values = np.asarray(a_values[::-1])
a_values_err = np.asarray(a_values_err[::-1])
t0_values = np.asarray(t0_values[::-1])
t0err_values = np.asarray(t0err_values[::-1])
# Functions for t0 and propagating uncertainty
def t0_func(_t0):
return np.sqrt(8 * _t0) / self.r0
def t0err_func(_t0, _t0_err): return _t0_err * \
np.sqrt(8/_t0)/(2.0*self.r0)
# Sets up t0 and t0_error values to plot
y = t0_func(t0_values)
yerr = t0err_func(t0_values, t0err_values)
# Extrapolates t0 to continuum
N_cont = 1000
a_squared_cont = np.linspace(-0.025, a_values[-1] * 1.1, N_cont)
# Fits to continuum and retrieves values to be plotted
continuum_fit = LineFit(a_values, y, y_err=yerr)
y_cont, y_cont_err, fit_params, chi_squared = \
continuum_fit.fit_weighted(a_squared_cont)
res = continuum_fit(0, weighted=True)
self.sqrt_8t0_cont = res[0][0]
self.sqrt_8t0_cont_error = (res[1][-1][0] - res[1][0][0]) / 2
self.t0_cont = self.sqrt_8t0_cont**2 / 8
self.t0_cont_error = self.sqrt_8t0_cont_error * np.sqrt(
self.t0_cont / 2.0)
# Creates continuum extrapolation figure
fname = os.path.join(
self.output_folder_path,
"post_analysis_extrapmethod%s_t0reference_continuum_%s.pdf" %
(extrapolation_method, self.analysis_data_type))
self.plot_continuum_fit(a_squared_cont, y_cont, y_cont_err,
chi_squared, a_values, a_values_err, y, yerr,
0, 0, self.sqrt_8t0_cont,
self.sqrt_8t0_cont_error,
r"\frac{\sqrt{8t_{0,\mathrm{cont}}}}{r_0}",
fname, r"$\frac{\sqrt{8t_0}}{r_0}$",
r"$a^2/t_0$")
self.extrapolation_method = extrapolation_method
# Reverses values for storage.
a_values, a_values_err, t0_values, t0err_values = map(
lambda k: np.flip(k, 0),
(a_values, a_values_err, t0_values, t0err_values))
_tmp_batch_dict = {
bn: {
"t0": t0_values[i],
"t0err": t0err_values[i],
"t0a2": t0_values[i]/self.plot_values[bn]["a"]**2,
# Including error term in lattice spacing, a
"t0a2err": np.sqrt((t0err_values[i] / \
self.plot_values[bn]["a"]**2)**2 \
+ (2*self.plot_values[bn]["a_err"] * \
t0_values[i] /\
self.plot_values[bn]["a"]**3)**2),
"t0r02": t0_values[i]/self.r0**2,
"t0r02err": t0err_values[i]/self.r0**2,
"aL": self.plot_values[bn]["a"]*self.lattice_sizes[bn][0],
"aLerr": (self.plot_values[bn]["a_err"] \
* self.lattice_sizes[bn][0]),
"L": self.lattice_sizes[bn][0],
"a": self.plot_values[bn]["a"],
"a_err": self.plot_values[bn]["a_err"],
}
for i, bn in enumerate(self.batch_names)
}
t0_dict = {"t0cont": self.t0_cont, "t0cont_err": self.t0_cont_error}
t0_dict.update(_tmp_batch_dict)
if self.verbose:
print "t0 reference values table: "
print "sqrt(8t0)/r0 = %.16f +/- %.16f" % (self.sqrt_8t0_cont,
self.sqrt_8t0_cont_error)
print "t0/r0^2 = %.16f +/- %.16f" % (self.t0_cont,
self.t0_cont_error)
print "chi^2/dof = %.16f" % chi_squared
for bn in self.batch_names:
msg = "beta = %.2f || t0 = %10f +/- %-10f" % (
self.beta_values[bn], t0_dict[bn]["t0"],
t0_dict[bn]["t0err"])
msg += " || t0/a^2 = %10f +/- %-10f" % (t0_dict[bn]["t0a2"],
t0_dict[bn]["t0a2err"])
msg += " || t0/r0^2 = %10f +/- %-10f" % (
t0_dict[bn]["t0r02"], t0_dict[bn]["t0r02err"])
print msg
if self.print_latex:
# Header:
# beta t0a2 t0r02 L/a L a
header = [
r"$\beta$", r"$t_0$[fm]", r"$t_0/a^2$", r"$t_0/r_0^2$",
r"$L/a$", r"$L[\fm]$", r"$a[\fm]$"
]
bvals = self.batch_names
tab = [
[r"{0:s}".format(self.ensemble_names[bn]) for bn in bvals],
[
r"{0:s}".format(
sciprint.sciprint(t0_dict[bn]["t0"],
t0_dict[bn]["t0err"]))
for bn in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(t0_dict[bn]["t0a2"],
t0_dict[bn]["t0a2err"]))
for bn in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(t0_dict[bn]["t0r02"],
t0_dict[bn]["t0r02err"]))
for bn in bvals
],
[r"{0:d}".format(self.lattice_sizes[bn][0]) for bn in bvals],
[
r"{0:s}".format(
sciprint.sciprint(
self.lattice_sizes[bn][0] *
self.plot_values[bn]["a"],
self.lattice_sizes[bn][0] *
self.plot_values[bn]["a_err"])) for bn in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(self.plot_values[bn]["a"],
self.plot_values[bn]["a_err"]))
for bn in bvals
],
]
table_filename = "energy_t0_" + self.analysis_data_type
table_filename += "-".join(self.batch_names) + ".txt"
ptab = TablePrinter(header, tab)
ptab.print_table(latex=True, width=15, filename=table_filename)
return t0_dict
def get_w0_scale(self,
extrapolation_method="plateau_mean",
W0=0.3,
**kwargs):
"""
Method for retrieving the w0 reference scale setting, based on paper:
http://xxx.lanl.gov/pdf/1203.4469v2
"""
if self.verbose:
print "Scale w0 extraction method: " + extrapolation_method
print "Scale w0 extraction data: " + self.analysis_data_type
# Retrieves t0 values from data
a_values = []
a_values_err = []
w0_values = []
w0err_values = []
for bn in self.sorted_batch_names:
bval = self.plot_values[bn]
y0, w0, w0_err, _, _ = extract_fit_target(
W0,
bval["xraw"],
bval["y"],
y_err=bval["y_err"],
y_raw=bval[self.analysis_data_type],
tau_int=bval["tau_int"][1:-1],
tau_int_err=bval["tau_int_err"][1:-1],
extrapolation_method=extrapolation_method,
plateau_size=10,
inverse_fit=True,
**kwargs)
# TODO: fix a lattice spacing error here @ w_t
a_values.append(bval["a"]**2)
a_values_err.append(2 * bval["a"] * bval["a_err"])
w0_values.append(np.sqrt(w0) * bval["a"])
w0err_values.append(0.5 * w0_err / np.sqrt(w0))
a_values = np.asarray(a_values[::-1])
a_values_err = np.asarray(a_values_err[::-1])
w0_values = np.asarray(w0_values[::-1])
w0err_values = np.asarray(w0err_values[::-1])
# # Functions for t0 and propagating uncertainty
# t0_func = lambda _t0: np.sqrt(8*_t0)/self.r0
# t0err_func = lambda _t0, _t0_err: _t0_err*np.sqrt(8/_t0)/(2.0*self.r0)
# # Sets up t0 and t0_error values to plot
# y = t0_func(t0_values)
# yerr = t0err_func(t0_values, t0err_values)
# Extrapolates t0 to continuum
N_cont = 1000
a_squared_cont = np.linspace(-0.00025, a_values[-1] * 1.1, N_cont)
# Fits to continuum and retrieves values to be plotted
continuum_fit = LineFit(a_values, w0_values, y_err=w0err_values)
y_cont, y_cont_err, fit_params, chi_squared = \
continuum_fit.fit_weighted(a_squared_cont)
res = continuum_fit(0, weighted=True)
self.w0_cont = res[0][0]
self.w0_cont_error = (res[1][-1][0] - res[1][0][0]) / 2
# self.t0_cont = self.sqrt_8t0_cont**2/8
# self.t0_cont_error = self.sqrt_8t0_cont_error*np.sqrt(self.t0_cont/2.0)
# Creates figure and plot window
fig = plt.figure()
ax = fig.add_subplot(111)
# Plots linefit with errorband
ax.plot(a_squared_cont,
y_cont,
color="tab:red",
alpha=0.5,
label=r"$\chi=%.2f$" % chi_squared)
ax.fill_between(a_squared_cont,
y_cont_err[0],
y_cont_err[1],
alpha=0.5,
edgecolor='',
facecolor="tab:red")
ax.axvline(0, linestyle="dashed", color="tab:red")
ax.errorbar(a_values,
w0_values,
xerr=a_values_err,
yerr=w0err_values,
fmt="o",
capsize=5,
capthick=1,
color="#000000",
ecolor="#000000")
ax.set_ylabel(r"$w_0[\mathrm{fm}]$")
ax.set_xlabel(r"$a^2[\mathrm{GeV}^{-2}]$")
ax.set_xlim(a_squared_cont[0], a_squared_cont[-1])
ax.legend()
ax.grid(True)
# Saves figure
fname = os.path.join(
self.output_folder_path,
"post_analysis_extrapmethod%s_w0reference_continuum_%s.pdf" %
(extrapolation_method, self.analysis_data_type))
fig.savefig(fname, dpi=self.dpi)
if self.verbose:
print "Figure saved in %s" % fname
plt.close(fig)
w0_values = w0_values[::-1]
w0err_values = w0err_values[::-1]
_tmp_beta_dict = {
b: {
"w0": w0_values[i],
"w0err": w0err_values[i],
"aL": self.plot_values[b]["a"]*self.lattice_sizes[b][0],
"aLerr": (self.plot_values[b]["a_err"] \
* self.lattice_sizes[b][0]),
"L": self.lattice_sizes[b][0],
"a": self.plot_values[bn]["a"],
"a_err": self.plot_values[b]["a_err"],
}
for i, b in enumerate(self.batch_names)
}
w0_dict = {"w0cont": self.w0_cont, "w0cont_err": self.w0_cont_error}
w0_dict.update(_tmp_beta_dict)
if self.verbose:
print "w0 reference values table: "
print "w0 = %.16f +/- %.16f" % (self.w0_cont, self.w0_cont_error)
for b in self.batch_names:
msg = "beta = %.2f || w0 = %10f +/- %-10f" % (
self.beta_values[b], w0_dict[b]["w0"], w0_dict[b]["w0err"])
print msg
if self.print_latex:
# Header:
# beta w0 a^2 L/a L a
header = [
r"$\beta$", r"$w_0[\fm]$", r"$a^2[\mathrm{GeV}^{-2}]$",
r"$L/a$", r"$L[\fm]$", r"$a[\fm]$"
]
bvals = self.sorted_batch_names
tab = [
[r"{0:.2f}".format(self.beta_values[b]) for b in bvals],
[
r"{0:s}".format(
sciprint.sciprint(w0_dict[b]["w0"],
w0_dict[b]["w0err"])) for b in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(
self.plot_values[b]["a"]**2,
self.plot_values[b]["a_err"] * 2 *
self.plot_values[b]["a"])) for b in bvals
],
[r"{0:d}".format(self.lattice_sizes[b][0]) for b in bvals],
[
r"{0:s}".format(
sciprint.sciprint(
self.lattice_sizes[b][0] *
self.plot_values[b]["a"],
self.lattice_sizes[b][0] *
self.plot_values[b]["a_err"])) for b in bvals
],
[
r"{0:s}".format(
sciprint.sciprint(self.plot_values[b]["a"],
self.plot_values[b]["a_err"]))
for b in bvals
],
]
ptab = TablePrinter(header, tab)
ptab.print_table(latex=True, width=15)
def get_t0_scale(self, extrapolation_method="plateau_mean", E0=0.3, **kwargs):
"""
Method for retrieveing reference value t0 based on Luscher(2010),
Properties and uses of the Wilson flow in lattice QCD.
t^2<E_t>|_{t=t_0} = 0.3
Will return t0 values and make a plot of the continuum value
extrapolation.
Args:
extrapolation_method: str, optional. Method of t0 extraction.
Default is plateau_mean.
E0: float, optional. Default is 0.3.
Returns:
t0: dictionary of t0 values for each of the betas, and a continuum
value extrapolation.
"""
if self.verbose:
print "Scale t0 extraction method: " + extrapolation_method
print "Scale t0 extraction data: " + self.analysis_data_type
# Retrieves t0 values from data
a_values = []
a_values_err = []
t0_values = []
t0err_values = []
for beta, bval in sorted(self.plot_values.items(), key=lambda i: i[0]):
y0, t0, t0_err, _, _ = extract_fit_target(E0, bval["t"], bval["y"],
y_err=bval["y_err"], y_raw=bval[self.analysis_data_type],
tau_int=bval["tau_int"], tau_int_err=bval["tau_int_err"],
extrapolation_method=extrapolation_method, plateau_size=10,
inverse_fit=True, **kwargs)
a_values.append(bval["a"]**2/t0)
a_values_err.append(np.sqrt((2*bval["a_err"]*bval["a"]/t0)**2 \
+ (bval["a"]**2*t0_err/t0**2)**2))
t0_values.append(t0)
t0err_values.append(t0_err)
a_values = np.asarray(a_values[::-1])
a_values_err = np.asarray(a_values_err[::-1])
t0_values = np.asarray(t0_values[::-1])
t0err_values = np.asarray(t0err_values[::-1])
# Functions for t0 and propagating uncertainty
t0_func = lambda _t0: np.sqrt(8*_t0)/self.r0
t0err_func = lambda _t0, _t0_err: _t0_err*np.sqrt(8/_t0)/(2.0*self.r0)
# Sets up t0 and t0_error values to plot
y = t0_func(t0_values)
yerr = t0err_func(t0_values, t0err_values)
# Extrapolates t0 to continuum
N_cont = 1000
a_squared_cont = np.linspace(-0.025, a_values[-1]*1.1, N_cont)
# Fits to continuum and retrieves values to be plotted
continuum_fit = LineFit(a_values, y, y_err=yerr)
y_cont, y_cont_err, fit_params, chi_squared = \
continuum_fit.fit_weighted(a_squared_cont)
res = continuum_fit(0, weighted=True)
self.sqrt_8t0_cont = res[0][0]
self.sqrt_8t0_cont_error = (res[1][-1][0] - res[1][0][0])/2
self.t0_cont = self.sqrt_8t0_cont**2/8
self.t0_cont_error = self.sqrt_8t0_cont_error*np.sqrt(self.t0_cont/2.0)
# Creates figure and plot window
fig = plt.figure()
ax = fig.add_subplot(111)
# Plots linefit with errorband
ax.plot(a_squared_cont, y_cont, color="tab:red", alpha=0.5,
label=r"$\chi=%.2f$" % chi_squared)
ax.fill_between(a_squared_cont, y_cont_err[0],
y_cont_err[1], alpha=0.5, edgecolor='',
facecolor="tab:red")
ax.axvline(0, linestyle="dashed", color="tab:red")
ax.errorbar(a_values, y, xerr=a_values_err, yerr=yerr, fmt="o", capsize=5,
capthick=1, color="#000000", ecolor="#000000")
ax.set_ylabel(r"$\sqrt{8t_0}/r_0$")
ax.set_xlabel(r"$a^2/t_0$")
ax.set_xlim(a_squared_cont[0], a_squared_cont[-1])
ax.legend()
ax.grid(True)
# Saves figure
fname = os.path.join(self.output_folder_path,
"post_analysis_extrapmethod%s_t0reference_continuum_%s.png" % (
extrapolation_method, self.analysis_data_type))
fig.savefig(fname, dpi=self.dpi)
if self.verbose:
print "Figure saved in %s" % fname
plt.close(fig)
self.extrapolation_method = extrapolation_method
_tmp_beta_dict = {
b: {
"t0": t0_values[i],
"t0err": t0err_values[i],
"t0a2": t0_values[i]/self.plot_values[b]["a"]**2,
# Including error term in lattice spacing, a
"t0a2err": np.sqrt((t0err_values[i]/self.plot_values[b]["a"]**2)**2 \
+ (2*self.plot_values[b]["a_err"]*t0_values[i]/self.plot_values[b]["a"]**3)**2),
"t0r02": t0_values[i]/self.r0**2,
"t0r02err": t0err_values[i]/self.r0**2,
"aL": self.plot_values[b]["a"]*self.lattice_sizes[b][0],
"aLerr": (self.plot_values[b]["a_err"] \
* self.lattice_sizes[b][0]),
"L": self.lattice_sizes[b][0],
"a": self.plot_values[beta]["a"],
"a_err": self.plot_values[b]["a_err"],
}
for i, b in enumerate(self.beta_values)
}
t0_dict = {"t0cont": self.t0_cont, "t0cont_err": self.t0_cont_error}
t0_dict.update(_tmp_beta_dict)
if self.verbose:
print "t0 reference values table: "
print "sqrt(8t0)/r0 = %.16f +/- %.16f" % (self.sqrt_8t0_cont,
self.sqrt_8t0_cont_error)
print "t0 = %.16f +/- %.16f" % (self.t0_cont,
self.t0_cont_error)
for b in self.beta_values:
msg = "beta = %.2f || t0 = %10f +/- %-10f" % (b,
t0_dict[b]["t0"], t0_dict[b]["t0err"])
msg += " || t0/a^2 = %10f +/- %-10f" % (t0_dict[b]["t0a2"],
t0_dict[b]["t0a2err"])
msg += " || t0/a^2 = %10f +/- %-10f" % (t0_dict[b]["t0a2"],
t0_dict[b]["t0a2err"])
msg += " || t0/r0^2 = %10f +/- %-10f" % (t0_dict[b]["t0r02"],
t0_dict[b]["t0r02err"])
print msg
if self.print_latex:
# Header:
# beta t0a2 t0r02 L/a L a
header = [r"$\beta$", r"$t_0/a^2$", r"$t_0/{r_0^2}$", r"$L/a$",
r"$L[\fm]$", r"$a[\fm]$"]
bvals = self.beta_values
tab = [
[r"{0:.2f}".format(b) for b in bvals],
[r"{0:s}".format(sciprint.sciprint(t0_dict[b]["t0a2"],
t0_dict[b]["t0a2err"])) for b in bvals],
[r"{0:s}".format(sciprint.sciprint(t0_dict[b]["t0r02"],
t0_dict[b]["t0r02err"])) for b in bvals],
[r"{0:d}".format(self.lattice_sizes[b][0]) for b in bvals],
[r"{0:s}".format(sciprint.sciprint(
self.lattice_sizes[b][0]*self.plot_values[b]["a"],
self.lattice_sizes[b][0]*self.plot_values[b]["a_err"]))
for b in bvals],
[r"{0:s}".format(sciprint.sciprint(
self.plot_values[b]["a"],
self.plot_values[b]["a_err"])) for b in bvals],
]
ptab = TablePrinter(header, tab)
ptab.print_table(latex=True, width=15)
return t0_dict