diff --git a/docs/pyerrors/obs.html b/docs/pyerrors/obs.html
index d65897e6..e526141d 100644
--- a/docs/pyerrors/obs.html
+++ b/docs/pyerrors/obs.html
@@ -216,1660 +216,1663 @@
12from itertools import groupby
13from .covobs import Covobs
14
- 15
- 16class Obs:
- 17 """Class for a general observable.
+ 15# Improve print output of numpy.ndarrays containing Obs objects.
+ 16np.set_printoptions(formatter={'object': lambda x: str(x)})
+ 17
18
- 19 Instances of Obs are the basic objects of a pyerrors error analysis.
- 20 They are initialized with a list which contains arrays of samples for
- 21 different ensembles/replica and another list of same length which contains
- 22 the names of the ensembles/replica. Mathematical operations can be
- 23 performed on instances. The result is another instance of Obs. The error of
- 24 an instance can be computed with the gamma_method. Also contains additional
- 25 methods for output and visualization of the error calculation.
- 26
- 27 Attributes
- 28 ----------
- 29 S_global : float
- 30 Standard value for S (default 2.0)
- 31 S_dict : dict
- 32 Dictionary for S values. If an entry for a given ensemble
- 33 exists this overwrites the standard value for that ensemble.
- 34 tau_exp_global : float
- 35 Standard value for tau_exp (default 0.0)
- 36 tau_exp_dict : dict
- 37 Dictionary for tau_exp values. If an entry for a given ensemble exists
- 38 this overwrites the standard value for that ensemble.
- 39 N_sigma_global : float
- 40 Standard value for N_sigma (default 1.0)
- 41 N_sigma_dict : dict
- 42 Dictionary for N_sigma values. If an entry for a given ensemble exists
- 43 this overwrites the standard value for that ensemble.
- 44 """
- 45 __slots__ = ['names', 'shape', 'r_values', 'deltas', 'N', '_value', '_dvalue',
- 46 'ddvalue', 'reweighted', 'S', 'tau_exp', 'N_sigma',
- 47 'e_dvalue', 'e_ddvalue', 'e_tauint', 'e_dtauint',
- 48 'e_windowsize', 'e_rho', 'e_drho', 'e_n_tauint', 'e_n_dtauint',
- 49 'idl', 'is_merged', 'tag', '_covobs', '__dict__']
- 50
- 51 S_global = 2.0
- 52 S_dict = {}
- 53 tau_exp_global = 0.0
- 54 tau_exp_dict = {}
- 55 N_sigma_global = 1.0
- 56 N_sigma_dict = {}
- 57 filter_eps = 1e-10
- 58
- 59 def __init__(self, samples, names, idl=None, **kwargs):
- 60 """ Initialize Obs object.
+ 19class Obs:
+ 20 """Class for a general observable.
+ 21
+ 22 Instances of Obs are the basic objects of a pyerrors error analysis.
+ 23 They are initialized with a list which contains arrays of samples for
+ 24 different ensembles/replica and another list of same length which contains
+ 25 the names of the ensembles/replica. Mathematical operations can be
+ 26 performed on instances. The result is another instance of Obs. The error of
+ 27 an instance can be computed with the gamma_method. Also contains additional
+ 28 methods for output and visualization of the error calculation.
+ 29
+ 30 Attributes
+ 31 ----------
+ 32 S_global : float
+ 33 Standard value for S (default 2.0)
+ 34 S_dict : dict
+ 35 Dictionary for S values. If an entry for a given ensemble
+ 36 exists this overwrites the standard value for that ensemble.
+ 37 tau_exp_global : float
+ 38 Standard value for tau_exp (default 0.0)
+ 39 tau_exp_dict : dict
+ 40 Dictionary for tau_exp values. If an entry for a given ensemble exists
+ 41 this overwrites the standard value for that ensemble.
+ 42 N_sigma_global : float
+ 43 Standard value for N_sigma (default 1.0)
+ 44 N_sigma_dict : dict
+ 45 Dictionary for N_sigma values. If an entry for a given ensemble exists
+ 46 this overwrites the standard value for that ensemble.
+ 47 """
+ 48 __slots__ = ['names', 'shape', 'r_values', 'deltas', 'N', '_value', '_dvalue',
+ 49 'ddvalue', 'reweighted', 'S', 'tau_exp', 'N_sigma',
+ 50 'e_dvalue', 'e_ddvalue', 'e_tauint', 'e_dtauint',
+ 51 'e_windowsize', 'e_rho', 'e_drho', 'e_n_tauint', 'e_n_dtauint',
+ 52 'idl', 'is_merged', 'tag', '_covobs', '__dict__']
+ 53
+ 54 S_global = 2.0
+ 55 S_dict = {}
+ 56 tau_exp_global = 0.0
+ 57 tau_exp_dict = {}
+ 58 N_sigma_global = 1.0
+ 59 N_sigma_dict = {}
+ 60 filter_eps = 1e-10
61
- 62 Parameters
- 63 ----------
- 64 samples : list
- 65 list of numpy arrays containing the Monte Carlo samples
- 66 names : list
- 67 list of strings labeling the individual samples
- 68 idl : list, optional
- 69 list of ranges or lists on which the samples are defined
- 70 """
- 71
- 72 if kwargs.get("means") is None and len(samples):
- 73 if len(samples) != len(names):
- 74 raise Exception('Length of samples and names incompatible.')
- 75 if idl is not None:
- 76 if len(idl) != len(names):
- 77 raise Exception('Length of idl incompatible with samples and names.')
- 78 name_length = len(names)
- 79 if name_length > 1:
- 80 if name_length != len(set(names)):
- 81 raise Exception('names are not unique.')
- 82 if not all(isinstance(x, str) for x in names):
- 83 raise TypeError('All names have to be strings.')
- 84 else:
- 85 if not isinstance(names[0], str):
+ 62 def __init__(self, samples, names, idl=None, **kwargs):
+ 63 """ Initialize Obs object.
+ 64
+ 65 Parameters
+ 66 ----------
+ 67 samples : list
+ 68 list of numpy arrays containing the Monte Carlo samples
+ 69 names : list
+ 70 list of strings labeling the individual samples
+ 71 idl : list, optional
+ 72 list of ranges or lists on which the samples are defined
+ 73 """
+ 74
+ 75 if kwargs.get("means") is None and len(samples):
+ 76 if len(samples) != len(names):
+ 77 raise Exception('Length of samples and names incompatible.')
+ 78 if idl is not None:
+ 79 if len(idl) != len(names):
+ 80 raise Exception('Length of idl incompatible with samples and names.')
+ 81 name_length = len(names)
+ 82 if name_length > 1:
+ 83 if name_length != len(set(names)):
+ 84 raise Exception('names are not unique.')
+ 85 if not all(isinstance(x, str) for x in names):
86 raise TypeError('All names have to be strings.')
- 87 if min(len(x) for x in samples) <= 4:
- 88 raise Exception('Samples have to have at least 5 entries.')
- 89
- 90 self.names = sorted(names)
- 91 self.shape = {}
- 92 self.r_values = {}
- 93 self.deltas = {}
- 94 self._covobs = {}
- 95
- 96 self._value = 0
- 97 self.N = 0
- 98 self.is_merged = {}
- 99 self.idl = {}
- 100 if idl is not None:
- 101 for name, idx in sorted(zip(names, idl)):
- 102 if isinstance(idx, range):
- 103 self.idl[name] = idx
- 104 elif isinstance(idx, (list, np.ndarray)):
- 105 dc = np.unique(np.diff(idx))
- 106 if np.any(dc < 0):
- 107 raise Exception("Unsorted idx for idl[%s]" % (name))
- 108 if len(dc) == 1:
- 109 self.idl[name] = range(idx[0], idx[-1] + dc[0], dc[0])
- 110 else:
- 111 self.idl[name] = list(idx)
- 112 else:
- 113 raise Exception('incompatible type for idl[%s].' % (name))
- 114 else:
- 115 for name, sample in sorted(zip(names, samples)):
- 116 self.idl[name] = range(1, len(sample) + 1)
- 117
- 118 if kwargs.get("means") is not None:
- 119 for name, sample, mean in sorted(zip(names, samples, kwargs.get("means"))):
- 120 self.shape[name] = len(self.idl[name])
- 121 self.N += self.shape[name]
- 122 self.r_values[name] = mean
- 123 self.deltas[name] = sample
- 124 else:
- 125 for name, sample in sorted(zip(names, samples)):
- 126 self.shape[name] = len(self.idl[name])
- 127 self.N += self.shape[name]
- 128 if len(sample) != self.shape[name]:
- 129 raise Exception('Incompatible samples and idx for %s: %d vs. %d' % (name, len(sample), self.shape[name]))
- 130 self.r_values[name] = np.mean(sample)
- 131 self.deltas[name] = sample - self.r_values[name]
- 132 self._value += self.shape[name] * self.r_values[name]
- 133 self._value /= self.N
- 134
- 135 self._dvalue = 0.0
- 136 self.ddvalue = 0.0
- 137 self.reweighted = False
- 138
- 139 self.tag = None
- 140
- 141 @property
- 142 def value(self):
- 143 return self._value
- 144
- 145 @property
- 146 def dvalue(self):
- 147 return self._dvalue
- 148
- 149 @property
- 150 def e_names(self):
- 151 return sorted(set([o.split('|')[0] for o in self.names]))
- 152
- 153 @property
- 154 def cov_names(self):
- 155 return sorted(set([o for o in self.covobs.keys()]))
- 156
- 157 @property
- 158 def mc_names(self):
- 159 return sorted(set([o.split('|')[0] for o in self.names if o not in self.cov_names]))
- 160
- 161 @property
- 162 def e_content(self):
- 163 res = {}
- 164 for e, e_name in enumerate(self.e_names):
- 165 res[e_name] = sorted(filter(lambda x: x.startswith(e_name + '|'), self.names))
- 166 if e_name in self.names:
- 167 res[e_name].append(e_name)
- 168 return res
- 169
- 170 @property
- 171 def covobs(self):
- 172 return self._covobs
- 173
- 174 def gamma_method(self, **kwargs):
- 175 """Estimate the error and related properties of the Obs.
+ 87 else:
+ 88 if not isinstance(names[0], str):
+ 89 raise TypeError('All names have to be strings.')
+ 90 if min(len(x) for x in samples) <= 4:
+ 91 raise Exception('Samples have to have at least 5 entries.')
+ 92
+ 93 self.names = sorted(names)
+ 94 self.shape = {}
+ 95 self.r_values = {}
+ 96 self.deltas = {}
+ 97 self._covobs = {}
+ 98
+ 99 self._value = 0
+ 100 self.N = 0
+ 101 self.is_merged = {}
+ 102 self.idl = {}
+ 103 if idl is not None:
+ 104 for name, idx in sorted(zip(names, idl)):
+ 105 if isinstance(idx, range):
+ 106 self.idl[name] = idx
+ 107 elif isinstance(idx, (list, np.ndarray)):
+ 108 dc = np.unique(np.diff(idx))
+ 109 if np.any(dc < 0):
+ 110 raise Exception("Unsorted idx for idl[%s]" % (name))
+ 111 if len(dc) == 1:
+ 112 self.idl[name] = range(idx[0], idx[-1] + dc[0], dc[0])
+ 113 else:
+ 114 self.idl[name] = list(idx)
+ 115 else:
+ 116 raise Exception('incompatible type for idl[%s].' % (name))
+ 117 else:
+ 118 for name, sample in sorted(zip(names, samples)):
+ 119 self.idl[name] = range(1, len(sample) + 1)
+ 120
+ 121 if kwargs.get("means") is not None:
+ 122 for name, sample, mean in sorted(zip(names, samples, kwargs.get("means"))):
+ 123 self.shape[name] = len(self.idl[name])
+ 124 self.N += self.shape[name]
+ 125 self.r_values[name] = mean
+ 126 self.deltas[name] = sample
+ 127 else:
+ 128 for name, sample in sorted(zip(names, samples)):
+ 129 self.shape[name] = len(self.idl[name])
+ 130 self.N += self.shape[name]
+ 131 if len(sample) != self.shape[name]:
+ 132 raise Exception('Incompatible samples and idx for %s: %d vs. %d' % (name, len(sample), self.shape[name]))
+ 133 self.r_values[name] = np.mean(sample)
+ 134 self.deltas[name] = sample - self.r_values[name]
+ 135 self._value += self.shape[name] * self.r_values[name]
+ 136 self._value /= self.N
+ 137
+ 138 self._dvalue = 0.0
+ 139 self.ddvalue = 0.0
+ 140 self.reweighted = False
+ 141
+ 142 self.tag = None
+ 143
+ 144 @property
+ 145 def value(self):
+ 146 return self._value
+ 147
+ 148 @property
+ 149 def dvalue(self):
+ 150 return self._dvalue
+ 151
+ 152 @property
+ 153 def e_names(self):
+ 154 return sorted(set([o.split('|')[0] for o in self.names]))
+ 155
+ 156 @property
+ 157 def cov_names(self):
+ 158 return sorted(set([o for o in self.covobs.keys()]))
+ 159
+ 160 @property
+ 161 def mc_names(self):
+ 162 return sorted(set([o.split('|')[0] for o in self.names if o not in self.cov_names]))
+ 163
+ 164 @property
+ 165 def e_content(self):
+ 166 res = {}
+ 167 for e, e_name in enumerate(self.e_names):
+ 168 res[e_name] = sorted(filter(lambda x: x.startswith(e_name + '|'), self.names))
+ 169 if e_name in self.names:
+ 170 res[e_name].append(e_name)
+ 171 return res
+ 172
+ 173 @property
+ 174 def covobs(self):
+ 175 return self._covobs
176
- 177 Parameters
- 178 ----------
- 179 S : float
- 180 specifies a custom value for the parameter S (default 2.0).
- 181 If set to 0 it is assumed that the data exhibits no
- 182 autocorrelation. In this case the error estimates coincides
- 183 with the sample standard error.
- 184 tau_exp : float
- 185 positive value triggers the critical slowing down analysis
- 186 (default 0.0).
- 187 N_sigma : float
- 188 number of standard deviations from zero until the tail is
- 189 attached to the autocorrelation function (default 1).
- 190 fft : bool
- 191 determines whether the fft algorithm is used for the computation
- 192 of the autocorrelation function (default True)
- 193 """
- 194
- 195 e_content = self.e_content
- 196 self.e_dvalue = {}
- 197 self.e_ddvalue = {}
- 198 self.e_tauint = {}
- 199 self.e_dtauint = {}
- 200 self.e_windowsize = {}
- 201 self.e_n_tauint = {}
- 202 self.e_n_dtauint = {}
- 203 e_gamma = {}
- 204 self.e_rho = {}
- 205 self.e_drho = {}
- 206 self._dvalue = 0
- 207 self.ddvalue = 0
- 208
- 209 self.S = {}
- 210 self.tau_exp = {}
- 211 self.N_sigma = {}
- 212
- 213 if kwargs.get('fft') is False:
- 214 fft = False
- 215 else:
- 216 fft = True
- 217
- 218 def _parse_kwarg(kwarg_name):
- 219 if kwarg_name in kwargs:
- 220 tmp = kwargs.get(kwarg_name)
- 221 if isinstance(tmp, (int, float)):
- 222 if tmp < 0:
- 223 raise Exception(kwarg_name + ' has to be larger or equal to 0.')
- 224 for e, e_name in enumerate(self.e_names):
- 225 getattr(self, kwarg_name)[e_name] = tmp
- 226 else:
- 227 raise TypeError(kwarg_name + ' is not in proper format.')
- 228 else:
- 229 for e, e_name in enumerate(self.e_names):
- 230 if e_name in getattr(Obs, kwarg_name + '_dict'):
- 231 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_dict')[e_name]
- 232 else:
- 233 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_global')
- 234
- 235 _parse_kwarg('S')
- 236 _parse_kwarg('tau_exp')
- 237 _parse_kwarg('N_sigma')
- 238
- 239 for e, e_name in enumerate(self.mc_names):
- 240 r_length = []
- 241 for r_name in e_content[e_name]:
- 242 if isinstance(self.idl[r_name], range):
- 243 r_length.append(len(self.idl[r_name]))
- 244 else:
- 245 r_length.append((self.idl[r_name][-1] - self.idl[r_name][0] + 1))
- 246
- 247 e_N = np.sum([self.shape[r_name] for r_name in e_content[e_name]])
- 248 w_max = max(r_length) // 2
- 249 e_gamma[e_name] = np.zeros(w_max)
- 250 self.e_rho[e_name] = np.zeros(w_max)
- 251 self.e_drho[e_name] = np.zeros(w_max)
- 252
- 253 for r_name in e_content[e_name]:
- 254 e_gamma[e_name] += self._calc_gamma(self.deltas[r_name], self.idl[r_name], self.shape[r_name], w_max, fft)
+ 177 def gamma_method(self, **kwargs):
+ 178 """Estimate the error and related properties of the Obs.
+ 179
+ 180 Parameters
+ 181 ----------
+ 182 S : float
+ 183 specifies a custom value for the parameter S (default 2.0).
+ 184 If set to 0 it is assumed that the data exhibits no
+ 185 autocorrelation. In this case the error estimates coincides
+ 186 with the sample standard error.
+ 187 tau_exp : float
+ 188 positive value triggers the critical slowing down analysis
+ 189 (default 0.0).
+ 190 N_sigma : float
+ 191 number of standard deviations from zero until the tail is
+ 192 attached to the autocorrelation function (default 1).
+ 193 fft : bool
+ 194 determines whether the fft algorithm is used for the computation
+ 195 of the autocorrelation function (default True)
+ 196 """
+ 197
+ 198 e_content = self.e_content
+ 199 self.e_dvalue = {}
+ 200 self.e_ddvalue = {}
+ 201 self.e_tauint = {}
+ 202 self.e_dtauint = {}
+ 203 self.e_windowsize = {}
+ 204 self.e_n_tauint = {}
+ 205 self.e_n_dtauint = {}
+ 206 e_gamma = {}
+ 207 self.e_rho = {}
+ 208 self.e_drho = {}
+ 209 self._dvalue = 0
+ 210 self.ddvalue = 0
+ 211
+ 212 self.S = {}
+ 213 self.tau_exp = {}
+ 214 self.N_sigma = {}
+ 215
+ 216 if kwargs.get('fft') is False:
+ 217 fft = False
+ 218 else:
+ 219 fft = True
+ 220
+ 221 def _parse_kwarg(kwarg_name):
+ 222 if kwarg_name in kwargs:
+ 223 tmp = kwargs.get(kwarg_name)
+ 224 if isinstance(tmp, (int, float)):
+ 225 if tmp < 0:
+ 226 raise Exception(kwarg_name + ' has to be larger or equal to 0.')
+ 227 for e, e_name in enumerate(self.e_names):
+ 228 getattr(self, kwarg_name)[e_name] = tmp
+ 229 else:
+ 230 raise TypeError(kwarg_name + ' is not in proper format.')
+ 231 else:
+ 232 for e, e_name in enumerate(self.e_names):
+ 233 if e_name in getattr(Obs, kwarg_name + '_dict'):
+ 234 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_dict')[e_name]
+ 235 else:
+ 236 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_global')
+ 237
+ 238 _parse_kwarg('S')
+ 239 _parse_kwarg('tau_exp')
+ 240 _parse_kwarg('N_sigma')
+ 241
+ 242 for e, e_name in enumerate(self.mc_names):
+ 243 r_length = []
+ 244 for r_name in e_content[e_name]:
+ 245 if isinstance(self.idl[r_name], range):
+ 246 r_length.append(len(self.idl[r_name]))
+ 247 else:
+ 248 r_length.append((self.idl[r_name][-1] - self.idl[r_name][0] + 1))
+ 249
+ 250 e_N = np.sum([self.shape[r_name] for r_name in e_content[e_name]])
+ 251 w_max = max(r_length) // 2
+ 252 e_gamma[e_name] = np.zeros(w_max)
+ 253 self.e_rho[e_name] = np.zeros(w_max)
+ 254 self.e_drho[e_name] = np.zeros(w_max)
255
- 256 gamma_div = np.zeros(w_max)
- 257 for r_name in e_content[e_name]:
- 258 gamma_div += self._calc_gamma(np.ones((self.shape[r_name])), self.idl[r_name], self.shape[r_name], w_max, fft)
- 259 gamma_div[gamma_div < 1] = 1.0
- 260 e_gamma[e_name] /= gamma_div[:w_max]
- 261
- 262 if np.abs(e_gamma[e_name][0]) < 10 * np.finfo(float).tiny: # Prevent division by zero
- 263 self.e_tauint[e_name] = 0.5
- 264 self.e_dtauint[e_name] = 0.0
- 265 self.e_dvalue[e_name] = 0.0
- 266 self.e_ddvalue[e_name] = 0.0
- 267 self.e_windowsize[e_name] = 0
- 268 continue
- 269
- 270 gaps = []
- 271 for r_name in e_content[e_name]:
- 272 if isinstance(self.idl[r_name], range):
- 273 gaps.append(1)
- 274 else:
- 275 gaps.append(np.min(np.diff(self.idl[r_name])))
- 276
- 277 if not np.all([gi == gaps[0] for gi in gaps]):
- 278 raise Exception(f"Replica for ensemble {e_name} are not equally spaced.", gaps)
- 279 else:
- 280 gapsize = gaps[0]
- 281
- 282 self.e_rho[e_name] = e_gamma[e_name][:w_max] / e_gamma[e_name][0]
- 283 self.e_n_tauint[e_name] = np.cumsum(np.concatenate(([0.5], self.e_rho[e_name][1:])))
- 284 # Make sure no entry of tauint is smaller than 0.5
- 285 self.e_n_tauint[e_name][self.e_n_tauint[e_name] <= 0.5] = 0.5 + np.finfo(np.float64).eps
- 286 # hep-lat/0306017 eq. (42)
- 287 self.e_n_dtauint[e_name] = self.e_n_tauint[e_name] * 2 * np.sqrt(np.abs(np.arange(w_max) / gapsize + 0.5 - self.e_n_tauint[e_name]) / e_N)
- 288 self.e_n_dtauint[e_name][0] = 0.0
- 289
- 290 def _compute_drho(i):
- 291 tmp = self.e_rho[e_name][i + 1:w_max] + np.concatenate([self.e_rho[e_name][i - 1::-1], self.e_rho[e_name][1:w_max - 2 * i]]) - 2 * self.e_rho[e_name][i] * self.e_rho[e_name][1:w_max - i]
- 292 self.e_drho[e_name][i] = np.sqrt(np.sum(tmp ** 2) / e_N)
- 293
- 294 _compute_drho(gapsize)
- 295 if self.tau_exp[e_name] > 0:
- 296 texp = self.tau_exp[e_name]
- 297 # Critical slowing down analysis
- 298 if w_max // 2 <= 1:
- 299 raise Exception("Need at least 8 samples for tau_exp error analysis")
- 300 for n in range(gapsize, w_max // 2, gapsize):
- 301 _compute_drho(n + gapsize)
- 302 if (self.e_rho[e_name][n] - self.N_sigma[e_name] * self.e_drho[e_name][n]) < 0 or n >= w_max // 2 - 2:
- 303 # Bias correction hep-lat/0306017 eq. (49) included
- 304 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) + texp * np.abs(self.e_rho[e_name][n + 1]) # The absolute makes sure, that the tail contribution is always positive
- 305 self.e_dtauint[e_name] = np.sqrt(self.e_n_dtauint[e_name][n] ** 2 + texp ** 2 * self.e_drho[e_name][n + 1] ** 2)
- 306 # Error of tau_exp neglected so far, missing term: self.e_rho[e_name][n + 1] ** 2 * d_tau_exp ** 2
- 307 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
- 308 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
- 309 self.e_windowsize[e_name] = n
- 310 break
- 311 else:
- 312 if self.S[e_name] == 0.0:
- 313 self.e_tauint[e_name] = 0.5
- 314 self.e_dtauint[e_name] = 0.0
- 315 self.e_dvalue[e_name] = np.sqrt(e_gamma[e_name][0] / (e_N - 1))
- 316 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt(0.5 / e_N)
- 317 self.e_windowsize[e_name] = 0
- 318 else:
- 319 # Standard automatic windowing procedure
- 320 tau = self.S[e_name] / np.log((2 * self.e_n_tauint[e_name][gapsize::gapsize] + 1) / (2 * self.e_n_tauint[e_name][gapsize::gapsize] - 1))
- 321 g_w = np.exp(- np.arange(1, len(tau) + 1) / tau) - tau / np.sqrt(np.arange(1, len(tau) + 1) * e_N)
- 322 for n in range(1, w_max):
- 323 if n < w_max // 2 - 2:
- 324 _compute_drho(gapsize * n + gapsize)
- 325 if g_w[n - 1] < 0 or n >= w_max - 1:
- 326 n *= gapsize
- 327 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) # Bias correction hep-lat/0306017 eq. (49)
- 328 self.e_dtauint[e_name] = self.e_n_dtauint[e_name][n]
- 329 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
- 330 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
- 331 self.e_windowsize[e_name] = n
- 332 break
- 333
- 334 self._dvalue += self.e_dvalue[e_name] ** 2
- 335 self.ddvalue += (self.e_dvalue[e_name] * self.e_ddvalue[e_name]) ** 2
+ 256 for r_name in e_content[e_name]:
+ 257 e_gamma[e_name] += self._calc_gamma(self.deltas[r_name], self.idl[r_name], self.shape[r_name], w_max, fft)
+ 258
+ 259 gamma_div = np.zeros(w_max)
+ 260 for r_name in e_content[e_name]:
+ 261 gamma_div += self._calc_gamma(np.ones((self.shape[r_name])), self.idl[r_name], self.shape[r_name], w_max, fft)
+ 262 gamma_div[gamma_div < 1] = 1.0
+ 263 e_gamma[e_name] /= gamma_div[:w_max]
+ 264
+ 265 if np.abs(e_gamma[e_name][0]) < 10 * np.finfo(float).tiny: # Prevent division by zero
+ 266 self.e_tauint[e_name] = 0.5
+ 267 self.e_dtauint[e_name] = 0.0
+ 268 self.e_dvalue[e_name] = 0.0
+ 269 self.e_ddvalue[e_name] = 0.0
+ 270 self.e_windowsize[e_name] = 0
+ 271 continue
+ 272
+ 273 gaps = []
+ 274 for r_name in e_content[e_name]:
+ 275 if isinstance(self.idl[r_name], range):
+ 276 gaps.append(1)
+ 277 else:
+ 278 gaps.append(np.min(np.diff(self.idl[r_name])))
+ 279
+ 280 if not np.all([gi == gaps[0] for gi in gaps]):
+ 281 raise Exception(f"Replica for ensemble {e_name} are not equally spaced.", gaps)
+ 282 else:
+ 283 gapsize = gaps[0]
+ 284
+ 285 self.e_rho[e_name] = e_gamma[e_name][:w_max] / e_gamma[e_name][0]
+ 286 self.e_n_tauint[e_name] = np.cumsum(np.concatenate(([0.5], self.e_rho[e_name][1:])))
+ 287 # Make sure no entry of tauint is smaller than 0.5
+ 288 self.e_n_tauint[e_name][self.e_n_tauint[e_name] <= 0.5] = 0.5 + np.finfo(np.float64).eps
+ 289 # hep-lat/0306017 eq. (42)
+ 290 self.e_n_dtauint[e_name] = self.e_n_tauint[e_name] * 2 * np.sqrt(np.abs(np.arange(w_max) / gapsize + 0.5 - self.e_n_tauint[e_name]) / e_N)
+ 291 self.e_n_dtauint[e_name][0] = 0.0
+ 292
+ 293 def _compute_drho(i):
+ 294 tmp = self.e_rho[e_name][i + 1:w_max] + np.concatenate([self.e_rho[e_name][i - 1::-1], self.e_rho[e_name][1:w_max - 2 * i]]) - 2 * self.e_rho[e_name][i] * self.e_rho[e_name][1:w_max - i]
+ 295 self.e_drho[e_name][i] = np.sqrt(np.sum(tmp ** 2) / e_N)
+ 296
+ 297 _compute_drho(gapsize)
+ 298 if self.tau_exp[e_name] > 0:
+ 299 texp = self.tau_exp[e_name]
+ 300 # Critical slowing down analysis
+ 301 if w_max // 2 <= 1:
+ 302 raise Exception("Need at least 8 samples for tau_exp error analysis")
+ 303 for n in range(gapsize, w_max // 2, gapsize):
+ 304 _compute_drho(n + gapsize)
+ 305 if (self.e_rho[e_name][n] - self.N_sigma[e_name] * self.e_drho[e_name][n]) < 0 or n >= w_max // 2 - 2:
+ 306 # Bias correction hep-lat/0306017 eq. (49) included
+ 307 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) + texp * np.abs(self.e_rho[e_name][n + 1]) # The absolute makes sure, that the tail contribution is always positive
+ 308 self.e_dtauint[e_name] = np.sqrt(self.e_n_dtauint[e_name][n] ** 2 + texp ** 2 * self.e_drho[e_name][n + 1] ** 2)
+ 309 # Error of tau_exp neglected so far, missing term: self.e_rho[e_name][n + 1] ** 2 * d_tau_exp ** 2
+ 310 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
+ 311 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
+ 312 self.e_windowsize[e_name] = n
+ 313 break
+ 314 else:
+ 315 if self.S[e_name] == 0.0:
+ 316 self.e_tauint[e_name] = 0.5
+ 317 self.e_dtauint[e_name] = 0.0
+ 318 self.e_dvalue[e_name] = np.sqrt(e_gamma[e_name][0] / (e_N - 1))
+ 319 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt(0.5 / e_N)
+ 320 self.e_windowsize[e_name] = 0
+ 321 else:
+ 322 # Standard automatic windowing procedure
+ 323 tau = self.S[e_name] / np.log((2 * self.e_n_tauint[e_name][gapsize::gapsize] + 1) / (2 * self.e_n_tauint[e_name][gapsize::gapsize] - 1))
+ 324 g_w = np.exp(- np.arange(1, len(tau) + 1) / tau) - tau / np.sqrt(np.arange(1, len(tau) + 1) * e_N)
+ 325 for n in range(1, w_max):
+ 326 if n < w_max // 2 - 2:
+ 327 _compute_drho(gapsize * n + gapsize)
+ 328 if g_w[n - 1] < 0 or n >= w_max - 1:
+ 329 n *= gapsize
+ 330 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) # Bias correction hep-lat/0306017 eq. (49)
+ 331 self.e_dtauint[e_name] = self.e_n_dtauint[e_name][n]
+ 332 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
+ 333 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
+ 334 self.e_windowsize[e_name] = n
+ 335 break
336
- 337 for e_name in self.cov_names:
- 338 self.e_dvalue[e_name] = np.sqrt(self.covobs[e_name].errsq())
- 339 self.e_ddvalue[e_name] = 0
- 340 self._dvalue += self.e_dvalue[e_name]**2
- 341
- 342 self._dvalue = np.sqrt(self._dvalue)
- 343 if self._dvalue == 0.0:
- 344 self.ddvalue = 0.0
- 345 else:
- 346 self.ddvalue = np.sqrt(self.ddvalue) / self._dvalue
- 347 return
- 348
- 349 def _calc_gamma(self, deltas, idx, shape, w_max, fft):
- 350 """Calculate Gamma_{AA} from the deltas, which are defined on idx.
- 351 idx is assumed to be a contiguous range (possibly with a stepsize != 1)
- 352
- 353 Parameters
- 354 ----------
- 355 deltas : list
- 356 List of fluctuations
- 357 idx : list
- 358 List or range of configurations on which the deltas are defined.
- 359 shape : int
- 360 Number of configurations in idx.
- 361 w_max : int
- 362 Upper bound for the summation window.
- 363 fft : bool
- 364 determines whether the fft algorithm is used for the computation
- 365 of the autocorrelation function.
- 366 """
- 367 gamma = np.zeros(w_max)
- 368 deltas = _expand_deltas(deltas, idx, shape)
- 369 new_shape = len(deltas)
- 370 if fft:
- 371 max_gamma = min(new_shape, w_max)
- 372 # The padding for the fft has to be even
- 373 padding = new_shape + max_gamma + (new_shape + max_gamma) % 2
- 374 gamma[:max_gamma] += np.fft.irfft(np.abs(np.fft.rfft(deltas, padding)) ** 2)[:max_gamma]
- 375 else:
- 376 for n in range(w_max):
- 377 if new_shape - n >= 0:
- 378 gamma[n] += deltas[0:new_shape - n].dot(deltas[n:new_shape])
- 379
- 380 return gamma
- 381
- 382 def details(self, ens_content=True):
- 383 """Output detailed properties of the Obs.
+ 337 self._dvalue += self.e_dvalue[e_name] ** 2
+ 338 self.ddvalue += (self.e_dvalue[e_name] * self.e_ddvalue[e_name]) ** 2
+ 339
+ 340 for e_name in self.cov_names:
+ 341 self.e_dvalue[e_name] = np.sqrt(self.covobs[e_name].errsq())
+ 342 self.e_ddvalue[e_name] = 0
+ 343 self._dvalue += self.e_dvalue[e_name]**2
+ 344
+ 345 self._dvalue = np.sqrt(self._dvalue)
+ 346 if self._dvalue == 0.0:
+ 347 self.ddvalue = 0.0
+ 348 else:
+ 349 self.ddvalue = np.sqrt(self.ddvalue) / self._dvalue
+ 350 return
+ 351
+ 352 def _calc_gamma(self, deltas, idx, shape, w_max, fft):
+ 353 """Calculate Gamma_{AA} from the deltas, which are defined on idx.
+ 354 idx is assumed to be a contiguous range (possibly with a stepsize != 1)
+ 355
+ 356 Parameters
+ 357 ----------
+ 358 deltas : list
+ 359 List of fluctuations
+ 360 idx : list
+ 361 List or range of configurations on which the deltas are defined.
+ 362 shape : int
+ 363 Number of configurations in idx.
+ 364 w_max : int
+ 365 Upper bound for the summation window.
+ 366 fft : bool
+ 367 determines whether the fft algorithm is used for the computation
+ 368 of the autocorrelation function.
+ 369 """
+ 370 gamma = np.zeros(w_max)
+ 371 deltas = _expand_deltas(deltas, idx, shape)
+ 372 new_shape = len(deltas)
+ 373 if fft:
+ 374 max_gamma = min(new_shape, w_max)
+ 375 # The padding for the fft has to be even
+ 376 padding = new_shape + max_gamma + (new_shape + max_gamma) % 2
+ 377 gamma[:max_gamma] += np.fft.irfft(np.abs(np.fft.rfft(deltas, padding)) ** 2)[:max_gamma]
+ 378 else:
+ 379 for n in range(w_max):
+ 380 if new_shape - n >= 0:
+ 381 gamma[n] += deltas[0:new_shape - n].dot(deltas[n:new_shape])
+ 382
+ 383 return gamma
384
- 385 Parameters
- 386 ----------
- 387 ens_content : bool
- 388 print details about the ensembles and replica if true.
- 389 """
- 390 if self.tag is not None:
- 391 print("Description:", self.tag)
- 392 if not hasattr(self, 'e_dvalue'):
- 393 print('Result\t %3.8e' % (self.value))
- 394 else:
- 395 if self.value == 0.0:
- 396 percentage = np.nan
- 397 else:
- 398 percentage = np.abs(self._dvalue / self.value) * 100
- 399 print('Result\t %3.8e +/- %3.8e +/- %3.8e (%3.3f%%)' % (self.value, self._dvalue, self.ddvalue, percentage))
- 400 if len(self.e_names) > 1:
- 401 print(' Ensemble errors:')
- 402 e_content = self.e_content
- 403 for e_name in self.mc_names:
- 404 if isinstance(self.idl[e_content[e_name][0]], range):
- 405 gap = self.idl[e_content[e_name][0]].step
- 406 else:
- 407 gap = np.min(np.diff(self.idl[e_content[e_name][0]]))
- 408
- 409 if len(self.e_names) > 1:
- 410 print('', e_name, '\t %3.6e +/- %3.6e' % (self.e_dvalue[e_name], self.e_ddvalue[e_name]))
- 411 tau_string = " \N{GREEK SMALL LETTER TAU}_int\t " + _format_uncertainty(self.e_tauint[e_name], self.e_dtauint[e_name])
- 412 tau_string += f" in units of {gap} config"
- 413 if gap > 1:
- 414 tau_string += "s"
- 415 if self.tau_exp[e_name] > 0:
- 416 tau_string = f"{tau_string: <45}" + '\t(\N{GREEK SMALL LETTER TAU}_exp=%3.2f, N_\N{GREEK SMALL LETTER SIGMA}=%1.0i)' % (self.tau_exp[e_name], self.N_sigma[e_name])
- 417 else:
- 418 tau_string = f"{tau_string: <45}" + '\t(S=%3.2f)' % (self.S[e_name])
- 419 print(tau_string)
- 420 for e_name in self.cov_names:
- 421 print('', e_name, '\t %3.8e' % (self.e_dvalue[e_name]))
- 422 if ens_content is True:
- 423 if len(self.e_names) == 1:
- 424 print(self.N, 'samples in', len(self.e_names), 'ensemble:')
- 425 else:
- 426 print(self.N, 'samples in', len(self.e_names), 'ensembles:')
- 427 my_string_list = []
- 428 for key, value in sorted(self.e_content.items()):
- 429 if key not in self.covobs:
- 430 my_string = ' ' + "\u00B7 Ensemble '" + key + "' "
- 431 if len(value) == 1:
- 432 my_string += f': {self.shape[value[0]]} configurations'
- 433 if isinstance(self.idl[value[0]], range):
- 434 my_string += f' (from {self.idl[value[0]].start} to {self.idl[value[0]][-1]}' + int(self.idl[value[0]].step != 1) * f' in steps of {self.idl[value[0]].step}' + ')'
- 435 else:
- 436 my_string += f' (irregular range from {self.idl[value[0]][0]} to {self.idl[value[0]][-1]})'
- 437 else:
- 438 sublist = []
- 439 for v in value:
- 440 my_substring = ' ' + "\u00B7 Replicum '" + v[len(key) + 1:] + "' "
- 441 my_substring += f': {self.shape[v]} configurations'
- 442 if isinstance(self.idl[v], range):
- 443 my_substring += f' (from {self.idl[v].start} to {self.idl[v][-1]}' + int(self.idl[v].step != 1) * f' in steps of {self.idl[v].step}' + ')'
- 444 else:
- 445 my_substring += f' (irregular range from {self.idl[v][0]} to {self.idl[v][-1]})'
- 446 sublist.append(my_substring)
- 447
- 448 my_string += '\n' + '\n'.join(sublist)
- 449 else:
- 450 my_string = ' ' + "\u00B7 Covobs '" + key + "' "
- 451 my_string_list.append(my_string)
- 452 print('\n'.join(my_string_list))
- 453
- 454 def reweight(self, weight):
- 455 """Reweight the obs with given rewighting factors.
+ 385 def details(self, ens_content=True):
+ 386 """Output detailed properties of the Obs.
+ 387
+ 388 Parameters
+ 389 ----------
+ 390 ens_content : bool
+ 391 print details about the ensembles and replica if true.
+ 392 """
+ 393 if self.tag is not None:
+ 394 print("Description:", self.tag)
+ 395 if not hasattr(self, 'e_dvalue'):
+ 396 print('Result\t %3.8e' % (self.value))
+ 397 else:
+ 398 if self.value == 0.0:
+ 399 percentage = np.nan
+ 400 else:
+ 401 percentage = np.abs(self._dvalue / self.value) * 100
+ 402 print('Result\t %3.8e +/- %3.8e +/- %3.8e (%3.3f%%)' % (self.value, self._dvalue, self.ddvalue, percentage))
+ 403 if len(self.e_names) > 1:
+ 404 print(' Ensemble errors:')
+ 405 e_content = self.e_content
+ 406 for e_name in self.mc_names:
+ 407 if isinstance(self.idl[e_content[e_name][0]], range):
+ 408 gap = self.idl[e_content[e_name][0]].step
+ 409 else:
+ 410 gap = np.min(np.diff(self.idl[e_content[e_name][0]]))
+ 411
+ 412 if len(self.e_names) > 1:
+ 413 print('', e_name, '\t %3.6e +/- %3.6e' % (self.e_dvalue[e_name], self.e_ddvalue[e_name]))
+ 414 tau_string = " \N{GREEK SMALL LETTER TAU}_int\t " + _format_uncertainty(self.e_tauint[e_name], self.e_dtauint[e_name])
+ 415 tau_string += f" in units of {gap} config"
+ 416 if gap > 1:
+ 417 tau_string += "s"
+ 418 if self.tau_exp[e_name] > 0:
+ 419 tau_string = f"{tau_string: <45}" + '\t(\N{GREEK SMALL LETTER TAU}_exp=%3.2f, N_\N{GREEK SMALL LETTER SIGMA}=%1.0i)' % (self.tau_exp[e_name], self.N_sigma[e_name])
+ 420 else:
+ 421 tau_string = f"{tau_string: <45}" + '\t(S=%3.2f)' % (self.S[e_name])
+ 422 print(tau_string)
+ 423 for e_name in self.cov_names:
+ 424 print('', e_name, '\t %3.8e' % (self.e_dvalue[e_name]))
+ 425 if ens_content is True:
+ 426 if len(self.e_names) == 1:
+ 427 print(self.N, 'samples in', len(self.e_names), 'ensemble:')
+ 428 else:
+ 429 print(self.N, 'samples in', len(self.e_names), 'ensembles:')
+ 430 my_string_list = []
+ 431 for key, value in sorted(self.e_content.items()):
+ 432 if key not in self.covobs:
+ 433 my_string = ' ' + "\u00B7 Ensemble '" + key + "' "
+ 434 if len(value) == 1:
+ 435 my_string += f': {self.shape[value[0]]} configurations'
+ 436 if isinstance(self.idl[value[0]], range):
+ 437 my_string += f' (from {self.idl[value[0]].start} to {self.idl[value[0]][-1]}' + int(self.idl[value[0]].step != 1) * f' in steps of {self.idl[value[0]].step}' + ')'
+ 438 else:
+ 439 my_string += f' (irregular range from {self.idl[value[0]][0]} to {self.idl[value[0]][-1]})'
+ 440 else:
+ 441 sublist = []
+ 442 for v in value:
+ 443 my_substring = ' ' + "\u00B7 Replicum '" + v[len(key) + 1:] + "' "
+ 444 my_substring += f': {self.shape[v]} configurations'
+ 445 if isinstance(self.idl[v], range):
+ 446 my_substring += f' (from {self.idl[v].start} to {self.idl[v][-1]}' + int(self.idl[v].step != 1) * f' in steps of {self.idl[v].step}' + ')'
+ 447 else:
+ 448 my_substring += f' (irregular range from {self.idl[v][0]} to {self.idl[v][-1]})'
+ 449 sublist.append(my_substring)
+ 450
+ 451 my_string += '\n' + '\n'.join(sublist)
+ 452 else:
+ 453 my_string = ' ' + "\u00B7 Covobs '" + key + "' "
+ 454 my_string_list.append(my_string)
+ 455 print('\n'.join(my_string_list))
456
- 457 Parameters
- 458 ----------
- 459 weight : Obs
- 460 Reweighting factor. An Observable that has to be defined on a superset of the
- 461 configurations in obs[i].idl for all i.
- 462 all_configs : bool
- 463 if True, the reweighted observables are normalized by the average of
- 464 the reweighting factor on all configurations in weight.idl and not
- 465 on the configurations in obs[i].idl. Default False.
- 466 """
- 467 return reweight(weight, [self])[0]
- 468
- 469 def is_zero_within_error(self, sigma=1):
- 470 """Checks whether the observable is zero within 'sigma' standard errors.
+ 457 def reweight(self, weight):
+ 458 """Reweight the obs with given rewighting factors.
+ 459
+ 460 Parameters
+ 461 ----------
+ 462 weight : Obs
+ 463 Reweighting factor. An Observable that has to be defined on a superset of the
+ 464 configurations in obs[i].idl for all i.
+ 465 all_configs : bool
+ 466 if True, the reweighted observables are normalized by the average of
+ 467 the reweighting factor on all configurations in weight.idl and not
+ 468 on the configurations in obs[i].idl. Default False.
+ 469 """
+ 470 return reweight(weight, [self])[0]
471
- 472 Parameters
- 473 ----------
- 474 sigma : int
- 475 Number of standard errors used for the check.
- 476
- 477 Works only properly when the gamma method was run.
- 478 """
- 479 return self.is_zero() or np.abs(self.value) <= sigma * self._dvalue
- 480
- 481 def is_zero(self, atol=1e-10):
- 482 """Checks whether the observable is zero within a given tolerance.
+ 472 def is_zero_within_error(self, sigma=1):
+ 473 """Checks whether the observable is zero within 'sigma' standard errors.
+ 474
+ 475 Parameters
+ 476 ----------
+ 477 sigma : int
+ 478 Number of standard errors used for the check.
+ 479
+ 480 Works only properly when the gamma method was run.
+ 481 """
+ 482 return self.is_zero() or np.abs(self.value) <= sigma * self._dvalue
483
- 484 Parameters
- 485 ----------
- 486 atol : float
- 487 Absolute tolerance (for details see numpy documentation).
- 488 """
- 489 return np.isclose(0.0, self.value, 1e-14, atol) and all(np.allclose(0.0, delta, 1e-14, atol) for delta in self.deltas.values()) and all(np.allclose(0.0, delta.errsq(), 1e-14, atol) for delta in self.covobs.values())
- 490
- 491 def plot_tauint(self, save=None):
- 492 """Plot integrated autocorrelation time for each ensemble.
+ 484 def is_zero(self, atol=1e-10):
+ 485 """Checks whether the observable is zero within a given tolerance.
+ 486
+ 487 Parameters
+ 488 ----------
+ 489 atol : float
+ 490 Absolute tolerance (for details see numpy documentation).
+ 491 """
+ 492 return np.isclose(0.0, self.value, 1e-14, atol) and all(np.allclose(0.0, delta, 1e-14, atol) for delta in self.deltas.values()) and all(np.allclose(0.0, delta.errsq(), 1e-14, atol) for delta in self.covobs.values())
493
- 494 Parameters
- 495 ----------
- 496 save : str
- 497 saves the figure to a file named 'save' if.
- 498 """
- 499 if not hasattr(self, 'e_dvalue'):
- 500 raise Exception('Run the gamma method first.')
- 501
- 502 for e, e_name in enumerate(self.mc_names):
- 503 fig = plt.figure()
- 504 plt.xlabel(r'$W$')
- 505 plt.ylabel(r'$\tau_\mathrm{int}$')
- 506 length = int(len(self.e_n_tauint[e_name]))
- 507 if self.tau_exp[e_name] > 0:
- 508 base = self.e_n_tauint[e_name][self.e_windowsize[e_name]]
- 509 x_help = np.arange(2 * self.tau_exp[e_name])
- 510 y_help = (x_help + 1) * np.abs(self.e_rho[e_name][self.e_windowsize[e_name] + 1]) * (1 - x_help / (2 * (2 * self.tau_exp[e_name] - 1))) + base
- 511 x_arr = np.arange(self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name])
- 512 plt.plot(x_arr, y_help, 'C' + str(e), linewidth=1, ls='--', marker=',')
- 513 plt.errorbar([self.e_windowsize[e_name] + 2 * self.tau_exp[e_name]], [self.e_tauint[e_name]],
- 514 yerr=[self.e_dtauint[e_name]], fmt='C' + str(e), linewidth=1, capsize=2, marker='o', mfc=plt.rcParams['axes.facecolor'])
- 515 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
- 516 label = e_name + r', $\tau_\mathrm{exp}$=' + str(np.around(self.tau_exp[e_name], decimals=2))
- 517 else:
- 518 label = e_name + ', S=' + str(np.around(self.S[e_name], decimals=2))
- 519 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
- 520
- 521 plt.errorbar(np.arange(length)[:int(xmax) + 1], self.e_n_tauint[e_name][:int(xmax) + 1], yerr=self.e_n_dtauint[e_name][:int(xmax) + 1], linewidth=1, capsize=2, label=label)
- 522 plt.axvline(x=self.e_windowsize[e_name], color='C' + str(e), alpha=0.5, marker=',', ls='--')
- 523 plt.legend()
- 524 plt.xlim(-0.5, xmax)
- 525 ylim = plt.ylim()
- 526 plt.ylim(bottom=0.0, top=max(1.0, ylim[1]))
- 527 plt.draw()
- 528 if save:
- 529 fig.savefig(save + "_" + str(e))
- 530
- 531 def plot_rho(self, save=None):
- 532 """Plot normalized autocorrelation function time for each ensemble.
+ 494 def plot_tauint(self, save=None):
+ 495 """Plot integrated autocorrelation time for each ensemble.
+ 496
+ 497 Parameters
+ 498 ----------
+ 499 save : str
+ 500 saves the figure to a file named 'save' if.
+ 501 """
+ 502 if not hasattr(self, 'e_dvalue'):
+ 503 raise Exception('Run the gamma method first.')
+ 504
+ 505 for e, e_name in enumerate(self.mc_names):
+ 506 fig = plt.figure()
+ 507 plt.xlabel(r'$W$')
+ 508 plt.ylabel(r'$\tau_\mathrm{int}$')
+ 509 length = int(len(self.e_n_tauint[e_name]))
+ 510 if self.tau_exp[e_name] > 0:
+ 511 base = self.e_n_tauint[e_name][self.e_windowsize[e_name]]
+ 512 x_help = np.arange(2 * self.tau_exp[e_name])
+ 513 y_help = (x_help + 1) * np.abs(self.e_rho[e_name][self.e_windowsize[e_name] + 1]) * (1 - x_help / (2 * (2 * self.tau_exp[e_name] - 1))) + base
+ 514 x_arr = np.arange(self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name])
+ 515 plt.plot(x_arr, y_help, 'C' + str(e), linewidth=1, ls='--', marker=',')
+ 516 plt.errorbar([self.e_windowsize[e_name] + 2 * self.tau_exp[e_name]], [self.e_tauint[e_name]],
+ 517 yerr=[self.e_dtauint[e_name]], fmt='C' + str(e), linewidth=1, capsize=2, marker='o', mfc=plt.rcParams['axes.facecolor'])
+ 518 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
+ 519 label = e_name + r', $\tau_\mathrm{exp}$=' + str(np.around(self.tau_exp[e_name], decimals=2))
+ 520 else:
+ 521 label = e_name + ', S=' + str(np.around(self.S[e_name], decimals=2))
+ 522 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
+ 523
+ 524 plt.errorbar(np.arange(length)[:int(xmax) + 1], self.e_n_tauint[e_name][:int(xmax) + 1], yerr=self.e_n_dtauint[e_name][:int(xmax) + 1], linewidth=1, capsize=2, label=label)
+ 525 plt.axvline(x=self.e_windowsize[e_name], color='C' + str(e), alpha=0.5, marker=',', ls='--')
+ 526 plt.legend()
+ 527 plt.xlim(-0.5, xmax)
+ 528 ylim = plt.ylim()
+ 529 plt.ylim(bottom=0.0, top=max(1.0, ylim[1]))
+ 530 plt.draw()
+ 531 if save:
+ 532 fig.savefig(save + "_" + str(e))
533
- 534 Parameters
- 535 ----------
- 536 save : str
- 537 saves the figure to a file named 'save' if.
- 538 """
- 539 if not hasattr(self, 'e_dvalue'):
- 540 raise Exception('Run the gamma method first.')
- 541 for e, e_name in enumerate(self.mc_names):
- 542 fig = plt.figure()
- 543 plt.xlabel('W')
- 544 plt.ylabel('rho')
- 545 length = int(len(self.e_drho[e_name]))
- 546 plt.errorbar(np.arange(length), self.e_rho[e_name][:length], yerr=self.e_drho[e_name][:], linewidth=1, capsize=2)
- 547 plt.axvline(x=self.e_windowsize[e_name], color='r', alpha=0.25, ls='--', marker=',')
- 548 if self.tau_exp[e_name] > 0:
- 549 plt.plot([self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name]],
- 550 [self.e_rho[e_name][self.e_windowsize[e_name] + 1], 0], 'k-', lw=1)
- 551 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
- 552 plt.title('Rho ' + e_name + r', tau\_exp=' + str(np.around(self.tau_exp[e_name], decimals=2)))
- 553 else:
- 554 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
- 555 plt.title('Rho ' + e_name + ', S=' + str(np.around(self.S[e_name], decimals=2)))
- 556 plt.plot([-0.5, xmax], [0, 0], 'k--', lw=1)
- 557 plt.xlim(-0.5, xmax)
- 558 plt.draw()
- 559 if save:
- 560 fig.savefig(save + "_" + str(e))
- 561
- 562 def plot_rep_dist(self):
- 563 """Plot replica distribution for each ensemble with more than one replicum."""
- 564 if not hasattr(self, 'e_dvalue'):
- 565 raise Exception('Run the gamma method first.')
- 566 for e, e_name in enumerate(self.mc_names):
- 567 if len(self.e_content[e_name]) == 1:
- 568 print('No replica distribution for a single replicum (', e_name, ')')
- 569 continue
- 570 r_length = []
- 571 sub_r_mean = 0
- 572 for r, r_name in enumerate(self.e_content[e_name]):
- 573 r_length.append(len(self.deltas[r_name]))
- 574 sub_r_mean += self.shape[r_name] * self.r_values[r_name]
- 575 e_N = np.sum(r_length)
- 576 sub_r_mean /= e_N
- 577 arr = np.zeros(len(self.e_content[e_name]))
- 578 for r, r_name in enumerate(self.e_content[e_name]):
- 579 arr[r] = (self.r_values[r_name] - sub_r_mean) / (self.e_dvalue[e_name] * np.sqrt(e_N / self.shape[r_name] - 1))
- 580 plt.hist(arr, rwidth=0.8, bins=len(self.e_content[e_name]))
- 581 plt.title('Replica distribution' + e_name + ' (mean=0, var=1)')
- 582 plt.draw()
- 583
- 584 def plot_history(self, expand=True):
- 585 """Plot derived Monte Carlo history for each ensemble
+ 534 def plot_rho(self, save=None):
+ 535 """Plot normalized autocorrelation function time for each ensemble.
+ 536
+ 537 Parameters
+ 538 ----------
+ 539 save : str
+ 540 saves the figure to a file named 'save' if.
+ 541 """
+ 542 if not hasattr(self, 'e_dvalue'):
+ 543 raise Exception('Run the gamma method first.')
+ 544 for e, e_name in enumerate(self.mc_names):
+ 545 fig = plt.figure()
+ 546 plt.xlabel('W')
+ 547 plt.ylabel('rho')
+ 548 length = int(len(self.e_drho[e_name]))
+ 549 plt.errorbar(np.arange(length), self.e_rho[e_name][:length], yerr=self.e_drho[e_name][:], linewidth=1, capsize=2)
+ 550 plt.axvline(x=self.e_windowsize[e_name], color='r', alpha=0.25, ls='--', marker=',')
+ 551 if self.tau_exp[e_name] > 0:
+ 552 plt.plot([self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name]],
+ 553 [self.e_rho[e_name][self.e_windowsize[e_name] + 1], 0], 'k-', lw=1)
+ 554 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
+ 555 plt.title('Rho ' + e_name + r', tau\_exp=' + str(np.around(self.tau_exp[e_name], decimals=2)))
+ 556 else:
+ 557 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
+ 558 plt.title('Rho ' + e_name + ', S=' + str(np.around(self.S[e_name], decimals=2)))
+ 559 plt.plot([-0.5, xmax], [0, 0], 'k--', lw=1)
+ 560 plt.xlim(-0.5, xmax)
+ 561 plt.draw()
+ 562 if save:
+ 563 fig.savefig(save + "_" + str(e))
+ 564
+ 565 def plot_rep_dist(self):
+ 566 """Plot replica distribution for each ensemble with more than one replicum."""
+ 567 if not hasattr(self, 'e_dvalue'):
+ 568 raise Exception('Run the gamma method first.')
+ 569 for e, e_name in enumerate(self.mc_names):
+ 570 if len(self.e_content[e_name]) == 1:
+ 571 print('No replica distribution for a single replicum (', e_name, ')')
+ 572 continue
+ 573 r_length = []
+ 574 sub_r_mean = 0
+ 575 for r, r_name in enumerate(self.e_content[e_name]):
+ 576 r_length.append(len(self.deltas[r_name]))
+ 577 sub_r_mean += self.shape[r_name] * self.r_values[r_name]
+ 578 e_N = np.sum(r_length)
+ 579 sub_r_mean /= e_N
+ 580 arr = np.zeros(len(self.e_content[e_name]))
+ 581 for r, r_name in enumerate(self.e_content[e_name]):
+ 582 arr[r] = (self.r_values[r_name] - sub_r_mean) / (self.e_dvalue[e_name] * np.sqrt(e_N / self.shape[r_name] - 1))
+ 583 plt.hist(arr, rwidth=0.8, bins=len(self.e_content[e_name]))
+ 584 plt.title('Replica distribution' + e_name + ' (mean=0, var=1)')
+ 585 plt.draw()
586
- 587 Parameters
- 588 ----------
- 589 expand : bool
- 590 show expanded history for irregular Monte Carlo chains (default: True).
- 591 """
- 592 for e, e_name in enumerate(self.mc_names):
- 593 plt.figure()
- 594 r_length = []
- 595 tmp = []
- 596 tmp_expanded = []
- 597 for r, r_name in enumerate(self.e_content[e_name]):
- 598 tmp.append(self.deltas[r_name] + self.r_values[r_name])
- 599 if expand:
- 600 tmp_expanded.append(_expand_deltas(self.deltas[r_name], list(self.idl[r_name]), self.shape[r_name]) + self.r_values[r_name])
- 601 r_length.append(len(tmp_expanded[-1]))
- 602 else:
- 603 r_length.append(len(tmp[-1]))
- 604 e_N = np.sum(r_length)
- 605 x = np.arange(e_N)
- 606 y_test = np.concatenate(tmp, axis=0)
- 607 if expand:
- 608 y = np.concatenate(tmp_expanded, axis=0)
- 609 else:
- 610 y = y_test
- 611 plt.errorbar(x, y, fmt='.', markersize=3)
- 612 plt.xlim(-0.5, e_N - 0.5)
- 613 plt.title(e_name + f'\nskew: {skew(y_test):.3f} (p={skewtest(y_test).pvalue:.3f}), kurtosis: {kurtosis(y_test):.3f} (p={kurtosistest(y_test).pvalue:.3f})')
- 614 plt.draw()
- 615
- 616 def plot_piechart(self, save=None):
- 617 """Plot piechart which shows the fractional contribution of each
- 618 ensemble to the error and returns a dictionary containing the fractions.
- 619
- 620 Parameters
- 621 ----------
- 622 save : str
- 623 saves the figure to a file named 'save' if.
- 624 """
- 625 if not hasattr(self, 'e_dvalue'):
- 626 raise Exception('Run the gamma method first.')
- 627 if np.isclose(0.0, self._dvalue, atol=1e-15):
- 628 raise Exception('Error is 0.0')
- 629 labels = self.e_names
- 630 sizes = [self.e_dvalue[name] ** 2 for name in labels] / self._dvalue ** 2
- 631 fig1, ax1 = plt.subplots()
- 632 ax1.pie(sizes, labels=labels, startangle=90, normalize=True)
- 633 ax1.axis('equal')
- 634 plt.draw()
- 635 if save:
- 636 fig1.savefig(save)
- 637
- 638 return dict(zip(self.e_names, sizes))
- 639
- 640 def dump(self, filename, datatype="json.gz", description="", **kwargs):
- 641 """Dump the Obs to a file 'name' of chosen format.
+ 587 def plot_history(self, expand=True):
+ 588 """Plot derived Monte Carlo history for each ensemble
+ 589
+ 590 Parameters
+ 591 ----------
+ 592 expand : bool
+ 593 show expanded history for irregular Monte Carlo chains (default: True).
+ 594 """
+ 595 for e, e_name in enumerate(self.mc_names):
+ 596 plt.figure()
+ 597 r_length = []
+ 598 tmp = []
+ 599 tmp_expanded = []
+ 600 for r, r_name in enumerate(self.e_content[e_name]):
+ 601 tmp.append(self.deltas[r_name] + self.r_values[r_name])
+ 602 if expand:
+ 603 tmp_expanded.append(_expand_deltas(self.deltas[r_name], list(self.idl[r_name]), self.shape[r_name]) + self.r_values[r_name])
+ 604 r_length.append(len(tmp_expanded[-1]))
+ 605 else:
+ 606 r_length.append(len(tmp[-1]))
+ 607 e_N = np.sum(r_length)
+ 608 x = np.arange(e_N)
+ 609 y_test = np.concatenate(tmp, axis=0)
+ 610 if expand:
+ 611 y = np.concatenate(tmp_expanded, axis=0)
+ 612 else:
+ 613 y = y_test
+ 614 plt.errorbar(x, y, fmt='.', markersize=3)
+ 615 plt.xlim(-0.5, e_N - 0.5)
+ 616 plt.title(e_name + f'\nskew: {skew(y_test):.3f} (p={skewtest(y_test).pvalue:.3f}), kurtosis: {kurtosis(y_test):.3f} (p={kurtosistest(y_test).pvalue:.3f})')
+ 617 plt.draw()
+ 618
+ 619 def plot_piechart(self, save=None):
+ 620 """Plot piechart which shows the fractional contribution of each
+ 621 ensemble to the error and returns a dictionary containing the fractions.
+ 622
+ 623 Parameters
+ 624 ----------
+ 625 save : str
+ 626 saves the figure to a file named 'save' if.
+ 627 """
+ 628 if not hasattr(self, 'e_dvalue'):
+ 629 raise Exception('Run the gamma method first.')
+ 630 if np.isclose(0.0, self._dvalue, atol=1e-15):
+ 631 raise Exception('Error is 0.0')
+ 632 labels = self.e_names
+ 633 sizes = [self.e_dvalue[name] ** 2 for name in labels] / self._dvalue ** 2
+ 634 fig1, ax1 = plt.subplots()
+ 635 ax1.pie(sizes, labels=labels, startangle=90, normalize=True)
+ 636 ax1.axis('equal')
+ 637 plt.draw()
+ 638 if save:
+ 639 fig1.savefig(save)
+ 640
+ 641 return dict(zip(self.e_names, sizes))
642
- 643 Parameters
- 644 ----------
- 645 filename : str
- 646 name of the file to be saved.
- 647 datatype : str
- 648 Format of the exported file. Supported formats include
- 649 "json.gz" and "pickle"
- 650 description : str
- 651 Description for output file, only relevant for json.gz format.
- 652 path : str
- 653 specifies a custom path for the file (default '.')
- 654 """
- 655 if 'path' in kwargs:
- 656 file_name = kwargs.get('path') + '/' + filename
- 657 else:
- 658 file_name = filename
- 659
- 660 if datatype == "json.gz":
- 661 from .input.json import dump_to_json
- 662 dump_to_json([self], file_name, description=description)
- 663 elif datatype == "pickle":
- 664 with open(file_name + '.p', 'wb') as fb:
- 665 pickle.dump(self, fb)
- 666 else:
- 667 raise Exception("Unknown datatype " + str(datatype))
- 668
- 669 def export_jackknife(self):
- 670 """Export jackknife samples from the Obs
+ 643 def dump(self, filename, datatype="json.gz", description="", **kwargs):
+ 644 """Dump the Obs to a file 'name' of chosen format.
+ 645
+ 646 Parameters
+ 647 ----------
+ 648 filename : str
+ 649 name of the file to be saved.
+ 650 datatype : str
+ 651 Format of the exported file. Supported formats include
+ 652 "json.gz" and "pickle"
+ 653 description : str
+ 654 Description for output file, only relevant for json.gz format.
+ 655 path : str
+ 656 specifies a custom path for the file (default '.')
+ 657 """
+ 658 if 'path' in kwargs:
+ 659 file_name = kwargs.get('path') + '/' + filename
+ 660 else:
+ 661 file_name = filename
+ 662
+ 663 if datatype == "json.gz":
+ 664 from .input.json import dump_to_json
+ 665 dump_to_json([self], file_name, description=description)
+ 666 elif datatype == "pickle":
+ 667 with open(file_name + '.p', 'wb') as fb:
+ 668 pickle.dump(self, fb)
+ 669 else:
+ 670 raise Exception("Unknown datatype " + str(datatype))
671
- 672 Returns
- 673 -------
- 674 numpy.ndarray
- 675 Returns a numpy array of length N + 1 where N is the number of samples
- 676 for the given ensemble and replicum. The zeroth entry of the array contains
- 677 the mean value of the Obs, entries 1 to N contain the N jackknife samples
- 678 derived from the Obs. The current implementation only works for observables
- 679 defined on exactly one ensemble and replicum. The derived jackknife samples
- 680 should agree with samples from a full jackknife analysis up to O(1/N).
- 681 """
- 682
- 683 if len(self.names) != 1:
- 684 raise Exception("'export_jackknife' is only implemented for Obs defined on one ensemble and replicum.")
+ 672 def export_jackknife(self):
+ 673 """Export jackknife samples from the Obs
+ 674
+ 675 Returns
+ 676 -------
+ 677 numpy.ndarray
+ 678 Returns a numpy array of length N + 1 where N is the number of samples
+ 679 for the given ensemble and replicum. The zeroth entry of the array contains
+ 680 the mean value of the Obs, entries 1 to N contain the N jackknife samples
+ 681 derived from the Obs. The current implementation only works for observables
+ 682 defined on exactly one ensemble and replicum. The derived jackknife samples
+ 683 should agree with samples from a full jackknife analysis up to O(1/N).
+ 684 """
685
- 686 name = self.names[0]
- 687 full_data = self.deltas[name] + self.r_values[name]
- 688 n = full_data.size
- 689 mean = self.value
- 690 tmp_jacks = np.zeros(n + 1)
- 691 tmp_jacks[0] = mean
- 692 tmp_jacks[1:] = (n * mean - full_data) / (n - 1)
- 693 return tmp_jacks
- 694
- 695 def __float__(self):
- 696 return float(self.value)
+ 686 if len(self.names) != 1:
+ 687 raise Exception("'export_jackknife' is only implemented for Obs defined on one ensemble and replicum.")
+ 688
+ 689 name = self.names[0]
+ 690 full_data = self.deltas[name] + self.r_values[name]
+ 691 n = full_data.size
+ 692 mean = self.value
+ 693 tmp_jacks = np.zeros(n + 1)
+ 694 tmp_jacks[0] = mean
+ 695 tmp_jacks[1:] = (n * mean - full_data) / (n - 1)
+ 696 return tmp_jacks
697
- 698 def __repr__(self):
- 699 return 'Obs[' + str(self) + ']'
+ 698 def __float__(self):
+ 699 return float(self.value)
700
- 701 def __str__(self):
- 702 return _format_uncertainty(self.value, self._dvalue)
+ 701 def __repr__(self):
+ 702 return 'Obs[' + str(self) + ']'
703
- 704 def __hash__(self):
- 705 hash_tuple = (np.array([self.value]).astype(np.float32).data.tobytes(),)
- 706 hash_tuple += tuple([o.astype(np.float32).data.tobytes() for o in self.deltas.values()])
- 707 hash_tuple += tuple([np.array([o.errsq()]).astype(np.float32).data.tobytes() for o in self.covobs.values()])
- 708 hash_tuple += tuple([o.encode() for o in self.names])
- 709 m = hashlib.md5()
- 710 [m.update(o) for o in hash_tuple]
- 711 return int(m.hexdigest(), 16) & 0xFFFFFFFF
- 712
- 713 # Overload comparisons
- 714 def __lt__(self, other):
- 715 return self.value < other
- 716
- 717 def __le__(self, other):
- 718 return self.value <= other
+ 704 def __str__(self):
+ 705 return _format_uncertainty(self.value, self._dvalue)
+ 706
+ 707 def __hash__(self):
+ 708 hash_tuple = (np.array([self.value]).astype(np.float32).data.tobytes(),)
+ 709 hash_tuple += tuple([o.astype(np.float32).data.tobytes() for o in self.deltas.values()])
+ 710 hash_tuple += tuple([np.array([o.errsq()]).astype(np.float32).data.tobytes() for o in self.covobs.values()])
+ 711 hash_tuple += tuple([o.encode() for o in self.names])
+ 712 m = hashlib.md5()
+ 713 [m.update(o) for o in hash_tuple]
+ 714 return int(m.hexdigest(), 16) & 0xFFFFFFFF
+ 715
+ 716 # Overload comparisons
+ 717 def __lt__(self, other):
+ 718 return self.value < other
719
- 720 def __gt__(self, other):
- 721 return self.value > other
+ 720 def __le__(self, other):
+ 721 return self.value <= other
722
- 723 def __ge__(self, other):
- 724 return self.value >= other
+ 723 def __gt__(self, other):
+ 724 return self.value > other
725
- 726 def __eq__(self, other):
- 727 return (self - other).is_zero()
+ 726 def __ge__(self, other):
+ 727 return self.value >= other
728
- 729 def __ne__(self, other):
- 730 return not (self - other).is_zero()
+ 729 def __eq__(self, other):
+ 730 return (self - other).is_zero()
731
- 732 # Overload math operations
- 733 def __add__(self, y):
- 734 if isinstance(y, Obs):
- 735 return derived_observable(lambda x, **kwargs: x[0] + x[1], [self, y], man_grad=[1, 1])
- 736 else:
- 737 if isinstance(y, np.ndarray):
- 738 return np.array([self + o for o in y])
- 739 elif y.__class__.__name__ in ['Corr', 'CObs']:
- 740 return NotImplemented
- 741 else:
- 742 return derived_observable(lambda x, **kwargs: x[0] + y, [self], man_grad=[1])
- 743
- 744 def __radd__(self, y):
- 745 return self + y
+ 732 def __ne__(self, other):
+ 733 return not (self - other).is_zero()
+ 734
+ 735 # Overload math operations
+ 736 def __add__(self, y):
+ 737 if isinstance(y, Obs):
+ 738 return derived_observable(lambda x, **kwargs: x[0] + x[1], [self, y], man_grad=[1, 1])
+ 739 else:
+ 740 if isinstance(y, np.ndarray):
+ 741 return np.array([self + o for o in y])
+ 742 elif y.__class__.__name__ in ['Corr', 'CObs']:
+ 743 return NotImplemented
+ 744 else:
+ 745 return derived_observable(lambda x, **kwargs: x[0] + y, [self], man_grad=[1])
746
- 747 def __mul__(self, y):
- 748 if isinstance(y, Obs):
- 749 return derived_observable(lambda x, **kwargs: x[0] * x[1], [self, y], man_grad=[y.value, self.value])
- 750 else:
- 751 if isinstance(y, np.ndarray):
- 752 return np.array([self * o for o in y])
- 753 elif isinstance(y, complex):
- 754 return CObs(self * y.real, self * y.imag)
- 755 elif y.__class__.__name__ in ['Corr', 'CObs']:
- 756 return NotImplemented
- 757 else:
- 758 return derived_observable(lambda x, **kwargs: x[0] * y, [self], man_grad=[y])
- 759
- 760 def __rmul__(self, y):
- 761 return self * y
+ 747 def __radd__(self, y):
+ 748 return self + y
+ 749
+ 750 def __mul__(self, y):
+ 751 if isinstance(y, Obs):
+ 752 return derived_observable(lambda x, **kwargs: x[0] * x[1], [self, y], man_grad=[y.value, self.value])
+ 753 else:
+ 754 if isinstance(y, np.ndarray):
+ 755 return np.array([self * o for o in y])
+ 756 elif isinstance(y, complex):
+ 757 return CObs(self * y.real, self * y.imag)
+ 758 elif y.__class__.__name__ in ['Corr', 'CObs']:
+ 759 return NotImplemented
+ 760 else:
+ 761 return derived_observable(lambda x, **kwargs: x[0] * y, [self], man_grad=[y])
762
- 763 def __sub__(self, y):
- 764 if isinstance(y, Obs):
- 765 return derived_observable(lambda x, **kwargs: x[0] - x[1], [self, y], man_grad=[1, -1])
- 766 else:
- 767 if isinstance(y, np.ndarray):
- 768 return np.array([self - o for o in y])
- 769 elif y.__class__.__name__ in ['Corr', 'CObs']:
- 770 return NotImplemented
- 771 else:
- 772 return derived_observable(lambda x, **kwargs: x[0] - y, [self], man_grad=[1])
- 773
- 774 def __rsub__(self, y):
- 775 return -1 * (self - y)
+ 763 def __rmul__(self, y):
+ 764 return self * y
+ 765
+ 766 def __sub__(self, y):
+ 767 if isinstance(y, Obs):
+ 768 return derived_observable(lambda x, **kwargs: x[0] - x[1], [self, y], man_grad=[1, -1])
+ 769 else:
+ 770 if isinstance(y, np.ndarray):
+ 771 return np.array([self - o for o in y])
+ 772 elif y.__class__.__name__ in ['Corr', 'CObs']:
+ 773 return NotImplemented
+ 774 else:
+ 775 return derived_observable(lambda x, **kwargs: x[0] - y, [self], man_grad=[1])
776
- 777 def __pos__(self):
- 778 return self
+ 777 def __rsub__(self, y):
+ 778 return -1 * (self - y)
779
- 780 def __neg__(self):
- 781 return -1 * self
+ 780 def __pos__(self):
+ 781 return self
782
- 783 def __truediv__(self, y):
- 784 if isinstance(y, Obs):
- 785 return derived_observable(lambda x, **kwargs: x[0] / x[1], [self, y], man_grad=[1 / y.value, - self.value / y.value ** 2])
- 786 else:
- 787 if isinstance(y, np.ndarray):
- 788 return np.array([self / o for o in y])
- 789 elif y.__class__.__name__ in ['Corr', 'CObs']:
- 790 return NotImplemented
- 791 else:
- 792 return derived_observable(lambda x, **kwargs: x[0] / y, [self], man_grad=[1 / y])
- 793
- 794 def __rtruediv__(self, y):
- 795 if isinstance(y, Obs):
- 796 return derived_observable(lambda x, **kwargs: x[0] / x[1], [y, self], man_grad=[1 / self.value, - y.value / self.value ** 2])
- 797 else:
- 798 if isinstance(y, np.ndarray):
- 799 return np.array([o / self for o in y])
- 800 elif y.__class__.__name__ in ['Corr', 'CObs']:
- 801 return NotImplemented
- 802 else:
- 803 return derived_observable(lambda x, **kwargs: y / x[0], [self], man_grad=[-y / self.value ** 2])
- 804
- 805 def __pow__(self, y):
- 806 if isinstance(y, Obs):
- 807 return derived_observable(lambda x: x[0] ** x[1], [self, y])
- 808 else:
- 809 return derived_observable(lambda x: x[0] ** y, [self])
- 810
- 811 def __rpow__(self, y):
- 812 if isinstance(y, Obs):
- 813 return derived_observable(lambda x: x[0] ** x[1], [y, self])
- 814 else:
- 815 return derived_observable(lambda x: y ** x[0], [self])
- 816
- 817 def __abs__(self):
- 818 return derived_observable(lambda x: anp.abs(x[0]), [self])
+ 783 def __neg__(self):
+ 784 return -1 * self
+ 785
+ 786 def __truediv__(self, y):
+ 787 if isinstance(y, Obs):
+ 788 return derived_observable(lambda x, **kwargs: x[0] / x[1], [self, y], man_grad=[1 / y.value, - self.value / y.value ** 2])
+ 789 else:
+ 790 if isinstance(y, np.ndarray):
+ 791 return np.array([self / o for o in y])
+ 792 elif y.__class__.__name__ in ['Corr', 'CObs']:
+ 793 return NotImplemented
+ 794 else:
+ 795 return derived_observable(lambda x, **kwargs: x[0] / y, [self], man_grad=[1 / y])
+ 796
+ 797 def __rtruediv__(self, y):
+ 798 if isinstance(y, Obs):
+ 799 return derived_observable(lambda x, **kwargs: x[0] / x[1], [y, self], man_grad=[1 / self.value, - y.value / self.value ** 2])
+ 800 else:
+ 801 if isinstance(y, np.ndarray):
+ 802 return np.array([o / self for o in y])
+ 803 elif y.__class__.__name__ in ['Corr', 'CObs']:
+ 804 return NotImplemented
+ 805 else:
+ 806 return derived_observable(lambda x, **kwargs: y / x[0], [self], man_grad=[-y / self.value ** 2])
+ 807
+ 808 def __pow__(self, y):
+ 809 if isinstance(y, Obs):
+ 810 return derived_observable(lambda x: x[0] ** x[1], [self, y])
+ 811 else:
+ 812 return derived_observable(lambda x: x[0] ** y, [self])
+ 813
+ 814 def __rpow__(self, y):
+ 815 if isinstance(y, Obs):
+ 816 return derived_observable(lambda x: x[0] ** x[1], [y, self])
+ 817 else:
+ 818 return derived_observable(lambda x: y ** x[0], [self])
819
- 820 # Overload numpy functions
- 821 def sqrt(self):
- 822 return derived_observable(lambda x, **kwargs: np.sqrt(x[0]), [self], man_grad=[1 / 2 / np.sqrt(self.value)])
- 823
- 824 def log(self):
- 825 return derived_observable(lambda x, **kwargs: np.log(x[0]), [self], man_grad=[1 / self.value])
+ 820 def __abs__(self):
+ 821 return derived_observable(lambda x: anp.abs(x[0]), [self])
+ 822
+ 823 # Overload numpy functions
+ 824 def sqrt(self):
+ 825 return derived_observable(lambda x, **kwargs: np.sqrt(x[0]), [self], man_grad=[1 / 2 / np.sqrt(self.value)])
826
- 827 def exp(self):
- 828 return derived_observable(lambda x, **kwargs: np.exp(x[0]), [self], man_grad=[np.exp(self.value)])
+ 827 def log(self):
+ 828 return derived_observable(lambda x, **kwargs: np.log(x[0]), [self], man_grad=[1 / self.value])
829
- 830 def sin(self):
- 831 return derived_observable(lambda x, **kwargs: np.sin(x[0]), [self], man_grad=[np.cos(self.value)])
+ 830 def exp(self):
+ 831 return derived_observable(lambda x, **kwargs: np.exp(x[0]), [self], man_grad=[np.exp(self.value)])
832
- 833 def cos(self):
- 834 return derived_observable(lambda x, **kwargs: np.cos(x[0]), [self], man_grad=[-np.sin(self.value)])
+ 833 def sin(self):
+ 834 return derived_observable(lambda x, **kwargs: np.sin(x[0]), [self], man_grad=[np.cos(self.value)])
835
- 836 def tan(self):
- 837 return derived_observable(lambda x, **kwargs: np.tan(x[0]), [self], man_grad=[1 / np.cos(self.value) ** 2])
+ 836 def cos(self):
+ 837 return derived_observable(lambda x, **kwargs: np.cos(x[0]), [self], man_grad=[-np.sin(self.value)])
838
- 839 def arcsin(self):
- 840 return derived_observable(lambda x: anp.arcsin(x[0]), [self])
+ 839 def tan(self):
+ 840 return derived_observable(lambda x, **kwargs: np.tan(x[0]), [self], man_grad=[1 / np.cos(self.value) ** 2])
841
- 842 def arccos(self):
- 843 return derived_observable(lambda x: anp.arccos(x[0]), [self])
+ 842 def arcsin(self):
+ 843 return derived_observable(lambda x: anp.arcsin(x[0]), [self])
844
- 845 def arctan(self):
- 846 return derived_observable(lambda x: anp.arctan(x[0]), [self])
+ 845 def arccos(self):
+ 846 return derived_observable(lambda x: anp.arccos(x[0]), [self])
847
- 848 def sinh(self):
- 849 return derived_observable(lambda x, **kwargs: np.sinh(x[0]), [self], man_grad=[np.cosh(self.value)])
+ 848 def arctan(self):
+ 849 return derived_observable(lambda x: anp.arctan(x[0]), [self])
850
- 851 def cosh(self):
- 852 return derived_observable(lambda x, **kwargs: np.cosh(x[0]), [self], man_grad=[np.sinh(self.value)])
+ 851 def sinh(self):
+ 852 return derived_observable(lambda x, **kwargs: np.sinh(x[0]), [self], man_grad=[np.cosh(self.value)])
853
- 854 def tanh(self):
- 855 return derived_observable(lambda x, **kwargs: np.tanh(x[0]), [self], man_grad=[1 / np.cosh(self.value) ** 2])
+ 854 def cosh(self):
+ 855 return derived_observable(lambda x, **kwargs: np.cosh(x[0]), [self], man_grad=[np.sinh(self.value)])
856
- 857 def arcsinh(self):
- 858 return derived_observable(lambda x: anp.arcsinh(x[0]), [self])
+ 857 def tanh(self):
+ 858 return derived_observable(lambda x, **kwargs: np.tanh(x[0]), [self], man_grad=[1 / np.cosh(self.value) ** 2])
859
- 860 def arccosh(self):
- 861 return derived_observable(lambda x: anp.arccosh(x[0]), [self])
+ 860 def arcsinh(self):
+ 861 return derived_observable(lambda x: anp.arcsinh(x[0]), [self])
862
- 863 def arctanh(self):
- 864 return derived_observable(lambda x: anp.arctanh(x[0]), [self])
+ 863 def arccosh(self):
+ 864 return derived_observable(lambda x: anp.arccosh(x[0]), [self])
865
- 866
- 867class CObs:
- 868 """Class for a complex valued observable."""
- 869 __slots__ = ['_real', '_imag', 'tag']
- 870
- 871 def __init__(self, real, imag=0.0):
- 872 self._real = real
- 873 self._imag = imag
- 874 self.tag = None
- 875
- 876 @property
- 877 def real(self):
- 878 return self._real
- 879
- 880 @property
- 881 def imag(self):
- 882 return self._imag
- 883
- 884 def gamma_method(self, **kwargs):
- 885 """Executes the gamma_method for the real and the imaginary part."""
- 886 if isinstance(self.real, Obs):
- 887 self.real.gamma_method(**kwargs)
- 888 if isinstance(self.imag, Obs):
- 889 self.imag.gamma_method(**kwargs)
- 890
- 891 def is_zero(self):
- 892 """Checks whether both real and imaginary part are zero within machine precision."""
- 893 return self.real == 0.0 and self.imag == 0.0
- 894
- 895 def conjugate(self):
- 896 return CObs(self.real, -self.imag)
+ 866 def arctanh(self):
+ 867 return derived_observable(lambda x: anp.arctanh(x[0]), [self])
+ 868
+ 869
+ 870class CObs:
+ 871 """Class for a complex valued observable."""
+ 872 __slots__ = ['_real', '_imag', 'tag']
+ 873
+ 874 def __init__(self, real, imag=0.0):
+ 875 self._real = real
+ 876 self._imag = imag
+ 877 self.tag = None
+ 878
+ 879 @property
+ 880 def real(self):
+ 881 return self._real
+ 882
+ 883 @property
+ 884 def imag(self):
+ 885 return self._imag
+ 886
+ 887 def gamma_method(self, **kwargs):
+ 888 """Executes the gamma_method for the real and the imaginary part."""
+ 889 if isinstance(self.real, Obs):
+ 890 self.real.gamma_method(**kwargs)
+ 891 if isinstance(self.imag, Obs):
+ 892 self.imag.gamma_method(**kwargs)
+ 893
+ 894 def is_zero(self):
+ 895 """Checks whether both real and imaginary part are zero within machine precision."""
+ 896 return self.real == 0.0 and self.imag == 0.0
897
- 898 def __add__(self, other):
- 899 if isinstance(other, np.ndarray):
- 900 return other + self
- 901 elif hasattr(other, 'real') and hasattr(other, 'imag'):
- 902 return CObs(self.real + other.real,
- 903 self.imag + other.imag)
- 904 else:
- 905 return CObs(self.real + other, self.imag)
- 906
- 907 def __radd__(self, y):
- 908 return self + y
+ 898 def conjugate(self):
+ 899 return CObs(self.real, -self.imag)
+ 900
+ 901 def __add__(self, other):
+ 902 if isinstance(other, np.ndarray):
+ 903 return other + self
+ 904 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+ 905 return CObs(self.real + other.real,
+ 906 self.imag + other.imag)
+ 907 else:
+ 908 return CObs(self.real + other, self.imag)
909
- 910 def __sub__(self, other):
- 911 if isinstance(other, np.ndarray):
- 912 return -1 * (other - self)
- 913 elif hasattr(other, 'real') and hasattr(other, 'imag'):
- 914 return CObs(self.real - other.real, self.imag - other.imag)
- 915 else:
- 916 return CObs(self.real - other, self.imag)
- 917
- 918 def __rsub__(self, other):
- 919 return -1 * (self - other)
+ 910 def __radd__(self, y):
+ 911 return self + y
+ 912
+ 913 def __sub__(self, other):
+ 914 if isinstance(other, np.ndarray):
+ 915 return -1 * (other - self)
+ 916 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+ 917 return CObs(self.real - other.real, self.imag - other.imag)
+ 918 else:
+ 919 return CObs(self.real - other, self.imag)
920
- 921 def __mul__(self, other):
- 922 if isinstance(other, np.ndarray):
- 923 return other * self
- 924 elif hasattr(other, 'real') and hasattr(other, 'imag'):
- 925 if all(isinstance(i, Obs) for i in [self.real, self.imag, other.real, other.imag]):
- 926 return CObs(derived_observable(lambda x, **kwargs: x[0] * x[1] - x[2] * x[3],
- 927 [self.real, other.real, self.imag, other.imag],
- 928 man_grad=[other.real.value, self.real.value, -other.imag.value, -self.imag.value]),
- 929 derived_observable(lambda x, **kwargs: x[2] * x[1] + x[0] * x[3],
+ 921 def __rsub__(self, other):
+ 922 return -1 * (self - other)
+ 923
+ 924 def __mul__(self, other):
+ 925 if isinstance(other, np.ndarray):
+ 926 return other * self
+ 927 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+ 928 if all(isinstance(i, Obs) for i in [self.real, self.imag, other.real, other.imag]):
+ 929 return CObs(derived_observable(lambda x, **kwargs: x[0] * x[1] - x[2] * x[3],
930 [self.real, other.real, self.imag, other.imag],
- 931 man_grad=[other.imag.value, self.imag.value, other.real.value, self.real.value]))
- 932 elif getattr(other, 'imag', 0) != 0:
- 933 return CObs(self.real * other.real - self.imag * other.imag,
- 934 self.imag * other.real + self.real * other.imag)
- 935 else:
- 936 return CObs(self.real * other.real, self.imag * other.real)
- 937 else:
- 938 return CObs(self.real * other, self.imag * other)
- 939
- 940 def __rmul__(self, other):
- 941 return self * other
+ 931 man_grad=[other.real.value, self.real.value, -other.imag.value, -self.imag.value]),
+ 932 derived_observable(lambda x, **kwargs: x[2] * x[1] + x[0] * x[3],
+ 933 [self.real, other.real, self.imag, other.imag],
+ 934 man_grad=[other.imag.value, self.imag.value, other.real.value, self.real.value]))
+ 935 elif getattr(other, 'imag', 0) != 0:
+ 936 return CObs(self.real * other.real - self.imag * other.imag,
+ 937 self.imag * other.real + self.real * other.imag)
+ 938 else:
+ 939 return CObs(self.real * other.real, self.imag * other.real)
+ 940 else:
+ 941 return CObs(self.real * other, self.imag * other)
942
- 943 def __truediv__(self, other):
- 944 if isinstance(other, np.ndarray):
- 945 return 1 / (other / self)
- 946 elif hasattr(other, 'real') and hasattr(other, 'imag'):
- 947 r = other.real ** 2 + other.imag ** 2
- 948 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.imag * other.real - self.real * other.imag) / r)
- 949 else:
- 950 return CObs(self.real / other, self.imag / other)
- 951
- 952 def __rtruediv__(self, other):
- 953 r = self.real ** 2 + self.imag ** 2
- 954 if hasattr(other, 'real') and hasattr(other, 'imag'):
- 955 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.real * other.imag - self.imag * other.real) / r)
- 956 else:
- 957 return CObs(self.real * other / r, -self.imag * other / r)
- 958
- 959 def __abs__(self):
- 960 return np.sqrt(self.real**2 + self.imag**2)
+ 943 def __rmul__(self, other):
+ 944 return self * other
+ 945
+ 946 def __truediv__(self, other):
+ 947 if isinstance(other, np.ndarray):
+ 948 return 1 / (other / self)
+ 949 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+ 950 r = other.real ** 2 + other.imag ** 2
+ 951 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.imag * other.real - self.real * other.imag) / r)
+ 952 else:
+ 953 return CObs(self.real / other, self.imag / other)
+ 954
+ 955 def __rtruediv__(self, other):
+ 956 r = self.real ** 2 + self.imag ** 2
+ 957 if hasattr(other, 'real') and hasattr(other, 'imag'):
+ 958 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.real * other.imag - self.imag * other.real) / r)
+ 959 else:
+ 960 return CObs(self.real * other / r, -self.imag * other / r)
961
- 962 def __pos__(self):
- 963 return self
+ 962 def __abs__(self):
+ 963 return np.sqrt(self.real**2 + self.imag**2)
964
- 965 def __neg__(self):
- 966 return -1 * self
+ 965 def __pos__(self):
+ 966 return self
967
- 968 def __eq__(self, other):
- 969 return self.real == other.real and self.imag == other.imag
+ 968 def __neg__(self):
+ 969 return -1 * self
970
- 971 def __str__(self):
- 972 return '(' + str(self.real) + int(self.imag >= 0.0) * '+' + str(self.imag) + 'j)'
+ 971 def __eq__(self, other):
+ 972 return self.real == other.real and self.imag == other.imag
973
- 974 def __repr__(self):
- 975 return 'CObs[' + str(self) + ']'
+ 974 def __str__(self):
+ 975 return '(' + str(self.real) + int(self.imag >= 0.0) * '+' + str(self.imag) + 'j)'
976
- 977
- 978def _format_uncertainty(value, dvalue):
- 979 """Creates a string of a value and its error in paranthesis notation, e.g., 13.02(45)"""
- 980 if dvalue == 0.0:
- 981 return str(value)
- 982 fexp = np.floor(np.log10(dvalue))
- 983 if fexp < 0.0:
- 984 return '{:{form}}({:2.0f})'.format(value, dvalue * 10 ** (-fexp + 1), form='.' + str(-int(fexp) + 1) + 'f')
- 985 elif fexp == 0.0:
- 986 return '{:.1f}({:1.1f})'.format(value, dvalue)
- 987 else:
- 988 return '{:.0f}({:2.0f})'.format(value, dvalue)
- 989
- 990
- 991def _expand_deltas(deltas, idx, shape):
- 992 """Expand deltas defined on idx to a regular, contiguous range, where holes are filled by 0.
- 993 If idx is of type range, the deltas are not changed
- 994
- 995 Parameters
- 996 ----------
- 997 deltas : list
- 998 List of fluctuations
- 999 idx : list
-1000 List or range of configs on which the deltas are defined, has to be sorted in ascending order.
-1001 shape : int
-1002 Number of configs in idx.
-1003 """
-1004 if isinstance(idx, range):
-1005 return deltas
-1006 else:
-1007 ret = np.zeros(idx[-1] - idx[0] + 1)
-1008 for i in range(shape):
-1009 ret[idx[i] - idx[0]] = deltas[i]
-1010 return ret
-1011
-1012
-1013def _merge_idx(idl):
-1014 """Returns the union of all lists in idl as sorted list
+ 977 def __repr__(self):
+ 978 return 'CObs[' + str(self) + ']'
+ 979
+ 980
+ 981def _format_uncertainty(value, dvalue):
+ 982 """Creates a string of a value and its error in paranthesis notation, e.g., 13.02(45)"""
+ 983 if dvalue == 0.0:
+ 984 return str(value)
+ 985 fexp = np.floor(np.log10(dvalue))
+ 986 if fexp < 0.0:
+ 987 return '{:{form}}({:2.0f})'.format(value, dvalue * 10 ** (-fexp + 1), form='.' + str(-int(fexp) + 1) + 'f')
+ 988 elif fexp == 0.0:
+ 989 return '{:.1f}({:1.1f})'.format(value, dvalue)
+ 990 else:
+ 991 return '{:.0f}({:2.0f})'.format(value, dvalue)
+ 992
+ 993
+ 994def _expand_deltas(deltas, idx, shape):
+ 995 """Expand deltas defined on idx to a regular, contiguous range, where holes are filled by 0.
+ 996 If idx is of type range, the deltas are not changed
+ 997
+ 998 Parameters
+ 999 ----------
+1000 deltas : list
+1001 List of fluctuations
+1002 idx : list
+1003 List or range of configs on which the deltas are defined, has to be sorted in ascending order.
+1004 shape : int
+1005 Number of configs in idx.
+1006 """
+1007 if isinstance(idx, range):
+1008 return deltas
+1009 else:
+1010 ret = np.zeros(idx[-1] - idx[0] + 1)
+1011 for i in range(shape):
+1012 ret[idx[i] - idx[0]] = deltas[i]
+1013 return ret
+1014
1015
-1016 Parameters
-1017 ----------
-1018 idl : list
-1019 List of lists or ranges.
-1020 """
-1021
-1022 # Use groupby to efficiently check whether all elements of idl are identical
-1023 try:
-1024 g = groupby(idl)
-1025 if next(g, True) and not next(g, False):
-1026 return idl[0]
-1027 except Exception:
-1028 pass
-1029
-1030 if np.all([type(idx) is range for idx in idl]):
-1031 if len(set([idx[0] for idx in idl])) == 1:
-1032 idstart = min([idx.start for idx in idl])
-1033 idstop = max([idx.stop for idx in idl])
-1034 idstep = min([idx.step for idx in idl])
-1035 return range(idstart, idstop, idstep)
-1036
-1037 return sorted(set().union(*idl))
-1038
+1016def _merge_idx(idl):
+1017 """Returns the union of all lists in idl as sorted list
+1018
+1019 Parameters
+1020 ----------
+1021 idl : list
+1022 List of lists or ranges.
+1023 """
+1024
+1025 # Use groupby to efficiently check whether all elements of idl are identical
+1026 try:
+1027 g = groupby(idl)
+1028 if next(g, True) and not next(g, False):
+1029 return idl[0]
+1030 except Exception:
+1031 pass
+1032
+1033 if np.all([type(idx) is range for idx in idl]):
+1034 if len(set([idx[0] for idx in idl])) == 1:
+1035 idstart = min([idx.start for idx in idl])
+1036 idstop = max([idx.stop for idx in idl])
+1037 idstep = min([idx.step for idx in idl])
+1038 return range(idstart, idstop, idstep)
1039
-1040def _intersection_idx(idl):
-1041 """Returns the intersection of all lists in idl as sorted list
+1040 return sorted(set().union(*idl))
+1041
1042
-1043 Parameters
-1044 ----------
-1045 idl : list
-1046 List of lists or ranges.
-1047 """
-1048
-1049 def _lcm(*args):
-1050 """Returns the lowest common multiple of args.
+1043def _intersection_idx(idl):
+1044 """Returns the intersection of all lists in idl as sorted list
+1045
+1046 Parameters
+1047 ----------
+1048 idl : list
+1049 List of lists or ranges.
+1050 """
1051
-1052 From python 3.9 onwards the math library contains an lcm function."""
-1053 return reduce(lambda a, b: a * b // gcd(a, b), args)
+1052 def _lcm(*args):
+1053 """Returns the lowest common multiple of args.
1054
-1055 # Use groupby to efficiently check whether all elements of idl are identical
-1056 try:
-1057 g = groupby(idl)
-1058 if next(g, True) and not next(g, False):
-1059 return idl[0]
-1060 except Exception:
-1061 pass
-1062
-1063 if np.all([type(idx) is range for idx in idl]):
-1064 if len(set([idx[0] for idx in idl])) == 1:
-1065 idstart = max([idx.start for idx in idl])
-1066 idstop = min([idx.stop for idx in idl])
-1067 idstep = _lcm(*[idx.step for idx in idl])
-1068 return range(idstart, idstop, idstep)
-1069
-1070 return sorted(set.intersection(*[set(o) for o in idl]))
-1071
+1055 From python 3.9 onwards the math library contains an lcm function."""
+1056 return reduce(lambda a, b: a * b // gcd(a, b), args)
+1057
+1058 # Use groupby to efficiently check whether all elements of idl are identical
+1059 try:
+1060 g = groupby(idl)
+1061 if next(g, True) and not next(g, False):
+1062 return idl[0]
+1063 except Exception:
+1064 pass
+1065
+1066 if np.all([type(idx) is range for idx in idl]):
+1067 if len(set([idx[0] for idx in idl])) == 1:
+1068 idstart = max([idx.start for idx in idl])
+1069 idstop = min([idx.stop for idx in idl])
+1070 idstep = _lcm(*[idx.step for idx in idl])
+1071 return range(idstart, idstop, idstep)
1072
-1073def _expand_deltas_for_merge(deltas, idx, shape, new_idx):
-1074 """Expand deltas defined on idx to the list of configs that is defined by new_idx.
-1075 New, empty entries are filled by 0. If idx and new_idx are of type range, the smallest
-1076 common divisor of the step sizes is used as new step size.
-1077
-1078 Parameters
-1079 ----------
-1080 deltas : list
-1081 List of fluctuations
-1082 idx : list
-1083 List or range of configs on which the deltas are defined.
-1084 Has to be a subset of new_idx and has to be sorted in ascending order.
-1085 shape : list
-1086 Number of configs in idx.
-1087 new_idx : list
-1088 List of configs that defines the new range, has to be sorted in ascending order.
-1089 """
-1090
-1091 if type(idx) is range and type(new_idx) is range:
-1092 if idx == new_idx:
-1093 return deltas
-1094 ret = np.zeros(new_idx[-1] - new_idx[0] + 1)
-1095 for i in range(shape):
-1096 ret[idx[i] - new_idx[0]] = deltas[i]
-1097 return np.array([ret[new_idx[i] - new_idx[0]] for i in range(len(new_idx))])
-1098
-1099
-1100def _filter_zeroes(deltas, idx, eps=Obs.filter_eps):
-1101 """Filter out all configurations with vanishing fluctuation such that they do not
-1102 contribute to the error estimate anymore. Returns the new deltas and
-1103 idx according to the filtering.
-1104 A fluctuation is considered to be vanishing, if it is smaller than eps times
-1105 the mean of the absolute values of all deltas in one list.
-1106
-1107 Parameters
-1108 ----------
-1109 deltas : list
-1110 List of fluctuations
-1111 idx : list
-1112 List or ranges of configs on which the deltas are defined.
-1113 eps : float
-1114 Prefactor that enters the filter criterion.
-1115 """
-1116 new_deltas = []
-1117 new_idx = []
-1118 maxd = np.mean(np.fabs(deltas))
-1119 for i in range(len(deltas)):
-1120 if abs(deltas[i]) > eps * maxd:
-1121 new_deltas.append(deltas[i])
-1122 new_idx.append(idx[i])
-1123 if new_idx:
-1124 return np.array(new_deltas), new_idx
-1125 else:
-1126 return deltas, idx
-1127
-1128
-1129def derived_observable(func, data, array_mode=False, **kwargs):
-1130 """Construct a derived Obs according to func(data, **kwargs) using automatic differentiation.
+1073 return sorted(set.intersection(*[set(o) for o in idl]))
+1074
+1075
+1076def _expand_deltas_for_merge(deltas, idx, shape, new_idx):
+1077 """Expand deltas defined on idx to the list of configs that is defined by new_idx.
+1078 New, empty entries are filled by 0. If idx and new_idx are of type range, the smallest
+1079 common divisor of the step sizes is used as new step size.
+1080
+1081 Parameters
+1082 ----------
+1083 deltas : list
+1084 List of fluctuations
+1085 idx : list
+1086 List or range of configs on which the deltas are defined.
+1087 Has to be a subset of new_idx and has to be sorted in ascending order.
+1088 shape : list
+1089 Number of configs in idx.
+1090 new_idx : list
+1091 List of configs that defines the new range, has to be sorted in ascending order.
+1092 """
+1093
+1094 if type(idx) is range and type(new_idx) is range:
+1095 if idx == new_idx:
+1096 return deltas
+1097 ret = np.zeros(new_idx[-1] - new_idx[0] + 1)
+1098 for i in range(shape):
+1099 ret[idx[i] - new_idx[0]] = deltas[i]
+1100 return np.array([ret[new_idx[i] - new_idx[0]] for i in range(len(new_idx))])
+1101
+1102
+1103def _filter_zeroes(deltas, idx, eps=Obs.filter_eps):
+1104 """Filter out all configurations with vanishing fluctuation such that they do not
+1105 contribute to the error estimate anymore. Returns the new deltas and
+1106 idx according to the filtering.
+1107 A fluctuation is considered to be vanishing, if it is smaller than eps times
+1108 the mean of the absolute values of all deltas in one list.
+1109
+1110 Parameters
+1111 ----------
+1112 deltas : list
+1113 List of fluctuations
+1114 idx : list
+1115 List or ranges of configs on which the deltas are defined.
+1116 eps : float
+1117 Prefactor that enters the filter criterion.
+1118 """
+1119 new_deltas = []
+1120 new_idx = []
+1121 maxd = np.mean(np.fabs(deltas))
+1122 for i in range(len(deltas)):
+1123 if abs(deltas[i]) > eps * maxd:
+1124 new_deltas.append(deltas[i])
+1125 new_idx.append(idx[i])
+1126 if new_idx:
+1127 return np.array(new_deltas), new_idx
+1128 else:
+1129 return deltas, idx
+1130
1131
-1132 Parameters
-1133 ----------
-1134 func : object
-1135 arbitrary function of the form func(data, **kwargs). For the
-1136 automatic differentiation to work, all numpy functions have to have
-1137 the autograd wrapper (use 'import autograd.numpy as anp').
-1138 data : list
-1139 list of Obs, e.g. [obs1, obs2, obs3].
-1140 num_grad : bool
-1141 if True, numerical derivatives are used instead of autograd
-1142 (default False). To control the numerical differentiation the
-1143 kwargs of numdifftools.step_generators.MaxStepGenerator
-1144 can be used.
-1145 man_grad : list
-1146 manually supply a list or an array which contains the jacobian
-1147 of func. Use cautiously, supplying the wrong derivative will
-1148 not be intercepted.
-1149
-1150 Notes
-1151 -----
-1152 For simple mathematical operations it can be practical to use anonymous
-1153 functions. For the ratio of two observables one can e.g. use
-1154
-1155 new_obs = derived_observable(lambda x: x[0] / x[1], [obs1, obs2])
-1156 """
+1132def derived_observable(func, data, array_mode=False, **kwargs):
+1133 """Construct a derived Obs according to func(data, **kwargs) using automatic differentiation.
+1134
+1135 Parameters
+1136 ----------
+1137 func : object
+1138 arbitrary function of the form func(data, **kwargs). For the
+1139 automatic differentiation to work, all numpy functions have to have
+1140 the autograd wrapper (use 'import autograd.numpy as anp').
+1141 data : list
+1142 list of Obs, e.g. [obs1, obs2, obs3].
+1143 num_grad : bool
+1144 if True, numerical derivatives are used instead of autograd
+1145 (default False). To control the numerical differentiation the
+1146 kwargs of numdifftools.step_generators.MaxStepGenerator
+1147 can be used.
+1148 man_grad : list
+1149 manually supply a list or an array which contains the jacobian
+1150 of func. Use cautiously, supplying the wrong derivative will
+1151 not be intercepted.
+1152
+1153 Notes
+1154 -----
+1155 For simple mathematical operations it can be practical to use anonymous
+1156 functions. For the ratio of two observables one can e.g. use
1157
-1158 data = np.asarray(data)
-1159 raveled_data = data.ravel()
+1158 new_obs = derived_observable(lambda x: x[0] / x[1], [obs1, obs2])
+1159 """
1160
-1161 # Workaround for matrix operations containing non Obs data
-1162 if not all(isinstance(x, Obs) for x in raveled_data):
-1163 for i in range(len(raveled_data)):
-1164 if isinstance(raveled_data[i], (int, float)):
-1165 raveled_data[i] = cov_Obs(raveled_data[i], 0.0, "###dummy_covobs###")
-1166
-1167 allcov = {}
-1168 for o in raveled_data:
-1169 for name in o.cov_names:
-1170 if name in allcov:
-1171 if not np.allclose(allcov[name], o.covobs[name].cov):
-1172 raise Exception('Inconsistent covariance matrices for %s!' % (name))
-1173 else:
-1174 allcov[name] = o.covobs[name].cov
-1175
-1176 n_obs = len(raveled_data)
-1177 new_names = sorted(set([y for x in [o.names for o in raveled_data] for y in x]))
-1178 new_cov_names = sorted(set([y for x in [o.cov_names for o in raveled_data] for y in x]))
-1179 new_sample_names = sorted(set(new_names) - set(new_cov_names))
-1180
-1181 is_merged = {name: (len(list(filter(lambda o: o.is_merged.get(name, False) is True, raveled_data))) > 0) for name in new_sample_names}
-1182 reweighted = len(list(filter(lambda o: o.reweighted is True, raveled_data))) > 0
+1161 data = np.asarray(data)
+1162 raveled_data = data.ravel()
+1163
+1164 # Workaround for matrix operations containing non Obs data
+1165 if not all(isinstance(x, Obs) for x in raveled_data):
+1166 for i in range(len(raveled_data)):
+1167 if isinstance(raveled_data[i], (int, float)):
+1168 raveled_data[i] = cov_Obs(raveled_data[i], 0.0, "###dummy_covobs###")
+1169
+1170 allcov = {}
+1171 for o in raveled_data:
+1172 for name in o.cov_names:
+1173 if name in allcov:
+1174 if not np.allclose(allcov[name], o.covobs[name].cov):
+1175 raise Exception('Inconsistent covariance matrices for %s!' % (name))
+1176 else:
+1177 allcov[name] = o.covobs[name].cov
+1178
+1179 n_obs = len(raveled_data)
+1180 new_names = sorted(set([y for x in [o.names for o in raveled_data] for y in x]))
+1181 new_cov_names = sorted(set([y for x in [o.cov_names for o in raveled_data] for y in x]))
+1182 new_sample_names = sorted(set(new_names) - set(new_cov_names))
1183
-1184 if data.ndim == 1:
-1185 values = np.array([o.value for o in data])
-1186 else:
-1187 values = np.vectorize(lambda x: x.value)(data)
-1188
-1189 new_values = func(values, **kwargs)
-1190
-1191 multi = int(isinstance(new_values, np.ndarray))
-1192
-1193 new_r_values = {}
-1194 new_idl_d = {}
-1195 for name in new_sample_names:
-1196 idl = []
-1197 tmp_values = np.zeros(n_obs)
-1198 for i, item in enumerate(raveled_data):
-1199 tmp_values[i] = item.r_values.get(name, item.value)
-1200 tmp_idl = item.idl.get(name)
-1201 if tmp_idl is not None:
-1202 idl.append(tmp_idl)
-1203 if multi > 0:
-1204 tmp_values = np.array(tmp_values).reshape(data.shape)
-1205 new_r_values[name] = func(tmp_values, **kwargs)
-1206 new_idl_d[name] = _merge_idx(idl)
-1207 if not is_merged[name]:
-1208 is_merged[name] = (1 != len(set([len(idx) for idx in [*idl, new_idl_d[name]]])))
-1209
-1210 if 'man_grad' in kwargs:
-1211 deriv = np.asarray(kwargs.get('man_grad'))
-1212 if new_values.shape + data.shape != deriv.shape:
-1213 raise Exception('Manual derivative does not have correct shape.')
-1214 elif kwargs.get('num_grad') is True:
-1215 if multi > 0:
-1216 raise Exception('Multi mode currently not supported for numerical derivative')
-1217 options = {
-1218 'base_step': 0.1,
-1219 'step_ratio': 2.5}
-1220 for key in options.keys():
-1221 kwarg = kwargs.get(key)
-1222 if kwarg is not None:
-1223 options[key] = kwarg
-1224 tmp_df = nd.Gradient(func, order=4, **{k: v for k, v in options.items() if v is not None})(values, **kwargs)
-1225 if tmp_df.size == 1:
-1226 deriv = np.array([tmp_df.real])
-1227 else:
-1228 deriv = tmp_df.real
-1229 else:
-1230 deriv = jacobian(func)(values, **kwargs)
-1231
-1232 final_result = np.zeros(new_values.shape, dtype=object)
-1233
-1234 if array_mode is True:
-1235
-1236 class _Zero_grad():
-1237 def __init__(self, N):
-1238 self.grad = np.zeros((N, 1))
-1239
-1240 new_covobs_lengths = dict(set([y for x in [[(n, o.covobs[n].N) for n in o.cov_names] for o in raveled_data] for y in x]))
-1241 d_extracted = {}
-1242 g_extracted = {}
-1243 for name in new_sample_names:
-1244 d_extracted[name] = []
-1245 ens_length = len(new_idl_d[name])
-1246 for i_dat, dat in enumerate(data):
-1247 d_extracted[name].append(np.array([_expand_deltas_for_merge(o.deltas.get(name, np.zeros(ens_length)), o.idl.get(name, new_idl_d[name]), o.shape.get(name, ens_length), new_idl_d[name]) for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (ens_length, )))
-1248 for name in new_cov_names:
-1249 g_extracted[name] = []
-1250 zero_grad = _Zero_grad(new_covobs_lengths[name])
-1251 for i_dat, dat in enumerate(data):
-1252 g_extracted[name].append(np.array([o.covobs.get(name, zero_grad).grad for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (new_covobs_lengths[name], 1)))
-1253
-1254 for i_val, new_val in np.ndenumerate(new_values):
-1255 new_deltas = {}
-1256 new_grad = {}
-1257 if array_mode is True:
-1258 for name in new_sample_names:
-1259 ens_length = d_extracted[name][0].shape[-1]
-1260 new_deltas[name] = np.zeros(ens_length)
-1261 for i_dat, dat in enumerate(d_extracted[name]):
-1262 new_deltas[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
-1263 for name in new_cov_names:
-1264 new_grad[name] = 0
-1265 for i_dat, dat in enumerate(g_extracted[name]):
-1266 new_grad[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
-1267 else:
-1268 for j_obs, obs in np.ndenumerate(data):
-1269 for name in obs.names:
-1270 if name in obs.cov_names:
-1271 new_grad[name] = new_grad.get(name, 0) + deriv[i_val + j_obs] * obs.covobs[name].grad
-1272 else:
-1273 new_deltas[name] = new_deltas.get(name, 0) + deriv[i_val + j_obs] * _expand_deltas_for_merge(obs.deltas[name], obs.idl[name], obs.shape[name], new_idl_d[name])
-1274
-1275 new_covobs = {name: Covobs(0, allcov[name], name, grad=new_grad[name]) for name in new_grad}
-1276
-1277 if not set(new_covobs.keys()).isdisjoint(new_deltas.keys()):
-1278 raise Exception('The same name has been used for deltas and covobs!')
-1279 new_samples = []
-1280 new_means = []
-1281 new_idl = []
-1282 new_names_obs = []
-1283 for name in new_names:
-1284 if name not in new_covobs:
-1285 if is_merged[name]:
-1286 filtered_deltas, filtered_idl_d = _filter_zeroes(new_deltas[name], new_idl_d[name])
-1287 else:
-1288 filtered_deltas = new_deltas[name]
-1289 filtered_idl_d = new_idl_d[name]
-1290
-1291 new_samples.append(filtered_deltas)
-1292 new_idl.append(filtered_idl_d)
-1293 new_means.append(new_r_values[name][i_val])
-1294 new_names_obs.append(name)
-1295 final_result[i_val] = Obs(new_samples, new_names_obs, means=new_means, idl=new_idl)
-1296 for name in new_covobs:
-1297 final_result[i_val].names.append(name)
-1298 final_result[i_val]._covobs = new_covobs
-1299 final_result[i_val]._value = new_val
-1300 final_result[i_val].is_merged = is_merged
-1301 final_result[i_val].reweighted = reweighted
-1302
-1303 if multi == 0:
-1304 final_result = final_result.item()
+1184 is_merged = {name: (len(list(filter(lambda o: o.is_merged.get(name, False) is True, raveled_data))) > 0) for name in new_sample_names}
+1185 reweighted = len(list(filter(lambda o: o.reweighted is True, raveled_data))) > 0
+1186
+1187 if data.ndim == 1:
+1188 values = np.array([o.value for o in data])
+1189 else:
+1190 values = np.vectorize(lambda x: x.value)(data)
+1191
+1192 new_values = func(values, **kwargs)
+1193
+1194 multi = int(isinstance(new_values, np.ndarray))
+1195
+1196 new_r_values = {}
+1197 new_idl_d = {}
+1198 for name in new_sample_names:
+1199 idl = []
+1200 tmp_values = np.zeros(n_obs)
+1201 for i, item in enumerate(raveled_data):
+1202 tmp_values[i] = item.r_values.get(name, item.value)
+1203 tmp_idl = item.idl.get(name)
+1204 if tmp_idl is not None:
+1205 idl.append(tmp_idl)
+1206 if multi > 0:
+1207 tmp_values = np.array(tmp_values).reshape(data.shape)
+1208 new_r_values[name] = func(tmp_values, **kwargs)
+1209 new_idl_d[name] = _merge_idx(idl)
+1210 if not is_merged[name]:
+1211 is_merged[name] = (1 != len(set([len(idx) for idx in [*idl, new_idl_d[name]]])))
+1212
+1213 if 'man_grad' in kwargs:
+1214 deriv = np.asarray(kwargs.get('man_grad'))
+1215 if new_values.shape + data.shape != deriv.shape:
+1216 raise Exception('Manual derivative does not have correct shape.')
+1217 elif kwargs.get('num_grad') is True:
+1218 if multi > 0:
+1219 raise Exception('Multi mode currently not supported for numerical derivative')
+1220 options = {
+1221 'base_step': 0.1,
+1222 'step_ratio': 2.5}
+1223 for key in options.keys():
+1224 kwarg = kwargs.get(key)
+1225 if kwarg is not None:
+1226 options[key] = kwarg
+1227 tmp_df = nd.Gradient(func, order=4, **{k: v for k, v in options.items() if v is not None})(values, **kwargs)
+1228 if tmp_df.size == 1:
+1229 deriv = np.array([tmp_df.real])
+1230 else:
+1231 deriv = tmp_df.real
+1232 else:
+1233 deriv = jacobian(func)(values, **kwargs)
+1234
+1235 final_result = np.zeros(new_values.shape, dtype=object)
+1236
+1237 if array_mode is True:
+1238
+1239 class _Zero_grad():
+1240 def __init__(self, N):
+1241 self.grad = np.zeros((N, 1))
+1242
+1243 new_covobs_lengths = dict(set([y for x in [[(n, o.covobs[n].N) for n in o.cov_names] for o in raveled_data] for y in x]))
+1244 d_extracted = {}
+1245 g_extracted = {}
+1246 for name in new_sample_names:
+1247 d_extracted[name] = []
+1248 ens_length = len(new_idl_d[name])
+1249 for i_dat, dat in enumerate(data):
+1250 d_extracted[name].append(np.array([_expand_deltas_for_merge(o.deltas.get(name, np.zeros(ens_length)), o.idl.get(name, new_idl_d[name]), o.shape.get(name, ens_length), new_idl_d[name]) for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (ens_length, )))
+1251 for name in new_cov_names:
+1252 g_extracted[name] = []
+1253 zero_grad = _Zero_grad(new_covobs_lengths[name])
+1254 for i_dat, dat in enumerate(data):
+1255 g_extracted[name].append(np.array([o.covobs.get(name, zero_grad).grad for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (new_covobs_lengths[name], 1)))
+1256
+1257 for i_val, new_val in np.ndenumerate(new_values):
+1258 new_deltas = {}
+1259 new_grad = {}
+1260 if array_mode is True:
+1261 for name in new_sample_names:
+1262 ens_length = d_extracted[name][0].shape[-1]
+1263 new_deltas[name] = np.zeros(ens_length)
+1264 for i_dat, dat in enumerate(d_extracted[name]):
+1265 new_deltas[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
+1266 for name in new_cov_names:
+1267 new_grad[name] = 0
+1268 for i_dat, dat in enumerate(g_extracted[name]):
+1269 new_grad[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
+1270 else:
+1271 for j_obs, obs in np.ndenumerate(data):
+1272 for name in obs.names:
+1273 if name in obs.cov_names:
+1274 new_grad[name] = new_grad.get(name, 0) + deriv[i_val + j_obs] * obs.covobs[name].grad
+1275 else:
+1276 new_deltas[name] = new_deltas.get(name, 0) + deriv[i_val + j_obs] * _expand_deltas_for_merge(obs.deltas[name], obs.idl[name], obs.shape[name], new_idl_d[name])
+1277
+1278 new_covobs = {name: Covobs(0, allcov[name], name, grad=new_grad[name]) for name in new_grad}
+1279
+1280 if not set(new_covobs.keys()).isdisjoint(new_deltas.keys()):
+1281 raise Exception('The same name has been used for deltas and covobs!')
+1282 new_samples = []
+1283 new_means = []
+1284 new_idl = []
+1285 new_names_obs = []
+1286 for name in new_names:
+1287 if name not in new_covobs:
+1288 if is_merged[name]:
+1289 filtered_deltas, filtered_idl_d = _filter_zeroes(new_deltas[name], new_idl_d[name])
+1290 else:
+1291 filtered_deltas = new_deltas[name]
+1292 filtered_idl_d = new_idl_d[name]
+1293
+1294 new_samples.append(filtered_deltas)
+1295 new_idl.append(filtered_idl_d)
+1296 new_means.append(new_r_values[name][i_val])
+1297 new_names_obs.append(name)
+1298 final_result[i_val] = Obs(new_samples, new_names_obs, means=new_means, idl=new_idl)
+1299 for name in new_covobs:
+1300 final_result[i_val].names.append(name)
+1301 final_result[i_val]._covobs = new_covobs
+1302 final_result[i_val]._value = new_val
+1303 final_result[i_val].is_merged = is_merged
+1304 final_result[i_val].reweighted = reweighted
1305
-1306 return final_result
-1307
+1306 if multi == 0:
+1307 final_result = final_result.item()
1308
-1309def _reduce_deltas(deltas, idx_old, idx_new):
-1310 """Extract deltas defined on idx_old on all configs of idx_new.
+1309 return final_result
+1310
1311
-1312 Assumes, that idx_old and idx_new are correctly defined idl, i.e., they
-1313 are ordered in an ascending order.
+1312def _reduce_deltas(deltas, idx_old, idx_new):
+1313 """Extract deltas defined on idx_old on all configs of idx_new.
1314
-1315 Parameters
-1316 ----------
-1317 deltas : list
-1318 List of fluctuations
-1319 idx_old : list
-1320 List or range of configs on which the deltas are defined
-1321 idx_new : list
-1322 List of configs for which we want to extract the deltas.
-1323 Has to be a subset of idx_old.
-1324 """
-1325 if not len(deltas) == len(idx_old):
-1326 raise Exception('Length of deltas and idx_old have to be the same: %d != %d' % (len(deltas), len(idx_old)))
-1327 if type(idx_old) is range and type(idx_new) is range:
-1328 if idx_old == idx_new:
-1329 return deltas
-1330 # Use groupby to efficiently check whether all elements of idx_old and idx_new are identical
-1331 try:
-1332 g = groupby([idx_old, idx_new])
-1333 if next(g, True) and not next(g, False):
-1334 return deltas
-1335 except Exception:
-1336 pass
-1337 indices = np.intersect1d(idx_old, idx_new, assume_unique=True, return_indices=True)[1]
-1338 if len(indices) < len(idx_new):
-1339 raise Exception('Error in _reduce_deltas: Config of idx_new not in idx_old')
-1340 return np.array(deltas)[indices]
-1341
-1342
-1343def reweight(weight, obs, **kwargs):
-1344 """Reweight a list of observables.
+1315 Assumes, that idx_old and idx_new are correctly defined idl, i.e., they
+1316 are ordered in an ascending order.
+1317
+1318 Parameters
+1319 ----------
+1320 deltas : list
+1321 List of fluctuations
+1322 idx_old : list
+1323 List or range of configs on which the deltas are defined
+1324 idx_new : list
+1325 List of configs for which we want to extract the deltas.
+1326 Has to be a subset of idx_old.
+1327 """
+1328 if not len(deltas) == len(idx_old):
+1329 raise Exception('Length of deltas and idx_old have to be the same: %d != %d' % (len(deltas), len(idx_old)))
+1330 if type(idx_old) is range and type(idx_new) is range:
+1331 if idx_old == idx_new:
+1332 return deltas
+1333 # Use groupby to efficiently check whether all elements of idx_old and idx_new are identical
+1334 try:
+1335 g = groupby([idx_old, idx_new])
+1336 if next(g, True) and not next(g, False):
+1337 return deltas
+1338 except Exception:
+1339 pass
+1340 indices = np.intersect1d(idx_old, idx_new, assume_unique=True, return_indices=True)[1]
+1341 if len(indices) < len(idx_new):
+1342 raise Exception('Error in _reduce_deltas: Config of idx_new not in idx_old')
+1343 return np.array(deltas)[indices]
+1344
1345
-1346 Parameters
-1347 ----------
-1348 weight : Obs
-1349 Reweighting factor. An Observable that has to be defined on a superset of the
-1350 configurations in obs[i].idl for all i.
-1351 obs : list
-1352 list of Obs, e.g. [obs1, obs2, obs3].
-1353 all_configs : bool
-1354 if True, the reweighted observables are normalized by the average of
-1355 the reweighting factor on all configurations in weight.idl and not
-1356 on the configurations in obs[i].idl. Default False.
-1357 """
-1358 result = []
-1359 for i in range(len(obs)):
-1360 if len(obs[i].cov_names):
-1361 raise Exception('Error: Not possible to reweight an Obs that contains covobs!')
-1362 if not set(obs[i].names).issubset(weight.names):
-1363 raise Exception('Error: Ensembles do not fit')
-1364 for name in obs[i].names:
-1365 if not set(obs[i].idl[name]).issubset(weight.idl[name]):
-1366 raise Exception('obs[%d] has to be defined on a subset of the configs in weight.idl[%s]!' % (i, name))
-1367 new_samples = []
-1368 w_deltas = {}
-1369 for name in sorted(obs[i].names):
-1370 w_deltas[name] = _reduce_deltas(weight.deltas[name], weight.idl[name], obs[i].idl[name])
-1371 new_samples.append((w_deltas[name] + weight.r_values[name]) * (obs[i].deltas[name] + obs[i].r_values[name]))
-1372 tmp_obs = Obs(new_samples, sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
-1373
-1374 if kwargs.get('all_configs'):
-1375 new_weight = weight
-1376 else:
-1377 new_weight = Obs([w_deltas[name] + weight.r_values[name] for name in sorted(obs[i].names)], sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
-1378
-1379 result.append(tmp_obs / new_weight)
-1380 result[-1].reweighted = True
-1381 result[-1].is_merged = obs[i].is_merged
-1382
-1383 return result
-1384
+1346def reweight(weight, obs, **kwargs):
+1347 """Reweight a list of observables.
+1348
+1349 Parameters
+1350 ----------
+1351 weight : Obs
+1352 Reweighting factor. An Observable that has to be defined on a superset of the
+1353 configurations in obs[i].idl for all i.
+1354 obs : list
+1355 list of Obs, e.g. [obs1, obs2, obs3].
+1356 all_configs : bool
+1357 if True, the reweighted observables are normalized by the average of
+1358 the reweighting factor on all configurations in weight.idl and not
+1359 on the configurations in obs[i].idl. Default False.
+1360 """
+1361 result = []
+1362 for i in range(len(obs)):
+1363 if len(obs[i].cov_names):
+1364 raise Exception('Error: Not possible to reweight an Obs that contains covobs!')
+1365 if not set(obs[i].names).issubset(weight.names):
+1366 raise Exception('Error: Ensembles do not fit')
+1367 for name in obs[i].names:
+1368 if not set(obs[i].idl[name]).issubset(weight.idl[name]):
+1369 raise Exception('obs[%d] has to be defined on a subset of the configs in weight.idl[%s]!' % (i, name))
+1370 new_samples = []
+1371 w_deltas = {}
+1372 for name in sorted(obs[i].names):
+1373 w_deltas[name] = _reduce_deltas(weight.deltas[name], weight.idl[name], obs[i].idl[name])
+1374 new_samples.append((w_deltas[name] + weight.r_values[name]) * (obs[i].deltas[name] + obs[i].r_values[name]))
+1375 tmp_obs = Obs(new_samples, sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
+1376
+1377 if kwargs.get('all_configs'):
+1378 new_weight = weight
+1379 else:
+1380 new_weight = Obs([w_deltas[name] + weight.r_values[name] for name in sorted(obs[i].names)], sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
+1381
+1382 result.append(tmp_obs / new_weight)
+1383 result[-1].reweighted = True
+1384 result[-1].is_merged = obs[i].is_merged
1385
-1386def correlate(obs_a, obs_b):
-1387 """Correlate two observables.
+1386 return result
+1387
1388
-1389 Parameters
-1390 ----------
-1391 obs_a : Obs
-1392 First observable
-1393 obs_b : Obs
-1394 Second observable
-1395
-1396 Notes
-1397 -----
-1398 Keep in mind to only correlate primary observables which have not been reweighted
-1399 yet. The reweighting has to be applied after correlating the observables.
-1400 Currently only works if ensembles are identical (this is not strictly necessary).
-1401 """
-1402
-1403 if sorted(obs_a.names) != sorted(obs_b.names):
-1404 raise Exception(f"Ensembles do not fit {set(sorted(obs_a.names)) ^ set(sorted(obs_b.names))}")
-1405 if len(obs_a.cov_names) or len(obs_b.cov_names):
-1406 raise Exception('Error: Not possible to correlate Obs that contain covobs!')
-1407 for name in obs_a.names:
-1408 if obs_a.shape[name] != obs_b.shape[name]:
-1409 raise Exception('Shapes of ensemble', name, 'do not fit')
-1410 if obs_a.idl[name] != obs_b.idl[name]:
-1411 raise Exception('idl of ensemble', name, 'do not fit')
-1412
-1413 if obs_a.reweighted is True:
-1414 warnings.warn("The first observable is already reweighted.", RuntimeWarning)
-1415 if obs_b.reweighted is True:
-1416 warnings.warn("The second observable is already reweighted.", RuntimeWarning)
-1417
-1418 new_samples = []
-1419 new_idl = []
-1420 for name in sorted(obs_a.names):
-1421 new_samples.append((obs_a.deltas[name] + obs_a.r_values[name]) * (obs_b.deltas[name] + obs_b.r_values[name]))
-1422 new_idl.append(obs_a.idl[name])
-1423
-1424 o = Obs(new_samples, sorted(obs_a.names), idl=new_idl)
-1425 o.is_merged = {name: (obs_a.is_merged.get(name, False) or obs_b.is_merged.get(name, False)) for name in o.names}
-1426 o.reweighted = obs_a.reweighted or obs_b.reweighted
-1427 return o
-1428
-1429
-1430def covariance(obs, visualize=False, correlation=False, smooth=None, **kwargs):
-1431 r'''Calculates the error covariance matrix of a set of observables.
+1389def correlate(obs_a, obs_b):
+1390 """Correlate two observables.
+1391
+1392 Parameters
+1393 ----------
+1394 obs_a : Obs
+1395 First observable
+1396 obs_b : Obs
+1397 Second observable
+1398
+1399 Notes
+1400 -----
+1401 Keep in mind to only correlate primary observables which have not been reweighted
+1402 yet. The reweighting has to be applied after correlating the observables.
+1403 Currently only works if ensembles are identical (this is not strictly necessary).
+1404 """
+1405
+1406 if sorted(obs_a.names) != sorted(obs_b.names):
+1407 raise Exception(f"Ensembles do not fit {set(sorted(obs_a.names)) ^ set(sorted(obs_b.names))}")
+1408 if len(obs_a.cov_names) or len(obs_b.cov_names):
+1409 raise Exception('Error: Not possible to correlate Obs that contain covobs!')
+1410 for name in obs_a.names:
+1411 if obs_a.shape[name] != obs_b.shape[name]:
+1412 raise Exception('Shapes of ensemble', name, 'do not fit')
+1413 if obs_a.idl[name] != obs_b.idl[name]:
+1414 raise Exception('idl of ensemble', name, 'do not fit')
+1415
+1416 if obs_a.reweighted is True:
+1417 warnings.warn("The first observable is already reweighted.", RuntimeWarning)
+1418 if obs_b.reweighted is True:
+1419 warnings.warn("The second observable is already reweighted.", RuntimeWarning)
+1420
+1421 new_samples = []
+1422 new_idl = []
+1423 for name in sorted(obs_a.names):
+1424 new_samples.append((obs_a.deltas[name] + obs_a.r_values[name]) * (obs_b.deltas[name] + obs_b.r_values[name]))
+1425 new_idl.append(obs_a.idl[name])
+1426
+1427 o = Obs(new_samples, sorted(obs_a.names), idl=new_idl)
+1428 o.is_merged = {name: (obs_a.is_merged.get(name, False) or obs_b.is_merged.get(name, False)) for name in o.names}
+1429 o.reweighted = obs_a.reweighted or obs_b.reweighted
+1430 return o
+1431
1432
-1433 WARNING: This function should be used with care, especially for observables with support on multiple
-1434 ensembles with differing autocorrelations. See the notes below for details.
+1433def covariance(obs, visualize=False, correlation=False, smooth=None, **kwargs):
+1434 r'''Calculates the error covariance matrix of a set of observables.
1435
-1436 The gamma method has to be applied first to all observables.
-1437
-1438 Parameters
-1439 ----------
-1440 obs : list or numpy.ndarray
-1441 List or one dimensional array of Obs
-1442 visualize : bool
-1443 If True plots the corresponding normalized correlation matrix (default False).
-1444 correlation : bool
-1445 If True the correlation matrix instead of the error covariance matrix is returned (default False).
-1446 smooth : None or int
-1447 If smooth is an integer 'E' between 2 and the dimension of the matrix minus 1 the eigenvalue
-1448 smoothing procedure of hep-lat/9412087 is applied to the correlation matrix which leaves the
-1449 largest E eigenvalues essentially unchanged and smoothes the smaller eigenvalues to avoid extremely
-1450 small ones.
-1451
-1452 Notes
-1453 -----
-1454 The error covariance is defined such that it agrees with the squared standard error for two identical observables
-1455 $$\operatorname{cov}(a,a)=\sum_{s=1}^N\delta_a^s\delta_a^s/N^2=\Gamma_{aa}(0)/N=\operatorname{var}(a)/N=\sigma_a^2$$
-1456 in the absence of autocorrelation.
-1457 The error covariance is estimated by calculating the correlation matrix assuming no autocorrelation and then rescaling the correlation matrix by the full errors including the previous gamma method estimate for the autocorrelation of the observables. The covariance at windowsize 0 is guaranteed to be positive semi-definite
-1458 $$\sum_{i,j}v_i\Gamma_{ij}(0)v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i,j}v_i\delta_i^s\delta_j^s v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i}|v_i\delta_i^s|^2\geq 0\,,$$ for every $v\in\mathbb{R}^M$, while such an identity does not hold for larger windows/lags.
-1459 For observables defined on a single ensemble our approximation is equivalent to assuming that the integrated autocorrelation time of an off-diagonal element is equal to the geometric mean of the integrated autocorrelation times of the corresponding diagonal elements.
-1460 $$\tau_{\mathrm{int}, ij}=\sqrt{\tau_{\mathrm{int}, i}\times \tau_{\mathrm{int}, j}}$$
-1461 This construction ensures that the estimated covariance matrix is positive semi-definite (up to numerical rounding errors).
-1462 '''
-1463
-1464 length = len(obs)
-1465
-1466 max_samples = np.max([o.N for o in obs])
-1467 if max_samples <= length and not [item for sublist in [o.cov_names for o in obs] for item in sublist]:
-1468 warnings.warn(f"The dimension of the covariance matrix ({length}) is larger or equal to the number of samples ({max_samples}). This will result in a rank deficient matrix.", RuntimeWarning)
-1469
-1470 cov = np.zeros((length, length))
-1471 for i in range(length):
-1472 for j in range(i, length):
-1473 cov[i, j] = _covariance_element(obs[i], obs[j])
-1474 cov = cov + cov.T - np.diag(np.diag(cov))
-1475
-1476 corr = np.diag(1 / np.sqrt(np.diag(cov))) @ cov @ np.diag(1 / np.sqrt(np.diag(cov)))
-1477
-1478 if isinstance(smooth, int):
-1479 corr = _smooth_eigenvalues(corr, smooth)
+1436 WARNING: This function should be used with care, especially for observables with support on multiple
+1437 ensembles with differing autocorrelations. See the notes below for details.
+1438
+1439 The gamma method has to be applied first to all observables.
+1440
+1441 Parameters
+1442 ----------
+1443 obs : list or numpy.ndarray
+1444 List or one dimensional array of Obs
+1445 visualize : bool
+1446 If True plots the corresponding normalized correlation matrix (default False).
+1447 correlation : bool
+1448 If True the correlation matrix instead of the error covariance matrix is returned (default False).
+1449 smooth : None or int
+1450 If smooth is an integer 'E' between 2 and the dimension of the matrix minus 1 the eigenvalue
+1451 smoothing procedure of hep-lat/9412087 is applied to the correlation matrix which leaves the
+1452 largest E eigenvalues essentially unchanged and smoothes the smaller eigenvalues to avoid extremely
+1453 small ones.
+1454
+1455 Notes
+1456 -----
+1457 The error covariance is defined such that it agrees with the squared standard error for two identical observables
+1458 $$\operatorname{cov}(a,a)=\sum_{s=1}^N\delta_a^s\delta_a^s/N^2=\Gamma_{aa}(0)/N=\operatorname{var}(a)/N=\sigma_a^2$$
+1459 in the absence of autocorrelation.
+1460 The error covariance is estimated by calculating the correlation matrix assuming no autocorrelation and then rescaling the correlation matrix by the full errors including the previous gamma method estimate for the autocorrelation of the observables. The covariance at windowsize 0 is guaranteed to be positive semi-definite
+1461 $$\sum_{i,j}v_i\Gamma_{ij}(0)v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i,j}v_i\delta_i^s\delta_j^s v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i}|v_i\delta_i^s|^2\geq 0\,,$$ for every $v\in\mathbb{R}^M$, while such an identity does not hold for larger windows/lags.
+1462 For observables defined on a single ensemble our approximation is equivalent to assuming that the integrated autocorrelation time of an off-diagonal element is equal to the geometric mean of the integrated autocorrelation times of the corresponding diagonal elements.
+1463 $$\tau_{\mathrm{int}, ij}=\sqrt{\tau_{\mathrm{int}, i}\times \tau_{\mathrm{int}, j}}$$
+1464 This construction ensures that the estimated covariance matrix is positive semi-definite (up to numerical rounding errors).
+1465 '''
+1466
+1467 length = len(obs)
+1468
+1469 max_samples = np.max([o.N for o in obs])
+1470 if max_samples <= length and not [item for sublist in [o.cov_names for o in obs] for item in sublist]:
+1471 warnings.warn(f"The dimension of the covariance matrix ({length}) is larger or equal to the number of samples ({max_samples}). This will result in a rank deficient matrix.", RuntimeWarning)
+1472
+1473 cov = np.zeros((length, length))
+1474 for i in range(length):
+1475 for j in range(i, length):
+1476 cov[i, j] = _covariance_element(obs[i], obs[j])
+1477 cov = cov + cov.T - np.diag(np.diag(cov))
+1478
+1479 corr = np.diag(1 / np.sqrt(np.diag(cov))) @ cov @ np.diag(1 / np.sqrt(np.diag(cov)))
1480
-1481 if visualize:
-1482 plt.matshow(corr, vmin=-1, vmax=1)
-1483 plt.set_cmap('RdBu')
-1484 plt.colorbar()
-1485 plt.draw()
-1486
-1487 if correlation is True:
-1488 return corr
+1481 if isinstance(smooth, int):
+1482 corr = _smooth_eigenvalues(corr, smooth)
+1483
+1484 if visualize:
+1485 plt.matshow(corr, vmin=-1, vmax=1)
+1486 plt.set_cmap('RdBu')
+1487 plt.colorbar()
+1488 plt.draw()
1489
-1490 errors = [o.dvalue for o in obs]
-1491 cov = np.diag(errors) @ corr @ np.diag(errors)
+1490 if correlation is True:
+1491 return corr
1492
-1493 eigenvalues = np.linalg.eigh(cov)[0]
-1494 if not np.all(eigenvalues >= 0):
-1495 warnings.warn("Covariance matrix is not positive semi-definite (Eigenvalues: " + str(eigenvalues) + ")", RuntimeWarning)
-1496
-1497 return cov
-1498
+1493 errors = [o.dvalue for o in obs]
+1494 cov = np.diag(errors) @ corr @ np.diag(errors)
+1495
+1496 eigenvalues = np.linalg.eigh(cov)[0]
+1497 if not np.all(eigenvalues >= 0):
+1498 warnings.warn("Covariance matrix is not positive semi-definite (Eigenvalues: " + str(eigenvalues) + ")", RuntimeWarning)
1499
-1500def _smooth_eigenvalues(corr, E):
-1501 """Eigenvalue smoothing as described in hep-lat/9412087
+1500 return cov
+1501
1502
-1503 corr : np.ndarray
-1504 correlation matrix
-1505 E : integer
-1506 Number of eigenvalues to be left substantially unchanged
-1507 """
-1508 if not (2 < E < corr.shape[0] - 1):
-1509 raise Exception(f"'E' has to be between 2 and the dimension of the correlation matrix minus 1 ({corr.shape[0] - 1}).")
-1510 vals, vec = np.linalg.eigh(corr)
-1511 lambda_min = np.mean(vals[:-E])
-1512 vals[vals < lambda_min] = lambda_min
-1513 vals /= np.mean(vals)
-1514 return vec @ np.diag(vals) @ vec.T
-1515
-1516
-1517def _covariance_element(obs1, obs2):
-1518 """Estimates the covariance of two Obs objects, neglecting autocorrelations."""
+1503def _smooth_eigenvalues(corr, E):
+1504 """Eigenvalue smoothing as described in hep-lat/9412087
+1505
+1506 corr : np.ndarray
+1507 correlation matrix
+1508 E : integer
+1509 Number of eigenvalues to be left substantially unchanged
+1510 """
+1511 if not (2 < E < corr.shape[0] - 1):
+1512 raise Exception(f"'E' has to be between 2 and the dimension of the correlation matrix minus 1 ({corr.shape[0] - 1}).")
+1513 vals, vec = np.linalg.eigh(corr)
+1514 lambda_min = np.mean(vals[:-E])
+1515 vals[vals < lambda_min] = lambda_min
+1516 vals /= np.mean(vals)
+1517 return vec @ np.diag(vals) @ vec.T
+1518
1519
-1520 def calc_gamma(deltas1, deltas2, idx1, idx2, new_idx):
-1521 deltas1 = _reduce_deltas(deltas1, idx1, new_idx)
-1522 deltas2 = _reduce_deltas(deltas2, idx2, new_idx)
-1523 return np.sum(deltas1 * deltas2)
-1524
-1525 if set(obs1.names).isdisjoint(set(obs2.names)):
-1526 return 0.0
+1520def _covariance_element(obs1, obs2):
+1521 """Estimates the covariance of two Obs objects, neglecting autocorrelations."""
+1522
+1523 def calc_gamma(deltas1, deltas2, idx1, idx2, new_idx):
+1524 deltas1 = _reduce_deltas(deltas1, idx1, new_idx)
+1525 deltas2 = _reduce_deltas(deltas2, idx2, new_idx)
+1526 return np.sum(deltas1 * deltas2)
1527
-1528 if not hasattr(obs1, 'e_dvalue') or not hasattr(obs2, 'e_dvalue'):
-1529 raise Exception('The gamma method has to be applied to both Obs first.')
+1528 if set(obs1.names).isdisjoint(set(obs2.names)):
+1529 return 0.0
1530
-1531 dvalue = 0.0
-1532
-1533 for e_name in obs1.mc_names:
-1534
-1535 if e_name not in obs2.mc_names:
-1536 continue
+1531 if not hasattr(obs1, 'e_dvalue') or not hasattr(obs2, 'e_dvalue'):
+1532 raise Exception('The gamma method has to be applied to both Obs first.')
+1533
+1534 dvalue = 0.0
+1535
+1536 for e_name in obs1.mc_names:
1537
-1538 idl_d = {}
-1539 for r_name in obs1.e_content[e_name]:
-1540 if r_name not in obs2.e_content[e_name]:
-1541 continue
-1542 idl_d[r_name] = _intersection_idx([obs1.idl[r_name], obs2.idl[r_name]])
-1543
-1544 gamma = 0.0
-1545
-1546 for r_name in obs1.e_content[e_name]:
-1547 if r_name not in obs2.e_content[e_name]:
-1548 continue
-1549 if len(idl_d[r_name]) == 0:
-1550 continue
-1551 gamma += calc_gamma(obs1.deltas[r_name], obs2.deltas[r_name], obs1.idl[r_name], obs2.idl[r_name], idl_d[r_name])
-1552
-1553 if gamma == 0.0:
-1554 continue
+1538 if e_name not in obs2.mc_names:
+1539 continue
+1540
+1541 idl_d = {}
+1542 for r_name in obs1.e_content[e_name]:
+1543 if r_name not in obs2.e_content[e_name]:
+1544 continue
+1545 idl_d[r_name] = _intersection_idx([obs1.idl[r_name], obs2.idl[r_name]])
+1546
+1547 gamma = 0.0
+1548
+1549 for r_name in obs1.e_content[e_name]:
+1550 if r_name not in obs2.e_content[e_name]:
+1551 continue
+1552 if len(idl_d[r_name]) == 0:
+1553 continue
+1554 gamma += calc_gamma(obs1.deltas[r_name], obs2.deltas[r_name], obs1.idl[r_name], obs2.idl[r_name], idl_d[r_name])
1555
-1556 gamma_div = 0.0
-1557 for r_name in obs1.e_content[e_name]:
-1558 if r_name not in obs2.e_content[e_name]:
-1559 continue
-1560 if len(idl_d[r_name]) == 0:
-1561 continue
-1562 gamma_div += np.sqrt(calc_gamma(obs1.deltas[r_name], obs1.deltas[r_name], obs1.idl[r_name], obs1.idl[r_name], idl_d[r_name]) * calc_gamma(obs2.deltas[r_name], obs2.deltas[r_name], obs2.idl[r_name], obs2.idl[r_name], idl_d[r_name]))
-1563 gamma /= gamma_div
-1564
-1565 dvalue += gamma
-1566
-1567 for e_name in obs1.cov_names:
-1568
-1569 if e_name not in obs2.cov_names:
-1570 continue
+1556 if gamma == 0.0:
+1557 continue
+1558
+1559 gamma_div = 0.0
+1560 for r_name in obs1.e_content[e_name]:
+1561 if r_name not in obs2.e_content[e_name]:
+1562 continue
+1563 if len(idl_d[r_name]) == 0:
+1564 continue
+1565 gamma_div += np.sqrt(calc_gamma(obs1.deltas[r_name], obs1.deltas[r_name], obs1.idl[r_name], obs1.idl[r_name], idl_d[r_name]) * calc_gamma(obs2.deltas[r_name], obs2.deltas[r_name], obs2.idl[r_name], obs2.idl[r_name], idl_d[r_name]))
+1566 gamma /= gamma_div
+1567
+1568 dvalue += gamma
+1569
+1570 for e_name in obs1.cov_names:
1571
-1572 dvalue += float(np.dot(np.transpose(obs1.covobs[e_name].grad), np.dot(obs1.covobs[e_name].cov, obs2.covobs[e_name].grad)))
-1573
-1574 return dvalue
-1575
+1572 if e_name not in obs2.cov_names:
+1573 continue
+1574
+1575 dvalue += float(np.dot(np.transpose(obs1.covobs[e_name].grad), np.dot(obs1.covobs[e_name].cov, obs2.covobs[e_name].grad)))
1576
-1577def import_jackknife(jacks, name, idl=None):
-1578 """Imports jackknife samples and returns an Obs
+1577 return dvalue
+1578
1579
-1580 Parameters
-1581 ----------
-1582 jacks : numpy.ndarray
-1583 numpy array containing the mean value as zeroth entry and
-1584 the N jackknife samples as first to Nth entry.
-1585 name : str
-1586 name of the ensemble the samples are defined on.
-1587 """
-1588 length = len(jacks) - 1
-1589 prj = (np.ones((length, length)) - (length - 1) * np.identity(length))
-1590 samples = jacks[1:] @ prj
-1591 mean = np.mean(samples)
-1592 new_obs = Obs([samples - mean], [name], idl=idl, means=[mean])
-1593 new_obs._value = jacks[0]
-1594 return new_obs
-1595
-1596
-1597def merge_obs(list_of_obs):
-1598 """Combine all observables in list_of_obs into one new observable
+1580def import_jackknife(jacks, name, idl=None):
+1581 """Imports jackknife samples and returns an Obs
+1582
+1583 Parameters
+1584 ----------
+1585 jacks : numpy.ndarray
+1586 numpy array containing the mean value as zeroth entry and
+1587 the N jackknife samples as first to Nth entry.
+1588 name : str
+1589 name of the ensemble the samples are defined on.
+1590 """
+1591 length = len(jacks) - 1
+1592 prj = (np.ones((length, length)) - (length - 1) * np.identity(length))
+1593 samples = jacks[1:] @ prj
+1594 mean = np.mean(samples)
+1595 new_obs = Obs([samples - mean], [name], idl=idl, means=[mean])
+1596 new_obs._value = jacks[0]
+1597 return new_obs
+1598
1599
-1600 Parameters
-1601 ----------
-1602 list_of_obs : list
-1603 list of the Obs object to be combined
-1604
-1605 Notes
-1606 -----
-1607 It is not possible to combine obs which are based on the same replicum
-1608 """
-1609 replist = [item for obs in list_of_obs for item in obs.names]
-1610 if (len(replist) == len(set(replist))) is False:
-1611 raise Exception('list_of_obs contains duplicate replica: %s' % (str(replist)))
-1612 if any([len(o.cov_names) for o in list_of_obs]):
-1613 raise Exception('Not possible to merge data that contains covobs!')
-1614 new_dict = {}
-1615 idl_dict = {}
-1616 for o in list_of_obs:
-1617 new_dict.update({key: o.deltas.get(key, 0) + o.r_values.get(key, 0)
-1618 for key in set(o.deltas) | set(o.r_values)})
-1619 idl_dict.update({key: o.idl.get(key, 0) for key in set(o.deltas)})
-1620
-1621 names = sorted(new_dict.keys())
-1622 o = Obs([new_dict[name] for name in names], names, idl=[idl_dict[name] for name in names])
-1623 o.is_merged = {name: np.any([oi.is_merged.get(name, False) for oi in list_of_obs]) for name in o.names}
-1624 o.reweighted = np.max([oi.reweighted for oi in list_of_obs])
-1625 return o
-1626
-1627
-1628def cov_Obs(means, cov, name, grad=None):
-1629 """Create an Obs based on mean(s) and a covariance matrix
+1600def merge_obs(list_of_obs):
+1601 """Combine all observables in list_of_obs into one new observable
+1602
+1603 Parameters
+1604 ----------
+1605 list_of_obs : list
+1606 list of the Obs object to be combined
+1607
+1608 Notes
+1609 -----
+1610 It is not possible to combine obs which are based on the same replicum
+1611 """
+1612 replist = [item for obs in list_of_obs for item in obs.names]
+1613 if (len(replist) == len(set(replist))) is False:
+1614 raise Exception('list_of_obs contains duplicate replica: %s' % (str(replist)))
+1615 if any([len(o.cov_names) for o in list_of_obs]):
+1616 raise Exception('Not possible to merge data that contains covobs!')
+1617 new_dict = {}
+1618 idl_dict = {}
+1619 for o in list_of_obs:
+1620 new_dict.update({key: o.deltas.get(key, 0) + o.r_values.get(key, 0)
+1621 for key in set(o.deltas) | set(o.r_values)})
+1622 idl_dict.update({key: o.idl.get(key, 0) for key in set(o.deltas)})
+1623
+1624 names = sorted(new_dict.keys())
+1625 o = Obs([new_dict[name] for name in names], names, idl=[idl_dict[name] for name in names])
+1626 o.is_merged = {name: np.any([oi.is_merged.get(name, False) for oi in list_of_obs]) for name in o.names}
+1627 o.reweighted = np.max([oi.reweighted for oi in list_of_obs])
+1628 return o
+1629
1630
-1631 Parameters
-1632 ----------
-1633 mean : list of floats or float
-1634 N mean value(s) of the new Obs
-1635 cov : list or array
-1636 2d (NxN) Covariance matrix, 1d diagonal entries or 0d covariance
-1637 name : str
-1638 identifier for the covariance matrix
-1639 grad : list or array
-1640 Gradient of the Covobs wrt. the means belonging to cov.
-1641 """
-1642
-1643 def covobs_to_obs(co):
-1644 """Make an Obs out of a Covobs
+1631def cov_Obs(means, cov, name, grad=None):
+1632 """Create an Obs based on mean(s) and a covariance matrix
+1633
+1634 Parameters
+1635 ----------
+1636 mean : list of floats or float
+1637 N mean value(s) of the new Obs
+1638 cov : list or array
+1639 2d (NxN) Covariance matrix, 1d diagonal entries or 0d covariance
+1640 name : str
+1641 identifier for the covariance matrix
+1642 grad : list or array
+1643 Gradient of the Covobs wrt. the means belonging to cov.
+1644 """
1645
-1646 Parameters
-1647 ----------
-1648 co : Covobs
-1649 Covobs to be embedded into the Obs
-1650 """
-1651 o = Obs([], [], means=[])
-1652 o._value = co.value
-1653 o.names.append(co.name)
-1654 o._covobs[co.name] = co
-1655 o._dvalue = np.sqrt(co.errsq())
-1656 return o
-1657
-1658 ol = []
-1659 if isinstance(means, (float, int)):
-1660 means = [means]
-1661
-1662 for i in range(len(means)):
-1663 ol.append(covobs_to_obs(Covobs(means[i], cov, name, pos=i, grad=grad)))
-1664 if ol[0].covobs[name].N != len(means):
-1665 raise Exception('You have to provide %d mean values!' % (ol[0].N))
-1666 if len(ol) == 1:
-1667 return ol[0]
-1668 return ol
+1646 def covobs_to_obs(co):
+1647 """Make an Obs out of a Covobs
+1648
+1649 Parameters
+1650 ----------
+1651 co : Covobs
+1652 Covobs to be embedded into the Obs
+1653 """
+1654 o = Obs([], [], means=[])
+1655 o._value = co.value
+1656 o.names.append(co.name)
+1657 o._covobs[co.name] = co
+1658 o._dvalue = np.sqrt(co.errsq())
+1659 return o
+1660
+1661 ol = []
+1662 if isinstance(means, (float, int)):
+1663 means = [means]
+1664
+1665 for i in range(len(means)):
+1666 ol.append(covobs_to_obs(Covobs(means[i], cov, name, pos=i, grad=grad)))
+1667 if ol[0].covobs[name].N != len(means):
+1668 raise Exception('You have to provide %d mean values!' % (ol[0].N))
+1669 if len(ol) == 1:
+1670 return ol[0]
+1671 return ol
@@ -1885,855 +1888,855 @@
- 17class Obs:
- 18 """Class for a general observable.
- 19
- 20 Instances of Obs are the basic objects of a pyerrors error analysis.
- 21 They are initialized with a list which contains arrays of samples for
- 22 different ensembles/replica and another list of same length which contains
- 23 the names of the ensembles/replica. Mathematical operations can be
- 24 performed on instances. The result is another instance of Obs. The error of
- 25 an instance can be computed with the gamma_method. Also contains additional
- 26 methods for output and visualization of the error calculation.
- 27
- 28 Attributes
- 29 ----------
- 30 S_global : float
- 31 Standard value for S (default 2.0)
- 32 S_dict : dict
- 33 Dictionary for S values. If an entry for a given ensemble
- 34 exists this overwrites the standard value for that ensemble.
- 35 tau_exp_global : float
- 36 Standard value for tau_exp (default 0.0)
- 37 tau_exp_dict : dict
- 38 Dictionary for tau_exp values. If an entry for a given ensemble exists
- 39 this overwrites the standard value for that ensemble.
- 40 N_sigma_global : float
- 41 Standard value for N_sigma (default 1.0)
- 42 N_sigma_dict : dict
- 43 Dictionary for N_sigma values. If an entry for a given ensemble exists
- 44 this overwrites the standard value for that ensemble.
- 45 """
- 46 __slots__ = ['names', 'shape', 'r_values', 'deltas', 'N', '_value', '_dvalue',
- 47 'ddvalue', 'reweighted', 'S', 'tau_exp', 'N_sigma',
- 48 'e_dvalue', 'e_ddvalue', 'e_tauint', 'e_dtauint',
- 49 'e_windowsize', 'e_rho', 'e_drho', 'e_n_tauint', 'e_n_dtauint',
- 50 'idl', 'is_merged', 'tag', '_covobs', '__dict__']
- 51
- 52 S_global = 2.0
- 53 S_dict = {}
- 54 tau_exp_global = 0.0
- 55 tau_exp_dict = {}
- 56 N_sigma_global = 1.0
- 57 N_sigma_dict = {}
- 58 filter_eps = 1e-10
- 59
- 60 def __init__(self, samples, names, idl=None, **kwargs):
- 61 """ Initialize Obs object.
+ 20class Obs:
+ 21 """Class for a general observable.
+ 22
+ 23 Instances of Obs are the basic objects of a pyerrors error analysis.
+ 24 They are initialized with a list which contains arrays of samples for
+ 25 different ensembles/replica and another list of same length which contains
+ 26 the names of the ensembles/replica. Mathematical operations can be
+ 27 performed on instances. The result is another instance of Obs. The error of
+ 28 an instance can be computed with the gamma_method. Also contains additional
+ 29 methods for output and visualization of the error calculation.
+ 30
+ 31 Attributes
+ 32 ----------
+ 33 S_global : float
+ 34 Standard value for S (default 2.0)
+ 35 S_dict : dict
+ 36 Dictionary for S values. If an entry for a given ensemble
+ 37 exists this overwrites the standard value for that ensemble.
+ 38 tau_exp_global : float
+ 39 Standard value for tau_exp (default 0.0)
+ 40 tau_exp_dict : dict
+ 41 Dictionary for tau_exp values. If an entry for a given ensemble exists
+ 42 this overwrites the standard value for that ensemble.
+ 43 N_sigma_global : float
+ 44 Standard value for N_sigma (default 1.0)
+ 45 N_sigma_dict : dict
+ 46 Dictionary for N_sigma values. If an entry for a given ensemble exists
+ 47 this overwrites the standard value for that ensemble.
+ 48 """
+ 49 __slots__ = ['names', 'shape', 'r_values', 'deltas', 'N', '_value', '_dvalue',
+ 50 'ddvalue', 'reweighted', 'S', 'tau_exp', 'N_sigma',
+ 51 'e_dvalue', 'e_ddvalue', 'e_tauint', 'e_dtauint',
+ 52 'e_windowsize', 'e_rho', 'e_drho', 'e_n_tauint', 'e_n_dtauint',
+ 53 'idl', 'is_merged', 'tag', '_covobs', '__dict__']
+ 54
+ 55 S_global = 2.0
+ 56 S_dict = {}
+ 57 tau_exp_global = 0.0
+ 58 tau_exp_dict = {}
+ 59 N_sigma_global = 1.0
+ 60 N_sigma_dict = {}
+ 61 filter_eps = 1e-10
62
- 63 Parameters
- 64 ----------
- 65 samples : list
- 66 list of numpy arrays containing the Monte Carlo samples
- 67 names : list
- 68 list of strings labeling the individual samples
- 69 idl : list, optional
- 70 list of ranges or lists on which the samples are defined
- 71 """
- 72
- 73 if kwargs.get("means") is None and len(samples):
- 74 if len(samples) != len(names):
- 75 raise Exception('Length of samples and names incompatible.')
- 76 if idl is not None:
- 77 if len(idl) != len(names):
- 78 raise Exception('Length of idl incompatible with samples and names.')
- 79 name_length = len(names)
- 80 if name_length > 1:
- 81 if name_length != len(set(names)):
- 82 raise Exception('names are not unique.')
- 83 if not all(isinstance(x, str) for x in names):
- 84 raise TypeError('All names have to be strings.')
- 85 else:
- 86 if not isinstance(names[0], str):
+ 63 def __init__(self, samples, names, idl=None, **kwargs):
+ 64 """ Initialize Obs object.
+ 65
+ 66 Parameters
+ 67 ----------
+ 68 samples : list
+ 69 list of numpy arrays containing the Monte Carlo samples
+ 70 names : list
+ 71 list of strings labeling the individual samples
+ 72 idl : list, optional
+ 73 list of ranges or lists on which the samples are defined
+ 74 """
+ 75
+ 76 if kwargs.get("means") is None and len(samples):
+ 77 if len(samples) != len(names):
+ 78 raise Exception('Length of samples and names incompatible.')
+ 79 if idl is not None:
+ 80 if len(idl) != len(names):
+ 81 raise Exception('Length of idl incompatible with samples and names.')
+ 82 name_length = len(names)
+ 83 if name_length > 1:
+ 84 if name_length != len(set(names)):
+ 85 raise Exception('names are not unique.')
+ 86 if not all(isinstance(x, str) for x in names):
87 raise TypeError('All names have to be strings.')
- 88 if min(len(x) for x in samples) <= 4:
- 89 raise Exception('Samples have to have at least 5 entries.')
- 90
- 91 self.names = sorted(names)
- 92 self.shape = {}
- 93 self.r_values = {}
- 94 self.deltas = {}
- 95 self._covobs = {}
- 96
- 97 self._value = 0
- 98 self.N = 0
- 99 self.is_merged = {}
-100 self.idl = {}
-101 if idl is not None:
-102 for name, idx in sorted(zip(names, idl)):
-103 if isinstance(idx, range):
-104 self.idl[name] = idx
-105 elif isinstance(idx, (list, np.ndarray)):
-106 dc = np.unique(np.diff(idx))
-107 if np.any(dc < 0):
-108 raise Exception("Unsorted idx for idl[%s]" % (name))
-109 if len(dc) == 1:
-110 self.idl[name] = range(idx[0], idx[-1] + dc[0], dc[0])
-111 else:
-112 self.idl[name] = list(idx)
-113 else:
-114 raise Exception('incompatible type for idl[%s].' % (name))
-115 else:
-116 for name, sample in sorted(zip(names, samples)):
-117 self.idl[name] = range(1, len(sample) + 1)
-118
-119 if kwargs.get("means") is not None:
-120 for name, sample, mean in sorted(zip(names, samples, kwargs.get("means"))):
-121 self.shape[name] = len(self.idl[name])
-122 self.N += self.shape[name]
-123 self.r_values[name] = mean
-124 self.deltas[name] = sample
-125 else:
-126 for name, sample in sorted(zip(names, samples)):
-127 self.shape[name] = len(self.idl[name])
-128 self.N += self.shape[name]
-129 if len(sample) != self.shape[name]:
-130 raise Exception('Incompatible samples and idx for %s: %d vs. %d' % (name, len(sample), self.shape[name]))
-131 self.r_values[name] = np.mean(sample)
-132 self.deltas[name] = sample - self.r_values[name]
-133 self._value += self.shape[name] * self.r_values[name]
-134 self._value /= self.N
-135
-136 self._dvalue = 0.0
-137 self.ddvalue = 0.0
-138 self.reweighted = False
-139
-140 self.tag = None
-141
-142 @property
-143 def value(self):
-144 return self._value
-145
-146 @property
-147 def dvalue(self):
-148 return self._dvalue
-149
-150 @property
-151 def e_names(self):
-152 return sorted(set([o.split('|')[0] for o in self.names]))
-153
-154 @property
-155 def cov_names(self):
-156 return sorted(set([o for o in self.covobs.keys()]))
-157
-158 @property
-159 def mc_names(self):
-160 return sorted(set([o.split('|')[0] for o in self.names if o not in self.cov_names]))
-161
-162 @property
-163 def e_content(self):
-164 res = {}
-165 for e, e_name in enumerate(self.e_names):
-166 res[e_name] = sorted(filter(lambda x: x.startswith(e_name + '|'), self.names))
-167 if e_name in self.names:
-168 res[e_name].append(e_name)
-169 return res
-170
-171 @property
-172 def covobs(self):
-173 return self._covobs
-174
-175 def gamma_method(self, **kwargs):
-176 """Estimate the error and related properties of the Obs.
+ 88 else:
+ 89 if not isinstance(names[0], str):
+ 90 raise TypeError('All names have to be strings.')
+ 91 if min(len(x) for x in samples) <= 4:
+ 92 raise Exception('Samples have to have at least 5 entries.')
+ 93
+ 94 self.names = sorted(names)
+ 95 self.shape = {}
+ 96 self.r_values = {}
+ 97 self.deltas = {}
+ 98 self._covobs = {}
+ 99
+100 self._value = 0
+101 self.N = 0
+102 self.is_merged = {}
+103 self.idl = {}
+104 if idl is not None:
+105 for name, idx in sorted(zip(names, idl)):
+106 if isinstance(idx, range):
+107 self.idl[name] = idx
+108 elif isinstance(idx, (list, np.ndarray)):
+109 dc = np.unique(np.diff(idx))
+110 if np.any(dc < 0):
+111 raise Exception("Unsorted idx for idl[%s]" % (name))
+112 if len(dc) == 1:
+113 self.idl[name] = range(idx[0], idx[-1] + dc[0], dc[0])
+114 else:
+115 self.idl[name] = list(idx)
+116 else:
+117 raise Exception('incompatible type for idl[%s].' % (name))
+118 else:
+119 for name, sample in sorted(zip(names, samples)):
+120 self.idl[name] = range(1, len(sample) + 1)
+121
+122 if kwargs.get("means") is not None:
+123 for name, sample, mean in sorted(zip(names, samples, kwargs.get("means"))):
+124 self.shape[name] = len(self.idl[name])
+125 self.N += self.shape[name]
+126 self.r_values[name] = mean
+127 self.deltas[name] = sample
+128 else:
+129 for name, sample in sorted(zip(names, samples)):
+130 self.shape[name] = len(self.idl[name])
+131 self.N += self.shape[name]
+132 if len(sample) != self.shape[name]:
+133 raise Exception('Incompatible samples and idx for %s: %d vs. %d' % (name, len(sample), self.shape[name]))
+134 self.r_values[name] = np.mean(sample)
+135 self.deltas[name] = sample - self.r_values[name]
+136 self._value += self.shape[name] * self.r_values[name]
+137 self._value /= self.N
+138
+139 self._dvalue = 0.0
+140 self.ddvalue = 0.0
+141 self.reweighted = False
+142
+143 self.tag = None
+144
+145 @property
+146 def value(self):
+147 return self._value
+148
+149 @property
+150 def dvalue(self):
+151 return self._dvalue
+152
+153 @property
+154 def e_names(self):
+155 return sorted(set([o.split('|')[0] for o in self.names]))
+156
+157 @property
+158 def cov_names(self):
+159 return sorted(set([o for o in self.covobs.keys()]))
+160
+161 @property
+162 def mc_names(self):
+163 return sorted(set([o.split('|')[0] for o in self.names if o not in self.cov_names]))
+164
+165 @property
+166 def e_content(self):
+167 res = {}
+168 for e, e_name in enumerate(self.e_names):
+169 res[e_name] = sorted(filter(lambda x: x.startswith(e_name + '|'), self.names))
+170 if e_name in self.names:
+171 res[e_name].append(e_name)
+172 return res
+173
+174 @property
+175 def covobs(self):
+176 return self._covobs
177
-178 Parameters
-179 ----------
-180 S : float
-181 specifies a custom value for the parameter S (default 2.0).
-182 If set to 0 it is assumed that the data exhibits no
-183 autocorrelation. In this case the error estimates coincides
-184 with the sample standard error.
-185 tau_exp : float
-186 positive value triggers the critical slowing down analysis
-187 (default 0.0).
-188 N_sigma : float
-189 number of standard deviations from zero until the tail is
-190 attached to the autocorrelation function (default 1).
-191 fft : bool
-192 determines whether the fft algorithm is used for the computation
-193 of the autocorrelation function (default True)
-194 """
-195
-196 e_content = self.e_content
-197 self.e_dvalue = {}
-198 self.e_ddvalue = {}
-199 self.e_tauint = {}
-200 self.e_dtauint = {}
-201 self.e_windowsize = {}
-202 self.e_n_tauint = {}
-203 self.e_n_dtauint = {}
-204 e_gamma = {}
-205 self.e_rho = {}
-206 self.e_drho = {}
-207 self._dvalue = 0
-208 self.ddvalue = 0
-209
-210 self.S = {}
-211 self.tau_exp = {}
-212 self.N_sigma = {}
-213
-214 if kwargs.get('fft') is False:
-215 fft = False
-216 else:
-217 fft = True
-218
-219 def _parse_kwarg(kwarg_name):
-220 if kwarg_name in kwargs:
-221 tmp = kwargs.get(kwarg_name)
-222 if isinstance(tmp, (int, float)):
-223 if tmp < 0:
-224 raise Exception(kwarg_name + ' has to be larger or equal to 0.')
-225 for e, e_name in enumerate(self.e_names):
-226 getattr(self, kwarg_name)[e_name] = tmp
-227 else:
-228 raise TypeError(kwarg_name + ' is not in proper format.')
-229 else:
-230 for e, e_name in enumerate(self.e_names):
-231 if e_name in getattr(Obs, kwarg_name + '_dict'):
-232 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_dict')[e_name]
-233 else:
-234 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_global')
-235
-236 _parse_kwarg('S')
-237 _parse_kwarg('tau_exp')
-238 _parse_kwarg('N_sigma')
-239
-240 for e, e_name in enumerate(self.mc_names):
-241 r_length = []
-242 for r_name in e_content[e_name]:
-243 if isinstance(self.idl[r_name], range):
-244 r_length.append(len(self.idl[r_name]))
-245 else:
-246 r_length.append((self.idl[r_name][-1] - self.idl[r_name][0] + 1))
-247
-248 e_N = np.sum([self.shape[r_name] for r_name in e_content[e_name]])
-249 w_max = max(r_length) // 2
-250 e_gamma[e_name] = np.zeros(w_max)
-251 self.e_rho[e_name] = np.zeros(w_max)
-252 self.e_drho[e_name] = np.zeros(w_max)
-253
-254 for r_name in e_content[e_name]:
-255 e_gamma[e_name] += self._calc_gamma(self.deltas[r_name], self.idl[r_name], self.shape[r_name], w_max, fft)
+178 def gamma_method(self, **kwargs):
+179 """Estimate the error and related properties of the Obs.
+180
+181 Parameters
+182 ----------
+183 S : float
+184 specifies a custom value for the parameter S (default 2.0).
+185 If set to 0 it is assumed that the data exhibits no
+186 autocorrelation. In this case the error estimates coincides
+187 with the sample standard error.
+188 tau_exp : float
+189 positive value triggers the critical slowing down analysis
+190 (default 0.0).
+191 N_sigma : float
+192 number of standard deviations from zero until the tail is
+193 attached to the autocorrelation function (default 1).
+194 fft : bool
+195 determines whether the fft algorithm is used for the computation
+196 of the autocorrelation function (default True)
+197 """
+198
+199 e_content = self.e_content
+200 self.e_dvalue = {}
+201 self.e_ddvalue = {}
+202 self.e_tauint = {}
+203 self.e_dtauint = {}
+204 self.e_windowsize = {}
+205 self.e_n_tauint = {}
+206 self.e_n_dtauint = {}
+207 e_gamma = {}
+208 self.e_rho = {}
+209 self.e_drho = {}
+210 self._dvalue = 0
+211 self.ddvalue = 0
+212
+213 self.S = {}
+214 self.tau_exp = {}
+215 self.N_sigma = {}
+216
+217 if kwargs.get('fft') is False:
+218 fft = False
+219 else:
+220 fft = True
+221
+222 def _parse_kwarg(kwarg_name):
+223 if kwarg_name in kwargs:
+224 tmp = kwargs.get(kwarg_name)
+225 if isinstance(tmp, (int, float)):
+226 if tmp < 0:
+227 raise Exception(kwarg_name + ' has to be larger or equal to 0.')
+228 for e, e_name in enumerate(self.e_names):
+229 getattr(self, kwarg_name)[e_name] = tmp
+230 else:
+231 raise TypeError(kwarg_name + ' is not in proper format.')
+232 else:
+233 for e, e_name in enumerate(self.e_names):
+234 if e_name in getattr(Obs, kwarg_name + '_dict'):
+235 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_dict')[e_name]
+236 else:
+237 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_global')
+238
+239 _parse_kwarg('S')
+240 _parse_kwarg('tau_exp')
+241 _parse_kwarg('N_sigma')
+242
+243 for e, e_name in enumerate(self.mc_names):
+244 r_length = []
+245 for r_name in e_content[e_name]:
+246 if isinstance(self.idl[r_name], range):
+247 r_length.append(len(self.idl[r_name]))
+248 else:
+249 r_length.append((self.idl[r_name][-1] - self.idl[r_name][0] + 1))
+250
+251 e_N = np.sum([self.shape[r_name] for r_name in e_content[e_name]])
+252 w_max = max(r_length) // 2
+253 e_gamma[e_name] = np.zeros(w_max)
+254 self.e_rho[e_name] = np.zeros(w_max)
+255 self.e_drho[e_name] = np.zeros(w_max)
256
-257 gamma_div = np.zeros(w_max)
-258 for r_name in e_content[e_name]:
-259 gamma_div += self._calc_gamma(np.ones((self.shape[r_name])), self.idl[r_name], self.shape[r_name], w_max, fft)
-260 gamma_div[gamma_div < 1] = 1.0
-261 e_gamma[e_name] /= gamma_div[:w_max]
-262
-263 if np.abs(e_gamma[e_name][0]) < 10 * np.finfo(float).tiny: # Prevent division by zero
-264 self.e_tauint[e_name] = 0.5
-265 self.e_dtauint[e_name] = 0.0
-266 self.e_dvalue[e_name] = 0.0
-267 self.e_ddvalue[e_name] = 0.0
-268 self.e_windowsize[e_name] = 0
-269 continue
-270
-271 gaps = []
-272 for r_name in e_content[e_name]:
-273 if isinstance(self.idl[r_name], range):
-274 gaps.append(1)
-275 else:
-276 gaps.append(np.min(np.diff(self.idl[r_name])))
-277
-278 if not np.all([gi == gaps[0] for gi in gaps]):
-279 raise Exception(f"Replica for ensemble {e_name} are not equally spaced.", gaps)
-280 else:
-281 gapsize = gaps[0]
-282
-283 self.e_rho[e_name] = e_gamma[e_name][:w_max] / e_gamma[e_name][0]
-284 self.e_n_tauint[e_name] = np.cumsum(np.concatenate(([0.5], self.e_rho[e_name][1:])))
-285 # Make sure no entry of tauint is smaller than 0.5
-286 self.e_n_tauint[e_name][self.e_n_tauint[e_name] <= 0.5] = 0.5 + np.finfo(np.float64).eps
-287 # hep-lat/0306017 eq. (42)
-288 self.e_n_dtauint[e_name] = self.e_n_tauint[e_name] * 2 * np.sqrt(np.abs(np.arange(w_max) / gapsize + 0.5 - self.e_n_tauint[e_name]) / e_N)
-289 self.e_n_dtauint[e_name][0] = 0.0
-290
-291 def _compute_drho(i):
-292 tmp = self.e_rho[e_name][i + 1:w_max] + np.concatenate([self.e_rho[e_name][i - 1::-1], self.e_rho[e_name][1:w_max - 2 * i]]) - 2 * self.e_rho[e_name][i] * self.e_rho[e_name][1:w_max - i]
-293 self.e_drho[e_name][i] = np.sqrt(np.sum(tmp ** 2) / e_N)
-294
-295 _compute_drho(gapsize)
-296 if self.tau_exp[e_name] > 0:
-297 texp = self.tau_exp[e_name]
-298 # Critical slowing down analysis
-299 if w_max // 2 <= 1:
-300 raise Exception("Need at least 8 samples for tau_exp error analysis")
-301 for n in range(gapsize, w_max // 2, gapsize):
-302 _compute_drho(n + gapsize)
-303 if (self.e_rho[e_name][n] - self.N_sigma[e_name] * self.e_drho[e_name][n]) < 0 or n >= w_max // 2 - 2:
-304 # Bias correction hep-lat/0306017 eq. (49) included
-305 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) + texp * np.abs(self.e_rho[e_name][n + 1]) # The absolute makes sure, that the tail contribution is always positive
-306 self.e_dtauint[e_name] = np.sqrt(self.e_n_dtauint[e_name][n] ** 2 + texp ** 2 * self.e_drho[e_name][n + 1] ** 2)
-307 # Error of tau_exp neglected so far, missing term: self.e_rho[e_name][n + 1] ** 2 * d_tau_exp ** 2
-308 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
-309 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
-310 self.e_windowsize[e_name] = n
-311 break
-312 else:
-313 if self.S[e_name] == 0.0:
-314 self.e_tauint[e_name] = 0.5
-315 self.e_dtauint[e_name] = 0.0
-316 self.e_dvalue[e_name] = np.sqrt(e_gamma[e_name][0] / (e_N - 1))
-317 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt(0.5 / e_N)
-318 self.e_windowsize[e_name] = 0
-319 else:
-320 # Standard automatic windowing procedure
-321 tau = self.S[e_name] / np.log((2 * self.e_n_tauint[e_name][gapsize::gapsize] + 1) / (2 * self.e_n_tauint[e_name][gapsize::gapsize] - 1))
-322 g_w = np.exp(- np.arange(1, len(tau) + 1) / tau) - tau / np.sqrt(np.arange(1, len(tau) + 1) * e_N)
-323 for n in range(1, w_max):
-324 if n < w_max // 2 - 2:
-325 _compute_drho(gapsize * n + gapsize)
-326 if g_w[n - 1] < 0 or n >= w_max - 1:
-327 n *= gapsize
-328 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) # Bias correction hep-lat/0306017 eq. (49)
-329 self.e_dtauint[e_name] = self.e_n_dtauint[e_name][n]
-330 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
-331 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
-332 self.e_windowsize[e_name] = n
-333 break
-334
-335 self._dvalue += self.e_dvalue[e_name] ** 2
-336 self.ddvalue += (self.e_dvalue[e_name] * self.e_ddvalue[e_name]) ** 2
+257 for r_name in e_content[e_name]:
+258 e_gamma[e_name] += self._calc_gamma(self.deltas[r_name], self.idl[r_name], self.shape[r_name], w_max, fft)
+259
+260 gamma_div = np.zeros(w_max)
+261 for r_name in e_content[e_name]:
+262 gamma_div += self._calc_gamma(np.ones((self.shape[r_name])), self.idl[r_name], self.shape[r_name], w_max, fft)
+263 gamma_div[gamma_div < 1] = 1.0
+264 e_gamma[e_name] /= gamma_div[:w_max]
+265
+266 if np.abs(e_gamma[e_name][0]) < 10 * np.finfo(float).tiny: # Prevent division by zero
+267 self.e_tauint[e_name] = 0.5
+268 self.e_dtauint[e_name] = 0.0
+269 self.e_dvalue[e_name] = 0.0
+270 self.e_ddvalue[e_name] = 0.0
+271 self.e_windowsize[e_name] = 0
+272 continue
+273
+274 gaps = []
+275 for r_name in e_content[e_name]:
+276 if isinstance(self.idl[r_name], range):
+277 gaps.append(1)
+278 else:
+279 gaps.append(np.min(np.diff(self.idl[r_name])))
+280
+281 if not np.all([gi == gaps[0] for gi in gaps]):
+282 raise Exception(f"Replica for ensemble {e_name} are not equally spaced.", gaps)
+283 else:
+284 gapsize = gaps[0]
+285
+286 self.e_rho[e_name] = e_gamma[e_name][:w_max] / e_gamma[e_name][0]
+287 self.e_n_tauint[e_name] = np.cumsum(np.concatenate(([0.5], self.e_rho[e_name][1:])))
+288 # Make sure no entry of tauint is smaller than 0.5
+289 self.e_n_tauint[e_name][self.e_n_tauint[e_name] <= 0.5] = 0.5 + np.finfo(np.float64).eps
+290 # hep-lat/0306017 eq. (42)
+291 self.e_n_dtauint[e_name] = self.e_n_tauint[e_name] * 2 * np.sqrt(np.abs(np.arange(w_max) / gapsize + 0.5 - self.e_n_tauint[e_name]) / e_N)
+292 self.e_n_dtauint[e_name][0] = 0.0
+293
+294 def _compute_drho(i):
+295 tmp = self.e_rho[e_name][i + 1:w_max] + np.concatenate([self.e_rho[e_name][i - 1::-1], self.e_rho[e_name][1:w_max - 2 * i]]) - 2 * self.e_rho[e_name][i] * self.e_rho[e_name][1:w_max - i]
+296 self.e_drho[e_name][i] = np.sqrt(np.sum(tmp ** 2) / e_N)
+297
+298 _compute_drho(gapsize)
+299 if self.tau_exp[e_name] > 0:
+300 texp = self.tau_exp[e_name]
+301 # Critical slowing down analysis
+302 if w_max // 2 <= 1:
+303 raise Exception("Need at least 8 samples for tau_exp error analysis")
+304 for n in range(gapsize, w_max // 2, gapsize):
+305 _compute_drho(n + gapsize)
+306 if (self.e_rho[e_name][n] - self.N_sigma[e_name] * self.e_drho[e_name][n]) < 0 or n >= w_max // 2 - 2:
+307 # Bias correction hep-lat/0306017 eq. (49) included
+308 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) + texp * np.abs(self.e_rho[e_name][n + 1]) # The absolute makes sure, that the tail contribution is always positive
+309 self.e_dtauint[e_name] = np.sqrt(self.e_n_dtauint[e_name][n] ** 2 + texp ** 2 * self.e_drho[e_name][n + 1] ** 2)
+310 # Error of tau_exp neglected so far, missing term: self.e_rho[e_name][n + 1] ** 2 * d_tau_exp ** 2
+311 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
+312 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
+313 self.e_windowsize[e_name] = n
+314 break
+315 else:
+316 if self.S[e_name] == 0.0:
+317 self.e_tauint[e_name] = 0.5
+318 self.e_dtauint[e_name] = 0.0
+319 self.e_dvalue[e_name] = np.sqrt(e_gamma[e_name][0] / (e_N - 1))
+320 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt(0.5 / e_N)
+321 self.e_windowsize[e_name] = 0
+322 else:
+323 # Standard automatic windowing procedure
+324 tau = self.S[e_name] / np.log((2 * self.e_n_tauint[e_name][gapsize::gapsize] + 1) / (2 * self.e_n_tauint[e_name][gapsize::gapsize] - 1))
+325 g_w = np.exp(- np.arange(1, len(tau) + 1) / tau) - tau / np.sqrt(np.arange(1, len(tau) + 1) * e_N)
+326 for n in range(1, w_max):
+327 if n < w_max // 2 - 2:
+328 _compute_drho(gapsize * n + gapsize)
+329 if g_w[n - 1] < 0 or n >= w_max - 1:
+330 n *= gapsize
+331 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) # Bias correction hep-lat/0306017 eq. (49)
+332 self.e_dtauint[e_name] = self.e_n_dtauint[e_name][n]
+333 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
+334 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
+335 self.e_windowsize[e_name] = n
+336 break
337
-338 for e_name in self.cov_names:
-339 self.e_dvalue[e_name] = np.sqrt(self.covobs[e_name].errsq())
-340 self.e_ddvalue[e_name] = 0
-341 self._dvalue += self.e_dvalue[e_name]**2
-342
-343 self._dvalue = np.sqrt(self._dvalue)
-344 if self._dvalue == 0.0:
-345 self.ddvalue = 0.0
-346 else:
-347 self.ddvalue = np.sqrt(self.ddvalue) / self._dvalue
-348 return
-349
-350 def _calc_gamma(self, deltas, idx, shape, w_max, fft):
-351 """Calculate Gamma_{AA} from the deltas, which are defined on idx.
-352 idx is assumed to be a contiguous range (possibly with a stepsize != 1)
-353
-354 Parameters
-355 ----------
-356 deltas : list
-357 List of fluctuations
-358 idx : list
-359 List or range of configurations on which the deltas are defined.
-360 shape : int
-361 Number of configurations in idx.
-362 w_max : int
-363 Upper bound for the summation window.
-364 fft : bool
-365 determines whether the fft algorithm is used for the computation
-366 of the autocorrelation function.
-367 """
-368 gamma = np.zeros(w_max)
-369 deltas = _expand_deltas(deltas, idx, shape)
-370 new_shape = len(deltas)
-371 if fft:
-372 max_gamma = min(new_shape, w_max)
-373 # The padding for the fft has to be even
-374 padding = new_shape + max_gamma + (new_shape + max_gamma) % 2
-375 gamma[:max_gamma] += np.fft.irfft(np.abs(np.fft.rfft(deltas, padding)) ** 2)[:max_gamma]
-376 else:
-377 for n in range(w_max):
-378 if new_shape - n >= 0:
-379 gamma[n] += deltas[0:new_shape - n].dot(deltas[n:new_shape])
-380
-381 return gamma
-382
-383 def details(self, ens_content=True):
-384 """Output detailed properties of the Obs.
+338 self._dvalue += self.e_dvalue[e_name] ** 2
+339 self.ddvalue += (self.e_dvalue[e_name] * self.e_ddvalue[e_name]) ** 2
+340
+341 for e_name in self.cov_names:
+342 self.e_dvalue[e_name] = np.sqrt(self.covobs[e_name].errsq())
+343 self.e_ddvalue[e_name] = 0
+344 self._dvalue += self.e_dvalue[e_name]**2
+345
+346 self._dvalue = np.sqrt(self._dvalue)
+347 if self._dvalue == 0.0:
+348 self.ddvalue = 0.0
+349 else:
+350 self.ddvalue = np.sqrt(self.ddvalue) / self._dvalue
+351 return
+352
+353 def _calc_gamma(self, deltas, idx, shape, w_max, fft):
+354 """Calculate Gamma_{AA} from the deltas, which are defined on idx.
+355 idx is assumed to be a contiguous range (possibly with a stepsize != 1)
+356
+357 Parameters
+358 ----------
+359 deltas : list
+360 List of fluctuations
+361 idx : list
+362 List or range of configurations on which the deltas are defined.
+363 shape : int
+364 Number of configurations in idx.
+365 w_max : int
+366 Upper bound for the summation window.
+367 fft : bool
+368 determines whether the fft algorithm is used for the computation
+369 of the autocorrelation function.
+370 """
+371 gamma = np.zeros(w_max)
+372 deltas = _expand_deltas(deltas, idx, shape)
+373 new_shape = len(deltas)
+374 if fft:
+375 max_gamma = min(new_shape, w_max)
+376 # The padding for the fft has to be even
+377 padding = new_shape + max_gamma + (new_shape + max_gamma) % 2
+378 gamma[:max_gamma] += np.fft.irfft(np.abs(np.fft.rfft(deltas, padding)) ** 2)[:max_gamma]
+379 else:
+380 for n in range(w_max):
+381 if new_shape - n >= 0:
+382 gamma[n] += deltas[0:new_shape - n].dot(deltas[n:new_shape])
+383
+384 return gamma
385
-386 Parameters
-387 ----------
-388 ens_content : bool
-389 print details about the ensembles and replica if true.
-390 """
-391 if self.tag is not None:
-392 print("Description:", self.tag)
-393 if not hasattr(self, 'e_dvalue'):
-394 print('Result\t %3.8e' % (self.value))
-395 else:
-396 if self.value == 0.0:
-397 percentage = np.nan
-398 else:
-399 percentage = np.abs(self._dvalue / self.value) * 100
-400 print('Result\t %3.8e +/- %3.8e +/- %3.8e (%3.3f%%)' % (self.value, self._dvalue, self.ddvalue, percentage))
-401 if len(self.e_names) > 1:
-402 print(' Ensemble errors:')
-403 e_content = self.e_content
-404 for e_name in self.mc_names:
-405 if isinstance(self.idl[e_content[e_name][0]], range):
-406 gap = self.idl[e_content[e_name][0]].step
-407 else:
-408 gap = np.min(np.diff(self.idl[e_content[e_name][0]]))
-409
-410 if len(self.e_names) > 1:
-411 print('', e_name, '\t %3.6e +/- %3.6e' % (self.e_dvalue[e_name], self.e_ddvalue[e_name]))
-412 tau_string = " \N{GREEK SMALL LETTER TAU}_int\t " + _format_uncertainty(self.e_tauint[e_name], self.e_dtauint[e_name])
-413 tau_string += f" in units of {gap} config"
-414 if gap > 1:
-415 tau_string += "s"
-416 if self.tau_exp[e_name] > 0:
-417 tau_string = f"{tau_string: <45}" + '\t(\N{GREEK SMALL LETTER TAU}_exp=%3.2f, N_\N{GREEK SMALL LETTER SIGMA}=%1.0i)' % (self.tau_exp[e_name], self.N_sigma[e_name])
-418 else:
-419 tau_string = f"{tau_string: <45}" + '\t(S=%3.2f)' % (self.S[e_name])
-420 print(tau_string)
-421 for e_name in self.cov_names:
-422 print('', e_name, '\t %3.8e' % (self.e_dvalue[e_name]))
-423 if ens_content is True:
-424 if len(self.e_names) == 1:
-425 print(self.N, 'samples in', len(self.e_names), 'ensemble:')
-426 else:
-427 print(self.N, 'samples in', len(self.e_names), 'ensembles:')
-428 my_string_list = []
-429 for key, value in sorted(self.e_content.items()):
-430 if key not in self.covobs:
-431 my_string = ' ' + "\u00B7 Ensemble '" + key + "' "
-432 if len(value) == 1:
-433 my_string += f': {self.shape[value[0]]} configurations'
-434 if isinstance(self.idl[value[0]], range):
-435 my_string += f' (from {self.idl[value[0]].start} to {self.idl[value[0]][-1]}' + int(self.idl[value[0]].step != 1) * f' in steps of {self.idl[value[0]].step}' + ')'
-436 else:
-437 my_string += f' (irregular range from {self.idl[value[0]][0]} to {self.idl[value[0]][-1]})'
-438 else:
-439 sublist = []
-440 for v in value:
-441 my_substring = ' ' + "\u00B7 Replicum '" + v[len(key) + 1:] + "' "
-442 my_substring += f': {self.shape[v]} configurations'
-443 if isinstance(self.idl[v], range):
-444 my_substring += f' (from {self.idl[v].start} to {self.idl[v][-1]}' + int(self.idl[v].step != 1) * f' in steps of {self.idl[v].step}' + ')'
-445 else:
-446 my_substring += f' (irregular range from {self.idl[v][0]} to {self.idl[v][-1]})'
-447 sublist.append(my_substring)
-448
-449 my_string += '\n' + '\n'.join(sublist)
-450 else:
-451 my_string = ' ' + "\u00B7 Covobs '" + key + "' "
-452 my_string_list.append(my_string)
-453 print('\n'.join(my_string_list))
-454
-455 def reweight(self, weight):
-456 """Reweight the obs with given rewighting factors.
+386 def details(self, ens_content=True):
+387 """Output detailed properties of the Obs.
+388
+389 Parameters
+390 ----------
+391 ens_content : bool
+392 print details about the ensembles and replica if true.
+393 """
+394 if self.tag is not None:
+395 print("Description:", self.tag)
+396 if not hasattr(self, 'e_dvalue'):
+397 print('Result\t %3.8e' % (self.value))
+398 else:
+399 if self.value == 0.0:
+400 percentage = np.nan
+401 else:
+402 percentage = np.abs(self._dvalue / self.value) * 100
+403 print('Result\t %3.8e +/- %3.8e +/- %3.8e (%3.3f%%)' % (self.value, self._dvalue, self.ddvalue, percentage))
+404 if len(self.e_names) > 1:
+405 print(' Ensemble errors:')
+406 e_content = self.e_content
+407 for e_name in self.mc_names:
+408 if isinstance(self.idl[e_content[e_name][0]], range):
+409 gap = self.idl[e_content[e_name][0]].step
+410 else:
+411 gap = np.min(np.diff(self.idl[e_content[e_name][0]]))
+412
+413 if len(self.e_names) > 1:
+414 print('', e_name, '\t %3.6e +/- %3.6e' % (self.e_dvalue[e_name], self.e_ddvalue[e_name]))
+415 tau_string = " \N{GREEK SMALL LETTER TAU}_int\t " + _format_uncertainty(self.e_tauint[e_name], self.e_dtauint[e_name])
+416 tau_string += f" in units of {gap} config"
+417 if gap > 1:
+418 tau_string += "s"
+419 if self.tau_exp[e_name] > 0:
+420 tau_string = f"{tau_string: <45}" + '\t(\N{GREEK SMALL LETTER TAU}_exp=%3.2f, N_\N{GREEK SMALL LETTER SIGMA}=%1.0i)' % (self.tau_exp[e_name], self.N_sigma[e_name])
+421 else:
+422 tau_string = f"{tau_string: <45}" + '\t(S=%3.2f)' % (self.S[e_name])
+423 print(tau_string)
+424 for e_name in self.cov_names:
+425 print('', e_name, '\t %3.8e' % (self.e_dvalue[e_name]))
+426 if ens_content is True:
+427 if len(self.e_names) == 1:
+428 print(self.N, 'samples in', len(self.e_names), 'ensemble:')
+429 else:
+430 print(self.N, 'samples in', len(self.e_names), 'ensembles:')
+431 my_string_list = []
+432 for key, value in sorted(self.e_content.items()):
+433 if key not in self.covobs:
+434 my_string = ' ' + "\u00B7 Ensemble '" + key + "' "
+435 if len(value) == 1:
+436 my_string += f': {self.shape[value[0]]} configurations'
+437 if isinstance(self.idl[value[0]], range):
+438 my_string += f' (from {self.idl[value[0]].start} to {self.idl[value[0]][-1]}' + int(self.idl[value[0]].step != 1) * f' in steps of {self.idl[value[0]].step}' + ')'
+439 else:
+440 my_string += f' (irregular range from {self.idl[value[0]][0]} to {self.idl[value[0]][-1]})'
+441 else:
+442 sublist = []
+443 for v in value:
+444 my_substring = ' ' + "\u00B7 Replicum '" + v[len(key) + 1:] + "' "
+445 my_substring += f': {self.shape[v]} configurations'
+446 if isinstance(self.idl[v], range):
+447 my_substring += f' (from {self.idl[v].start} to {self.idl[v][-1]}' + int(self.idl[v].step != 1) * f' in steps of {self.idl[v].step}' + ')'
+448 else:
+449 my_substring += f' (irregular range from {self.idl[v][0]} to {self.idl[v][-1]})'
+450 sublist.append(my_substring)
+451
+452 my_string += '\n' + '\n'.join(sublist)
+453 else:
+454 my_string = ' ' + "\u00B7 Covobs '" + key + "' "
+455 my_string_list.append(my_string)
+456 print('\n'.join(my_string_list))
457
-458 Parameters
-459 ----------
-460 weight : Obs
-461 Reweighting factor. An Observable that has to be defined on a superset of the
-462 configurations in obs[i].idl for all i.
-463 all_configs : bool
-464 if True, the reweighted observables are normalized by the average of
-465 the reweighting factor on all configurations in weight.idl and not
-466 on the configurations in obs[i].idl. Default False.
-467 """
-468 return reweight(weight, [self])[0]
-469
-470 def is_zero_within_error(self, sigma=1):
-471 """Checks whether the observable is zero within 'sigma' standard errors.
+458 def reweight(self, weight):
+459 """Reweight the obs with given rewighting factors.
+460
+461 Parameters
+462 ----------
+463 weight : Obs
+464 Reweighting factor. An Observable that has to be defined on a superset of the
+465 configurations in obs[i].idl for all i.
+466 all_configs : bool
+467 if True, the reweighted observables are normalized by the average of
+468 the reweighting factor on all configurations in weight.idl and not
+469 on the configurations in obs[i].idl. Default False.
+470 """
+471 return reweight(weight, [self])[0]
472
-473 Parameters
-474 ----------
-475 sigma : int
-476 Number of standard errors used for the check.
-477
-478 Works only properly when the gamma method was run.
-479 """
-480 return self.is_zero() or np.abs(self.value) <= sigma * self._dvalue
-481
-482 def is_zero(self, atol=1e-10):
-483 """Checks whether the observable is zero within a given tolerance.
+473 def is_zero_within_error(self, sigma=1):
+474 """Checks whether the observable is zero within 'sigma' standard errors.
+475
+476 Parameters
+477 ----------
+478 sigma : int
+479 Number of standard errors used for the check.
+480
+481 Works only properly when the gamma method was run.
+482 """
+483 return self.is_zero() or np.abs(self.value) <= sigma * self._dvalue
484
-485 Parameters
-486 ----------
-487 atol : float
-488 Absolute tolerance (for details see numpy documentation).
-489 """
-490 return np.isclose(0.0, self.value, 1e-14, atol) and all(np.allclose(0.0, delta, 1e-14, atol) for delta in self.deltas.values()) and all(np.allclose(0.0, delta.errsq(), 1e-14, atol) for delta in self.covobs.values())
-491
-492 def plot_tauint(self, save=None):
-493 """Plot integrated autocorrelation time for each ensemble.
+485 def is_zero(self, atol=1e-10):
+486 """Checks whether the observable is zero within a given tolerance.
+487
+488 Parameters
+489 ----------
+490 atol : float
+491 Absolute tolerance (for details see numpy documentation).
+492 """
+493 return np.isclose(0.0, self.value, 1e-14, atol) and all(np.allclose(0.0, delta, 1e-14, atol) for delta in self.deltas.values()) and all(np.allclose(0.0, delta.errsq(), 1e-14, atol) for delta in self.covobs.values())
494
-495 Parameters
-496 ----------
-497 save : str
-498 saves the figure to a file named 'save' if.
-499 """
-500 if not hasattr(self, 'e_dvalue'):
-501 raise Exception('Run the gamma method first.')
-502
-503 for e, e_name in enumerate(self.mc_names):
-504 fig = plt.figure()
-505 plt.xlabel(r'$W$')
-506 plt.ylabel(r'$\tau_\mathrm{int}$')
-507 length = int(len(self.e_n_tauint[e_name]))
-508 if self.tau_exp[e_name] > 0:
-509 base = self.e_n_tauint[e_name][self.e_windowsize[e_name]]
-510 x_help = np.arange(2 * self.tau_exp[e_name])
-511 y_help = (x_help + 1) * np.abs(self.e_rho[e_name][self.e_windowsize[e_name] + 1]) * (1 - x_help / (2 * (2 * self.tau_exp[e_name] - 1))) + base
-512 x_arr = np.arange(self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name])
-513 plt.plot(x_arr, y_help, 'C' + str(e), linewidth=1, ls='--', marker=',')
-514 plt.errorbar([self.e_windowsize[e_name] + 2 * self.tau_exp[e_name]], [self.e_tauint[e_name]],
-515 yerr=[self.e_dtauint[e_name]], fmt='C' + str(e), linewidth=1, capsize=2, marker='o', mfc=plt.rcParams['axes.facecolor'])
-516 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
-517 label = e_name + r', $\tau_\mathrm{exp}$=' + str(np.around(self.tau_exp[e_name], decimals=2))
-518 else:
-519 label = e_name + ', S=' + str(np.around(self.S[e_name], decimals=2))
-520 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
-521
-522 plt.errorbar(np.arange(length)[:int(xmax) + 1], self.e_n_tauint[e_name][:int(xmax) + 1], yerr=self.e_n_dtauint[e_name][:int(xmax) + 1], linewidth=1, capsize=2, label=label)
-523 plt.axvline(x=self.e_windowsize[e_name], color='C' + str(e), alpha=0.5, marker=',', ls='--')
-524 plt.legend()
-525 plt.xlim(-0.5, xmax)
-526 ylim = plt.ylim()
-527 plt.ylim(bottom=0.0, top=max(1.0, ylim[1]))
-528 plt.draw()
-529 if save:
-530 fig.savefig(save + "_" + str(e))
-531
-532 def plot_rho(self, save=None):
-533 """Plot normalized autocorrelation function time for each ensemble.
+495 def plot_tauint(self, save=None):
+496 """Plot integrated autocorrelation time for each ensemble.
+497
+498 Parameters
+499 ----------
+500 save : str
+501 saves the figure to a file named 'save' if.
+502 """
+503 if not hasattr(self, 'e_dvalue'):
+504 raise Exception('Run the gamma method first.')
+505
+506 for e, e_name in enumerate(self.mc_names):
+507 fig = plt.figure()
+508 plt.xlabel(r'$W$')
+509 plt.ylabel(r'$\tau_\mathrm{int}$')
+510 length = int(len(self.e_n_tauint[e_name]))
+511 if self.tau_exp[e_name] > 0:
+512 base = self.e_n_tauint[e_name][self.e_windowsize[e_name]]
+513 x_help = np.arange(2 * self.tau_exp[e_name])
+514 y_help = (x_help + 1) * np.abs(self.e_rho[e_name][self.e_windowsize[e_name] + 1]) * (1 - x_help / (2 * (2 * self.tau_exp[e_name] - 1))) + base
+515 x_arr = np.arange(self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name])
+516 plt.plot(x_arr, y_help, 'C' + str(e), linewidth=1, ls='--', marker=',')
+517 plt.errorbar([self.e_windowsize[e_name] + 2 * self.tau_exp[e_name]], [self.e_tauint[e_name]],
+518 yerr=[self.e_dtauint[e_name]], fmt='C' + str(e), linewidth=1, capsize=2, marker='o', mfc=plt.rcParams['axes.facecolor'])
+519 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
+520 label = e_name + r', $\tau_\mathrm{exp}$=' + str(np.around(self.tau_exp[e_name], decimals=2))
+521 else:
+522 label = e_name + ', S=' + str(np.around(self.S[e_name], decimals=2))
+523 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
+524
+525 plt.errorbar(np.arange(length)[:int(xmax) + 1], self.e_n_tauint[e_name][:int(xmax) + 1], yerr=self.e_n_dtauint[e_name][:int(xmax) + 1], linewidth=1, capsize=2, label=label)
+526 plt.axvline(x=self.e_windowsize[e_name], color='C' + str(e), alpha=0.5, marker=',', ls='--')
+527 plt.legend()
+528 plt.xlim(-0.5, xmax)
+529 ylim = plt.ylim()
+530 plt.ylim(bottom=0.0, top=max(1.0, ylim[1]))
+531 plt.draw()
+532 if save:
+533 fig.savefig(save + "_" + str(e))
534
-535 Parameters
-536 ----------
-537 save : str
-538 saves the figure to a file named 'save' if.
-539 """
-540 if not hasattr(self, 'e_dvalue'):
-541 raise Exception('Run the gamma method first.')
-542 for e, e_name in enumerate(self.mc_names):
-543 fig = plt.figure()
-544 plt.xlabel('W')
-545 plt.ylabel('rho')
-546 length = int(len(self.e_drho[e_name]))
-547 plt.errorbar(np.arange(length), self.e_rho[e_name][:length], yerr=self.e_drho[e_name][:], linewidth=1, capsize=2)
-548 plt.axvline(x=self.e_windowsize[e_name], color='r', alpha=0.25, ls='--', marker=',')
-549 if self.tau_exp[e_name] > 0:
-550 plt.plot([self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name]],
-551 [self.e_rho[e_name][self.e_windowsize[e_name] + 1], 0], 'k-', lw=1)
-552 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
-553 plt.title('Rho ' + e_name + r', tau\_exp=' + str(np.around(self.tau_exp[e_name], decimals=2)))
-554 else:
-555 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
-556 plt.title('Rho ' + e_name + ', S=' + str(np.around(self.S[e_name], decimals=2)))
-557 plt.plot([-0.5, xmax], [0, 0], 'k--', lw=1)
-558 plt.xlim(-0.5, xmax)
-559 plt.draw()
-560 if save:
-561 fig.savefig(save + "_" + str(e))
-562
-563 def plot_rep_dist(self):
-564 """Plot replica distribution for each ensemble with more than one replicum."""
-565 if not hasattr(self, 'e_dvalue'):
-566 raise Exception('Run the gamma method first.')
-567 for e, e_name in enumerate(self.mc_names):
-568 if len(self.e_content[e_name]) == 1:
-569 print('No replica distribution for a single replicum (', e_name, ')')
-570 continue
-571 r_length = []
-572 sub_r_mean = 0
-573 for r, r_name in enumerate(self.e_content[e_name]):
-574 r_length.append(len(self.deltas[r_name]))
-575 sub_r_mean += self.shape[r_name] * self.r_values[r_name]
-576 e_N = np.sum(r_length)
-577 sub_r_mean /= e_N
-578 arr = np.zeros(len(self.e_content[e_name]))
-579 for r, r_name in enumerate(self.e_content[e_name]):
-580 arr[r] = (self.r_values[r_name] - sub_r_mean) / (self.e_dvalue[e_name] * np.sqrt(e_N / self.shape[r_name] - 1))
-581 plt.hist(arr, rwidth=0.8, bins=len(self.e_content[e_name]))
-582 plt.title('Replica distribution' + e_name + ' (mean=0, var=1)')
-583 plt.draw()
-584
-585 def plot_history(self, expand=True):
-586 """Plot derived Monte Carlo history for each ensemble
+535 def plot_rho(self, save=None):
+536 """Plot normalized autocorrelation function time for each ensemble.
+537
+538 Parameters
+539 ----------
+540 save : str
+541 saves the figure to a file named 'save' if.
+542 """
+543 if not hasattr(self, 'e_dvalue'):
+544 raise Exception('Run the gamma method first.')
+545 for e, e_name in enumerate(self.mc_names):
+546 fig = plt.figure()
+547 plt.xlabel('W')
+548 plt.ylabel('rho')
+549 length = int(len(self.e_drho[e_name]))
+550 plt.errorbar(np.arange(length), self.e_rho[e_name][:length], yerr=self.e_drho[e_name][:], linewidth=1, capsize=2)
+551 plt.axvline(x=self.e_windowsize[e_name], color='r', alpha=0.25, ls='--', marker=',')
+552 if self.tau_exp[e_name] > 0:
+553 plt.plot([self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name]],
+554 [self.e_rho[e_name][self.e_windowsize[e_name] + 1], 0], 'k-', lw=1)
+555 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
+556 plt.title('Rho ' + e_name + r', tau\_exp=' + str(np.around(self.tau_exp[e_name], decimals=2)))
+557 else:
+558 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
+559 plt.title('Rho ' + e_name + ', S=' + str(np.around(self.S[e_name], decimals=2)))
+560 plt.plot([-0.5, xmax], [0, 0], 'k--', lw=1)
+561 plt.xlim(-0.5, xmax)
+562 plt.draw()
+563 if save:
+564 fig.savefig(save + "_" + str(e))
+565
+566 def plot_rep_dist(self):
+567 """Plot replica distribution for each ensemble with more than one replicum."""
+568 if not hasattr(self, 'e_dvalue'):
+569 raise Exception('Run the gamma method first.')
+570 for e, e_name in enumerate(self.mc_names):
+571 if len(self.e_content[e_name]) == 1:
+572 print('No replica distribution for a single replicum (', e_name, ')')
+573 continue
+574 r_length = []
+575 sub_r_mean = 0
+576 for r, r_name in enumerate(self.e_content[e_name]):
+577 r_length.append(len(self.deltas[r_name]))
+578 sub_r_mean += self.shape[r_name] * self.r_values[r_name]
+579 e_N = np.sum(r_length)
+580 sub_r_mean /= e_N
+581 arr = np.zeros(len(self.e_content[e_name]))
+582 for r, r_name in enumerate(self.e_content[e_name]):
+583 arr[r] = (self.r_values[r_name] - sub_r_mean) / (self.e_dvalue[e_name] * np.sqrt(e_N / self.shape[r_name] - 1))
+584 plt.hist(arr, rwidth=0.8, bins=len(self.e_content[e_name]))
+585 plt.title('Replica distribution' + e_name + ' (mean=0, var=1)')
+586 plt.draw()
587
-588 Parameters
-589 ----------
-590 expand : bool
-591 show expanded history for irregular Monte Carlo chains (default: True).
-592 """
-593 for e, e_name in enumerate(self.mc_names):
-594 plt.figure()
-595 r_length = []
-596 tmp = []
-597 tmp_expanded = []
-598 for r, r_name in enumerate(self.e_content[e_name]):
-599 tmp.append(self.deltas[r_name] + self.r_values[r_name])
-600 if expand:
-601 tmp_expanded.append(_expand_deltas(self.deltas[r_name], list(self.idl[r_name]), self.shape[r_name]) + self.r_values[r_name])
-602 r_length.append(len(tmp_expanded[-1]))
-603 else:
-604 r_length.append(len(tmp[-1]))
-605 e_N = np.sum(r_length)
-606 x = np.arange(e_N)
-607 y_test = np.concatenate(tmp, axis=0)
-608 if expand:
-609 y = np.concatenate(tmp_expanded, axis=0)
-610 else:
-611 y = y_test
-612 plt.errorbar(x, y, fmt='.', markersize=3)
-613 plt.xlim(-0.5, e_N - 0.5)
-614 plt.title(e_name + f'\nskew: {skew(y_test):.3f} (p={skewtest(y_test).pvalue:.3f}), kurtosis: {kurtosis(y_test):.3f} (p={kurtosistest(y_test).pvalue:.3f})')
-615 plt.draw()
-616
-617 def plot_piechart(self, save=None):
-618 """Plot piechart which shows the fractional contribution of each
-619 ensemble to the error and returns a dictionary containing the fractions.
-620
-621 Parameters
-622 ----------
-623 save : str
-624 saves the figure to a file named 'save' if.
-625 """
-626 if not hasattr(self, 'e_dvalue'):
-627 raise Exception('Run the gamma method first.')
-628 if np.isclose(0.0, self._dvalue, atol=1e-15):
-629 raise Exception('Error is 0.0')
-630 labels = self.e_names
-631 sizes = [self.e_dvalue[name] ** 2 for name in labels] / self._dvalue ** 2
-632 fig1, ax1 = plt.subplots()
-633 ax1.pie(sizes, labels=labels, startangle=90, normalize=True)
-634 ax1.axis('equal')
-635 plt.draw()
-636 if save:
-637 fig1.savefig(save)
-638
-639 return dict(zip(self.e_names, sizes))
-640
-641 def dump(self, filename, datatype="json.gz", description="", **kwargs):
-642 """Dump the Obs to a file 'name' of chosen format.
+588 def plot_history(self, expand=True):
+589 """Plot derived Monte Carlo history for each ensemble
+590
+591 Parameters
+592 ----------
+593 expand : bool
+594 show expanded history for irregular Monte Carlo chains (default: True).
+595 """
+596 for e, e_name in enumerate(self.mc_names):
+597 plt.figure()
+598 r_length = []
+599 tmp = []
+600 tmp_expanded = []
+601 for r, r_name in enumerate(self.e_content[e_name]):
+602 tmp.append(self.deltas[r_name] + self.r_values[r_name])
+603 if expand:
+604 tmp_expanded.append(_expand_deltas(self.deltas[r_name], list(self.idl[r_name]), self.shape[r_name]) + self.r_values[r_name])
+605 r_length.append(len(tmp_expanded[-1]))
+606 else:
+607 r_length.append(len(tmp[-1]))
+608 e_N = np.sum(r_length)
+609 x = np.arange(e_N)
+610 y_test = np.concatenate(tmp, axis=0)
+611 if expand:
+612 y = np.concatenate(tmp_expanded, axis=0)
+613 else:
+614 y = y_test
+615 plt.errorbar(x, y, fmt='.', markersize=3)
+616 plt.xlim(-0.5, e_N - 0.5)
+617 plt.title(e_name + f'\nskew: {skew(y_test):.3f} (p={skewtest(y_test).pvalue:.3f}), kurtosis: {kurtosis(y_test):.3f} (p={kurtosistest(y_test).pvalue:.3f})')
+618 plt.draw()
+619
+620 def plot_piechart(self, save=None):
+621 """Plot piechart which shows the fractional contribution of each
+622 ensemble to the error and returns a dictionary containing the fractions.
+623
+624 Parameters
+625 ----------
+626 save : str
+627 saves the figure to a file named 'save' if.
+628 """
+629 if not hasattr(self, 'e_dvalue'):
+630 raise Exception('Run the gamma method first.')
+631 if np.isclose(0.0, self._dvalue, atol=1e-15):
+632 raise Exception('Error is 0.0')
+633 labels = self.e_names
+634 sizes = [self.e_dvalue[name] ** 2 for name in labels] / self._dvalue ** 2
+635 fig1, ax1 = plt.subplots()
+636 ax1.pie(sizes, labels=labels, startangle=90, normalize=True)
+637 ax1.axis('equal')
+638 plt.draw()
+639 if save:
+640 fig1.savefig(save)
+641
+642 return dict(zip(self.e_names, sizes))
643
-644 Parameters
-645 ----------
-646 filename : str
-647 name of the file to be saved.
-648 datatype : str
-649 Format of the exported file. Supported formats include
-650 "json.gz" and "pickle"
-651 description : str
-652 Description for output file, only relevant for json.gz format.
-653 path : str
-654 specifies a custom path for the file (default '.')
-655 """
-656 if 'path' in kwargs:
-657 file_name = kwargs.get('path') + '/' + filename
-658 else:
-659 file_name = filename
-660
-661 if datatype == "json.gz":
-662 from .input.json import dump_to_json
-663 dump_to_json([self], file_name, description=description)
-664 elif datatype == "pickle":
-665 with open(file_name + '.p', 'wb') as fb:
-666 pickle.dump(self, fb)
-667 else:
-668 raise Exception("Unknown datatype " + str(datatype))
-669
-670 def export_jackknife(self):
-671 """Export jackknife samples from the Obs
+644 def dump(self, filename, datatype="json.gz", description="", **kwargs):
+645 """Dump the Obs to a file 'name' of chosen format.
+646
+647 Parameters
+648 ----------
+649 filename : str
+650 name of the file to be saved.
+651 datatype : str
+652 Format of the exported file. Supported formats include
+653 "json.gz" and "pickle"
+654 description : str
+655 Description for output file, only relevant for json.gz format.
+656 path : str
+657 specifies a custom path for the file (default '.')
+658 """
+659 if 'path' in kwargs:
+660 file_name = kwargs.get('path') + '/' + filename
+661 else:
+662 file_name = filename
+663
+664 if datatype == "json.gz":
+665 from .input.json import dump_to_json
+666 dump_to_json([self], file_name, description=description)
+667 elif datatype == "pickle":
+668 with open(file_name + '.p', 'wb') as fb:
+669 pickle.dump(self, fb)
+670 else:
+671 raise Exception("Unknown datatype " + str(datatype))
672
-673 Returns
-674 -------
-675 numpy.ndarray
-676 Returns a numpy array of length N + 1 where N is the number of samples
-677 for the given ensemble and replicum. The zeroth entry of the array contains
-678 the mean value of the Obs, entries 1 to N contain the N jackknife samples
-679 derived from the Obs. The current implementation only works for observables
-680 defined on exactly one ensemble and replicum. The derived jackknife samples
-681 should agree with samples from a full jackknife analysis up to O(1/N).
-682 """
-683
-684 if len(self.names) != 1:
-685 raise Exception("'export_jackknife' is only implemented for Obs defined on one ensemble and replicum.")
+673 def export_jackknife(self):
+674 """Export jackknife samples from the Obs
+675
+676 Returns
+677 -------
+678 numpy.ndarray
+679 Returns a numpy array of length N + 1 where N is the number of samples
+680 for the given ensemble and replicum. The zeroth entry of the array contains
+681 the mean value of the Obs, entries 1 to N contain the N jackknife samples
+682 derived from the Obs. The current implementation only works for observables
+683 defined on exactly one ensemble and replicum. The derived jackknife samples
+684 should agree with samples from a full jackknife analysis up to O(1/N).
+685 """
686
-687 name = self.names[0]
-688 full_data = self.deltas[name] + self.r_values[name]
-689 n = full_data.size
-690 mean = self.value
-691 tmp_jacks = np.zeros(n + 1)
-692 tmp_jacks[0] = mean
-693 tmp_jacks[1:] = (n * mean - full_data) / (n - 1)
-694 return tmp_jacks
-695
-696 def __float__(self):
-697 return float(self.value)
+687 if len(self.names) != 1:
+688 raise Exception("'export_jackknife' is only implemented for Obs defined on one ensemble and replicum.")
+689
+690 name = self.names[0]
+691 full_data = self.deltas[name] + self.r_values[name]
+692 n = full_data.size
+693 mean = self.value
+694 tmp_jacks = np.zeros(n + 1)
+695 tmp_jacks[0] = mean
+696 tmp_jacks[1:] = (n * mean - full_data) / (n - 1)
+697 return tmp_jacks
698
-699 def __repr__(self):
-700 return 'Obs[' + str(self) + ']'
+699 def __float__(self):
+700 return float(self.value)
701
-702 def __str__(self):
-703 return _format_uncertainty(self.value, self._dvalue)
+702 def __repr__(self):
+703 return 'Obs[' + str(self) + ']'
704
-705 def __hash__(self):
-706 hash_tuple = (np.array([self.value]).astype(np.float32).data.tobytes(),)
-707 hash_tuple += tuple([o.astype(np.float32).data.tobytes() for o in self.deltas.values()])
-708 hash_tuple += tuple([np.array([o.errsq()]).astype(np.float32).data.tobytes() for o in self.covobs.values()])
-709 hash_tuple += tuple([o.encode() for o in self.names])
-710 m = hashlib.md5()
-711 [m.update(o) for o in hash_tuple]
-712 return int(m.hexdigest(), 16) & 0xFFFFFFFF
-713
-714 # Overload comparisons
-715 def __lt__(self, other):
-716 return self.value < other
-717
-718 def __le__(self, other):
-719 return self.value <= other
+705 def __str__(self):
+706 return _format_uncertainty(self.value, self._dvalue)
+707
+708 def __hash__(self):
+709 hash_tuple = (np.array([self.value]).astype(np.float32).data.tobytes(),)
+710 hash_tuple += tuple([o.astype(np.float32).data.tobytes() for o in self.deltas.values()])
+711 hash_tuple += tuple([np.array([o.errsq()]).astype(np.float32).data.tobytes() for o in self.covobs.values()])
+712 hash_tuple += tuple([o.encode() for o in self.names])
+713 m = hashlib.md5()
+714 [m.update(o) for o in hash_tuple]
+715 return int(m.hexdigest(), 16) & 0xFFFFFFFF
+716
+717 # Overload comparisons
+718 def __lt__(self, other):
+719 return self.value < other
720
-721 def __gt__(self, other):
-722 return self.value > other
+721 def __le__(self, other):
+722 return self.value <= other
723
-724 def __ge__(self, other):
-725 return self.value >= other
+724 def __gt__(self, other):
+725 return self.value > other
726
-727 def __eq__(self, other):
-728 return (self - other).is_zero()
+727 def __ge__(self, other):
+728 return self.value >= other
729
-730 def __ne__(self, other):
-731 return not (self - other).is_zero()
+730 def __eq__(self, other):
+731 return (self - other).is_zero()
732
-733 # Overload math operations
-734 def __add__(self, y):
-735 if isinstance(y, Obs):
-736 return derived_observable(lambda x, **kwargs: x[0] + x[1], [self, y], man_grad=[1, 1])
-737 else:
-738 if isinstance(y, np.ndarray):
-739 return np.array([self + o for o in y])
-740 elif y.__class__.__name__ in ['Corr', 'CObs']:
-741 return NotImplemented
-742 else:
-743 return derived_observable(lambda x, **kwargs: x[0] + y, [self], man_grad=[1])
-744
-745 def __radd__(self, y):
-746 return self + y
+733 def __ne__(self, other):
+734 return not (self - other).is_zero()
+735
+736 # Overload math operations
+737 def __add__(self, y):
+738 if isinstance(y, Obs):
+739 return derived_observable(lambda x, **kwargs: x[0] + x[1], [self, y], man_grad=[1, 1])
+740 else:
+741 if isinstance(y, np.ndarray):
+742 return np.array([self + o for o in y])
+743 elif y.__class__.__name__ in ['Corr', 'CObs']:
+744 return NotImplemented
+745 else:
+746 return derived_observable(lambda x, **kwargs: x[0] + y, [self], man_grad=[1])
747
-748 def __mul__(self, y):
-749 if isinstance(y, Obs):
-750 return derived_observable(lambda x, **kwargs: x[0] * x[1], [self, y], man_grad=[y.value, self.value])
-751 else:
-752 if isinstance(y, np.ndarray):
-753 return np.array([self * o for o in y])
-754 elif isinstance(y, complex):
-755 return CObs(self * y.real, self * y.imag)
-756 elif y.__class__.__name__ in ['Corr', 'CObs']:
-757 return NotImplemented
-758 else:
-759 return derived_observable(lambda x, **kwargs: x[0] * y, [self], man_grad=[y])
-760
-761 def __rmul__(self, y):
-762 return self * y
+748 def __radd__(self, y):
+749 return self + y
+750
+751 def __mul__(self, y):
+752 if isinstance(y, Obs):
+753 return derived_observable(lambda x, **kwargs: x[0] * x[1], [self, y], man_grad=[y.value, self.value])
+754 else:
+755 if isinstance(y, np.ndarray):
+756 return np.array([self * o for o in y])
+757 elif isinstance(y, complex):
+758 return CObs(self * y.real, self * y.imag)
+759 elif y.__class__.__name__ in ['Corr', 'CObs']:
+760 return NotImplemented
+761 else:
+762 return derived_observable(lambda x, **kwargs: x[0] * y, [self], man_grad=[y])
763
-764 def __sub__(self, y):
-765 if isinstance(y, Obs):
-766 return derived_observable(lambda x, **kwargs: x[0] - x[1], [self, y], man_grad=[1, -1])
-767 else:
-768 if isinstance(y, np.ndarray):
-769 return np.array([self - o for o in y])
-770 elif y.__class__.__name__ in ['Corr', 'CObs']:
-771 return NotImplemented
-772 else:
-773 return derived_observable(lambda x, **kwargs: x[0] - y, [self], man_grad=[1])
-774
-775 def __rsub__(self, y):
-776 return -1 * (self - y)
+764 def __rmul__(self, y):
+765 return self * y
+766
+767 def __sub__(self, y):
+768 if isinstance(y, Obs):
+769 return derived_observable(lambda x, **kwargs: x[0] - x[1], [self, y], man_grad=[1, -1])
+770 else:
+771 if isinstance(y, np.ndarray):
+772 return np.array([self - o for o in y])
+773 elif y.__class__.__name__ in ['Corr', 'CObs']:
+774 return NotImplemented
+775 else:
+776 return derived_observable(lambda x, **kwargs: x[0] - y, [self], man_grad=[1])
777
-778 def __pos__(self):
-779 return self
+778 def __rsub__(self, y):
+779 return -1 * (self - y)
780
-781 def __neg__(self):
-782 return -1 * self
+781 def __pos__(self):
+782 return self
783
-784 def __truediv__(self, y):
-785 if isinstance(y, Obs):
-786 return derived_observable(lambda x, **kwargs: x[0] / x[1], [self, y], man_grad=[1 / y.value, - self.value / y.value ** 2])
-787 else:
-788 if isinstance(y, np.ndarray):
-789 return np.array([self / o for o in y])
-790 elif y.__class__.__name__ in ['Corr', 'CObs']:
-791 return NotImplemented
-792 else:
-793 return derived_observable(lambda x, **kwargs: x[0] / y, [self], man_grad=[1 / y])
-794
-795 def __rtruediv__(self, y):
-796 if isinstance(y, Obs):
-797 return derived_observable(lambda x, **kwargs: x[0] / x[1], [y, self], man_grad=[1 / self.value, - y.value / self.value ** 2])
-798 else:
-799 if isinstance(y, np.ndarray):
-800 return np.array([o / self for o in y])
-801 elif y.__class__.__name__ in ['Corr', 'CObs']:
-802 return NotImplemented
-803 else:
-804 return derived_observable(lambda x, **kwargs: y / x[0], [self], man_grad=[-y / self.value ** 2])
-805
-806 def __pow__(self, y):
-807 if isinstance(y, Obs):
-808 return derived_observable(lambda x: x[0] ** x[1], [self, y])
-809 else:
-810 return derived_observable(lambda x: x[0] ** y, [self])
-811
-812 def __rpow__(self, y):
-813 if isinstance(y, Obs):
-814 return derived_observable(lambda x: x[0] ** x[1], [y, self])
-815 else:
-816 return derived_observable(lambda x: y ** x[0], [self])
-817
-818 def __abs__(self):
-819 return derived_observable(lambda x: anp.abs(x[0]), [self])
+784 def __neg__(self):
+785 return -1 * self
+786
+787 def __truediv__(self, y):
+788 if isinstance(y, Obs):
+789 return derived_observable(lambda x, **kwargs: x[0] / x[1], [self, y], man_grad=[1 / y.value, - self.value / y.value ** 2])
+790 else:
+791 if isinstance(y, np.ndarray):
+792 return np.array([self / o for o in y])
+793 elif y.__class__.__name__ in ['Corr', 'CObs']:
+794 return NotImplemented
+795 else:
+796 return derived_observable(lambda x, **kwargs: x[0] / y, [self], man_grad=[1 / y])
+797
+798 def __rtruediv__(self, y):
+799 if isinstance(y, Obs):
+800 return derived_observable(lambda x, **kwargs: x[0] / x[1], [y, self], man_grad=[1 / self.value, - y.value / self.value ** 2])
+801 else:
+802 if isinstance(y, np.ndarray):
+803 return np.array([o / self for o in y])
+804 elif y.__class__.__name__ in ['Corr', 'CObs']:
+805 return NotImplemented
+806 else:
+807 return derived_observable(lambda x, **kwargs: y / x[0], [self], man_grad=[-y / self.value ** 2])
+808
+809 def __pow__(self, y):
+810 if isinstance(y, Obs):
+811 return derived_observable(lambda x: x[0] ** x[1], [self, y])
+812 else:
+813 return derived_observable(lambda x: x[0] ** y, [self])
+814
+815 def __rpow__(self, y):
+816 if isinstance(y, Obs):
+817 return derived_observable(lambda x: x[0] ** x[1], [y, self])
+818 else:
+819 return derived_observable(lambda x: y ** x[0], [self])
820
-821 # Overload numpy functions
-822 def sqrt(self):
-823 return derived_observable(lambda x, **kwargs: np.sqrt(x[0]), [self], man_grad=[1 / 2 / np.sqrt(self.value)])
-824
-825 def log(self):
-826 return derived_observable(lambda x, **kwargs: np.log(x[0]), [self], man_grad=[1 / self.value])
+821 def __abs__(self):
+822 return derived_observable(lambda x: anp.abs(x[0]), [self])
+823
+824 # Overload numpy functions
+825 def sqrt(self):
+826 return derived_observable(lambda x, **kwargs: np.sqrt(x[0]), [self], man_grad=[1 / 2 / np.sqrt(self.value)])
827
-828 def exp(self):
-829 return derived_observable(lambda x, **kwargs: np.exp(x[0]), [self], man_grad=[np.exp(self.value)])
+828 def log(self):
+829 return derived_observable(lambda x, **kwargs: np.log(x[0]), [self], man_grad=[1 / self.value])
830
-831 def sin(self):
-832 return derived_observable(lambda x, **kwargs: np.sin(x[0]), [self], man_grad=[np.cos(self.value)])
+831 def exp(self):
+832 return derived_observable(lambda x, **kwargs: np.exp(x[0]), [self], man_grad=[np.exp(self.value)])
833
-834 def cos(self):
-835 return derived_observable(lambda x, **kwargs: np.cos(x[0]), [self], man_grad=[-np.sin(self.value)])
+834 def sin(self):
+835 return derived_observable(lambda x, **kwargs: np.sin(x[0]), [self], man_grad=[np.cos(self.value)])
836
-837 def tan(self):
-838 return derived_observable(lambda x, **kwargs: np.tan(x[0]), [self], man_grad=[1 / np.cos(self.value) ** 2])
+837 def cos(self):
+838 return derived_observable(lambda x, **kwargs: np.cos(x[0]), [self], man_grad=[-np.sin(self.value)])
839
-840 def arcsin(self):
-841 return derived_observable(lambda x: anp.arcsin(x[0]), [self])
+840 def tan(self):
+841 return derived_observable(lambda x, **kwargs: np.tan(x[0]), [self], man_grad=[1 / np.cos(self.value) ** 2])
842
-843 def arccos(self):
-844 return derived_observable(lambda x: anp.arccos(x[0]), [self])
+843 def arcsin(self):
+844 return derived_observable(lambda x: anp.arcsin(x[0]), [self])
845
-846 def arctan(self):
-847 return derived_observable(lambda x: anp.arctan(x[0]), [self])
+846 def arccos(self):
+847 return derived_observable(lambda x: anp.arccos(x[0]), [self])
848
-849 def sinh(self):
-850 return derived_observable(lambda x, **kwargs: np.sinh(x[0]), [self], man_grad=[np.cosh(self.value)])
+849 def arctan(self):
+850 return derived_observable(lambda x: anp.arctan(x[0]), [self])
851
-852 def cosh(self):
-853 return derived_observable(lambda x, **kwargs: np.cosh(x[0]), [self], man_grad=[np.sinh(self.value)])
+852 def sinh(self):
+853 return derived_observable(lambda x, **kwargs: np.sinh(x[0]), [self], man_grad=[np.cosh(self.value)])
854
-855 def tanh(self):
-856 return derived_observable(lambda x, **kwargs: np.tanh(x[0]), [self], man_grad=[1 / np.cosh(self.value) ** 2])
+855 def cosh(self):
+856 return derived_observable(lambda x, **kwargs: np.cosh(x[0]), [self], man_grad=[np.sinh(self.value)])
857
-858 def arcsinh(self):
-859 return derived_observable(lambda x: anp.arcsinh(x[0]), [self])
+858 def tanh(self):
+859 return derived_observable(lambda x, **kwargs: np.tanh(x[0]), [self], man_grad=[1 / np.cosh(self.value) ** 2])
860
-861 def arccosh(self):
-862 return derived_observable(lambda x: anp.arccosh(x[0]), [self])
+861 def arcsinh(self):
+862 return derived_observable(lambda x: anp.arcsinh(x[0]), [self])
863
-864 def arctanh(self):
-865 return derived_observable(lambda x: anp.arctanh(x[0]), [self])
+864 def arccosh(self):
+865 return derived_observable(lambda x: anp.arccosh(x[0]), [self])
+866
+867 def arctanh(self):
+868 return derived_observable(lambda x: anp.arctanh(x[0]), [self])
60 def __init__(self, samples, names, idl=None, **kwargs):
- 61 """ Initialize Obs object.
- 62
- 63 Parameters
- 64 ----------
- 65 samples : list
- 66 list of numpy arrays containing the Monte Carlo samples
- 67 names : list
- 68 list of strings labeling the individual samples
- 69 idl : list, optional
- 70 list of ranges or lists on which the samples are defined
- 71 """
- 72
- 73 if kwargs.get("means") is None and len(samples):
- 74 if len(samples) != len(names):
- 75 raise Exception('Length of samples and names incompatible.')
- 76 if idl is not None:
- 77 if len(idl) != len(names):
- 78 raise Exception('Length of idl incompatible with samples and names.')
- 79 name_length = len(names)
- 80 if name_length > 1:
- 81 if name_length != len(set(names)):
- 82 raise Exception('names are not unique.')
- 83 if not all(isinstance(x, str) for x in names):
- 84 raise TypeError('All names have to be strings.')
- 85 else:
- 86 if not isinstance(names[0], str):
+ 63 def __init__(self, samples, names, idl=None, **kwargs):
+ 64 """ Initialize Obs object.
+ 65
+ 66 Parameters
+ 67 ----------
+ 68 samples : list
+ 69 list of numpy arrays containing the Monte Carlo samples
+ 70 names : list
+ 71 list of strings labeling the individual samples
+ 72 idl : list, optional
+ 73 list of ranges or lists on which the samples are defined
+ 74 """
+ 75
+ 76 if kwargs.get("means") is None and len(samples):
+ 77 if len(samples) != len(names):
+ 78 raise Exception('Length of samples and names incompatible.')
+ 79 if idl is not None:
+ 80 if len(idl) != len(names):
+ 81 raise Exception('Length of idl incompatible with samples and names.')
+ 82 name_length = len(names)
+ 83 if name_length > 1:
+ 84 if name_length != len(set(names)):
+ 85 raise Exception('names are not unique.')
+ 86 if not all(isinstance(x, str) for x in names):
87 raise TypeError('All names have to be strings.')
- 88 if min(len(x) for x in samples) <= 4:
- 89 raise Exception('Samples have to have at least 5 entries.')
- 90
- 91 self.names = sorted(names)
- 92 self.shape = {}
- 93 self.r_values = {}
- 94 self.deltas = {}
- 95 self._covobs = {}
- 96
- 97 self._value = 0
- 98 self.N = 0
- 99 self.is_merged = {}
-100 self.idl = {}
-101 if idl is not None:
-102 for name, idx in sorted(zip(names, idl)):
-103 if isinstance(idx, range):
-104 self.idl[name] = idx
-105 elif isinstance(idx, (list, np.ndarray)):
-106 dc = np.unique(np.diff(idx))
-107 if np.any(dc < 0):
-108 raise Exception("Unsorted idx for idl[%s]" % (name))
-109 if len(dc) == 1:
-110 self.idl[name] = range(idx[0], idx[-1] + dc[0], dc[0])
-111 else:
-112 self.idl[name] = list(idx)
-113 else:
-114 raise Exception('incompatible type for idl[%s].' % (name))
-115 else:
-116 for name, sample in sorted(zip(names, samples)):
-117 self.idl[name] = range(1, len(sample) + 1)
-118
-119 if kwargs.get("means") is not None:
-120 for name, sample, mean in sorted(zip(names, samples, kwargs.get("means"))):
-121 self.shape[name] = len(self.idl[name])
-122 self.N += self.shape[name]
-123 self.r_values[name] = mean
-124 self.deltas[name] = sample
-125 else:
-126 for name, sample in sorted(zip(names, samples)):
-127 self.shape[name] = len(self.idl[name])
-128 self.N += self.shape[name]
-129 if len(sample) != self.shape[name]:
-130 raise Exception('Incompatible samples and idx for %s: %d vs. %d' % (name, len(sample), self.shape[name]))
-131 self.r_values[name] = np.mean(sample)
-132 self.deltas[name] = sample - self.r_values[name]
-133 self._value += self.shape[name] * self.r_values[name]
-134 self._value /= self.N
-135
-136 self._dvalue = 0.0
-137 self.ddvalue = 0.0
-138 self.reweighted = False
-139
-140 self.tag = None
+ 88 else:
+ 89 if not isinstance(names[0], str):
+ 90 raise TypeError('All names have to be strings.')
+ 91 if min(len(x) for x in samples) <= 4:
+ 92 raise Exception('Samples have to have at least 5 entries.')
+ 93
+ 94 self.names = sorted(names)
+ 95 self.shape = {}
+ 96 self.r_values = {}
+ 97 self.deltas = {}
+ 98 self._covobs = {}
+ 99
+100 self._value = 0
+101 self.N = 0
+102 self.is_merged = {}
+103 self.idl = {}
+104 if idl is not None:
+105 for name, idx in sorted(zip(names, idl)):
+106 if isinstance(idx, range):
+107 self.idl[name] = idx
+108 elif isinstance(idx, (list, np.ndarray)):
+109 dc = np.unique(np.diff(idx))
+110 if np.any(dc < 0):
+111 raise Exception("Unsorted idx for idl[%s]" % (name))
+112 if len(dc) == 1:
+113 self.idl[name] = range(idx[0], idx[-1] + dc[0], dc[0])
+114 else:
+115 self.idl[name] = list(idx)
+116 else:
+117 raise Exception('incompatible type for idl[%s].' % (name))
+118 else:
+119 for name, sample in sorted(zip(names, samples)):
+120 self.idl[name] = range(1, len(sample) + 1)
+121
+122 if kwargs.get("means") is not None:
+123 for name, sample, mean in sorted(zip(names, samples, kwargs.get("means"))):
+124 self.shape[name] = len(self.idl[name])
+125 self.N += self.shape[name]
+126 self.r_values[name] = mean
+127 self.deltas[name] = sample
+128 else:
+129 for name, sample in sorted(zip(names, samples)):
+130 self.shape[name] = len(self.idl[name])
+131 self.N += self.shape[name]
+132 if len(sample) != self.shape[name]:
+133 raise Exception('Incompatible samples and idx for %s: %d vs. %d' % (name, len(sample), self.shape[name]))
+134 self.r_values[name] = np.mean(sample)
+135 self.deltas[name] = sample - self.r_values[name]
+136 self._value += self.shape[name] * self.r_values[name]
+137 self._value /= self.N
+138
+139 self._dvalue = 0.0
+140 self.ddvalue = 0.0
+141 self.reweighted = False
+142
+143 self.tag = None
175 def gamma_method(self, **kwargs):
-176 """Estimate the error and related properties of the Obs.
-177
-178 Parameters
-179 ----------
-180 S : float
-181 specifies a custom value for the parameter S (default 2.0).
-182 If set to 0 it is assumed that the data exhibits no
-183 autocorrelation. In this case the error estimates coincides
-184 with the sample standard error.
-185 tau_exp : float
-186 positive value triggers the critical slowing down analysis
-187 (default 0.0).
-188 N_sigma : float
-189 number of standard deviations from zero until the tail is
-190 attached to the autocorrelation function (default 1).
-191 fft : bool
-192 determines whether the fft algorithm is used for the computation
-193 of the autocorrelation function (default True)
-194 """
-195
-196 e_content = self.e_content
-197 self.e_dvalue = {}
-198 self.e_ddvalue = {}
-199 self.e_tauint = {}
-200 self.e_dtauint = {}
-201 self.e_windowsize = {}
-202 self.e_n_tauint = {}
-203 self.e_n_dtauint = {}
-204 e_gamma = {}
-205 self.e_rho = {}
-206 self.e_drho = {}
-207 self._dvalue = 0
-208 self.ddvalue = 0
-209
-210 self.S = {}
-211 self.tau_exp = {}
-212 self.N_sigma = {}
-213
-214 if kwargs.get('fft') is False:
-215 fft = False
-216 else:
-217 fft = True
-218
-219 def _parse_kwarg(kwarg_name):
-220 if kwarg_name in kwargs:
-221 tmp = kwargs.get(kwarg_name)
-222 if isinstance(tmp, (int, float)):
-223 if tmp < 0:
-224 raise Exception(kwarg_name + ' has to be larger or equal to 0.')
-225 for e, e_name in enumerate(self.e_names):
-226 getattr(self, kwarg_name)[e_name] = tmp
-227 else:
-228 raise TypeError(kwarg_name + ' is not in proper format.')
-229 else:
-230 for e, e_name in enumerate(self.e_names):
-231 if e_name in getattr(Obs, kwarg_name + '_dict'):
-232 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_dict')[e_name]
-233 else:
-234 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_global')
-235
-236 _parse_kwarg('S')
-237 _parse_kwarg('tau_exp')
-238 _parse_kwarg('N_sigma')
-239
-240 for e, e_name in enumerate(self.mc_names):
-241 r_length = []
-242 for r_name in e_content[e_name]:
-243 if isinstance(self.idl[r_name], range):
-244 r_length.append(len(self.idl[r_name]))
-245 else:
-246 r_length.append((self.idl[r_name][-1] - self.idl[r_name][0] + 1))
-247
-248 e_N = np.sum([self.shape[r_name] for r_name in e_content[e_name]])
-249 w_max = max(r_length) // 2
-250 e_gamma[e_name] = np.zeros(w_max)
-251 self.e_rho[e_name] = np.zeros(w_max)
-252 self.e_drho[e_name] = np.zeros(w_max)
-253
-254 for r_name in e_content[e_name]:
-255 e_gamma[e_name] += self._calc_gamma(self.deltas[r_name], self.idl[r_name], self.shape[r_name], w_max, fft)
+ 178 def gamma_method(self, **kwargs):
+179 """Estimate the error and related properties of the Obs.
+180
+181 Parameters
+182 ----------
+183 S : float
+184 specifies a custom value for the parameter S (default 2.0).
+185 If set to 0 it is assumed that the data exhibits no
+186 autocorrelation. In this case the error estimates coincides
+187 with the sample standard error.
+188 tau_exp : float
+189 positive value triggers the critical slowing down analysis
+190 (default 0.0).
+191 N_sigma : float
+192 number of standard deviations from zero until the tail is
+193 attached to the autocorrelation function (default 1).
+194 fft : bool
+195 determines whether the fft algorithm is used for the computation
+196 of the autocorrelation function (default True)
+197 """
+198
+199 e_content = self.e_content
+200 self.e_dvalue = {}
+201 self.e_ddvalue = {}
+202 self.e_tauint = {}
+203 self.e_dtauint = {}
+204 self.e_windowsize = {}
+205 self.e_n_tauint = {}
+206 self.e_n_dtauint = {}
+207 e_gamma = {}
+208 self.e_rho = {}
+209 self.e_drho = {}
+210 self._dvalue = 0
+211 self.ddvalue = 0
+212
+213 self.S = {}
+214 self.tau_exp = {}
+215 self.N_sigma = {}
+216
+217 if kwargs.get('fft') is False:
+218 fft = False
+219 else:
+220 fft = True
+221
+222 def _parse_kwarg(kwarg_name):
+223 if kwarg_name in kwargs:
+224 tmp = kwargs.get(kwarg_name)
+225 if isinstance(tmp, (int, float)):
+226 if tmp < 0:
+227 raise Exception(kwarg_name + ' has to be larger or equal to 0.')
+228 for e, e_name in enumerate(self.e_names):
+229 getattr(self, kwarg_name)[e_name] = tmp
+230 else:
+231 raise TypeError(kwarg_name + ' is not in proper format.')
+232 else:
+233 for e, e_name in enumerate(self.e_names):
+234 if e_name in getattr(Obs, kwarg_name + '_dict'):
+235 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_dict')[e_name]
+236 else:
+237 getattr(self, kwarg_name)[e_name] = getattr(Obs, kwarg_name + '_global')
+238
+239 _parse_kwarg('S')
+240 _parse_kwarg('tau_exp')
+241 _parse_kwarg('N_sigma')
+242
+243 for e, e_name in enumerate(self.mc_names):
+244 r_length = []
+245 for r_name in e_content[e_name]:
+246 if isinstance(self.idl[r_name], range):
+247 r_length.append(len(self.idl[r_name]))
+248 else:
+249 r_length.append((self.idl[r_name][-1] - self.idl[r_name][0] + 1))
+250
+251 e_N = np.sum([self.shape[r_name] for r_name in e_content[e_name]])
+252 w_max = max(r_length) // 2
+253 e_gamma[e_name] = np.zeros(w_max)
+254 self.e_rho[e_name] = np.zeros(w_max)
+255 self.e_drho[e_name] = np.zeros(w_max)
256
-257 gamma_div = np.zeros(w_max)
-258 for r_name in e_content[e_name]:
-259 gamma_div += self._calc_gamma(np.ones((self.shape[r_name])), self.idl[r_name], self.shape[r_name], w_max, fft)
-260 gamma_div[gamma_div < 1] = 1.0
-261 e_gamma[e_name] /= gamma_div[:w_max]
-262
-263 if np.abs(e_gamma[e_name][0]) < 10 * np.finfo(float).tiny: # Prevent division by zero
-264 self.e_tauint[e_name] = 0.5
-265 self.e_dtauint[e_name] = 0.0
-266 self.e_dvalue[e_name] = 0.0
-267 self.e_ddvalue[e_name] = 0.0
-268 self.e_windowsize[e_name] = 0
-269 continue
-270
-271 gaps = []
-272 for r_name in e_content[e_name]:
-273 if isinstance(self.idl[r_name], range):
-274 gaps.append(1)
-275 else:
-276 gaps.append(np.min(np.diff(self.idl[r_name])))
-277
-278 if not np.all([gi == gaps[0] for gi in gaps]):
-279 raise Exception(f"Replica for ensemble {e_name} are not equally spaced.", gaps)
-280 else:
-281 gapsize = gaps[0]
-282
-283 self.e_rho[e_name] = e_gamma[e_name][:w_max] / e_gamma[e_name][0]
-284 self.e_n_tauint[e_name] = np.cumsum(np.concatenate(([0.5], self.e_rho[e_name][1:])))
-285 # Make sure no entry of tauint is smaller than 0.5
-286 self.e_n_tauint[e_name][self.e_n_tauint[e_name] <= 0.5] = 0.5 + np.finfo(np.float64).eps
-287 # hep-lat/0306017 eq. (42)
-288 self.e_n_dtauint[e_name] = self.e_n_tauint[e_name] * 2 * np.sqrt(np.abs(np.arange(w_max) / gapsize + 0.5 - self.e_n_tauint[e_name]) / e_N)
-289 self.e_n_dtauint[e_name][0] = 0.0
-290
-291 def _compute_drho(i):
-292 tmp = self.e_rho[e_name][i + 1:w_max] + np.concatenate([self.e_rho[e_name][i - 1::-1], self.e_rho[e_name][1:w_max - 2 * i]]) - 2 * self.e_rho[e_name][i] * self.e_rho[e_name][1:w_max - i]
-293 self.e_drho[e_name][i] = np.sqrt(np.sum(tmp ** 2) / e_N)
-294
-295 _compute_drho(gapsize)
-296 if self.tau_exp[e_name] > 0:
-297 texp = self.tau_exp[e_name]
-298 # Critical slowing down analysis
-299 if w_max // 2 <= 1:
-300 raise Exception("Need at least 8 samples for tau_exp error analysis")
-301 for n in range(gapsize, w_max // 2, gapsize):
-302 _compute_drho(n + gapsize)
-303 if (self.e_rho[e_name][n] - self.N_sigma[e_name] * self.e_drho[e_name][n]) < 0 or n >= w_max // 2 - 2:
-304 # Bias correction hep-lat/0306017 eq. (49) included
-305 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) + texp * np.abs(self.e_rho[e_name][n + 1]) # The absolute makes sure, that the tail contribution is always positive
-306 self.e_dtauint[e_name] = np.sqrt(self.e_n_dtauint[e_name][n] ** 2 + texp ** 2 * self.e_drho[e_name][n + 1] ** 2)
-307 # Error of tau_exp neglected so far, missing term: self.e_rho[e_name][n + 1] ** 2 * d_tau_exp ** 2
-308 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
-309 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
-310 self.e_windowsize[e_name] = n
-311 break
-312 else:
-313 if self.S[e_name] == 0.0:
-314 self.e_tauint[e_name] = 0.5
-315 self.e_dtauint[e_name] = 0.0
-316 self.e_dvalue[e_name] = np.sqrt(e_gamma[e_name][0] / (e_N - 1))
-317 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt(0.5 / e_N)
-318 self.e_windowsize[e_name] = 0
-319 else:
-320 # Standard automatic windowing procedure
-321 tau = self.S[e_name] / np.log((2 * self.e_n_tauint[e_name][gapsize::gapsize] + 1) / (2 * self.e_n_tauint[e_name][gapsize::gapsize] - 1))
-322 g_w = np.exp(- np.arange(1, len(tau) + 1) / tau) - tau / np.sqrt(np.arange(1, len(tau) + 1) * e_N)
-323 for n in range(1, w_max):
-324 if n < w_max // 2 - 2:
-325 _compute_drho(gapsize * n + gapsize)
-326 if g_w[n - 1] < 0 or n >= w_max - 1:
-327 n *= gapsize
-328 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) # Bias correction hep-lat/0306017 eq. (49)
-329 self.e_dtauint[e_name] = self.e_n_dtauint[e_name][n]
-330 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
-331 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
-332 self.e_windowsize[e_name] = n
-333 break
-334
-335 self._dvalue += self.e_dvalue[e_name] ** 2
-336 self.ddvalue += (self.e_dvalue[e_name] * self.e_ddvalue[e_name]) ** 2
+257 for r_name in e_content[e_name]:
+258 e_gamma[e_name] += self._calc_gamma(self.deltas[r_name], self.idl[r_name], self.shape[r_name], w_max, fft)
+259
+260 gamma_div = np.zeros(w_max)
+261 for r_name in e_content[e_name]:
+262 gamma_div += self._calc_gamma(np.ones((self.shape[r_name])), self.idl[r_name], self.shape[r_name], w_max, fft)
+263 gamma_div[gamma_div < 1] = 1.0
+264 e_gamma[e_name] /= gamma_div[:w_max]
+265
+266 if np.abs(e_gamma[e_name][0]) < 10 * np.finfo(float).tiny: # Prevent division by zero
+267 self.e_tauint[e_name] = 0.5
+268 self.e_dtauint[e_name] = 0.0
+269 self.e_dvalue[e_name] = 0.0
+270 self.e_ddvalue[e_name] = 0.0
+271 self.e_windowsize[e_name] = 0
+272 continue
+273
+274 gaps = []
+275 for r_name in e_content[e_name]:
+276 if isinstance(self.idl[r_name], range):
+277 gaps.append(1)
+278 else:
+279 gaps.append(np.min(np.diff(self.idl[r_name])))
+280
+281 if not np.all([gi == gaps[0] for gi in gaps]):
+282 raise Exception(f"Replica for ensemble {e_name} are not equally spaced.", gaps)
+283 else:
+284 gapsize = gaps[0]
+285
+286 self.e_rho[e_name] = e_gamma[e_name][:w_max] / e_gamma[e_name][0]
+287 self.e_n_tauint[e_name] = np.cumsum(np.concatenate(([0.5], self.e_rho[e_name][1:])))
+288 # Make sure no entry of tauint is smaller than 0.5
+289 self.e_n_tauint[e_name][self.e_n_tauint[e_name] <= 0.5] = 0.5 + np.finfo(np.float64).eps
+290 # hep-lat/0306017 eq. (42)
+291 self.e_n_dtauint[e_name] = self.e_n_tauint[e_name] * 2 * np.sqrt(np.abs(np.arange(w_max) / gapsize + 0.5 - self.e_n_tauint[e_name]) / e_N)
+292 self.e_n_dtauint[e_name][0] = 0.0
+293
+294 def _compute_drho(i):
+295 tmp = self.e_rho[e_name][i + 1:w_max] + np.concatenate([self.e_rho[e_name][i - 1::-1], self.e_rho[e_name][1:w_max - 2 * i]]) - 2 * self.e_rho[e_name][i] * self.e_rho[e_name][1:w_max - i]
+296 self.e_drho[e_name][i] = np.sqrt(np.sum(tmp ** 2) / e_N)
+297
+298 _compute_drho(gapsize)
+299 if self.tau_exp[e_name] > 0:
+300 texp = self.tau_exp[e_name]
+301 # Critical slowing down analysis
+302 if w_max // 2 <= 1:
+303 raise Exception("Need at least 8 samples for tau_exp error analysis")
+304 for n in range(gapsize, w_max // 2, gapsize):
+305 _compute_drho(n + gapsize)
+306 if (self.e_rho[e_name][n] - self.N_sigma[e_name] * self.e_drho[e_name][n]) < 0 or n >= w_max // 2 - 2:
+307 # Bias correction hep-lat/0306017 eq. (49) included
+308 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) + texp * np.abs(self.e_rho[e_name][n + 1]) # The absolute makes sure, that the tail contribution is always positive
+309 self.e_dtauint[e_name] = np.sqrt(self.e_n_dtauint[e_name][n] ** 2 + texp ** 2 * self.e_drho[e_name][n + 1] ** 2)
+310 # Error of tau_exp neglected so far, missing term: self.e_rho[e_name][n + 1] ** 2 * d_tau_exp ** 2
+311 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
+312 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
+313 self.e_windowsize[e_name] = n
+314 break
+315 else:
+316 if self.S[e_name] == 0.0:
+317 self.e_tauint[e_name] = 0.5
+318 self.e_dtauint[e_name] = 0.0
+319 self.e_dvalue[e_name] = np.sqrt(e_gamma[e_name][0] / (e_N - 1))
+320 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt(0.5 / e_N)
+321 self.e_windowsize[e_name] = 0
+322 else:
+323 # Standard automatic windowing procedure
+324 tau = self.S[e_name] / np.log((2 * self.e_n_tauint[e_name][gapsize::gapsize] + 1) / (2 * self.e_n_tauint[e_name][gapsize::gapsize] - 1))
+325 g_w = np.exp(- np.arange(1, len(tau) + 1) / tau) - tau / np.sqrt(np.arange(1, len(tau) + 1) * e_N)
+326 for n in range(1, w_max):
+327 if n < w_max // 2 - 2:
+328 _compute_drho(gapsize * n + gapsize)
+329 if g_w[n - 1] < 0 or n >= w_max - 1:
+330 n *= gapsize
+331 self.e_tauint[e_name] = self.e_n_tauint[e_name][n] * (1 + (2 * n / gapsize + 1) / e_N) / (1 + 1 / e_N) # Bias correction hep-lat/0306017 eq. (49)
+332 self.e_dtauint[e_name] = self.e_n_dtauint[e_name][n]
+333 self.e_dvalue[e_name] = np.sqrt(2 * self.e_tauint[e_name] * e_gamma[e_name][0] * (1 + 1 / e_N) / e_N)
+334 self.e_ddvalue[e_name] = self.e_dvalue[e_name] * np.sqrt((n / gapsize + 0.5) / e_N)
+335 self.e_windowsize[e_name] = n
+336 break
337
-338 for e_name in self.cov_names:
-339 self.e_dvalue[e_name] = np.sqrt(self.covobs[e_name].errsq())
-340 self.e_ddvalue[e_name] = 0
-341 self._dvalue += self.e_dvalue[e_name]**2
-342
-343 self._dvalue = np.sqrt(self._dvalue)
-344 if self._dvalue == 0.0:
-345 self.ddvalue = 0.0
-346 else:
-347 self.ddvalue = np.sqrt(self.ddvalue) / self._dvalue
-348 return
+338 self._dvalue += self.e_dvalue[e_name] ** 2
+339 self.ddvalue += (self.e_dvalue[e_name] * self.e_ddvalue[e_name]) ** 2
+340
+341 for e_name in self.cov_names:
+342 self.e_dvalue[e_name] = np.sqrt(self.covobs[e_name].errsq())
+343 self.e_ddvalue[e_name] = 0
+344 self._dvalue += self.e_dvalue[e_name]**2
+345
+346 self._dvalue = np.sqrt(self._dvalue)
+347 if self._dvalue == 0.0:
+348 self.ddvalue = 0.0
+349 else:
+350 self.ddvalue = np.sqrt(self.ddvalue) / self._dvalue
+351 return
383 def details(self, ens_content=True):
-384 """Output detailed properties of the Obs.
-385
-386 Parameters
-387 ----------
-388 ens_content : bool
-389 print details about the ensembles and replica if true.
-390 """
-391 if self.tag is not None:
-392 print("Description:", self.tag)
-393 if not hasattr(self, 'e_dvalue'):
-394 print('Result\t %3.8e' % (self.value))
-395 else:
-396 if self.value == 0.0:
-397 percentage = np.nan
-398 else:
-399 percentage = np.abs(self._dvalue / self.value) * 100
-400 print('Result\t %3.8e +/- %3.8e +/- %3.8e (%3.3f%%)' % (self.value, self._dvalue, self.ddvalue, percentage))
-401 if len(self.e_names) > 1:
-402 print(' Ensemble errors:')
-403 e_content = self.e_content
-404 for e_name in self.mc_names:
-405 if isinstance(self.idl[e_content[e_name][0]], range):
-406 gap = self.idl[e_content[e_name][0]].step
-407 else:
-408 gap = np.min(np.diff(self.idl[e_content[e_name][0]]))
-409
-410 if len(self.e_names) > 1:
-411 print('', e_name, '\t %3.6e +/- %3.6e' % (self.e_dvalue[e_name], self.e_ddvalue[e_name]))
-412 tau_string = " \N{GREEK SMALL LETTER TAU}_int\t " + _format_uncertainty(self.e_tauint[e_name], self.e_dtauint[e_name])
-413 tau_string += f" in units of {gap} config"
-414 if gap > 1:
-415 tau_string += "s"
-416 if self.tau_exp[e_name] > 0:
-417 tau_string = f"{tau_string: <45}" + '\t(\N{GREEK SMALL LETTER TAU}_exp=%3.2f, N_\N{GREEK SMALL LETTER SIGMA}=%1.0i)' % (self.tau_exp[e_name], self.N_sigma[e_name])
-418 else:
-419 tau_string = f"{tau_string: <45}" + '\t(S=%3.2f)' % (self.S[e_name])
-420 print(tau_string)
-421 for e_name in self.cov_names:
-422 print('', e_name, '\t %3.8e' % (self.e_dvalue[e_name]))
-423 if ens_content is True:
-424 if len(self.e_names) == 1:
-425 print(self.N, 'samples in', len(self.e_names), 'ensemble:')
-426 else:
-427 print(self.N, 'samples in', len(self.e_names), 'ensembles:')
-428 my_string_list = []
-429 for key, value in sorted(self.e_content.items()):
-430 if key not in self.covobs:
-431 my_string = ' ' + "\u00B7 Ensemble '" + key + "' "
-432 if len(value) == 1:
-433 my_string += f': {self.shape[value[0]]} configurations'
-434 if isinstance(self.idl[value[0]], range):
-435 my_string += f' (from {self.idl[value[0]].start} to {self.idl[value[0]][-1]}' + int(self.idl[value[0]].step != 1) * f' in steps of {self.idl[value[0]].step}' + ')'
-436 else:
-437 my_string += f' (irregular range from {self.idl[value[0]][0]} to {self.idl[value[0]][-1]})'
-438 else:
-439 sublist = []
-440 for v in value:
-441 my_substring = ' ' + "\u00B7 Replicum '" + v[len(key) + 1:] + "' "
-442 my_substring += f': {self.shape[v]} configurations'
-443 if isinstance(self.idl[v], range):
-444 my_substring += f' (from {self.idl[v].start} to {self.idl[v][-1]}' + int(self.idl[v].step != 1) * f' in steps of {self.idl[v].step}' + ')'
-445 else:
-446 my_substring += f' (irregular range from {self.idl[v][0]} to {self.idl[v][-1]})'
-447 sublist.append(my_substring)
-448
-449 my_string += '\n' + '\n'.join(sublist)
-450 else:
-451 my_string = ' ' + "\u00B7 Covobs '" + key + "' "
-452 my_string_list.append(my_string)
-453 print('\n'.join(my_string_list))
+ 386 def details(self, ens_content=True):
+387 """Output detailed properties of the Obs.
+388
+389 Parameters
+390 ----------
+391 ens_content : bool
+392 print details about the ensembles and replica if true.
+393 """
+394 if self.tag is not None:
+395 print("Description:", self.tag)
+396 if not hasattr(self, 'e_dvalue'):
+397 print('Result\t %3.8e' % (self.value))
+398 else:
+399 if self.value == 0.0:
+400 percentage = np.nan
+401 else:
+402 percentage = np.abs(self._dvalue / self.value) * 100
+403 print('Result\t %3.8e +/- %3.8e +/- %3.8e (%3.3f%%)' % (self.value, self._dvalue, self.ddvalue, percentage))
+404 if len(self.e_names) > 1:
+405 print(' Ensemble errors:')
+406 e_content = self.e_content
+407 for e_name in self.mc_names:
+408 if isinstance(self.idl[e_content[e_name][0]], range):
+409 gap = self.idl[e_content[e_name][0]].step
+410 else:
+411 gap = np.min(np.diff(self.idl[e_content[e_name][0]]))
+412
+413 if len(self.e_names) > 1:
+414 print('', e_name, '\t %3.6e +/- %3.6e' % (self.e_dvalue[e_name], self.e_ddvalue[e_name]))
+415 tau_string = " \N{GREEK SMALL LETTER TAU}_int\t " + _format_uncertainty(self.e_tauint[e_name], self.e_dtauint[e_name])
+416 tau_string += f" in units of {gap} config"
+417 if gap > 1:
+418 tau_string += "s"
+419 if self.tau_exp[e_name] > 0:
+420 tau_string = f"{tau_string: <45}" + '\t(\N{GREEK SMALL LETTER TAU}_exp=%3.2f, N_\N{GREEK SMALL LETTER SIGMA}=%1.0i)' % (self.tau_exp[e_name], self.N_sigma[e_name])
+421 else:
+422 tau_string = f"{tau_string: <45}" + '\t(S=%3.2f)' % (self.S[e_name])
+423 print(tau_string)
+424 for e_name in self.cov_names:
+425 print('', e_name, '\t %3.8e' % (self.e_dvalue[e_name]))
+426 if ens_content is True:
+427 if len(self.e_names) == 1:
+428 print(self.N, 'samples in', len(self.e_names), 'ensemble:')
+429 else:
+430 print(self.N, 'samples in', len(self.e_names), 'ensembles:')
+431 my_string_list = []
+432 for key, value in sorted(self.e_content.items()):
+433 if key not in self.covobs:
+434 my_string = ' ' + "\u00B7 Ensemble '" + key + "' "
+435 if len(value) == 1:
+436 my_string += f': {self.shape[value[0]]} configurations'
+437 if isinstance(self.idl[value[0]], range):
+438 my_string += f' (from {self.idl[value[0]].start} to {self.idl[value[0]][-1]}' + int(self.idl[value[0]].step != 1) * f' in steps of {self.idl[value[0]].step}' + ')'
+439 else:
+440 my_string += f' (irregular range from {self.idl[value[0]][0]} to {self.idl[value[0]][-1]})'
+441 else:
+442 sublist = []
+443 for v in value:
+444 my_substring = ' ' + "\u00B7 Replicum '" + v[len(key) + 1:] + "' "
+445 my_substring += f': {self.shape[v]} configurations'
+446 if isinstance(self.idl[v], range):
+447 my_substring += f' (from {self.idl[v].start} to {self.idl[v][-1]}' + int(self.idl[v].step != 1) * f' in steps of {self.idl[v].step}' + ')'
+448 else:
+449 my_substring += f' (irregular range from {self.idl[v][0]} to {self.idl[v][-1]})'
+450 sublist.append(my_substring)
+451
+452 my_string += '\n' + '\n'.join(sublist)
+453 else:
+454 my_string = ' ' + "\u00B7 Covobs '" + key + "' "
+455 my_string_list.append(my_string)
+456 print('\n'.join(my_string_list))
455 def reweight(self, weight):
-456 """Reweight the obs with given rewighting factors.
-457
-458 Parameters
-459 ----------
-460 weight : Obs
-461 Reweighting factor. An Observable that has to be defined on a superset of the
-462 configurations in obs[i].idl for all i.
-463 all_configs : bool
-464 if True, the reweighted observables are normalized by the average of
-465 the reweighting factor on all configurations in weight.idl and not
-466 on the configurations in obs[i].idl. Default False.
-467 """
-468 return reweight(weight, [self])[0]
+ 458 def reweight(self, weight):
+459 """Reweight the obs with given rewighting factors.
+460
+461 Parameters
+462 ----------
+463 weight : Obs
+464 Reweighting factor. An Observable that has to be defined on a superset of the
+465 configurations in obs[i].idl for all i.
+466 all_configs : bool
+467 if True, the reweighted observables are normalized by the average of
+468 the reweighting factor on all configurations in weight.idl and not
+469 on the configurations in obs[i].idl. Default False.
+470 """
+471 return reweight(weight, [self])[0]
470 def is_zero_within_error(self, sigma=1):
-471 """Checks whether the observable is zero within 'sigma' standard errors.
-472
-473 Parameters
-474 ----------
-475 sigma : int
-476 Number of standard errors used for the check.
-477
-478 Works only properly when the gamma method was run.
-479 """
-480 return self.is_zero() or np.abs(self.value) <= sigma * self._dvalue
+ 473 def is_zero_within_error(self, sigma=1):
+474 """Checks whether the observable is zero within 'sigma' standard errors.
+475
+476 Parameters
+477 ----------
+478 sigma : int
+479 Number of standard errors used for the check.
+480
+481 Works only properly when the gamma method was run.
+482 """
+483 return self.is_zero() or np.abs(self.value) <= sigma * self._dvalue
482 def is_zero(self, atol=1e-10):
-483 """Checks whether the observable is zero within a given tolerance.
-484
-485 Parameters
-486 ----------
-487 atol : float
-488 Absolute tolerance (for details see numpy documentation).
-489 """
-490 return np.isclose(0.0, self.value, 1e-14, atol) and all(np.allclose(0.0, delta, 1e-14, atol) for delta in self.deltas.values()) and all(np.allclose(0.0, delta.errsq(), 1e-14, atol) for delta in self.covobs.values())
+ 485 def is_zero(self, atol=1e-10):
+486 """Checks whether the observable is zero within a given tolerance.
+487
+488 Parameters
+489 ----------
+490 atol : float
+491 Absolute tolerance (for details see numpy documentation).
+492 """
+493 return np.isclose(0.0, self.value, 1e-14, atol) and all(np.allclose(0.0, delta, 1e-14, atol) for delta in self.deltas.values()) and all(np.allclose(0.0, delta.errsq(), 1e-14, atol) for delta in self.covobs.values())
492 def plot_tauint(self, save=None):
-493 """Plot integrated autocorrelation time for each ensemble.
-494
-495 Parameters
-496 ----------
-497 save : str
-498 saves the figure to a file named 'save' if.
-499 """
-500 if not hasattr(self, 'e_dvalue'):
-501 raise Exception('Run the gamma method first.')
-502
-503 for e, e_name in enumerate(self.mc_names):
-504 fig = plt.figure()
-505 plt.xlabel(r'$W$')
-506 plt.ylabel(r'$\tau_\mathrm{int}$')
-507 length = int(len(self.e_n_tauint[e_name]))
-508 if self.tau_exp[e_name] > 0:
-509 base = self.e_n_tauint[e_name][self.e_windowsize[e_name]]
-510 x_help = np.arange(2 * self.tau_exp[e_name])
-511 y_help = (x_help + 1) * np.abs(self.e_rho[e_name][self.e_windowsize[e_name] + 1]) * (1 - x_help / (2 * (2 * self.tau_exp[e_name] - 1))) + base
-512 x_arr = np.arange(self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name])
-513 plt.plot(x_arr, y_help, 'C' + str(e), linewidth=1, ls='--', marker=',')
-514 plt.errorbar([self.e_windowsize[e_name] + 2 * self.tau_exp[e_name]], [self.e_tauint[e_name]],
-515 yerr=[self.e_dtauint[e_name]], fmt='C' + str(e), linewidth=1, capsize=2, marker='o', mfc=plt.rcParams['axes.facecolor'])
-516 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
-517 label = e_name + r', $\tau_\mathrm{exp}$=' + str(np.around(self.tau_exp[e_name], decimals=2))
-518 else:
-519 label = e_name + ', S=' + str(np.around(self.S[e_name], decimals=2))
-520 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
-521
-522 plt.errorbar(np.arange(length)[:int(xmax) + 1], self.e_n_tauint[e_name][:int(xmax) + 1], yerr=self.e_n_dtauint[e_name][:int(xmax) + 1], linewidth=1, capsize=2, label=label)
-523 plt.axvline(x=self.e_windowsize[e_name], color='C' + str(e), alpha=0.5, marker=',', ls='--')
-524 plt.legend()
-525 plt.xlim(-0.5, xmax)
-526 ylim = plt.ylim()
-527 plt.ylim(bottom=0.0, top=max(1.0, ylim[1]))
-528 plt.draw()
-529 if save:
-530 fig.savefig(save + "_" + str(e))
+ 495 def plot_tauint(self, save=None):
+496 """Plot integrated autocorrelation time for each ensemble.
+497
+498 Parameters
+499 ----------
+500 save : str
+501 saves the figure to a file named 'save' if.
+502 """
+503 if not hasattr(self, 'e_dvalue'):
+504 raise Exception('Run the gamma method first.')
+505
+506 for e, e_name in enumerate(self.mc_names):
+507 fig = plt.figure()
+508 plt.xlabel(r'$W$')
+509 plt.ylabel(r'$\tau_\mathrm{int}$')
+510 length = int(len(self.e_n_tauint[e_name]))
+511 if self.tau_exp[e_name] > 0:
+512 base = self.e_n_tauint[e_name][self.e_windowsize[e_name]]
+513 x_help = np.arange(2 * self.tau_exp[e_name])
+514 y_help = (x_help + 1) * np.abs(self.e_rho[e_name][self.e_windowsize[e_name] + 1]) * (1 - x_help / (2 * (2 * self.tau_exp[e_name] - 1))) + base
+515 x_arr = np.arange(self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name])
+516 plt.plot(x_arr, y_help, 'C' + str(e), linewidth=1, ls='--', marker=',')
+517 plt.errorbar([self.e_windowsize[e_name] + 2 * self.tau_exp[e_name]], [self.e_tauint[e_name]],
+518 yerr=[self.e_dtauint[e_name]], fmt='C' + str(e), linewidth=1, capsize=2, marker='o', mfc=plt.rcParams['axes.facecolor'])
+519 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
+520 label = e_name + r', $\tau_\mathrm{exp}$=' + str(np.around(self.tau_exp[e_name], decimals=2))
+521 else:
+522 label = e_name + ', S=' + str(np.around(self.S[e_name], decimals=2))
+523 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
+524
+525 plt.errorbar(np.arange(length)[:int(xmax) + 1], self.e_n_tauint[e_name][:int(xmax) + 1], yerr=self.e_n_dtauint[e_name][:int(xmax) + 1], linewidth=1, capsize=2, label=label)
+526 plt.axvline(x=self.e_windowsize[e_name], color='C' + str(e), alpha=0.5, marker=',', ls='--')
+527 plt.legend()
+528 plt.xlim(-0.5, xmax)
+529 ylim = plt.ylim()
+530 plt.ylim(bottom=0.0, top=max(1.0, ylim[1]))
+531 plt.draw()
+532 if save:
+533 fig.savefig(save + "_" + str(e))
532 def plot_rho(self, save=None):
-533 """Plot normalized autocorrelation function time for each ensemble.
-534
-535 Parameters
-536 ----------
-537 save : str
-538 saves the figure to a file named 'save' if.
-539 """
-540 if not hasattr(self, 'e_dvalue'):
-541 raise Exception('Run the gamma method first.')
-542 for e, e_name in enumerate(self.mc_names):
-543 fig = plt.figure()
-544 plt.xlabel('W')
-545 plt.ylabel('rho')
-546 length = int(len(self.e_drho[e_name]))
-547 plt.errorbar(np.arange(length), self.e_rho[e_name][:length], yerr=self.e_drho[e_name][:], linewidth=1, capsize=2)
-548 plt.axvline(x=self.e_windowsize[e_name], color='r', alpha=0.25, ls='--', marker=',')
-549 if self.tau_exp[e_name] > 0:
-550 plt.plot([self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name]],
-551 [self.e_rho[e_name][self.e_windowsize[e_name] + 1], 0], 'k-', lw=1)
-552 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
-553 plt.title('Rho ' + e_name + r', tau\_exp=' + str(np.around(self.tau_exp[e_name], decimals=2)))
-554 else:
-555 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
-556 plt.title('Rho ' + e_name + ', S=' + str(np.around(self.S[e_name], decimals=2)))
-557 plt.plot([-0.5, xmax], [0, 0], 'k--', lw=1)
-558 plt.xlim(-0.5, xmax)
-559 plt.draw()
-560 if save:
-561 fig.savefig(save + "_" + str(e))
+ 535 def plot_rho(self, save=None):
+536 """Plot normalized autocorrelation function time for each ensemble.
+537
+538 Parameters
+539 ----------
+540 save : str
+541 saves the figure to a file named 'save' if.
+542 """
+543 if not hasattr(self, 'e_dvalue'):
+544 raise Exception('Run the gamma method first.')
+545 for e, e_name in enumerate(self.mc_names):
+546 fig = plt.figure()
+547 plt.xlabel('W')
+548 plt.ylabel('rho')
+549 length = int(len(self.e_drho[e_name]))
+550 plt.errorbar(np.arange(length), self.e_rho[e_name][:length], yerr=self.e_drho[e_name][:], linewidth=1, capsize=2)
+551 plt.axvline(x=self.e_windowsize[e_name], color='r', alpha=0.25, ls='--', marker=',')
+552 if self.tau_exp[e_name] > 0:
+553 plt.plot([self.e_windowsize[e_name] + 1, self.e_windowsize[e_name] + 1 + 2 * self.tau_exp[e_name]],
+554 [self.e_rho[e_name][self.e_windowsize[e_name] + 1], 0], 'k-', lw=1)
+555 xmax = self.e_windowsize[e_name] + 2 * self.tau_exp[e_name] + 1.5
+556 plt.title('Rho ' + e_name + r', tau\_exp=' + str(np.around(self.tau_exp[e_name], decimals=2)))
+557 else:
+558 xmax = max(10.5, 2 * self.e_windowsize[e_name] - 0.5)
+559 plt.title('Rho ' + e_name + ', S=' + str(np.around(self.S[e_name], decimals=2)))
+560 plt.plot([-0.5, xmax], [0, 0], 'k--', lw=1)
+561 plt.xlim(-0.5, xmax)
+562 plt.draw()
+563 if save:
+564 fig.savefig(save + "_" + str(e))
563 def plot_rep_dist(self):
-564 """Plot replica distribution for each ensemble with more than one replicum."""
-565 if not hasattr(self, 'e_dvalue'):
-566 raise Exception('Run the gamma method first.')
-567 for e, e_name in enumerate(self.mc_names):
-568 if len(self.e_content[e_name]) == 1:
-569 print('No replica distribution for a single replicum (', e_name, ')')
-570 continue
-571 r_length = []
-572 sub_r_mean = 0
-573 for r, r_name in enumerate(self.e_content[e_name]):
-574 r_length.append(len(self.deltas[r_name]))
-575 sub_r_mean += self.shape[r_name] * self.r_values[r_name]
-576 e_N = np.sum(r_length)
-577 sub_r_mean /= e_N
-578 arr = np.zeros(len(self.e_content[e_name]))
-579 for r, r_name in enumerate(self.e_content[e_name]):
-580 arr[r] = (self.r_values[r_name] - sub_r_mean) / (self.e_dvalue[e_name] * np.sqrt(e_N / self.shape[r_name] - 1))
-581 plt.hist(arr, rwidth=0.8, bins=len(self.e_content[e_name]))
-582 plt.title('Replica distribution' + e_name + ' (mean=0, var=1)')
-583 plt.draw()
+ 566 def plot_rep_dist(self):
+567 """Plot replica distribution for each ensemble with more than one replicum."""
+568 if not hasattr(self, 'e_dvalue'):
+569 raise Exception('Run the gamma method first.')
+570 for e, e_name in enumerate(self.mc_names):
+571 if len(self.e_content[e_name]) == 1:
+572 print('No replica distribution for a single replicum (', e_name, ')')
+573 continue
+574 r_length = []
+575 sub_r_mean = 0
+576 for r, r_name in enumerate(self.e_content[e_name]):
+577 r_length.append(len(self.deltas[r_name]))
+578 sub_r_mean += self.shape[r_name] * self.r_values[r_name]
+579 e_N = np.sum(r_length)
+580 sub_r_mean /= e_N
+581 arr = np.zeros(len(self.e_content[e_name]))
+582 for r, r_name in enumerate(self.e_content[e_name]):
+583 arr[r] = (self.r_values[r_name] - sub_r_mean) / (self.e_dvalue[e_name] * np.sqrt(e_N / self.shape[r_name] - 1))
+584 plt.hist(arr, rwidth=0.8, bins=len(self.e_content[e_name]))
+585 plt.title('Replica distribution' + e_name + ' (mean=0, var=1)')
+586 plt.draw()
585 def plot_history(self, expand=True):
-586 """Plot derived Monte Carlo history for each ensemble
-587
-588 Parameters
-589 ----------
-590 expand : bool
-591 show expanded history for irregular Monte Carlo chains (default: True).
-592 """
-593 for e, e_name in enumerate(self.mc_names):
-594 plt.figure()
-595 r_length = []
-596 tmp = []
-597 tmp_expanded = []
-598 for r, r_name in enumerate(self.e_content[e_name]):
-599 tmp.append(self.deltas[r_name] + self.r_values[r_name])
-600 if expand:
-601 tmp_expanded.append(_expand_deltas(self.deltas[r_name], list(self.idl[r_name]), self.shape[r_name]) + self.r_values[r_name])
-602 r_length.append(len(tmp_expanded[-1]))
-603 else:
-604 r_length.append(len(tmp[-1]))
-605 e_N = np.sum(r_length)
-606 x = np.arange(e_N)
-607 y_test = np.concatenate(tmp, axis=0)
-608 if expand:
-609 y = np.concatenate(tmp_expanded, axis=0)
-610 else:
-611 y = y_test
-612 plt.errorbar(x, y, fmt='.', markersize=3)
-613 plt.xlim(-0.5, e_N - 0.5)
-614 plt.title(e_name + f'\nskew: {skew(y_test):.3f} (p={skewtest(y_test).pvalue:.3f}), kurtosis: {kurtosis(y_test):.3f} (p={kurtosistest(y_test).pvalue:.3f})')
-615 plt.draw()
+ 588 def plot_history(self, expand=True):
+589 """Plot derived Monte Carlo history for each ensemble
+590
+591 Parameters
+592 ----------
+593 expand : bool
+594 show expanded history for irregular Monte Carlo chains (default: True).
+595 """
+596 for e, e_name in enumerate(self.mc_names):
+597 plt.figure()
+598 r_length = []
+599 tmp = []
+600 tmp_expanded = []
+601 for r, r_name in enumerate(self.e_content[e_name]):
+602 tmp.append(self.deltas[r_name] + self.r_values[r_name])
+603 if expand:
+604 tmp_expanded.append(_expand_deltas(self.deltas[r_name], list(self.idl[r_name]), self.shape[r_name]) + self.r_values[r_name])
+605 r_length.append(len(tmp_expanded[-1]))
+606 else:
+607 r_length.append(len(tmp[-1]))
+608 e_N = np.sum(r_length)
+609 x = np.arange(e_N)
+610 y_test = np.concatenate(tmp, axis=0)
+611 if expand:
+612 y = np.concatenate(tmp_expanded, axis=0)
+613 else:
+614 y = y_test
+615 plt.errorbar(x, y, fmt='.', markersize=3)
+616 plt.xlim(-0.5, e_N - 0.5)
+617 plt.title(e_name + f'\nskew: {skew(y_test):.3f} (p={skewtest(y_test).pvalue:.3f}), kurtosis: {kurtosis(y_test):.3f} (p={kurtosistest(y_test).pvalue:.3f})')
+618 plt.draw()
617 def plot_piechart(self, save=None):
-618 """Plot piechart which shows the fractional contribution of each
-619 ensemble to the error and returns a dictionary containing the fractions.
-620
-621 Parameters
-622 ----------
-623 save : str
-624 saves the figure to a file named 'save' if.
-625 """
-626 if not hasattr(self, 'e_dvalue'):
-627 raise Exception('Run the gamma method first.')
-628 if np.isclose(0.0, self._dvalue, atol=1e-15):
-629 raise Exception('Error is 0.0')
-630 labels = self.e_names
-631 sizes = [self.e_dvalue[name] ** 2 for name in labels] / self._dvalue ** 2
-632 fig1, ax1 = plt.subplots()
-633 ax1.pie(sizes, labels=labels, startangle=90, normalize=True)
-634 ax1.axis('equal')
-635 plt.draw()
-636 if save:
-637 fig1.savefig(save)
-638
-639 return dict(zip(self.e_names, sizes))
+ 620 def plot_piechart(self, save=None):
+621 """Plot piechart which shows the fractional contribution of each
+622 ensemble to the error and returns a dictionary containing the fractions.
+623
+624 Parameters
+625 ----------
+626 save : str
+627 saves the figure to a file named 'save' if.
+628 """
+629 if not hasattr(self, 'e_dvalue'):
+630 raise Exception('Run the gamma method first.')
+631 if np.isclose(0.0, self._dvalue, atol=1e-15):
+632 raise Exception('Error is 0.0')
+633 labels = self.e_names
+634 sizes = [self.e_dvalue[name] ** 2 for name in labels] / self._dvalue ** 2
+635 fig1, ax1 = plt.subplots()
+636 ax1.pie(sizes, labels=labels, startangle=90, normalize=True)
+637 ax1.axis('equal')
+638 plt.draw()
+639 if save:
+640 fig1.savefig(save)
+641
+642 return dict(zip(self.e_names, sizes))
641 def dump(self, filename, datatype="json.gz", description="", **kwargs):
-642 """Dump the Obs to a file 'name' of chosen format.
-643
-644 Parameters
-645 ----------
-646 filename : str
-647 name of the file to be saved.
-648 datatype : str
-649 Format of the exported file. Supported formats include
-650 "json.gz" and "pickle"
-651 description : str
-652 Description for output file, only relevant for json.gz format.
-653 path : str
-654 specifies a custom path for the file (default '.')
-655 """
-656 if 'path' in kwargs:
-657 file_name = kwargs.get('path') + '/' + filename
-658 else:
-659 file_name = filename
-660
-661 if datatype == "json.gz":
-662 from .input.json import dump_to_json
-663 dump_to_json([self], file_name, description=description)
-664 elif datatype == "pickle":
-665 with open(file_name + '.p', 'wb') as fb:
-666 pickle.dump(self, fb)
-667 else:
-668 raise Exception("Unknown datatype " + str(datatype))
+ 644 def dump(self, filename, datatype="json.gz", description="", **kwargs):
+645 """Dump the Obs to a file 'name' of chosen format.
+646
+647 Parameters
+648 ----------
+649 filename : str
+650 name of the file to be saved.
+651 datatype : str
+652 Format of the exported file. Supported formats include
+653 "json.gz" and "pickle"
+654 description : str
+655 Description for output file, only relevant for json.gz format.
+656 path : str
+657 specifies a custom path for the file (default '.')
+658 """
+659 if 'path' in kwargs:
+660 file_name = kwargs.get('path') + '/' + filename
+661 else:
+662 file_name = filename
+663
+664 if datatype == "json.gz":
+665 from .input.json import dump_to_json
+666 dump_to_json([self], file_name, description=description)
+667 elif datatype == "pickle":
+668 with open(file_name + '.p', 'wb') as fb:
+669 pickle.dump(self, fb)
+670 else:
+671 raise Exception("Unknown datatype " + str(datatype))
670 def export_jackknife(self):
-671 """Export jackknife samples from the Obs
-672
-673 Returns
-674 -------
-675 numpy.ndarray
-676 Returns a numpy array of length N + 1 where N is the number of samples
-677 for the given ensemble and replicum. The zeroth entry of the array contains
-678 the mean value of the Obs, entries 1 to N contain the N jackknife samples
-679 derived from the Obs. The current implementation only works for observables
-680 defined on exactly one ensemble and replicum. The derived jackknife samples
-681 should agree with samples from a full jackknife analysis up to O(1/N).
-682 """
-683
-684 if len(self.names) != 1:
-685 raise Exception("'export_jackknife' is only implemented for Obs defined on one ensemble and replicum.")
+ 673 def export_jackknife(self):
+674 """Export jackknife samples from the Obs
+675
+676 Returns
+677 -------
+678 numpy.ndarray
+679 Returns a numpy array of length N + 1 where N is the number of samples
+680 for the given ensemble and replicum. The zeroth entry of the array contains
+681 the mean value of the Obs, entries 1 to N contain the N jackknife samples
+682 derived from the Obs. The current implementation only works for observables
+683 defined on exactly one ensemble and replicum. The derived jackknife samples
+684 should agree with samples from a full jackknife analysis up to O(1/N).
+685 """
686
-687 name = self.names[0]
-688 full_data = self.deltas[name] + self.r_values[name]
-689 n = full_data.size
-690 mean = self.value
-691 tmp_jacks = np.zeros(n + 1)
-692 tmp_jacks[0] = mean
-693 tmp_jacks[1:] = (n * mean - full_data) / (n - 1)
-694 return tmp_jacks
+687 if len(self.names) != 1:
+688 raise Exception("'export_jackknife' is only implemented for Obs defined on one ensemble and replicum.")
+689
+690 name = self.names[0]
+691 full_data = self.deltas[name] + self.r_values[name]
+692 n = full_data.size
+693 mean = self.value
+694 tmp_jacks = np.zeros(n + 1)
+695 tmp_jacks[0] = mean
+696 tmp_jacks[1:] = (n * mean - full_data) / (n - 1)
+697 return tmp_jacks
822 def sqrt(self):
-823 return derived_observable(lambda x, **kwargs: np.sqrt(x[0]), [self], man_grad=[1 / 2 / np.sqrt(self.value)])
+ 825 def sqrt(self):
+826 return derived_observable(lambda x, **kwargs: np.sqrt(x[0]), [self], man_grad=[1 / 2 / np.sqrt(self.value)])
825 def log(self):
-826 return derived_observable(lambda x, **kwargs: np.log(x[0]), [self], man_grad=[1 / self.value])
+ 828 def log(self):
+829 return derived_observable(lambda x, **kwargs: np.log(x[0]), [self], man_grad=[1 / self.value])
828 def exp(self):
-829 return derived_observable(lambda x, **kwargs: np.exp(x[0]), [self], man_grad=[np.exp(self.value)])
+ 831 def exp(self):
+832 return derived_observable(lambda x, **kwargs: np.exp(x[0]), [self], man_grad=[np.exp(self.value)])
831 def sin(self):
-832 return derived_observable(lambda x, **kwargs: np.sin(x[0]), [self], man_grad=[np.cos(self.value)])
+ 834 def sin(self):
+835 return derived_observable(lambda x, **kwargs: np.sin(x[0]), [self], man_grad=[np.cos(self.value)])
834 def cos(self):
-835 return derived_observable(lambda x, **kwargs: np.cos(x[0]), [self], man_grad=[-np.sin(self.value)])
+ 837 def cos(self):
+838 return derived_observable(lambda x, **kwargs: np.cos(x[0]), [self], man_grad=[-np.sin(self.value)])
837 def tan(self):
-838 return derived_observable(lambda x, **kwargs: np.tan(x[0]), [self], man_grad=[1 / np.cos(self.value) ** 2])
+ 840 def tan(self):
+841 return derived_observable(lambda x, **kwargs: np.tan(x[0]), [self], man_grad=[1 / np.cos(self.value) ** 2])
840 def arcsin(self):
-841 return derived_observable(lambda x: anp.arcsin(x[0]), [self])
+ 843 def arcsin(self):
+844 return derived_observable(lambda x: anp.arcsin(x[0]), [self])
843 def arccos(self):
-844 return derived_observable(lambda x: anp.arccos(x[0]), [self])
+ 846 def arccos(self):
+847 return derived_observable(lambda x: anp.arccos(x[0]), [self])
846 def arctan(self):
-847 return derived_observable(lambda x: anp.arctan(x[0]), [self])
+ 849 def arctan(self):
+850 return derived_observable(lambda x: anp.arctan(x[0]), [self])
849 def sinh(self):
-850 return derived_observable(lambda x, **kwargs: np.sinh(x[0]), [self], man_grad=[np.cosh(self.value)])
+ 852 def sinh(self):
+853 return derived_observable(lambda x, **kwargs: np.sinh(x[0]), [self], man_grad=[np.cosh(self.value)])
852 def cosh(self):
-853 return derived_observable(lambda x, **kwargs: np.cosh(x[0]), [self], man_grad=[np.sinh(self.value)])
+ 855 def cosh(self):
+856 return derived_observable(lambda x, **kwargs: np.cosh(x[0]), [self], man_grad=[np.sinh(self.value)])
855 def tanh(self):
-856 return derived_observable(lambda x, **kwargs: np.tanh(x[0]), [self], man_grad=[1 / np.cosh(self.value) ** 2])
+ 858 def tanh(self):
+859 return derived_observable(lambda x, **kwargs: np.tanh(x[0]), [self], man_grad=[1 / np.cosh(self.value) ** 2])
858 def arcsinh(self):
-859 return derived_observable(lambda x: anp.arcsinh(x[0]), [self])
+ 861 def arcsinh(self):
+862 return derived_observable(lambda x: anp.arcsinh(x[0]), [self])
861 def arccosh(self):
-862 return derived_observable(lambda x: anp.arccosh(x[0]), [self])
+ 864 def arccosh(self):
+865 return derived_observable(lambda x: anp.arccosh(x[0]), [self])
864 def arctanh(self):
-865 return derived_observable(lambda x: anp.arctanh(x[0]), [self])
+ 867 def arctanh(self):
+868 return derived_observable(lambda x: anp.arctanh(x[0]), [self])
868class CObs:
-869 """Class for a complex valued observable."""
-870 __slots__ = ['_real', '_imag', 'tag']
-871
-872 def __init__(self, real, imag=0.0):
-873 self._real = real
-874 self._imag = imag
-875 self.tag = None
-876
-877 @property
-878 def real(self):
-879 return self._real
-880
-881 @property
-882 def imag(self):
-883 return self._imag
-884
-885 def gamma_method(self, **kwargs):
-886 """Executes the gamma_method for the real and the imaginary part."""
-887 if isinstance(self.real, Obs):
-888 self.real.gamma_method(**kwargs)
-889 if isinstance(self.imag, Obs):
-890 self.imag.gamma_method(**kwargs)
-891
-892 def is_zero(self):
-893 """Checks whether both real and imaginary part are zero within machine precision."""
-894 return self.real == 0.0 and self.imag == 0.0
-895
-896 def conjugate(self):
-897 return CObs(self.real, -self.imag)
+ 871class CObs:
+872 """Class for a complex valued observable."""
+873 __slots__ = ['_real', '_imag', 'tag']
+874
+875 def __init__(self, real, imag=0.0):
+876 self._real = real
+877 self._imag = imag
+878 self.tag = None
+879
+880 @property
+881 def real(self):
+882 return self._real
+883
+884 @property
+885 def imag(self):
+886 return self._imag
+887
+888 def gamma_method(self, **kwargs):
+889 """Executes the gamma_method for the real and the imaginary part."""
+890 if isinstance(self.real, Obs):
+891 self.real.gamma_method(**kwargs)
+892 if isinstance(self.imag, Obs):
+893 self.imag.gamma_method(**kwargs)
+894
+895 def is_zero(self):
+896 """Checks whether both real and imaginary part are zero within machine precision."""
+897 return self.real == 0.0 and self.imag == 0.0
898
-899 def __add__(self, other):
-900 if isinstance(other, np.ndarray):
-901 return other + self
-902 elif hasattr(other, 'real') and hasattr(other, 'imag'):
-903 return CObs(self.real + other.real,
-904 self.imag + other.imag)
-905 else:
-906 return CObs(self.real + other, self.imag)
-907
-908 def __radd__(self, y):
-909 return self + y
+899 def conjugate(self):
+900 return CObs(self.real, -self.imag)
+901
+902 def __add__(self, other):
+903 if isinstance(other, np.ndarray):
+904 return other + self
+905 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+906 return CObs(self.real + other.real,
+907 self.imag + other.imag)
+908 else:
+909 return CObs(self.real + other, self.imag)
910
-911 def __sub__(self, other):
-912 if isinstance(other, np.ndarray):
-913 return -1 * (other - self)
-914 elif hasattr(other, 'real') and hasattr(other, 'imag'):
-915 return CObs(self.real - other.real, self.imag - other.imag)
-916 else:
-917 return CObs(self.real - other, self.imag)
-918
-919 def __rsub__(self, other):
-920 return -1 * (self - other)
+911 def __radd__(self, y):
+912 return self + y
+913
+914 def __sub__(self, other):
+915 if isinstance(other, np.ndarray):
+916 return -1 * (other - self)
+917 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+918 return CObs(self.real - other.real, self.imag - other.imag)
+919 else:
+920 return CObs(self.real - other, self.imag)
921
-922 def __mul__(self, other):
-923 if isinstance(other, np.ndarray):
-924 return other * self
-925 elif hasattr(other, 'real') and hasattr(other, 'imag'):
-926 if all(isinstance(i, Obs) for i in [self.real, self.imag, other.real, other.imag]):
-927 return CObs(derived_observable(lambda x, **kwargs: x[0] * x[1] - x[2] * x[3],
-928 [self.real, other.real, self.imag, other.imag],
-929 man_grad=[other.real.value, self.real.value, -other.imag.value, -self.imag.value]),
-930 derived_observable(lambda x, **kwargs: x[2] * x[1] + x[0] * x[3],
+922 def __rsub__(self, other):
+923 return -1 * (self - other)
+924
+925 def __mul__(self, other):
+926 if isinstance(other, np.ndarray):
+927 return other * self
+928 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+929 if all(isinstance(i, Obs) for i in [self.real, self.imag, other.real, other.imag]):
+930 return CObs(derived_observable(lambda x, **kwargs: x[0] * x[1] - x[2] * x[3],
931 [self.real, other.real, self.imag, other.imag],
-932 man_grad=[other.imag.value, self.imag.value, other.real.value, self.real.value]))
-933 elif getattr(other, 'imag', 0) != 0:
-934 return CObs(self.real * other.real - self.imag * other.imag,
-935 self.imag * other.real + self.real * other.imag)
-936 else:
-937 return CObs(self.real * other.real, self.imag * other.real)
-938 else:
-939 return CObs(self.real * other, self.imag * other)
-940
-941 def __rmul__(self, other):
-942 return self * other
+932 man_grad=[other.real.value, self.real.value, -other.imag.value, -self.imag.value]),
+933 derived_observable(lambda x, **kwargs: x[2] * x[1] + x[0] * x[3],
+934 [self.real, other.real, self.imag, other.imag],
+935 man_grad=[other.imag.value, self.imag.value, other.real.value, self.real.value]))
+936 elif getattr(other, 'imag', 0) != 0:
+937 return CObs(self.real * other.real - self.imag * other.imag,
+938 self.imag * other.real + self.real * other.imag)
+939 else:
+940 return CObs(self.real * other.real, self.imag * other.real)
+941 else:
+942 return CObs(self.real * other, self.imag * other)
943
-944 def __truediv__(self, other):
-945 if isinstance(other, np.ndarray):
-946 return 1 / (other / self)
-947 elif hasattr(other, 'real') and hasattr(other, 'imag'):
-948 r = other.real ** 2 + other.imag ** 2
-949 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.imag * other.real - self.real * other.imag) / r)
-950 else:
-951 return CObs(self.real / other, self.imag / other)
-952
-953 def __rtruediv__(self, other):
-954 r = self.real ** 2 + self.imag ** 2
-955 if hasattr(other, 'real') and hasattr(other, 'imag'):
-956 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.real * other.imag - self.imag * other.real) / r)
-957 else:
-958 return CObs(self.real * other / r, -self.imag * other / r)
-959
-960 def __abs__(self):
-961 return np.sqrt(self.real**2 + self.imag**2)
+944 def __rmul__(self, other):
+945 return self * other
+946
+947 def __truediv__(self, other):
+948 if isinstance(other, np.ndarray):
+949 return 1 / (other / self)
+950 elif hasattr(other, 'real') and hasattr(other, 'imag'):
+951 r = other.real ** 2 + other.imag ** 2
+952 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.imag * other.real - self.real * other.imag) / r)
+953 else:
+954 return CObs(self.real / other, self.imag / other)
+955
+956 def __rtruediv__(self, other):
+957 r = self.real ** 2 + self.imag ** 2
+958 if hasattr(other, 'real') and hasattr(other, 'imag'):
+959 return CObs((self.real * other.real + self.imag * other.imag) / r, (self.real * other.imag - self.imag * other.real) / r)
+960 else:
+961 return CObs(self.real * other / r, -self.imag * other / r)
962
-963 def __pos__(self):
-964 return self
+963 def __abs__(self):
+964 return np.sqrt(self.real**2 + self.imag**2)
965
-966 def __neg__(self):
-967 return -1 * self
+966 def __pos__(self):
+967 return self
968
-969 def __eq__(self, other):
-970 return self.real == other.real and self.imag == other.imag
+969 def __neg__(self):
+970 return -1 * self
971
-972 def __str__(self):
-973 return '(' + str(self.real) + int(self.imag >= 0.0) * '+' + str(self.imag) + 'j)'
+972 def __eq__(self, other):
+973 return self.real == other.real and self.imag == other.imag
974
-975 def __repr__(self):
-976 return 'CObs[' + str(self) + ']'
+975 def __str__(self):
+976 return '(' + str(self.real) + int(self.imag >= 0.0) * '+' + str(self.imag) + 'j)'
+977
+978 def __repr__(self):
+979 return 'CObs[' + str(self) + ']'
872 def __init__(self, real, imag=0.0):
-873 self._real = real
-874 self._imag = imag
-875 self.tag = None
+ 875 def __init__(self, real, imag=0.0):
+876 self._real = real
+877 self._imag = imag
+878 self.tag = None
885 def gamma_method(self, **kwargs):
-886 """Executes the gamma_method for the real and the imaginary part."""
-887 if isinstance(self.real, Obs):
-888 self.real.gamma_method(**kwargs)
-889 if isinstance(self.imag, Obs):
-890 self.imag.gamma_method(**kwargs)
+ 888 def gamma_method(self, **kwargs):
+889 """Executes the gamma_method for the real and the imaginary part."""
+890 if isinstance(self.real, Obs):
+891 self.real.gamma_method(**kwargs)
+892 if isinstance(self.imag, Obs):
+893 self.imag.gamma_method(**kwargs)
892 def is_zero(self):
-893 """Checks whether both real and imaginary part are zero within machine precision."""
-894 return self.real == 0.0 and self.imag == 0.0
+ 895 def is_zero(self):
+896 """Checks whether both real and imaginary part are zero within machine precision."""
+897 return self.real == 0.0 and self.imag == 0.0
896 def conjugate(self):
-897 return CObs(self.real, -self.imag)
+ 899 def conjugate(self):
+900 return CObs(self.real, -self.imag)
1130def derived_observable(func, data, array_mode=False, **kwargs):
-1131 """Construct a derived Obs according to func(data, **kwargs) using automatic differentiation.
-1132
-1133 Parameters
-1134 ----------
-1135 func : object
-1136 arbitrary function of the form func(data, **kwargs). For the
-1137 automatic differentiation to work, all numpy functions have to have
-1138 the autograd wrapper (use 'import autograd.numpy as anp').
-1139 data : list
-1140 list of Obs, e.g. [obs1, obs2, obs3].
-1141 num_grad : bool
-1142 if True, numerical derivatives are used instead of autograd
-1143 (default False). To control the numerical differentiation the
-1144 kwargs of numdifftools.step_generators.MaxStepGenerator
-1145 can be used.
-1146 man_grad : list
-1147 manually supply a list or an array which contains the jacobian
-1148 of func. Use cautiously, supplying the wrong derivative will
-1149 not be intercepted.
-1150
-1151 Notes
-1152 -----
-1153 For simple mathematical operations it can be practical to use anonymous
-1154 functions. For the ratio of two observables one can e.g. use
-1155
-1156 new_obs = derived_observable(lambda x: x[0] / x[1], [obs1, obs2])
-1157 """
+ 1133def derived_observable(func, data, array_mode=False, **kwargs):
+1134 """Construct a derived Obs according to func(data, **kwargs) using automatic differentiation.
+1135
+1136 Parameters
+1137 ----------
+1138 func : object
+1139 arbitrary function of the form func(data, **kwargs). For the
+1140 automatic differentiation to work, all numpy functions have to have
+1141 the autograd wrapper (use 'import autograd.numpy as anp').
+1142 data : list
+1143 list of Obs, e.g. [obs1, obs2, obs3].
+1144 num_grad : bool
+1145 if True, numerical derivatives are used instead of autograd
+1146 (default False). To control the numerical differentiation the
+1147 kwargs of numdifftools.step_generators.MaxStepGenerator
+1148 can be used.
+1149 man_grad : list
+1150 manually supply a list or an array which contains the jacobian
+1151 of func. Use cautiously, supplying the wrong derivative will
+1152 not be intercepted.
+1153
+1154 Notes
+1155 -----
+1156 For simple mathematical operations it can be practical to use anonymous
+1157 functions. For the ratio of two observables one can e.g. use
1158
-1159 data = np.asarray(data)
-1160 raveled_data = data.ravel()
+1159 new_obs = derived_observable(lambda x: x[0] / x[1], [obs1, obs2])
+1160 """
1161
-1162 # Workaround for matrix operations containing non Obs data
-1163 if not all(isinstance(x, Obs) for x in raveled_data):
-1164 for i in range(len(raveled_data)):
-1165 if isinstance(raveled_data[i], (int, float)):
-1166 raveled_data[i] = cov_Obs(raveled_data[i], 0.0, "###dummy_covobs###")
-1167
-1168 allcov = {}
-1169 for o in raveled_data:
-1170 for name in o.cov_names:
-1171 if name in allcov:
-1172 if not np.allclose(allcov[name], o.covobs[name].cov):
-1173 raise Exception('Inconsistent covariance matrices for %s!' % (name))
-1174 else:
-1175 allcov[name] = o.covobs[name].cov
-1176
-1177 n_obs = len(raveled_data)
-1178 new_names = sorted(set([y for x in [o.names for o in raveled_data] for y in x]))
-1179 new_cov_names = sorted(set([y for x in [o.cov_names for o in raveled_data] for y in x]))
-1180 new_sample_names = sorted(set(new_names) - set(new_cov_names))
-1181
-1182 is_merged = {name: (len(list(filter(lambda o: o.is_merged.get(name, False) is True, raveled_data))) > 0) for name in new_sample_names}
-1183 reweighted = len(list(filter(lambda o: o.reweighted is True, raveled_data))) > 0
+1162 data = np.asarray(data)
+1163 raveled_data = data.ravel()
+1164
+1165 # Workaround for matrix operations containing non Obs data
+1166 if not all(isinstance(x, Obs) for x in raveled_data):
+1167 for i in range(len(raveled_data)):
+1168 if isinstance(raveled_data[i], (int, float)):
+1169 raveled_data[i] = cov_Obs(raveled_data[i], 0.0, "###dummy_covobs###")
+1170
+1171 allcov = {}
+1172 for o in raveled_data:
+1173 for name in o.cov_names:
+1174 if name in allcov:
+1175 if not np.allclose(allcov[name], o.covobs[name].cov):
+1176 raise Exception('Inconsistent covariance matrices for %s!' % (name))
+1177 else:
+1178 allcov[name] = o.covobs[name].cov
+1179
+1180 n_obs = len(raveled_data)
+1181 new_names = sorted(set([y for x in [o.names for o in raveled_data] for y in x]))
+1182 new_cov_names = sorted(set([y for x in [o.cov_names for o in raveled_data] for y in x]))
+1183 new_sample_names = sorted(set(new_names) - set(new_cov_names))
1184
-1185 if data.ndim == 1:
-1186 values = np.array([o.value for o in data])
-1187 else:
-1188 values = np.vectorize(lambda x: x.value)(data)
-1189
-1190 new_values = func(values, **kwargs)
-1191
-1192 multi = int(isinstance(new_values, np.ndarray))
-1193
-1194 new_r_values = {}
-1195 new_idl_d = {}
-1196 for name in new_sample_names:
-1197 idl = []
-1198 tmp_values = np.zeros(n_obs)
-1199 for i, item in enumerate(raveled_data):
-1200 tmp_values[i] = item.r_values.get(name, item.value)
-1201 tmp_idl = item.idl.get(name)
-1202 if tmp_idl is not None:
-1203 idl.append(tmp_idl)
-1204 if multi > 0:
-1205 tmp_values = np.array(tmp_values).reshape(data.shape)
-1206 new_r_values[name] = func(tmp_values, **kwargs)
-1207 new_idl_d[name] = _merge_idx(idl)
-1208 if not is_merged[name]:
-1209 is_merged[name] = (1 != len(set([len(idx) for idx in [*idl, new_idl_d[name]]])))
-1210
-1211 if 'man_grad' in kwargs:
-1212 deriv = np.asarray(kwargs.get('man_grad'))
-1213 if new_values.shape + data.shape != deriv.shape:
-1214 raise Exception('Manual derivative does not have correct shape.')
-1215 elif kwargs.get('num_grad') is True:
-1216 if multi > 0:
-1217 raise Exception('Multi mode currently not supported for numerical derivative')
-1218 options = {
-1219 'base_step': 0.1,
-1220 'step_ratio': 2.5}
-1221 for key in options.keys():
-1222 kwarg = kwargs.get(key)
-1223 if kwarg is not None:
-1224 options[key] = kwarg
-1225 tmp_df = nd.Gradient(func, order=4, **{k: v for k, v in options.items() if v is not None})(values, **kwargs)
-1226 if tmp_df.size == 1:
-1227 deriv = np.array([tmp_df.real])
-1228 else:
-1229 deriv = tmp_df.real
-1230 else:
-1231 deriv = jacobian(func)(values, **kwargs)
-1232
-1233 final_result = np.zeros(new_values.shape, dtype=object)
-1234
-1235 if array_mode is True:
-1236
-1237 class _Zero_grad():
-1238 def __init__(self, N):
-1239 self.grad = np.zeros((N, 1))
-1240
-1241 new_covobs_lengths = dict(set([y for x in [[(n, o.covobs[n].N) for n in o.cov_names] for o in raveled_data] for y in x]))
-1242 d_extracted = {}
-1243 g_extracted = {}
-1244 for name in new_sample_names:
-1245 d_extracted[name] = []
-1246 ens_length = len(new_idl_d[name])
-1247 for i_dat, dat in enumerate(data):
-1248 d_extracted[name].append(np.array([_expand_deltas_for_merge(o.deltas.get(name, np.zeros(ens_length)), o.idl.get(name, new_idl_d[name]), o.shape.get(name, ens_length), new_idl_d[name]) for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (ens_length, )))
-1249 for name in new_cov_names:
-1250 g_extracted[name] = []
-1251 zero_grad = _Zero_grad(new_covobs_lengths[name])
-1252 for i_dat, dat in enumerate(data):
-1253 g_extracted[name].append(np.array([o.covobs.get(name, zero_grad).grad for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (new_covobs_lengths[name], 1)))
-1254
-1255 for i_val, new_val in np.ndenumerate(new_values):
-1256 new_deltas = {}
-1257 new_grad = {}
-1258 if array_mode is True:
-1259 for name in new_sample_names:
-1260 ens_length = d_extracted[name][0].shape[-1]
-1261 new_deltas[name] = np.zeros(ens_length)
-1262 for i_dat, dat in enumerate(d_extracted[name]):
-1263 new_deltas[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
-1264 for name in new_cov_names:
-1265 new_grad[name] = 0
-1266 for i_dat, dat in enumerate(g_extracted[name]):
-1267 new_grad[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
-1268 else:
-1269 for j_obs, obs in np.ndenumerate(data):
-1270 for name in obs.names:
-1271 if name in obs.cov_names:
-1272 new_grad[name] = new_grad.get(name, 0) + deriv[i_val + j_obs] * obs.covobs[name].grad
-1273 else:
-1274 new_deltas[name] = new_deltas.get(name, 0) + deriv[i_val + j_obs] * _expand_deltas_for_merge(obs.deltas[name], obs.idl[name], obs.shape[name], new_idl_d[name])
-1275
-1276 new_covobs = {name: Covobs(0, allcov[name], name, grad=new_grad[name]) for name in new_grad}
-1277
-1278 if not set(new_covobs.keys()).isdisjoint(new_deltas.keys()):
-1279 raise Exception('The same name has been used for deltas and covobs!')
-1280 new_samples = []
-1281 new_means = []
-1282 new_idl = []
-1283 new_names_obs = []
-1284 for name in new_names:
-1285 if name not in new_covobs:
-1286 if is_merged[name]:
-1287 filtered_deltas, filtered_idl_d = _filter_zeroes(new_deltas[name], new_idl_d[name])
-1288 else:
-1289 filtered_deltas = new_deltas[name]
-1290 filtered_idl_d = new_idl_d[name]
-1291
-1292 new_samples.append(filtered_deltas)
-1293 new_idl.append(filtered_idl_d)
-1294 new_means.append(new_r_values[name][i_val])
-1295 new_names_obs.append(name)
-1296 final_result[i_val] = Obs(new_samples, new_names_obs, means=new_means, idl=new_idl)
-1297 for name in new_covobs:
-1298 final_result[i_val].names.append(name)
-1299 final_result[i_val]._covobs = new_covobs
-1300 final_result[i_val]._value = new_val
-1301 final_result[i_val].is_merged = is_merged
-1302 final_result[i_val].reweighted = reweighted
-1303
-1304 if multi == 0:
-1305 final_result = final_result.item()
+1185 is_merged = {name: (len(list(filter(lambda o: o.is_merged.get(name, False) is True, raveled_data))) > 0) for name in new_sample_names}
+1186 reweighted = len(list(filter(lambda o: o.reweighted is True, raveled_data))) > 0
+1187
+1188 if data.ndim == 1:
+1189 values = np.array([o.value for o in data])
+1190 else:
+1191 values = np.vectorize(lambda x: x.value)(data)
+1192
+1193 new_values = func(values, **kwargs)
+1194
+1195 multi = int(isinstance(new_values, np.ndarray))
+1196
+1197 new_r_values = {}
+1198 new_idl_d = {}
+1199 for name in new_sample_names:
+1200 idl = []
+1201 tmp_values = np.zeros(n_obs)
+1202 for i, item in enumerate(raveled_data):
+1203 tmp_values[i] = item.r_values.get(name, item.value)
+1204 tmp_idl = item.idl.get(name)
+1205 if tmp_idl is not None:
+1206 idl.append(tmp_idl)
+1207 if multi > 0:
+1208 tmp_values = np.array(tmp_values).reshape(data.shape)
+1209 new_r_values[name] = func(tmp_values, **kwargs)
+1210 new_idl_d[name] = _merge_idx(idl)
+1211 if not is_merged[name]:
+1212 is_merged[name] = (1 != len(set([len(idx) for idx in [*idl, new_idl_d[name]]])))
+1213
+1214 if 'man_grad' in kwargs:
+1215 deriv = np.asarray(kwargs.get('man_grad'))
+1216 if new_values.shape + data.shape != deriv.shape:
+1217 raise Exception('Manual derivative does not have correct shape.')
+1218 elif kwargs.get('num_grad') is True:
+1219 if multi > 0:
+1220 raise Exception('Multi mode currently not supported for numerical derivative')
+1221 options = {
+1222 'base_step': 0.1,
+1223 'step_ratio': 2.5}
+1224 for key in options.keys():
+1225 kwarg = kwargs.get(key)
+1226 if kwarg is not None:
+1227 options[key] = kwarg
+1228 tmp_df = nd.Gradient(func, order=4, **{k: v for k, v in options.items() if v is not None})(values, **kwargs)
+1229 if tmp_df.size == 1:
+1230 deriv = np.array([tmp_df.real])
+1231 else:
+1232 deriv = tmp_df.real
+1233 else:
+1234 deriv = jacobian(func)(values, **kwargs)
+1235
+1236 final_result = np.zeros(new_values.shape, dtype=object)
+1237
+1238 if array_mode is True:
+1239
+1240 class _Zero_grad():
+1241 def __init__(self, N):
+1242 self.grad = np.zeros((N, 1))
+1243
+1244 new_covobs_lengths = dict(set([y for x in [[(n, o.covobs[n].N) for n in o.cov_names] for o in raveled_data] for y in x]))
+1245 d_extracted = {}
+1246 g_extracted = {}
+1247 for name in new_sample_names:
+1248 d_extracted[name] = []
+1249 ens_length = len(new_idl_d[name])
+1250 for i_dat, dat in enumerate(data):
+1251 d_extracted[name].append(np.array([_expand_deltas_for_merge(o.deltas.get(name, np.zeros(ens_length)), o.idl.get(name, new_idl_d[name]), o.shape.get(name, ens_length), new_idl_d[name]) for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (ens_length, )))
+1252 for name in new_cov_names:
+1253 g_extracted[name] = []
+1254 zero_grad = _Zero_grad(new_covobs_lengths[name])
+1255 for i_dat, dat in enumerate(data):
+1256 g_extracted[name].append(np.array([o.covobs.get(name, zero_grad).grad for o in dat.reshape(np.prod(dat.shape))]).reshape(dat.shape + (new_covobs_lengths[name], 1)))
+1257
+1258 for i_val, new_val in np.ndenumerate(new_values):
+1259 new_deltas = {}
+1260 new_grad = {}
+1261 if array_mode is True:
+1262 for name in new_sample_names:
+1263 ens_length = d_extracted[name][0].shape[-1]
+1264 new_deltas[name] = np.zeros(ens_length)
+1265 for i_dat, dat in enumerate(d_extracted[name]):
+1266 new_deltas[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
+1267 for name in new_cov_names:
+1268 new_grad[name] = 0
+1269 for i_dat, dat in enumerate(g_extracted[name]):
+1270 new_grad[name] += np.tensordot(deriv[i_val + (i_dat, )], dat)
+1271 else:
+1272 for j_obs, obs in np.ndenumerate(data):
+1273 for name in obs.names:
+1274 if name in obs.cov_names:
+1275 new_grad[name] = new_grad.get(name, 0) + deriv[i_val + j_obs] * obs.covobs[name].grad
+1276 else:
+1277 new_deltas[name] = new_deltas.get(name, 0) + deriv[i_val + j_obs] * _expand_deltas_for_merge(obs.deltas[name], obs.idl[name], obs.shape[name], new_idl_d[name])
+1278
+1279 new_covobs = {name: Covobs(0, allcov[name], name, grad=new_grad[name]) for name in new_grad}
+1280
+1281 if not set(new_covobs.keys()).isdisjoint(new_deltas.keys()):
+1282 raise Exception('The same name has been used for deltas and covobs!')
+1283 new_samples = []
+1284 new_means = []
+1285 new_idl = []
+1286 new_names_obs = []
+1287 for name in new_names:
+1288 if name not in new_covobs:
+1289 if is_merged[name]:
+1290 filtered_deltas, filtered_idl_d = _filter_zeroes(new_deltas[name], new_idl_d[name])
+1291 else:
+1292 filtered_deltas = new_deltas[name]
+1293 filtered_idl_d = new_idl_d[name]
+1294
+1295 new_samples.append(filtered_deltas)
+1296 new_idl.append(filtered_idl_d)
+1297 new_means.append(new_r_values[name][i_val])
+1298 new_names_obs.append(name)
+1299 final_result[i_val] = Obs(new_samples, new_names_obs, means=new_means, idl=new_idl)
+1300 for name in new_covobs:
+1301 final_result[i_val].names.append(name)
+1302 final_result[i_val]._covobs = new_covobs
+1303 final_result[i_val]._value = new_val
+1304 final_result[i_val].is_merged = is_merged
+1305 final_result[i_val].reweighted = reweighted
1306
-1307 return final_result
+1307 if multi == 0:
+1308 final_result = final_result.item()
+1309
+1310 return final_result
1344def reweight(weight, obs, **kwargs):
-1345 """Reweight a list of observables.
-1346
-1347 Parameters
-1348 ----------
-1349 weight : Obs
-1350 Reweighting factor. An Observable that has to be defined on a superset of the
-1351 configurations in obs[i].idl for all i.
-1352 obs : list
-1353 list of Obs, e.g. [obs1, obs2, obs3].
-1354 all_configs : bool
-1355 if True, the reweighted observables are normalized by the average of
-1356 the reweighting factor on all configurations in weight.idl and not
-1357 on the configurations in obs[i].idl. Default False.
-1358 """
-1359 result = []
-1360 for i in range(len(obs)):
-1361 if len(obs[i].cov_names):
-1362 raise Exception('Error: Not possible to reweight an Obs that contains covobs!')
-1363 if not set(obs[i].names).issubset(weight.names):
-1364 raise Exception('Error: Ensembles do not fit')
-1365 for name in obs[i].names:
-1366 if not set(obs[i].idl[name]).issubset(weight.idl[name]):
-1367 raise Exception('obs[%d] has to be defined on a subset of the configs in weight.idl[%s]!' % (i, name))
-1368 new_samples = []
-1369 w_deltas = {}
-1370 for name in sorted(obs[i].names):
-1371 w_deltas[name] = _reduce_deltas(weight.deltas[name], weight.idl[name], obs[i].idl[name])
-1372 new_samples.append((w_deltas[name] + weight.r_values[name]) * (obs[i].deltas[name] + obs[i].r_values[name]))
-1373 tmp_obs = Obs(new_samples, sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
-1374
-1375 if kwargs.get('all_configs'):
-1376 new_weight = weight
-1377 else:
-1378 new_weight = Obs([w_deltas[name] + weight.r_values[name] for name in sorted(obs[i].names)], sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
-1379
-1380 result.append(tmp_obs / new_weight)
-1381 result[-1].reweighted = True
-1382 result[-1].is_merged = obs[i].is_merged
-1383
-1384 return result
+ 1347def reweight(weight, obs, **kwargs):
+1348 """Reweight a list of observables.
+1349
+1350 Parameters
+1351 ----------
+1352 weight : Obs
+1353 Reweighting factor. An Observable that has to be defined on a superset of the
+1354 configurations in obs[i].idl for all i.
+1355 obs : list
+1356 list of Obs, e.g. [obs1, obs2, obs3].
+1357 all_configs : bool
+1358 if True, the reweighted observables are normalized by the average of
+1359 the reweighting factor on all configurations in weight.idl and not
+1360 on the configurations in obs[i].idl. Default False.
+1361 """
+1362 result = []
+1363 for i in range(len(obs)):
+1364 if len(obs[i].cov_names):
+1365 raise Exception('Error: Not possible to reweight an Obs that contains covobs!')
+1366 if not set(obs[i].names).issubset(weight.names):
+1367 raise Exception('Error: Ensembles do not fit')
+1368 for name in obs[i].names:
+1369 if not set(obs[i].idl[name]).issubset(weight.idl[name]):
+1370 raise Exception('obs[%d] has to be defined on a subset of the configs in weight.idl[%s]!' % (i, name))
+1371 new_samples = []
+1372 w_deltas = {}
+1373 for name in sorted(obs[i].names):
+1374 w_deltas[name] = _reduce_deltas(weight.deltas[name], weight.idl[name], obs[i].idl[name])
+1375 new_samples.append((w_deltas[name] + weight.r_values[name]) * (obs[i].deltas[name] + obs[i].r_values[name]))
+1376 tmp_obs = Obs(new_samples, sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
+1377
+1378 if kwargs.get('all_configs'):
+1379 new_weight = weight
+1380 else:
+1381 new_weight = Obs([w_deltas[name] + weight.r_values[name] for name in sorted(obs[i].names)], sorted(obs[i].names), idl=[obs[i].idl[name] for name in sorted(obs[i].names)])
+1382
+1383 result.append(tmp_obs / new_weight)
+1384 result[-1].reweighted = True
+1385 result[-1].is_merged = obs[i].is_merged
+1386
+1387 return result
1387def correlate(obs_a, obs_b):
-1388 """Correlate two observables.
-1389
-1390 Parameters
-1391 ----------
-1392 obs_a : Obs
-1393 First observable
-1394 obs_b : Obs
-1395 Second observable
-1396
-1397 Notes
-1398 -----
-1399 Keep in mind to only correlate primary observables which have not been reweighted
-1400 yet. The reweighting has to be applied after correlating the observables.
-1401 Currently only works if ensembles are identical (this is not strictly necessary).
-1402 """
-1403
-1404 if sorted(obs_a.names) != sorted(obs_b.names):
-1405 raise Exception(f"Ensembles do not fit {set(sorted(obs_a.names)) ^ set(sorted(obs_b.names))}")
-1406 if len(obs_a.cov_names) or len(obs_b.cov_names):
-1407 raise Exception('Error: Not possible to correlate Obs that contain covobs!')
-1408 for name in obs_a.names:
-1409 if obs_a.shape[name] != obs_b.shape[name]:
-1410 raise Exception('Shapes of ensemble', name, 'do not fit')
-1411 if obs_a.idl[name] != obs_b.idl[name]:
-1412 raise Exception('idl of ensemble', name, 'do not fit')
-1413
-1414 if obs_a.reweighted is True:
-1415 warnings.warn("The first observable is already reweighted.", RuntimeWarning)
-1416 if obs_b.reweighted is True:
-1417 warnings.warn("The second observable is already reweighted.", RuntimeWarning)
-1418
-1419 new_samples = []
-1420 new_idl = []
-1421 for name in sorted(obs_a.names):
-1422 new_samples.append((obs_a.deltas[name] + obs_a.r_values[name]) * (obs_b.deltas[name] + obs_b.r_values[name]))
-1423 new_idl.append(obs_a.idl[name])
-1424
-1425 o = Obs(new_samples, sorted(obs_a.names), idl=new_idl)
-1426 o.is_merged = {name: (obs_a.is_merged.get(name, False) or obs_b.is_merged.get(name, False)) for name in o.names}
-1427 o.reweighted = obs_a.reweighted or obs_b.reweighted
-1428 return o
+ 1390def correlate(obs_a, obs_b):
+1391 """Correlate two observables.
+1392
+1393 Parameters
+1394 ----------
+1395 obs_a : Obs
+1396 First observable
+1397 obs_b : Obs
+1398 Second observable
+1399
+1400 Notes
+1401 -----
+1402 Keep in mind to only correlate primary observables which have not been reweighted
+1403 yet. The reweighting has to be applied after correlating the observables.
+1404 Currently only works if ensembles are identical (this is not strictly necessary).
+1405 """
+1406
+1407 if sorted(obs_a.names) != sorted(obs_b.names):
+1408 raise Exception(f"Ensembles do not fit {set(sorted(obs_a.names)) ^ set(sorted(obs_b.names))}")
+1409 if len(obs_a.cov_names) or len(obs_b.cov_names):
+1410 raise Exception('Error: Not possible to correlate Obs that contain covobs!')
+1411 for name in obs_a.names:
+1412 if obs_a.shape[name] != obs_b.shape[name]:
+1413 raise Exception('Shapes of ensemble', name, 'do not fit')
+1414 if obs_a.idl[name] != obs_b.idl[name]:
+1415 raise Exception('idl of ensemble', name, 'do not fit')
+1416
+1417 if obs_a.reweighted is True:
+1418 warnings.warn("The first observable is already reweighted.", RuntimeWarning)
+1419 if obs_b.reweighted is True:
+1420 warnings.warn("The second observable is already reweighted.", RuntimeWarning)
+1421
+1422 new_samples = []
+1423 new_idl = []
+1424 for name in sorted(obs_a.names):
+1425 new_samples.append((obs_a.deltas[name] + obs_a.r_values[name]) * (obs_b.deltas[name] + obs_b.r_values[name]))
+1426 new_idl.append(obs_a.idl[name])
+1427
+1428 o = Obs(new_samples, sorted(obs_a.names), idl=new_idl)
+1429 o.is_merged = {name: (obs_a.is_merged.get(name, False) or obs_b.is_merged.get(name, False)) for name in o.names}
+1430 o.reweighted = obs_a.reweighted or obs_b.reweighted
+1431 return o
1431def covariance(obs, visualize=False, correlation=False, smooth=None, **kwargs):
-1432 r'''Calculates the error covariance matrix of a set of observables.
-1433
-1434 WARNING: This function should be used with care, especially for observables with support on multiple
-1435 ensembles with differing autocorrelations. See the notes below for details.
+ 1434def covariance(obs, visualize=False, correlation=False, smooth=None, **kwargs):
+1435 r'''Calculates the error covariance matrix of a set of observables.
1436
-1437 The gamma method has to be applied first to all observables.
-1438
-1439 Parameters
-1440 ----------
-1441 obs : list or numpy.ndarray
-1442 List or one dimensional array of Obs
-1443 visualize : bool
-1444 If True plots the corresponding normalized correlation matrix (default False).
-1445 correlation : bool
-1446 If True the correlation matrix instead of the error covariance matrix is returned (default False).
-1447 smooth : None or int
-1448 If smooth is an integer 'E' between 2 and the dimension of the matrix minus 1 the eigenvalue
-1449 smoothing procedure of hep-lat/9412087 is applied to the correlation matrix which leaves the
-1450 largest E eigenvalues essentially unchanged and smoothes the smaller eigenvalues to avoid extremely
-1451 small ones.
-1452
-1453 Notes
-1454 -----
-1455 The error covariance is defined such that it agrees with the squared standard error for two identical observables
-1456 $$\operatorname{cov}(a,a)=\sum_{s=1}^N\delta_a^s\delta_a^s/N^2=\Gamma_{aa}(0)/N=\operatorname{var}(a)/N=\sigma_a^2$$
-1457 in the absence of autocorrelation.
-1458 The error covariance is estimated by calculating the correlation matrix assuming no autocorrelation and then rescaling the correlation matrix by the full errors including the previous gamma method estimate for the autocorrelation of the observables. The covariance at windowsize 0 is guaranteed to be positive semi-definite
-1459 $$\sum_{i,j}v_i\Gamma_{ij}(0)v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i,j}v_i\delta_i^s\delta_j^s v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i}|v_i\delta_i^s|^2\geq 0\,,$$ for every $v\in\mathbb{R}^M$, while such an identity does not hold for larger windows/lags.
-1460 For observables defined on a single ensemble our approximation is equivalent to assuming that the integrated autocorrelation time of an off-diagonal element is equal to the geometric mean of the integrated autocorrelation times of the corresponding diagonal elements.
-1461 $$\tau_{\mathrm{int}, ij}=\sqrt{\tau_{\mathrm{int}, i}\times \tau_{\mathrm{int}, j}}$$
-1462 This construction ensures that the estimated covariance matrix is positive semi-definite (up to numerical rounding errors).
-1463 '''
-1464
-1465 length = len(obs)
-1466
-1467 max_samples = np.max([o.N for o in obs])
-1468 if max_samples <= length and not [item for sublist in [o.cov_names for o in obs] for item in sublist]:
-1469 warnings.warn(f"The dimension of the covariance matrix ({length}) is larger or equal to the number of samples ({max_samples}). This will result in a rank deficient matrix.", RuntimeWarning)
-1470
-1471 cov = np.zeros((length, length))
-1472 for i in range(length):
-1473 for j in range(i, length):
-1474 cov[i, j] = _covariance_element(obs[i], obs[j])
-1475 cov = cov + cov.T - np.diag(np.diag(cov))
-1476
-1477 corr = np.diag(1 / np.sqrt(np.diag(cov))) @ cov @ np.diag(1 / np.sqrt(np.diag(cov)))
-1478
-1479 if isinstance(smooth, int):
-1480 corr = _smooth_eigenvalues(corr, smooth)
+1437 WARNING: This function should be used with care, especially for observables with support on multiple
+1438 ensembles with differing autocorrelations. See the notes below for details.
+1439
+1440 The gamma method has to be applied first to all observables.
+1441
+1442 Parameters
+1443 ----------
+1444 obs : list or numpy.ndarray
+1445 List or one dimensional array of Obs
+1446 visualize : bool
+1447 If True plots the corresponding normalized correlation matrix (default False).
+1448 correlation : bool
+1449 If True the correlation matrix instead of the error covariance matrix is returned (default False).
+1450 smooth : None or int
+1451 If smooth is an integer 'E' between 2 and the dimension of the matrix minus 1 the eigenvalue
+1452 smoothing procedure of hep-lat/9412087 is applied to the correlation matrix which leaves the
+1453 largest E eigenvalues essentially unchanged and smoothes the smaller eigenvalues to avoid extremely
+1454 small ones.
+1455
+1456 Notes
+1457 -----
+1458 The error covariance is defined such that it agrees with the squared standard error for two identical observables
+1459 $$\operatorname{cov}(a,a)=\sum_{s=1}^N\delta_a^s\delta_a^s/N^2=\Gamma_{aa}(0)/N=\operatorname{var}(a)/N=\sigma_a^2$$
+1460 in the absence of autocorrelation.
+1461 The error covariance is estimated by calculating the correlation matrix assuming no autocorrelation and then rescaling the correlation matrix by the full errors including the previous gamma method estimate for the autocorrelation of the observables. The covariance at windowsize 0 is guaranteed to be positive semi-definite
+1462 $$\sum_{i,j}v_i\Gamma_{ij}(0)v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i,j}v_i\delta_i^s\delta_j^s v_j=\frac{1}{N}\sum_{s=1}^N\sum_{i}|v_i\delta_i^s|^2\geq 0\,,$$ for every $v\in\mathbb{R}^M$, while such an identity does not hold for larger windows/lags.
+1463 For observables defined on a single ensemble our approximation is equivalent to assuming that the integrated autocorrelation time of an off-diagonal element is equal to the geometric mean of the integrated autocorrelation times of the corresponding diagonal elements.
+1464 $$\tau_{\mathrm{int}, ij}=\sqrt{\tau_{\mathrm{int}, i}\times \tau_{\mathrm{int}, j}}$$
+1465 This construction ensures that the estimated covariance matrix is positive semi-definite (up to numerical rounding errors).
+1466 '''
+1467
+1468 length = len(obs)
+1469
+1470 max_samples = np.max([o.N for o in obs])
+1471 if max_samples <= length and not [item for sublist in [o.cov_names for o in obs] for item in sublist]:
+1472 warnings.warn(f"The dimension of the covariance matrix ({length}) is larger or equal to the number of samples ({max_samples}). This will result in a rank deficient matrix.", RuntimeWarning)
+1473
+1474 cov = np.zeros((length, length))
+1475 for i in range(length):
+1476 for j in range(i, length):
+1477 cov[i, j] = _covariance_element(obs[i], obs[j])
+1478 cov = cov + cov.T - np.diag(np.diag(cov))
+1479
+1480 corr = np.diag(1 / np.sqrt(np.diag(cov))) @ cov @ np.diag(1 / np.sqrt(np.diag(cov)))
1481
-1482 if visualize:
-1483 plt.matshow(corr, vmin=-1, vmax=1)
-1484 plt.set_cmap('RdBu')
-1485 plt.colorbar()
-1486 plt.draw()
-1487
-1488 if correlation is True:
-1489 return corr
+1482 if isinstance(smooth, int):
+1483 corr = _smooth_eigenvalues(corr, smooth)
+1484
+1485 if visualize:
+1486 plt.matshow(corr, vmin=-1, vmax=1)
+1487 plt.set_cmap('RdBu')
+1488 plt.colorbar()
+1489 plt.draw()
1490
-1491 errors = [o.dvalue for o in obs]
-1492 cov = np.diag(errors) @ corr @ np.diag(errors)
+1491 if correlation is True:
+1492 return corr
1493
-1494 eigenvalues = np.linalg.eigh(cov)[0]
-1495 if not np.all(eigenvalues >= 0):
-1496 warnings.warn("Covariance matrix is not positive semi-definite (Eigenvalues: " + str(eigenvalues) + ")", RuntimeWarning)
-1497
-1498 return cov
+1494 errors = [o.dvalue for o in obs]
+1495 cov = np.diag(errors) @ corr @ np.diag(errors)
+1496
+1497 eigenvalues = np.linalg.eigh(cov)[0]
+1498 if not np.all(eigenvalues >= 0):
+1499 warnings.warn("Covariance matrix is not positive semi-definite (Eigenvalues: " + str(eigenvalues) + ")", RuntimeWarning)
+1500
+1501 return cov
1578def import_jackknife(jacks, name, idl=None):
-1579 """Imports jackknife samples and returns an Obs
-1580
-1581 Parameters
-1582 ----------
-1583 jacks : numpy.ndarray
-1584 numpy array containing the mean value as zeroth entry and
-1585 the N jackknife samples as first to Nth entry.
-1586 name : str
-1587 name of the ensemble the samples are defined on.
-1588 """
-1589 length = len(jacks) - 1
-1590 prj = (np.ones((length, length)) - (length - 1) * np.identity(length))
-1591 samples = jacks[1:] @ prj
-1592 mean = np.mean(samples)
-1593 new_obs = Obs([samples - mean], [name], idl=idl, means=[mean])
-1594 new_obs._value = jacks[0]
-1595 return new_obs
+ 1581def import_jackknife(jacks, name, idl=None):
+1582 """Imports jackknife samples and returns an Obs
+1583
+1584 Parameters
+1585 ----------
+1586 jacks : numpy.ndarray
+1587 numpy array containing the mean value as zeroth entry and
+1588 the N jackknife samples as first to Nth entry.
+1589 name : str
+1590 name of the ensemble the samples are defined on.
+1591 """
+1592 length = len(jacks) - 1
+1593 prj = (np.ones((length, length)) - (length - 1) * np.identity(length))
+1594 samples = jacks[1:] @ prj
+1595 mean = np.mean(samples)
+1596 new_obs = Obs([samples - mean], [name], idl=idl, means=[mean])
+1597 new_obs._value = jacks[0]
+1598 return new_obs
1598def merge_obs(list_of_obs):
-1599 """Combine all observables in list_of_obs into one new observable
-1600
-1601 Parameters
-1602 ----------
-1603 list_of_obs : list
-1604 list of the Obs object to be combined
-1605
-1606 Notes
-1607 -----
-1608 It is not possible to combine obs which are based on the same replicum
-1609 """
-1610 replist = [item for obs in list_of_obs for item in obs.names]
-1611 if (len(replist) == len(set(replist))) is False:
-1612 raise Exception('list_of_obs contains duplicate replica: %s' % (str(replist)))
-1613 if any([len(o.cov_names) for o in list_of_obs]):
-1614 raise Exception('Not possible to merge data that contains covobs!')
-1615 new_dict = {}
-1616 idl_dict = {}
-1617 for o in list_of_obs:
-1618 new_dict.update({key: o.deltas.get(key, 0) + o.r_values.get(key, 0)
-1619 for key in set(o.deltas) | set(o.r_values)})
-1620 idl_dict.update({key: o.idl.get(key, 0) for key in set(o.deltas)})
-1621
-1622 names = sorted(new_dict.keys())
-1623 o = Obs([new_dict[name] for name in names], names, idl=[idl_dict[name] for name in names])
-1624 o.is_merged = {name: np.any([oi.is_merged.get(name, False) for oi in list_of_obs]) for name in o.names}
-1625 o.reweighted = np.max([oi.reweighted for oi in list_of_obs])
-1626 return o
+ 1601def merge_obs(list_of_obs):
+1602 """Combine all observables in list_of_obs into one new observable
+1603
+1604 Parameters
+1605 ----------
+1606 list_of_obs : list
+1607 list of the Obs object to be combined
+1608
+1609 Notes
+1610 -----
+1611 It is not possible to combine obs which are based on the same replicum
+1612 """
+1613 replist = [item for obs in list_of_obs for item in obs.names]
+1614 if (len(replist) == len(set(replist))) is False:
+1615 raise Exception('list_of_obs contains duplicate replica: %s' % (str(replist)))
+1616 if any([len(o.cov_names) for o in list_of_obs]):
+1617 raise Exception('Not possible to merge data that contains covobs!')
+1618 new_dict = {}
+1619 idl_dict = {}
+1620 for o in list_of_obs:
+1621 new_dict.update({key: o.deltas.get(key, 0) + o.r_values.get(key, 0)
+1622 for key in set(o.deltas) | set(o.r_values)})
+1623 idl_dict.update({key: o.idl.get(key, 0) for key in set(o.deltas)})
+1624
+1625 names = sorted(new_dict.keys())
+1626 o = Obs([new_dict[name] for name in names], names, idl=[idl_dict[name] for name in names])
+1627 o.is_merged = {name: np.any([oi.is_merged.get(name, False) for oi in list_of_obs]) for name in o.names}
+1628 o.reweighted = np.max([oi.reweighted for oi in list_of_obs])
+1629 return o
1629def cov_Obs(means, cov, name, grad=None):
-1630 """Create an Obs based on mean(s) and a covariance matrix
-1631
-1632 Parameters
-1633 ----------
-1634 mean : list of floats or float
-1635 N mean value(s) of the new Obs
-1636 cov : list or array
-1637 2d (NxN) Covariance matrix, 1d diagonal entries or 0d covariance
-1638 name : str
-1639 identifier for the covariance matrix
-1640 grad : list or array
-1641 Gradient of the Covobs wrt. the means belonging to cov.
-1642 """
-1643
-1644 def covobs_to_obs(co):
-1645 """Make an Obs out of a Covobs
+ 1632def cov_Obs(means, cov, name, grad=None):
+1633 """Create an Obs based on mean(s) and a covariance matrix
+1634
+1635 Parameters
+1636 ----------
+1637 mean : list of floats or float
+1638 N mean value(s) of the new Obs
+1639 cov : list or array
+1640 2d (NxN) Covariance matrix, 1d diagonal entries or 0d covariance
+1641 name : str
+1642 identifier for the covariance matrix
+1643 grad : list or array
+1644 Gradient of the Covobs wrt. the means belonging to cov.
+1645 """
1646
-1647 Parameters
-1648 ----------
-1649 co : Covobs
-1650 Covobs to be embedded into the Obs
-1651 """
-1652 o = Obs([], [], means=[])
-1653 o._value = co.value
-1654 o.names.append(co.name)
-1655 o._covobs[co.name] = co
-1656 o._dvalue = np.sqrt(co.errsq())
-1657 return o
-1658
-1659 ol = []
-1660 if isinstance(means, (float, int)):
-1661 means = [means]
-1662
-1663 for i in range(len(means)):
-1664 ol.append(covobs_to_obs(Covobs(means[i], cov, name, pos=i, grad=grad)))
-1665 if ol[0].covobs[name].N != len(means):
-1666 raise Exception('You have to provide %d mean values!' % (ol[0].N))
-1667 if len(ol) == 1:
-1668 return ol[0]
-1669 return ol
+1647 def covobs_to_obs(co):
+1648 """Make an Obs out of a Covobs
+1649
+1650 Parameters
+1651 ----------
+1652 co : Covobs
+1653 Covobs to be embedded into the Obs
+1654 """
+1655 o = Obs([], [], means=[])
+1656 o._value = co.value
+1657 o.names.append(co.name)
+1658 o._covobs[co.name] = co
+1659 o._dvalue = np.sqrt(co.errsq())
+1660 return o
+1661
+1662 ol = []
+1663 if isinstance(means, (float, int)):
+1664 means = [means]
+1665
+1666 for i in range(len(means)):
+1667 ol.append(covobs_to_obs(Covobs(means[i], cov, name, pos=i, grad=grad)))
+1668 if ol[0].covobs[name].N != len(means):
+1669 raise Exception('You have to provide %d mean values!' % (ol[0].N))
+1670 if len(ol) == 1:
+1671 return ol[0]
+1672 return ol