style + cleanup

Author: mbruno46

pyobs/core/__init__.py

@@ -25,12 +25,10 @@
 from .gradient import gradient
 from .transform import transform
 from . import mftools
-from .complex import complex_observable
 
 __all__ = ["observable"]
 __all__.extend(["derobs", "num_grad", "error_bias4"])
 __all__.extend(["errinfo"])
 __all__.extend(["mftools"])
 __all__.extend(["gradient"])
 __all__.extend(["transform"])
-__all__.extend(["complex_observable"])

pyobs/core/complex.py

@@ -197,7 +197,7 @@ def axpy(self, grad, d):
 
         # takes into accounts holes present in d.delta but absent in self.delta
         rescale_delta = self.n / d.n
-        
+
         if (np.iscomplexobj(grad.grad)) or (np.iscomplexobj(d.delta)):
             self.delta = self.delta.astype(pyobs.complex)
         grad.apply(self.delta, self.mask, jlist, d.delta * rescale_delta, d.mask)
@@ -223,14 +223,12 @@ def gamma(self, xmax, a, b=None):
             self.delta, self.idx, self.ncnfg() if isMC else self.lat, xmax, a, b
         )
         return [m, g]
-        
+
     def bias4(self, hess):
         oid = np.array(self.mask)
         idx = np.ix_(oid, oid)
         # no rescaling factor; prone to roundoff errors
-        d2 = np.einsum(
-            "abc,bj,cj->aj", hess[:, idx[0], idx[1]], self.delta, self.delta
-        )
+        d2 = np.einsum("abc,bj,cj->aj", hess[:, idx[0], idx[1]], self.delta, self.delta)
         return np.sum(d2, axis=1)
 
     def blocked(self, bs):

pyobs/core/data.py

@@ -49,7 +49,6 @@ def __init__(self, n, g, Stau, D, k, fold=False):
         idx = numpy.arange(len(mask))[mask]
         self.x = [i for i in (idx if fold else numpy.sqrt(idx))]
 
-        ###gg = pyobs.double_array((self.size, len(self.x)), zeros=True)
         gg = g[:, idx] / n[:, idx]
 
         if fold:
@@ -83,13 +82,12 @@ def find_opt(self):
                 for i in range(1, len(self.x)):
                     if self.g(i, a) > 0:
                         break
-                while (self.cvar[a, i] < self.cvar[a, 0]):
+                while self.cvar[a, i] < self.cvar[a, 0]:
                     i -= 1
             if self.cvar[a, i] < 0:
                 i = 0
                 print(f"Warning: automatic window failed for obs {a}, using {i}")
-            
-            
+
             self.xopt[a] = self.x[i]
             self.var[a, 0] = self.cvar[a, i]
             self.var[a, 1] = self.cvar[a, i] * self.stat_relerr(self.x[i], a)
@@ -98,7 +96,6 @@ def find_opt(self):
                 print(
                     f"Warning: automatic window failed for obs {a}, using {self.xopt[a]}"
                 )
-                
 
     def set_opt(self, xopt):
         for a in range(self.size):
@@ -252,10 +249,10 @@ def __init__(self, x, name, Stau, k):
             mask += x.delta[ik].mask
         self.mask = list(set(mask))
         self.size = len(self.mask)
-                
+
         n = pyobs.double_array((self.size, xmax), zeros=True)
         g = pyobs.double_array((self.size, xmax), zeros=True)
-        
+
         # with this code we cover the situation where 1 obs happens to be known on 1 replica
         # and another obs in another replica, which may have different dtrj
         for i in range(len(keys)):
@@ -338,6 +335,7 @@ def __init__(self, Stau=1.5, k=0, W=None, gamma_bias=True):
         self.W = W
         self.gamma_bias = gamma_bias
 
+
 def gamma_error(x, name, plot=False, pfile=None, einfo=None):
     if einfo is None:
         einfo = errinfo()

pyobs/core/error.py

@@ -38,7 +38,7 @@ def __init__(self, g, x0=None, gtype="full"):
         self.gtype = gtype
 
         _grad = g(numpy.ones(x0.shape)).flatten()
-        
+
         if gtype == "full":
             self.grad = pyobs.array((self.Na, self.Ni), _grad.dtype, zeros=True)
             dx = pyobs.double_array(self.Ni, zeros=True)
@@ -51,9 +51,9 @@ def __init__(self, g, x0=None, gtype="full"):
             pyobs.assertion(self.Na == self.Ni, "diagonal gradient error")
         else:  # pragma: no cover
             raise pyobs.PyobsError("gradient error")
