def _initiate_plot_values(self, data, data_raw, interval_keys=None): """Sorts data into a format specific for the plotting method.""" for ib, bn in enumerate(self.sorted_batch_names): values = {} if isinstance(interval_keys, types.NoneType): # Case where we have sub sections of observables, e.g. in # euclidean time. for sub_obs in self.observable_intervals[bn]: sub_values = {} sub_values["a"], sub_values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) sub_values["x"] = sub_values["a"] * \ np.sqrt(8*data[bn][sub_obs]["x"]) sub_values["y"] = data[bn][sub_obs]["y"] sub_values["y_err"] = data[bn][sub_obs]["y_error"] # sub_values["label"] = r"%s, %s, $\beta=%2.2f$, %s" % ( # self.ensemble_names[bn], # self.size_labels[bn], self.beta_values[bn], # self._convert_label(sub_obs)) sub_values["label"] = r"%s, %s" % ( self.ensemble_names[bn], self._convert_label(sub_obs)) values[sub_obs] = sub_values else: int_key = interval_keys[ib] values["a"], values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) values["x"] = values["a"] * np.sqrt(8*data[bn][int_key]["x"]) values["y"] = data[bn][int_key]["y"] values["y_err"] = data[bn][int_key]["y_error"] values["label"] = r"%s, %s" % ( self.ensemble_names[bn], self._convert_label(int_key)) values["interval"] = int_key self.plot_values[beta] = values
def _initiate_plot_values(self, data, data_raw, interval_keys=None): """Sorts data into a format specific for the plotting method.""" for ib, bn in enumerate(self.sorted_batch_names): values = {} if isinstance(interval_keys, types.NoneType): # Case where we have sub sections of observables, e.g. in # euclidean time. for sub_obs in self.observable_intervals[bn]: sub_values = {} sub_values["a"], sub_values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) sub_values["x"] = sub_values["a"] * \ np.sqrt(8*data[bn][sub_obs]["x"]) sub_values["y"] = data[bn][sub_obs]["y"] sub_values["y_err"] = data[bn][sub_obs]["y_error"] if self.with_autocorr: sub_values["tau_int"] = \ data[bn][sub_obs]["ac"]["tau_int"] sub_values["tau_int_err"] = \ data[bn][sub_obs]["ac"]["tau_int_err"] # Retrieves raw data sub_values["y_raw"] = \ data_raw[bn][self.observable_name_compact][sub_obs] # sub_values["label"] = r"%s, %s, $\beta=%2.2f$, %s" % ( # self.ensemble_names[bn], self.size_labels[bn], # self.beta_values[bn], self._convert_label(sub_obs)) sub_values["label"] = r"%s, %s" % ( self.ensemble_names[bn], self._convert_label(sub_obs)) values[sub_obs] = sub_values else: # sorted_intervals = sorted(data[beta].keys()) # Modulo division in order to avoid going out of range in # intervals. int_key = interval_keys[ib] values["a"], values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) values["x"] = values["a"] * np.sqrt(8 * data[bn][int_key]["x"]) values["y"] = data[bn][int_key]["y"] values["y_err"] = data[bn][int_key]["y_error"] if self.with_autocorr: values["tau_int"] = data[bn][int_key]["ac"]["tau_int"] values["tau_int_err"] = \ data[bn][int_key]["ac"]["tau_int_err"] values["y_raw"] = \ data_raw[bn][self.observable_name_compact][int_key] # values["label"] = r"%s, %s, $\beta=%2.2f$, %s" % ( # self.ensemble_names, self.size_labels[bn], # self.beta_values[bn], self._convert_label(int_key)) values["label"] = r"%s, %s" % (self.ensemble_names, self._convert_label(int_key)) values["interval"] = int_key self.plot_values[bn] = values
def _initiate_plot_values(self, data, data_raw): # Sorts data into a format specific for the plotting method for bn in self.sorted_batch_names: values = {} values["beta"] = self.beta_values[bn] values["a"], values["a_err"] = get_lattice_spacing(values["beta"]) values["xraw"] = data[bn]["x"] # t_f/a^2 values["t"] = values["xraw"] * values["a"]**2 values["sqrt8t"] = values["a"] * np.sqrt(8 * data[bn]["x"]) values["x"] = values["t"] / self.r0**2 values["y"] = data[bn]["y"] values["y_err"] = data[bn]["y_error"] values["flow_epsilon"] = self.flow_epsilon[bn] # values["tder"], values["W"], values["W_err"], values["W_raw"] = \ # self.calculateW(values["x"], data[bn]["y"], # data[bn]["y_error"], # data_raw[bn][self.observable_name_compact], # values["flow_epsilon"], data[bn]["x"]) # exit("Exits in plot values initiations.") if self.with_autocorr: values["tau_int"] = data[bn]["ac"]["tau_int"] values["tau_int_err"] = data[bm]["ac"]["tau_int_err"] else: values["tau_int"] = None values["tau_int_err"] = None values[self.analysis_data_type] = \ (data_raw[bn][self.observable_name_compact].T \ *(data[bn]["x"]**2)).T values["label"] = (r"%s $\beta=%2.2f$" % (self.size_labels[bn], values["beta"])) self.plot_values[bn] = values
def _initiate_plot_values(self, data, data_raw): # Sorts data into a format specific for the plotting method for beta in sorted(data.keys()): values = {} values["beta"] = beta values["a"], values["a_err"] = get_lattice_spacing(beta) values["t"] = data[beta]["x"]*values["a"]**2 values["x"] = values["t"]/self.r0**2 values["y"] = data[beta]["y"]*data[beta]["x"]**2 values["y_err"] = data[beta]["y_error"]*data[beta]["x"]**2 values["flow_epsilon"] = self.flow_epsilon[beta] values["tder"], values["W"], values["W_err"], values["W_raw"] = \ self.calculateW(values["t"], data[beta]["y"], data[beta]["y_error"], data_raw[beta][self.observable_name_compact], values["flow_epsilon"], data[beta]["x"]) # print values["x"] # exit("Exits in plot values initiations.") if self.with_autocorr: values["tau_int"] = data[beta]["ac"]["tau_int"] values["tau_int_err"] = data[beta]["ac"]["tau_int_err"] else: values["tau_int"] = None values["tau_int_err"] = None values[self.analysis_data_type] = \ (data_raw[beta][self.observable_name_compact].T \ *(data[beta]["x"]**2)).T values["label"] = (r"%s $\beta=%2.2f$" % (self.size_labels[beta], beta)) self.plot_values[beta] = values
def _initiate_plot_values(self, data, data_raw): """Sorts data into a format specific for the plotting method.""" for beta in sorted(data): values = {} values["a"], values["a_err"] = get_lattice_spacing(beta) values["x"] = values["a"] * np.sqrt(8 * data[beta]["x"]) values["y"] = data[beta]["y"] values["y_err"] = data[beta]["y_error"] values["y_raw"] = data_raw[beta][self.observable_name_compact] values["y_uraw"] = self.data_raw["unanalyzed"][beta]\ [self.observable_name_compact] # print values["y_raw"].shape, values["y_uraw"].shape # print "%s beta: %f" % (self.observable_name_compact, beta) # print np.mean(values["y_raw"][-1,:]), np.std(values["y_raw"][-1,:]) # print np.mean(values["y_uraw"][-1,:]), np.std(values["y_uraw"][-1,:]) if self.with_autocorr: values["tau_int"] = data[beta]["ac"]["tau_int"] values["tau_int_err"] = data[beta]["ac"]["tau_int_err"] else: values["tau_int"] = None values["tau_int_err"] = None values["label"] = r"%s $\beta=%2.2f$" % (self.size_labels[beta], beta) values["color"] = self.colors[beta] self.plot_values[beta] = values
def _initialize_topsus_func_const(self): """Sets the constant in the topsus function for found beta values.""" for beta in self.beta_values: a, a_err = get_lattice_spacing(beta) V = float(self.lattice_sizes[beta][0]**3) self.chi_const[beta] = self.hbarc/a/V**0.25 self.chi_const_err[beta] = self.hbarc*a_err/a**2/V**0.25
def _initiate_plot_values(self, data, data_raw): """Sorts data into a format specific for the plotting method.""" for bn in self.sorted_batch_names: values = {} values["beta"] = self.beta_values[bn] values["a"], values["a_err"] = get_lattice_spacing(values["beta"]) values["sqrt8t"] = values["a"] * np.sqrt(8 * data[bn]["x"]) values["x"] = values["a"] * np.sqrt(8 * data[bn]["x"]) values["y"] = data[bn]["y"] values["y_err"] = data[bn]["y_error"] values["y_raw"] = data_raw[bn][self.observable_name_compact] values["y_uraw"] = \ self.data_raw["unanalyzed"][bn][self.observable_name_compact] if self.with_autocorr and not "blocked" in self.analysis_data_type: values["tau_int"] = data[bn]["ac"]["tau_int"] values["tau_int_err"] = data[bn]["ac"]["tau_int_err"] values["tau_raw"] = self.ac_raw["ac_raw"][bn] values["tau_raw_err"] = self.ac_raw["ac_raw_error"][bn] else: values["tau_int"] = None values["tau_int_err"] = None values["tau_raw"] = None values["tau_raw_err"] = None # values["label"] = r"%s, %s, $\beta=%2.2f$" % ( # self.ensemble_names[bn], self.size_labels[bn], values["beta"]) values["label"] = r"%s" % self.ensemble_names[bn] values["color"] = self.colors[bn] self.plot_values[bn] = values
def _initialize_topsus_func_const(self): """Sets the constant in the topsus function for found batches.""" for bn in self.batch_names: a, a_err = get_lattice_spacing(self.beta_values[bn]) V = float(self.lattice_sizes[bn][0]**3 * self.lattice_sizes[bn][1]) self.chi_const[bn] = self.hbarc / a / V**0.25 self.chi_const_err[bn] = self.hbarc * a_err / a**2 / V**0.25
def _initiate_plot_values(self, data, data_raw): """Sorts data into a format specific for the plotting method.""" for beta in self.beta_values: values = {} values["a"] = get_lattice_spacing(beta)[0] values["x"] = values["a"] * np.sqrt(8 * data[beta]["x"]) values["y"] = data[beta]["y"] values["y_err"] = data[beta]["y_error"] # values["y_raw"] = data_raw[beta][self.observable_name_compact] # values["tau_int"] = data[beta]["ac"]["tau_int"] values["label"] = r"%s $\beta=%2.2f$" % (self.size_labels[beta], beta) self.plot_values[beta] = values
def _initiate_plot_values(self, data, data_raw, interval_keys=None): """Sorts data into a format specific for the plotting method.""" for ib, beta in enumerate(sorted(data.keys())): values = {} if isinstance(interval_keys, types.NoneType): # Case where we have sub sections of observables, e.g. in # euclidean time. for sub_obs in self.observable_intervals[beta]: sub_values = {} sub_values["a"], sub_values["a_err"] = \ get_lattice_spacing(beta) sub_values["x"] = sub_values["a"] * \ np.sqrt(8*data[beta][sub_obs]["x"]) sub_values["y"] = data[beta][sub_obs]["y"] sub_values["y_err"] = data[beta][sub_obs]["y_error"] sub_values["label"] = r"%s, $\beta=%2.2f$, %s" % ( self.size_labels[beta], beta, self._convert_label(sub_obs)) values[sub_obs] = sub_values else: # sorted_intervals = sorted(data[beta].keys()) # Modulo division in order to avoid going out of range in # intervals. int_key = interval_keys[ib] # print data[beta].keys() # print data[beta][int_key].keys() # print data_raw[beta].keys() # exit(1) values["a"], values["a_err"] = get_lattice_spacing(beta) values["x"] = values["a"] * np.sqrt( 8 * data[beta][int_key]["x"]) values["y"] = data[beta][int_key]["y"] values["y_err"] = data[beta][int_key]["y_error"] values["label"] = r"%s, $\beta=%2.2f$, %s" % ( self.size_labels[beta], beta, self._convert_label(int_key)) values["interval"] = int_key self.plot_values[beta] = values
def _initiate_plot_values(self, data, data_raw): """Sorts data into a format specific for the plotting method.""" for bn in self.sorted_batch_names: values = {} values["a"] = get_lattice_spacing(self.beta_values[bn])[0] values["sqrt8t"] = values["a"] * np.sqrt(8 * data[bn]["x"]) values["x"] = values["a"] * np.sqrt(8 * data[bn]["x"]) values["y"] = data[bn]["y"] values["y_err"] = data[bn]["y_error"] # values["y_raw"] = data_raw[bn][self.observable_name_compact] # values["tau_int"] = data[bn]["ac"]["tau_int"] # values["label"] = r"%s, %s, $\beta=%2.2f$" % ( # self.ensemble_names[bn], # self.size_labels[bn], self.beta_values[bn]) values["label"] = r"%s" % self.ensemble_names[bn] self.plot_values[bn] = values
def _setup_volumes(self): """Sets up lattice volumes.""" # Sets up the lattice spacing values with errors self.a_vals, self.a_vals_err = \ zip(*[get_lattice_spacing(b) for b in self.beta_values]) self.a_vals = {b: self.a_vals[i] \ for i, b in enumerate(self.beta_values)} self.a_vals_err = {b: self.a_vals_err[i] \ for i, b in enumerate(self.beta_values)} # Sets up the volumes vol = lambda b: self.lattice_sizes[b] * self.a_vals[b]**4 vol_err = lambda b: \ 4*self.lattice_sizes[b]*self.a_vals[b]**3*self.a_vals_err[b] self.V = {b: vol(b) for b in self.beta_values} self.V_err = {b: vol_err(b) for b in self.beta_values}
def _initiate_plot_values(self, data, data_raw): # Sorts data into a format specific for the plotting method for bn in self.sorted_batch_names: values = {} values["beta"] = self.beta_values[bn] values["a"], values["a_err"] = get_lattice_spacing(values["beta"]) values["t"] = data[bn]["x"] * values["a"]**2 values["sqrt8t"] = values["a"] * np.sqrt(8 * data[bn]["x"]) values["x"] = values["t"] / self.r0**2 values["y"] = data[bn]["y"] * data[bn]["x"]**2 values["y_err"] = data[bn]["y_error"] * data[bn]["x"]**2 values["flow_epsilon"] = self.flow_epsilon[bn] values["y_raw"] = data_raw[bn][self.observable_name_compact] values["y_uraw"] = \ self.data_raw["unanalyzed"][bn][self.observable_name_compact] # Calculates the energy derivatve values["tder"], values["W"], values["W_err"], values["W_raw"] = \ self.calculateW(values["t"], data[bn]["y"], data[bn]["y_error"], data_raw[bn][self.observable_name_compact], values["flow_epsilon"], data[bn]["x"]) if self.with_autocorr and not "blocked" in self.analysis_data_type: values["tau_int"] = data[bn]["ac"]["tau_int"] values["tau_int_err"] = data[bn]["ac"]["tau_int_err"] values["tau_raw"] = self.ac_raw["ac_raw"][bn] values["tau_raw_err"] = self.ac_raw["ac_raw_error"][bn] else: values["tau_int"] = None values["tau_int_err"] = None values["tau_raw"] = None values["tau_raw_err"] = None # Calculates the t^2<E> for the raw values values[self.analysis_data_type] = \ (data_raw[bn][self.observable_name_compact].T * (data[bn]["x"]**2)).T # values["label"] = (r"%s, %s, $\beta=%2.2f$" % # (self.ensemble_names[bn], self.size_labels[bn], # values["beta"])) values["label"] = r"%s" % self.ensemble_names[bn] self.plot_values[bn] = values
def _setup_volumes(self): """Sets up lattice volumes.""" # Sets up the lattice spacing values with errors self.a_vals = {} self.a_vals_err = {} for bn in self.sorted_batch_names: self.a_vals[bn], self.a_vals_err[bn] = \ get_lattice_spacing(self.beta_values[bn]) # Sets up the volumes def vol(bn_): return self.lattice_volumes[bn_] * self.a_vals[bn_]**4 def vol_err(bn_): return 4 * self.lattice_volumes[bn_] * self.a_vals[ bn_]**3 * self.a_vals_err[bn_] self.V = {bn: vol(bn) for bn in self.sorted_batch_names} self.V_err = {bn: vol_err(bn) for bn in self.sorted_batch_names}
def _initiate_plot_values(self, data, data_raw, flow_index=None): """interval_index: int, should be in euclidean time.""" # Sorts data into a format specific for the plotting method for beta in self.beta_values: values = {} if flow_index == None: # Case where we have sub sections of observables, e.g. in # euclidean time. for sub_obs in self.observable_intervals[beta]: sub_values = {} sub_values["a"], sub_values["a_err"] = get_lattice_spacing( beta) sub_values["x"] = np.linspace( 0, self.lattice_sizes[beta][1] * sub_values["a"], self.lattice_sizes[beta][1]) sub_values["y"], sub_values["y_err"] = self.analyse_raw( data[beta][sub_obs], data_raw[beta][self.observable_name_compact][sub_obs]) sub_values["label"] = r"%s, $\beta=%2.2f$, $t_f=%.2f$" % ( self.size_labels[beta], beta, self._convert_label(sub_obs)) sub_values["raw"] = data_raw[beta] \ [self.observable_name_compact][sub_obs] if self.fold: sub_values["x"] = np.linspace( 0, (int(sub_values["y"].shape[0] / 2)) * sub_values["a"], int(sub_values["y"].shape[0] / 2) + 1) sub_values["y"] = self.fold_array( sub_values["y"]) * self.r0 / sub_values["a"] # sub_values["y_err"] = \ # self.fold_error_array(sub_values["y_err"]) * self.r0 / sub_values["a"] # Error propagation with lattice spacing error sub_values["y_err"] = np.sqrt( (self.fold_error_array(sub_values["y_err"])*self.r0/sub_values["a"])**2 + \ (sub_values["y"]/sub_values["a"]*sub_values["a_err"])**2) # sub_values["raw"] = self.fold_array(sub_values["raw"], # axis=0) self.fold_position = sub_values["x"][self.fold_range] if self.with_autocorr: sub_values["tau_int"] = \ data[beta][sub_obs]["ac"]["tau_int"] sub_values["tau_int_err"] = \ data[beta][sub_obs]["ac"]["tau_int_err"] values[sub_obs] = sub_values self.plot_values[beta] = values else: tf_index = "tflow%04.4f" % flow_index values["a"], values["a_err"] = get_lattice_spacing(beta) # For exact box sizes values["x"] = np.linspace( 0, self.lattice_sizes[beta][1] * values["a"], self.lattice_sizes[beta][1]) values["y_raw"] = data_raw[beta] \ [self.observable_name_compact][tf_index] if self.with_autocorr: values["tau_int"] = data[beta][tf_index]["ac"]["tau_int"] values["tau_int_err"] = \ data[beta][tf_index]["ac"]["tau_int_err"] values["y"], values["y_err"] = \ self.analyse_data(data[beta][tf_index]) if self.fold: values["x"] = np.linspace( 0, (int(values["y"].shape[0] / 2)) * values["a"], int(values["y"].shape[0] / 2) + 1) values["y"] = self.fold_array( values["y"]) * self.r0 / values["a"] # values["y_err"] = \ # self.fold_error_array(values["y_err"]) * self.r0 / values["a"] # Error propagation with lattice spacing error values["y_err"] = np.sqrt( (self.fold_error_array(values["y_err"])*self.r0/values["a"])**2 + \ (values["y"]/values["a"]*values["a_err"])**2) # values["y_raw"] = self.fold_array(values["y_raw"], axis=0) self.fold_position = values["x"][self.fold_range] values["label"] = r"%s $\beta=%2.2f$, $t_f=%.2f$" % ( self.size_labels[beta], beta, flow_index) self.plot_values[beta] = values
def _initiate_plot_values(self, data, data_raw, tf0, mc_int=None): """mc_int: int, should be in mc time.""" tf0_key = "tflow%.4f" % tf0 # Sorts data into a format specific for the plotting method for beta in self.beta_values: values = {} if isinstance(mc_int, types.NoneType): # Case where we have sub sections of observables, e.g. in # mc time. for sub_obs in self.observable_intervals[beta]: sub_values = {} sub_values["a"], sub_values["a_err"] = get_lattice_spacing( beta) sub_values["x"] = np.linspace( 0, self.lattice_sizes[beta][1] * sub_values["a"], self.lattice_sizes[beta][1]) sub_values["y"], sub_values["y_err"] = self.analyse_raw( data[beta][sub_obs][tf0_key], data_raw[beta][ self.observable_name_compact][sub_obs][tf0_key]) sub_values[ "label"] = r"%s, $\beta=%2.2f$, $t_f=%.2f$, $MC:%s$" % ( self.size_labels[beta], beta, tf0, sub_obs) sub_values["raw"] = data_raw[beta] \ [self.observable_name_compact][sub_obs][tf0_key] if self.fold: # OLD FOLD METHOD - DO NOT INCREASE STATISTICS BY THIS WAY:| # sub_values["x"] = np.linspace(-self.fold_range*sub_values["a"], # (self.fold_range-1)*sub_values["a"], self.fold_range*2) sub_values["x"] = np.linspace( 0, (int(sub_values["y"].shape[0] / 2)) * sub_values["a"], int(sub_values["y"].shape[0] / 2) + 1) sub_values["y"] = self.fold_array( sub_values["y"]) * self.r0 / sub_values["a"] # Error propagation with lattice spacing error sub_values["y_err"] = np.sqrt( (self.fold_error_array(sub_values["y_err"])*self.r0/sub_values["a"])**2 + \ (sub_values["y"]/sub_values["a"]*sub_values["a_err"])**2) # sub_values["raw"] = self.fold_array(sub_values["raw"], # axis=0) self.fold_position = sub_values["x"][self.fold_range] if self.with_autocorr: sub_values["tau_int"] = \ data[beta][sub_obs][tf0_key]["ac"]["tau_int"] sub_values["tau_int_err"] = \ data[beta][sub_obs][tf0_key]["ac"]["tau_int_err"] values[sub_obs] = sub_values self.plot_values[beta] = values else: mc_dict = { b: mc_int[ib] for ib, b in enumerate(self.beta_values) } # raise NotImplementedError("This section is not complete") values["a"], values["a_err"] = get_lattice_spacing(beta) # For exact box sizes values["x"] = np.linspace( 0, self.lattice_sizes[beta][1] * values["a"], self.lattice_sizes[beta][1]) values["y_raw"] = data_raw[beta] \ [self.observable_name_compact][mc_dict[beta]][tf0_key] if self.with_autocorr: values["tau_int"] = data[beta][ mc_dict[beta]][tf0_key]["ac"]["tau_int"] values["tau_int_err"] = \ data[beta][mc_dict[beta]][tf0_key]["ac"]["tau_int_err"] values["y"], values["y_err"] = \ self.analyse_data(data[beta][mc_dict[beta]][tf0_key]) if self.fold: values["x"] = np.linspace( 0, (int(values["y"].shape[0] / 2)) * values["a"], int(values["y"].shape[0] / 2) + 1) values["y"] = self.fold_array( values["y"]) * self.r0 / values["a"] # Error propagation with lattice spacing error values["y_err"] = np.sqrt( (self.fold_error_array(values["y_err"])*self.r0/values["a"])**2 + \ (values["y"]/values["a"]*values["a_err"])**2) # values["y_raw"] = self.fold_array(values["y_raw"], axis=0) self.fold_position = values["x"][self.fold_range] values["label"] = r"%s $\beta=%2.2f$, $t_f=%.2f$, $MC=%s$" % ( self.size_labels[beta], beta, tf0, ", ".join( ["[%s)" % i for i in mc_int])) self.plot_values[beta] = values
def _initiate_plot_values(self, data, data_raw, euclidean_percent, q0_flow_time=None): """interval_index: int, should be in euclidean time.""" # Sorts data into a format specific for the plotting method for bn in self.sorted_batch_names: euclidean_index = self._get_euclidean_index(euclidean_percent, bn) te_index = "te%04d" % euclidean_index values = {} if q0_flow_time == None: # Case where we have sub sections of observables, # e.g. in euclidean time. for sub_obs in self.observable_intervals[bn]: sub_values = {} sub_values["a"], sub_values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) sub_values["x"] = np.linspace( 0, self.lattice_sizes[bn][1] * sub_values["a"], self.lattice_sizes[bn][1]) sub_values["y"] = data[bn][sub_obs][te_index]["y"] sub_values["y_err"] = \ data[bn][sub_obs][te_index]["y_error"] sub_values["y_raw"] = \ data_raw[bn][self.observable_name_compact][sub_obs] if self.with_autocorr: sub_values["tau_int"] = \ data[bn][sub_obs][te_index]["ac"]["tau_int"] sub_values["tau_int_err"] = \ data[bn][sub_obs][te_index]["ac"]["tau_int_err"] # sub_values["label"] = ( # r"%s, %s, $\beta=%2.2f$, $\sqrt{8t_{f}}=%.2f$" # % (self.ensemble_names[bn], # self.size_labels[bn], # self.beta_values[bn], # self._convert_label(sub_obs))) sub_values["label"] = self.ensemble_names[bn] values[sub_obs] = sub_values self.plot_values[bn] = values else: tf_index = "tflow%04.4f" % q0_flow_time values = {} values["a"], values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) # FOR EXACT BOX SIZE: values["x"] = np.linspace( 0, self.lattice_sizes[bn][1] * values["a"], self.lattice_sizes[bn][1]) values["y"] = data[bn][tf_index][te_index]["y"] values["y_err"] = data[bn][tf_index][te_index]["y_error"] values["y_raw"] = \ data_raw[bn][self.observable_name_compact][tf_index] if self.with_autocorr: values["tau_int"] = \ data[bn][tf_index][te_index]["ac"]["tau_int"] values["tau_int_err"] = \ data[bn][tf_index][te_index]["ac"]["tau_int_err"] # values["label"] = ( # r"%s, %s, $\beta=%2.2f$, $\sqrt{8t_f}=%.2f$, $t_{e,0}/a=%d$" % ( # self.ensemble_names[bn], # self.size_labels[bn], self.beta_values[bn], # q0_flow_time, euclidean_index)) values["label"] = ( r"%s, $\sqrt{8t_f}=%.2f$, $t_{e,0}/a=%d$" % (self.ensemble_names[bn], q0_flow_time, euclidean_index)) self.plot_values[bn] = values
def __init__(self, data, mc_interval=None, figures_folder=False, parallel=False, numprocs=4, dryrun=False, verbose=False): """ Parent class for analyzing flowed observables. Args: data: DataReader([observable_name]), an DataReader object called with the compact observable name. Options: "plaq", "energy", "topc". mc_interval: optional, tuple, will only look at Monte Carlo history inside interval. Default is using all Monte Carlo of the Monte Carlo history available. figures_folder: optional argument for where to place the figures created. Default is "../figures". parallel: optinal argument if we are to run analysis in parallel. Default is False. numprocs: optional argument for the number of processors to use. Default is 4. dryrun: optional dryrun mode. Default is False. verbose: optional argument for a more verbose run. Default is False. Returns: Object for analyzing flow. """ # Retrieves data from data self.batch_name = data["batch_name"] self.batch_data_folder = data["batch_data_folder"] self.x = data["t"] self.y = data["obs"] self.flow_epsilon = data["FlowEpsilon"] # Sets lattice parameters self.beta = data["beta"] self.a, self.a_err = get_lattice_spacing(self.beta) self.r0 = 0.5 # Sommer Parameters # Sets the lattice sizes if one is provided self.lattice_size = data["lattice_size"] # Initializes up global constants self.N_bs = None self.dryrun = dryrun self.verbose = verbose if figures_folder != False: # Default is just figures self.figures_folder = figures_folder # Parallel variables self.parallel = parallel self.numprocs = numprocs # Checks that a figures folder exists check_folder(self.figures_folder, self.dryrun, verbose=self.verbose) # Check that a data run folder exist, so one data anlysis performed on # different data sets do not mix self.data_batch_folder_path = \ os.path.join(self.figures_folder, os.path.split(self.batch_data_folder)[-1]) check_folder(self.data_batch_folder_path, self.dryrun, verbose=self.verbose) # Checks that a batch folder exists self.batch_name_folder_path = os.path.join(self.data_batch_folder_path, self.batch_name) check_folder(self.batch_name_folder_path, self.dryrun, verbose=self.verbose) # Checks that observable output folder exist, and if not will create it self.observable_output_folder_path = os.path.join( self.batch_name_folder_path, self.observable_name_compact) check_folder(self.observable_output_folder_path, self.dryrun, verbose=self.verbose) # Sets up the post analysis folder, but do not create it till its # needed. self.post_analysis_folder_base = os.path.join(self.batch_data_folder, self.batch_name, "post_analysis_data") check_folder(self.post_analysis_folder_base, self.dryrun, verbose=self.verbose) # Checks that {post_analysis_folder}/{observable_name} exists self.post_analysis_folder = \ os.path.join(self.post_analysis_folder_base, self.observable_name_compact) check_folder(self.post_analysis_folder, self.dryrun, verbose=self.verbose) # Sets the MC interval self._set_mc_interval(mc_interval) # Makes a backup, for later use self.post_analysis_folder_old = self.post_analysis_folder # Checks if we already have scaled the x values or not # print(np.all(np.abs(np.diff(self.x) - self.flow_epsilon) > 1e-14)) if np.all(np.abs(np.diff(self.x) - self.flow_epsilon) > 1e-14): self.x = self.x * self.flow_epsilon self.pre_scale = False else: self.pre_scale = True # Max plotting window variables self.y_limits = [None, None] # Default type of observables, one per configuration per flow self.N_configurations, self.NFlows = self.y.shape[:2] self._analysis_arrays_setup()
def _initiate_plot_values(self, data, data_raw, flow_index=None): """interval_index: int, should be in euclidean time.""" # Sorts data into a format specific for the plotting method for bn in self.batch_names: values = {} if flow_index == None: # Case where we have sub sections of observables, e.g. in # euclidean time. for sub_obs in self.observable_intervals[bn]: sub_values = {} sub_values["a"], sub_values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) sub_values["x"] = np.linspace( 0, self.lattice_sizes[bn][1] * sub_values["a"], self.lattice_sizes[bn][1]) sub_values["y"], sub_values["y_err"] = self.analyse_raw( data[bn][sub_obs], data_raw[bn][self.observable_name_compact][sub_obs]) sub_values["label"] = self.ensemble_names[bn] sub_values["raw"] = \ data_raw[bn][self.observable_name_compact][sub_obs] if self.fold: sub_values["x"] = np.linspace( 0, (int(sub_values["y"].shape[0] / 2)) * sub_values["a"], int(sub_values["y"].shape[0] / 2) + 1) sub_values["y"], sub_values["y_err"] = \ self._folder_and_propagate(sub_values) self.fold_position = sub_values["x"][self.fold_range] if self.with_autocorr: sub_values["tau_int"] = \ data[bn][sub_obs]["ac"]["tau_int"] sub_values["tau_int_err"] = \ data[bn][sub_obs]["ac"]["tau_int_err"] values[sub_obs] = sub_values self.plot_values[bn] = values else: tf_index = "tflow%04.4f" % flow_index values["a"], values["a_err"] = \ get_lattice_spacing(self.beta_values[bn]) # For exact box sizes values["x"] = np.linspace( 0, self.lattice_sizes[bn][1] * values["a"], self.lattice_sizes[bn][1]) values["y_raw"] = \ data_raw[bn][self.observable_name_compact][tf_index] if self.with_autocorr: values["tau_int"] = data[bn][tf_index]["ac"]["tau_int"] values["tau_int_err"] = \ data[bn][tf_index]["ac"]["tau_int_err"] values["y"], values["y_err"] = \ self.analyse_data(data[bn][tf_index]) if self.fold: values["x"] = \ np.linspace( 0, (int(values["y"].shape[0]/2))*values["a"], int(values["y"].shape[0]/2)+1) values["y"], values["y_err"] = self._folder_and_propagate( values) # values["y_raw"] = self.fold_array(values["y_raw"], axis=0) self.fold_position = values["x"][self.fold_range] values["label"] = self.ensemble_names[bn] self.plot_values[bn] = values