def plot_speedup(sc_list, sc_type): """Plots the speedup of a program.""" fig, axes = plt.subplots(nrows=3, ncols=1) sc_list = [ x for _, x in sorted(zip(["gen", "flow", "io"], sc_list), key=lambda k: k[1]["sc"]) ] sc_list = [sc_list[1], sc_list[0], sc_list[2]] # Bad hard coding for i, data in enumerate(sc_list): data["y"] = data["y"][0] / data["y"] print "Speedup and parallelizability for %s:" % data["label"] f = amdahls_law_inverse(data["y"], data["x"]) # Makes a linear fit of the values above p=256 L = LineFit(data["x"], f) L.fit() sc_list[i]["f"] = np.mean(f[4:]) sc_list[i]["f_err"] = np.std(f[4:]) sc_list[i]["Sp"] = amdahls_law(data["x"], sc_list[i]["f"]) sc_list[i]["Sp_err"] = amdahls_law_error(data["x"], sc_list[i]["f"], sc_list[i]["f_err"]) for p_, y_, f_ in zip(data["x"], data["y"], f): print "p = %5d S(p) = %10.4f f = %f" % (p_, y_, f_) for data, ax in zip(sc_list, axes): ax.semilogx(data["x"], data["y"], "o-", label=data["label"]) # ax.plot(data["x"], data["Sp"], "o-", label=r"Amdahl's law, $f=%.2f$" % data["f"], color=fit_color) # ax.fill_between(data["x"], data["Sp"] - data["Sp_err"], data["Sp"] + data["Sp_err"], alpha=0.5, # edgecolor="", facecolor=fit_fill_color) ax.set_xlabel(data["xlabel"]) ax.set_ylabel(data["ylabel_speedup"]) ax.grid(True) ax.legend(loc="lower right") figpath = os.path.join(data["figure_folder"], "speedup_" + sc_type + "_all" + ".pdf") fig.savefig(figpath) print "Figure {} created.".format(figpath)
def plot_continuum(self, fit_target, title_addendum="", extrapolation_method="bootstrap", plateau_fit_size=20, interpolation_rank=3, plot_continuum_fit=False): """Method for plotting the continuum limit of topsus at a given fit_target. Args: fit_target: float or str. If float, will choose corresponding float time t_f value of where we extrapolate from. If string, one can choose either 't0', 't0cont', 'w0' and 'w0cont'. 't0' and 'w0' will use values for given batch. For 't0cont' and 'w0cont' will use extrapolated values to select topsus values from. title_addendum: str, optional, default is an empty string, ''. Adds string to end of title. extrapolation_method: str, optional, method of selecting the extrapolation point to do the continuum limit. Method will be used on y values and tau int. Choices: - plateau: line fits points neighbouring point in order to reduce the error bars using y_raw for covariance matrix. - plateau_mean: line fits points neighbouring point in order to reduce the error bars. Line will be weighted by the y_err. - nearest: line fit from the point nearest to what we seek - interpolate: linear interpolation in order to retrieve value and error. Does not work in conjecture with use_raw_values. - bootstrap: will create multiple line fits, and take average. Assumes y_raw is the bootstrapped or jackknifed samples. plateau_size: int, optional. Number of points in positive and negative direction to extrapolate fit target value from. This value also applies to the interpolation interval. Default is 20. interpolation_rank: int, optional. Interpolation rank to use if extrapolation method is interpolation Default is 3. raw_func: function, optional, will modify the bootstrap data after samples has been taken by this function. raw_func_err: function, optional, will propagate the error of the bootstrapped line fitted data, raw_func_err(y, yerr). Calculated by regular error propagation. """ if not self.check_continuum_extrapolation(): return self.extrapolation_method = extrapolation_method if not isinstance(self.reference_values, types.NoneType): if extrapolation_method in self.reference_values.keys(): # Checking that the extrapolation method selected can be used. t0_values = (self.reference_values[self.extrapolation_method][ self.analysis_data_type]) else: # If the extrapolation method is not among the used methods. t0_values = self.reference_values.values()[0][ self.analysis_data_type] else: t0_values = None # Retrieves data for analysis. if fit_target == -1: fit_target = self.plot_values[max(self.plot_values)]["x"][-1] fit_targets = self.get_fit_targets(fit_target) if self.verbose: print "Fit targets: ", fit_targets a, a_err, a_norm_factor, a_norm_factor_err, obs, obs_raw, obs_err, \ tau_int_corr = [], [], [], [], [], [], [], [] for i, bn in enumerate(self.sorted_batch_names): if self.with_autocorr and not "blocked" in self.analysis_data_type: tau_int = self.plot_values[bn]["tau_int"] tau_int_err = self.plot_values[bn]["tau_int_err"] else: tau_int = None tau_int_err = None # plt.plot(self.plot_values[bn]["x"], self.chi[bn]( # np.mean(self.plot_values[bn]["y_raw"], axis=1))) # plt.plot(self.plot_values[bn]["x"], # self.plot_values[bn]["y"], color="red") # plt.show() # exit("Good @ 255") # Extrapolation of point to use in continuum extrapolation res = extract_fit_target(fit_targets[i], self.plot_values[bn]["x"], self.plot_values[bn]["y"], self.plot_values[bn]["y_err"], y_raw=self.plot_values[bn]["y_raw"], tau_int=tau_int, tau_int_err=tau_int_err, extrapolation_method=extrapolation_method, plateau_size=plateau_fit_size, interpolation_rank=3, plot_fit=plot_continuum_fit, raw_func=self.chi[bn], raw_func_err=self.chi_der[bn], plot_samples=False, verbose=False) _x0, _y0, _y0_error, _y0_raw, _tau_int0 = res # In case something is wrong -> skip if np.isnan([_y0, _y0_error]).any(): print "NaN type detected: skipping calculation" return if self.verbose: msg = "Beta = %4.2f Topsus = %14.12f +/- %14.12f" % ( self.beta_values[bn], _y0, _y0_error) a.append(self.plot_values[bn]["a"]) a_err.append(self.plot_values[bn]["a_err"]) if isinstance(t0_values, types.NoneType): a_norm_factor.append(_x0) a_norm_factor_err.append(0) else: a_norm_factor.append(t0_values["t0cont"]) a_norm_factor_err.append(t0_values["t0cont_err"]) if self.verbose: _tmp = t0_values["t0cont"] / (self.plot_values[bn]["a"]**2) _tmp *= self.r0**2 msg += " t0 = %14.12f" % (_tmp) if self.verbose: print msg obs.append(_y0) obs_err.append(_y0_error) obs_raw.append(_y0_raw) tau_int_corr.append(_tau_int0) # Makes lists into arrays a = np.asarray(a)[::-1] a_err = np.asarray(a_err)[::-1] a_norm_factor = np.asarray(a_norm_factor)[::-1] a_norm_factor_err = np.asarray(a_norm_factor_err)[::-1] a_squared = a**2 / a_norm_factor a_squared_err = np.sqrt((2 * a * a_err / a_norm_factor)**2 + (a**2 * a_norm_factor_err / a_norm_factor**2)**2) obs = np.asarray(obs)[::-1] obs_err = np.asarray(obs_err)[::-1] # Continuum limit arrays N_cont = 1000 a_squared_cont = np.linspace(-0.0025, a_squared[-1] * 1.1, N_cont) # Fits to continuum and retrieves values to be plotted continuum_fit = LineFit(a_squared, obs, obs_err) y_cont, y_cont_err, fit_params, chi_squared = \ continuum_fit.fit_weighted(a_squared_cont) self.chi_squared = chi_squared self.fit_params = fit_params # continuum_fit.plot(True) # Gets the continium value and its error y0_cont, y0_cont_err, _, _, = \ continuum_fit.fit_weighted(0.0) # Matplotlib requires 2 point to plot error bars at a0_squared = [0, 0] y0 = [y0_cont[0], y0_cont[0]] y0_err = [y0_cont_err[0][0], y0_cont_err[1][0]] # Stores the chi continuum self.topsus_continuum = y0[0] self.topsus_continuum_error = (y0_err[1] - y0_err[0]) / 2.0 y0_err = [self.topsus_continuum_error, self.topsus_continuum_error] # Sets of title string with the chi squared and fit target if isinstance(self.fit_target, str): title_string = r"$%s, \chi^2/\mathrm{d.o.f.} = %.2f$" % ( self.fit_target, self.chi_squared) else: title_string = r"$\sqrt{8t_{f,\mathrm{extrap}}} = %.2f[fm], \chi^2 = %.2f$" % ( self.fit_target, self.chi_squared) title_string += title_addendum # Creates figure and plot window fig = plt.figure() ax = fig.add_subplot(111) # Plots an ax-line at 0 ax.axvline(0, linestyle="dashed", color=self.cont_axvline_color, linewidth=0.5) if chi_squared < 0.01: chi_squared_label = r"$\chi^2/\mathrm{d.o.f.}=%.4f$" % chi_squared else: chi_squared_label = r"$\chi^2/\mathrm{d.o.f.}=%.2f$" % chi_squared topsus_continuum_label = sciprint.sciprint(self.topsus_continuum, self.topsus_continuum_error, prec=3) # Plots the fit ax.plot(a_squared_cont, y_cont, color=self.fit_color, alpha=0.5, label=chi_squared_label) ax.fill_between(a_squared_cont, y_cont_err[0], y_cont_err[1], alpha=0.5, edgecolor='', facecolor=self.fit_fill_color) # Plot lattice points ax.errorbar(a_squared, obs, xerr=a_squared_err, yerr=obs_err, fmt="o", capsize=5, capthick=1, color=self.lattice_points_color, ecolor=self.lattice_points_color) # plots continuum limit, 5 is a good value for cap size ax.errorbar(a0_squared, y0, yerr=y0_err, fmt="o", capsize=5, capthick=1, color=self.cont_error_color, ecolor=self.cont_error_color, label=r"$\chi_{t_f}^{1/4}=%s$ GeV" % (topsus_continuum_label)) ax.set_ylabel(self.y_label_continuum) ax.set_xlabel(self.x_label_continuum) if self.include_title: ax.set_title(title_string) ax.set_xlim(a_squared_cont[0], a_squared_cont[-1]) ax.legend() ax.grid(True) if self.verbose: print "Target: %.16f +/- %.16f GeV" % (self.topsus_continuum, self.topsus_continuum_error) # Saves figure fname = os.path.join( self.output_folder_path, "post_analysis_extrapmethod%s_%s_continuum%s_%s.pdf" % (extrapolation_method, self.observable_name_compact, str(fit_target).replace(".", ""), self.analysis_data_type)) fig.savefig(fname, dpi=self.dpi) if self.verbose: print "Continuum plot of %s created in %s" % ( self.observable_name_compact, fname) # plt.show() plt.close(fig) self.print_continuum_estimate()
def plot_plateau(self, flow_index, plateau_limits, meff_plot_type="ma"): """Method for extracting the glueball mass and plot plateau.""" self.meff_plot_type = meff_plot_type self.plot_values = {} self.interval_index = flow_index self._initiate_plot_values(self.data[self.analysis_data_type], self.data_raw[self.analysis_data_type], flow_index=flow_index) # Sets the x-label to proper units x_label_old = self.x_label self.x_label = r"$t_e[fm]$" # print plateau_limits plateau_limits = [0.3, 0.6] a, a_err, meff, meff_err, t0, t0_err = \ self._plateau_fit(plateau_limits) # Propagates error a a_squared = a**2 / t0 a_squared_err = np.sqrt((2 * a * a_err / t0)**2 + (a**2 * t0_err / t0**2)**2) if np.any(meff == np.nan) or np.any(meff_err == np.nan): print "nan value discovered in:", meff, meff_err self.skipped_plateau_plot = True return if len(meff) <= 2: print "Too few values for continuum fit:", len(meff) self.skipped_plateau_plot = True return # Continuum limit arrays N_cont = 1000 a_squared_cont = np.linspace(-0.025, a_squared[-1] * 1.1, N_cont) # Performs a continuum extrapolation of the effective mass continuum_fit = LineFit(a_squared, meff, meff_err) y_cont, y_cont_err, fit_params, chi_squared = \ continuum_fit.fit_weighted(a_squared_cont) self.cont_chi_squared = chi_squared self.cont_fit_params = fit_params # Gets the continuum value and its error y0_cont, y0_cont_err, _, _, = \ continuum_fit.fit_weighted(0.0) # Matplotlib requires 2 point to plot error bars at a0_squared = [0, 0] y0 = [y0_cont[0], y0_cont[0]] y0_err = [y0_cont_err[0][0], y0_cont_err[1][0]] # Stores the chi continuum self.meff_cont = y0[0] self.meff_cont_err = (y0_err[1] - y0_err[0]) / 2.0 # Prepares plotting y0_err = [self.meff_cont_err, self.meff_cont_err] # if self.verbose: # print "The effective mass for {} is: {}".format( # self.meff_plot_type, # sciprint(self.meff_cont, self.meff_cont_err, prec=3)) # print "Chi^2: {}".format(self.cont_chi_squared) if self.meff_plot_type != "ma": return # Creates figure and plot window fig = plt.figure() ax = fig.add_subplot(111) # Plots an ax-line at 0 ax.axvline(0, linestyle="dashed", color=self.cont_axvline_color, linewidth=0.5) # Plots the fit ax.plot(a_squared_cont, y_cont, color=self.fit_color, alpha=0.5) ax.fill_between(a_squared_cont, y_cont_err[0], y_cont_err[1], alpha=0.5, edgecolor='', label=r"$\chi^2/\mathrm{d.o.f.}=%.2f$" % chi_squared, facecolor=self.fit_fill_color) # Plot lattice points ax.errorbar(a_squared, meff, xerr=a_squared_err, yerr=meff_err, fmt="o", capsize=5, capthick=1, color=self.lattice_points_color, ecolor=self.lattice_points_color) # plots continuum limit, 5 is a good value for cap size ax.errorbar(a0_squared, y0, yerr=y0_err, fmt="o", capsize=5, capthick=1, color=self.cont_error_color, ecolor=self.cont_error_color, label=r"$m_\mathrm{eff}=%.3f\pm%.3f$" % (self.meff_cont, self.meff_cont_err)) ax.set_ylabel(self.y_label_continuum) ax.set_xlabel(self.x_label_continuum) ax.set_xlim(a_squared_cont[0], a_squared_cont[-1]) ax.set_ylim(0, 3) ax.legend() ax.grid(True) # Saves figure fname = os.path.join( self.output_folder_path, "post_analysis_%s_%s_%s.pdf" % (self.observable_name_compact, self.analysis_data_type, self.meff_plot_type)) fig.savefig(fname) if self.verbose: print "Continuum plot of %s created in %s" % ( self.observable_name_compact, fname) plt.close(fig) self.skipped_plateau_plot = False
def get_plateau_value(self, flow_index, plateau_ranges, meff_plot_type): """Calculates the extrapolated plateau value with systematic error estimates.""" self.meff_plot_type = meff_plot_type self.plot_values = {} self.interval_index = flow_index self._initiate_plot_values(self.data[self.analysis_data_type], self.data_raw[self.analysis_data_type], flow_index=flow_index) # Sets the x-label to proper units x_label_old = self.x_label self.x_label = r"$t_e[fm]$" # Systematic error retrieved by going through: plateau_ranges = [] range_start = 0.1 range_stop = 0.8 range_step_size = 0.1 # Range start for _prange_start in np.arange(range_start, range_stop, range_step_size): # Range stop for _prange_stop in np.arange(_prange_start + range_step_size, range_stop + range_step_size, range_step_size): plateau_ranges.append([_prange_start, _prange_stop]) meff_values, meff_err_values, chi2_values = [], [], [] for i, _prange in enumerate(plateau_ranges): # Performs a plateau fit a, a_err, meff, meff_err, t0, t0_err = \ self._plateau_fit(_prange) if len(a) == 0: print("Too few values retrieved from plateau fit for" " range", _prange) return # Propagates error a a_squared = a**2 / t0 # Continuum limit arrays N_cont = 1000 a_squared_cont = np.linspace(-0.025, a_squared[-1] * 1.1, N_cont) # Performs a continuum extrapolation of the effective mass continuum_fit = LineFit(a_squared, meff, meff_err) y_cont, y_cont_err, fit_params, chi_squared = \ continuum_fit.fit_weighted(a_squared_cont) cont_fit_params = fit_params # Gets the continuum value and its error y0_cont, y0_cont_err, _, _, = \ continuum_fit.fit_weighted(0.0) # Matplotlib requires 2 point to plot error bars at y0 = [y0_cont[0], y0_cont[0]] y0_err = [y0_cont_err[0][0], y0_cont_err[1][0]] # Stores the continuum mass meff_cont = y0[0] meff_cont_err = (y0_err[1] - y0_err[0]) / 2.0 _lowlim = self.meff_hist_y_limits[self.meff_plot_type][0] _upplim = self.meff_hist_y_limits[self.meff_plot_type][1] if (meff_cont < _lowlim or meff_cont > _upplim): # print "Skipping bad interval for {}".format(_prange) continue if np.isnan(meff_cont_err) or np.isnan(meff_cont): continue # Store chi^2 chi2_values.append(chi_squared) # Store mass + error meff_values.append(meff_cont) meff_err_values.append(meff_cont_err) meff_values, meff_err_values, chi2_values = map( np.asarray, [meff_values, meff_err_values, chi2_values]) systematic_error = np.std(meff_values) # /len(meff_values) # print "Systematic error for %s: %g" % ( # self.meff_plot_type, # systematic_error) if self.skipped_plateau_plot: print( "Skipping get_plateau_value since we could not " "perform a proper plteau plot.") return assert hasattr(self, "meff_cont"), "Run plot_plateau." assert hasattr(self, "meff_cont_err"), "Run plot_plateau." # Gets the systematic error in correct str format sys_error_str = sciprint(self.meff_cont, systematic_error, prec=3) sys_error_str = "(" + sys_error_str.split("(")[-1] # Sets up string for effective mass eff_mass_str = "{}{}".format( sciprint(self.meff_cont, self.meff_cont_err, prec=3), sys_error_str) msg = "Effective mass for {}: {}".format(self.meff_plot_type, eff_mass_str) print msg # Method 1 # Make histogram of mass # Take std of histogram fig1, ax1 = plt.subplots() ax1.hist(meff_values, label=r"%s$=%s$%s" % (self.meff_labels[self.meff_plot_type], eff_mass_str, self.meff_unit_labels[self.meff_plot_type]), density=True) ax1.grid(True) ax1.set_xlabel("%s%s" % (self.meff_labels[self.meff_plot_type], self.meff_unit_labels[self.meff_plot_type])) ax1.set_xlim(self.meff_hist_x_limits[self.meff_plot_type]) fig1.legend(loc="upper right") # Saves and closes figure fname = self._get_plot_figure_name( output_folder=None, figure_name_appendix="_{0:s}_syserror_unweighted".format( self.meff_plot_type)) plt.savefig(fname) if self.verbose: print "Figure saved in %s" % fname plt.close(fig1)
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 plot_continuum(self, fit_target, title_addendum="", extrapolation_method="bootstrap", plateau_fit_size=20, interpolation_rank=3, plot_continuum_fit=False): """Method for plotting the continuum limit of topsus at a given fit_target. Args: fit_target: float, value of where we extrapolate from. title_addendum: str, optional, default is an empty string, ''. Adds string to end of title. extrapolation_method: str, optional, method of selecting the extrapolation point to do the continuum limit. Method will be used on y values and tau int. Choices: - plateau: line fits points neighbouring point in order to reduce the error bars using y_raw for covariance matrix. - plateau_mean: line fits points neighbouring point in order to reduce the error bars. Line will be weighted by the y_err. - nearest: line fit from the point nearest to what we seek - interpolate: linear interpolation in order to retrieve value and error. Does not work in conjecture with use_raw_values. - bootstrap: will create multiple line fits, and take average. Assumes y_raw is the bootstrapped or jackknifed samples. plateau_size: int, optional. Number of points in positive and negative direction to extrapolate fit target value from. This value also applies to the interpolation interval. Default is 20. interpolation_rank: int, optional. Interpolation rank to use if extrapolation method is interpolation Default is 3. raw_func: function, optional, will modify the bootstrap data after samples has been taken by this function. raw_func_err: function, optional, will propagate the error of the bootstrapped line fitted data, raw_func_err(y, yerr). Calculated by regular error propagation. """ self.extrapolation_method = extrapolation_method if not isinstance(self.reference_values, types.NoneType): if extrapolation_method in self.reference_values.keys(): # Checking that the extrapolation method selected can be used. t0_values = self.reference_values[self.extrapolation_method]\ [self.analysis_data_type] else: # If the extrapolation method is not among the used methods. t0_values = self.reference_values.values()[0]\ [self.analysis_data_type] else: t0_values = None # Retrieves data for analysis. if fit_target == -1: fit_target = self.plot_values[max(self.plot_values)]["x"][-1] a, a_err, a_norm_factor, a_norm_factor_err, obs, obs_raw, obs_err, \ tau_int_corr = [], [], [], [], [], [], [], [] for beta in sorted(self.plot_values): x = self.plot_values[beta]["x"] y = self.plot_values[beta]["y"] y_err = self.plot_values[beta]["y_err"] y_raw = self.plot_values[beta]["y_raw"] if self.with_autocorr: tau_int = self.plot_values[beta]["tau_int"] tau_int_err = self.plot_values[beta]["tau_int_err"] else: tau_int = None tau_int_err = None # Extrapolation of point to use in continuum extrapolation res = extract_fit_target(fit_target, x, y, y_err, y_raw=y_raw, tau_int=tau_int, tau_int_err=tau_int_err, extrapolation_method=extrapolation_method, plateau_size=plateau_fit_size, interpolation_rank=3, plot_fit=plot_continuum_fit, raw_func=self.chi[beta], raw_func_err=self.chi_der[beta], plot_samples=False, verbose=False) _x0, _y0, _y0_error, _y0_raw, _tau_int0 = res if np.isnan([_y0, _y0_error]).any(): print "NaN type detected: skipping calculation" return if self.verbose: msg = "Beta = %4.2f Topsus = %14.12f +/- %14.12f" % (beta, _y0, _y0_error) a.append(self.plot_values[beta]["a"]) a_err.append(self.plot_values[beta]["a_err"]) if isinstance(t0_values, types.NoneType): a_norm_factor.append(_x0) a_norm_factor_err.append(0) else: a_norm_factor.append(t0_values["t0cont"]) a_norm_factor_err.append(t0_values["t0cont_err"]) if self.verbose: msg += " t0 = %14.12f" % (t0_values["t0cont"]\ / (self.plot_values[beta]["a"]**2) * self.r0**2) if self.verbose: print msg obs.append(_y0) obs_err.append(_y0_error) obs_raw.append(_y0_raw) tau_int_corr.append(_tau_int0) # Makes lists into arrays a = np.asarray(a)[::-1] a_err = np.asarray(a_err)[::-1] a_norm_factor = np.asarray(a_norm_factor)[::-1] a_norm_factor_err = np.asarray(a_norm_factor_err)[::-1] a_squared = a**2 / a_norm_factor a_squared_err = np.sqrt((2*a*a_err/a_norm_factor)**2 \ + (a**2*a_norm_factor_err/a_norm_factor**2)**2) obs = np.asarray(obs)[::-1] obs_err = np.asarray(obs_err)[::-1] # Continuum limit arrays N_cont = 1000 a_squared_cont = np.linspace(-0.0025, a_squared[-1] * 1.1, N_cont) # Fits to continuum and retrieves values to be plotted continuum_fit = LineFit(a_squared, obs, obs_err) y_cont, y_cont_err, fit_params, chi_squared = \ continuum_fit.fit_weighted(a_squared_cont) self.chi_squared = chi_squared self.fit_params = fit_params self.fit_target = fit_target # continuum_fit.plot(True) # Gets the continium value and its error y0_cont, y0_cont_err, _, _, = \ continuum_fit.fit_weighted(0.0) # Matplotlib requires 2 point to plot error bars at a0_squared = [0, 0] y0 = [y0_cont[0], y0_cont[0]] y0_err = [y0_cont_err[0][0], y0_cont_err[1][0]] # Stores the chi continuum self.topsus_continuum = y0[0] self.topsus_continuum_error = (y0_err[1] - y0_err[0]) / 2.0 y0_err = [self.topsus_continuum_error, self.topsus_continuum_error] # Sets of title string with the chi squared and fit target title_string = r"$t_{f,0} = %.2f[fm], \chi^2 = %.2f$" % ( self.fit_target, self.chi_squared) title_string += title_addendum # 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:blue", alpha=0.5) ax.fill_between(a_squared_cont, y_cont_err[0], y_cont_err[1], alpha=0.5, edgecolor='', facecolor="tab:blue") # Plot lattice points ax.errorbar(a_squared, obs, xerr=a_squared_err, yerr=obs_err, fmt="o", color="tab:orange", ecolor="tab:orange") # plots continuum limit, 5 is a good value for cap size ax.errorbar(a0_squared, y0, yerr=y0_err, fmt="o", capsize=None, capthick=1, color="tab:red", ecolor="tab:red", label=r"$\chi^{1/4}=%.3f\pm%.3f$" % (self.topsus_continuum, self.topsus_continuum_error)) ax.set_ylabel(self.y_label_continuum) ax.set_xlabel(self.x_label_continuum) ax.set_title(title_string) ax.set_xlim(a_squared_cont[0], a_squared_cont[-1]) ax.legend() ax.grid(True) if self.verbose: print "Target: %.16f +/- %.16f" % (self.topsus_continuum, self.topsus_continuum_error) # Saves figure fname = os.path.join( self.output_folder_path, "post_analysis_extrapmethod%s_%s_continuum%s_%s.png" % (extrapolation_method, self.observable_name_compact, str(fit_target).replace(".", ""), self.analysis_data_type)) fig.savefig(fname, dpi=self.dpi) if self.verbose: print "Continuum plot of %s created in %s" % ( self.observable_name_compact, fname) # plt.show() plt.close(fig) self.print_continuum_estimate()
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