diff --git a/docs/pyerrors/correlators.html b/docs/pyerrors/correlators.html
index b1951891..afc027f7 100644
--- a/docs/pyerrors/correlators.html
+++ b/docs/pyerrors/correlators.html
@@ -239,1298 +239,1300 @@
23
24 """
25
- 26 def __init__(self, data_input, padding=[0, 0], prange=None):
- 27 """ Initialize a Corr object.
- 28
- 29 Parameters
- 30 ----------
- 31 data_input : list or array
- 32 list of Obs or list of arrays of Obs or array of Corrs
- 33 padding : list, optional
- 34 List with two entries where the first labels the padding
- 35 at the front of the correlator and the second the padding
- 36 at the back.
- 37 prange : list, optional
- 38 List containing the first and last timeslice of the plateau
- 39 region indentified for this correlator.
- 40 """
- 41
- 42 if isinstance(data_input, np.ndarray):
+ 26 __slots__ = ["content", "N", "T", "tag", "prange"]
+ 27
+ 28 def __init__(self, data_input, padding=[0, 0], prange=None):
+ 29 """ Initialize a Corr object.
+ 30
+ 31 Parameters
+ 32 ----------
+ 33 data_input : list or array
+ 34 list of Obs or list of arrays of Obs or array of Corrs
+ 35 padding : list, optional
+ 36 List with two entries where the first labels the padding
+ 37 at the front of the correlator and the second the padding
+ 38 at the back.
+ 39 prange : list, optional
+ 40 List containing the first and last timeslice of the plateau
+ 41 region indentified for this correlator.
+ 42 """
43
- 44 # This only works, if the array fulfills the conditions below
- 45 if not len(data_input.shape) == 2 and data_input.shape[0] == data_input.shape[1]:
- 46 raise Exception("Incompatible array shape")
- 47 if not all([isinstance(item, Corr) for item in data_input.flatten()]):
- 48 raise Exception("If the input is an array, its elements must be of type pe.Corr")
- 49 if not all([item.N == 1 for item in data_input.flatten()]):
- 50 raise Exception("Can only construct matrix correlator from single valued correlators")
- 51 if not len(set([item.T for item in data_input.flatten()])) == 1:
- 52 raise Exception("All input Correlators must be defined over the same timeslices.")
- 53
- 54 T = data_input[0, 0].T
- 55 N = data_input.shape[0]
- 56 input_as_list = []
- 57 for t in range(T):
- 58 if any([(item.content[t] is None) for item in data_input.flatten()]):
- 59 if not all([(item.content[t] is None) for item in data_input.flatten()]):
- 60 warnings.warn("Input ill-defined at different timeslices. Conversion leads to data loss!", RuntimeWarning)
- 61 input_as_list.append(None)
- 62 else:
- 63 array_at_timeslace = np.empty([N, N], dtype="object")
- 64 for i in range(N):
- 65 for j in range(N):
- 66 array_at_timeslace[i, j] = data_input[i, j][t]
- 67 input_as_list.append(array_at_timeslace)
- 68 data_input = input_as_list
- 69
- 70 if isinstance(data_input, list):
+ 44 if isinstance(data_input, np.ndarray):
+ 45
+ 46 # This only works, if the array fulfills the conditions below
+ 47 if not len(data_input.shape) == 2 and data_input.shape[0] == data_input.shape[1]:
+ 48 raise Exception("Incompatible array shape")
+ 49 if not all([isinstance(item, Corr) for item in data_input.flatten()]):
+ 50 raise Exception("If the input is an array, its elements must be of type pe.Corr")
+ 51 if not all([item.N == 1 for item in data_input.flatten()]):
+ 52 raise Exception("Can only construct matrix correlator from single valued correlators")
+ 53 if not len(set([item.T for item in data_input.flatten()])) == 1:
+ 54 raise Exception("All input Correlators must be defined over the same timeslices.")
+ 55
+ 56 T = data_input[0, 0].T
+ 57 N = data_input.shape[0]
+ 58 input_as_list = []
+ 59 for t in range(T):
+ 60 if any([(item.content[t] is None) for item in data_input.flatten()]):
+ 61 if not all([(item.content[t] is None) for item in data_input.flatten()]):
+ 62 warnings.warn("Input ill-defined at different timeslices. Conversion leads to data loss!", RuntimeWarning)
+ 63 input_as_list.append(None)
+ 64 else:
+ 65 array_at_timeslace = np.empty([N, N], dtype="object")
+ 66 for i in range(N):
+ 67 for j in range(N):
+ 68 array_at_timeslace[i, j] = data_input[i, j][t]
+ 69 input_as_list.append(array_at_timeslace)
+ 70 data_input = input_as_list
71
- 72 if all([isinstance(item, (Obs, CObs)) or item is None for item in data_input]):
- 73 _assert_equal_properties([o for o in data_input if o is not None])
- 74 self.content = [np.asarray([item]) if item is not None else None for item in data_input]
- 75 self.N = 1
- 76
- 77 elif all([isinstance(item, np.ndarray) or item is None for item in data_input]) and any([isinstance(item, np.ndarray) for item in data_input]):
- 78 self.content = data_input
- 79 noNull = [a for a in self.content if not (a is None)] # To check if the matrices are correct for all undefined elements
- 80 self.N = noNull[0].shape[0]
- 81 if self.N > 1 and noNull[0].shape[0] != noNull[0].shape[1]:
- 82 raise Exception("Smearing matrices are not NxN")
- 83 if (not all([item.shape == noNull[0].shape for item in noNull])):
- 84 raise Exception("Items in data_input are not of identical shape." + str(noNull))
- 85 else:
- 86 raise Exception("data_input contains item of wrong type")
- 87 else:
- 88 raise Exception("Data input was not given as list or correct array")
- 89
- 90 self.tag = None
+ 72 if isinstance(data_input, list):
+ 73
+ 74 if all([isinstance(item, (Obs, CObs)) or item is None for item in data_input]):
+ 75 _assert_equal_properties([o for o in data_input if o is not None])
+ 76 self.content = [np.asarray([item]) if item is not None else None for item in data_input]
+ 77 self.N = 1
+ 78
+ 79 elif all([isinstance(item, np.ndarray) or item is None for item in data_input]) and any([isinstance(item, np.ndarray) for item in data_input]):
+ 80 self.content = data_input
+ 81 noNull = [a for a in self.content if not (a is None)] # To check if the matrices are correct for all undefined elements
+ 82 self.N = noNull[0].shape[0]
+ 83 if self.N > 1 and noNull[0].shape[0] != noNull[0].shape[1]:
+ 84 raise Exception("Smearing matrices are not NxN")
+ 85 if (not all([item.shape == noNull[0].shape for item in noNull])):
+ 86 raise Exception("Items in data_input are not of identical shape." + str(noNull))
+ 87 else:
+ 88 raise Exception("data_input contains item of wrong type")
+ 89 else:
+ 90 raise Exception("Data input was not given as list or correct array")
91
- 92 # An undefined timeslice is represented by the None object
- 93 self.content = [None] * padding[0] + self.content + [None] * padding[1]
- 94 self.T = len(self.content)
- 95 self.prange = prange
- 96
- 97 def __getitem__(self, idx):
- 98 """Return the content of timeslice idx"""
- 99 if self.content[idx] is None:
- 100 return None
- 101 elif len(self.content[idx]) == 1:
- 102 return self.content[idx][0]
- 103 else:
- 104 return self.content[idx]
- 105
- 106 @property
- 107 def reweighted(self):
- 108 bool_array = np.array([list(map(lambda x: x.reweighted, o)) for o in [x for x in self.content if x is not None]])
- 109 if np.all(bool_array == 1):
- 110 return True
- 111 elif np.all(bool_array == 0):
- 112 return False
- 113 else:
- 114 raise Exception("Reweighting status of correlator corrupted.")
- 115
- 116 def gamma_method(self, **kwargs):
- 117 """Apply the gamma method to the content of the Corr."""
- 118 for item in self.content:
- 119 if not (item is None):
- 120 if self.N == 1:
- 121 item[0].gamma_method(**kwargs)
- 122 else:
- 123 for i in range(self.N):
- 124 for j in range(self.N):
- 125 item[i, j].gamma_method(**kwargs)
- 126
- 127 gm = gamma_method
+ 92 self.tag = None
+ 93
+ 94 # An undefined timeslice is represented by the None object
+ 95 self.content = [None] * padding[0] + self.content + [None] * padding[1]
+ 96 self.T = len(self.content)
+ 97 self.prange = prange
+ 98
+ 99 def __getitem__(self, idx):
+ 100 """Return the content of timeslice idx"""
+ 101 if self.content[idx] is None:
+ 102 return None
+ 103 elif len(self.content[idx]) == 1:
+ 104 return self.content[idx][0]
+ 105 else:
+ 106 return self.content[idx]
+ 107
+ 108 @property
+ 109 def reweighted(self):
+ 110 bool_array = np.array([list(map(lambda x: x.reweighted, o)) for o in [x for x in self.content if x is not None]])
+ 111 if np.all(bool_array == 1):
+ 112 return True
+ 113 elif np.all(bool_array == 0):
+ 114 return False
+ 115 else:
+ 116 raise Exception("Reweighting status of correlator corrupted.")
+ 117
+ 118 def gamma_method(self, **kwargs):
+ 119 """Apply the gamma method to the content of the Corr."""
+ 120 for item in self.content:
+ 121 if not (item is None):
+ 122 if self.N == 1:
+ 123 item[0].gamma_method(**kwargs)
+ 124 else:
+ 125 for i in range(self.N):
+ 126 for j in range(self.N):
+ 127 item[i, j].gamma_method(**kwargs)
128
- 129 def projected(self, vector_l=None, vector_r=None, normalize=False):
- 130 """We need to project the Correlator with a Vector to get a single value at each timeslice.
- 131
- 132 The method can use one or two vectors.
- 133 If two are specified it returns v1@G@v2 (the order might be very important.)
- 134 By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to
- 135 """
- 136 if self.N == 1:
- 137 raise Exception("Trying to project a Corr, that already has N=1.")
- 138
- 139 if vector_l is None:
- 140 vector_l, vector_r = np.asarray([1.] + (self.N - 1) * [0.]), np.asarray([1.] + (self.N - 1) * [0.])
- 141 elif (vector_r is None):
- 142 vector_r = vector_l
- 143 if isinstance(vector_l, list) and not isinstance(vector_r, list):
- 144 if len(vector_l) != self.T:
- 145 raise Exception("Length of vector list must be equal to T")
- 146 vector_r = [vector_r] * self.T
- 147 if isinstance(vector_r, list) and not isinstance(vector_l, list):
- 148 if len(vector_r) != self.T:
- 149 raise Exception("Length of vector list must be equal to T")
- 150 vector_l = [vector_l] * self.T
- 151
- 152 if not isinstance(vector_l, list):
- 153 if not vector_l.shape == vector_r.shape == (self.N,):
- 154 raise Exception("Vectors are of wrong shape!")
- 155 if normalize:
- 156 vector_l, vector_r = vector_l / np.sqrt((vector_l @ vector_l)), vector_r / np.sqrt(vector_r @ vector_r)
- 157 newcontent = [None if _check_for_none(self, item) else np.asarray([vector_l.T @ item @ vector_r]) for item in self.content]
- 158
- 159 else:
- 160 # There are no checks here yet. There are so many possible scenarios, where this can go wrong.
- 161 if normalize:
- 162 for t in range(self.T):
- 163 vector_l[t], vector_r[t] = vector_l[t] / np.sqrt((vector_l[t] @ vector_l[t])), vector_r[t] / np.sqrt(vector_r[t] @ vector_r[t])
- 164
- 165 newcontent = [None if (_check_for_none(self, self.content[t]) or vector_l[t] is None or vector_r[t] is None) else np.asarray([vector_l[t].T @ self.content[t] @ vector_r[t]]) for t in range(self.T)]
- 166 return Corr(newcontent)
- 167
- 168 def item(self, i, j):
- 169 """Picks the element [i,j] from every matrix and returns a correlator containing one Obs per timeslice.
- 170
- 171 Parameters
- 172 ----------
- 173 i : int
- 174 First index to be picked.
- 175 j : int
- 176 Second index to be picked.
- 177 """
- 178 if self.N == 1:
- 179 raise Exception("Trying to pick item from projected Corr")
- 180 newcontent = [None if (item is None) else item[i, j] for item in self.content]
- 181 return Corr(newcontent)
- 182
- 183 def plottable(self):
- 184 """Outputs the correlator in a plotable format.
- 185
- 186 Outputs three lists containing the timeslice index, the value on each
- 187 timeslice and the error on each timeslice.
- 188 """
- 189 if self.N != 1:
- 190 raise Exception("Can only make Corr[N=1] plottable")
- 191 x_list = [x for x in range(self.T) if not self.content[x] is None]
- 192 y_list = [y[0].value for y in self.content if y is not None]
- 193 y_err_list = [y[0].dvalue for y in self.content if y is not None]
- 194
- 195 return x_list, y_list, y_err_list
+ 129 gm = gamma_method
+ 130
+ 131 def projected(self, vector_l=None, vector_r=None, normalize=False):
+ 132 """We need to project the Correlator with a Vector to get a single value at each timeslice.
+ 133
+ 134 The method can use one or two vectors.
+ 135 If two are specified it returns v1@G@v2 (the order might be very important.)
+ 136 By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to
+ 137 """
+ 138 if self.N == 1:
+ 139 raise Exception("Trying to project a Corr, that already has N=1.")
+ 140
+ 141 if vector_l is None:
+ 142 vector_l, vector_r = np.asarray([1.] + (self.N - 1) * [0.]), np.asarray([1.] + (self.N - 1) * [0.])
+ 143 elif (vector_r is None):
+ 144 vector_r = vector_l
+ 145 if isinstance(vector_l, list) and not isinstance(vector_r, list):
+ 146 if len(vector_l) != self.T:
+ 147 raise Exception("Length of vector list must be equal to T")
+ 148 vector_r = [vector_r] * self.T
+ 149 if isinstance(vector_r, list) and not isinstance(vector_l, list):
+ 150 if len(vector_r) != self.T:
+ 151 raise Exception("Length of vector list must be equal to T")
+ 152 vector_l = [vector_l] * self.T
+ 153
+ 154 if not isinstance(vector_l, list):
+ 155 if not vector_l.shape == vector_r.shape == (self.N,):
+ 156 raise Exception("Vectors are of wrong shape!")
+ 157 if normalize:
+ 158 vector_l, vector_r = vector_l / np.sqrt((vector_l @ vector_l)), vector_r / np.sqrt(vector_r @ vector_r)
+ 159 newcontent = [None if _check_for_none(self, item) else np.asarray([vector_l.T @ item @ vector_r]) for item in self.content]
+ 160
+ 161 else:
+ 162 # There are no checks here yet. There are so many possible scenarios, where this can go wrong.
+ 163 if normalize:
+ 164 for t in range(self.T):
+ 165 vector_l[t], vector_r[t] = vector_l[t] / np.sqrt((vector_l[t] @ vector_l[t])), vector_r[t] / np.sqrt(vector_r[t] @ vector_r[t])
+ 166
+ 167 newcontent = [None if (_check_for_none(self, self.content[t]) or vector_l[t] is None or vector_r[t] is None) else np.asarray([vector_l[t].T @ self.content[t] @ vector_r[t]]) for t in range(self.T)]
+ 168 return Corr(newcontent)
+ 169
+ 170 def item(self, i, j):
+ 171 """Picks the element [i,j] from every matrix and returns a correlator containing one Obs per timeslice.
+ 172
+ 173 Parameters
+ 174 ----------
+ 175 i : int
+ 176 First index to be picked.
+ 177 j : int
+ 178 Second index to be picked.
+ 179 """
+ 180 if self.N == 1:
+ 181 raise Exception("Trying to pick item from projected Corr")
+ 182 newcontent = [None if (item is None) else item[i, j] for item in self.content]
+ 183 return Corr(newcontent)
+ 184
+ 185 def plottable(self):
+ 186 """Outputs the correlator in a plotable format.
+ 187
+ 188 Outputs three lists containing the timeslice index, the value on each
+ 189 timeslice and the error on each timeslice.
+ 190 """
+ 191 if self.N != 1:
+ 192 raise Exception("Can only make Corr[N=1] plottable")
+ 193 x_list = [x for x in range(self.T) if not self.content[x] is None]
+ 194 y_list = [y[0].value for y in self.content if y is not None]
+ 195 y_err_list = [y[0].dvalue for y in self.content if y is not None]
196
- 197 def symmetric(self):
- 198 """ Symmetrize the correlator around x0=0."""
- 199 if self.N != 1:
- 200 raise Exception('symmetric cannot be safely applied to multi-dimensional correlators.')
- 201 if self.T % 2 != 0:
- 202 raise Exception("Can not symmetrize odd T")
- 203
- 204 if self.content[0] is not None:
- 205 if np.argmax(np.abs([o[0].value if o is not None else 0 for o in self.content])) != 0:
- 206 warnings.warn("Correlator does not seem to be symmetric around x0=0.", RuntimeWarning)
- 207
- 208 newcontent = [self.content[0]]
- 209 for t in range(1, self.T):
- 210 if (self.content[t] is None) or (self.content[self.T - t] is None):
- 211 newcontent.append(None)
- 212 else:
- 213 newcontent.append(0.5 * (self.content[t] + self.content[self.T - t]))
- 214 if (all([x is None for x in newcontent])):
- 215 raise Exception("Corr could not be symmetrized: No redundant values")
- 216 return Corr(newcontent, prange=self.prange)
- 217
- 218 def anti_symmetric(self):
- 219 """Anti-symmetrize the correlator around x0=0."""
- 220 if self.N != 1:
- 221 raise Exception('anti_symmetric cannot be safely applied to multi-dimensional correlators.')
- 222 if self.T % 2 != 0:
- 223 raise Exception("Can not symmetrize odd T")
- 224
- 225 test = 1 * self
- 226 test.gamma_method()
- 227 if not all([o.is_zero_within_error(3) for o in test.content[0]]):
- 228 warnings.warn("Correlator does not seem to be anti-symmetric around x0=0.", RuntimeWarning)
- 229
- 230 newcontent = [self.content[0]]
- 231 for t in range(1, self.T):
- 232 if (self.content[t] is None) or (self.content[self.T - t] is None):
- 233 newcontent.append(None)
- 234 else:
- 235 newcontent.append(0.5 * (self.content[t] - self.content[self.T - t]))
- 236 if (all([x is None for x in newcontent])):
- 237 raise Exception("Corr could not be symmetrized: No redundant values")
- 238 return Corr(newcontent, prange=self.prange)
- 239
- 240 def is_matrix_symmetric(self):
- 241 """Checks whether a correlator matrices is symmetric on every timeslice."""
- 242 if self.N == 1:
- 243 raise Exception("Only works for correlator matrices.")
- 244 for t in range(self.T):
- 245 if self[t] is None:
- 246 continue
- 247 for i in range(self.N):
- 248 for j in range(i + 1, self.N):
- 249 if self[t][i, j] is self[t][j, i]:
- 250 continue
- 251 if hash(self[t][i, j]) != hash(self[t][j, i]):
- 252 return False
- 253 return True
- 254
- 255 def matrix_symmetric(self):
- 256 """Symmetrizes the correlator matrices on every timeslice."""
- 257 if self.N == 1:
- 258 raise Exception("Trying to symmetrize a correlator matrix, that already has N=1.")
- 259 if self.is_matrix_symmetric():
- 260 return 1.0 * self
- 261 else:
- 262 transposed = [None if _check_for_none(self, G) else G.T for G in self.content]
- 263 return 0.5 * (Corr(transposed) + self)
- 264
- 265 def GEVP(self, t0, ts=None, sort="Eigenvalue", **kwargs):
- 266 r'''Solve the generalized eigenvalue problem on the correlator matrix and returns the corresponding eigenvectors.
- 267
- 268 The eigenvectors are sorted according to the descending eigenvalues, the zeroth eigenvector(s) correspond to the
- 269 largest eigenvalue(s). The eigenvector(s) for the individual states can be accessed via slicing
- 270 ```python
- 271 C.GEVP(t0=2)[0] # Ground state vector(s)
- 272 C.GEVP(t0=2)[:3] # Vectors for the lowest three states
- 273 ```
- 274
- 275 Parameters
- 276 ----------
- 277 t0 : int
- 278 The time t0 for the right hand side of the GEVP according to $G(t)v_i=\lambda_i G(t_0)v_i$
- 279 ts : int
- 280 fixed time $G(t_s)v_i=\lambda_i G(t_0)v_i$ if sort=None.
- 281 If sort="Eigenvector" it gives a reference point for the sorting method.
- 282 sort : string
- 283 If this argument is set, a list of self.T vectors per state is returned. If it is set to None, only one vector is returned.
- 284 - "Eigenvalue": The eigenvector is chosen according to which eigenvalue it belongs individually on every timeslice.
- 285 - "Eigenvector": Use the method described in arXiv:2004.10472 to find the set of v(t) belonging to the state.
- 286 The reference state is identified by its eigenvalue at $t=t_s$.
- 287
- 288 Other Parameters
- 289 ----------------
- 290 state : int
- 291 Returns only the vector(s) for a specified state. The lowest state is zero.
- 292 '''
- 293
- 294 if self.N == 1:
- 295 raise Exception("GEVP methods only works on correlator matrices and not single correlators.")
- 296 if ts is not None:
- 297 if (ts <= t0):
- 298 raise Exception("ts has to be larger than t0.")
- 299
- 300 if "sorted_list" in kwargs:
- 301 warnings.warn("Argument 'sorted_list' is deprecated, use 'sort' instead.", DeprecationWarning)
- 302 sort = kwargs.get("sorted_list")
- 303
- 304 if self.is_matrix_symmetric():
- 305 symmetric_corr = self
- 306 else:
- 307 symmetric_corr = self.matrix_symmetric()
- 308
- 309 G0 = np.vectorize(lambda x: x.value)(symmetric_corr[t0])
- 310 np.linalg.cholesky(G0) # Check if matrix G0 is positive-semidefinite.
- 311
- 312 if sort is None:
- 313 if (ts is None):
- 314 raise Exception("ts is required if sort=None.")
- 315 if (self.content[t0] is None) or (self.content[ts] is None):
- 316 raise Exception("Corr not defined at t0/ts.")
- 317 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[ts])
- 318 reordered_vecs = _GEVP_solver(Gt, G0)
- 319
- 320 elif sort in ["Eigenvalue", "Eigenvector"]:
- 321 if sort == "Eigenvalue" and ts is not None:
- 322 warnings.warn("ts has no effect when sorting by eigenvalue is chosen.", RuntimeWarning)
- 323 all_vecs = [None] * (t0 + 1)
- 324 for t in range(t0 + 1, self.T):
- 325 try:
- 326 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[t])
- 327 all_vecs.append(_GEVP_solver(Gt, G0))
- 328 except Exception:
- 329 all_vecs.append(None)
- 330 if sort == "Eigenvector":
- 331 if ts is None:
- 332 raise Exception("ts is required for the Eigenvector sorting method.")
- 333 all_vecs = _sort_vectors(all_vecs, ts)
- 334
- 335 reordered_vecs = [[v[s] if v is not None else None for v in all_vecs] for s in range(self.N)]
- 336 else:
- 337 raise Exception("Unkown value for 'sort'.")
- 338
- 339 if "state" in kwargs:
- 340 return reordered_vecs[kwargs.get("state")]
- 341 else:
- 342 return reordered_vecs
- 343
- 344 def Eigenvalue(self, t0, ts=None, state=0, sort="Eigenvalue"):
- 345 """Determines the eigenvalue of the GEVP by solving and projecting the correlator
- 346
- 347 Parameters
- 348 ----------
- 349 state : int
- 350 The state one is interested in ordered by energy. The lowest state is zero.
- 351
- 352 All other parameters are identical to the ones of Corr.GEVP.
- 353 """
- 354 vec = self.GEVP(t0, ts=ts, sort=sort)[state]
- 355 return self.projected(vec)
- 356
- 357 def Hankel(self, N, periodic=False):
- 358 """Constructs an NxN Hankel matrix
- 359
- 360 C(t) c(t+1) ... c(t+n-1)
- 361 C(t+1) c(t+2) ... c(t+n)
- 362 .................
- 363 C(t+(n-1)) c(t+n) ... c(t+2(n-1))
- 364
- 365 Parameters
- 366 ----------
- 367 N : int
- 368 Dimension of the Hankel matrix
- 369 periodic : bool, optional
- 370 determines whether the matrix is extended periodically
- 371 """
- 372
- 373 if self.N != 1:
- 374 raise Exception("Multi-operator Prony not implemented!")
- 375
- 376 array = np.empty([N, N], dtype="object")
- 377 new_content = []
- 378 for t in range(self.T):
- 379 new_content.append(array.copy())
- 380
- 381 def wrap(i):
- 382 while i >= self.T:
- 383 i -= self.T
- 384 return i
- 385
- 386 for t in range(self.T):
- 387 for i in range(N):
- 388 for j in range(N):
- 389 if periodic:
- 390 new_content[t][i, j] = self.content[wrap(t + i + j)][0]
- 391 elif (t + i + j) >= self.T:
- 392 new_content[t] = None
- 393 else:
- 394 new_content[t][i, j] = self.content[t + i + j][0]
- 395
- 396 return Corr(new_content)
+ 197 return x_list, y_list, y_err_list
+ 198
+ 199 def symmetric(self):
+ 200 """ Symmetrize the correlator around x0=0."""
+ 201 if self.N != 1:
+ 202 raise Exception('symmetric cannot be safely applied to multi-dimensional correlators.')
+ 203 if self.T % 2 != 0:
+ 204 raise Exception("Can not symmetrize odd T")
+ 205
+ 206 if self.content[0] is not None:
+ 207 if np.argmax(np.abs([o[0].value if o is not None else 0 for o in self.content])) != 0:
+ 208 warnings.warn("Correlator does not seem to be symmetric around x0=0.", RuntimeWarning)
+ 209
+ 210 newcontent = [self.content[0]]
+ 211 for t in range(1, self.T):
+ 212 if (self.content[t] is None) or (self.content[self.T - t] is None):
+ 213 newcontent.append(None)
+ 214 else:
+ 215 newcontent.append(0.5 * (self.content[t] + self.content[self.T - t]))
+ 216 if (all([x is None for x in newcontent])):
+ 217 raise Exception("Corr could not be symmetrized: No redundant values")
+ 218 return Corr(newcontent, prange=self.prange)
+ 219
+ 220 def anti_symmetric(self):
+ 221 """Anti-symmetrize the correlator around x0=0."""
+ 222 if self.N != 1:
+ 223 raise Exception('anti_symmetric cannot be safely applied to multi-dimensional correlators.')
+ 224 if self.T % 2 != 0:
+ 225 raise Exception("Can not symmetrize odd T")
+ 226
+ 227 test = 1 * self
+ 228 test.gamma_method()
+ 229 if not all([o.is_zero_within_error(3) for o in test.content[0]]):
+ 230 warnings.warn("Correlator does not seem to be anti-symmetric around x0=0.", RuntimeWarning)
+ 231
+ 232 newcontent = [self.content[0]]
+ 233 for t in range(1, self.T):
+ 234 if (self.content[t] is None) or (self.content[self.T - t] is None):
+ 235 newcontent.append(None)
+ 236 else:
+ 237 newcontent.append(0.5 * (self.content[t] - self.content[self.T - t]))
+ 238 if (all([x is None for x in newcontent])):
+ 239 raise Exception("Corr could not be symmetrized: No redundant values")
+ 240 return Corr(newcontent, prange=self.prange)
+ 241
+ 242 def is_matrix_symmetric(self):
+ 243 """Checks whether a correlator matrices is symmetric on every timeslice."""
+ 244 if self.N == 1:
+ 245 raise Exception("Only works for correlator matrices.")
+ 246 for t in range(self.T):
+ 247 if self[t] is None:
+ 248 continue
+ 249 for i in range(self.N):
+ 250 for j in range(i + 1, self.N):
+ 251 if self[t][i, j] is self[t][j, i]:
+ 252 continue
+ 253 if hash(self[t][i, j]) != hash(self[t][j, i]):
+ 254 return False
+ 255 return True
+ 256
+ 257 def matrix_symmetric(self):
+ 258 """Symmetrizes the correlator matrices on every timeslice."""
+ 259 if self.N == 1:
+ 260 raise Exception("Trying to symmetrize a correlator matrix, that already has N=1.")
+ 261 if self.is_matrix_symmetric():
+ 262 return 1.0 * self
+ 263 else:
+ 264 transposed = [None if _check_for_none(self, G) else G.T for G in self.content]
+ 265 return 0.5 * (Corr(transposed) + self)
+ 266
+ 267 def GEVP(self, t0, ts=None, sort="Eigenvalue", **kwargs):
+ 268 r'''Solve the generalized eigenvalue problem on the correlator matrix and returns the corresponding eigenvectors.
+ 269
+ 270 The eigenvectors are sorted according to the descending eigenvalues, the zeroth eigenvector(s) correspond to the
+ 271 largest eigenvalue(s). The eigenvector(s) for the individual states can be accessed via slicing
+ 272 ```python
+ 273 C.GEVP(t0=2)[0] # Ground state vector(s)
+ 274 C.GEVP(t0=2)[:3] # Vectors for the lowest three states
+ 275 ```
+ 276
+ 277 Parameters
+ 278 ----------
+ 279 t0 : int
+ 280 The time t0 for the right hand side of the GEVP according to $G(t)v_i=\lambda_i G(t_0)v_i$
+ 281 ts : int
+ 282 fixed time $G(t_s)v_i=\lambda_i G(t_0)v_i$ if sort=None.
+ 283 If sort="Eigenvector" it gives a reference point for the sorting method.
+ 284 sort : string
+ 285 If this argument is set, a list of self.T vectors per state is returned. If it is set to None, only one vector is returned.
+ 286 - "Eigenvalue": The eigenvector is chosen according to which eigenvalue it belongs individually on every timeslice.
+ 287 - "Eigenvector": Use the method described in arXiv:2004.10472 to find the set of v(t) belonging to the state.
+ 288 The reference state is identified by its eigenvalue at $t=t_s$.
+ 289
+ 290 Other Parameters
+ 291 ----------------
+ 292 state : int
+ 293 Returns only the vector(s) for a specified state. The lowest state is zero.
+ 294 '''
+ 295
+ 296 if self.N == 1:
+ 297 raise Exception("GEVP methods only works on correlator matrices and not single correlators.")
+ 298 if ts is not None:
+ 299 if (ts <= t0):
+ 300 raise Exception("ts has to be larger than t0.")
+ 301
+ 302 if "sorted_list" in kwargs:
+ 303 warnings.warn("Argument 'sorted_list' is deprecated, use 'sort' instead.", DeprecationWarning)
+ 304 sort = kwargs.get("sorted_list")
+ 305
+ 306 if self.is_matrix_symmetric():
+ 307 symmetric_corr = self
+ 308 else:
+ 309 symmetric_corr = self.matrix_symmetric()
+ 310
+ 311 G0 = np.vectorize(lambda x: x.value)(symmetric_corr[t0])
+ 312 np.linalg.cholesky(G0) # Check if matrix G0 is positive-semidefinite.
+ 313
+ 314 if sort is None:
+ 315 if (ts is None):
+ 316 raise Exception("ts is required if sort=None.")
+ 317 if (self.content[t0] is None) or (self.content[ts] is None):
+ 318 raise Exception("Corr not defined at t0/ts.")
+ 319 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[ts])
+ 320 reordered_vecs = _GEVP_solver(Gt, G0)
+ 321
+ 322 elif sort in ["Eigenvalue", "Eigenvector"]:
+ 323 if sort == "Eigenvalue" and ts is not None:
+ 324 warnings.warn("ts has no effect when sorting by eigenvalue is chosen.", RuntimeWarning)
+ 325 all_vecs = [None] * (t0 + 1)
+ 326 for t in range(t0 + 1, self.T):
+ 327 try:
+ 328 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[t])
+ 329 all_vecs.append(_GEVP_solver(Gt, G0))
+ 330 except Exception:
+ 331 all_vecs.append(None)
+ 332 if sort == "Eigenvector":
+ 333 if ts is None:
+ 334 raise Exception("ts is required for the Eigenvector sorting method.")
+ 335 all_vecs = _sort_vectors(all_vecs, ts)
+ 336
+ 337 reordered_vecs = [[v[s] if v is not None else None for v in all_vecs] for s in range(self.N)]
+ 338 else:
+ 339 raise Exception("Unkown value for 'sort'.")
+ 340
+ 341 if "state" in kwargs:
+ 342 return reordered_vecs[kwargs.get("state")]
+ 343 else:
+ 344 return reordered_vecs
+ 345
+ 346 def Eigenvalue(self, t0, ts=None, state=0, sort="Eigenvalue"):
+ 347 """Determines the eigenvalue of the GEVP by solving and projecting the correlator
+ 348
+ 349 Parameters
+ 350 ----------
+ 351 state : int
+ 352 The state one is interested in ordered by energy. The lowest state is zero.
+ 353
+ 354 All other parameters are identical to the ones of Corr.GEVP.
+ 355 """
+ 356 vec = self.GEVP(t0, ts=ts, sort=sort)[state]
+ 357 return self.projected(vec)
+ 358
+ 359 def Hankel(self, N, periodic=False):
+ 360 """Constructs an NxN Hankel matrix
+ 361
+ 362 C(t) c(t+1) ... c(t+n-1)
+ 363 C(t+1) c(t+2) ... c(t+n)
+ 364 .................
+ 365 C(t+(n-1)) c(t+n) ... c(t+2(n-1))
+ 366
+ 367 Parameters
+ 368 ----------
+ 369 N : int
+ 370 Dimension of the Hankel matrix
+ 371 periodic : bool, optional
+ 372 determines whether the matrix is extended periodically
+ 373 """
+ 374
+ 375 if self.N != 1:
+ 376 raise Exception("Multi-operator Prony not implemented!")
+ 377
+ 378 array = np.empty([N, N], dtype="object")
+ 379 new_content = []
+ 380 for t in range(self.T):
+ 381 new_content.append(array.copy())
+ 382
+ 383 def wrap(i):
+ 384 while i >= self.T:
+ 385 i -= self.T
+ 386 return i
+ 387
+ 388 for t in range(self.T):
+ 389 for i in range(N):
+ 390 for j in range(N):
+ 391 if periodic:
+ 392 new_content[t][i, j] = self.content[wrap(t + i + j)][0]
+ 393 elif (t + i + j) >= self.T:
+ 394 new_content[t] = None
+ 395 else:
+ 396 new_content[t][i, j] = self.content[t + i + j][0]
397
- 398 def roll(self, dt):
- 399 """Periodically shift the correlator by dt timeslices
- 400
- 401 Parameters
- 402 ----------
- 403 dt : int
- 404 number of timeslices
- 405 """
- 406 return Corr(list(np.roll(np.array(self.content, dtype=object), dt)))
- 407
- 408 def reverse(self):
- 409 """Reverse the time ordering of the Corr"""
- 410 return Corr(self.content[:: -1])
- 411
- 412 def thin(self, spacing=2, offset=0):
- 413 """Thin out a correlator to suppress correlations
- 414
- 415 Parameters
- 416 ----------
- 417 spacing : int
- 418 Keep only every 'spacing'th entry of the correlator
- 419 offset : int
- 420 Offset the equal spacing
- 421 """
- 422 new_content = []
- 423 for t in range(self.T):
- 424 if (offset + t) % spacing != 0:
- 425 new_content.append(None)
- 426 else:
- 427 new_content.append(self.content[t])
- 428 return Corr(new_content)
- 429
- 430 def correlate(self, partner):
- 431 """Correlate the correlator with another correlator or Obs
- 432
- 433 Parameters
- 434 ----------
- 435 partner : Obs or Corr
- 436 partner to correlate the correlator with.
- 437 Can either be an Obs which is correlated with all entries of the
- 438 correlator or a Corr of same length.
- 439 """
- 440 if self.N != 1:
- 441 raise Exception("Only one-dimensional correlators can be safely correlated.")
- 442 new_content = []
- 443 for x0, t_slice in enumerate(self.content):
- 444 if _check_for_none(self, t_slice):
- 445 new_content.append(None)
- 446 else:
- 447 if isinstance(partner, Corr):
- 448 if _check_for_none(partner, partner.content[x0]):
- 449 new_content.append(None)
- 450 else:
- 451 new_content.append(np.array([correlate(o, partner.content[x0][0]) for o in t_slice]))
- 452 elif isinstance(partner, Obs): # Should this include CObs?
- 453 new_content.append(np.array([correlate(o, partner) for o in t_slice]))
- 454 else:
- 455 raise Exception("Can only correlate with an Obs or a Corr.")
- 456
- 457 return Corr(new_content)
+ 398 return Corr(new_content)
+ 399
+ 400 def roll(self, dt):
+ 401 """Periodically shift the correlator by dt timeslices
+ 402
+ 403 Parameters
+ 404 ----------
+ 405 dt : int
+ 406 number of timeslices
+ 407 """
+ 408 return Corr(list(np.roll(np.array(self.content, dtype=object), dt)))
+ 409
+ 410 def reverse(self):
+ 411 """Reverse the time ordering of the Corr"""
+ 412 return Corr(self.content[:: -1])
+ 413
+ 414 def thin(self, spacing=2, offset=0):
+ 415 """Thin out a correlator to suppress correlations
+ 416
+ 417 Parameters
+ 418 ----------
+ 419 spacing : int
+ 420 Keep only every 'spacing'th entry of the correlator
+ 421 offset : int
+ 422 Offset the equal spacing
+ 423 """
+ 424 new_content = []
+ 425 for t in range(self.T):
+ 426 if (offset + t) % spacing != 0:
+ 427 new_content.append(None)
+ 428 else:
+ 429 new_content.append(self.content[t])
+ 430 return Corr(new_content)
+ 431
+ 432 def correlate(self, partner):
+ 433 """Correlate the correlator with another correlator or Obs
+ 434
+ 435 Parameters
+ 436 ----------
+ 437 partner : Obs or Corr
+ 438 partner to correlate the correlator with.
+ 439 Can either be an Obs which is correlated with all entries of the
+ 440 correlator or a Corr of same length.
+ 441 """
+ 442 if self.N != 1:
+ 443 raise Exception("Only one-dimensional correlators can be safely correlated.")
+ 444 new_content = []
+ 445 for x0, t_slice in enumerate(self.content):
+ 446 if _check_for_none(self, t_slice):
+ 447 new_content.append(None)
+ 448 else:
+ 449 if isinstance(partner, Corr):
+ 450 if _check_for_none(partner, partner.content[x0]):
+ 451 new_content.append(None)
+ 452 else:
+ 453 new_content.append(np.array([correlate(o, partner.content[x0][0]) for o in t_slice]))
+ 454 elif isinstance(partner, Obs): # Should this include CObs?
+ 455 new_content.append(np.array([correlate(o, partner) for o in t_slice]))
+ 456 else:
+ 457 raise Exception("Can only correlate with an Obs or a Corr.")
458
- 459 def reweight(self, weight, **kwargs):
- 460 """Reweight the correlator.
- 461
- 462 Parameters
- 463 ----------
- 464 weight : Obs
- 465 Reweighting factor. An Observable that has to be defined on a superset of the
- 466 configurations in obs[i].idl for all i.
- 467 all_configs : bool
- 468 if True, the reweighted observables are normalized by the average of
- 469 the reweighting factor on all configurations in weight.idl and not
- 470 on the configurations in obs[i].idl.
- 471 """
- 472 if self.N != 1:
- 473 raise Exception("Reweighting only implemented for one-dimensional correlators.")
- 474 new_content = []
- 475 for t_slice in self.content:
- 476 if _check_for_none(self, t_slice):
- 477 new_content.append(None)
- 478 else:
- 479 new_content.append(np.array(reweight(weight, t_slice, **kwargs)))
- 480 return Corr(new_content)
- 481
- 482 def T_symmetry(self, partner, parity=+1):
- 483 """Return the time symmetry average of the correlator and its partner
- 484
- 485 Parameters
- 486 ----------
- 487 partner : Corr
- 488 Time symmetry partner of the Corr
- 489 partity : int
- 490 Parity quantum number of the correlator, can be +1 or -1
- 491 """
- 492 if self.N != 1:
- 493 raise Exception("T_symmetry only implemented for one-dimensional correlators.")
- 494 if not isinstance(partner, Corr):
- 495 raise Exception("T partner has to be a Corr object.")
- 496 if parity not in [+1, -1]:
- 497 raise Exception("Parity has to be +1 or -1.")
- 498 T_partner = parity * partner.reverse()
- 499
- 500 t_slices = []
- 501 test = (self - T_partner)
- 502 test.gamma_method()
- 503 for x0, t_slice in enumerate(test.content):
- 504 if t_slice is not None:
- 505 if not t_slice[0].is_zero_within_error(5):
- 506 t_slices.append(x0)
- 507 if t_slices:
- 508 warnings.warn("T symmetry partners do not agree within 5 sigma on time slices " + str(t_slices) + ".", RuntimeWarning)
- 509
- 510 return (self + T_partner) / 2
+ 459 return Corr(new_content)
+ 460
+ 461 def reweight(self, weight, **kwargs):
+ 462 """Reweight the correlator.
+ 463
+ 464 Parameters
+ 465 ----------
+ 466 weight : Obs
+ 467 Reweighting factor. An Observable that has to be defined on a superset of the
+ 468 configurations in obs[i].idl for all i.
+ 469 all_configs : bool
+ 470 if True, the reweighted observables are normalized by the average of
+ 471 the reweighting factor on all configurations in weight.idl and not
+ 472 on the configurations in obs[i].idl.
+ 473 """
+ 474 if self.N != 1:
+ 475 raise Exception("Reweighting only implemented for one-dimensional correlators.")
+ 476 new_content = []
+ 477 for t_slice in self.content:
+ 478 if _check_for_none(self, t_slice):
+ 479 new_content.append(None)
+ 480 else:
+ 481 new_content.append(np.array(reweight(weight, t_slice, **kwargs)))
+ 482 return Corr(new_content)
+ 483
+ 484 def T_symmetry(self, partner, parity=+1):
+ 485 """Return the time symmetry average of the correlator and its partner
+ 486
+ 487 Parameters
+ 488 ----------
+ 489 partner : Corr
+ 490 Time symmetry partner of the Corr
+ 491 partity : int
+ 492 Parity quantum number of the correlator, can be +1 or -1
+ 493 """
+ 494 if self.N != 1:
+ 495 raise Exception("T_symmetry only implemented for one-dimensional correlators.")
+ 496 if not isinstance(partner, Corr):
+ 497 raise Exception("T partner has to be a Corr object.")
+ 498 if parity not in [+1, -1]:
+ 499 raise Exception("Parity has to be +1 or -1.")
+ 500 T_partner = parity * partner.reverse()
+ 501
+ 502 t_slices = []
+ 503 test = (self - T_partner)
+ 504 test.gamma_method()
+ 505 for x0, t_slice in enumerate(test.content):
+ 506 if t_slice is not None:
+ 507 if not t_slice[0].is_zero_within_error(5):
+ 508 t_slices.append(x0)
+ 509 if t_slices:
+ 510 warnings.warn("T symmetry partners do not agree within 5 sigma on time slices " + str(t_slices) + ".", RuntimeWarning)
511
- 512 def deriv(self, variant="symmetric"):
- 513 """Return the first derivative of the correlator with respect to x0.
- 514
- 515 Parameters
- 516 ----------
- 517 variant : str
- 518 decides which definition of the finite differences derivative is used.
- 519 Available choice: symmetric, forward, backward, improved, log, default: symmetric
- 520 """
- 521 if self.N != 1:
- 522 raise Exception("deriv only implemented for one-dimensional correlators.")
- 523 if variant == "symmetric":
- 524 newcontent = []
- 525 for t in range(1, self.T - 1):
- 526 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
- 527 newcontent.append(None)
- 528 else:
- 529 newcontent.append(0.5 * (self.content[t + 1] - self.content[t - 1]))
- 530 if (all([x is None for x in newcontent])):
- 531 raise Exception('Derivative is undefined at all timeslices')
- 532 return Corr(newcontent, padding=[1, 1])
- 533 elif variant == "forward":
- 534 newcontent = []
- 535 for t in range(self.T - 1):
- 536 if (self.content[t] is None) or (self.content[t + 1] is None):
- 537 newcontent.append(None)
- 538 else:
- 539 newcontent.append(self.content[t + 1] - self.content[t])
- 540 if (all([x is None for x in newcontent])):
- 541 raise Exception("Derivative is undefined at all timeslices")
- 542 return Corr(newcontent, padding=[0, 1])
- 543 elif variant == "backward":
- 544 newcontent = []
- 545 for t in range(1, self.T):
- 546 if (self.content[t - 1] is None) or (self.content[t] is None):
- 547 newcontent.append(None)
- 548 else:
- 549 newcontent.append(self.content[t] - self.content[t - 1])
- 550 if (all([x is None for x in newcontent])):
- 551 raise Exception("Derivative is undefined at all timeslices")
- 552 return Corr(newcontent, padding=[1, 0])
- 553 elif variant == "improved":
- 554 newcontent = []
- 555 for t in range(2, self.T - 2):
- 556 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
- 557 newcontent.append(None)
- 558 else:
- 559 newcontent.append((1 / 12) * (self.content[t - 2] - 8 * self.content[t - 1] + 8 * self.content[t + 1] - self.content[t + 2]))
- 560 if (all([x is None for x in newcontent])):
- 561 raise Exception('Derivative is undefined at all timeslices')
- 562 return Corr(newcontent, padding=[2, 2])
- 563 elif variant == 'log':
- 564 newcontent = []
- 565 for t in range(self.T):
- 566 if (self.content[t] is None) or (self.content[t] <= 0):
- 567 newcontent.append(None)
- 568 else:
- 569 newcontent.append(np.log(self.content[t]))
- 570 if (all([x is None for x in newcontent])):
- 571 raise Exception("Log is undefined at all timeslices")
- 572 logcorr = Corr(newcontent)
- 573 return self * logcorr.deriv('symmetric')
- 574 else:
- 575 raise Exception("Unknown variant.")
- 576
- 577 def second_deriv(self, variant="symmetric"):
- 578 """Return the second derivative of the correlator with respect to x0.
- 579
- 580 Parameters
- 581 ----------
- 582 variant : str
- 583 decides which definition of the finite differences derivative is used.
- 584 Available choice: symmetric, improved, log, default: symmetric
- 585 """
- 586 if self.N != 1:
- 587 raise Exception("second_deriv only implemented for one-dimensional correlators.")
- 588 if variant == "symmetric":
- 589 newcontent = []
- 590 for t in range(1, self.T - 1):
- 591 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
- 592 newcontent.append(None)
- 593 else:
- 594 newcontent.append((self.content[t + 1] - 2 * self.content[t] + self.content[t - 1]))
- 595 if (all([x is None for x in newcontent])):
- 596 raise Exception("Derivative is undefined at all timeslices")
- 597 return Corr(newcontent, padding=[1, 1])
- 598 elif variant == "improved":
- 599 newcontent = []
- 600 for t in range(2, self.T - 2):
- 601 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
- 602 newcontent.append(None)
- 603 else:
- 604 newcontent.append((1 / 12) * (-self.content[t + 2] + 16 * self.content[t + 1] - 30 * self.content[t] + 16 * self.content[t - 1] - self.content[t - 2]))
- 605 if (all([x is None for x in newcontent])):
- 606 raise Exception("Derivative is undefined at all timeslices")
- 607 return Corr(newcontent, padding=[2, 2])
- 608 elif variant == 'log':
- 609 newcontent = []
- 610 for t in range(self.T):
- 611 if (self.content[t] is None) or (self.content[t] <= 0):
- 612 newcontent.append(None)
- 613 else:
- 614 newcontent.append(np.log(self.content[t]))
- 615 if (all([x is None for x in newcontent])):
- 616 raise Exception("Log is undefined at all timeslices")
- 617 logcorr = Corr(newcontent)
- 618 return self * (logcorr.second_deriv('symmetric') + (logcorr.deriv('symmetric'))**2)
- 619 else:
- 620 raise Exception("Unknown variant.")
- 621
- 622 def m_eff(self, variant='log', guess=1.0):
- 623 """Returns the effective mass of the correlator as correlator object
- 624
- 625 Parameters
- 626 ----------
- 627 variant : str
- 628 log : uses the standard effective mass log(C(t) / C(t+1))
- 629 cosh, periodic : Use periodicitiy of the correlator by solving C(t) / C(t+1) = cosh(m * (t - T/2)) / cosh(m * (t + 1 - T/2)) for m.
- 630 sinh : Use anti-periodicitiy of the correlator by solving C(t) / C(t+1) = sinh(m * (t - T/2)) / sinh(m * (t + 1 - T/2)) for m.
- 631 See, e.g., arXiv:1205.5380
- 632 arccosh : Uses the explicit form of the symmetrized correlator (not recommended)
- 633 logsym: uses the symmetric effective mass log(C(t-1) / C(t+1))/2
- 634 guess : float
- 635 guess for the root finder, only relevant for the root variant
- 636 """
- 637 if self.N != 1:
- 638 raise Exception('Correlator must be projected before getting m_eff')
- 639 if variant == 'log':
- 640 newcontent = []
- 641 for t in range(self.T - 1):
- 642 if ((self.content[t] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
- 643 newcontent.append(None)
- 644 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 512 return (self + T_partner) / 2
+ 513
+ 514 def deriv(self, variant="symmetric"):
+ 515 """Return the first derivative of the correlator with respect to x0.
+ 516
+ 517 Parameters
+ 518 ----------
+ 519 variant : str
+ 520 decides which definition of the finite differences derivative is used.
+ 521 Available choice: symmetric, forward, backward, improved, log, default: symmetric
+ 522 """
+ 523 if self.N != 1:
+ 524 raise Exception("deriv only implemented for one-dimensional correlators.")
+ 525 if variant == "symmetric":
+ 526 newcontent = []
+ 527 for t in range(1, self.T - 1):
+ 528 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
+ 529 newcontent.append(None)
+ 530 else:
+ 531 newcontent.append(0.5 * (self.content[t + 1] - self.content[t - 1]))
+ 532 if (all([x is None for x in newcontent])):
+ 533 raise Exception('Derivative is undefined at all timeslices')
+ 534 return Corr(newcontent, padding=[1, 1])
+ 535 elif variant == "forward":
+ 536 newcontent = []
+ 537 for t in range(self.T - 1):
+ 538 if (self.content[t] is None) or (self.content[t + 1] is None):
+ 539 newcontent.append(None)
+ 540 else:
+ 541 newcontent.append(self.content[t + 1] - self.content[t])
+ 542 if (all([x is None for x in newcontent])):
+ 543 raise Exception("Derivative is undefined at all timeslices")
+ 544 return Corr(newcontent, padding=[0, 1])
+ 545 elif variant == "backward":
+ 546 newcontent = []
+ 547 for t in range(1, self.T):
+ 548 if (self.content[t - 1] is None) or (self.content[t] is None):
+ 549 newcontent.append(None)
+ 550 else:
+ 551 newcontent.append(self.content[t] - self.content[t - 1])
+ 552 if (all([x is None for x in newcontent])):
+ 553 raise Exception("Derivative is undefined at all timeslices")
+ 554 return Corr(newcontent, padding=[1, 0])
+ 555 elif variant == "improved":
+ 556 newcontent = []
+ 557 for t in range(2, self.T - 2):
+ 558 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
+ 559 newcontent.append(None)
+ 560 else:
+ 561 newcontent.append((1 / 12) * (self.content[t - 2] - 8 * self.content[t - 1] + 8 * self.content[t + 1] - self.content[t + 2]))
+ 562 if (all([x is None for x in newcontent])):
+ 563 raise Exception('Derivative is undefined at all timeslices')
+ 564 return Corr(newcontent, padding=[2, 2])
+ 565 elif variant == 'log':
+ 566 newcontent = []
+ 567 for t in range(self.T):
+ 568 if (self.content[t] is None) or (self.content[t] <= 0):
+ 569 newcontent.append(None)
+ 570 else:
+ 571 newcontent.append(np.log(self.content[t]))
+ 572 if (all([x is None for x in newcontent])):
+ 573 raise Exception("Log is undefined at all timeslices")
+ 574 logcorr = Corr(newcontent)
+ 575 return self * logcorr.deriv('symmetric')
+ 576 else:
+ 577 raise Exception("Unknown variant.")
+ 578
+ 579 def second_deriv(self, variant="symmetric"):
+ 580 """Return the second derivative of the correlator with respect to x0.
+ 581
+ 582 Parameters
+ 583 ----------
+ 584 variant : str
+ 585 decides which definition of the finite differences derivative is used.
+ 586 Available choice: symmetric, improved, log, default: symmetric
+ 587 """
+ 588 if self.N != 1:
+ 589 raise Exception("second_deriv only implemented for one-dimensional correlators.")
+ 590 if variant == "symmetric":
+ 591 newcontent = []
+ 592 for t in range(1, self.T - 1):
+ 593 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
+ 594 newcontent.append(None)
+ 595 else:
+ 596 newcontent.append((self.content[t + 1] - 2 * self.content[t] + self.content[t - 1]))
+ 597 if (all([x is None for x in newcontent])):
+ 598 raise Exception("Derivative is undefined at all timeslices")
+ 599 return Corr(newcontent, padding=[1, 1])
+ 600 elif variant == "improved":
+ 601 newcontent = []
+ 602 for t in range(2, self.T - 2):
+ 603 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
+ 604 newcontent.append(None)
+ 605 else:
+ 606 newcontent.append((1 / 12) * (-self.content[t + 2] + 16 * self.content[t + 1] - 30 * self.content[t] + 16 * self.content[t - 1] - self.content[t - 2]))
+ 607 if (all([x is None for x in newcontent])):
+ 608 raise Exception("Derivative is undefined at all timeslices")
+ 609 return Corr(newcontent, padding=[2, 2])
+ 610 elif variant == 'log':
+ 611 newcontent = []
+ 612 for t in range(self.T):
+ 613 if (self.content[t] is None) or (self.content[t] <= 0):
+ 614 newcontent.append(None)
+ 615 else:
+ 616 newcontent.append(np.log(self.content[t]))
+ 617 if (all([x is None for x in newcontent])):
+ 618 raise Exception("Log is undefined at all timeslices")
+ 619 logcorr = Corr(newcontent)
+ 620 return self * (logcorr.second_deriv('symmetric') + (logcorr.deriv('symmetric'))**2)
+ 621 else:
+ 622 raise Exception("Unknown variant.")
+ 623
+ 624 def m_eff(self, variant='log', guess=1.0):
+ 625 """Returns the effective mass of the correlator as correlator object
+ 626
+ 627 Parameters
+ 628 ----------
+ 629 variant : str
+ 630 log : uses the standard effective mass log(C(t) / C(t+1))
+ 631 cosh, periodic : Use periodicitiy of the correlator by solving C(t) / C(t+1) = cosh(m * (t - T/2)) / cosh(m * (t + 1 - T/2)) for m.
+ 632 sinh : Use anti-periodicitiy of the correlator by solving C(t) / C(t+1) = sinh(m * (t - T/2)) / sinh(m * (t + 1 - T/2)) for m.
+ 633 See, e.g., arXiv:1205.5380
+ 634 arccosh : Uses the explicit form of the symmetrized correlator (not recommended)
+ 635 logsym: uses the symmetric effective mass log(C(t-1) / C(t+1))/2
+ 636 guess : float
+ 637 guess for the root finder, only relevant for the root variant
+ 638 """
+ 639 if self.N != 1:
+ 640 raise Exception('Correlator must be projected before getting m_eff')
+ 641 if variant == 'log':
+ 642 newcontent = []
+ 643 for t in range(self.T - 1):
+ 644 if ((self.content[t] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
645 newcontent.append(None)
- 646 else:
- 647 newcontent.append(self.content[t] / self.content[t + 1])
- 648 if (all([x is None for x in newcontent])):
- 649 raise Exception('m_eff is undefined at all timeslices')
- 650
- 651 return np.log(Corr(newcontent, padding=[0, 1]))
+ 646 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 647 newcontent.append(None)
+ 648 else:
+ 649 newcontent.append(self.content[t] / self.content[t + 1])
+ 650 if (all([x is None for x in newcontent])):
+ 651 raise Exception('m_eff is undefined at all timeslices')
652
- 653 elif variant == 'logsym':
- 654 newcontent = []
- 655 for t in range(1, self.T - 1):
- 656 if ((self.content[t - 1] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
- 657 newcontent.append(None)
- 658 elif self.content[t - 1][0].value / self.content[t + 1][0].value < 0:
+ 653 return np.log(Corr(newcontent, padding=[0, 1]))
+ 654
+ 655 elif variant == 'logsym':
+ 656 newcontent = []
+ 657 for t in range(1, self.T - 1):
+ 658 if ((self.content[t - 1] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
659 newcontent.append(None)
- 660 else:
- 661 newcontent.append(self.content[t - 1] / self.content[t + 1])
- 662 if (all([x is None for x in newcontent])):
- 663 raise Exception('m_eff is undefined at all timeslices')
- 664
- 665 return np.log(Corr(newcontent, padding=[1, 1])) / 2
+ 660 elif self.content[t - 1][0].value / self.content[t + 1][0].value < 0:
+ 661 newcontent.append(None)
+ 662 else:
+ 663 newcontent.append(self.content[t - 1] / self.content[t + 1])
+ 664 if (all([x is None for x in newcontent])):
+ 665 raise Exception('m_eff is undefined at all timeslices')
666
- 667 elif variant in ['periodic', 'cosh', 'sinh']:
- 668 if variant in ['periodic', 'cosh']:
- 669 func = anp.cosh
- 670 else:
- 671 func = anp.sinh
- 672
- 673 def root_function(x, d):
- 674 return func(x * (t - self.T / 2)) / func(x * (t + 1 - self.T / 2)) - d
- 675
- 676 newcontent = []
- 677 for t in range(self.T - 1):
- 678 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 1][0].value == 0):
- 679 newcontent.append(None)
- 680 # Fill the two timeslices in the middle of the lattice with their predecessors
- 681 elif variant == 'sinh' and t in [self.T / 2, self.T / 2 - 1]:
- 682 newcontent.append(newcontent[-1])
- 683 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
- 684 newcontent.append(None)
- 685 else:
- 686 newcontent.append(np.abs(find_root(self.content[t][0] / self.content[t + 1][0], root_function, guess=guess)))
- 687 if (all([x is None for x in newcontent])):
- 688 raise Exception('m_eff is undefined at all timeslices')
- 689
- 690 return Corr(newcontent, padding=[0, 1])
+ 667 return np.log(Corr(newcontent, padding=[1, 1])) / 2
+ 668
+ 669 elif variant in ['periodic', 'cosh', 'sinh']:
+ 670 if variant in ['periodic', 'cosh']:
+ 671 func = anp.cosh
+ 672 else:
+ 673 func = anp.sinh
+ 674
+ 675 def root_function(x, d):
+ 676 return func(x * (t - self.T / 2)) / func(x * (t + 1 - self.T / 2)) - d
+ 677
+ 678 newcontent = []
+ 679 for t in range(self.T - 1):
+ 680 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 1][0].value == 0):
+ 681 newcontent.append(None)
+ 682 # Fill the two timeslices in the middle of the lattice with their predecessors
+ 683 elif variant == 'sinh' and t in [self.T / 2, self.T / 2 - 1]:
+ 684 newcontent.append(newcontent[-1])
+ 685 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 686 newcontent.append(None)
+ 687 else:
+ 688 newcontent.append(np.abs(find_root(self.content[t][0] / self.content[t + 1][0], root_function, guess=guess)))
+ 689 if (all([x is None for x in newcontent])):
+ 690 raise Exception('m_eff is undefined at all timeslices')
691
- 692 elif variant == 'arccosh':
- 693 newcontent = []
- 694 for t in range(1, self.T - 1):
- 695 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t - 1] is None) or (self.content[t][0].value == 0):
- 696 newcontent.append(None)
- 697 else:
- 698 newcontent.append((self.content[t + 1] + self.content[t - 1]) / (2 * self.content[t]))
- 699 if (all([x is None for x in newcontent])):
- 700 raise Exception("m_eff is undefined at all timeslices")
- 701 return np.arccosh(Corr(newcontent, padding=[1, 1]))
- 702
- 703 else:
- 704 raise Exception('Unknown variant.')
- 705
- 706 def fit(self, function, fitrange=None, silent=False, **kwargs):
- 707 r'''Fits function to the data
- 708
- 709 Parameters
- 710 ----------
- 711 function : obj
- 712 function to fit to the data. See fits.least_squares for details.
- 713 fitrange : list
- 714 Two element list containing the timeslices on which the fit is supposed to start and stop.
- 715 Caution: This range is inclusive as opposed to standard python indexing.
- 716 `fitrange=[4, 6]` corresponds to the three entries 4, 5 and 6.
- 717 If not specified, self.prange or all timeslices are used.
- 718 silent : bool
- 719 Decides whether output is printed to the standard output.
- 720 '''
- 721 if self.N != 1:
- 722 raise Exception("Correlator must be projected before fitting")
- 723
- 724 if fitrange is None:
- 725 if self.prange:
- 726 fitrange = self.prange
- 727 else:
- 728 fitrange = [0, self.T - 1]
- 729 else:
- 730 if not isinstance(fitrange, list):
- 731 raise Exception("fitrange has to be a list with two elements")
- 732 if len(fitrange) != 2:
- 733 raise Exception("fitrange has to have exactly two elements [fit_start, fit_stop]")
- 734
- 735 xs = [x for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
- 736 ys = [self.content[x][0] for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
- 737 result = least_squares(xs, ys, function, silent=silent, **kwargs)
- 738 return result
- 739
- 740 def plateau(self, plateau_range=None, method="fit", auto_gamma=False):
- 741 """ Extract a plateau value from a Corr object
- 742
- 743 Parameters
- 744 ----------
- 745 plateau_range : list
- 746 list with two entries, indicating the first and the last timeslice
- 747 of the plateau region.
- 748 method : str
- 749 method to extract the plateau.
- 750 'fit' fits a constant to the plateau region
- 751 'avg', 'average' or 'mean' just average over the given timeslices.
- 752 auto_gamma : bool
- 753 apply gamma_method with default parameters to the Corr. Defaults to None
- 754 """
- 755 if not plateau_range:
- 756 if self.prange:
- 757 plateau_range = self.prange
- 758 else:
- 759 raise Exception("no plateau range provided")
- 760 if self.N != 1:
- 761 raise Exception("Correlator must be projected before getting a plateau.")
- 762 if (all([self.content[t] is None for t in range(plateau_range[0], plateau_range[1] + 1)])):
- 763 raise Exception("plateau is undefined at all timeslices in plateaurange.")
- 764 if auto_gamma:
- 765 self.gamma_method()
- 766 if method == "fit":
- 767 def const_func(a, t):
- 768 return a[0]
- 769 return self.fit(const_func, plateau_range)[0]
- 770 elif method in ["avg", "average", "mean"]:
- 771 returnvalue = np.mean([item[0] for item in self.content[plateau_range[0]:plateau_range[1] + 1] if item is not None])
- 772 return returnvalue
- 773
- 774 else:
- 775 raise Exception("Unsupported plateau method: " + method)
- 776
- 777 def set_prange(self, prange):
- 778 """Sets the attribute prange of the Corr object."""
- 779 if not len(prange) == 2:
- 780 raise Exception("prange must be a list or array with two values")
- 781 if not ((isinstance(prange[0], int)) and (isinstance(prange[1], int))):
- 782 raise Exception("Start and end point must be integers")
- 783 if not (0 <= prange[0] <= self.T and 0 <= prange[1] <= self.T and prange[0] < prange[1]):
- 784 raise Exception("Start and end point must define a range in the interval 0,T")
- 785
- 786 self.prange = prange
- 787 return
- 788
- 789 def show(self, x_range=None, comp=None, y_range=None, logscale=False, plateau=None, fit_res=None, ylabel=None, save=None, auto_gamma=False, hide_sigma=None, references=None, title=None):
- 790 """Plots the correlator using the tag of the correlator as label if available.
- 791
- 792 Parameters
- 793 ----------
- 794 x_range : list
- 795 list of two values, determining the range of the x-axis e.g. [4, 8].
- 796 comp : Corr or list of Corr
- 797 Correlator or list of correlators which are plotted for comparison.
- 798 The tags of these correlators are used as labels if available.
- 799 logscale : bool
- 800 Sets y-axis to logscale.
- 801 plateau : Obs
- 802 Plateau value to be visualized in the figure.
- 803 fit_res : Fit_result
- 804 Fit_result object to be visualized.
- 805 ylabel : str
- 806 Label for the y-axis.
- 807 save : str
- 808 path to file in which the figure should be saved.
- 809 auto_gamma : bool
- 810 Apply the gamma method with standard parameters to all correlators and plateau values before plotting.
- 811 hide_sigma : float
- 812 Hides data points from the first value on which is consistent with zero within 'hide_sigma' standard errors.
- 813 references : list
- 814 List of floating point values that are displayed as horizontal lines for reference.
- 815 title : string
- 816 Optional title of the figure.
- 817 """
- 818 if self.N != 1:
- 819 raise Exception("Correlator must be projected before plotting")
- 820
- 821 if auto_gamma:
- 822 self.gamma_method()
- 823
- 824 if x_range is None:
- 825 x_range = [0, self.T - 1]
- 826
- 827 fig = plt.figure()
- 828 ax1 = fig.add_subplot(111)
- 829
- 830 x, y, y_err = self.plottable()
- 831 if hide_sigma:
- 832 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
- 833 else:
- 834 hide_from = None
- 835 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=self.tag)
- 836 if logscale:
- 837 ax1.set_yscale('log')
- 838 else:
- 839 if y_range is None:
- 840 try:
- 841 y_min = min([(x[0].value - x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
- 842 y_max = max([(x[0].value + x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
- 843 ax1.set_ylim([y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min)])
- 844 except Exception:
- 845 pass
- 846 else:
- 847 ax1.set_ylim(y_range)
- 848 if comp:
- 849 if isinstance(comp, (Corr, list)):
- 850 for corr in comp if isinstance(comp, list) else [comp]:
- 851 if auto_gamma:
- 852 corr.gamma_method()
- 853 x, y, y_err = corr.plottable()
- 854 if hide_sigma:
- 855 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
- 856 else:
- 857 hide_from = None
- 858 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=corr.tag, mfc=plt.rcParams['axes.facecolor'])
- 859 else:
- 860 raise Exception("'comp' must be a correlator or a list of correlators.")
- 861
- 862 if plateau:
- 863 if isinstance(plateau, Obs):
- 864 if auto_gamma:
- 865 plateau.gamma_method()
- 866 ax1.axhline(y=plateau.value, linewidth=2, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--', label=str(plateau))
- 867 ax1.axhspan(plateau.value - plateau.dvalue, plateau.value + plateau.dvalue, alpha=0.25, color=plt.rcParams['text.color'], ls='-')
- 868 else:
- 869 raise Exception("'plateau' must be an Obs")
- 870
- 871 if references:
- 872 if isinstance(references, list):
- 873 for ref in references:
- 874 ax1.axhline(y=ref, linewidth=1, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--')
- 875 else:
- 876 raise Exception("'references' must be a list of floating pint values.")
- 877
- 878 if self.prange:
- 879 ax1.axvline(self.prange[0], 0, 1, ls='-', marker=',')
- 880 ax1.axvline(self.prange[1], 0, 1, ls='-', marker=',')
- 881
- 882 if fit_res:
- 883 x_samples = np.arange(x_range[0], x_range[1] + 1, 0.05)
- 884 ax1.plot(x_samples,
- 885 fit_res.fit_function([o.value for o in fit_res.fit_parameters], x_samples),
- 886 ls='-', marker=',', lw=2)
- 887
- 888 ax1.set_xlabel(r'$x_0 / a$')
- 889 if ylabel:
- 890 ax1.set_ylabel(ylabel)
- 891 ax1.set_xlim([x_range[0] - 0.5, x_range[1] + 0.5])
- 892
- 893 handles, labels = ax1.get_legend_handles_labels()
- 894 if labels:
- 895 ax1.legend()
- 896
- 897 if title:
- 898 plt.title(title)
- 899
- 900 plt.draw()
+ 692 return Corr(newcontent, padding=[0, 1])
+ 693
+ 694 elif variant == 'arccosh':
+ 695 newcontent = []
+ 696 for t in range(1, self.T - 1):
+ 697 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t - 1] is None) or (self.content[t][0].value == 0):
+ 698 newcontent.append(None)
+ 699 else:
+ 700 newcontent.append((self.content[t + 1] + self.content[t - 1]) / (2 * self.content[t]))
+ 701 if (all([x is None for x in newcontent])):
+ 702 raise Exception("m_eff is undefined at all timeslices")
+ 703 return np.arccosh(Corr(newcontent, padding=[1, 1]))
+ 704
+ 705 else:
+ 706 raise Exception('Unknown variant.')
+ 707
+ 708 def fit(self, function, fitrange=None, silent=False, **kwargs):
+ 709 r'''Fits function to the data
+ 710
+ 711 Parameters
+ 712 ----------
+ 713 function : obj
+ 714 function to fit to the data. See fits.least_squares for details.
+ 715 fitrange : list
+ 716 Two element list containing the timeslices on which the fit is supposed to start and stop.
+ 717 Caution: This range is inclusive as opposed to standard python indexing.
+ 718 `fitrange=[4, 6]` corresponds to the three entries 4, 5 and 6.
+ 719 If not specified, self.prange or all timeslices are used.
+ 720 silent : bool
+ 721 Decides whether output is printed to the standard output.
+ 722 '''
+ 723 if self.N != 1:
+ 724 raise Exception("Correlator must be projected before fitting")
+ 725
+ 726 if fitrange is None:
+ 727 if self.prange:
+ 728 fitrange = self.prange
+ 729 else:
+ 730 fitrange = [0, self.T - 1]
+ 731 else:
+ 732 if not isinstance(fitrange, list):
+ 733 raise Exception("fitrange has to be a list with two elements")
+ 734 if len(fitrange) != 2:
+ 735 raise Exception("fitrange has to have exactly two elements [fit_start, fit_stop]")
+ 736
+ 737 xs = [x for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
+ 738 ys = [self.content[x][0] for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
+ 739 result = least_squares(xs, ys, function, silent=silent, **kwargs)
+ 740 return result
+ 741
+ 742 def plateau(self, plateau_range=None, method="fit", auto_gamma=False):
+ 743 """ Extract a plateau value from a Corr object
+ 744
+ 745 Parameters
+ 746 ----------
+ 747 plateau_range : list
+ 748 list with two entries, indicating the first and the last timeslice
+ 749 of the plateau region.
+ 750 method : str
+ 751 method to extract the plateau.
+ 752 'fit' fits a constant to the plateau region
+ 753 'avg', 'average' or 'mean' just average over the given timeslices.
+ 754 auto_gamma : bool
+ 755 apply gamma_method with default parameters to the Corr. Defaults to None
+ 756 """
+ 757 if not plateau_range:
+ 758 if self.prange:
+ 759 plateau_range = self.prange
+ 760 else:
+ 761 raise Exception("no plateau range provided")
+ 762 if self.N != 1:
+ 763 raise Exception("Correlator must be projected before getting a plateau.")
+ 764 if (all([self.content[t] is None for t in range(plateau_range[0], plateau_range[1] + 1)])):
+ 765 raise Exception("plateau is undefined at all timeslices in plateaurange.")
+ 766 if auto_gamma:
+ 767 self.gamma_method()
+ 768 if method == "fit":
+ 769 def const_func(a, t):
+ 770 return a[0]
+ 771 return self.fit(const_func, plateau_range)[0]
+ 772 elif method in ["avg", "average", "mean"]:
+ 773 returnvalue = np.mean([item[0] for item in self.content[plateau_range[0]:plateau_range[1] + 1] if item is not None])
+ 774 return returnvalue
+ 775
+ 776 else:
+ 777 raise Exception("Unsupported plateau method: " + method)
+ 778
+ 779 def set_prange(self, prange):
+ 780 """Sets the attribute prange of the Corr object."""
+ 781 if not len(prange) == 2:
+ 782 raise Exception("prange must be a list or array with two values")
+ 783 if not ((isinstance(prange[0], int)) and (isinstance(prange[1], int))):
+ 784 raise Exception("Start and end point must be integers")
+ 785 if not (0 <= prange[0] <= self.T and 0 <= prange[1] <= self.T and prange[0] < prange[1]):
+ 786 raise Exception("Start and end point must define a range in the interval 0,T")
+ 787
+ 788 self.prange = prange
+ 789 return
+ 790
+ 791 def show(self, x_range=None, comp=None, y_range=None, logscale=False, plateau=None, fit_res=None, ylabel=None, save=None, auto_gamma=False, hide_sigma=None, references=None, title=None):
+ 792 """Plots the correlator using the tag of the correlator as label if available.
+ 793
+ 794 Parameters
+ 795 ----------
+ 796 x_range : list
+ 797 list of two values, determining the range of the x-axis e.g. [4, 8].
+ 798 comp : Corr or list of Corr
+ 799 Correlator or list of correlators which are plotted for comparison.
+ 800 The tags of these correlators are used as labels if available.
+ 801 logscale : bool
+ 802 Sets y-axis to logscale.
+ 803 plateau : Obs
+ 804 Plateau value to be visualized in the figure.
+ 805 fit_res : Fit_result
+ 806 Fit_result object to be visualized.
+ 807 ylabel : str
+ 808 Label for the y-axis.
+ 809 save : str
+ 810 path to file in which the figure should be saved.
+ 811 auto_gamma : bool
+ 812 Apply the gamma method with standard parameters to all correlators and plateau values before plotting.
+ 813 hide_sigma : float
+ 814 Hides data points from the first value on which is consistent with zero within 'hide_sigma' standard errors.
+ 815 references : list
+ 816 List of floating point values that are displayed as horizontal lines for reference.
+ 817 title : string
+ 818 Optional title of the figure.
+ 819 """
+ 820 if self.N != 1:
+ 821 raise Exception("Correlator must be projected before plotting")
+ 822
+ 823 if auto_gamma:
+ 824 self.gamma_method()
+ 825
+ 826 if x_range is None:
+ 827 x_range = [0, self.T - 1]
+ 828
+ 829 fig = plt.figure()
+ 830 ax1 = fig.add_subplot(111)
+ 831
+ 832 x, y, y_err = self.plottable()
+ 833 if hide_sigma:
+ 834 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
+ 835 else:
+ 836 hide_from = None
+ 837 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=self.tag)
+ 838 if logscale:
+ 839 ax1.set_yscale('log')
+ 840 else:
+ 841 if y_range is None:
+ 842 try:
+ 843 y_min = min([(x[0].value - x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
+ 844 y_max = max([(x[0].value + x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
+ 845 ax1.set_ylim([y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min)])
+ 846 except Exception:
+ 847 pass
+ 848 else:
+ 849 ax1.set_ylim(y_range)
+ 850 if comp:
+ 851 if isinstance(comp, (Corr, list)):
+ 852 for corr in comp if isinstance(comp, list) else [comp]:
+ 853 if auto_gamma:
+ 854 corr.gamma_method()
+ 855 x, y, y_err = corr.plottable()
+ 856 if hide_sigma:
+ 857 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
+ 858 else:
+ 859 hide_from = None
+ 860 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=corr.tag, mfc=plt.rcParams['axes.facecolor'])
+ 861 else:
+ 862 raise Exception("'comp' must be a correlator or a list of correlators.")
+ 863
+ 864 if plateau:
+ 865 if isinstance(plateau, Obs):
+ 866 if auto_gamma:
+ 867 plateau.gamma_method()
+ 868 ax1.axhline(y=plateau.value, linewidth=2, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--', label=str(plateau))
+ 869 ax1.axhspan(plateau.value - plateau.dvalue, plateau.value + plateau.dvalue, alpha=0.25, color=plt.rcParams['text.color'], ls='-')
+ 870 else:
+ 871 raise Exception("'plateau' must be an Obs")
+ 872
+ 873 if references:
+ 874 if isinstance(references, list):
+ 875 for ref in references:
+ 876 ax1.axhline(y=ref, linewidth=1, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--')
+ 877 else:
+ 878 raise Exception("'references' must be a list of floating pint values.")
+ 879
+ 880 if self.prange:
+ 881 ax1.axvline(self.prange[0], 0, 1, ls='-', marker=',')
+ 882 ax1.axvline(self.prange[1], 0, 1, ls='-', marker=',')
+ 883
+ 884 if fit_res:
+ 885 x_samples = np.arange(x_range[0], x_range[1] + 1, 0.05)
+ 886 ax1.plot(x_samples,
+ 887 fit_res.fit_function([o.value for o in fit_res.fit_parameters], x_samples),
+ 888 ls='-', marker=',', lw=2)
+ 889
+ 890 ax1.set_xlabel(r'$x_0 / a$')
+ 891 if ylabel:
+ 892 ax1.set_ylabel(ylabel)
+ 893 ax1.set_xlim([x_range[0] - 0.5, x_range[1] + 0.5])
+ 894
+ 895 handles, labels = ax1.get_legend_handles_labels()
+ 896 if labels:
+ 897 ax1.legend()
+ 898
+ 899 if title:
+ 900 plt.title(title)
901
- 902 if save:
- 903 if isinstance(save, str):
- 904 fig.savefig(save, bbox_inches='tight')
- 905 else:
- 906 raise Exception("'save' has to be a string.")
- 907
- 908 def spaghetti_plot(self, logscale=True):
- 909 """Produces a spaghetti plot of the correlator suited to monitor exceptional configurations.
- 910
- 911 Parameters
- 912 ----------
- 913 logscale : bool
- 914 Determines whether the scale of the y-axis is logarithmic or standard.
- 915 """
- 916 if self.N != 1:
- 917 raise Exception("Correlator needs to be projected first.")
- 918
- 919 mc_names = list(set([item for sublist in [sum(map(o[0].e_content.get, o[0].mc_names), []) for o in self.content if o is not None] for item in sublist]))
- 920 x0_vals = [n for (n, o) in zip(np.arange(self.T), self.content) if o is not None]
- 921
- 922 for name in mc_names:
- 923 data = np.array([o[0].deltas[name] + o[0].r_values[name] for o in self.content if o is not None]).T
- 924
- 925 fig = plt.figure()
- 926 ax = fig.add_subplot(111)
- 927 for dat in data:
- 928 ax.plot(x0_vals, dat, ls='-', marker='')
- 929
- 930 if logscale is True:
- 931 ax.set_yscale('log')
- 932
- 933 ax.set_xlabel(r'$x_0 / a$')
- 934 plt.title(name)
- 935 plt.draw()
- 936
- 937 def dump(self, filename, datatype="json.gz", **kwargs):
- 938 """Dumps the Corr into a file of chosen type
- 939 Parameters
- 940 ----------
- 941 filename : str
- 942 Name of the file to be saved.
- 943 datatype : str
- 944 Format of the exported file. Supported formats include
- 945 "json.gz" and "pickle"
- 946 path : str
- 947 specifies a custom path for the file (default '.')
- 948 """
- 949 if datatype == "json.gz":
- 950 from .input.json import dump_to_json
- 951 if 'path' in kwargs:
- 952 file_name = kwargs.get('path') + '/' + filename
- 953 else:
- 954 file_name = filename
- 955 dump_to_json(self, file_name)
- 956 elif datatype == "pickle":
- 957 dump_object(self, filename, **kwargs)
- 958 else:
- 959 raise Exception("Unknown datatype " + str(datatype))
- 960
- 961 def print(self, print_range=None):
- 962 print(self.__repr__(print_range))
- 963
- 964 def __repr__(self, print_range=None):
- 965 if print_range is None:
- 966 print_range = [0, None]
- 967
- 968 content_string = ""
- 969 content_string += "Corr T=" + str(self.T) + " N=" + str(self.N) + "\n" # +" filled with"+ str(type(self.content[0][0])) there should be a good solution here
- 970
- 971 if self.tag is not None:
- 972 content_string += "Description: " + self.tag + "\n"
- 973 if self.N != 1:
- 974 return content_string
- 975 if isinstance(self[0], CObs):
+ 902 plt.draw()
+ 903
+ 904 if save:
+ 905 if isinstance(save, str):
+ 906 fig.savefig(save, bbox_inches='tight')
+ 907 else:
+ 908 raise Exception("'save' has to be a string.")
+ 909
+ 910 def spaghetti_plot(self, logscale=True):
+ 911 """Produces a spaghetti plot of the correlator suited to monitor exceptional configurations.
+ 912
+ 913 Parameters
+ 914 ----------
+ 915 logscale : bool
+ 916 Determines whether the scale of the y-axis is logarithmic or standard.
+ 917 """
+ 918 if self.N != 1:
+ 919 raise Exception("Correlator needs to be projected first.")
+ 920
+ 921 mc_names = list(set([item for sublist in [sum(map(o[0].e_content.get, o[0].mc_names), []) for o in self.content if o is not None] for item in sublist]))
+ 922 x0_vals = [n for (n, o) in zip(np.arange(self.T), self.content) if o is not None]
+ 923
+ 924 for name in mc_names:
+ 925 data = np.array([o[0].deltas[name] + o[0].r_values[name] for o in self.content if o is not None]).T
+ 926
+ 927 fig = plt.figure()
+ 928 ax = fig.add_subplot(111)
+ 929 for dat in data:
+ 930 ax.plot(x0_vals, dat, ls='-', marker='')
+ 931
+ 932 if logscale is True:
+ 933 ax.set_yscale('log')
+ 934
+ 935 ax.set_xlabel(r'$x_0 / a$')
+ 936 plt.title(name)
+ 937 plt.draw()
+ 938
+ 939 def dump(self, filename, datatype="json.gz", **kwargs):
+ 940 """Dumps the Corr into a file of chosen type
+ 941 Parameters
+ 942 ----------
+ 943 filename : str
+ 944 Name of the file to be saved.
+ 945 datatype : str
+ 946 Format of the exported file. Supported formats include
+ 947 "json.gz" and "pickle"
+ 948 path : str
+ 949 specifies a custom path for the file (default '.')
+ 950 """
+ 951 if datatype == "json.gz":
+ 952 from .input.json import dump_to_json
+ 953 if 'path' in kwargs:
+ 954 file_name = kwargs.get('path') + '/' + filename
+ 955 else:
+ 956 file_name = filename
+ 957 dump_to_json(self, file_name)
+ 958 elif datatype == "pickle":
+ 959 dump_object(self, filename, **kwargs)
+ 960 else:
+ 961 raise Exception("Unknown datatype " + str(datatype))
+ 962
+ 963 def print(self, print_range=None):
+ 964 print(self.__repr__(print_range))
+ 965
+ 966 def __repr__(self, print_range=None):
+ 967 if print_range is None:
+ 968 print_range = [0, None]
+ 969
+ 970 content_string = ""
+ 971 content_string += "Corr T=" + str(self.T) + " N=" + str(self.N) + "\n" # +" filled with"+ str(type(self.content[0][0])) there should be a good solution here
+ 972
+ 973 if self.tag is not None:
+ 974 content_string += "Description: " + self.tag + "\n"
+ 975 if self.N != 1:
976 return content_string
- 977
- 978 if print_range[1]:
- 979 print_range[1] += 1
- 980 content_string += 'x0/a\tCorr(x0/a)\n------------------\n'
- 981 for i, sub_corr in enumerate(self.content[print_range[0]:print_range[1]]):
- 982 if sub_corr is None:
- 983 content_string += str(i + print_range[0]) + '\n'
- 984 else:
- 985 content_string += str(i + print_range[0])
- 986 for element in sub_corr:
- 987 content_string += '\t' + ' ' * int(element >= 0) + str(element)
- 988 content_string += '\n'
- 989 return content_string
- 990
- 991 def __str__(self):
- 992 return self.__repr__()
- 993
- 994 # We define the basic operations, that can be performed with correlators.
- 995 # While */+- get defined here, they only work for Corr*Obs and not Obs*Corr.
- 996 # This is because Obs*Corr checks Obs.__mul__ first and does not catch an exception.
- 997 # One could try and tell Obs to check if the y in __mul__ is a Corr and
- 998
- 999 def __add__(self, y):
-1000 if isinstance(y, Corr):
-1001 if ((self.N != y.N) or (self.T != y.T)):
-1002 raise Exception("Addition of Corrs with different shape")
-1003 newcontent = []
-1004 for t in range(self.T):
-1005 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
-1006 newcontent.append(None)
-1007 else:
-1008 newcontent.append(self.content[t] + y.content[t])
-1009 return Corr(newcontent)
-1010
-1011 elif isinstance(y, (Obs, int, float, CObs)):
-1012 newcontent = []
-1013 for t in range(self.T):
-1014 if _check_for_none(self, self.content[t]):
-1015 newcontent.append(None)
-1016 else:
-1017 newcontent.append(self.content[t] + y)
-1018 return Corr(newcontent, prange=self.prange)
-1019 elif isinstance(y, np.ndarray):
-1020 if y.shape == (self.T,):
-1021 return Corr(list((np.array(self.content).T + y).T))
-1022 else:
-1023 raise ValueError("operands could not be broadcast together")
-1024 else:
-1025 raise TypeError("Corr + wrong type")
-1026
-1027 def __mul__(self, y):
-1028 if isinstance(y, Corr):
-1029 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
-1030 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
-1031 newcontent = []
-1032 for t in range(self.T):
-1033 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
-1034 newcontent.append(None)
-1035 else:
-1036 newcontent.append(self.content[t] * y.content[t])
-1037 return Corr(newcontent)
-1038
-1039 elif isinstance(y, (Obs, int, float, CObs)):
-1040 newcontent = []
-1041 for t in range(self.T):
-1042 if _check_for_none(self, self.content[t]):
-1043 newcontent.append(None)
-1044 else:
-1045 newcontent.append(self.content[t] * y)
-1046 return Corr(newcontent, prange=self.prange)
-1047 elif isinstance(y, np.ndarray):
-1048 if y.shape == (self.T,):
-1049 return Corr(list((np.array(self.content).T * y).T))
-1050 else:
-1051 raise ValueError("operands could not be broadcast together")
-1052 else:
-1053 raise TypeError("Corr * wrong type")
-1054
-1055 def __truediv__(self, y):
-1056 if isinstance(y, Corr):
-1057 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
-1058 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
-1059 newcontent = []
-1060 for t in range(self.T):
-1061 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
-1062 newcontent.append(None)
-1063 else:
-1064 newcontent.append(self.content[t] / y.content[t])
-1065 for t in range(self.T):
-1066 if _check_for_none(self, newcontent[t]):
-1067 continue
-1068 if np.isnan(np.sum(newcontent[t]).value):
-1069 newcontent[t] = None
-1070
-1071 if all([item is None for item in newcontent]):
-1072 raise Exception("Division returns completely undefined correlator")
-1073 return Corr(newcontent)
-1074
-1075 elif isinstance(y, (Obs, CObs)):
-1076 if isinstance(y, Obs):
-1077 if y.value == 0:
-1078 raise Exception('Division by zero will return undefined correlator')
-1079 if isinstance(y, CObs):
-1080 if y.is_zero():
-1081 raise Exception('Division by zero will return undefined correlator')
-1082
-1083 newcontent = []
-1084 for t in range(self.T):
-1085 if _check_for_none(self, self.content[t]):
-1086 newcontent.append(None)
-1087 else:
-1088 newcontent.append(self.content[t] / y)
-1089 return Corr(newcontent, prange=self.prange)
-1090
-1091 elif isinstance(y, (int, float)):
-1092 if y == 0:
-1093 raise Exception('Division by zero will return undefined correlator')
-1094 newcontent = []
-1095 for t in range(self.T):
-1096 if _check_for_none(self, self.content[t]):
-1097 newcontent.append(None)
-1098 else:
-1099 newcontent.append(self.content[t] / y)
-1100 return Corr(newcontent, prange=self.prange)
-1101 elif isinstance(y, np.ndarray):
-1102 if y.shape == (self.T,):
-1103 return Corr(list((np.array(self.content).T / y).T))
-1104 else:
-1105 raise ValueError("operands could not be broadcast together")
-1106 else:
-1107 raise TypeError('Corr / wrong type')
-1108
-1109 def __neg__(self):
-1110 newcontent = [None if _check_for_none(self, item) else -1. * item for item in self.content]
-1111 return Corr(newcontent, prange=self.prange)
-1112
-1113 def __sub__(self, y):
-1114 return self + (-y)
-1115
-1116 def __pow__(self, y):
-1117 if isinstance(y, (Obs, int, float, CObs)):
-1118 newcontent = [None if _check_for_none(self, item) else item**y for item in self.content]
-1119 return Corr(newcontent, prange=self.prange)
-1120 else:
-1121 raise TypeError('Type of exponent not supported')
-1122
-1123 def __abs__(self):
-1124 newcontent = [None if _check_for_none(self, item) else np.abs(item) for item in self.content]
-1125 return Corr(newcontent, prange=self.prange)
-1126
-1127 # The numpy functions:
-1128 def sqrt(self):
-1129 return self ** 0.5
-1130
-1131 def log(self):
-1132 newcontent = [None if _check_for_none(self, item) else np.log(item) for item in self.content]
-1133 return Corr(newcontent, prange=self.prange)
-1134
-1135 def exp(self):
-1136 newcontent = [None if _check_for_none(self, item) else np.exp(item) for item in self.content]
-1137 return Corr(newcontent, prange=self.prange)
-1138
-1139 def _apply_func_to_corr(self, func):
-1140 newcontent = [None if _check_for_none(self, item) else func(item) for item in self.content]
-1141 for t in range(self.T):
-1142 if _check_for_none(self, newcontent[t]):
-1143 continue
-1144 tmp_sum = np.sum(newcontent[t])
-1145 if hasattr(tmp_sum, "value"):
-1146 if np.isnan(tmp_sum.value):
-1147 newcontent[t] = None
-1148 if all([item is None for item in newcontent]):
-1149 raise Exception('Operation returns undefined correlator')
-1150 return Corr(newcontent)
-1151
-1152 def sin(self):
-1153 return self._apply_func_to_corr(np.sin)
-1154
-1155 def cos(self):
-1156 return self._apply_func_to_corr(np.cos)
-1157
-1158 def tan(self):
-1159 return self._apply_func_to_corr(np.tan)
-1160
-1161 def sinh(self):
-1162 return self._apply_func_to_corr(np.sinh)
-1163
-1164 def cosh(self):
-1165 return self._apply_func_to_corr(np.cosh)
-1166
-1167 def tanh(self):
-1168 return self._apply_func_to_corr(np.tanh)
-1169
-1170 def arcsin(self):
-1171 return self._apply_func_to_corr(np.arcsin)
-1172
-1173 def arccos(self):
-1174 return self._apply_func_to_corr(np.arccos)
-1175
-1176 def arctan(self):
-1177 return self._apply_func_to_corr(np.arctan)
-1178
-1179 def arcsinh(self):
-1180 return self._apply_func_to_corr(np.arcsinh)
-1181
-1182 def arccosh(self):
-1183 return self._apply_func_to_corr(np.arccosh)
-1184
-1185 def arctanh(self):
-1186 return self._apply_func_to_corr(np.arctanh)
-1187
-1188 # Right hand side operations (require tweak in main module to work)
-1189 def __radd__(self, y):
-1190 return self + y
-1191
-1192 def __rsub__(self, y):
-1193 return -self + y
-1194
-1195 def __rmul__(self, y):
-1196 return self * y
-1197
-1198 def __rtruediv__(self, y):
-1199 return (self / y) ** (-1)
-1200
-1201 @property
-1202 def real(self):
-1203 def return_real(obs_OR_cobs):
-1204 if isinstance(obs_OR_cobs.flatten()[0], CObs):
-1205 return np.vectorize(lambda x: x.real)(obs_OR_cobs)
-1206 else:
-1207 return obs_OR_cobs
-1208
-1209 return self._apply_func_to_corr(return_real)
+ 977 if isinstance(self[0], CObs):
+ 978 return content_string
+ 979
+ 980 if print_range[1]:
+ 981 print_range[1] += 1
+ 982 content_string += 'x0/a\tCorr(x0/a)\n------------------\n'
+ 983 for i, sub_corr in enumerate(self.content[print_range[0]:print_range[1]]):
+ 984 if sub_corr is None:
+ 985 content_string += str(i + print_range[0]) + '\n'
+ 986 else:
+ 987 content_string += str(i + print_range[0])
+ 988 for element in sub_corr:
+ 989 content_string += '\t' + ' ' * int(element >= 0) + str(element)
+ 990 content_string += '\n'
+ 991 return content_string
+ 992
+ 993 def __str__(self):
+ 994 return self.__repr__()
+ 995
+ 996 # We define the basic operations, that can be performed with correlators.
+ 997 # While */+- get defined here, they only work for Corr*Obs and not Obs*Corr.
+ 998 # This is because Obs*Corr checks Obs.__mul__ first and does not catch an exception.
+ 999 # One could try and tell Obs to check if the y in __mul__ is a Corr and
+1000
+1001 def __add__(self, y):
+1002 if isinstance(y, Corr):
+1003 if ((self.N != y.N) or (self.T != y.T)):
+1004 raise Exception("Addition of Corrs with different shape")
+1005 newcontent = []
+1006 for t in range(self.T):
+1007 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
+1008 newcontent.append(None)
+1009 else:
+1010 newcontent.append(self.content[t] + y.content[t])
+1011 return Corr(newcontent)
+1012
+1013 elif isinstance(y, (Obs, int, float, CObs)):
+1014 newcontent = []
+1015 for t in range(self.T):
+1016 if _check_for_none(self, self.content[t]):
+1017 newcontent.append(None)
+1018 else:
+1019 newcontent.append(self.content[t] + y)
+1020 return Corr(newcontent, prange=self.prange)
+1021 elif isinstance(y, np.ndarray):
+1022 if y.shape == (self.T,):
+1023 return Corr(list((np.array(self.content).T + y).T))
+1024 else:
+1025 raise ValueError("operands could not be broadcast together")
+1026 else:
+1027 raise TypeError("Corr + wrong type")
+1028
+1029 def __mul__(self, y):
+1030 if isinstance(y, Corr):
+1031 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
+1032 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
+1033 newcontent = []
+1034 for t in range(self.T):
+1035 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
+1036 newcontent.append(None)
+1037 else:
+1038 newcontent.append(self.content[t] * y.content[t])
+1039 return Corr(newcontent)
+1040
+1041 elif isinstance(y, (Obs, int, float, CObs)):
+1042 newcontent = []
+1043 for t in range(self.T):
+1044 if _check_for_none(self, self.content[t]):
+1045 newcontent.append(None)
+1046 else:
+1047 newcontent.append(self.content[t] * y)
+1048 return Corr(newcontent, prange=self.prange)
+1049 elif isinstance(y, np.ndarray):
+1050 if y.shape == (self.T,):
+1051 return Corr(list((np.array(self.content).T * y).T))
+1052 else:
+1053 raise ValueError("operands could not be broadcast together")
+1054 else:
+1055 raise TypeError("Corr * wrong type")
+1056
+1057 def __truediv__(self, y):
+1058 if isinstance(y, Corr):
+1059 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
+1060 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
+1061 newcontent = []
+1062 for t in range(self.T):
+1063 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
+1064 newcontent.append(None)
+1065 else:
+1066 newcontent.append(self.content[t] / y.content[t])
+1067 for t in range(self.T):
+1068 if _check_for_none(self, newcontent[t]):
+1069 continue
+1070 if np.isnan(np.sum(newcontent[t]).value):
+1071 newcontent[t] = None
+1072
+1073 if all([item is None for item in newcontent]):
+1074 raise Exception("Division returns completely undefined correlator")
+1075 return Corr(newcontent)
+1076
+1077 elif isinstance(y, (Obs, CObs)):
+1078 if isinstance(y, Obs):
+1079 if y.value == 0:
+1080 raise Exception('Division by zero will return undefined correlator')
+1081 if isinstance(y, CObs):
+1082 if y.is_zero():
+1083 raise Exception('Division by zero will return undefined correlator')
+1084
+1085 newcontent = []
+1086 for t in range(self.T):
+1087 if _check_for_none(self, self.content[t]):
+1088 newcontent.append(None)
+1089 else:
+1090 newcontent.append(self.content[t] / y)
+1091 return Corr(newcontent, prange=self.prange)
+1092
+1093 elif isinstance(y, (int, float)):
+1094 if y == 0:
+1095 raise Exception('Division by zero will return undefined correlator')
+1096 newcontent = []
+1097 for t in range(self.T):
+1098 if _check_for_none(self, self.content[t]):
+1099 newcontent.append(None)
+1100 else:
+1101 newcontent.append(self.content[t] / y)
+1102 return Corr(newcontent, prange=self.prange)
+1103 elif isinstance(y, np.ndarray):
+1104 if y.shape == (self.T,):
+1105 return Corr(list((np.array(self.content).T / y).T))
+1106 else:
+1107 raise ValueError("operands could not be broadcast together")
+1108 else:
+1109 raise TypeError('Corr / wrong type')
+1110
+1111 def __neg__(self):
+1112 newcontent = [None if _check_for_none(self, item) else -1. * item for item in self.content]
+1113 return Corr(newcontent, prange=self.prange)
+1114
+1115 def __sub__(self, y):
+1116 return self + (-y)
+1117
+1118 def __pow__(self, y):
+1119 if isinstance(y, (Obs, int, float, CObs)):
+1120 newcontent = [None if _check_for_none(self, item) else item**y for item in self.content]
+1121 return Corr(newcontent, prange=self.prange)
+1122 else:
+1123 raise TypeError('Type of exponent not supported')
+1124
+1125 def __abs__(self):
+1126 newcontent = [None if _check_for_none(self, item) else np.abs(item) for item in self.content]
+1127 return Corr(newcontent, prange=self.prange)
+1128
+1129 # The numpy functions:
+1130 def sqrt(self):
+1131 return self ** 0.5
+1132
+1133 def log(self):
+1134 newcontent = [None if _check_for_none(self, item) else np.log(item) for item in self.content]
+1135 return Corr(newcontent, prange=self.prange)
+1136
+1137 def exp(self):
+1138 newcontent = [None if _check_for_none(self, item) else np.exp(item) for item in self.content]
+1139 return Corr(newcontent, prange=self.prange)
+1140
+1141 def _apply_func_to_corr(self, func):
+1142 newcontent = [None if _check_for_none(self, item) else func(item) for item in self.content]
+1143 for t in range(self.T):
+1144 if _check_for_none(self, newcontent[t]):
+1145 continue
+1146 tmp_sum = np.sum(newcontent[t])
+1147 if hasattr(tmp_sum, "value"):
+1148 if np.isnan(tmp_sum.value):
+1149 newcontent[t] = None
+1150 if all([item is None for item in newcontent]):
+1151 raise Exception('Operation returns undefined correlator')
+1152 return Corr(newcontent)
+1153
+1154 def sin(self):
+1155 return self._apply_func_to_corr(np.sin)
+1156
+1157 def cos(self):
+1158 return self._apply_func_to_corr(np.cos)
+1159
+1160 def tan(self):
+1161 return self._apply_func_to_corr(np.tan)
+1162
+1163 def sinh(self):
+1164 return self._apply_func_to_corr(np.sinh)
+1165
+1166 def cosh(self):
+1167 return self._apply_func_to_corr(np.cosh)
+1168
+1169 def tanh(self):
+1170 return self._apply_func_to_corr(np.tanh)
+1171
+1172 def arcsin(self):
+1173 return self._apply_func_to_corr(np.arcsin)
+1174
+1175 def arccos(self):
+1176 return self._apply_func_to_corr(np.arccos)
+1177
+1178 def arctan(self):
+1179 return self._apply_func_to_corr(np.arctan)
+1180
+1181 def arcsinh(self):
+1182 return self._apply_func_to_corr(np.arcsinh)
+1183
+1184 def arccosh(self):
+1185 return self._apply_func_to_corr(np.arccosh)
+1186
+1187 def arctanh(self):
+1188 return self._apply_func_to_corr(np.arctanh)
+1189
+1190 # Right hand side operations (require tweak in main module to work)
+1191 def __radd__(self, y):
+1192 return self + y
+1193
+1194 def __rsub__(self, y):
+1195 return -self + y
+1196
+1197 def __rmul__(self, y):
+1198 return self * y
+1199
+1200 def __rtruediv__(self, y):
+1201 return (self / y) ** (-1)
+1202
+1203 @property
+1204 def real(self):
+1205 def return_real(obs_OR_cobs):
+1206 if isinstance(obs_OR_cobs.flatten()[0], CObs):
+1207 return np.vectorize(lambda x: x.real)(obs_OR_cobs)
+1208 else:
+1209 return obs_OR_cobs
1210
-1211 @property
-1212 def imag(self):
-1213 def return_imag(obs_OR_cobs):
-1214 if isinstance(obs_OR_cobs.flatten()[0], CObs):
-1215 return np.vectorize(lambda x: x.imag)(obs_OR_cobs)
-1216 else:
-1217 return obs_OR_cobs * 0 # So it stays the right type
-1218
-1219 return self._apply_func_to_corr(return_imag)
+1211 return self._apply_func_to_corr(return_real)
+1212
+1213 @property
+1214 def imag(self):
+1215 def return_imag(obs_OR_cobs):
+1216 if isinstance(obs_OR_cobs.flatten()[0], CObs):
+1217 return np.vectorize(lambda x: x.imag)(obs_OR_cobs)
+1218 else:
+1219 return obs_OR_cobs * 0 # So it stays the right type
1220
-1221 def prune(self, Ntrunc, tproj=3, t0proj=2, basematrix=None):
-1222 r''' Project large correlation matrix to lowest states
-1223
-1224 This method can be used to reduce the size of an (N x N) correlation matrix
-1225 to (Ntrunc x Ntrunc) by solving a GEVP at very early times where the noise
-1226 is still small.
-1227
-1228 Parameters
-1229 ----------
-1230 Ntrunc: int
-1231 Rank of the target matrix.
-1232 tproj: int
-1233 Time where the eigenvectors are evaluated, corresponds to ts in the GEVP method.
-1234 The default value is 3.
-1235 t0proj: int
-1236 Time where the correlation matrix is inverted. Choosing t0proj=1 is strongly
-1237 discouraged for O(a) improved theories, since the correctness of the procedure
-1238 cannot be granted in this case. The default value is 2.
-1239 basematrix : Corr
-1240 Correlation matrix that is used to determine the eigenvectors of the
-1241 lowest states based on a GEVP. basematrix is taken to be the Corr itself if
-1242 is is not specified.
-1243
-1244 Notes
-1245 -----
-1246 We have the basematrix $C(t)$ and the target matrix $G(t)$. We start by solving
-1247 the GEVP $$C(t) v_n(t, t_0) = \lambda_n(t, t_0) C(t_0) v_n(t, t_0)$$ where $t \equiv t_\mathrm{proj}$
-1248 and $t_0 \equiv t_{0, \mathrm{proj}}$. The target matrix is projected onto the subspace of the
-1249 resulting eigenvectors $v_n, n=1,\dots,N_\mathrm{trunc}$ via
-1250 $$G^\prime_{i, j}(t) = (v_i, G(t) v_j)$$. This allows to reduce the size of a large
-1251 correlation matrix and to remove some noise that is added by irrelevant operators.
-1252 This may allow to use the GEVP on $G(t)$ at late times such that the theoretically motivated
-1253 bound $t_0 \leq t/2$ holds, since the condition number of $G(t)$ is decreased, compared to $C(t)$.
-1254 '''
-1255
-1256 if self.N == 1:
-1257 raise Exception('Method cannot be applied to one-dimensional correlators.')
-1258 if basematrix is None:
-1259 basematrix = self
-1260 if Ntrunc >= basematrix.N:
-1261 raise Exception('Cannot truncate using Ntrunc <= %d' % (basematrix.N))
-1262 if basematrix.N != self.N:
-1263 raise Exception('basematrix and targetmatrix have to be of the same size.')
-1264
-1265 evecs = basematrix.GEVP(t0proj, tproj, sort=None)[:Ntrunc]
+1221 return self._apply_func_to_corr(return_imag)
+1222
+1223 def prune(self, Ntrunc, tproj=3, t0proj=2, basematrix=None):
+1224 r''' Project large correlation matrix to lowest states
+1225
+1226 This method can be used to reduce the size of an (N x N) correlation matrix
+1227 to (Ntrunc x Ntrunc) by solving a GEVP at very early times where the noise
+1228 is still small.
+1229
+1230 Parameters
+1231 ----------
+1232 Ntrunc: int
+1233 Rank of the target matrix.
+1234 tproj: int
+1235 Time where the eigenvectors are evaluated, corresponds to ts in the GEVP method.
+1236 The default value is 3.
+1237 t0proj: int
+1238 Time where the correlation matrix is inverted. Choosing t0proj=1 is strongly
+1239 discouraged for O(a) improved theories, since the correctness of the procedure
+1240 cannot be granted in this case. The default value is 2.
+1241 basematrix : Corr
+1242 Correlation matrix that is used to determine the eigenvectors of the
+1243 lowest states based on a GEVP. basematrix is taken to be the Corr itself if
+1244 is is not specified.
+1245
+1246 Notes
+1247 -----
+1248 We have the basematrix $C(t)$ and the target matrix $G(t)$. We start by solving
+1249 the GEVP $$C(t) v_n(t, t_0) = \lambda_n(t, t_0) C(t_0) v_n(t, t_0)$$ where $t \equiv t_\mathrm{proj}$
+1250 and $t_0 \equiv t_{0, \mathrm{proj}}$. The target matrix is projected onto the subspace of the
+1251 resulting eigenvectors $v_n, n=1,\dots,N_\mathrm{trunc}$ via
+1252 $$G^\prime_{i, j}(t) = (v_i, G(t) v_j)$$. This allows to reduce the size of a large
+1253 correlation matrix and to remove some noise that is added by irrelevant operators.
+1254 This may allow to use the GEVP on $G(t)$ at late times such that the theoretically motivated
+1255 bound $t_0 \leq t/2$ holds, since the condition number of $G(t)$ is decreased, compared to $C(t)$.
+1256 '''
+1257
+1258 if self.N == 1:
+1259 raise Exception('Method cannot be applied to one-dimensional correlators.')
+1260 if basematrix is None:
+1261 basematrix = self
+1262 if Ntrunc >= basematrix.N:
+1263 raise Exception('Cannot truncate using Ntrunc <= %d' % (basematrix.N))
+1264 if basematrix.N != self.N:
+1265 raise Exception('basematrix and targetmatrix have to be of the same size.')
1266
-1267 tmpmat = np.empty((Ntrunc, Ntrunc), dtype=object)
-1268 rmat = []
-1269 for t in range(basematrix.T):
-1270 for i in range(Ntrunc):
-1271 for j in range(Ntrunc):
-1272 tmpmat[i][j] = evecs[i].T @ self[t] @ evecs[j]
-1273 rmat.append(np.copy(tmpmat))
-1274
-1275 newcontent = [None if (self.content[t] is None) else rmat[t] for t in range(self.T)]
-1276 return Corr(newcontent)
-1277
-1278
-1279def _sort_vectors(vec_set, ts):
-1280 """Helper function used to find a set of Eigenvectors consistent over all timeslices"""
-1281 reference_sorting = np.array(vec_set[ts])
-1282 N = reference_sorting.shape[0]
-1283 sorted_vec_set = []
-1284 for t in range(len(vec_set)):
-1285 if vec_set[t] is None:
-1286 sorted_vec_set.append(None)
-1287 elif not t == ts:
-1288 perms = [list(o) for o in permutations([i for i in range(N)], N)]
-1289 best_score = 0
-1290 for perm in perms:
-1291 current_score = 1
-1292 for k in range(N):
-1293 new_sorting = reference_sorting.copy()
-1294 new_sorting[perm[k], :] = vec_set[t][k]
-1295 current_score *= abs(np.linalg.det(new_sorting))
-1296 if current_score > best_score:
-1297 best_score = current_score
-1298 best_perm = perm
-1299 sorted_vec_set.append([vec_set[t][k] for k in best_perm])
-1300 else:
-1301 sorted_vec_set.append(vec_set[t])
-1302
-1303 return sorted_vec_set
+1267 evecs = basematrix.GEVP(t0proj, tproj, sort=None)[:Ntrunc]
+1268
+1269 tmpmat = np.empty((Ntrunc, Ntrunc), dtype=object)
+1270 rmat = []
+1271 for t in range(basematrix.T):
+1272 for i in range(Ntrunc):
+1273 for j in range(Ntrunc):
+1274 tmpmat[i][j] = evecs[i].T @ self[t] @ evecs[j]
+1275 rmat.append(np.copy(tmpmat))
+1276
+1277 newcontent = [None if (self.content[t] is None) else rmat[t] for t in range(self.T)]
+1278 return Corr(newcontent)
+1279
+1280
+1281def _sort_vectors(vec_set, ts):
+1282 """Helper function used to find a set of Eigenvectors consistent over all timeslices"""
+1283 reference_sorting = np.array(vec_set[ts])
+1284 N = reference_sorting.shape[0]
+1285 sorted_vec_set = []
+1286 for t in range(len(vec_set)):
+1287 if vec_set[t] is None:
+1288 sorted_vec_set.append(None)
+1289 elif not t == ts:
+1290 perms = [list(o) for o in permutations([i for i in range(N)], N)]
+1291 best_score = 0
+1292 for perm in perms:
+1293 current_score = 1
+1294 for k in range(N):
+1295 new_sorting = reference_sorting.copy()
+1296 new_sorting[perm[k], :] = vec_set[t][k]
+1297 current_score *= abs(np.linalg.det(new_sorting))
+1298 if current_score > best_score:
+1299 best_score = current_score
+1300 best_perm = perm
+1301 sorted_vec_set.append([vec_set[t][k] for k in best_perm])
+1302 else:
+1303 sorted_vec_set.append(vec_set[t])
1304
-1305
-1306def _check_for_none(corr, entry):
-1307 """Checks if entry for correlator corr is None"""
-1308 return len(list(filter(None, np.asarray(entry).flatten()))) < corr.N ** 2
-1309
-1310
-1311def _GEVP_solver(Gt, G0):
-1312 """Helper function for solving the GEVP and sorting the eigenvectors.
-1313
-1314 The helper function assumes that both provided matrices are symmetric and
-1315 only processes the lower triangular part of both matrices. In case the matrices
-1316 are not symmetric the upper triangular parts are effectively discarded."""
-1317 return scipy.linalg.eigh(Gt, G0, lower=True)[1].T[::-1]
+1305 return sorted_vec_set
+1306
+1307
+1308def _check_for_none(corr, entry):
+1309 """Checks if entry for correlator corr is None"""
+1310 return len(list(filter(None, np.asarray(entry).flatten()))) < corr.N ** 2
+1311
+1312
+1313def _GEVP_solver(Gt, G0):
+1314 """Helper function for solving the GEVP and sorting the eigenvectors.
+1315
+1316 The helper function assumes that both provided matrices are symmetric and
+1317 only processes the lower triangular part of both matrices. In case the matrices
+1318 are not symmetric the upper triangular parts are effectively discarded."""
+1319 return scipy.linalg.eigh(Gt, G0, lower=True)[1].T[::-1]
@@ -1559,1257 +1561,1259 @@
24
25 """
26
- 27 def __init__(self, data_input, padding=[0, 0], prange=None):
- 28 """ Initialize a Corr object.
- 29
- 30 Parameters
- 31 ----------
- 32 data_input : list or array
- 33 list of Obs or list of arrays of Obs or array of Corrs
- 34 padding : list, optional
- 35 List with two entries where the first labels the padding
- 36 at the front of the correlator and the second the padding
- 37 at the back.
- 38 prange : list, optional
- 39 List containing the first and last timeslice of the plateau
- 40 region indentified for this correlator.
- 41 """
- 42
- 43 if isinstance(data_input, np.ndarray):
+ 27 __slots__ = ["content", "N", "T", "tag", "prange"]
+ 28
+ 29 def __init__(self, data_input, padding=[0, 0], prange=None):
+ 30 """ Initialize a Corr object.
+ 31
+ 32 Parameters
+ 33 ----------
+ 34 data_input : list or array
+ 35 list of Obs or list of arrays of Obs or array of Corrs
+ 36 padding : list, optional
+ 37 List with two entries where the first labels the padding
+ 38 at the front of the correlator and the second the padding
+ 39 at the back.
+ 40 prange : list, optional
+ 41 List containing the first and last timeslice of the plateau
+ 42 region indentified for this correlator.
+ 43 """
44
- 45 # This only works, if the array fulfills the conditions below
- 46 if not len(data_input.shape) == 2 and data_input.shape[0] == data_input.shape[1]:
- 47 raise Exception("Incompatible array shape")
- 48 if not all([isinstance(item, Corr) for item in data_input.flatten()]):
- 49 raise Exception("If the input is an array, its elements must be of type pe.Corr")
- 50 if not all([item.N == 1 for item in data_input.flatten()]):
- 51 raise Exception("Can only construct matrix correlator from single valued correlators")
- 52 if not len(set([item.T for item in data_input.flatten()])) == 1:
- 53 raise Exception("All input Correlators must be defined over the same timeslices.")
- 54
- 55 T = data_input[0, 0].T
- 56 N = data_input.shape[0]
- 57 input_as_list = []
- 58 for t in range(T):
- 59 if any([(item.content[t] is None) for item in data_input.flatten()]):
- 60 if not all([(item.content[t] is None) for item in data_input.flatten()]):
- 61 warnings.warn("Input ill-defined at different timeslices. Conversion leads to data loss!", RuntimeWarning)
- 62 input_as_list.append(None)
- 63 else:
- 64 array_at_timeslace = np.empty([N, N], dtype="object")
- 65 for i in range(N):
- 66 for j in range(N):
- 67 array_at_timeslace[i, j] = data_input[i, j][t]
- 68 input_as_list.append(array_at_timeslace)
- 69 data_input = input_as_list
- 70
- 71 if isinstance(data_input, list):
+ 45 if isinstance(data_input, np.ndarray):
+ 46
+ 47 # This only works, if the array fulfills the conditions below
+ 48 if not len(data_input.shape) == 2 and data_input.shape[0] == data_input.shape[1]:
+ 49 raise Exception("Incompatible array shape")
+ 50 if not all([isinstance(item, Corr) for item in data_input.flatten()]):
+ 51 raise Exception("If the input is an array, its elements must be of type pe.Corr")
+ 52 if not all([item.N == 1 for item in data_input.flatten()]):
+ 53 raise Exception("Can only construct matrix correlator from single valued correlators")
+ 54 if not len(set([item.T for item in data_input.flatten()])) == 1:
+ 55 raise Exception("All input Correlators must be defined over the same timeslices.")
+ 56
+ 57 T = data_input[0, 0].T
+ 58 N = data_input.shape[0]
+ 59 input_as_list = []
+ 60 for t in range(T):
+ 61 if any([(item.content[t] is None) for item in data_input.flatten()]):
+ 62 if not all([(item.content[t] is None) for item in data_input.flatten()]):
+ 63 warnings.warn("Input ill-defined at different timeslices. Conversion leads to data loss!", RuntimeWarning)
+ 64 input_as_list.append(None)
+ 65 else:
+ 66 array_at_timeslace = np.empty([N, N], dtype="object")
+ 67 for i in range(N):
+ 68 for j in range(N):
+ 69 array_at_timeslace[i, j] = data_input[i, j][t]
+ 70 input_as_list.append(array_at_timeslace)
+ 71 data_input = input_as_list
72
- 73 if all([isinstance(item, (Obs, CObs)) or item is None for item in data_input]):
- 74 _assert_equal_properties([o for o in data_input if o is not None])
- 75 self.content = [np.asarray([item]) if item is not None else None for item in data_input]
- 76 self.N = 1
- 77
- 78 elif all([isinstance(item, np.ndarray) or item is None for item in data_input]) and any([isinstance(item, np.ndarray) for item in data_input]):
- 79 self.content = data_input
- 80 noNull = [a for a in self.content if not (a is None)] # To check if the matrices are correct for all undefined elements
- 81 self.N = noNull[0].shape[0]
- 82 if self.N > 1 and noNull[0].shape[0] != noNull[0].shape[1]:
- 83 raise Exception("Smearing matrices are not NxN")
- 84 if (not all([item.shape == noNull[0].shape for item in noNull])):
- 85 raise Exception("Items in data_input are not of identical shape." + str(noNull))
- 86 else:
- 87 raise Exception("data_input contains item of wrong type")
- 88 else:
- 89 raise Exception("Data input was not given as list or correct array")
- 90
- 91 self.tag = None
+ 73 if isinstance(data_input, list):
+ 74
+ 75 if all([isinstance(item, (Obs, CObs)) or item is None for item in data_input]):
+ 76 _assert_equal_properties([o for o in data_input if o is not None])
+ 77 self.content = [np.asarray([item]) if item is not None else None for item in data_input]
+ 78 self.N = 1
+ 79
+ 80 elif all([isinstance(item, np.ndarray) or item is None for item in data_input]) and any([isinstance(item, np.ndarray) for item in data_input]):
+ 81 self.content = data_input
+ 82 noNull = [a for a in self.content if not (a is None)] # To check if the matrices are correct for all undefined elements
+ 83 self.N = noNull[0].shape[0]
+ 84 if self.N > 1 and noNull[0].shape[0] != noNull[0].shape[1]:
+ 85 raise Exception("Smearing matrices are not NxN")
+ 86 if (not all([item.shape == noNull[0].shape for item in noNull])):
+ 87 raise Exception("Items in data_input are not of identical shape." + str(noNull))
+ 88 else:
+ 89 raise Exception("data_input contains item of wrong type")
+ 90 else:
+ 91 raise Exception("Data input was not given as list or correct array")
92
- 93 # An undefined timeslice is represented by the None object
- 94 self.content = [None] * padding[0] + self.content + [None] * padding[1]
- 95 self.T = len(self.content)
- 96 self.prange = prange
- 97
- 98 def __getitem__(self, idx):
- 99 """Return the content of timeslice idx"""
- 100 if self.content[idx] is None:
- 101 return None
- 102 elif len(self.content[idx]) == 1:
- 103 return self.content[idx][0]
- 104 else:
- 105 return self.content[idx]
- 106
- 107 @property
- 108 def reweighted(self):
- 109 bool_array = np.array([list(map(lambda x: x.reweighted, o)) for o in [x for x in self.content if x is not None]])
- 110 if np.all(bool_array == 1):
- 111 return True
- 112 elif np.all(bool_array == 0):
- 113 return False
- 114 else:
- 115 raise Exception("Reweighting status of correlator corrupted.")
- 116
- 117 def gamma_method(self, **kwargs):
- 118 """Apply the gamma method to the content of the Corr."""
- 119 for item in self.content:
- 120 if not (item is None):
- 121 if self.N == 1:
- 122 item[0].gamma_method(**kwargs)
- 123 else:
- 124 for i in range(self.N):
- 125 for j in range(self.N):
- 126 item[i, j].gamma_method(**kwargs)
- 127
- 128 gm = gamma_method
+ 93 self.tag = None
+ 94
+ 95 # An undefined timeslice is represented by the None object
+ 96 self.content = [None] * padding[0] + self.content + [None] * padding[1]
+ 97 self.T = len(self.content)
+ 98 self.prange = prange
+ 99
+ 100 def __getitem__(self, idx):
+ 101 """Return the content of timeslice idx"""
+ 102 if self.content[idx] is None:
+ 103 return None
+ 104 elif len(self.content[idx]) == 1:
+ 105 return self.content[idx][0]
+ 106 else:
+ 107 return self.content[idx]
+ 108
+ 109 @property
+ 110 def reweighted(self):
+ 111 bool_array = np.array([list(map(lambda x: x.reweighted, o)) for o in [x for x in self.content if x is not None]])
+ 112 if np.all(bool_array == 1):
+ 113 return True
+ 114 elif np.all(bool_array == 0):
+ 115 return False
+ 116 else:
+ 117 raise Exception("Reweighting status of correlator corrupted.")
+ 118
+ 119 def gamma_method(self, **kwargs):
+ 120 """Apply the gamma method to the content of the Corr."""
+ 121 for item in self.content:
+ 122 if not (item is None):
+ 123 if self.N == 1:
+ 124 item[0].gamma_method(**kwargs)
+ 125 else:
+ 126 for i in range(self.N):
+ 127 for j in range(self.N):
+ 128 item[i, j].gamma_method(**kwargs)
129
- 130 def projected(self, vector_l=None, vector_r=None, normalize=False):
- 131 """We need to project the Correlator with a Vector to get a single value at each timeslice.
- 132
- 133 The method can use one or two vectors.
- 134 If two are specified it returns v1@G@v2 (the order might be very important.)
- 135 By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to
- 136 """
- 137 if self.N == 1:
- 138 raise Exception("Trying to project a Corr, that already has N=1.")
- 139
- 140 if vector_l is None:
- 141 vector_l, vector_r = np.asarray([1.] + (self.N - 1) * [0.]), np.asarray([1.] + (self.N - 1) * [0.])
- 142 elif (vector_r is None):
- 143 vector_r = vector_l
- 144 if isinstance(vector_l, list) and not isinstance(vector_r, list):
- 145 if len(vector_l) != self.T:
- 146 raise Exception("Length of vector list must be equal to T")
- 147 vector_r = [vector_r] * self.T
- 148 if isinstance(vector_r, list) and not isinstance(vector_l, list):
- 149 if len(vector_r) != self.T:
- 150 raise Exception("Length of vector list must be equal to T")
- 151 vector_l = [vector_l] * self.T
- 152
- 153 if not isinstance(vector_l, list):
- 154 if not vector_l.shape == vector_r.shape == (self.N,):
- 155 raise Exception("Vectors are of wrong shape!")
- 156 if normalize:
- 157 vector_l, vector_r = vector_l / np.sqrt((vector_l @ vector_l)), vector_r / np.sqrt(vector_r @ vector_r)
- 158 newcontent = [None if _check_for_none(self, item) else np.asarray([vector_l.T @ item @ vector_r]) for item in self.content]
- 159
- 160 else:
- 161 # There are no checks here yet. There are so many possible scenarios, where this can go wrong.
- 162 if normalize:
- 163 for t in range(self.T):
- 164 vector_l[t], vector_r[t] = vector_l[t] / np.sqrt((vector_l[t] @ vector_l[t])), vector_r[t] / np.sqrt(vector_r[t] @ vector_r[t])
- 165
- 166 newcontent = [None if (_check_for_none(self, self.content[t]) or vector_l[t] is None or vector_r[t] is None) else np.asarray([vector_l[t].T @ self.content[t] @ vector_r[t]]) for t in range(self.T)]
- 167 return Corr(newcontent)
- 168
- 169 def item(self, i, j):
- 170 """Picks the element [i,j] from every matrix and returns a correlator containing one Obs per timeslice.
- 171
- 172 Parameters
- 173 ----------
- 174 i : int
- 175 First index to be picked.
- 176 j : int
- 177 Second index to be picked.
- 178 """
- 179 if self.N == 1:
- 180 raise Exception("Trying to pick item from projected Corr")
- 181 newcontent = [None if (item is None) else item[i, j] for item in self.content]
- 182 return Corr(newcontent)
- 183
- 184 def plottable(self):
- 185 """Outputs the correlator in a plotable format.
- 186
- 187 Outputs three lists containing the timeslice index, the value on each
- 188 timeslice and the error on each timeslice.
- 189 """
- 190 if self.N != 1:
- 191 raise Exception("Can only make Corr[N=1] plottable")
- 192 x_list = [x for x in range(self.T) if not self.content[x] is None]
- 193 y_list = [y[0].value for y in self.content if y is not None]
- 194 y_err_list = [y[0].dvalue for y in self.content if y is not None]
- 195
- 196 return x_list, y_list, y_err_list
+ 130 gm = gamma_method
+ 131
+ 132 def projected(self, vector_l=None, vector_r=None, normalize=False):
+ 133 """We need to project the Correlator with a Vector to get a single value at each timeslice.
+ 134
+ 135 The method can use one or two vectors.
+ 136 If two are specified it returns v1@G@v2 (the order might be very important.)
+ 137 By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to
+ 138 """
+ 139 if self.N == 1:
+ 140 raise Exception("Trying to project a Corr, that already has N=1.")
+ 141
+ 142 if vector_l is None:
+ 143 vector_l, vector_r = np.asarray([1.] + (self.N - 1) * [0.]), np.asarray([1.] + (self.N - 1) * [0.])
+ 144 elif (vector_r is None):
+ 145 vector_r = vector_l
+ 146 if isinstance(vector_l, list) and not isinstance(vector_r, list):
+ 147 if len(vector_l) != self.T:
+ 148 raise Exception("Length of vector list must be equal to T")
+ 149 vector_r = [vector_r] * self.T
+ 150 if isinstance(vector_r, list) and not isinstance(vector_l, list):
+ 151 if len(vector_r) != self.T:
+ 152 raise Exception("Length of vector list must be equal to T")
+ 153 vector_l = [vector_l] * self.T
+ 154
+ 155 if not isinstance(vector_l, list):
+ 156 if not vector_l.shape == vector_r.shape == (self.N,):
+ 157 raise Exception("Vectors are of wrong shape!")
+ 158 if normalize:
+ 159 vector_l, vector_r = vector_l / np.sqrt((vector_l @ vector_l)), vector_r / np.sqrt(vector_r @ vector_r)
+ 160 newcontent = [None if _check_for_none(self, item) else np.asarray([vector_l.T @ item @ vector_r]) for item in self.content]
+ 161
+ 162 else:
+ 163 # There are no checks here yet. There are so many possible scenarios, where this can go wrong.
+ 164 if normalize:
+ 165 for t in range(self.T):
+ 166 vector_l[t], vector_r[t] = vector_l[t] / np.sqrt((vector_l[t] @ vector_l[t])), vector_r[t] / np.sqrt(vector_r[t] @ vector_r[t])
+ 167
+ 168 newcontent = [None if (_check_for_none(self, self.content[t]) or vector_l[t] is None or vector_r[t] is None) else np.asarray([vector_l[t].T @ self.content[t] @ vector_r[t]]) for t in range(self.T)]
+ 169 return Corr(newcontent)
+ 170
+ 171 def item(self, i, j):
+ 172 """Picks the element [i,j] from every matrix and returns a correlator containing one Obs per timeslice.
+ 173
+ 174 Parameters
+ 175 ----------
+ 176 i : int
+ 177 First index to be picked.
+ 178 j : int
+ 179 Second index to be picked.
+ 180 """
+ 181 if self.N == 1:
+ 182 raise Exception("Trying to pick item from projected Corr")
+ 183 newcontent = [None if (item is None) else item[i, j] for item in self.content]
+ 184 return Corr(newcontent)
+ 185
+ 186 def plottable(self):
+ 187 """Outputs the correlator in a plotable format.
+ 188
+ 189 Outputs three lists containing the timeslice index, the value on each
+ 190 timeslice and the error on each timeslice.
+ 191 """
+ 192 if self.N != 1:
+ 193 raise Exception("Can only make Corr[N=1] plottable")
+ 194 x_list = [x for x in range(self.T) if not self.content[x] is None]
+ 195 y_list = [y[0].value for y in self.content if y is not None]
+ 196 y_err_list = [y[0].dvalue for y in self.content if y is not None]
197
- 198 def symmetric(self):
- 199 """ Symmetrize the correlator around x0=0."""
- 200 if self.N != 1:
- 201 raise Exception('symmetric cannot be safely applied to multi-dimensional correlators.')
- 202 if self.T % 2 != 0:
- 203 raise Exception("Can not symmetrize odd T")
- 204
- 205 if self.content[0] is not None:
- 206 if np.argmax(np.abs([o[0].value if o is not None else 0 for o in self.content])) != 0:
- 207 warnings.warn("Correlator does not seem to be symmetric around x0=0.", RuntimeWarning)
- 208
- 209 newcontent = [self.content[0]]
- 210 for t in range(1, self.T):
- 211 if (self.content[t] is None) or (self.content[self.T - t] is None):
- 212 newcontent.append(None)
- 213 else:
- 214 newcontent.append(0.5 * (self.content[t] + self.content[self.T - t]))
- 215 if (all([x is None for x in newcontent])):
- 216 raise Exception("Corr could not be symmetrized: No redundant values")
- 217 return Corr(newcontent, prange=self.prange)
- 218
- 219 def anti_symmetric(self):
- 220 """Anti-symmetrize the correlator around x0=0."""
- 221 if self.N != 1:
- 222 raise Exception('anti_symmetric cannot be safely applied to multi-dimensional correlators.')
- 223 if self.T % 2 != 0:
- 224 raise Exception("Can not symmetrize odd T")
- 225
- 226 test = 1 * self
- 227 test.gamma_method()
- 228 if not all([o.is_zero_within_error(3) for o in test.content[0]]):
- 229 warnings.warn("Correlator does not seem to be anti-symmetric around x0=0.", RuntimeWarning)
- 230
- 231 newcontent = [self.content[0]]
- 232 for t in range(1, self.T):
- 233 if (self.content[t] is None) or (self.content[self.T - t] is None):
- 234 newcontent.append(None)
- 235 else:
- 236 newcontent.append(0.5 * (self.content[t] - self.content[self.T - t]))
- 237 if (all([x is None for x in newcontent])):
- 238 raise Exception("Corr could not be symmetrized: No redundant values")
- 239 return Corr(newcontent, prange=self.prange)
- 240
- 241 def is_matrix_symmetric(self):
- 242 """Checks whether a correlator matrices is symmetric on every timeslice."""
- 243 if self.N == 1:
- 244 raise Exception("Only works for correlator matrices.")
- 245 for t in range(self.T):
- 246 if self[t] is None:
- 247 continue
- 248 for i in range(self.N):
- 249 for j in range(i + 1, self.N):
- 250 if self[t][i, j] is self[t][j, i]:
- 251 continue
- 252 if hash(self[t][i, j]) != hash(self[t][j, i]):
- 253 return False
- 254 return True
- 255
- 256 def matrix_symmetric(self):
- 257 """Symmetrizes the correlator matrices on every timeslice."""
- 258 if self.N == 1:
- 259 raise Exception("Trying to symmetrize a correlator matrix, that already has N=1.")
- 260 if self.is_matrix_symmetric():
- 261 return 1.0 * self
- 262 else:
- 263 transposed = [None if _check_for_none(self, G) else G.T for G in self.content]
- 264 return 0.5 * (Corr(transposed) + self)
- 265
- 266 def GEVP(self, t0, ts=None, sort="Eigenvalue", **kwargs):
- 267 r'''Solve the generalized eigenvalue problem on the correlator matrix and returns the corresponding eigenvectors.
- 268
- 269 The eigenvectors are sorted according to the descending eigenvalues, the zeroth eigenvector(s) correspond to the
- 270 largest eigenvalue(s). The eigenvector(s) for the individual states can be accessed via slicing
- 271 ```python
- 272 C.GEVP(t0=2)[0] # Ground state vector(s)
- 273 C.GEVP(t0=2)[:3] # Vectors for the lowest three states
- 274 ```
- 275
- 276 Parameters
- 277 ----------
- 278 t0 : int
- 279 The time t0 for the right hand side of the GEVP according to $G(t)v_i=\lambda_i G(t_0)v_i$
- 280 ts : int
- 281 fixed time $G(t_s)v_i=\lambda_i G(t_0)v_i$ if sort=None.
- 282 If sort="Eigenvector" it gives a reference point for the sorting method.
- 283 sort : string
- 284 If this argument is set, a list of self.T vectors per state is returned. If it is set to None, only one vector is returned.
- 285 - "Eigenvalue": The eigenvector is chosen according to which eigenvalue it belongs individually on every timeslice.
- 286 - "Eigenvector": Use the method described in arXiv:2004.10472 to find the set of v(t) belonging to the state.
- 287 The reference state is identified by its eigenvalue at $t=t_s$.
- 288
- 289 Other Parameters
- 290 ----------------
- 291 state : int
- 292 Returns only the vector(s) for a specified state. The lowest state is zero.
- 293 '''
- 294
- 295 if self.N == 1:
- 296 raise Exception("GEVP methods only works on correlator matrices and not single correlators.")
- 297 if ts is not None:
- 298 if (ts <= t0):
- 299 raise Exception("ts has to be larger than t0.")
- 300
- 301 if "sorted_list" in kwargs:
- 302 warnings.warn("Argument 'sorted_list' is deprecated, use 'sort' instead.", DeprecationWarning)
- 303 sort = kwargs.get("sorted_list")
- 304
- 305 if self.is_matrix_symmetric():
- 306 symmetric_corr = self
- 307 else:
- 308 symmetric_corr = self.matrix_symmetric()
- 309
- 310 G0 = np.vectorize(lambda x: x.value)(symmetric_corr[t0])
- 311 np.linalg.cholesky(G0) # Check if matrix G0 is positive-semidefinite.
- 312
- 313 if sort is None:
- 314 if (ts is None):
- 315 raise Exception("ts is required if sort=None.")
- 316 if (self.content[t0] is None) or (self.content[ts] is None):
- 317 raise Exception("Corr not defined at t0/ts.")
- 318 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[ts])
- 319 reordered_vecs = _GEVP_solver(Gt, G0)
- 320
- 321 elif sort in ["Eigenvalue", "Eigenvector"]:
- 322 if sort == "Eigenvalue" and ts is not None:
- 323 warnings.warn("ts has no effect when sorting by eigenvalue is chosen.", RuntimeWarning)
- 324 all_vecs = [None] * (t0 + 1)
- 325 for t in range(t0 + 1, self.T):
- 326 try:
- 327 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[t])
- 328 all_vecs.append(_GEVP_solver(Gt, G0))
- 329 except Exception:
- 330 all_vecs.append(None)
- 331 if sort == "Eigenvector":
- 332 if ts is None:
- 333 raise Exception("ts is required for the Eigenvector sorting method.")
- 334 all_vecs = _sort_vectors(all_vecs, ts)
- 335
- 336 reordered_vecs = [[v[s] if v is not None else None for v in all_vecs] for s in range(self.N)]
- 337 else:
- 338 raise Exception("Unkown value for 'sort'.")
- 339
- 340 if "state" in kwargs:
- 341 return reordered_vecs[kwargs.get("state")]
- 342 else:
- 343 return reordered_vecs
- 344
- 345 def Eigenvalue(self, t0, ts=None, state=0, sort="Eigenvalue"):
- 346 """Determines the eigenvalue of the GEVP by solving and projecting the correlator
- 347
- 348 Parameters
- 349 ----------
- 350 state : int
- 351 The state one is interested in ordered by energy. The lowest state is zero.
- 352
- 353 All other parameters are identical to the ones of Corr.GEVP.
- 354 """
- 355 vec = self.GEVP(t0, ts=ts, sort=sort)[state]
- 356 return self.projected(vec)
- 357
- 358 def Hankel(self, N, periodic=False):
- 359 """Constructs an NxN Hankel matrix
- 360
- 361 C(t) c(t+1) ... c(t+n-1)
- 362 C(t+1) c(t+2) ... c(t+n)
- 363 .................
- 364 C(t+(n-1)) c(t+n) ... c(t+2(n-1))
- 365
- 366 Parameters
- 367 ----------
- 368 N : int
- 369 Dimension of the Hankel matrix
- 370 periodic : bool, optional
- 371 determines whether the matrix is extended periodically
- 372 """
- 373
- 374 if self.N != 1:
- 375 raise Exception("Multi-operator Prony not implemented!")
- 376
- 377 array = np.empty([N, N], dtype="object")
- 378 new_content = []
- 379 for t in range(self.T):
- 380 new_content.append(array.copy())
- 381
- 382 def wrap(i):
- 383 while i >= self.T:
- 384 i -= self.T
- 385 return i
- 386
- 387 for t in range(self.T):
- 388 for i in range(N):
- 389 for j in range(N):
- 390 if periodic:
- 391 new_content[t][i, j] = self.content[wrap(t + i + j)][0]
- 392 elif (t + i + j) >= self.T:
- 393 new_content[t] = None
- 394 else:
- 395 new_content[t][i, j] = self.content[t + i + j][0]
- 396
- 397 return Corr(new_content)
+ 198 return x_list, y_list, y_err_list
+ 199
+ 200 def symmetric(self):
+ 201 """ Symmetrize the correlator around x0=0."""
+ 202 if self.N != 1:
+ 203 raise Exception('symmetric cannot be safely applied to multi-dimensional correlators.')
+ 204 if self.T % 2 != 0:
+ 205 raise Exception("Can not symmetrize odd T")
+ 206
+ 207 if self.content[0] is not None:
+ 208 if np.argmax(np.abs([o[0].value if o is not None else 0 for o in self.content])) != 0:
+ 209 warnings.warn("Correlator does not seem to be symmetric around x0=0.", RuntimeWarning)
+ 210
+ 211 newcontent = [self.content[0]]
+ 212 for t in range(1, self.T):
+ 213 if (self.content[t] is None) or (self.content[self.T - t] is None):
+ 214 newcontent.append(None)
+ 215 else:
+ 216 newcontent.append(0.5 * (self.content[t] + self.content[self.T - t]))
+ 217 if (all([x is None for x in newcontent])):
+ 218 raise Exception("Corr could not be symmetrized: No redundant values")
+ 219 return Corr(newcontent, prange=self.prange)
+ 220
+ 221 def anti_symmetric(self):
+ 222 """Anti-symmetrize the correlator around x0=0."""
+ 223 if self.N != 1:
+ 224 raise Exception('anti_symmetric cannot be safely applied to multi-dimensional correlators.')
+ 225 if self.T % 2 != 0:
+ 226 raise Exception("Can not symmetrize odd T")
+ 227
+ 228 test = 1 * self
+ 229 test.gamma_method()
+ 230 if not all([o.is_zero_within_error(3) for o in test.content[0]]):
+ 231 warnings.warn("Correlator does not seem to be anti-symmetric around x0=0.", RuntimeWarning)
+ 232
+ 233 newcontent = [self.content[0]]
+ 234 for t in range(1, self.T):
+ 235 if (self.content[t] is None) or (self.content[self.T - t] is None):
+ 236 newcontent.append(None)
+ 237 else:
+ 238 newcontent.append(0.5 * (self.content[t] - self.content[self.T - t]))
+ 239 if (all([x is None for x in newcontent])):
+ 240 raise Exception("Corr could not be symmetrized: No redundant values")
+ 241 return Corr(newcontent, prange=self.prange)
+ 242
+ 243 def is_matrix_symmetric(self):
+ 244 """Checks whether a correlator matrices is symmetric on every timeslice."""
+ 245 if self.N == 1:
+ 246 raise Exception("Only works for correlator matrices.")
+ 247 for t in range(self.T):
+ 248 if self[t] is None:
+ 249 continue
+ 250 for i in range(self.N):
+ 251 for j in range(i + 1, self.N):
+ 252 if self[t][i, j] is self[t][j, i]:
+ 253 continue
+ 254 if hash(self[t][i, j]) != hash(self[t][j, i]):
+ 255 return False
+ 256 return True
+ 257
+ 258 def matrix_symmetric(self):
+ 259 """Symmetrizes the correlator matrices on every timeslice."""
+ 260 if self.N == 1:
+ 261 raise Exception("Trying to symmetrize a correlator matrix, that already has N=1.")
+ 262 if self.is_matrix_symmetric():
+ 263 return 1.0 * self
+ 264 else:
+ 265 transposed = [None if _check_for_none(self, G) else G.T for G in self.content]
+ 266 return 0.5 * (Corr(transposed) + self)
+ 267
+ 268 def GEVP(self, t0, ts=None, sort="Eigenvalue", **kwargs):
+ 269 r'''Solve the generalized eigenvalue problem on the correlator matrix and returns the corresponding eigenvectors.
+ 270
+ 271 The eigenvectors are sorted according to the descending eigenvalues, the zeroth eigenvector(s) correspond to the
+ 272 largest eigenvalue(s). The eigenvector(s) for the individual states can be accessed via slicing
+ 273 ```python
+ 274 C.GEVP(t0=2)[0] # Ground state vector(s)
+ 275 C.GEVP(t0=2)[:3] # Vectors for the lowest three states
+ 276 ```
+ 277
+ 278 Parameters
+ 279 ----------
+ 280 t0 : int
+ 281 The time t0 for the right hand side of the GEVP according to $G(t)v_i=\lambda_i G(t_0)v_i$
+ 282 ts : int
+ 283 fixed time $G(t_s)v_i=\lambda_i G(t_0)v_i$ if sort=None.
+ 284 If sort="Eigenvector" it gives a reference point for the sorting method.
+ 285 sort : string
+ 286 If this argument is set, a list of self.T vectors per state is returned. If it is set to None, only one vector is returned.
+ 287 - "Eigenvalue": The eigenvector is chosen according to which eigenvalue it belongs individually on every timeslice.
+ 288 - "Eigenvector": Use the method described in arXiv:2004.10472 to find the set of v(t) belonging to the state.
+ 289 The reference state is identified by its eigenvalue at $t=t_s$.
+ 290
+ 291 Other Parameters
+ 292 ----------------
+ 293 state : int
+ 294 Returns only the vector(s) for a specified state. The lowest state is zero.
+ 295 '''
+ 296
+ 297 if self.N == 1:
+ 298 raise Exception("GEVP methods only works on correlator matrices and not single correlators.")
+ 299 if ts is not None:
+ 300 if (ts <= t0):
+ 301 raise Exception("ts has to be larger than t0.")
+ 302
+ 303 if "sorted_list" in kwargs:
+ 304 warnings.warn("Argument 'sorted_list' is deprecated, use 'sort' instead.", DeprecationWarning)
+ 305 sort = kwargs.get("sorted_list")
+ 306
+ 307 if self.is_matrix_symmetric():
+ 308 symmetric_corr = self
+ 309 else:
+ 310 symmetric_corr = self.matrix_symmetric()
+ 311
+ 312 G0 = np.vectorize(lambda x: x.value)(symmetric_corr[t0])
+ 313 np.linalg.cholesky(G0) # Check if matrix G0 is positive-semidefinite.
+ 314
+ 315 if sort is None:
+ 316 if (ts is None):
+ 317 raise Exception("ts is required if sort=None.")
+ 318 if (self.content[t0] is None) or (self.content[ts] is None):
+ 319 raise Exception("Corr not defined at t0/ts.")
+ 320 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[ts])
+ 321 reordered_vecs = _GEVP_solver(Gt, G0)
+ 322
+ 323 elif sort in ["Eigenvalue", "Eigenvector"]:
+ 324 if sort == "Eigenvalue" and ts is not None:
+ 325 warnings.warn("ts has no effect when sorting by eigenvalue is chosen.", RuntimeWarning)
+ 326 all_vecs = [None] * (t0 + 1)
+ 327 for t in range(t0 + 1, self.T):
+ 328 try:
+ 329 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[t])
+ 330 all_vecs.append(_GEVP_solver(Gt, G0))
+ 331 except Exception:
+ 332 all_vecs.append(None)
+ 333 if sort == "Eigenvector":
+ 334 if ts is None:
+ 335 raise Exception("ts is required for the Eigenvector sorting method.")
+ 336 all_vecs = _sort_vectors(all_vecs, ts)
+ 337
+ 338 reordered_vecs = [[v[s] if v is not None else None for v in all_vecs] for s in range(self.N)]
+ 339 else:
+ 340 raise Exception("Unkown value for 'sort'.")
+ 341
+ 342 if "state" in kwargs:
+ 343 return reordered_vecs[kwargs.get("state")]
+ 344 else:
+ 345 return reordered_vecs
+ 346
+ 347 def Eigenvalue(self, t0, ts=None, state=0, sort="Eigenvalue"):
+ 348 """Determines the eigenvalue of the GEVP by solving and projecting the correlator
+ 349
+ 350 Parameters
+ 351 ----------
+ 352 state : int
+ 353 The state one is interested in ordered by energy. The lowest state is zero.
+ 354
+ 355 All other parameters are identical to the ones of Corr.GEVP.
+ 356 """
+ 357 vec = self.GEVP(t0, ts=ts, sort=sort)[state]
+ 358 return self.projected(vec)
+ 359
+ 360 def Hankel(self, N, periodic=False):
+ 361 """Constructs an NxN Hankel matrix
+ 362
+ 363 C(t) c(t+1) ... c(t+n-1)
+ 364 C(t+1) c(t+2) ... c(t+n)
+ 365 .................
+ 366 C(t+(n-1)) c(t+n) ... c(t+2(n-1))
+ 367
+ 368 Parameters
+ 369 ----------
+ 370 N : int
+ 371 Dimension of the Hankel matrix
+ 372 periodic : bool, optional
+ 373 determines whether the matrix is extended periodically
+ 374 """
+ 375
+ 376 if self.N != 1:
+ 377 raise Exception("Multi-operator Prony not implemented!")
+ 378
+ 379 array = np.empty([N, N], dtype="object")
+ 380 new_content = []
+ 381 for t in range(self.T):
+ 382 new_content.append(array.copy())
+ 383
+ 384 def wrap(i):
+ 385 while i >= self.T:
+ 386 i -= self.T
+ 387 return i
+ 388
+ 389 for t in range(self.T):
+ 390 for i in range(N):
+ 391 for j in range(N):
+ 392 if periodic:
+ 393 new_content[t][i, j] = self.content[wrap(t + i + j)][0]
+ 394 elif (t + i + j) >= self.T:
+ 395 new_content[t] = None
+ 396 else:
+ 397 new_content[t][i, j] = self.content[t + i + j][0]
398
- 399 def roll(self, dt):
- 400 """Periodically shift the correlator by dt timeslices
- 401
- 402 Parameters
- 403 ----------
- 404 dt : int
- 405 number of timeslices
- 406 """
- 407 return Corr(list(np.roll(np.array(self.content, dtype=object), dt)))
- 408
- 409 def reverse(self):
- 410 """Reverse the time ordering of the Corr"""
- 411 return Corr(self.content[:: -1])
- 412
- 413 def thin(self, spacing=2, offset=0):
- 414 """Thin out a correlator to suppress correlations
- 415
- 416 Parameters
- 417 ----------
- 418 spacing : int
- 419 Keep only every 'spacing'th entry of the correlator
- 420 offset : int
- 421 Offset the equal spacing
- 422 """
- 423 new_content = []
- 424 for t in range(self.T):
- 425 if (offset + t) % spacing != 0:
- 426 new_content.append(None)
- 427 else:
- 428 new_content.append(self.content[t])
- 429 return Corr(new_content)
- 430
- 431 def correlate(self, partner):
- 432 """Correlate the correlator with another correlator or Obs
- 433
- 434 Parameters
- 435 ----------
- 436 partner : Obs or Corr
- 437 partner to correlate the correlator with.
- 438 Can either be an Obs which is correlated with all entries of the
- 439 correlator or a Corr of same length.
- 440 """
- 441 if self.N != 1:
- 442 raise Exception("Only one-dimensional correlators can be safely correlated.")
- 443 new_content = []
- 444 for x0, t_slice in enumerate(self.content):
- 445 if _check_for_none(self, t_slice):
- 446 new_content.append(None)
- 447 else:
- 448 if isinstance(partner, Corr):
- 449 if _check_for_none(partner, partner.content[x0]):
- 450 new_content.append(None)
- 451 else:
- 452 new_content.append(np.array([correlate(o, partner.content[x0][0]) for o in t_slice]))
- 453 elif isinstance(partner, Obs): # Should this include CObs?
- 454 new_content.append(np.array([correlate(o, partner) for o in t_slice]))
- 455 else:
- 456 raise Exception("Can only correlate with an Obs or a Corr.")
- 457
- 458 return Corr(new_content)
+ 399 return Corr(new_content)
+ 400
+ 401 def roll(self, dt):
+ 402 """Periodically shift the correlator by dt timeslices
+ 403
+ 404 Parameters
+ 405 ----------
+ 406 dt : int
+ 407 number of timeslices
+ 408 """
+ 409 return Corr(list(np.roll(np.array(self.content, dtype=object), dt)))
+ 410
+ 411 def reverse(self):
+ 412 """Reverse the time ordering of the Corr"""
+ 413 return Corr(self.content[:: -1])
+ 414
+ 415 def thin(self, spacing=2, offset=0):
+ 416 """Thin out a correlator to suppress correlations
+ 417
+ 418 Parameters
+ 419 ----------
+ 420 spacing : int
+ 421 Keep only every 'spacing'th entry of the correlator
+ 422 offset : int
+ 423 Offset the equal spacing
+ 424 """
+ 425 new_content = []
+ 426 for t in range(self.T):
+ 427 if (offset + t) % spacing != 0:
+ 428 new_content.append(None)
+ 429 else:
+ 430 new_content.append(self.content[t])
+ 431 return Corr(new_content)
+ 432
+ 433 def correlate(self, partner):
+ 434 """Correlate the correlator with another correlator or Obs
+ 435
+ 436 Parameters
+ 437 ----------
+ 438 partner : Obs or Corr
+ 439 partner to correlate the correlator with.
+ 440 Can either be an Obs which is correlated with all entries of the
+ 441 correlator or a Corr of same length.
+ 442 """
+ 443 if self.N != 1:
+ 444 raise Exception("Only one-dimensional correlators can be safely correlated.")
+ 445 new_content = []
+ 446 for x0, t_slice in enumerate(self.content):
+ 447 if _check_for_none(self, t_slice):
+ 448 new_content.append(None)
+ 449 else:
+ 450 if isinstance(partner, Corr):
+ 451 if _check_for_none(partner, partner.content[x0]):
+ 452 new_content.append(None)
+ 453 else:
+ 454 new_content.append(np.array([correlate(o, partner.content[x0][0]) for o in t_slice]))
+ 455 elif isinstance(partner, Obs): # Should this include CObs?
+ 456 new_content.append(np.array([correlate(o, partner) for o in t_slice]))
+ 457 else:
+ 458 raise Exception("Can only correlate with an Obs or a Corr.")
459
- 460 def reweight(self, weight, **kwargs):
- 461 """Reweight the correlator.
- 462
- 463 Parameters
- 464 ----------
- 465 weight : Obs
- 466 Reweighting factor. An Observable that has to be defined on a superset of the
- 467 configurations in obs[i].idl for all i.
- 468 all_configs : bool
- 469 if True, the reweighted observables are normalized by the average of
- 470 the reweighting factor on all configurations in weight.idl and not
- 471 on the configurations in obs[i].idl.
- 472 """
- 473 if self.N != 1:
- 474 raise Exception("Reweighting only implemented for one-dimensional correlators.")
- 475 new_content = []
- 476 for t_slice in self.content:
- 477 if _check_for_none(self, t_slice):
- 478 new_content.append(None)
- 479 else:
- 480 new_content.append(np.array(reweight(weight, t_slice, **kwargs)))
- 481 return Corr(new_content)
- 482
- 483 def T_symmetry(self, partner, parity=+1):
- 484 """Return the time symmetry average of the correlator and its partner
- 485
- 486 Parameters
- 487 ----------
- 488 partner : Corr
- 489 Time symmetry partner of the Corr
- 490 partity : int
- 491 Parity quantum number of the correlator, can be +1 or -1
- 492 """
- 493 if self.N != 1:
- 494 raise Exception("T_symmetry only implemented for one-dimensional correlators.")
- 495 if not isinstance(partner, Corr):
- 496 raise Exception("T partner has to be a Corr object.")
- 497 if parity not in [+1, -1]:
- 498 raise Exception("Parity has to be +1 or -1.")
- 499 T_partner = parity * partner.reverse()
- 500
- 501 t_slices = []
- 502 test = (self - T_partner)
- 503 test.gamma_method()
- 504 for x0, t_slice in enumerate(test.content):
- 505 if t_slice is not None:
- 506 if not t_slice[0].is_zero_within_error(5):
- 507 t_slices.append(x0)
- 508 if t_slices:
- 509 warnings.warn("T symmetry partners do not agree within 5 sigma on time slices " + str(t_slices) + ".", RuntimeWarning)
- 510
- 511 return (self + T_partner) / 2
+ 460 return Corr(new_content)
+ 461
+ 462 def reweight(self, weight, **kwargs):
+ 463 """Reweight the correlator.
+ 464
+ 465 Parameters
+ 466 ----------
+ 467 weight : Obs
+ 468 Reweighting factor. An Observable that has to be defined on a superset of the
+ 469 configurations in obs[i].idl for all i.
+ 470 all_configs : bool
+ 471 if True, the reweighted observables are normalized by the average of
+ 472 the reweighting factor on all configurations in weight.idl and not
+ 473 on the configurations in obs[i].idl.
+ 474 """
+ 475 if self.N != 1:
+ 476 raise Exception("Reweighting only implemented for one-dimensional correlators.")
+ 477 new_content = []
+ 478 for t_slice in self.content:
+ 479 if _check_for_none(self, t_slice):
+ 480 new_content.append(None)
+ 481 else:
+ 482 new_content.append(np.array(reweight(weight, t_slice, **kwargs)))
+ 483 return Corr(new_content)
+ 484
+ 485 def T_symmetry(self, partner, parity=+1):
+ 486 """Return the time symmetry average of the correlator and its partner
+ 487
+ 488 Parameters
+ 489 ----------
+ 490 partner : Corr
+ 491 Time symmetry partner of the Corr
+ 492 partity : int
+ 493 Parity quantum number of the correlator, can be +1 or -1
+ 494 """
+ 495 if self.N != 1:
+ 496 raise Exception("T_symmetry only implemented for one-dimensional correlators.")
+ 497 if not isinstance(partner, Corr):
+ 498 raise Exception("T partner has to be a Corr object.")
+ 499 if parity not in [+1, -1]:
+ 500 raise Exception("Parity has to be +1 or -1.")
+ 501 T_partner = parity * partner.reverse()
+ 502
+ 503 t_slices = []
+ 504 test = (self - T_partner)
+ 505 test.gamma_method()
+ 506 for x0, t_slice in enumerate(test.content):
+ 507 if t_slice is not None:
+ 508 if not t_slice[0].is_zero_within_error(5):
+ 509 t_slices.append(x0)
+ 510 if t_slices:
+ 511 warnings.warn("T symmetry partners do not agree within 5 sigma on time slices " + str(t_slices) + ".", RuntimeWarning)
512
- 513 def deriv(self, variant="symmetric"):
- 514 """Return the first derivative of the correlator with respect to x0.
- 515
- 516 Parameters
- 517 ----------
- 518 variant : str
- 519 decides which definition of the finite differences derivative is used.
- 520 Available choice: symmetric, forward, backward, improved, log, default: symmetric
- 521 """
- 522 if self.N != 1:
- 523 raise Exception("deriv only implemented for one-dimensional correlators.")
- 524 if variant == "symmetric":
- 525 newcontent = []
- 526 for t in range(1, self.T - 1):
- 527 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
- 528 newcontent.append(None)
- 529 else:
- 530 newcontent.append(0.5 * (self.content[t + 1] - self.content[t - 1]))
- 531 if (all([x is None for x in newcontent])):
- 532 raise Exception('Derivative is undefined at all timeslices')
- 533 return Corr(newcontent, padding=[1, 1])
- 534 elif variant == "forward":
- 535 newcontent = []
- 536 for t in range(self.T - 1):
- 537 if (self.content[t] is None) or (self.content[t + 1] is None):
- 538 newcontent.append(None)
- 539 else:
- 540 newcontent.append(self.content[t + 1] - self.content[t])
- 541 if (all([x is None for x in newcontent])):
- 542 raise Exception("Derivative is undefined at all timeslices")
- 543 return Corr(newcontent, padding=[0, 1])
- 544 elif variant == "backward":
- 545 newcontent = []
- 546 for t in range(1, self.T):
- 547 if (self.content[t - 1] is None) or (self.content[t] is None):
- 548 newcontent.append(None)
- 549 else:
- 550 newcontent.append(self.content[t] - self.content[t - 1])
- 551 if (all([x is None for x in newcontent])):
- 552 raise Exception("Derivative is undefined at all timeslices")
- 553 return Corr(newcontent, padding=[1, 0])
- 554 elif variant == "improved":
- 555 newcontent = []
- 556 for t in range(2, self.T - 2):
- 557 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
- 558 newcontent.append(None)
- 559 else:
- 560 newcontent.append((1 / 12) * (self.content[t - 2] - 8 * self.content[t - 1] + 8 * self.content[t + 1] - self.content[t + 2]))
- 561 if (all([x is None for x in newcontent])):
- 562 raise Exception('Derivative is undefined at all timeslices')
- 563 return Corr(newcontent, padding=[2, 2])
- 564 elif variant == 'log':
- 565 newcontent = []
- 566 for t in range(self.T):
- 567 if (self.content[t] is None) or (self.content[t] <= 0):
- 568 newcontent.append(None)
- 569 else:
- 570 newcontent.append(np.log(self.content[t]))
- 571 if (all([x is None for x in newcontent])):
- 572 raise Exception("Log is undefined at all timeslices")
- 573 logcorr = Corr(newcontent)
- 574 return self * logcorr.deriv('symmetric')
- 575 else:
- 576 raise Exception("Unknown variant.")
- 577
- 578 def second_deriv(self, variant="symmetric"):
- 579 """Return the second derivative of the correlator with respect to x0.
- 580
- 581 Parameters
- 582 ----------
- 583 variant : str
- 584 decides which definition of the finite differences derivative is used.
- 585 Available choice: symmetric, improved, log, default: symmetric
- 586 """
- 587 if self.N != 1:
- 588 raise Exception("second_deriv only implemented for one-dimensional correlators.")
- 589 if variant == "symmetric":
- 590 newcontent = []
- 591 for t in range(1, self.T - 1):
- 592 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
- 593 newcontent.append(None)
- 594 else:
- 595 newcontent.append((self.content[t + 1] - 2 * self.content[t] + self.content[t - 1]))
- 596 if (all([x is None for x in newcontent])):
- 597 raise Exception("Derivative is undefined at all timeslices")
- 598 return Corr(newcontent, padding=[1, 1])
- 599 elif variant == "improved":
- 600 newcontent = []
- 601 for t in range(2, self.T - 2):
- 602 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
- 603 newcontent.append(None)
- 604 else:
- 605 newcontent.append((1 / 12) * (-self.content[t + 2] + 16 * self.content[t + 1] - 30 * self.content[t] + 16 * self.content[t - 1] - self.content[t - 2]))
- 606 if (all([x is None for x in newcontent])):
- 607 raise Exception("Derivative is undefined at all timeslices")
- 608 return Corr(newcontent, padding=[2, 2])
- 609 elif variant == 'log':
- 610 newcontent = []
- 611 for t in range(self.T):
- 612 if (self.content[t] is None) or (self.content[t] <= 0):
- 613 newcontent.append(None)
- 614 else:
- 615 newcontent.append(np.log(self.content[t]))
- 616 if (all([x is None for x in newcontent])):
- 617 raise Exception("Log is undefined at all timeslices")
- 618 logcorr = Corr(newcontent)
- 619 return self * (logcorr.second_deriv('symmetric') + (logcorr.deriv('symmetric'))**2)
- 620 else:
- 621 raise Exception("Unknown variant.")
- 622
- 623 def m_eff(self, variant='log', guess=1.0):
- 624 """Returns the effective mass of the correlator as correlator object
- 625
- 626 Parameters
- 627 ----------
- 628 variant : str
- 629 log : uses the standard effective mass log(C(t) / C(t+1))
- 630 cosh, periodic : Use periodicitiy of the correlator by solving C(t) / C(t+1) = cosh(m * (t - T/2)) / cosh(m * (t + 1 - T/2)) for m.
- 631 sinh : Use anti-periodicitiy of the correlator by solving C(t) / C(t+1) = sinh(m * (t - T/2)) / sinh(m * (t + 1 - T/2)) for m.
- 632 See, e.g., arXiv:1205.5380
- 633 arccosh : Uses the explicit form of the symmetrized correlator (not recommended)
- 634 logsym: uses the symmetric effective mass log(C(t-1) / C(t+1))/2
- 635 guess : float
- 636 guess for the root finder, only relevant for the root variant
- 637 """
- 638 if self.N != 1:
- 639 raise Exception('Correlator must be projected before getting m_eff')
- 640 if variant == 'log':
- 641 newcontent = []
- 642 for t in range(self.T - 1):
- 643 if ((self.content[t] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
- 644 newcontent.append(None)
- 645 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 513 return (self + T_partner) / 2
+ 514
+ 515 def deriv(self, variant="symmetric"):
+ 516 """Return the first derivative of the correlator with respect to x0.
+ 517
+ 518 Parameters
+ 519 ----------
+ 520 variant : str
+ 521 decides which definition of the finite differences derivative is used.
+ 522 Available choice: symmetric, forward, backward, improved, log, default: symmetric
+ 523 """
+ 524 if self.N != 1:
+ 525 raise Exception("deriv only implemented for one-dimensional correlators.")
+ 526 if variant == "symmetric":
+ 527 newcontent = []
+ 528 for t in range(1, self.T - 1):
+ 529 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
+ 530 newcontent.append(None)
+ 531 else:
+ 532 newcontent.append(0.5 * (self.content[t + 1] - self.content[t - 1]))
+ 533 if (all([x is None for x in newcontent])):
+ 534 raise Exception('Derivative is undefined at all timeslices')
+ 535 return Corr(newcontent, padding=[1, 1])
+ 536 elif variant == "forward":
+ 537 newcontent = []
+ 538 for t in range(self.T - 1):
+ 539 if (self.content[t] is None) or (self.content[t + 1] is None):
+ 540 newcontent.append(None)
+ 541 else:
+ 542 newcontent.append(self.content[t + 1] - self.content[t])
+ 543 if (all([x is None for x in newcontent])):
+ 544 raise Exception("Derivative is undefined at all timeslices")
+ 545 return Corr(newcontent, padding=[0, 1])
+ 546 elif variant == "backward":
+ 547 newcontent = []
+ 548 for t in range(1, self.T):
+ 549 if (self.content[t - 1] is None) or (self.content[t] is None):
+ 550 newcontent.append(None)
+ 551 else:
+ 552 newcontent.append(self.content[t] - self.content[t - 1])
+ 553 if (all([x is None for x in newcontent])):
+ 554 raise Exception("Derivative is undefined at all timeslices")
+ 555 return Corr(newcontent, padding=[1, 0])
+ 556 elif variant == "improved":
+ 557 newcontent = []
+ 558 for t in range(2, self.T - 2):
+ 559 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
+ 560 newcontent.append(None)
+ 561 else:
+ 562 newcontent.append((1 / 12) * (self.content[t - 2] - 8 * self.content[t - 1] + 8 * self.content[t + 1] - self.content[t + 2]))
+ 563 if (all([x is None for x in newcontent])):
+ 564 raise Exception('Derivative is undefined at all timeslices')
+ 565 return Corr(newcontent, padding=[2, 2])
+ 566 elif variant == 'log':
+ 567 newcontent = []
+ 568 for t in range(self.T):
+ 569 if (self.content[t] is None) or (self.content[t] <= 0):
+ 570 newcontent.append(None)
+ 571 else:
+ 572 newcontent.append(np.log(self.content[t]))
+ 573 if (all([x is None for x in newcontent])):
+ 574 raise Exception("Log is undefined at all timeslices")
+ 575 logcorr = Corr(newcontent)
+ 576 return self * logcorr.deriv('symmetric')
+ 577 else:
+ 578 raise Exception("Unknown variant.")
+ 579
+ 580 def second_deriv(self, variant="symmetric"):
+ 581 """Return the second derivative of the correlator with respect to x0.
+ 582
+ 583 Parameters
+ 584 ----------
+ 585 variant : str
+ 586 decides which definition of the finite differences derivative is used.
+ 587 Available choice: symmetric, improved, log, default: symmetric
+ 588 """
+ 589 if self.N != 1:
+ 590 raise Exception("second_deriv only implemented for one-dimensional correlators.")
+ 591 if variant == "symmetric":
+ 592 newcontent = []
+ 593 for t in range(1, self.T - 1):
+ 594 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
+ 595 newcontent.append(None)
+ 596 else:
+ 597 newcontent.append((self.content[t + 1] - 2 * self.content[t] + self.content[t - 1]))
+ 598 if (all([x is None for x in newcontent])):
+ 599 raise Exception("Derivative is undefined at all timeslices")
+ 600 return Corr(newcontent, padding=[1, 1])
+ 601 elif variant == "improved":
+ 602 newcontent = []
+ 603 for t in range(2, self.T - 2):
+ 604 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
+ 605 newcontent.append(None)
+ 606 else:
+ 607 newcontent.append((1 / 12) * (-self.content[t + 2] + 16 * self.content[t + 1] - 30 * self.content[t] + 16 * self.content[t - 1] - self.content[t - 2]))
+ 608 if (all([x is None for x in newcontent])):
+ 609 raise Exception("Derivative is undefined at all timeslices")
+ 610 return Corr(newcontent, padding=[2, 2])
+ 611 elif variant == 'log':
+ 612 newcontent = []
+ 613 for t in range(self.T):
+ 614 if (self.content[t] is None) or (self.content[t] <= 0):
+ 615 newcontent.append(None)
+ 616 else:
+ 617 newcontent.append(np.log(self.content[t]))
+ 618 if (all([x is None for x in newcontent])):
+ 619 raise Exception("Log is undefined at all timeslices")
+ 620 logcorr = Corr(newcontent)
+ 621 return self * (logcorr.second_deriv('symmetric') + (logcorr.deriv('symmetric'))**2)
+ 622 else:
+ 623 raise Exception("Unknown variant.")
+ 624
+ 625 def m_eff(self, variant='log', guess=1.0):
+ 626 """Returns the effective mass of the correlator as correlator object
+ 627
+ 628 Parameters
+ 629 ----------
+ 630 variant : str
+ 631 log : uses the standard effective mass log(C(t) / C(t+1))
+ 632 cosh, periodic : Use periodicitiy of the correlator by solving C(t) / C(t+1) = cosh(m * (t - T/2)) / cosh(m * (t + 1 - T/2)) for m.
+ 633 sinh : Use anti-periodicitiy of the correlator by solving C(t) / C(t+1) = sinh(m * (t - T/2)) / sinh(m * (t + 1 - T/2)) for m.
+ 634 See, e.g., arXiv:1205.5380
+ 635 arccosh : Uses the explicit form of the symmetrized correlator (not recommended)
+ 636 logsym: uses the symmetric effective mass log(C(t-1) / C(t+1))/2
+ 637 guess : float
+ 638 guess for the root finder, only relevant for the root variant
+ 639 """
+ 640 if self.N != 1:
+ 641 raise Exception('Correlator must be projected before getting m_eff')
+ 642 if variant == 'log':
+ 643 newcontent = []
+ 644 for t in range(self.T - 1):
+ 645 if ((self.content[t] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
646 newcontent.append(None)
- 647 else:
- 648 newcontent.append(self.content[t] / self.content[t + 1])
- 649 if (all([x is None for x in newcontent])):
- 650 raise Exception('m_eff is undefined at all timeslices')
- 651
- 652 return np.log(Corr(newcontent, padding=[0, 1]))
+ 647 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 648 newcontent.append(None)
+ 649 else:
+ 650 newcontent.append(self.content[t] / self.content[t + 1])
+ 651 if (all([x is None for x in newcontent])):
+ 652 raise Exception('m_eff is undefined at all timeslices')
653
- 654 elif variant == 'logsym':
- 655 newcontent = []
- 656 for t in range(1, self.T - 1):
- 657 if ((self.content[t - 1] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
- 658 newcontent.append(None)
- 659 elif self.content[t - 1][0].value / self.content[t + 1][0].value < 0:
+ 654 return np.log(Corr(newcontent, padding=[0, 1]))
+ 655
+ 656 elif variant == 'logsym':
+ 657 newcontent = []
+ 658 for t in range(1, self.T - 1):
+ 659 if ((self.content[t - 1] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
660 newcontent.append(None)
- 661 else:
- 662 newcontent.append(self.content[t - 1] / self.content[t + 1])
- 663 if (all([x is None for x in newcontent])):
- 664 raise Exception('m_eff is undefined at all timeslices')
- 665
- 666 return np.log(Corr(newcontent, padding=[1, 1])) / 2
+ 661 elif self.content[t - 1][0].value / self.content[t + 1][0].value < 0:
+ 662 newcontent.append(None)
+ 663 else:
+ 664 newcontent.append(self.content[t - 1] / self.content[t + 1])
+ 665 if (all([x is None for x in newcontent])):
+ 666 raise Exception('m_eff is undefined at all timeslices')
667
- 668 elif variant in ['periodic', 'cosh', 'sinh']:
- 669 if variant in ['periodic', 'cosh']:
- 670 func = anp.cosh
- 671 else:
- 672 func = anp.sinh
- 673
- 674 def root_function(x, d):
- 675 return func(x * (t - self.T / 2)) / func(x * (t + 1 - self.T / 2)) - d
- 676
- 677 newcontent = []
- 678 for t in range(self.T - 1):
- 679 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 1][0].value == 0):
- 680 newcontent.append(None)
- 681 # Fill the two timeslices in the middle of the lattice with their predecessors
- 682 elif variant == 'sinh' and t in [self.T / 2, self.T / 2 - 1]:
- 683 newcontent.append(newcontent[-1])
- 684 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
- 685 newcontent.append(None)
- 686 else:
- 687 newcontent.append(np.abs(find_root(self.content[t][0] / self.content[t + 1][0], root_function, guess=guess)))
- 688 if (all([x is None for x in newcontent])):
- 689 raise Exception('m_eff is undefined at all timeslices')
- 690
- 691 return Corr(newcontent, padding=[0, 1])
+ 668 return np.log(Corr(newcontent, padding=[1, 1])) / 2
+ 669
+ 670 elif variant in ['periodic', 'cosh', 'sinh']:
+ 671 if variant in ['periodic', 'cosh']:
+ 672 func = anp.cosh
+ 673 else:
+ 674 func = anp.sinh
+ 675
+ 676 def root_function(x, d):
+ 677 return func(x * (t - self.T / 2)) / func(x * (t + 1 - self.T / 2)) - d
+ 678
+ 679 newcontent = []
+ 680 for t in range(self.T - 1):
+ 681 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 1][0].value == 0):
+ 682 newcontent.append(None)
+ 683 # Fill the two timeslices in the middle of the lattice with their predecessors
+ 684 elif variant == 'sinh' and t in [self.T / 2, self.T / 2 - 1]:
+ 685 newcontent.append(newcontent[-1])
+ 686 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 687 newcontent.append(None)
+ 688 else:
+ 689 newcontent.append(np.abs(find_root(self.content[t][0] / self.content[t + 1][0], root_function, guess=guess)))
+ 690 if (all([x is None for x in newcontent])):
+ 691 raise Exception('m_eff is undefined at all timeslices')
692
- 693 elif variant == 'arccosh':
- 694 newcontent = []
- 695 for t in range(1, self.T - 1):
- 696 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t - 1] is None) or (self.content[t][0].value == 0):
- 697 newcontent.append(None)
- 698 else:
- 699 newcontent.append((self.content[t + 1] + self.content[t - 1]) / (2 * self.content[t]))
- 700 if (all([x is None for x in newcontent])):
- 701 raise Exception("m_eff is undefined at all timeslices")
- 702 return np.arccosh(Corr(newcontent, padding=[1, 1]))
- 703
- 704 else:
- 705 raise Exception('Unknown variant.')
- 706
- 707 def fit(self, function, fitrange=None, silent=False, **kwargs):
- 708 r'''Fits function to the data
- 709
- 710 Parameters
- 711 ----------
- 712 function : obj
- 713 function to fit to the data. See fits.least_squares for details.
- 714 fitrange : list
- 715 Two element list containing the timeslices on which the fit is supposed to start and stop.
- 716 Caution: This range is inclusive as opposed to standard python indexing.
- 717 `fitrange=[4, 6]` corresponds to the three entries 4, 5 and 6.
- 718 If not specified, self.prange or all timeslices are used.
- 719 silent : bool
- 720 Decides whether output is printed to the standard output.
- 721 '''
- 722 if self.N != 1:
- 723 raise Exception("Correlator must be projected before fitting")
- 724
- 725 if fitrange is None:
- 726 if self.prange:
- 727 fitrange = self.prange
- 728 else:
- 729 fitrange = [0, self.T - 1]
- 730 else:
- 731 if not isinstance(fitrange, list):
- 732 raise Exception("fitrange has to be a list with two elements")
- 733 if len(fitrange) != 2:
- 734 raise Exception("fitrange has to have exactly two elements [fit_start, fit_stop]")
- 735
- 736 xs = [x for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
- 737 ys = [self.content[x][0] for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
- 738 result = least_squares(xs, ys, function, silent=silent, **kwargs)
- 739 return result
- 740
- 741 def plateau(self, plateau_range=None, method="fit", auto_gamma=False):
- 742 """ Extract a plateau value from a Corr object
- 743
- 744 Parameters
- 745 ----------
- 746 plateau_range : list
- 747 list with two entries, indicating the first and the last timeslice
- 748 of the plateau region.
- 749 method : str
- 750 method to extract the plateau.
- 751 'fit' fits a constant to the plateau region
- 752 'avg', 'average' or 'mean' just average over the given timeslices.
- 753 auto_gamma : bool
- 754 apply gamma_method with default parameters to the Corr. Defaults to None
- 755 """
- 756 if not plateau_range:
- 757 if self.prange:
- 758 plateau_range = self.prange
- 759 else:
- 760 raise Exception("no plateau range provided")
- 761 if self.N != 1:
- 762 raise Exception("Correlator must be projected before getting a plateau.")
- 763 if (all([self.content[t] is None for t in range(plateau_range[0], plateau_range[1] + 1)])):
- 764 raise Exception("plateau is undefined at all timeslices in plateaurange.")
- 765 if auto_gamma:
- 766 self.gamma_method()
- 767 if method == "fit":
- 768 def const_func(a, t):
- 769 return a[0]
- 770 return self.fit(const_func, plateau_range)[0]
- 771 elif method in ["avg", "average", "mean"]:
- 772 returnvalue = np.mean([item[0] for item in self.content[plateau_range[0]:plateau_range[1] + 1] if item is not None])
- 773 return returnvalue
- 774
- 775 else:
- 776 raise Exception("Unsupported plateau method: " + method)
- 777
- 778 def set_prange(self, prange):
- 779 """Sets the attribute prange of the Corr object."""
- 780 if not len(prange) == 2:
- 781 raise Exception("prange must be a list or array with two values")
- 782 if not ((isinstance(prange[0], int)) and (isinstance(prange[1], int))):
- 783 raise Exception("Start and end point must be integers")
- 784 if not (0 <= prange[0] <= self.T and 0 <= prange[1] <= self.T and prange[0] < prange[1]):
- 785 raise Exception("Start and end point must define a range in the interval 0,T")
- 786
- 787 self.prange = prange
- 788 return
- 789
- 790 def show(self, x_range=None, comp=None, y_range=None, logscale=False, plateau=None, fit_res=None, ylabel=None, save=None, auto_gamma=False, hide_sigma=None, references=None, title=None):
- 791 """Plots the correlator using the tag of the correlator as label if available.
- 792
- 793 Parameters
- 794 ----------
- 795 x_range : list
- 796 list of two values, determining the range of the x-axis e.g. [4, 8].
- 797 comp : Corr or list of Corr
- 798 Correlator or list of correlators which are plotted for comparison.
- 799 The tags of these correlators are used as labels if available.
- 800 logscale : bool
- 801 Sets y-axis to logscale.
- 802 plateau : Obs
- 803 Plateau value to be visualized in the figure.
- 804 fit_res : Fit_result
- 805 Fit_result object to be visualized.
- 806 ylabel : str
- 807 Label for the y-axis.
- 808 save : str
- 809 path to file in which the figure should be saved.
- 810 auto_gamma : bool
- 811 Apply the gamma method with standard parameters to all correlators and plateau values before plotting.
- 812 hide_sigma : float
- 813 Hides data points from the first value on which is consistent with zero within 'hide_sigma' standard errors.
- 814 references : list
- 815 List of floating point values that are displayed as horizontal lines for reference.
- 816 title : string
- 817 Optional title of the figure.
- 818 """
- 819 if self.N != 1:
- 820 raise Exception("Correlator must be projected before plotting")
- 821
- 822 if auto_gamma:
- 823 self.gamma_method()
- 824
- 825 if x_range is None:
- 826 x_range = [0, self.T - 1]
- 827
- 828 fig = plt.figure()
- 829 ax1 = fig.add_subplot(111)
- 830
- 831 x, y, y_err = self.plottable()
- 832 if hide_sigma:
- 833 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
- 834 else:
- 835 hide_from = None
- 836 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=self.tag)
- 837 if logscale:
- 838 ax1.set_yscale('log')
- 839 else:
- 840 if y_range is None:
- 841 try:
- 842 y_min = min([(x[0].value - x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
- 843 y_max = max([(x[0].value + x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
- 844 ax1.set_ylim([y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min)])
- 845 except Exception:
- 846 pass
- 847 else:
- 848 ax1.set_ylim(y_range)
- 849 if comp:
- 850 if isinstance(comp, (Corr, list)):
- 851 for corr in comp if isinstance(comp, list) else [comp]:
- 852 if auto_gamma:
- 853 corr.gamma_method()
- 854 x, y, y_err = corr.plottable()
- 855 if hide_sigma:
- 856 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
- 857 else:
- 858 hide_from = None
- 859 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=corr.tag, mfc=plt.rcParams['axes.facecolor'])
- 860 else:
- 861 raise Exception("'comp' must be a correlator or a list of correlators.")
- 862
- 863 if plateau:
- 864 if isinstance(plateau, Obs):
- 865 if auto_gamma:
- 866 plateau.gamma_method()
- 867 ax1.axhline(y=plateau.value, linewidth=2, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--', label=str(plateau))
- 868 ax1.axhspan(plateau.value - plateau.dvalue, plateau.value + plateau.dvalue, alpha=0.25, color=plt.rcParams['text.color'], ls='-')
- 869 else:
- 870 raise Exception("'plateau' must be an Obs")
- 871
- 872 if references:
- 873 if isinstance(references, list):
- 874 for ref in references:
- 875 ax1.axhline(y=ref, linewidth=1, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--')
- 876 else:
- 877 raise Exception("'references' must be a list of floating pint values.")
- 878
- 879 if self.prange:
- 880 ax1.axvline(self.prange[0], 0, 1, ls='-', marker=',')
- 881 ax1.axvline(self.prange[1], 0, 1, ls='-', marker=',')
- 882
- 883 if fit_res:
- 884 x_samples = np.arange(x_range[0], x_range[1] + 1, 0.05)
- 885 ax1.plot(x_samples,
- 886 fit_res.fit_function([o.value for o in fit_res.fit_parameters], x_samples),
- 887 ls='-', marker=',', lw=2)
- 888
- 889 ax1.set_xlabel(r'$x_0 / a$')
- 890 if ylabel:
- 891 ax1.set_ylabel(ylabel)
- 892 ax1.set_xlim([x_range[0] - 0.5, x_range[1] + 0.5])
- 893
- 894 handles, labels = ax1.get_legend_handles_labels()
- 895 if labels:
- 896 ax1.legend()
- 897
- 898 if title:
- 899 plt.title(title)
- 900
- 901 plt.draw()
+ 693 return Corr(newcontent, padding=[0, 1])
+ 694
+ 695 elif variant == 'arccosh':
+ 696 newcontent = []
+ 697 for t in range(1, self.T - 1):
+ 698 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t - 1] is None) or (self.content[t][0].value == 0):
+ 699 newcontent.append(None)
+ 700 else:
+ 701 newcontent.append((self.content[t + 1] + self.content[t - 1]) / (2 * self.content[t]))
+ 702 if (all([x is None for x in newcontent])):
+ 703 raise Exception("m_eff is undefined at all timeslices")
+ 704 return np.arccosh(Corr(newcontent, padding=[1, 1]))
+ 705
+ 706 else:
+ 707 raise Exception('Unknown variant.')
+ 708
+ 709 def fit(self, function, fitrange=None, silent=False, **kwargs):
+ 710 r'''Fits function to the data
+ 711
+ 712 Parameters
+ 713 ----------
+ 714 function : obj
+ 715 function to fit to the data. See fits.least_squares for details.
+ 716 fitrange : list
+ 717 Two element list containing the timeslices on which the fit is supposed to start and stop.
+ 718 Caution: This range is inclusive as opposed to standard python indexing.
+ 719 `fitrange=[4, 6]` corresponds to the three entries 4, 5 and 6.
+ 720 If not specified, self.prange or all timeslices are used.
+ 721 silent : bool
+ 722 Decides whether output is printed to the standard output.
+ 723 '''
+ 724 if self.N != 1:
+ 725 raise Exception("Correlator must be projected before fitting")
+ 726
+ 727 if fitrange is None:
+ 728 if self.prange:
+ 729 fitrange = self.prange
+ 730 else:
+ 731 fitrange = [0, self.T - 1]
+ 732 else:
+ 733 if not isinstance(fitrange, list):
+ 734 raise Exception("fitrange has to be a list with two elements")
+ 735 if len(fitrange) != 2:
+ 736 raise Exception("fitrange has to have exactly two elements [fit_start, fit_stop]")
+ 737
+ 738 xs = [x for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
+ 739 ys = [self.content[x][0] for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
+ 740 result = least_squares(xs, ys, function, silent=silent, **kwargs)
+ 741 return result
+ 742
+ 743 def plateau(self, plateau_range=None, method="fit", auto_gamma=False):
+ 744 """ Extract a plateau value from a Corr object
+ 745
+ 746 Parameters
+ 747 ----------
+ 748 plateau_range : list
+ 749 list with two entries, indicating the first and the last timeslice
+ 750 of the plateau region.
+ 751 method : str
+ 752 method to extract the plateau.
+ 753 'fit' fits a constant to the plateau region
+ 754 'avg', 'average' or 'mean' just average over the given timeslices.
+ 755 auto_gamma : bool
+ 756 apply gamma_method with default parameters to the Corr. Defaults to None
+ 757 """
+ 758 if not plateau_range:
+ 759 if self.prange:
+ 760 plateau_range = self.prange
+ 761 else:
+ 762 raise Exception("no plateau range provided")
+ 763 if self.N != 1:
+ 764 raise Exception("Correlator must be projected before getting a plateau.")
+ 765 if (all([self.content[t] is None for t in range(plateau_range[0], plateau_range[1] + 1)])):
+ 766 raise Exception("plateau is undefined at all timeslices in plateaurange.")
+ 767 if auto_gamma:
+ 768 self.gamma_method()
+ 769 if method == "fit":
+ 770 def const_func(a, t):
+ 771 return a[0]
+ 772 return self.fit(const_func, plateau_range)[0]
+ 773 elif method in ["avg", "average", "mean"]:
+ 774 returnvalue = np.mean([item[0] for item in self.content[plateau_range[0]:plateau_range[1] + 1] if item is not None])
+ 775 return returnvalue
+ 776
+ 777 else:
+ 778 raise Exception("Unsupported plateau method: " + method)
+ 779
+ 780 def set_prange(self, prange):
+ 781 """Sets the attribute prange of the Corr object."""
+ 782 if not len(prange) == 2:
+ 783 raise Exception("prange must be a list or array with two values")
+ 784 if not ((isinstance(prange[0], int)) and (isinstance(prange[1], int))):
+ 785 raise Exception("Start and end point must be integers")
+ 786 if not (0 <= prange[0] <= self.T and 0 <= prange[1] <= self.T and prange[0] < prange[1]):
+ 787 raise Exception("Start and end point must define a range in the interval 0,T")
+ 788
+ 789 self.prange = prange
+ 790 return
+ 791
+ 792 def show(self, x_range=None, comp=None, y_range=None, logscale=False, plateau=None, fit_res=None, ylabel=None, save=None, auto_gamma=False, hide_sigma=None, references=None, title=None):
+ 793 """Plots the correlator using the tag of the correlator as label if available.
+ 794
+ 795 Parameters
+ 796 ----------
+ 797 x_range : list
+ 798 list of two values, determining the range of the x-axis e.g. [4, 8].
+ 799 comp : Corr or list of Corr
+ 800 Correlator or list of correlators which are plotted for comparison.
+ 801 The tags of these correlators are used as labels if available.
+ 802 logscale : bool
+ 803 Sets y-axis to logscale.
+ 804 plateau : Obs
+ 805 Plateau value to be visualized in the figure.
+ 806 fit_res : Fit_result
+ 807 Fit_result object to be visualized.
+ 808 ylabel : str
+ 809 Label for the y-axis.
+ 810 save : str
+ 811 path to file in which the figure should be saved.
+ 812 auto_gamma : bool
+ 813 Apply the gamma method with standard parameters to all correlators and plateau values before plotting.
+ 814 hide_sigma : float
+ 815 Hides data points from the first value on which is consistent with zero within 'hide_sigma' standard errors.
+ 816 references : list
+ 817 List of floating point values that are displayed as horizontal lines for reference.
+ 818 title : string
+ 819 Optional title of the figure.
+ 820 """
+ 821 if self.N != 1:
+ 822 raise Exception("Correlator must be projected before plotting")
+ 823
+ 824 if auto_gamma:
+ 825 self.gamma_method()
+ 826
+ 827 if x_range is None:
+ 828 x_range = [0, self.T - 1]
+ 829
+ 830 fig = plt.figure()
+ 831 ax1 = fig.add_subplot(111)
+ 832
+ 833 x, y, y_err = self.plottable()
+ 834 if hide_sigma:
+ 835 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
+ 836 else:
+ 837 hide_from = None
+ 838 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=self.tag)
+ 839 if logscale:
+ 840 ax1.set_yscale('log')
+ 841 else:
+ 842 if y_range is None:
+ 843 try:
+ 844 y_min = min([(x[0].value - x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
+ 845 y_max = max([(x[0].value + x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
+ 846 ax1.set_ylim([y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min)])
+ 847 except Exception:
+ 848 pass
+ 849 else:
+ 850 ax1.set_ylim(y_range)
+ 851 if comp:
+ 852 if isinstance(comp, (Corr, list)):
+ 853 for corr in comp if isinstance(comp, list) else [comp]:
+ 854 if auto_gamma:
+ 855 corr.gamma_method()
+ 856 x, y, y_err = corr.plottable()
+ 857 if hide_sigma:
+ 858 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
+ 859 else:
+ 860 hide_from = None
+ 861 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=corr.tag, mfc=plt.rcParams['axes.facecolor'])
+ 862 else:
+ 863 raise Exception("'comp' must be a correlator or a list of correlators.")
+ 864
+ 865 if plateau:
+ 866 if isinstance(plateau, Obs):
+ 867 if auto_gamma:
+ 868 plateau.gamma_method()
+ 869 ax1.axhline(y=plateau.value, linewidth=2, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--', label=str(plateau))
+ 870 ax1.axhspan(plateau.value - plateau.dvalue, plateau.value + plateau.dvalue, alpha=0.25, color=plt.rcParams['text.color'], ls='-')
+ 871 else:
+ 872 raise Exception("'plateau' must be an Obs")
+ 873
+ 874 if references:
+ 875 if isinstance(references, list):
+ 876 for ref in references:
+ 877 ax1.axhline(y=ref, linewidth=1, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--')
+ 878 else:
+ 879 raise Exception("'references' must be a list of floating pint values.")
+ 880
+ 881 if self.prange:
+ 882 ax1.axvline(self.prange[0], 0, 1, ls='-', marker=',')
+ 883 ax1.axvline(self.prange[1], 0, 1, ls='-', marker=',')
+ 884
+ 885 if fit_res:
+ 886 x_samples = np.arange(x_range[0], x_range[1] + 1, 0.05)
+ 887 ax1.plot(x_samples,
+ 888 fit_res.fit_function([o.value for o in fit_res.fit_parameters], x_samples),
+ 889 ls='-', marker=',', lw=2)
+ 890
+ 891 ax1.set_xlabel(r'$x_0 / a$')
+ 892 if ylabel:
+ 893 ax1.set_ylabel(ylabel)
+ 894 ax1.set_xlim([x_range[0] - 0.5, x_range[1] + 0.5])
+ 895
+ 896 handles, labels = ax1.get_legend_handles_labels()
+ 897 if labels:
+ 898 ax1.legend()
+ 899
+ 900 if title:
+ 901 plt.title(title)
902
- 903 if save:
- 904 if isinstance(save, str):
- 905 fig.savefig(save, bbox_inches='tight')
- 906 else:
- 907 raise Exception("'save' has to be a string.")
- 908
- 909 def spaghetti_plot(self, logscale=True):
- 910 """Produces a spaghetti plot of the correlator suited to monitor exceptional configurations.
- 911
- 912 Parameters
- 913 ----------
- 914 logscale : bool
- 915 Determines whether the scale of the y-axis is logarithmic or standard.
- 916 """
- 917 if self.N != 1:
- 918 raise Exception("Correlator needs to be projected first.")
- 919
- 920 mc_names = list(set([item for sublist in [sum(map(o[0].e_content.get, o[0].mc_names), []) for o in self.content if o is not None] for item in sublist]))
- 921 x0_vals = [n for (n, o) in zip(np.arange(self.T), self.content) if o is not None]
- 922
- 923 for name in mc_names:
- 924 data = np.array([o[0].deltas[name] + o[0].r_values[name] for o in self.content if o is not None]).T
- 925
- 926 fig = plt.figure()
- 927 ax = fig.add_subplot(111)
- 928 for dat in data:
- 929 ax.plot(x0_vals, dat, ls='-', marker='')
- 930
- 931 if logscale is True:
- 932 ax.set_yscale('log')
- 933
- 934 ax.set_xlabel(r'$x_0 / a$')
- 935 plt.title(name)
- 936 plt.draw()
- 937
- 938 def dump(self, filename, datatype="json.gz", **kwargs):
- 939 """Dumps the Corr into a file of chosen type
- 940 Parameters
- 941 ----------
- 942 filename : str
- 943 Name of the file to be saved.
- 944 datatype : str
- 945 Format of the exported file. Supported formats include
- 946 "json.gz" and "pickle"
- 947 path : str
- 948 specifies a custom path for the file (default '.')
- 949 """
- 950 if datatype == "json.gz":
- 951 from .input.json import dump_to_json
- 952 if 'path' in kwargs:
- 953 file_name = kwargs.get('path') + '/' + filename
- 954 else:
- 955 file_name = filename
- 956 dump_to_json(self, file_name)
- 957 elif datatype == "pickle":
- 958 dump_object(self, filename, **kwargs)
- 959 else:
- 960 raise Exception("Unknown datatype " + str(datatype))
- 961
- 962 def print(self, print_range=None):
- 963 print(self.__repr__(print_range))
- 964
- 965 def __repr__(self, print_range=None):
- 966 if print_range is None:
- 967 print_range = [0, None]
- 968
- 969 content_string = ""
- 970 content_string += "Corr T=" + str(self.T) + " N=" + str(self.N) + "\n" # +" filled with"+ str(type(self.content[0][0])) there should be a good solution here
- 971
- 972 if self.tag is not None:
- 973 content_string += "Description: " + self.tag + "\n"
- 974 if self.N != 1:
- 975 return content_string
- 976 if isinstance(self[0], CObs):
+ 903 plt.draw()
+ 904
+ 905 if save:
+ 906 if isinstance(save, str):
+ 907 fig.savefig(save, bbox_inches='tight')
+ 908 else:
+ 909 raise Exception("'save' has to be a string.")
+ 910
+ 911 def spaghetti_plot(self, logscale=True):
+ 912 """Produces a spaghetti plot of the correlator suited to monitor exceptional configurations.
+ 913
+ 914 Parameters
+ 915 ----------
+ 916 logscale : bool
+ 917 Determines whether the scale of the y-axis is logarithmic or standard.
+ 918 """
+ 919 if self.N != 1:
+ 920 raise Exception("Correlator needs to be projected first.")
+ 921
+ 922 mc_names = list(set([item for sublist in [sum(map(o[0].e_content.get, o[0].mc_names), []) for o in self.content if o is not None] for item in sublist]))
+ 923 x0_vals = [n for (n, o) in zip(np.arange(self.T), self.content) if o is not None]
+ 924
+ 925 for name in mc_names:
+ 926 data = np.array([o[0].deltas[name] + o[0].r_values[name] for o in self.content if o is not None]).T
+ 927
+ 928 fig = plt.figure()
+ 929 ax = fig.add_subplot(111)
+ 930 for dat in data:
+ 931 ax.plot(x0_vals, dat, ls='-', marker='')
+ 932
+ 933 if logscale is True:
+ 934 ax.set_yscale('log')
+ 935
+ 936 ax.set_xlabel(r'$x_0 / a$')
+ 937 plt.title(name)
+ 938 plt.draw()
+ 939
+ 940 def dump(self, filename, datatype="json.gz", **kwargs):
+ 941 """Dumps the Corr into a file of chosen type
+ 942 Parameters
+ 943 ----------
+ 944 filename : str
+ 945 Name of the file to be saved.
+ 946 datatype : str
+ 947 Format of the exported file. Supported formats include
+ 948 "json.gz" and "pickle"
+ 949 path : str
+ 950 specifies a custom path for the file (default '.')
+ 951 """
+ 952 if datatype == "json.gz":
+ 953 from .input.json import dump_to_json
+ 954 if 'path' in kwargs:
+ 955 file_name = kwargs.get('path') + '/' + filename
+ 956 else:
+ 957 file_name = filename
+ 958 dump_to_json(self, file_name)
+ 959 elif datatype == "pickle":
+ 960 dump_object(self, filename, **kwargs)
+ 961 else:
+ 962 raise Exception("Unknown datatype " + str(datatype))
+ 963
+ 964 def print(self, print_range=None):
+ 965 print(self.__repr__(print_range))
+ 966
+ 967 def __repr__(self, print_range=None):
+ 968 if print_range is None:
+ 969 print_range = [0, None]
+ 970
+ 971 content_string = ""
+ 972 content_string += "Corr T=" + str(self.T) + " N=" + str(self.N) + "\n" # +" filled with"+ str(type(self.content[0][0])) there should be a good solution here
+ 973
+ 974 if self.tag is not None:
+ 975 content_string += "Description: " + self.tag + "\n"
+ 976 if self.N != 1:
977 return content_string
- 978
- 979 if print_range[1]:
- 980 print_range[1] += 1
- 981 content_string += 'x0/a\tCorr(x0/a)\n------------------\n'
- 982 for i, sub_corr in enumerate(self.content[print_range[0]:print_range[1]]):
- 983 if sub_corr is None:
- 984 content_string += str(i + print_range[0]) + '\n'
- 985 else:
- 986 content_string += str(i + print_range[0])
- 987 for element in sub_corr:
- 988 content_string += '\t' + ' ' * int(element >= 0) + str(element)
- 989 content_string += '\n'
- 990 return content_string
- 991
- 992 def __str__(self):
- 993 return self.__repr__()
- 994
- 995 # We define the basic operations, that can be performed with correlators.
- 996 # While */+- get defined here, they only work for Corr*Obs and not Obs*Corr.
- 997 # This is because Obs*Corr checks Obs.__mul__ first and does not catch an exception.
- 998 # One could try and tell Obs to check if the y in __mul__ is a Corr and
- 999
-1000 def __add__(self, y):
-1001 if isinstance(y, Corr):
-1002 if ((self.N != y.N) or (self.T != y.T)):
-1003 raise Exception("Addition of Corrs with different shape")
-1004 newcontent = []
-1005 for t in range(self.T):
-1006 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
-1007 newcontent.append(None)
-1008 else:
-1009 newcontent.append(self.content[t] + y.content[t])
-1010 return Corr(newcontent)
-1011
-1012 elif isinstance(y, (Obs, int, float, CObs)):
-1013 newcontent = []
-1014 for t in range(self.T):
-1015 if _check_for_none(self, self.content[t]):
-1016 newcontent.append(None)
-1017 else:
-1018 newcontent.append(self.content[t] + y)
-1019 return Corr(newcontent, prange=self.prange)
-1020 elif isinstance(y, np.ndarray):
-1021 if y.shape == (self.T,):
-1022 return Corr(list((np.array(self.content).T + y).T))
-1023 else:
-1024 raise ValueError("operands could not be broadcast together")
-1025 else:
-1026 raise TypeError("Corr + wrong type")
-1027
-1028 def __mul__(self, y):
-1029 if isinstance(y, Corr):
-1030 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
-1031 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
-1032 newcontent = []
-1033 for t in range(self.T):
-1034 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
-1035 newcontent.append(None)
-1036 else:
-1037 newcontent.append(self.content[t] * y.content[t])
-1038 return Corr(newcontent)
-1039
-1040 elif isinstance(y, (Obs, int, float, CObs)):
-1041 newcontent = []
-1042 for t in range(self.T):
-1043 if _check_for_none(self, self.content[t]):
-1044 newcontent.append(None)
-1045 else:
-1046 newcontent.append(self.content[t] * y)
-1047 return Corr(newcontent, prange=self.prange)
-1048 elif isinstance(y, np.ndarray):
-1049 if y.shape == (self.T,):
-1050 return Corr(list((np.array(self.content).T * y).T))
-1051 else:
-1052 raise ValueError("operands could not be broadcast together")
-1053 else:
-1054 raise TypeError("Corr * wrong type")
-1055
-1056 def __truediv__(self, y):
-1057 if isinstance(y, Corr):
-1058 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
-1059 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
-1060 newcontent = []
-1061 for t in range(self.T):
-1062 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
-1063 newcontent.append(None)
-1064 else:
-1065 newcontent.append(self.content[t] / y.content[t])
-1066 for t in range(self.T):
-1067 if _check_for_none(self, newcontent[t]):
-1068 continue
-1069 if np.isnan(np.sum(newcontent[t]).value):
-1070 newcontent[t] = None
-1071
-1072 if all([item is None for item in newcontent]):
-1073 raise Exception("Division returns completely undefined correlator")
-1074 return Corr(newcontent)
-1075
-1076 elif isinstance(y, (Obs, CObs)):
-1077 if isinstance(y, Obs):
-1078 if y.value == 0:
-1079 raise Exception('Division by zero will return undefined correlator')
-1080 if isinstance(y, CObs):
-1081 if y.is_zero():
-1082 raise Exception('Division by zero will return undefined correlator')
-1083
-1084 newcontent = []
-1085 for t in range(self.T):
-1086 if _check_for_none(self, self.content[t]):
-1087 newcontent.append(None)
-1088 else:
-1089 newcontent.append(self.content[t] / y)
-1090 return Corr(newcontent, prange=self.prange)
-1091
-1092 elif isinstance(y, (int, float)):
-1093 if y == 0:
-1094 raise Exception('Division by zero will return undefined correlator')
-1095 newcontent = []
-1096 for t in range(self.T):
-1097 if _check_for_none(self, self.content[t]):
-1098 newcontent.append(None)
-1099 else:
-1100 newcontent.append(self.content[t] / y)
-1101 return Corr(newcontent, prange=self.prange)
-1102 elif isinstance(y, np.ndarray):
-1103 if y.shape == (self.T,):
-1104 return Corr(list((np.array(self.content).T / y).T))
-1105 else:
-1106 raise ValueError("operands could not be broadcast together")
-1107 else:
-1108 raise TypeError('Corr / wrong type')
-1109
-1110 def __neg__(self):
-1111 newcontent = [None if _check_for_none(self, item) else -1. * item for item in self.content]
-1112 return Corr(newcontent, prange=self.prange)
-1113
-1114 def __sub__(self, y):
-1115 return self + (-y)
-1116
-1117 def __pow__(self, y):
-1118 if isinstance(y, (Obs, int, float, CObs)):
-1119 newcontent = [None if _check_for_none(self, item) else item**y for item in self.content]
-1120 return Corr(newcontent, prange=self.prange)
-1121 else:
-1122 raise TypeError('Type of exponent not supported')
-1123
-1124 def __abs__(self):
-1125 newcontent = [None if _check_for_none(self, item) else np.abs(item) for item in self.content]
-1126 return Corr(newcontent, prange=self.prange)
-1127
-1128 # The numpy functions:
-1129 def sqrt(self):
-1130 return self ** 0.5
-1131
-1132 def log(self):
-1133 newcontent = [None if _check_for_none(self, item) else np.log(item) for item in self.content]
-1134 return Corr(newcontent, prange=self.prange)
-1135
-1136 def exp(self):
-1137 newcontent = [None if _check_for_none(self, item) else np.exp(item) for item in self.content]
-1138 return Corr(newcontent, prange=self.prange)
-1139
-1140 def _apply_func_to_corr(self, func):
-1141 newcontent = [None if _check_for_none(self, item) else func(item) for item in self.content]
-1142 for t in range(self.T):
-1143 if _check_for_none(self, newcontent[t]):
-1144 continue
-1145 tmp_sum = np.sum(newcontent[t])
-1146 if hasattr(tmp_sum, "value"):
-1147 if np.isnan(tmp_sum.value):
-1148 newcontent[t] = None
-1149 if all([item is None for item in newcontent]):
-1150 raise Exception('Operation returns undefined correlator')
-1151 return Corr(newcontent)
-1152
-1153 def sin(self):
-1154 return self._apply_func_to_corr(np.sin)
-1155
-1156 def cos(self):
-1157 return self._apply_func_to_corr(np.cos)
-1158
-1159 def tan(self):
-1160 return self._apply_func_to_corr(np.tan)
-1161
-1162 def sinh(self):
-1163 return self._apply_func_to_corr(np.sinh)
-1164
-1165 def cosh(self):
-1166 return self._apply_func_to_corr(np.cosh)
-1167
-1168 def tanh(self):
-1169 return self._apply_func_to_corr(np.tanh)
-1170
-1171 def arcsin(self):
-1172 return self._apply_func_to_corr(np.arcsin)
-1173
-1174 def arccos(self):
-1175 return self._apply_func_to_corr(np.arccos)
-1176
-1177 def arctan(self):
-1178 return self._apply_func_to_corr(np.arctan)
-1179
-1180 def arcsinh(self):
-1181 return self._apply_func_to_corr(np.arcsinh)
-1182
-1183 def arccosh(self):
-1184 return self._apply_func_to_corr(np.arccosh)
-1185
-1186 def arctanh(self):
-1187 return self._apply_func_to_corr(np.arctanh)
-1188
-1189 # Right hand side operations (require tweak in main module to work)
-1190 def __radd__(self, y):
-1191 return self + y
-1192
-1193 def __rsub__(self, y):
-1194 return -self + y
-1195
-1196 def __rmul__(self, y):
-1197 return self * y
-1198
-1199 def __rtruediv__(self, y):
-1200 return (self / y) ** (-1)
-1201
-1202 @property
-1203 def real(self):
-1204 def return_real(obs_OR_cobs):
-1205 if isinstance(obs_OR_cobs.flatten()[0], CObs):
-1206 return np.vectorize(lambda x: x.real)(obs_OR_cobs)
-1207 else:
-1208 return obs_OR_cobs
-1209
-1210 return self._apply_func_to_corr(return_real)
+ 978 if isinstance(self[0], CObs):
+ 979 return content_string
+ 980
+ 981 if print_range[1]:
+ 982 print_range[1] += 1
+ 983 content_string += 'x0/a\tCorr(x0/a)\n------------------\n'
+ 984 for i, sub_corr in enumerate(self.content[print_range[0]:print_range[1]]):
+ 985 if sub_corr is None:
+ 986 content_string += str(i + print_range[0]) + '\n'
+ 987 else:
+ 988 content_string += str(i + print_range[0])
+ 989 for element in sub_corr:
+ 990 content_string += '\t' + ' ' * int(element >= 0) + str(element)
+ 991 content_string += '\n'
+ 992 return content_string
+ 993
+ 994 def __str__(self):
+ 995 return self.__repr__()
+ 996
+ 997 # We define the basic operations, that can be performed with correlators.
+ 998 # While */+- get defined here, they only work for Corr*Obs and not Obs*Corr.
+ 999 # This is because Obs*Corr checks Obs.__mul__ first and does not catch an exception.
+1000 # One could try and tell Obs to check if the y in __mul__ is a Corr and
+1001
+1002 def __add__(self, y):
+1003 if isinstance(y, Corr):
+1004 if ((self.N != y.N) or (self.T != y.T)):
+1005 raise Exception("Addition of Corrs with different shape")
+1006 newcontent = []
+1007 for t in range(self.T):
+1008 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
+1009 newcontent.append(None)
+1010 else:
+1011 newcontent.append(self.content[t] + y.content[t])
+1012 return Corr(newcontent)
+1013
+1014 elif isinstance(y, (Obs, int, float, CObs)):
+1015 newcontent = []
+1016 for t in range(self.T):
+1017 if _check_for_none(self, self.content[t]):
+1018 newcontent.append(None)
+1019 else:
+1020 newcontent.append(self.content[t] + y)
+1021 return Corr(newcontent, prange=self.prange)
+1022 elif isinstance(y, np.ndarray):
+1023 if y.shape == (self.T,):
+1024 return Corr(list((np.array(self.content).T + y).T))
+1025 else:
+1026 raise ValueError("operands could not be broadcast together")
+1027 else:
+1028 raise TypeError("Corr + wrong type")
+1029
+1030 def __mul__(self, y):
+1031 if isinstance(y, Corr):
+1032 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
+1033 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
+1034 newcontent = []
+1035 for t in range(self.T):
+1036 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
+1037 newcontent.append(None)
+1038 else:
+1039 newcontent.append(self.content[t] * y.content[t])
+1040 return Corr(newcontent)
+1041
+1042 elif isinstance(y, (Obs, int, float, CObs)):
+1043 newcontent = []
+1044 for t in range(self.T):
+1045 if _check_for_none(self, self.content[t]):
+1046 newcontent.append(None)
+1047 else:
+1048 newcontent.append(self.content[t] * y)
+1049 return Corr(newcontent, prange=self.prange)
+1050 elif isinstance(y, np.ndarray):
+1051 if y.shape == (self.T,):
+1052 return Corr(list((np.array(self.content).T * y).T))
+1053 else:
+1054 raise ValueError("operands could not be broadcast together")
+1055 else:
+1056 raise TypeError("Corr * wrong type")
+1057
+1058 def __truediv__(self, y):
+1059 if isinstance(y, Corr):
+1060 if not ((self.N == 1 or y.N == 1 or self.N == y.N) and self.T == y.T):
+1061 raise Exception("Multiplication of Corr object requires N=N or N=1 and T=T")
+1062 newcontent = []
+1063 for t in range(self.T):
+1064 if _check_for_none(self, self.content[t]) or _check_for_none(y, y.content[t]):
+1065 newcontent.append(None)
+1066 else:
+1067 newcontent.append(self.content[t] / y.content[t])
+1068 for t in range(self.T):
+1069 if _check_for_none(self, newcontent[t]):
+1070 continue
+1071 if np.isnan(np.sum(newcontent[t]).value):
+1072 newcontent[t] = None
+1073
+1074 if all([item is None for item in newcontent]):
+1075 raise Exception("Division returns completely undefined correlator")
+1076 return Corr(newcontent)
+1077
+1078 elif isinstance(y, (Obs, CObs)):
+1079 if isinstance(y, Obs):
+1080 if y.value == 0:
+1081 raise Exception('Division by zero will return undefined correlator')
+1082 if isinstance(y, CObs):
+1083 if y.is_zero():
+1084 raise Exception('Division by zero will return undefined correlator')
+1085
+1086 newcontent = []
+1087 for t in range(self.T):
+1088 if _check_for_none(self, self.content[t]):
+1089 newcontent.append(None)
+1090 else:
+1091 newcontent.append(self.content[t] / y)
+1092 return Corr(newcontent, prange=self.prange)
+1093
+1094 elif isinstance(y, (int, float)):
+1095 if y == 0:
+1096 raise Exception('Division by zero will return undefined correlator')
+1097 newcontent = []
+1098 for t in range(self.T):
+1099 if _check_for_none(self, self.content[t]):
+1100 newcontent.append(None)
+1101 else:
+1102 newcontent.append(self.content[t] / y)
+1103 return Corr(newcontent, prange=self.prange)
+1104 elif isinstance(y, np.ndarray):
+1105 if y.shape == (self.T,):
+1106 return Corr(list((np.array(self.content).T / y).T))
+1107 else:
+1108 raise ValueError("operands could not be broadcast together")
+1109 else:
+1110 raise TypeError('Corr / wrong type')
+1111
+1112 def __neg__(self):
+1113 newcontent = [None if _check_for_none(self, item) else -1. * item for item in self.content]
+1114 return Corr(newcontent, prange=self.prange)
+1115
+1116 def __sub__(self, y):
+1117 return self + (-y)
+1118
+1119 def __pow__(self, y):
+1120 if isinstance(y, (Obs, int, float, CObs)):
+1121 newcontent = [None if _check_for_none(self, item) else item**y for item in self.content]
+1122 return Corr(newcontent, prange=self.prange)
+1123 else:
+1124 raise TypeError('Type of exponent not supported')
+1125
+1126 def __abs__(self):
+1127 newcontent = [None if _check_for_none(self, item) else np.abs(item) for item in self.content]
+1128 return Corr(newcontent, prange=self.prange)
+1129
+1130 # The numpy functions:
+1131 def sqrt(self):
+1132 return self ** 0.5
+1133
+1134 def log(self):
+1135 newcontent = [None if _check_for_none(self, item) else np.log(item) for item in self.content]
+1136 return Corr(newcontent, prange=self.prange)
+1137
+1138 def exp(self):
+1139 newcontent = [None if _check_for_none(self, item) else np.exp(item) for item in self.content]
+1140 return Corr(newcontent, prange=self.prange)
+1141
+1142 def _apply_func_to_corr(self, func):
+1143 newcontent = [None if _check_for_none(self, item) else func(item) for item in self.content]
+1144 for t in range(self.T):
+1145 if _check_for_none(self, newcontent[t]):
+1146 continue
+1147 tmp_sum = np.sum(newcontent[t])
+1148 if hasattr(tmp_sum, "value"):
+1149 if np.isnan(tmp_sum.value):
+1150 newcontent[t] = None
+1151 if all([item is None for item in newcontent]):
+1152 raise Exception('Operation returns undefined correlator')
+1153 return Corr(newcontent)
+1154
+1155 def sin(self):
+1156 return self._apply_func_to_corr(np.sin)
+1157
+1158 def cos(self):
+1159 return self._apply_func_to_corr(np.cos)
+1160
+1161 def tan(self):
+1162 return self._apply_func_to_corr(np.tan)
+1163
+1164 def sinh(self):
+1165 return self._apply_func_to_corr(np.sinh)
+1166
+1167 def cosh(self):
+1168 return self._apply_func_to_corr(np.cosh)
+1169
+1170 def tanh(self):
+1171 return self._apply_func_to_corr(np.tanh)
+1172
+1173 def arcsin(self):
+1174 return self._apply_func_to_corr(np.arcsin)
+1175
+1176 def arccos(self):
+1177 return self._apply_func_to_corr(np.arccos)
+1178
+1179 def arctan(self):
+1180 return self._apply_func_to_corr(np.arctan)
+1181
+1182 def arcsinh(self):
+1183 return self._apply_func_to_corr(np.arcsinh)
+1184
+1185 def arccosh(self):
+1186 return self._apply_func_to_corr(np.arccosh)
+1187
+1188 def arctanh(self):
+1189 return self._apply_func_to_corr(np.arctanh)
+1190
+1191 # Right hand side operations (require tweak in main module to work)
+1192 def __radd__(self, y):
+1193 return self + y
+1194
+1195 def __rsub__(self, y):
+1196 return -self + y
+1197
+1198 def __rmul__(self, y):
+1199 return self * y
+1200
+1201 def __rtruediv__(self, y):
+1202 return (self / y) ** (-1)
+1203
+1204 @property
+1205 def real(self):
+1206 def return_real(obs_OR_cobs):
+1207 if isinstance(obs_OR_cobs.flatten()[0], CObs):
+1208 return np.vectorize(lambda x: x.real)(obs_OR_cobs)
+1209 else:
+1210 return obs_OR_cobs
1211
-1212 @property
-1213 def imag(self):
-1214 def return_imag(obs_OR_cobs):
-1215 if isinstance(obs_OR_cobs.flatten()[0], CObs):
-1216 return np.vectorize(lambda x: x.imag)(obs_OR_cobs)
-1217 else:
-1218 return obs_OR_cobs * 0 # So it stays the right type
-1219
-1220 return self._apply_func_to_corr(return_imag)
+1212 return self._apply_func_to_corr(return_real)
+1213
+1214 @property
+1215 def imag(self):
+1216 def return_imag(obs_OR_cobs):
+1217 if isinstance(obs_OR_cobs.flatten()[0], CObs):
+1218 return np.vectorize(lambda x: x.imag)(obs_OR_cobs)
+1219 else:
+1220 return obs_OR_cobs * 0 # So it stays the right type
1221
-1222 def prune(self, Ntrunc, tproj=3, t0proj=2, basematrix=None):
-1223 r''' Project large correlation matrix to lowest states
-1224
-1225 This method can be used to reduce the size of an (N x N) correlation matrix
-1226 to (Ntrunc x Ntrunc) by solving a GEVP at very early times where the noise
-1227 is still small.
-1228
-1229 Parameters
-1230 ----------
-1231 Ntrunc: int
-1232 Rank of the target matrix.
-1233 tproj: int
-1234 Time where the eigenvectors are evaluated, corresponds to ts in the GEVP method.
-1235 The default value is 3.
-1236 t0proj: int
-1237 Time where the correlation matrix is inverted. Choosing t0proj=1 is strongly
-1238 discouraged for O(a) improved theories, since the correctness of the procedure
-1239 cannot be granted in this case. The default value is 2.
-1240 basematrix : Corr
-1241 Correlation matrix that is used to determine the eigenvectors of the
-1242 lowest states based on a GEVP. basematrix is taken to be the Corr itself if
-1243 is is not specified.
-1244
-1245 Notes
-1246 -----
-1247 We have the basematrix $C(t)$ and the target matrix $G(t)$. We start by solving
-1248 the GEVP $$C(t) v_n(t, t_0) = \lambda_n(t, t_0) C(t_0) v_n(t, t_0)$$ where $t \equiv t_\mathrm{proj}$
-1249 and $t_0 \equiv t_{0, \mathrm{proj}}$. The target matrix is projected onto the subspace of the
-1250 resulting eigenvectors $v_n, n=1,\dots,N_\mathrm{trunc}$ via
-1251 $$G^\prime_{i, j}(t) = (v_i, G(t) v_j)$$. This allows to reduce the size of a large
-1252 correlation matrix and to remove some noise that is added by irrelevant operators.
-1253 This may allow to use the GEVP on $G(t)$ at late times such that the theoretically motivated
-1254 bound $t_0 \leq t/2$ holds, since the condition number of $G(t)$ is decreased, compared to $C(t)$.
-1255 '''
-1256
-1257 if self.N == 1:
-1258 raise Exception('Method cannot be applied to one-dimensional correlators.')
-1259 if basematrix is None:
-1260 basematrix = self
-1261 if Ntrunc >= basematrix.N:
-1262 raise Exception('Cannot truncate using Ntrunc <= %d' % (basematrix.N))
-1263 if basematrix.N != self.N:
-1264 raise Exception('basematrix and targetmatrix have to be of the same size.')
-1265
-1266 evecs = basematrix.GEVP(t0proj, tproj, sort=None)[:Ntrunc]
+1222 return self._apply_func_to_corr(return_imag)
+1223
+1224 def prune(self, Ntrunc, tproj=3, t0proj=2, basematrix=None):
+1225 r''' Project large correlation matrix to lowest states
+1226
+1227 This method can be used to reduce the size of an (N x N) correlation matrix
+1228 to (Ntrunc x Ntrunc) by solving a GEVP at very early times where the noise
+1229 is still small.
+1230
+1231 Parameters
+1232 ----------
+1233 Ntrunc: int
+1234 Rank of the target matrix.
+1235 tproj: int
+1236 Time where the eigenvectors are evaluated, corresponds to ts in the GEVP method.
+1237 The default value is 3.
+1238 t0proj: int
+1239 Time where the correlation matrix is inverted. Choosing t0proj=1 is strongly
+1240 discouraged for O(a) improved theories, since the correctness of the procedure
+1241 cannot be granted in this case. The default value is 2.
+1242 basematrix : Corr
+1243 Correlation matrix that is used to determine the eigenvectors of the
+1244 lowest states based on a GEVP. basematrix is taken to be the Corr itself if
+1245 is is not specified.
+1246
+1247 Notes
+1248 -----
+1249 We have the basematrix $C(t)$ and the target matrix $G(t)$. We start by solving
+1250 the GEVP $$C(t) v_n(t, t_0) = \lambda_n(t, t_0) C(t_0) v_n(t, t_0)$$ where $t \equiv t_\mathrm{proj}$
+1251 and $t_0 \equiv t_{0, \mathrm{proj}}$. The target matrix is projected onto the subspace of the
+1252 resulting eigenvectors $v_n, n=1,\dots,N_\mathrm{trunc}$ via
+1253 $$G^\prime_{i, j}(t) = (v_i, G(t) v_j)$$. This allows to reduce the size of a large
+1254 correlation matrix and to remove some noise that is added by irrelevant operators.
+1255 This may allow to use the GEVP on $G(t)$ at late times such that the theoretically motivated
+1256 bound $t_0 \leq t/2$ holds, since the condition number of $G(t)$ is decreased, compared to $C(t)$.
+1257 '''
+1258
+1259 if self.N == 1:
+1260 raise Exception('Method cannot be applied to one-dimensional correlators.')
+1261 if basematrix is None:
+1262 basematrix = self
+1263 if Ntrunc >= basematrix.N:
+1264 raise Exception('Cannot truncate using Ntrunc <= %d' % (basematrix.N))
+1265 if basematrix.N != self.N:
+1266 raise Exception('basematrix and targetmatrix have to be of the same size.')
1267
-1268 tmpmat = np.empty((Ntrunc, Ntrunc), dtype=object)
-1269 rmat = []
-1270 for t in range(basematrix.T):
-1271 for i in range(Ntrunc):
-1272 for j in range(Ntrunc):
-1273 tmpmat[i][j] = evecs[i].T @ self[t] @ evecs[j]
-1274 rmat.append(np.copy(tmpmat))
-1275
-1276 newcontent = [None if (self.content[t] is None) else rmat[t] for t in range(self.T)]
-1277 return Corr(newcontent)
+1268 evecs = basematrix.GEVP(t0proj, tproj, sort=None)[:Ntrunc]
+1269
+1270 tmpmat = np.empty((Ntrunc, Ntrunc), dtype=object)
+1271 rmat = []
+1272 for t in range(basematrix.T):
+1273 for i in range(Ntrunc):
+1274 for j in range(Ntrunc):
+1275 tmpmat[i][j] = evecs[i].T @ self[t] @ evecs[j]
+1276 rmat.append(np.copy(tmpmat))
+1277
+1278 newcontent = [None if (self.content[t] is None) else rmat[t] for t in range(self.T)]
+1279 return Corr(newcontent)
@@ -2835,76 +2839,76 @@ matrix at every timeslice. Other dependency (eg. spatial) are not supported.
- 27 def __init__(self, data_input, padding=[0, 0], prange=None):
-28 """ Initialize a Corr object.
-29
-30 Parameters
-31 ----------
-32 data_input : list or array
-33 list of Obs or list of arrays of Obs or array of Corrs
-34 padding : list, optional
-35 List with two entries where the first labels the padding
-36 at the front of the correlator and the second the padding
-37 at the back.
-38 prange : list, optional
-39 List containing the first and last timeslice of the plateau
-40 region indentified for this correlator.
-41 """
-42
-43 if isinstance(data_input, np.ndarray):
+ 29 def __init__(self, data_input, padding=[0, 0], prange=None):
+30 """ Initialize a Corr object.
+31
+32 Parameters
+33 ----------
+34 data_input : list or array
+35 list of Obs or list of arrays of Obs or array of Corrs
+36 padding : list, optional
+37 List with two entries where the first labels the padding
+38 at the front of the correlator and the second the padding
+39 at the back.
+40 prange : list, optional
+41 List containing the first and last timeslice of the plateau
+42 region indentified for this correlator.
+43 """
44
-45 # This only works, if the array fulfills the conditions below
-46 if not len(data_input.shape) == 2 and data_input.shape[0] == data_input.shape[1]:
-47 raise Exception("Incompatible array shape")
-48 if not all([isinstance(item, Corr) for item in data_input.flatten()]):
-49 raise Exception("If the input is an array, its elements must be of type pe.Corr")
-50 if not all([item.N == 1 for item in data_input.flatten()]):
-51 raise Exception("Can only construct matrix correlator from single valued correlators")
-52 if not len(set([item.T for item in data_input.flatten()])) == 1:
-53 raise Exception("All input Correlators must be defined over the same timeslices.")
-54
-55 T = data_input[0, 0].T
-56 N = data_input.shape[0]
-57 input_as_list = []
-58 for t in range(T):
-59 if any([(item.content[t] is None) for item in data_input.flatten()]):
-60 if not all([(item.content[t] is None) for item in data_input.flatten()]):
-61 warnings.warn("Input ill-defined at different timeslices. Conversion leads to data loss!", RuntimeWarning)
-62 input_as_list.append(None)
-63 else:
-64 array_at_timeslace = np.empty([N, N], dtype="object")
-65 for i in range(N):
-66 for j in range(N):
-67 array_at_timeslace[i, j] = data_input[i, j][t]
-68 input_as_list.append(array_at_timeslace)
-69 data_input = input_as_list
-70
-71 if isinstance(data_input, list):
+45 if isinstance(data_input, np.ndarray):
+46
+47 # This only works, if the array fulfills the conditions below
+48 if not len(data_input.shape) == 2 and data_input.shape[0] == data_input.shape[1]:
+49 raise Exception("Incompatible array shape")
+50 if not all([isinstance(item, Corr) for item in data_input.flatten()]):
+51 raise Exception("If the input is an array, its elements must be of type pe.Corr")
+52 if not all([item.N == 1 for item in data_input.flatten()]):
+53 raise Exception("Can only construct matrix correlator from single valued correlators")
+54 if not len(set([item.T for item in data_input.flatten()])) == 1:
+55 raise Exception("All input Correlators must be defined over the same timeslices.")
+56
+57 T = data_input[0, 0].T
+58 N = data_input.shape[0]
+59 input_as_list = []
+60 for t in range(T):
+61 if any([(item.content[t] is None) for item in data_input.flatten()]):
+62 if not all([(item.content[t] is None) for item in data_input.flatten()]):
+63 warnings.warn("Input ill-defined at different timeslices. Conversion leads to data loss!", RuntimeWarning)
+64 input_as_list.append(None)
+65 else:
+66 array_at_timeslace = np.empty([N, N], dtype="object")
+67 for i in range(N):
+68 for j in range(N):
+69 array_at_timeslace[i, j] = data_input[i, j][t]
+70 input_as_list.append(array_at_timeslace)
+71 data_input = input_as_list
72
-73 if all([isinstance(item, (Obs, CObs)) or item is None for item in data_input]):
-74 _assert_equal_properties([o for o in data_input if o is not None])
-75 self.content = [np.asarray([item]) if item is not None else None for item in data_input]
-76 self.N = 1
-77
-78 elif all([isinstance(item, np.ndarray) or item is None for item in data_input]) and any([isinstance(item, np.ndarray) for item in data_input]):
-79 self.content = data_input
-80 noNull = [a for a in self.content if not (a is None)] # To check if the matrices are correct for all undefined elements
-81 self.N = noNull[0].shape[0]
-82 if self.N > 1 and noNull[0].shape[0] != noNull[0].shape[1]:
-83 raise Exception("Smearing matrices are not NxN")
-84 if (not all([item.shape == noNull[0].shape for item in noNull])):
-85 raise Exception("Items in data_input are not of identical shape." + str(noNull))
-86 else:
-87 raise Exception("data_input contains item of wrong type")
-88 else:
-89 raise Exception("Data input was not given as list or correct array")
-90
-91 self.tag = None
+73 if isinstance(data_input, list):
+74
+75 if all([isinstance(item, (Obs, CObs)) or item is None for item in data_input]):
+76 _assert_equal_properties([o for o in data_input if o is not None])
+77 self.content = [np.asarray([item]) if item is not None else None for item in data_input]
+78 self.N = 1
+79
+80 elif all([isinstance(item, np.ndarray) or item is None for item in data_input]) and any([isinstance(item, np.ndarray) for item in data_input]):
+81 self.content = data_input
+82 noNull = [a for a in self.content if not (a is None)] # To check if the matrices are correct for all undefined elements
+83 self.N = noNull[0].shape[0]
+84 if self.N > 1 and noNull[0].shape[0] != noNull[0].shape[1]:
+85 raise Exception("Smearing matrices are not NxN")
+86 if (not all([item.shape == noNull[0].shape for item in noNull])):
+87 raise Exception("Items in data_input are not of identical shape." + str(noNull))
+88 else:
+89 raise Exception("data_input contains item of wrong type")
+90 else:
+91 raise Exception("Data input was not given as list or correct array")
92
-93 # An undefined timeslice is represented by the None object
-94 self.content = [None] * padding[0] + self.content + [None] * padding[1]
-95 self.T = len(self.content)
-96 self.prange = prange
+93 self.tag = None
+94
+95 # An undefined timeslice is represented by the None object
+96 self.content = [None] * padding[0] + self.content + [None] * padding[1]
+97 self.T = len(self.content)
+98 self.prange = prange
117 def gamma_method(self, **kwargs):
-118 """Apply the gamma method to the content of the Corr."""
-119 for item in self.content:
-120 if not (item is None):
-121 if self.N == 1:
-122 item[0].gamma_method(**kwargs)
-123 else:
-124 for i in range(self.N):
-125 for j in range(self.N):
-126 item[i, j].gamma_method(**kwargs)
+ 119 def gamma_method(self, **kwargs):
+120 """Apply the gamma method to the content of the Corr."""
+121 for item in self.content:
+122 if not (item is None):
+123 if self.N == 1:
+124 item[0].gamma_method(**kwargs)
+125 else:
+126 for i in range(self.N):
+127 for j in range(self.N):
+128 item[i, j].gamma_method(**kwargs)
117 def gamma_method(self, **kwargs):
-118 """Apply the gamma method to the content of the Corr."""
-119 for item in self.content:
-120 if not (item is None):
-121 if self.N == 1:
-122 item[0].gamma_method(**kwargs)
-123 else:
-124 for i in range(self.N):
-125 for j in range(self.N):
-126 item[i, j].gamma_method(**kwargs)
+ 119 def gamma_method(self, **kwargs):
+120 """Apply the gamma method to the content of the Corr."""
+121 for item in self.content:
+122 if not (item is None):
+123 if self.N == 1:
+124 item[0].gamma_method(**kwargs)
+125 else:
+126 for i in range(self.N):
+127 for j in range(self.N):
+128 item[i, j].gamma_method(**kwargs)
130 def projected(self, vector_l=None, vector_r=None, normalize=False):
-131 """We need to project the Correlator with a Vector to get a single value at each timeslice.
-132
-133 The method can use one or two vectors.
-134 If two are specified it returns v1@G@v2 (the order might be very important.)
-135 By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to
-136 """
-137 if self.N == 1:
-138 raise Exception("Trying to project a Corr, that already has N=1.")
-139
-140 if vector_l is None:
-141 vector_l, vector_r = np.asarray([1.] + (self.N - 1) * [0.]), np.asarray([1.] + (self.N - 1) * [0.])
-142 elif (vector_r is None):
-143 vector_r = vector_l
-144 if isinstance(vector_l, list) and not isinstance(vector_r, list):
-145 if len(vector_l) != self.T:
-146 raise Exception("Length of vector list must be equal to T")
-147 vector_r = [vector_r] * self.T
-148 if isinstance(vector_r, list) and not isinstance(vector_l, list):
-149 if len(vector_r) != self.T:
-150 raise Exception("Length of vector list must be equal to T")
-151 vector_l = [vector_l] * self.T
-152
-153 if not isinstance(vector_l, list):
-154 if not vector_l.shape == vector_r.shape == (self.N,):
-155 raise Exception("Vectors are of wrong shape!")
-156 if normalize:
-157 vector_l, vector_r = vector_l / np.sqrt((vector_l @ vector_l)), vector_r / np.sqrt(vector_r @ vector_r)
-158 newcontent = [None if _check_for_none(self, item) else np.asarray([vector_l.T @ item @ vector_r]) for item in self.content]
-159
-160 else:
-161 # There are no checks here yet. There are so many possible scenarios, where this can go wrong.
-162 if normalize:
-163 for t in range(self.T):
-164 vector_l[t], vector_r[t] = vector_l[t] / np.sqrt((vector_l[t] @ vector_l[t])), vector_r[t] / np.sqrt(vector_r[t] @ vector_r[t])
-165
-166 newcontent = [None if (_check_for_none(self, self.content[t]) or vector_l[t] is None or vector_r[t] is None) else np.asarray([vector_l[t].T @ self.content[t] @ vector_r[t]]) for t in range(self.T)]
-167 return Corr(newcontent)
+ 132 def projected(self, vector_l=None, vector_r=None, normalize=False):
+133 """We need to project the Correlator with a Vector to get a single value at each timeslice.
+134
+135 The method can use one or two vectors.
+136 If two are specified it returns v1@G@v2 (the order might be very important.)
+137 By default it will return the lowest source, which usually means unsmeared-unsmeared (0,0), but it does not have to
+138 """
+139 if self.N == 1:
+140 raise Exception("Trying to project a Corr, that already has N=1.")
+141
+142 if vector_l is None:
+143 vector_l, vector_r = np.asarray([1.] + (self.N - 1) * [0.]), np.asarray([1.] + (self.N - 1) * [0.])
+144 elif (vector_r is None):
+145 vector_r = vector_l
+146 if isinstance(vector_l, list) and not isinstance(vector_r, list):
+147 if len(vector_l) != self.T:
+148 raise Exception("Length of vector list must be equal to T")
+149 vector_r = [vector_r] * self.T
+150 if isinstance(vector_r, list) and not isinstance(vector_l, list):
+151 if len(vector_r) != self.T:
+152 raise Exception("Length of vector list must be equal to T")
+153 vector_l = [vector_l] * self.T
+154
+155 if not isinstance(vector_l, list):
+156 if not vector_l.shape == vector_r.shape == (self.N,):
+157 raise Exception("Vectors are of wrong shape!")
+158 if normalize:
+159 vector_l, vector_r = vector_l / np.sqrt((vector_l @ vector_l)), vector_r / np.sqrt(vector_r @ vector_r)
+160 newcontent = [None if _check_for_none(self, item) else np.asarray([vector_l.T @ item @ vector_r]) for item in self.content]
+161
+162 else:
+163 # There are no checks here yet. There are so many possible scenarios, where this can go wrong.
+164 if normalize:
+165 for t in range(self.T):
+166 vector_l[t], vector_r[t] = vector_l[t] / np.sqrt((vector_l[t] @ vector_l[t])), vector_r[t] / np.sqrt(vector_r[t] @ vector_r[t])
+167
+168 newcontent = [None if (_check_for_none(self, self.content[t]) or vector_l[t] is None or vector_r[t] is None) else np.asarray([vector_l[t].T @ self.content[t] @ vector_r[t]]) for t in range(self.T)]
+169 return Corr(newcontent)
169 def item(self, i, j):
-170 """Picks the element [i,j] from every matrix and returns a correlator containing one Obs per timeslice.
-171
-172 Parameters
-173 ----------
-174 i : int
-175 First index to be picked.
-176 j : int
-177 Second index to be picked.
-178 """
-179 if self.N == 1:
-180 raise Exception("Trying to pick item from projected Corr")
-181 newcontent = [None if (item is None) else item[i, j] for item in self.content]
-182 return Corr(newcontent)
+ 171 def item(self, i, j):
+172 """Picks the element [i,j] from every matrix and returns a correlator containing one Obs per timeslice.
+173
+174 Parameters
+175 ----------
+176 i : int
+177 First index to be picked.
+178 j : int
+179 Second index to be picked.
+180 """
+181 if self.N == 1:
+182 raise Exception("Trying to pick item from projected Corr")
+183 newcontent = [None if (item is None) else item[i, j] for item in self.content]
+184 return Corr(newcontent)
184 def plottable(self):
-185 """Outputs the correlator in a plotable format.
-186
-187 Outputs three lists containing the timeslice index, the value on each
-188 timeslice and the error on each timeslice.
-189 """
-190 if self.N != 1:
-191 raise Exception("Can only make Corr[N=1] plottable")
-192 x_list = [x for x in range(self.T) if not self.content[x] is None]
-193 y_list = [y[0].value for y in self.content if y is not None]
-194 y_err_list = [y[0].dvalue for y in self.content if y is not None]
-195
-196 return x_list, y_list, y_err_list
+ 186 def plottable(self):
+187 """Outputs the correlator in a plotable format.
+188
+189 Outputs three lists containing the timeslice index, the value on each
+190 timeslice and the error on each timeslice.
+191 """
+192 if self.N != 1:
+193 raise Exception("Can only make Corr[N=1] plottable")
+194 x_list = [x for x in range(self.T) if not self.content[x] is None]
+195 y_list = [y[0].value for y in self.content if y is not None]
+196 y_err_list = [y[0].dvalue for y in self.content if y is not None]
+197
+198 return x_list, y_list, y_err_list
198 def symmetric(self):
-199 """ Symmetrize the correlator around x0=0."""
-200 if self.N != 1:
-201 raise Exception('symmetric cannot be safely applied to multi-dimensional correlators.')
-202 if self.T % 2 != 0:
-203 raise Exception("Can not symmetrize odd T")
-204
-205 if self.content[0] is not None:
-206 if np.argmax(np.abs([o[0].value if o is not None else 0 for o in self.content])) != 0:
-207 warnings.warn("Correlator does not seem to be symmetric around x0=0.", RuntimeWarning)
-208
-209 newcontent = [self.content[0]]
-210 for t in range(1, self.T):
-211 if (self.content[t] is None) or (self.content[self.T - t] is None):
-212 newcontent.append(None)
-213 else:
-214 newcontent.append(0.5 * (self.content[t] + self.content[self.T - t]))
-215 if (all([x is None for x in newcontent])):
-216 raise Exception("Corr could not be symmetrized: No redundant values")
-217 return Corr(newcontent, prange=self.prange)
+ 200 def symmetric(self):
+201 """ Symmetrize the correlator around x0=0."""
+202 if self.N != 1:
+203 raise Exception('symmetric cannot be safely applied to multi-dimensional correlators.')
+204 if self.T % 2 != 0:
+205 raise Exception("Can not symmetrize odd T")
+206
+207 if self.content[0] is not None:
+208 if np.argmax(np.abs([o[0].value if o is not None else 0 for o in self.content])) != 0:
+209 warnings.warn("Correlator does not seem to be symmetric around x0=0.", RuntimeWarning)
+210
+211 newcontent = [self.content[0]]
+212 for t in range(1, self.T):
+213 if (self.content[t] is None) or (self.content[self.T - t] is None):
+214 newcontent.append(None)
+215 else:
+216 newcontent.append(0.5 * (self.content[t] + self.content[self.T - t]))
+217 if (all([x is None for x in newcontent])):
+218 raise Exception("Corr could not be symmetrized: No redundant values")
+219 return Corr(newcontent, prange=self.prange)
219 def anti_symmetric(self):
-220 """Anti-symmetrize the correlator around x0=0."""
-221 if self.N != 1:
-222 raise Exception('anti_symmetric cannot be safely applied to multi-dimensional correlators.')
-223 if self.T % 2 != 0:
-224 raise Exception("Can not symmetrize odd T")
-225
-226 test = 1 * self
-227 test.gamma_method()
-228 if not all([o.is_zero_within_error(3) for o in test.content[0]]):
-229 warnings.warn("Correlator does not seem to be anti-symmetric around x0=0.", RuntimeWarning)
-230
-231 newcontent = [self.content[0]]
-232 for t in range(1, self.T):
-233 if (self.content[t] is None) or (self.content[self.T - t] is None):
-234 newcontent.append(None)
-235 else:
-236 newcontent.append(0.5 * (self.content[t] - self.content[self.T - t]))
-237 if (all([x is None for x in newcontent])):
-238 raise Exception("Corr could not be symmetrized: No redundant values")
-239 return Corr(newcontent, prange=self.prange)
+ 221 def anti_symmetric(self):
+222 """Anti-symmetrize the correlator around x0=0."""
+223 if self.N != 1:
+224 raise Exception('anti_symmetric cannot be safely applied to multi-dimensional correlators.')
+225 if self.T % 2 != 0:
+226 raise Exception("Can not symmetrize odd T")
+227
+228 test = 1 * self
+229 test.gamma_method()
+230 if not all([o.is_zero_within_error(3) for o in test.content[0]]):
+231 warnings.warn("Correlator does not seem to be anti-symmetric around x0=0.", RuntimeWarning)
+232
+233 newcontent = [self.content[0]]
+234 for t in range(1, self.T):
+235 if (self.content[t] is None) or (self.content[self.T - t] is None):
+236 newcontent.append(None)
+237 else:
+238 newcontent.append(0.5 * (self.content[t] - self.content[self.T - t]))
+239 if (all([x is None for x in newcontent])):
+240 raise Exception("Corr could not be symmetrized: No redundant values")
+241 return Corr(newcontent, prange=self.prange)
241 def is_matrix_symmetric(self):
-242 """Checks whether a correlator matrices is symmetric on every timeslice."""
-243 if self.N == 1:
-244 raise Exception("Only works for correlator matrices.")
-245 for t in range(self.T):
-246 if self[t] is None:
-247 continue
-248 for i in range(self.N):
-249 for j in range(i + 1, self.N):
-250 if self[t][i, j] is self[t][j, i]:
-251 continue
-252 if hash(self[t][i, j]) != hash(self[t][j, i]):
-253 return False
-254 return True
+ 243 def is_matrix_symmetric(self):
+244 """Checks whether a correlator matrices is symmetric on every timeslice."""
+245 if self.N == 1:
+246 raise Exception("Only works for correlator matrices.")
+247 for t in range(self.T):
+248 if self[t] is None:
+249 continue
+250 for i in range(self.N):
+251 for j in range(i + 1, self.N):
+252 if self[t][i, j] is self[t][j, i]:
+253 continue
+254 if hash(self[t][i, j]) != hash(self[t][j, i]):
+255 return False
+256 return True
256 def matrix_symmetric(self):
-257 """Symmetrizes the correlator matrices on every timeslice."""
-258 if self.N == 1:
-259 raise Exception("Trying to symmetrize a correlator matrix, that already has N=1.")
-260 if self.is_matrix_symmetric():
-261 return 1.0 * self
-262 else:
-263 transposed = [None if _check_for_none(self, G) else G.T for G in self.content]
-264 return 0.5 * (Corr(transposed) + self)
+ 258 def matrix_symmetric(self):
+259 """Symmetrizes the correlator matrices on every timeslice."""
+260 if self.N == 1:
+261 raise Exception("Trying to symmetrize a correlator matrix, that already has N=1.")
+262 if self.is_matrix_symmetric():
+263 return 1.0 * self
+264 else:
+265 transposed = [None if _check_for_none(self, G) else G.T for G in self.content]
+266 return 0.5 * (Corr(transposed) + self)
266 def GEVP(self, t0, ts=None, sort="Eigenvalue", **kwargs):
-267 r'''Solve the generalized eigenvalue problem on the correlator matrix and returns the corresponding eigenvectors.
-268
-269 The eigenvectors are sorted according to the descending eigenvalues, the zeroth eigenvector(s) correspond to the
-270 largest eigenvalue(s). The eigenvector(s) for the individual states can be accessed via slicing
-271 ```python
-272 C.GEVP(t0=2)[0] # Ground state vector(s)
-273 C.GEVP(t0=2)[:3] # Vectors for the lowest three states
-274 ```
-275
-276 Parameters
-277 ----------
-278 t0 : int
-279 The time t0 for the right hand side of the GEVP according to $G(t)v_i=\lambda_i G(t_0)v_i$
-280 ts : int
-281 fixed time $G(t_s)v_i=\lambda_i G(t_0)v_i$ if sort=None.
-282 If sort="Eigenvector" it gives a reference point for the sorting method.
-283 sort : string
-284 If this argument is set, a list of self.T vectors per state is returned. If it is set to None, only one vector is returned.
-285 - "Eigenvalue": The eigenvector is chosen according to which eigenvalue it belongs individually on every timeslice.
-286 - "Eigenvector": Use the method described in arXiv:2004.10472 to find the set of v(t) belonging to the state.
-287 The reference state is identified by its eigenvalue at $t=t_s$.
-288
-289 Other Parameters
-290 ----------------
-291 state : int
-292 Returns only the vector(s) for a specified state. The lowest state is zero.
-293 '''
-294
-295 if self.N == 1:
-296 raise Exception("GEVP methods only works on correlator matrices and not single correlators.")
-297 if ts is not None:
-298 if (ts <= t0):
-299 raise Exception("ts has to be larger than t0.")
-300
-301 if "sorted_list" in kwargs:
-302 warnings.warn("Argument 'sorted_list' is deprecated, use 'sort' instead.", DeprecationWarning)
-303 sort = kwargs.get("sorted_list")
-304
-305 if self.is_matrix_symmetric():
-306 symmetric_corr = self
-307 else:
-308 symmetric_corr = self.matrix_symmetric()
-309
-310 G0 = np.vectorize(lambda x: x.value)(symmetric_corr[t0])
-311 np.linalg.cholesky(G0) # Check if matrix G0 is positive-semidefinite.
-312
-313 if sort is None:
-314 if (ts is None):
-315 raise Exception("ts is required if sort=None.")
-316 if (self.content[t0] is None) or (self.content[ts] is None):
-317 raise Exception("Corr not defined at t0/ts.")
-318 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[ts])
-319 reordered_vecs = _GEVP_solver(Gt, G0)
-320
-321 elif sort in ["Eigenvalue", "Eigenvector"]:
-322 if sort == "Eigenvalue" and ts is not None:
-323 warnings.warn("ts has no effect when sorting by eigenvalue is chosen.", RuntimeWarning)
-324 all_vecs = [None] * (t0 + 1)
-325 for t in range(t0 + 1, self.T):
-326 try:
-327 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[t])
-328 all_vecs.append(_GEVP_solver(Gt, G0))
-329 except Exception:
-330 all_vecs.append(None)
-331 if sort == "Eigenvector":
-332 if ts is None:
-333 raise Exception("ts is required for the Eigenvector sorting method.")
-334 all_vecs = _sort_vectors(all_vecs, ts)
-335
-336 reordered_vecs = [[v[s] if v is not None else None for v in all_vecs] for s in range(self.N)]
-337 else:
-338 raise Exception("Unkown value for 'sort'.")
-339
-340 if "state" in kwargs:
-341 return reordered_vecs[kwargs.get("state")]
-342 else:
-343 return reordered_vecs
+ 268 def GEVP(self, t0, ts=None, sort="Eigenvalue", **kwargs):
+269 r'''Solve the generalized eigenvalue problem on the correlator matrix and returns the corresponding eigenvectors.
+270
+271 The eigenvectors are sorted according to the descending eigenvalues, the zeroth eigenvector(s) correspond to the
+272 largest eigenvalue(s). The eigenvector(s) for the individual states can be accessed via slicing
+273 ```python
+274 C.GEVP(t0=2)[0] # Ground state vector(s)
+275 C.GEVP(t0=2)[:3] # Vectors for the lowest three states
+276 ```
+277
+278 Parameters
+279 ----------
+280 t0 : int
+281 The time t0 for the right hand side of the GEVP according to $G(t)v_i=\lambda_i G(t_0)v_i$
+282 ts : int
+283 fixed time $G(t_s)v_i=\lambda_i G(t_0)v_i$ if sort=None.
+284 If sort="Eigenvector" it gives a reference point for the sorting method.
+285 sort : string
+286 If this argument is set, a list of self.T vectors per state is returned. If it is set to None, only one vector is returned.
+287 - "Eigenvalue": The eigenvector is chosen according to which eigenvalue it belongs individually on every timeslice.
+288 - "Eigenvector": Use the method described in arXiv:2004.10472 to find the set of v(t) belonging to the state.
+289 The reference state is identified by its eigenvalue at $t=t_s$.
+290
+291 Other Parameters
+292 ----------------
+293 state : int
+294 Returns only the vector(s) for a specified state. The lowest state is zero.
+295 '''
+296
+297 if self.N == 1:
+298 raise Exception("GEVP methods only works on correlator matrices and not single correlators.")
+299 if ts is not None:
+300 if (ts <= t0):
+301 raise Exception("ts has to be larger than t0.")
+302
+303 if "sorted_list" in kwargs:
+304 warnings.warn("Argument 'sorted_list' is deprecated, use 'sort' instead.", DeprecationWarning)
+305 sort = kwargs.get("sorted_list")
+306
+307 if self.is_matrix_symmetric():
+308 symmetric_corr = self
+309 else:
+310 symmetric_corr = self.matrix_symmetric()
+311
+312 G0 = np.vectorize(lambda x: x.value)(symmetric_corr[t0])
+313 np.linalg.cholesky(G0) # Check if matrix G0 is positive-semidefinite.
+314
+315 if sort is None:
+316 if (ts is None):
+317 raise Exception("ts is required if sort=None.")
+318 if (self.content[t0] is None) or (self.content[ts] is None):
+319 raise Exception("Corr not defined at t0/ts.")
+320 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[ts])
+321 reordered_vecs = _GEVP_solver(Gt, G0)
+322
+323 elif sort in ["Eigenvalue", "Eigenvector"]:
+324 if sort == "Eigenvalue" and ts is not None:
+325 warnings.warn("ts has no effect when sorting by eigenvalue is chosen.", RuntimeWarning)
+326 all_vecs = [None] * (t0 + 1)
+327 for t in range(t0 + 1, self.T):
+328 try:
+329 Gt = np.vectorize(lambda x: x.value)(symmetric_corr[t])
+330 all_vecs.append(_GEVP_solver(Gt, G0))
+331 except Exception:
+332 all_vecs.append(None)
+333 if sort == "Eigenvector":
+334 if ts is None:
+335 raise Exception("ts is required for the Eigenvector sorting method.")
+336 all_vecs = _sort_vectors(all_vecs, ts)
+337
+338 reordered_vecs = [[v[s] if v is not None else None for v in all_vecs] for s in range(self.N)]
+339 else:
+340 raise Exception("Unkown value for 'sort'.")
+341
+342 if "state" in kwargs:
+343 return reordered_vecs[kwargs.get("state")]
+344 else:
+345 return reordered_vecs
345 def Eigenvalue(self, t0, ts=None, state=0, sort="Eigenvalue"):
-346 """Determines the eigenvalue of the GEVP by solving and projecting the correlator
-347
-348 Parameters
-349 ----------
-350 state : int
-351 The state one is interested in ordered by energy. The lowest state is zero.
-352
-353 All other parameters are identical to the ones of Corr.GEVP.
-354 """
-355 vec = self.GEVP(t0, ts=ts, sort=sort)[state]
-356 return self.projected(vec)
+ 347 def Eigenvalue(self, t0, ts=None, state=0, sort="Eigenvalue"):
+348 """Determines the eigenvalue of the GEVP by solving and projecting the correlator
+349
+350 Parameters
+351 ----------
+352 state : int
+353 The state one is interested in ordered by energy. The lowest state is zero.
+354
+355 All other parameters are identical to the ones of Corr.GEVP.
+356 """
+357 vec = self.GEVP(t0, ts=ts, sort=sort)[state]
+358 return self.projected(vec)
358 def Hankel(self, N, periodic=False):
-359 """Constructs an NxN Hankel matrix
-360
-361 C(t) c(t+1) ... c(t+n-1)
-362 C(t+1) c(t+2) ... c(t+n)
-363 .................
-364 C(t+(n-1)) c(t+n) ... c(t+2(n-1))
-365
-366 Parameters
-367 ----------
-368 N : int
-369 Dimension of the Hankel matrix
-370 periodic : bool, optional
-371 determines whether the matrix is extended periodically
-372 """
-373
-374 if self.N != 1:
-375 raise Exception("Multi-operator Prony not implemented!")
-376
-377 array = np.empty([N, N], dtype="object")
-378 new_content = []
-379 for t in range(self.T):
-380 new_content.append(array.copy())
-381
-382 def wrap(i):
-383 while i >= self.T:
-384 i -= self.T
-385 return i
-386
-387 for t in range(self.T):
-388 for i in range(N):
-389 for j in range(N):
-390 if periodic:
-391 new_content[t][i, j] = self.content[wrap(t + i + j)][0]
-392 elif (t + i + j) >= self.T:
-393 new_content[t] = None
-394 else:
-395 new_content[t][i, j] = self.content[t + i + j][0]
-396
-397 return Corr(new_content)
+ 360 def Hankel(self, N, periodic=False):
+361 """Constructs an NxN Hankel matrix
+362
+363 C(t) c(t+1) ... c(t+n-1)
+364 C(t+1) c(t+2) ... c(t+n)
+365 .................
+366 C(t+(n-1)) c(t+n) ... c(t+2(n-1))
+367
+368 Parameters
+369 ----------
+370 N : int
+371 Dimension of the Hankel matrix
+372 periodic : bool, optional
+373 determines whether the matrix is extended periodically
+374 """
+375
+376 if self.N != 1:
+377 raise Exception("Multi-operator Prony not implemented!")
+378
+379 array = np.empty([N, N], dtype="object")
+380 new_content = []
+381 for t in range(self.T):
+382 new_content.append(array.copy())
+383
+384 def wrap(i):
+385 while i >= self.T:
+386 i -= self.T
+387 return i
+388
+389 for t in range(self.T):
+390 for i in range(N):
+391 for j in range(N):
+392 if periodic:
+393 new_content[t][i, j] = self.content[wrap(t + i + j)][0]
+394 elif (t + i + j) >= self.T:
+395 new_content[t] = None
+396 else:
+397 new_content[t][i, j] = self.content[t + i + j][0]
+398
+399 return Corr(new_content)
399 def roll(self, dt):
-400 """Periodically shift the correlator by dt timeslices
-401
-402 Parameters
-403 ----------
-404 dt : int
-405 number of timeslices
-406 """
-407 return Corr(list(np.roll(np.array(self.content, dtype=object), dt)))
+ 401 def roll(self, dt):
+402 """Periodically shift the correlator by dt timeslices
+403
+404 Parameters
+405 ----------
+406 dt : int
+407 number of timeslices
+408 """
+409 return Corr(list(np.roll(np.array(self.content, dtype=object), dt)))
409 def reverse(self):
-410 """Reverse the time ordering of the Corr"""
-411 return Corr(self.content[:: -1])
+ 411 def reverse(self):
+412 """Reverse the time ordering of the Corr"""
+413 return Corr(self.content[:: -1])
413 def thin(self, spacing=2, offset=0):
-414 """Thin out a correlator to suppress correlations
-415
-416 Parameters
-417 ----------
-418 spacing : int
-419 Keep only every 'spacing'th entry of the correlator
-420 offset : int
-421 Offset the equal spacing
-422 """
-423 new_content = []
-424 for t in range(self.T):
-425 if (offset + t) % spacing != 0:
-426 new_content.append(None)
-427 else:
-428 new_content.append(self.content[t])
-429 return Corr(new_content)
+ 415 def thin(self, spacing=2, offset=0):
+416 """Thin out a correlator to suppress correlations
+417
+418 Parameters
+419 ----------
+420 spacing : int
+421 Keep only every 'spacing'th entry of the correlator
+422 offset : int
+423 Offset the equal spacing
+424 """
+425 new_content = []
+426 for t in range(self.T):
+427 if (offset + t) % spacing != 0:
+428 new_content.append(None)
+429 else:
+430 new_content.append(self.content[t])
+431 return Corr(new_content)
431 def correlate(self, partner):
-432 """Correlate the correlator with another correlator or Obs
-433
-434 Parameters
-435 ----------
-436 partner : Obs or Corr
-437 partner to correlate the correlator with.
-438 Can either be an Obs which is correlated with all entries of the
-439 correlator or a Corr of same length.
-440 """
-441 if self.N != 1:
-442 raise Exception("Only one-dimensional correlators can be safely correlated.")
-443 new_content = []
-444 for x0, t_slice in enumerate(self.content):
-445 if _check_for_none(self, t_slice):
-446 new_content.append(None)
-447 else:
-448 if isinstance(partner, Corr):
-449 if _check_for_none(partner, partner.content[x0]):
-450 new_content.append(None)
-451 else:
-452 new_content.append(np.array([correlate(o, partner.content[x0][0]) for o in t_slice]))
-453 elif isinstance(partner, Obs): # Should this include CObs?
-454 new_content.append(np.array([correlate(o, partner) for o in t_slice]))
-455 else:
-456 raise Exception("Can only correlate with an Obs or a Corr.")
-457
-458 return Corr(new_content)
+ 433 def correlate(self, partner):
+434 """Correlate the correlator with another correlator or Obs
+435
+436 Parameters
+437 ----------
+438 partner : Obs or Corr
+439 partner to correlate the correlator with.
+440 Can either be an Obs which is correlated with all entries of the
+441 correlator or a Corr of same length.
+442 """
+443 if self.N != 1:
+444 raise Exception("Only one-dimensional correlators can be safely correlated.")
+445 new_content = []
+446 for x0, t_slice in enumerate(self.content):
+447 if _check_for_none(self, t_slice):
+448 new_content.append(None)
+449 else:
+450 if isinstance(partner, Corr):
+451 if _check_for_none(partner, partner.content[x0]):
+452 new_content.append(None)
+453 else:
+454 new_content.append(np.array([correlate(o, partner.content[x0][0]) for o in t_slice]))
+455 elif isinstance(partner, Obs): # Should this include CObs?
+456 new_content.append(np.array([correlate(o, partner) for o in t_slice]))
+457 else:
+458 raise Exception("Can only correlate with an Obs or a Corr.")
+459
+460 return Corr(new_content)
460 def reweight(self, weight, **kwargs):
-461 """Reweight the correlator.
-462
-463 Parameters
-464 ----------
-465 weight : Obs
-466 Reweighting factor. An Observable that has to be defined on a superset of the
-467 configurations in obs[i].idl for all i.
-468 all_configs : bool
-469 if True, the reweighted observables are normalized by the average of
-470 the reweighting factor on all configurations in weight.idl and not
-471 on the configurations in obs[i].idl.
-472 """
-473 if self.N != 1:
-474 raise Exception("Reweighting only implemented for one-dimensional correlators.")
-475 new_content = []
-476 for t_slice in self.content:
-477 if _check_for_none(self, t_slice):
-478 new_content.append(None)
-479 else:
-480 new_content.append(np.array(reweight(weight, t_slice, **kwargs)))
-481 return Corr(new_content)
+ 462 def reweight(self, weight, **kwargs):
+463 """Reweight the correlator.
+464
+465 Parameters
+466 ----------
+467 weight : Obs
+468 Reweighting factor. An Observable that has to be defined on a superset of the
+469 configurations in obs[i].idl for all i.
+470 all_configs : bool
+471 if True, the reweighted observables are normalized by the average of
+472 the reweighting factor on all configurations in weight.idl and not
+473 on the configurations in obs[i].idl.
+474 """
+475 if self.N != 1:
+476 raise Exception("Reweighting only implemented for one-dimensional correlators.")
+477 new_content = []
+478 for t_slice in self.content:
+479 if _check_for_none(self, t_slice):
+480 new_content.append(None)
+481 else:
+482 new_content.append(np.array(reweight(weight, t_slice, **kwargs)))
+483 return Corr(new_content)
483 def T_symmetry(self, partner, parity=+1):
-484 """Return the time symmetry average of the correlator and its partner
-485
-486 Parameters
-487 ----------
-488 partner : Corr
-489 Time symmetry partner of the Corr
-490 partity : int
-491 Parity quantum number of the correlator, can be +1 or -1
-492 """
-493 if self.N != 1:
-494 raise Exception("T_symmetry only implemented for one-dimensional correlators.")
-495 if not isinstance(partner, Corr):
-496 raise Exception("T partner has to be a Corr object.")
-497 if parity not in [+1, -1]:
-498 raise Exception("Parity has to be +1 or -1.")
-499 T_partner = parity * partner.reverse()
-500
-501 t_slices = []
-502 test = (self - T_partner)
-503 test.gamma_method()
-504 for x0, t_slice in enumerate(test.content):
-505 if t_slice is not None:
-506 if not t_slice[0].is_zero_within_error(5):
-507 t_slices.append(x0)
-508 if t_slices:
-509 warnings.warn("T symmetry partners do not agree within 5 sigma on time slices " + str(t_slices) + ".", RuntimeWarning)
-510
-511 return (self + T_partner) / 2
+ 485 def T_symmetry(self, partner, parity=+1):
+486 """Return the time symmetry average of the correlator and its partner
+487
+488 Parameters
+489 ----------
+490 partner : Corr
+491 Time symmetry partner of the Corr
+492 partity : int
+493 Parity quantum number of the correlator, can be +1 or -1
+494 """
+495 if self.N != 1:
+496 raise Exception("T_symmetry only implemented for one-dimensional correlators.")
+497 if not isinstance(partner, Corr):
+498 raise Exception("T partner has to be a Corr object.")
+499 if parity not in [+1, -1]:
+500 raise Exception("Parity has to be +1 or -1.")
+501 T_partner = parity * partner.reverse()
+502
+503 t_slices = []
+504 test = (self - T_partner)
+505 test.gamma_method()
+506 for x0, t_slice in enumerate(test.content):
+507 if t_slice is not None:
+508 if not t_slice[0].is_zero_within_error(5):
+509 t_slices.append(x0)
+510 if t_slices:
+511 warnings.warn("T symmetry partners do not agree within 5 sigma on time slices " + str(t_slices) + ".", RuntimeWarning)
+512
+513 return (self + T_partner) / 2
513 def deriv(self, variant="symmetric"):
-514 """Return the first derivative of the correlator with respect to x0.
-515
-516 Parameters
-517 ----------
-518 variant : str
-519 decides which definition of the finite differences derivative is used.
-520 Available choice: symmetric, forward, backward, improved, log, default: symmetric
-521 """
-522 if self.N != 1:
-523 raise Exception("deriv only implemented for one-dimensional correlators.")
-524 if variant == "symmetric":
-525 newcontent = []
-526 for t in range(1, self.T - 1):
-527 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
-528 newcontent.append(None)
-529 else:
-530 newcontent.append(0.5 * (self.content[t + 1] - self.content[t - 1]))
-531 if (all([x is None for x in newcontent])):
-532 raise Exception('Derivative is undefined at all timeslices')
-533 return Corr(newcontent, padding=[1, 1])
-534 elif variant == "forward":
-535 newcontent = []
-536 for t in range(self.T - 1):
-537 if (self.content[t] is None) or (self.content[t + 1] is None):
-538 newcontent.append(None)
-539 else:
-540 newcontent.append(self.content[t + 1] - self.content[t])
-541 if (all([x is None for x in newcontent])):
-542 raise Exception("Derivative is undefined at all timeslices")
-543 return Corr(newcontent, padding=[0, 1])
-544 elif variant == "backward":
-545 newcontent = []
-546 for t in range(1, self.T):
-547 if (self.content[t - 1] is None) or (self.content[t] is None):
-548 newcontent.append(None)
-549 else:
-550 newcontent.append(self.content[t] - self.content[t - 1])
-551 if (all([x is None for x in newcontent])):
-552 raise Exception("Derivative is undefined at all timeslices")
-553 return Corr(newcontent, padding=[1, 0])
-554 elif variant == "improved":
-555 newcontent = []
-556 for t in range(2, self.T - 2):
-557 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
-558 newcontent.append(None)
-559 else:
-560 newcontent.append((1 / 12) * (self.content[t - 2] - 8 * self.content[t - 1] + 8 * self.content[t + 1] - self.content[t + 2]))
-561 if (all([x is None for x in newcontent])):
-562 raise Exception('Derivative is undefined at all timeslices')
-563 return Corr(newcontent, padding=[2, 2])
-564 elif variant == 'log':
-565 newcontent = []
-566 for t in range(self.T):
-567 if (self.content[t] is None) or (self.content[t] <= 0):
-568 newcontent.append(None)
-569 else:
-570 newcontent.append(np.log(self.content[t]))
-571 if (all([x is None for x in newcontent])):
-572 raise Exception("Log is undefined at all timeslices")
-573 logcorr = Corr(newcontent)
-574 return self * logcorr.deriv('symmetric')
-575 else:
-576 raise Exception("Unknown variant.")
+ 515 def deriv(self, variant="symmetric"):
+516 """Return the first derivative of the correlator with respect to x0.
+517
+518 Parameters
+519 ----------
+520 variant : str
+521 decides which definition of the finite differences derivative is used.
+522 Available choice: symmetric, forward, backward, improved, log, default: symmetric
+523 """
+524 if self.N != 1:
+525 raise Exception("deriv only implemented for one-dimensional correlators.")
+526 if variant == "symmetric":
+527 newcontent = []
+528 for t in range(1, self.T - 1):
+529 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
+530 newcontent.append(None)
+531 else:
+532 newcontent.append(0.5 * (self.content[t + 1] - self.content[t - 1]))
+533 if (all([x is None for x in newcontent])):
+534 raise Exception('Derivative is undefined at all timeslices')
+535 return Corr(newcontent, padding=[1, 1])
+536 elif variant == "forward":
+537 newcontent = []
+538 for t in range(self.T - 1):
+539 if (self.content[t] is None) or (self.content[t + 1] is None):
+540 newcontent.append(None)
+541 else:
+542 newcontent.append(self.content[t + 1] - self.content[t])
+543 if (all([x is None for x in newcontent])):
+544 raise Exception("Derivative is undefined at all timeslices")
+545 return Corr(newcontent, padding=[0, 1])
+546 elif variant == "backward":
+547 newcontent = []
+548 for t in range(1, self.T):
+549 if (self.content[t - 1] is None) or (self.content[t] is None):
+550 newcontent.append(None)
+551 else:
+552 newcontent.append(self.content[t] - self.content[t - 1])
+553 if (all([x is None for x in newcontent])):
+554 raise Exception("Derivative is undefined at all timeslices")
+555 return Corr(newcontent, padding=[1, 0])
+556 elif variant == "improved":
+557 newcontent = []
+558 for t in range(2, self.T - 2):
+559 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
+560 newcontent.append(None)
+561 else:
+562 newcontent.append((1 / 12) * (self.content[t - 2] - 8 * self.content[t - 1] + 8 * self.content[t + 1] - self.content[t + 2]))
+563 if (all([x is None for x in newcontent])):
+564 raise Exception('Derivative is undefined at all timeslices')
+565 return Corr(newcontent, padding=[2, 2])
+566 elif variant == 'log':
+567 newcontent = []
+568 for t in range(self.T):
+569 if (self.content[t] is None) or (self.content[t] <= 0):
+570 newcontent.append(None)
+571 else:
+572 newcontent.append(np.log(self.content[t]))
+573 if (all([x is None for x in newcontent])):
+574 raise Exception("Log is undefined at all timeslices")
+575 logcorr = Corr(newcontent)
+576 return self * logcorr.deriv('symmetric')
+577 else:
+578 raise Exception("Unknown variant.")
578 def second_deriv(self, variant="symmetric"):
-579 """Return the second derivative of the correlator with respect to x0.
-580
-581 Parameters
-582 ----------
-583 variant : str
-584 decides which definition of the finite differences derivative is used.
-585 Available choice: symmetric, improved, log, default: symmetric
-586 """
-587 if self.N != 1:
-588 raise Exception("second_deriv only implemented for one-dimensional correlators.")
-589 if variant == "symmetric":
-590 newcontent = []
-591 for t in range(1, self.T - 1):
-592 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
-593 newcontent.append(None)
-594 else:
-595 newcontent.append((self.content[t + 1] - 2 * self.content[t] + self.content[t - 1]))
-596 if (all([x is None for x in newcontent])):
-597 raise Exception("Derivative is undefined at all timeslices")
-598 return Corr(newcontent, padding=[1, 1])
-599 elif variant == "improved":
-600 newcontent = []
-601 for t in range(2, self.T - 2):
-602 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
-603 newcontent.append(None)
-604 else:
-605 newcontent.append((1 / 12) * (-self.content[t + 2] + 16 * self.content[t + 1] - 30 * self.content[t] + 16 * self.content[t - 1] - self.content[t - 2]))
-606 if (all([x is None for x in newcontent])):
-607 raise Exception("Derivative is undefined at all timeslices")
-608 return Corr(newcontent, padding=[2, 2])
-609 elif variant == 'log':
-610 newcontent = []
-611 for t in range(self.T):
-612 if (self.content[t] is None) or (self.content[t] <= 0):
-613 newcontent.append(None)
-614 else:
-615 newcontent.append(np.log(self.content[t]))
-616 if (all([x is None for x in newcontent])):
-617 raise Exception("Log is undefined at all timeslices")
-618 logcorr = Corr(newcontent)
-619 return self * (logcorr.second_deriv('symmetric') + (logcorr.deriv('symmetric'))**2)
-620 else:
-621 raise Exception("Unknown variant.")
+ 580 def second_deriv(self, variant="symmetric"):
+581 """Return the second derivative of the correlator with respect to x0.
+582
+583 Parameters
+584 ----------
+585 variant : str
+586 decides which definition of the finite differences derivative is used.
+587 Available choice: symmetric, improved, log, default: symmetric
+588 """
+589 if self.N != 1:
+590 raise Exception("second_deriv only implemented for one-dimensional correlators.")
+591 if variant == "symmetric":
+592 newcontent = []
+593 for t in range(1, self.T - 1):
+594 if (self.content[t - 1] is None) or (self.content[t + 1] is None):
+595 newcontent.append(None)
+596 else:
+597 newcontent.append((self.content[t + 1] - 2 * self.content[t] + self.content[t - 1]))
+598 if (all([x is None for x in newcontent])):
+599 raise Exception("Derivative is undefined at all timeslices")
+600 return Corr(newcontent, padding=[1, 1])
+601 elif variant == "improved":
+602 newcontent = []
+603 for t in range(2, self.T - 2):
+604 if (self.content[t - 2] is None) or (self.content[t - 1] is None) or (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 2] is None):
+605 newcontent.append(None)
+606 else:
+607 newcontent.append((1 / 12) * (-self.content[t + 2] + 16 * self.content[t + 1] - 30 * self.content[t] + 16 * self.content[t - 1] - self.content[t - 2]))
+608 if (all([x is None for x in newcontent])):
+609 raise Exception("Derivative is undefined at all timeslices")
+610 return Corr(newcontent, padding=[2, 2])
+611 elif variant == 'log':
+612 newcontent = []
+613 for t in range(self.T):
+614 if (self.content[t] is None) or (self.content[t] <= 0):
+615 newcontent.append(None)
+616 else:
+617 newcontent.append(np.log(self.content[t]))
+618 if (all([x is None for x in newcontent])):
+619 raise Exception("Log is undefined at all timeslices")
+620 logcorr = Corr(newcontent)
+621 return self * (logcorr.second_deriv('symmetric') + (logcorr.deriv('symmetric'))**2)
+622 else:
+623 raise Exception("Unknown variant.")
623 def m_eff(self, variant='log', guess=1.0):
-624 """Returns the effective mass of the correlator as correlator object
-625
-626 Parameters
-627 ----------
-628 variant : str
-629 log : uses the standard effective mass log(C(t) / C(t+1))
-630 cosh, periodic : Use periodicitiy of the correlator by solving C(t) / C(t+1) = cosh(m * (t - T/2)) / cosh(m * (t + 1 - T/2)) for m.
-631 sinh : Use anti-periodicitiy of the correlator by solving C(t) / C(t+1) = sinh(m * (t - T/2)) / sinh(m * (t + 1 - T/2)) for m.
-632 See, e.g., arXiv:1205.5380
-633 arccosh : Uses the explicit form of the symmetrized correlator (not recommended)
-634 logsym: uses the symmetric effective mass log(C(t-1) / C(t+1))/2
-635 guess : float
-636 guess for the root finder, only relevant for the root variant
-637 """
-638 if self.N != 1:
-639 raise Exception('Correlator must be projected before getting m_eff')
-640 if variant == 'log':
-641 newcontent = []
-642 for t in range(self.T - 1):
-643 if ((self.content[t] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
-644 newcontent.append(None)
-645 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+ 625 def m_eff(self, variant='log', guess=1.0):
+626 """Returns the effective mass of the correlator as correlator object
+627
+628 Parameters
+629 ----------
+630 variant : str
+631 log : uses the standard effective mass log(C(t) / C(t+1))
+632 cosh, periodic : Use periodicitiy of the correlator by solving C(t) / C(t+1) = cosh(m * (t - T/2)) / cosh(m * (t + 1 - T/2)) for m.
+633 sinh : Use anti-periodicitiy of the correlator by solving C(t) / C(t+1) = sinh(m * (t - T/2)) / sinh(m * (t + 1 - T/2)) for m.
+634 See, e.g., arXiv:1205.5380
+635 arccosh : Uses the explicit form of the symmetrized correlator (not recommended)
+636 logsym: uses the symmetric effective mass log(C(t-1) / C(t+1))/2
+637 guess : float
+638 guess for the root finder, only relevant for the root variant
+639 """
+640 if self.N != 1:
+641 raise Exception('Correlator must be projected before getting m_eff')
+642 if variant == 'log':
+643 newcontent = []
+644 for t in range(self.T - 1):
+645 if ((self.content[t] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
646 newcontent.append(None)
-647 else:
-648 newcontent.append(self.content[t] / self.content[t + 1])
-649 if (all([x is None for x in newcontent])):
-650 raise Exception('m_eff is undefined at all timeslices')
-651
-652 return np.log(Corr(newcontent, padding=[0, 1]))
+647 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+648 newcontent.append(None)
+649 else:
+650 newcontent.append(self.content[t] / self.content[t + 1])
+651 if (all([x is None for x in newcontent])):
+652 raise Exception('m_eff is undefined at all timeslices')
653
-654 elif variant == 'logsym':
-655 newcontent = []
-656 for t in range(1, self.T - 1):
-657 if ((self.content[t - 1] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
-658 newcontent.append(None)
-659 elif self.content[t - 1][0].value / self.content[t + 1][0].value < 0:
+654 return np.log(Corr(newcontent, padding=[0, 1]))
+655
+656 elif variant == 'logsym':
+657 newcontent = []
+658 for t in range(1, self.T - 1):
+659 if ((self.content[t - 1] is None) or (self.content[t + 1] is None)) or (self.content[t + 1][0].value == 0):
660 newcontent.append(None)
-661 else:
-662 newcontent.append(self.content[t - 1] / self.content[t + 1])
-663 if (all([x is None for x in newcontent])):
-664 raise Exception('m_eff is undefined at all timeslices')
-665
-666 return np.log(Corr(newcontent, padding=[1, 1])) / 2
+661 elif self.content[t - 1][0].value / self.content[t + 1][0].value < 0:
+662 newcontent.append(None)
+663 else:
+664 newcontent.append(self.content[t - 1] / self.content[t + 1])
+665 if (all([x is None for x in newcontent])):
+666 raise Exception('m_eff is undefined at all timeslices')
667
-668 elif variant in ['periodic', 'cosh', 'sinh']:
-669 if variant in ['periodic', 'cosh']:
-670 func = anp.cosh
-671 else:
-672 func = anp.sinh
-673
-674 def root_function(x, d):
-675 return func(x * (t - self.T / 2)) / func(x * (t + 1 - self.T / 2)) - d
-676
-677 newcontent = []
-678 for t in range(self.T - 1):
-679 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 1][0].value == 0):
-680 newcontent.append(None)
-681 # Fill the two timeslices in the middle of the lattice with their predecessors
-682 elif variant == 'sinh' and t in [self.T / 2, self.T / 2 - 1]:
-683 newcontent.append(newcontent[-1])
-684 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
-685 newcontent.append(None)
-686 else:
-687 newcontent.append(np.abs(find_root(self.content[t][0] / self.content[t + 1][0], root_function, guess=guess)))
-688 if (all([x is None for x in newcontent])):
-689 raise Exception('m_eff is undefined at all timeslices')
-690
-691 return Corr(newcontent, padding=[0, 1])
+668 return np.log(Corr(newcontent, padding=[1, 1])) / 2
+669
+670 elif variant in ['periodic', 'cosh', 'sinh']:
+671 if variant in ['periodic', 'cosh']:
+672 func = anp.cosh
+673 else:
+674 func = anp.sinh
+675
+676 def root_function(x, d):
+677 return func(x * (t - self.T / 2)) / func(x * (t + 1 - self.T / 2)) - d
+678
+679 newcontent = []
+680 for t in range(self.T - 1):
+681 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t + 1][0].value == 0):
+682 newcontent.append(None)
+683 # Fill the two timeslices in the middle of the lattice with their predecessors
+684 elif variant == 'sinh' and t in [self.T / 2, self.T / 2 - 1]:
+685 newcontent.append(newcontent[-1])
+686 elif self.content[t][0].value / self.content[t + 1][0].value < 0:
+687 newcontent.append(None)
+688 else:
+689 newcontent.append(np.abs(find_root(self.content[t][0] / self.content[t + 1][0], root_function, guess=guess)))
+690 if (all([x is None for x in newcontent])):
+691 raise Exception('m_eff is undefined at all timeslices')
692
-693 elif variant == 'arccosh':
-694 newcontent = []
-695 for t in range(1, self.T - 1):
-696 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t - 1] is None) or (self.content[t][0].value == 0):
-697 newcontent.append(None)
-698 else:
-699 newcontent.append((self.content[t + 1] + self.content[t - 1]) / (2 * self.content[t]))
-700 if (all([x is None for x in newcontent])):
-701 raise Exception("m_eff is undefined at all timeslices")
-702 return np.arccosh(Corr(newcontent, padding=[1, 1]))
-703
-704 else:
-705 raise Exception('Unknown variant.')
+693 return Corr(newcontent, padding=[0, 1])
+694
+695 elif variant == 'arccosh':
+696 newcontent = []
+697 for t in range(1, self.T - 1):
+698 if (self.content[t] is None) or (self.content[t + 1] is None) or (self.content[t - 1] is None) or (self.content[t][0].value == 0):
+699 newcontent.append(None)
+700 else:
+701 newcontent.append((self.content[t + 1] + self.content[t - 1]) / (2 * self.content[t]))
+702 if (all([x is None for x in newcontent])):
+703 raise Exception("m_eff is undefined at all timeslices")
+704 return np.arccosh(Corr(newcontent, padding=[1, 1]))
+705
+706 else:
+707 raise Exception('Unknown variant.')
707 def fit(self, function, fitrange=None, silent=False, **kwargs):
-708 r'''Fits function to the data
-709
-710 Parameters
-711 ----------
-712 function : obj
-713 function to fit to the data. See fits.least_squares for details.
-714 fitrange : list
-715 Two element list containing the timeslices on which the fit is supposed to start and stop.
-716 Caution: This range is inclusive as opposed to standard python indexing.
-717 `fitrange=[4, 6]` corresponds to the three entries 4, 5 and 6.
-718 If not specified, self.prange or all timeslices are used.
-719 silent : bool
-720 Decides whether output is printed to the standard output.
-721 '''
-722 if self.N != 1:
-723 raise Exception("Correlator must be projected before fitting")
-724
-725 if fitrange is None:
-726 if self.prange:
-727 fitrange = self.prange
-728 else:
-729 fitrange = [0, self.T - 1]
-730 else:
-731 if not isinstance(fitrange, list):
-732 raise Exception("fitrange has to be a list with two elements")
-733 if len(fitrange) != 2:
-734 raise Exception("fitrange has to have exactly two elements [fit_start, fit_stop]")
-735
-736 xs = [x for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
-737 ys = [self.content[x][0] for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
-738 result = least_squares(xs, ys, function, silent=silent, **kwargs)
-739 return result
+ 709 def fit(self, function, fitrange=None, silent=False, **kwargs):
+710 r'''Fits function to the data
+711
+712 Parameters
+713 ----------
+714 function : obj
+715 function to fit to the data. See fits.least_squares for details.
+716 fitrange : list
+717 Two element list containing the timeslices on which the fit is supposed to start and stop.
+718 Caution: This range is inclusive as opposed to standard python indexing.
+719 `fitrange=[4, 6]` corresponds to the three entries 4, 5 and 6.
+720 If not specified, self.prange or all timeslices are used.
+721 silent : bool
+722 Decides whether output is printed to the standard output.
+723 '''
+724 if self.N != 1:
+725 raise Exception("Correlator must be projected before fitting")
+726
+727 if fitrange is None:
+728 if self.prange:
+729 fitrange = self.prange
+730 else:
+731 fitrange = [0, self.T - 1]
+732 else:
+733 if not isinstance(fitrange, list):
+734 raise Exception("fitrange has to be a list with two elements")
+735 if len(fitrange) != 2:
+736 raise Exception("fitrange has to have exactly two elements [fit_start, fit_stop]")
+737
+738 xs = [x for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
+739 ys = [self.content[x][0] for x in range(fitrange[0], fitrange[1] + 1) if not self.content[x] is None]
+740 result = least_squares(xs, ys, function, silent=silent, **kwargs)
+741 return result
741 def plateau(self, plateau_range=None, method="fit", auto_gamma=False):
-742 """ Extract a plateau value from a Corr object
-743
-744 Parameters
-745 ----------
-746 plateau_range : list
-747 list with two entries, indicating the first and the last timeslice
-748 of the plateau region.
-749 method : str
-750 method to extract the plateau.
-751 'fit' fits a constant to the plateau region
-752 'avg', 'average' or 'mean' just average over the given timeslices.
-753 auto_gamma : bool
-754 apply gamma_method with default parameters to the Corr. Defaults to None
-755 """
-756 if not plateau_range:
-757 if self.prange:
-758 plateau_range = self.prange
-759 else:
-760 raise Exception("no plateau range provided")
-761 if self.N != 1:
-762 raise Exception("Correlator must be projected before getting a plateau.")
-763 if (all([self.content[t] is None for t in range(plateau_range[0], plateau_range[1] + 1)])):
-764 raise Exception("plateau is undefined at all timeslices in plateaurange.")
-765 if auto_gamma:
-766 self.gamma_method()
-767 if method == "fit":
-768 def const_func(a, t):
-769 return a[0]
-770 return self.fit(const_func, plateau_range)[0]
-771 elif method in ["avg", "average", "mean"]:
-772 returnvalue = np.mean([item[0] for item in self.content[plateau_range[0]:plateau_range[1] + 1] if item is not None])
-773 return returnvalue
-774
-775 else:
-776 raise Exception("Unsupported plateau method: " + method)
+ 743 def plateau(self, plateau_range=None, method="fit", auto_gamma=False):
+744 """ Extract a plateau value from a Corr object
+745
+746 Parameters
+747 ----------
+748 plateau_range : list
+749 list with two entries, indicating the first and the last timeslice
+750 of the plateau region.
+751 method : str
+752 method to extract the plateau.
+753 'fit' fits a constant to the plateau region
+754 'avg', 'average' or 'mean' just average over the given timeslices.
+755 auto_gamma : bool
+756 apply gamma_method with default parameters to the Corr. Defaults to None
+757 """
+758 if not plateau_range:
+759 if self.prange:
+760 plateau_range = self.prange
+761 else:
+762 raise Exception("no plateau range provided")
+763 if self.N != 1:
+764 raise Exception("Correlator must be projected before getting a plateau.")
+765 if (all([self.content[t] is None for t in range(plateau_range[0], plateau_range[1] + 1)])):
+766 raise Exception("plateau is undefined at all timeslices in plateaurange.")
+767 if auto_gamma:
+768 self.gamma_method()
+769 if method == "fit":
+770 def const_func(a, t):
+771 return a[0]
+772 return self.fit(const_func, plateau_range)[0]
+773 elif method in ["avg", "average", "mean"]:
+774 returnvalue = np.mean([item[0] for item in self.content[plateau_range[0]:plateau_range[1] + 1] if item is not None])
+775 return returnvalue
+776
+777 else:
+778 raise Exception("Unsupported plateau method: " + method)
778 def set_prange(self, prange):
-779 """Sets the attribute prange of the Corr object."""
-780 if not len(prange) == 2:
-781 raise Exception("prange must be a list or array with two values")
-782 if not ((isinstance(prange[0], int)) and (isinstance(prange[1], int))):
-783 raise Exception("Start and end point must be integers")
-784 if not (0 <= prange[0] <= self.T and 0 <= prange[1] <= self.T and prange[0] < prange[1]):
-785 raise Exception("Start and end point must define a range in the interval 0,T")
-786
-787 self.prange = prange
-788 return
+ 780 def set_prange(self, prange):
+781 """Sets the attribute prange of the Corr object."""
+782 if not len(prange) == 2:
+783 raise Exception("prange must be a list or array with two values")
+784 if not ((isinstance(prange[0], int)) and (isinstance(prange[1], int))):
+785 raise Exception("Start and end point must be integers")
+786 if not (0 <= prange[0] <= self.T and 0 <= prange[1] <= self.T and prange[0] < prange[1]):
+787 raise Exception("Start and end point must define a range in the interval 0,T")
+788
+789 self.prange = prange
+790 return
790 def show(self, x_range=None, comp=None, y_range=None, logscale=False, plateau=None, fit_res=None, ylabel=None, save=None, auto_gamma=False, hide_sigma=None, references=None, title=None):
-791 """Plots the correlator using the tag of the correlator as label if available.
-792
-793 Parameters
-794 ----------
-795 x_range : list
-796 list of two values, determining the range of the x-axis e.g. [4, 8].
-797 comp : Corr or list of Corr
-798 Correlator or list of correlators which are plotted for comparison.
-799 The tags of these correlators are used as labels if available.
-800 logscale : bool
-801 Sets y-axis to logscale.
-802 plateau : Obs
-803 Plateau value to be visualized in the figure.
-804 fit_res : Fit_result
-805 Fit_result object to be visualized.
-806 ylabel : str
-807 Label for the y-axis.
-808 save : str
-809 path to file in which the figure should be saved.
-810 auto_gamma : bool
-811 Apply the gamma method with standard parameters to all correlators and plateau values before plotting.
-812 hide_sigma : float
-813 Hides data points from the first value on which is consistent with zero within 'hide_sigma' standard errors.
-814 references : list
-815 List of floating point values that are displayed as horizontal lines for reference.
-816 title : string
-817 Optional title of the figure.
-818 """
-819 if self.N != 1:
-820 raise Exception("Correlator must be projected before plotting")
-821
-822 if auto_gamma:
-823 self.gamma_method()
-824
-825 if x_range is None:
-826 x_range = [0, self.T - 1]
-827
-828 fig = plt.figure()
-829 ax1 = fig.add_subplot(111)
-830
-831 x, y, y_err = self.plottable()
-832 if hide_sigma:
-833 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
-834 else:
-835 hide_from = None
-836 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=self.tag)
-837 if logscale:
-838 ax1.set_yscale('log')
-839 else:
-840 if y_range is None:
-841 try:
-842 y_min = min([(x[0].value - x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
-843 y_max = max([(x[0].value + x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
-844 ax1.set_ylim([y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min)])
-845 except Exception:
-846 pass
-847 else:
-848 ax1.set_ylim(y_range)
-849 if comp:
-850 if isinstance(comp, (Corr, list)):
-851 for corr in comp if isinstance(comp, list) else [comp]:
-852 if auto_gamma:
-853 corr.gamma_method()
-854 x, y, y_err = corr.plottable()
-855 if hide_sigma:
-856 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
-857 else:
-858 hide_from = None
-859 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=corr.tag, mfc=plt.rcParams['axes.facecolor'])
-860 else:
-861 raise Exception("'comp' must be a correlator or a list of correlators.")
-862
-863 if plateau:
-864 if isinstance(plateau, Obs):
-865 if auto_gamma:
-866 plateau.gamma_method()
-867 ax1.axhline(y=plateau.value, linewidth=2, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--', label=str(plateau))
-868 ax1.axhspan(plateau.value - plateau.dvalue, plateau.value + plateau.dvalue, alpha=0.25, color=plt.rcParams['text.color'], ls='-')
-869 else:
-870 raise Exception("'plateau' must be an Obs")
-871
-872 if references:
-873 if isinstance(references, list):
-874 for ref in references:
-875 ax1.axhline(y=ref, linewidth=1, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--')
-876 else:
-877 raise Exception("'references' must be a list of floating pint values.")
-878
-879 if self.prange:
-880 ax1.axvline(self.prange[0], 0, 1, ls='-', marker=',')
-881 ax1.axvline(self.prange[1], 0, 1, ls='-', marker=',')
-882
-883 if fit_res:
-884 x_samples = np.arange(x_range[0], x_range[1] + 1, 0.05)
-885 ax1.plot(x_samples,
-886 fit_res.fit_function([o.value for o in fit_res.fit_parameters], x_samples),
-887 ls='-', marker=',', lw=2)
-888
-889 ax1.set_xlabel(r'$x_0 / a$')
-890 if ylabel:
-891 ax1.set_ylabel(ylabel)
-892 ax1.set_xlim([x_range[0] - 0.5, x_range[1] + 0.5])
-893
-894 handles, labels = ax1.get_legend_handles_labels()
-895 if labels:
-896 ax1.legend()
-897
-898 if title:
-899 plt.title(title)
-900
-901 plt.draw()
+ 792 def show(self, x_range=None, comp=None, y_range=None, logscale=False, plateau=None, fit_res=None, ylabel=None, save=None, auto_gamma=False, hide_sigma=None, references=None, title=None):
+793 """Plots the correlator using the tag of the correlator as label if available.
+794
+795 Parameters
+796 ----------
+797 x_range : list
+798 list of two values, determining the range of the x-axis e.g. [4, 8].
+799 comp : Corr or list of Corr
+800 Correlator or list of correlators which are plotted for comparison.
+801 The tags of these correlators are used as labels if available.
+802 logscale : bool
+803 Sets y-axis to logscale.
+804 plateau : Obs
+805 Plateau value to be visualized in the figure.
+806 fit_res : Fit_result
+807 Fit_result object to be visualized.
+808 ylabel : str
+809 Label for the y-axis.
+810 save : str
+811 path to file in which the figure should be saved.
+812 auto_gamma : bool
+813 Apply the gamma method with standard parameters to all correlators and plateau values before plotting.
+814 hide_sigma : float
+815 Hides data points from the first value on which is consistent with zero within 'hide_sigma' standard errors.
+816 references : list
+817 List of floating point values that are displayed as horizontal lines for reference.
+818 title : string
+819 Optional title of the figure.
+820 """
+821 if self.N != 1:
+822 raise Exception("Correlator must be projected before plotting")
+823
+824 if auto_gamma:
+825 self.gamma_method()
+826
+827 if x_range is None:
+828 x_range = [0, self.T - 1]
+829
+830 fig = plt.figure()
+831 ax1 = fig.add_subplot(111)
+832
+833 x, y, y_err = self.plottable()
+834 if hide_sigma:
+835 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
+836 else:
+837 hide_from = None
+838 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=self.tag)
+839 if logscale:
+840 ax1.set_yscale('log')
+841 else:
+842 if y_range is None:
+843 try:
+844 y_min = min([(x[0].value - x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
+845 y_max = max([(x[0].value + x[0].dvalue) for x in self.content[x_range[0]: x_range[1] + 1] if (x is not None) and x[0].dvalue < 2 * np.abs(x[0].value)])
+846 ax1.set_ylim([y_min - 0.1 * (y_max - y_min), y_max + 0.1 * (y_max - y_min)])
+847 except Exception:
+848 pass
+849 else:
+850 ax1.set_ylim(y_range)
+851 if comp:
+852 if isinstance(comp, (Corr, list)):
+853 for corr in comp if isinstance(comp, list) else [comp]:
+854 if auto_gamma:
+855 corr.gamma_method()
+856 x, y, y_err = corr.plottable()
+857 if hide_sigma:
+858 hide_from = np.argmax((hide_sigma * np.array(y_err[1:])) > np.abs(y[1:])) - 1
+859 else:
+860 hide_from = None
+861 ax1.errorbar(x[:hide_from], y[:hide_from], y_err[:hide_from], label=corr.tag, mfc=plt.rcParams['axes.facecolor'])
+862 else:
+863 raise Exception("'comp' must be a correlator or a list of correlators.")
+864
+865 if plateau:
+866 if isinstance(plateau, Obs):
+867 if auto_gamma:
+868 plateau.gamma_method()
+869 ax1.axhline(y=plateau.value, linewidth=2, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--', label=str(plateau))
+870 ax1.axhspan(plateau.value - plateau.dvalue, plateau.value + plateau.dvalue, alpha=0.25, color=plt.rcParams['text.color'], ls='-')
+871 else:
+872 raise Exception("'plateau' must be an Obs")
+873
+874 if references:
+875 if isinstance(references, list):
+876 for ref in references:
+877 ax1.axhline(y=ref, linewidth=1, color=plt.rcParams['text.color'], alpha=0.6, marker=',', ls='--')
+878 else:
+879 raise Exception("'references' must be a list of floating pint values.")
+880
+881 if self.prange:
+882 ax1.axvline(self.prange[0], 0, 1, ls='-', marker=',')
+883 ax1.axvline(self.prange[1], 0, 1, ls='-', marker=',')
+884
+885 if fit_res:
+886 x_samples = np.arange(x_range[0], x_range[1] + 1, 0.05)
+887 ax1.plot(x_samples,
+888 fit_res.fit_function([o.value for o in fit_res.fit_parameters], x_samples),
+889 ls='-', marker=',', lw=2)
+890
+891 ax1.set_xlabel(r'$x_0 / a$')
+892 if ylabel:
+893 ax1.set_ylabel(ylabel)
+894 ax1.set_xlim([x_range[0] - 0.5, x_range[1] + 0.5])
+895
+896 handles, labels = ax1.get_legend_handles_labels()
+897 if labels:
+898 ax1.legend()
+899
+900 if title:
+901 plt.title(title)
902
-903 if save:
-904 if isinstance(save, str):
-905 fig.savefig(save, bbox_inches='tight')
-906 else:
-907 raise Exception("'save' has to be a string.")
+903 plt.draw()
+904
+905 if save:
+906 if isinstance(save, str):
+907 fig.savefig(save, bbox_inches='tight')
+908 else:
+909 raise Exception("'save' has to be a string.")
909 def spaghetti_plot(self, logscale=True):
-910 """Produces a spaghetti plot of the correlator suited to monitor exceptional configurations.
-911
-912 Parameters
-913 ----------
-914 logscale : bool
-915 Determines whether the scale of the y-axis is logarithmic or standard.
-916 """
-917 if self.N != 1:
-918 raise Exception("Correlator needs to be projected first.")
-919
-920 mc_names = list(set([item for sublist in [sum(map(o[0].e_content.get, o[0].mc_names), []) for o in self.content if o is not None] for item in sublist]))
-921 x0_vals = [n for (n, o) in zip(np.arange(self.T), self.content) if o is not None]
-922
-923 for name in mc_names:
-924 data = np.array([o[0].deltas[name] + o[0].r_values[name] for o in self.content if o is not None]).T
-925
-926 fig = plt.figure()
-927 ax = fig.add_subplot(111)
-928 for dat in data:
-929 ax.plot(x0_vals, dat, ls='-', marker='')
-930
-931 if logscale is True:
-932 ax.set_yscale('log')
-933
-934 ax.set_xlabel(r'$x_0 / a$')
-935 plt.title(name)
-936 plt.draw()
+ 911 def spaghetti_plot(self, logscale=True):
+912 """Produces a spaghetti plot of the correlator suited to monitor exceptional configurations.
+913
+914 Parameters
+915 ----------
+916 logscale : bool
+917 Determines whether the scale of the y-axis is logarithmic or standard.
+918 """
+919 if self.N != 1:
+920 raise Exception("Correlator needs to be projected first.")
+921
+922 mc_names = list(set([item for sublist in [sum(map(o[0].e_content.get, o[0].mc_names), []) for o in self.content if o is not None] for item in sublist]))
+923 x0_vals = [n for (n, o) in zip(np.arange(self.T), self.content) if o is not None]
+924
+925 for name in mc_names:
+926 data = np.array([o[0].deltas[name] + o[0].r_values[name] for o in self.content if o is not None]).T
+927
+928 fig = plt.figure()
+929 ax = fig.add_subplot(111)
+930 for dat in data:
+931 ax.plot(x0_vals, dat, ls='-', marker='')
+932
+933 if logscale is True:
+934 ax.set_yscale('log')
+935
+936 ax.set_xlabel(r'$x_0 / a$')
+937 plt.title(name)
+938 plt.draw()
938 def dump(self, filename, datatype="json.gz", **kwargs):
-939 """Dumps the Corr into a file of chosen type
-940 Parameters
-941 ----------
-942 filename : str
-943 Name of the file to be saved.
-944 datatype : str
-945 Format of the exported file. Supported formats include
-946 "json.gz" and "pickle"
-947 path : str
-948 specifies a custom path for the file (default '.')
-949 """
-950 if datatype == "json.gz":
-951 from .input.json import dump_to_json
-952 if 'path' in kwargs:
-953 file_name = kwargs.get('path') + '/' + filename
-954 else:
-955 file_name = filename
-956 dump_to_json(self, file_name)
-957 elif datatype == "pickle":
-958 dump_object(self, filename, **kwargs)
-959 else:
-960 raise Exception("Unknown datatype " + str(datatype))
+ 940 def dump(self, filename, datatype="json.gz", **kwargs):
+941 """Dumps the Corr into a file of chosen type
+942 Parameters
+943 ----------
+944 filename : str
+945 Name of the file to be saved.
+946 datatype : str
+947 Format of the exported file. Supported formats include
+948 "json.gz" and "pickle"
+949 path : str
+950 specifies a custom path for the file (default '.')
+951 """
+952 if datatype == "json.gz":
+953 from .input.json import dump_to_json
+954 if 'path' in kwargs:
+955 file_name = kwargs.get('path') + '/' + filename
+956 else:
+957 file_name = filename
+958 dump_to_json(self, file_name)
+959 elif datatype == "pickle":
+960 dump_object(self, filename, **kwargs)
+961 else:
+962 raise Exception("Unknown datatype " + str(datatype))
962 def print(self, print_range=None):
-963 print(self.__repr__(print_range))
+ 964 def print(self, print_range=None):
+965 print(self.__repr__(print_range))
1129 def sqrt(self):
-1130 return self ** 0.5
+ 1131 def sqrt(self):
+1132 return self ** 0.5
1132 def log(self):
-1133 newcontent = [None if _check_for_none(self, item) else np.log(item) for item in self.content]
-1134 return Corr(newcontent, prange=self.prange)
+ 1134 def log(self):
+1135 newcontent = [None if _check_for_none(self, item) else np.log(item) for item in self.content]
+1136 return Corr(newcontent, prange=self.prange)
1136 def exp(self):
-1137 newcontent = [None if _check_for_none(self, item) else np.exp(item) for item in self.content]
-1138 return Corr(newcontent, prange=self.prange)
+ 1138 def exp(self):
+1139 newcontent = [None if _check_for_none(self, item) else np.exp(item) for item in self.content]
+1140 return Corr(newcontent, prange=self.prange)
1153 def sin(self):
-1154 return self._apply_func_to_corr(np.sin)
+ 1155 def sin(self):
+1156 return self._apply_func_to_corr(np.sin)
1156 def cos(self):
-1157 return self._apply_func_to_corr(np.cos)
+ 1158 def cos(self):
+1159 return self._apply_func_to_corr(np.cos)
1159 def tan(self):
-1160 return self._apply_func_to_corr(np.tan)
+ 1161 def tan(self):
+1162 return self._apply_func_to_corr(np.tan)
1162 def sinh(self):
-1163 return self._apply_func_to_corr(np.sinh)
+ 1164 def sinh(self):
+1165 return self._apply_func_to_corr(np.sinh)
1165 def cosh(self):
-1166 return self._apply_func_to_corr(np.cosh)
+ 1167 def cosh(self):
+1168 return self._apply_func_to_corr(np.cosh)
1168 def tanh(self):
-1169 return self._apply_func_to_corr(np.tanh)
+ 1170 def tanh(self):
+1171 return self._apply_func_to_corr(np.tanh)
1171 def arcsin(self):
-1172 return self._apply_func_to_corr(np.arcsin)
+ 1173 def arcsin(self):
+1174 return self._apply_func_to_corr(np.arcsin)
1174 def arccos(self):
-1175 return self._apply_func_to_corr(np.arccos)
+ 1176 def arccos(self):
+1177 return self._apply_func_to_corr(np.arccos)
1177 def arctan(self):
-1178 return self._apply_func_to_corr(np.arctan)
+ 1179 def arctan(self):
+1180 return self._apply_func_to_corr(np.arctan)
1180 def arcsinh(self):
-1181 return self._apply_func_to_corr(np.arcsinh)
+ 1182 def arcsinh(self):
+1183 return self._apply_func_to_corr(np.arcsinh)
1183 def arccosh(self):
-1184 return self._apply_func_to_corr(np.arccosh)
+ 1185 def arccosh(self):
+1186 return self._apply_func_to_corr(np.arccosh)
1186 def arctanh(self):
-1187 return self._apply_func_to_corr(np.arctanh)
+ 1188 def arctanh(self):
+1189 return self._apply_func_to_corr(np.arctanh)
1222 def prune(self, Ntrunc, tproj=3, t0proj=2, basematrix=None):
-1223 r''' Project large correlation matrix to lowest states
-1224
-1225 This method can be used to reduce the size of an (N x N) correlation matrix
-1226 to (Ntrunc x Ntrunc) by solving a GEVP at very early times where the noise
-1227 is still small.
-1228
-1229 Parameters
-1230 ----------
-1231 Ntrunc: int
-1232 Rank of the target matrix.
-1233 tproj: int
-1234 Time where the eigenvectors are evaluated, corresponds to ts in the GEVP method.
-1235 The default value is 3.
-1236 t0proj: int
-1237 Time where the correlation matrix is inverted. Choosing t0proj=1 is strongly
-1238 discouraged for O(a) improved theories, since the correctness of the procedure
-1239 cannot be granted in this case. The default value is 2.
-1240 basematrix : Corr
-1241 Correlation matrix that is used to determine the eigenvectors of the
-1242 lowest states based on a GEVP. basematrix is taken to be the Corr itself if
-1243 is is not specified.
-1244
-1245 Notes
-1246 -----
-1247 We have the basematrix $C(t)$ and the target matrix $G(t)$. We start by solving
-1248 the GEVP $$C(t) v_n(t, t_0) = \lambda_n(t, t_0) C(t_0) v_n(t, t_0)$$ where $t \equiv t_\mathrm{proj}$
-1249 and $t_0 \equiv t_{0, \mathrm{proj}}$. The target matrix is projected onto the subspace of the
-1250 resulting eigenvectors $v_n, n=1,\dots,N_\mathrm{trunc}$ via
-1251 $$G^\prime_{i, j}(t) = (v_i, G(t) v_j)$$. This allows to reduce the size of a large
-1252 correlation matrix and to remove some noise that is added by irrelevant operators.
-1253 This may allow to use the GEVP on $G(t)$ at late times such that the theoretically motivated
-1254 bound $t_0 \leq t/2$ holds, since the condition number of $G(t)$ is decreased, compared to $C(t)$.
-1255 '''
-1256
-1257 if self.N == 1:
-1258 raise Exception('Method cannot be applied to one-dimensional correlators.')
-1259 if basematrix is None:
-1260 basematrix = self
-1261 if Ntrunc >= basematrix.N:
-1262 raise Exception('Cannot truncate using Ntrunc <= %d' % (basematrix.N))
-1263 if basematrix.N != self.N:
-1264 raise Exception('basematrix and targetmatrix have to be of the same size.')
-1265
-1266 evecs = basematrix.GEVP(t0proj, tproj, sort=None)[:Ntrunc]
+ 1224 def prune(self, Ntrunc, tproj=3, t0proj=2, basematrix=None):
+1225 r''' Project large correlation matrix to lowest states
+1226
+1227 This method can be used to reduce the size of an (N x N) correlation matrix
+1228 to (Ntrunc x Ntrunc) by solving a GEVP at very early times where the noise
+1229 is still small.
+1230
+1231 Parameters
+1232 ----------
+1233 Ntrunc: int
+1234 Rank of the target matrix.
+1235 tproj: int
+1236 Time where the eigenvectors are evaluated, corresponds to ts in the GEVP method.
+1237 The default value is 3.
+1238 t0proj: int
+1239 Time where the correlation matrix is inverted. Choosing t0proj=1 is strongly
+1240 discouraged for O(a) improved theories, since the correctness of the procedure
+1241 cannot be granted in this case. The default value is 2.
+1242 basematrix : Corr
+1243 Correlation matrix that is used to determine the eigenvectors of the
+1244 lowest states based on a GEVP. basematrix is taken to be the Corr itself if
+1245 is is not specified.
+1246
+1247 Notes
+1248 -----
+1249 We have the basematrix $C(t)$ and the target matrix $G(t)$. We start by solving
+1250 the GEVP $$C(t) v_n(t, t_0) = \lambda_n(t, t_0) C(t_0) v_n(t, t_0)$$ where $t \equiv t_\mathrm{proj}$
+1251 and $t_0 \equiv t_{0, \mathrm{proj}}$. The target matrix is projected onto the subspace of the
+1252 resulting eigenvectors $v_n, n=1,\dots,N_\mathrm{trunc}$ via
+1253 $$G^\prime_{i, j}(t) = (v_i, G(t) v_j)$$. This allows to reduce the size of a large
+1254 correlation matrix and to remove some noise that is added by irrelevant operators.
+1255 This may allow to use the GEVP on $G(t)$ at late times such that the theoretically motivated
+1256 bound $t_0 \leq t/2$ holds, since the condition number of $G(t)$ is decreased, compared to $C(t)$.
+1257 '''
+1258
+1259 if self.N == 1:
+1260 raise Exception('Method cannot be applied to one-dimensional correlators.')
+1261 if basematrix is None:
+1262 basematrix = self
+1263 if Ntrunc >= basematrix.N:
+1264 raise Exception('Cannot truncate using Ntrunc <= %d' % (basematrix.N))
+1265 if basematrix.N != self.N:
+1266 raise Exception('basematrix and targetmatrix have to be of the same size.')
1267
-1268 tmpmat = np.empty((Ntrunc, Ntrunc), dtype=object)
-1269 rmat = []
-1270 for t in range(basematrix.T):
-1271 for i in range(Ntrunc):
-1272 for j in range(Ntrunc):
-1273 tmpmat[i][j] = evecs[i].T @ self[t] @ evecs[j]
-1274 rmat.append(np.copy(tmpmat))
-1275
-1276 newcontent = [None if (self.content[t] is None) else rmat[t] for t in range(self.T)]
-1277 return Corr(newcontent)
+1268 evecs = basematrix.GEVP(t0proj, tproj, sort=None)[:Ntrunc]
+1269
+1270 tmpmat = np.empty((Ntrunc, Ntrunc), dtype=object)
+1271 rmat = []
+1272 for t in range(basematrix.T):
+1273 for i in range(Ntrunc):
+1274 for j in range(Ntrunc):
+1275 tmpmat[i][j] = evecs[i].T @ self[t] @ evecs[j]
+1276 rmat.append(np.copy(tmpmat))
+1277
+1278 newcontent = [None if (self.content[t] is None) else rmat[t] for t in range(self.T)]
+1279 return Corr(newcontent)