-            
+
         del _grad
-        
+
     def get_mask(self, mask):
         idx = pyobs.int_array(mask)
         if self.gtype == "full":

pyobs/core/gradient.py

@@ -142,7 +142,7 @@ def create(self, ename, data, icnfg=None, rname=None, shape=(1,), lat=None):
             data = [np.array(data).astype(pyobs.complex)]
         else:
             pyobs.assertion(True, "Data type not supported")
-            
+
         R = len(data)
         nc = [len(data[ir]) // self.size for ir in range(R)]
         if rname is None:
@@ -175,7 +175,9 @@ def create(self, ename, data, icnfg=None, rname=None, shape=(1,), lat=None):
                     key not in self.delta.keys(), f"Replica name {key} already used"
                 )
             N0 = sum([self.delta[key].n for key in self.delta])
-            mean_old = np.copy(self.mean.flatten()) #np.reshape(self.mean, (self.size,))
+            mean_old = np.copy(
+                self.mean.flatten()
+            )  # np.reshape(self.mean, (self.size,))
             print(N0, mean_old, sum(nc), mean_data)
             self.mean = (N0 * mean_old + sum(nc) * mean_data) / (N0 + sum(nc))
             shift = sum(nc) * (mean_old - mean_data) / (N0 + sum(nc))
@@ -336,7 +338,7 @@ def peek(self, verbose=False):
                     outstr = f'    - {"Replica" if self.delta[key].lat is None else "Master-field"} {rn[1]}'
                     outstr = f'{outstr} with {f"ncnfg {self.delta[key].n}" if self.delta[key].lat is None else f"lattice {self.delta[key].lat}"}'
                     print(outstr)
-                    outstr = f'      index field {self.delta[key].idx}'
+                    outstr = f"      index field {self.delta[key].idx}"
                     print(outstr)
                     mm = (
                         self.delta[key].ncnfg() * 8.0 * 2.0
@@ -568,18 +570,18 @@ def __itruediv__(self, y):
         self = pyobs.observable(tmp)
         del tmp
         return self
-        
+
     def real(self):
-        return pyobs.observable(self, projector = lambda x: x.real)
-    
+        return pyobs.observable(self, projector=lambda x: x.real)
+
     def imag(self):
-        return pyobs.observable(self, projector = lambda x: x.imag)
-    
+        return pyobs.observable(self, projector=lambda x: x.imag)
+
     def conj(self):
         if np.iscomplexobj(self.mean):
             return self.real() - 1j * self.imag()
         return self
-        
+
     ##################################
     # Error functions
 
@@ -658,7 +660,7 @@ class provides additional details for the automatic or manual
             h = [len(self.ename), len(self.cdata)]
             if sum(h) > 1:
                 plot_piechart(self.description, sigma, sigma_tot.real)
-        
+
         return [self.mean, np.sqrt(sigma_tot)]
 
     def error_breakdown(self, errinfo={}):

pyobs/core/ndobs.py

@@ -34,25 +34,26 @@
 #             idx_b += [b.index(_a)]
 #     return idx_a, idx_b
 
-def indices_isin(a,b):
+
+def indices_isin(a, b):
     # idx_a = indices of elements of a that are present in b preserving the order a
-    idx_a = numpy.arange(len(a))[numpy.in1d(a,b)]
-    if idx_a.size==0:
+    idx_a = numpy.arange(len(a))[numpy.in1d(a, b)]
+    if idx_a.size == 0:
         return [], []
     # idx_b = indices of elements of b that are present in a preserving the order a
-    idx_b = numpy.arange(len(b))[numpy.in1d(b,a)]
-    mask = numpy.array(a)[idx_a,None] == numpy.array(b)[idx_b]
-    idx_b_2 = numpy.stack([idx_b]*len(idx_a))[mask]
+    idx_b = numpy.arange(len(b))[numpy.in1d(b, a)]
+    mask = numpy.array(a)[idx_a, None] == numpy.array(b)[idx_b]
+    idx_b_2 = numpy.stack([idx_b] * len(idx_a))[mask]
     return list(idx_a), list(idx_b_2)
-    
+
 
 def transform(obs, f):
     new_mean = f(obs.mean)
     res = pyobs.observable(description=obs.description)
     res.set_mean(new_mean)
 
     subset_mask = f(numpy.reshape(numpy.arange(obs.size), obs.shape)).flatten()
-    
+
     for key in obs.delta:
         d = obs.delta[key]
         idx_subset_mask, idx_mask = indices_isin(subset_mask, d.mask)