PEP8 work, revert some overly strict PEP8

nifty4/__init__.py

@@ -55,11 +55,11 @@ from .sugar import *
 from .plotting.plot import plot
 from . import library
 
-__all__= ["DomainObject", "FieldArray", "Space", "RGSpace", "LMSpace",
-          "HPSpace", "GLSpace", "DOFSpace", "PowerSpace", "DomainTuple",
-          "LinearOperator", "EndomorphicOperator", "ScalingOperator",
-          "DiagonalOperator", "FFTOperator", "FFTSmoothingOperator",
-          "DirectSmoothingOperator", "ResponseOperator", "LaplaceOperator",
-          "PowerProjectionOperator", "InversionEnabler",
-          "Field", "sqrt", "exp", "log",
-          "Prober", "DiagonalProberMixin", "TraceProberMixin"]
+__all__ = ["DomainObject", "FieldArray", "Space", "RGSpace", "LMSpace",
+           "HPSpace", "GLSpace", "DOFSpace", "PowerSpace", "DomainTuple",
+           "LinearOperator", "EndomorphicOperator", "ScalingOperator",
+           "DiagonalOperator", "FFTOperator", "FFTSmoothingOperator",
+           "DirectSmoothingOperator", "ResponseOperator", "LaplaceOperator",
+           "PowerProjectionOperator", "InversionEnabler",
+           "Field", "sqrt", "exp", "log",
+           "Prober", "DiagonalProberMixin", "TraceProberMixin"]

nifty4/library/critical_power_curvature.py

@@ -22,4 +22,4 @@ from ..operators.diagonal_operator import DiagonalOperator
 
 def CriticalPowerCurvature(theta, T, inverter):
     theta = DiagonalOperator(theta)
-    return InversionEnabler(T + theta, inverter, theta.inverse_times)
+    return InversionEnabler(T+theta, inverter, theta.inverse_times)

nifty4/library/critical_power_energy.py

@@ -94,21 +94,21 @@ class CriticalPowerEnergy(Energy):
                     sample = self.D.generate_posterior_sample() + self.m
                     w += P(abs(sample)**2)
 
-                w *= 1. / self.samples
+                w *= 1./self.samples
             else:
                 w = P(abs(self.m)**2)
         self._w = w
 
-        self._theta = exp(-self.position) * (self.q + self._w * 0.5)
+        self._theta = exp(-self.position) * (self.q + self._w*0.5)
         Tt = self.T(self.position)
 
         energy = self._theta.sum()
-        energy += self.position.sum() * (self.alpha - 0.5)
-        energy += 0.5 * self.position.vdot(Tt)
+        energy += self.position.sum() * (self.alpha-0.5)
+        energy += 0.5*self.position.vdot(Tt)
         self._value = energy.real
 
         gradient = -self._theta
-        gradient += self.alpha - 0.5
+        gradient += self.alpha-0.5
         gradient += Tt
         self._gradient = gradient
 

nifty4/library/log_normal_wiener_filter_curvature.py

@@ -20,7 +20,6 @@ from ..operators.inversion_enabler import InversionEnabler
 
 
 def LogNormalWienerFilterCurvature(R, N, S, ht, expp_sspace, inverter):
-    part1 = S.inverse
     LinResp = R * ht.adjoint * expp_sspace * ht
-    part3 = (LinResp.adjoint * N.inverse * LinResp)
-    return InversionEnabler(part1 + part3, inverter)
+    t_op = LinResp.adjoint * N.inverse * LinResp
+    return InversionEnabler(S.inverse + t_op, inverter)

nifty4/library/log_normal_wiener_filter_energy.py

@@ -19,7 +19,7 @@
 from ..minimization.energy import Energy
 from ..utilities import memo
 from .log_normal_wiener_filter_curvature import LogNormalWienerFilterCurvature
-from ..sugar import create_composed_fft_operator
+from ..sugar import create_composed_ht_operator
 from ..field import exp
 
 
@@ -52,8 +52,7 @@ class LogNormalWienerFilterEnergy(Energy):
         self._inverter = inverter
 
         if ht is None:
-            self._ht = create_composed_fft_operator(self.S.domain,
-                                                    all_to='position')
+            self._ht = create_composed_ht_operator(self.S.domain)
         else:
             self._ht = ht
 
@@ -63,7 +62,7 @@ class LogNormalWienerFilterEnergy(Energy):
         expp = self._ht.adjoint_times(self._expp_sspace)
         Rexppd = self.R(expp) - self.d
         NRexppd = self.N.inverse_times(Rexppd)
-        self._value = 0.5 * (self.position.vdot(Sp) + Rexppd.vdot(NRexppd))
+        self._value = 0.5*(self.position.vdot(Sp) + Rexppd.vdot(NRexppd))
         exppRNRexppd = self._ht.adjoint_times(
             self._expp_sspace * self._ht(self.R.adjoint_times(NRexppd)))
         self._gradient = Sp + exppRNRexppd

nifty4/library/noise_energy.py

@@ -51,7 +51,7 @@ class NoiseEnergy(Energy):
         self.xi_sample_list = xi_sample_list
         self.inverter = inverter
 
-        A = Projection.adjoint_times(exp(.5 * self.t))
+        A = Projection.adjoint_times(exp(.5*self.t))
 
         self._gradient = None
         for sample in self.xi_sample_list:
@@ -60,7 +60,7 @@ class NoiseEnergy(Energy):
             residual = self.d - \
                 self.Instrument(self.nonlinearity(map_s))
             lh = .5 * residual.vdot(self.N.inverse_times(residual))
-            grad = -.5 * self.N.inverse_times(residual.conjugate() * residual)
+            grad = -.5 * self.N.inverse_times(residual.conjugate()*residual)
 
             if self._gradient is None:
                 self._value = lh
@@ -75,7 +75,7 @@ class NoiseEnergy(Energy):
             self.q.vdot(exp(-self.position))
 
         self._gradient *= 1. / len(self.xi_sample_list)
-        self._gradient += (self.alpha - 0.5) - self.q * (exp(-self.position))
+        self._gradient += (self.alpha-0.5) - self.q*(exp(-self.position))
 
     def at(self, position):
         return self.__class__(

nifty4/library/nonlinear_power_curvature.py

@@ -26,7 +26,7 @@ def NonlinearPowerCurvature(tau, ht, Instrument, nonlinearity, Projection, N,
     for xi_sample in xi_sample_list:
         LinearizedResponse = LinearizedPowerResponse(
             Instrument, nonlinearity, ht, Projection, tau, xi_sample)
-        op = LinearizedResponse.adjoint * N.inverse * LinearizedResponse
+        op = LinearizedResponse.adjoint*N.inverse*LinearizedResponse
         result = op if result is None else result + op
-    result = result * (1. / len(xi_sample_list)) + T
+    result = result * (1./len(xi_sample_list)) + T
     return InversionEnabler(result, inverter)

nifty4/library/response_operators.py

@@ -20,11 +20,11 @@ from ..field import exp
 
 
 def LinearizedSignalResponse(Instrument, nonlinearity, ht, power, m):
-    return (Instrument * nonlinearity.derivative(m) * ht * power)
+    return Instrument * nonlinearity.derivative(m) * ht * power
 
 
 def LinearizedPowerResponse(Instrument, nonlinearity, ht, Projection, tau, xi):
-    power = exp(0.5 * tau)
-    position = ht(Projection.adjoint_times(power) * xi)
+    power = exp(0.5*tau)
+    position = ht(Projection.adjoint_times(power)*xi)
     linearization = nonlinearity.derivative(position)
-    return (0.5 * Instrument * linearization * ht * xi * Projection.adjoint * power)
+    return 0.5*Instrument*linearization*ht*xi*Projection.adjoint*power

nifty4/library/wiener_filter_curvature.py

@@ -45,7 +45,7 @@ class WienerFilterCurvature(EndomorphicOperator):
         self.R = R
         self.N = N
         self.S = S
-        op = R.adjoint * N.inverse * R + S.inverse
+        op = R.adjoint*N.inverse*R + S.inverse
         self._op = InversionEnabler(op, inverter, S.times)
 
     @property
@@ -91,10 +91,9 @@ class WienerFilterCurvature(EndomorphicOperator):
 
     def generate_posterior_sample2(self):
         power = self.S.diagonal()
-        mock_signal = Field.from_random(
-            random_type="normal",
-            domain=self.S.domain,
-            dtype=power.dtype)
+        mock_signal = Field.from_random(random_type="normal",
+                                        domain=self.S.domain,
+                                        dtype=power.dtype)
         mock_signal *= sqrt(power)
 
         noise = self.N.diagonal()

nifty4/library/wiener_filter_energy.py

@@ -52,8 +52,7 @@ class WienerFilterEnergy(Energy):
             _j = self.R.adjoint_times(self.N.inverse_times(d))
         self._j = _j
         Dx = self._curvature(self.position)
-        self._value = 0.5 * \
-            self.position.vdot(Dx) - self._j.vdot(self.position)
+        self._value = 0.5*self.position.vdot(Dx) - self._j.vdot(self.position)
         self._gradient = Dx - self._j
 
     def at(self, position):

nifty4/operators/scaling_operator.py

@@ -69,7 +69,7 @@ class ScalingOperator(EndomorphicOperator):
 
     @property
     def inverse(self):
-        if self._factor!= 0.:
+        if self._factor != 0.:
             return ScalingOperator(1./self._factor, self._domain)
         from .inverse_operator import InverseOperator
         return InverseOperator(self)
@@ -84,7 +84,7 @@ class ScalingOperator(EndomorphicOperator):
 
     @property
     def capability(self):
-        if self._factor==0.:
+        if self._factor == 0.:
             return self.TIMES | self.ADJOINT_TIMES
         return (self.TIMES | self.ADJOINT_TIMES |
                 self.INVERSE_TIMES | self.ADJOINT_INVERSE_TIMES)

nifty4/plotting/plot.py

@@ -189,13 +189,13 @@ def plot(f, **kwargs):
             if fld.domain != dom:
                 raise ValueError("domain mismatch")
             if not (isinstance(dom[0], PowerSpace) or
-                    (isinstance(dom[0], RGSpace) and len(dom[0].shape)==1)):
+                    (isinstance(dom[0], RGSpace) and len(dom[0].shape) == 1)):
                 raise ValueError("PowerSpace or 1D RGSpace required")
 
     label = _get_kw("label", None, **kwargs)
     if label is None:
         label = [None] * len(f)
-    if not isinstance (label, list):
+    if not isinstance(label, list):
         label = [label]
 
     dom = dom[0]
@@ -216,7 +216,7 @@ def plot(f, **kwargs):
             xcoord = np.arange(npoints, dtype=np.float64)*dist
             for i, fld in enumerate(f):
                 ycoord = dobj.to_global_data(fld.val)
-                plt.plot(xcoord, ycoord,label=label[i])
+                plt.plot(xcoord, ycoord, label=label[i])
             _limit_xy(**kwargs)
             if label != ([None]*len(f)):
                 plt.legend()

nifty4/sugar.py

@@ -23,6 +23,7 @@ from .field import Field, sqrt
 from .operators.diagonal_operator import DiagonalOperator
 from .operators.power_projection_operator import PowerProjectionOperator
 from .operators.fft_operator import FFTOperator
+from .operators.harmonic_transform_operator import HarmonicTransformOperator
 from .domain_tuple import DomainTuple
 from . import dobj, utilities
 
@@ -32,6 +33,7 @@ __all__ = ['PS_field',
            'power_synthesize_nonrandom',
            'create_power_field',
            'create_power_operator',
+           'create_composed_ht_operator',
            'create_composed_fft_operator',
            'create_harmonic_smoothing_operator']
 
@@ -241,6 +243,20 @@ def create_power_operator(domain, power_spectrum, space=None, dtype=None):
         spaces=space)
 
 
+def create_composed_ht_operator(domain, codomain=None):
+    if codomain is None:
+        codomain = [None]*len(domain)
+    res = None
+    for i, space in enumerate(domain):
+        if isinstance(space, Space) and space.harmonic:
+            tdom = domain if res is None else res.target
+            op = HarmonicTransformOperator(tdom, codomain[i], i)
+            res = op if res is None else op*res
+    if res is None:
+        raise ValueError("empty operator")
+    return res
+
+
 def create_composed_fft_operator(domain, codomain=None, all_to='other'):
     if codomain is None:
         codomain = [None]*len(domain)

test/test_energies/test_map.py

@@ -147,7 +147,8 @@ class Energy_Tests(unittest.TestCase):
 
         S = ift.create_power_operator(hspace, power_spectrum=_flat_PS)
         energy0 = ift.library.NonlinearWienerFilterEnergy(
-            position=xi0, d=d, Instrument=R, nonlinearity=f, ht=ht, power=A, N=N, S=S)
+            position=xi0, d=d, Instrument=R, nonlinearity=f, ht=ht, power=A,
+            N=N, S=S)
         energy1 = energy0.at(xi1)
 
         a = (energy1.value - energy0.value) / eps
@@ -204,7 +205,8 @@ class Curvature_Tests(unittest.TestCase):
 
     @expand(product([ift.RGSpace(64, distances=.789),
                      ift.RGSpace([32, 32], distances=.789)],
-                    # Only linear case due to approximation of Hessian in the case of nontrivial nonlinearities.
+                    # Only linear case due to approximation of Hessian in the
+                    # case of nontrivial nonlinearities.
                     [ift.library.Linear],
                     [4, 78, 23]))
     def testNonlinearMapCurvature(self, space, nonlinearity, seed):

test/test_energies/test_power.py

@@ -70,7 +70,8 @@ class Energy_Tests(unittest.TestCase):
                                            inverter=inverter).curvature
 
         energy0 = ift.library.CriticalPowerEnergy(
-            position=tau0, m=s, inverter=inverter, D=D, samples=10, smoothness_prior=1.)
+            position=tau0, m=s, inverter=inverter, D=D, samples=10,
+            smoothness_prior=1.)
         energy1 = energy0.at(tau1)
 
         a = (energy1.value - energy0.value) / eps

test/test_minimization/test_minimizers.py

@@ -41,7 +41,8 @@ class Test_Minimizers(unittest.TestCase):
         covariance = ift.DiagonalOperator(covariance_diagonal)
         required_result = ift.Field.ones(space, dtype=np.float64)
 
-        IC = ift.GradientNormController(tol_abs_gradnorm=1e-5, iteration_limit=1000)
+        IC = ift.GradientNormController(tol_abs_gradnorm=1e-5,
+                                        iteration_limit=1000)
         try:
             minimizer = minimizer_class(controller=IC)
             energy = ift.QuadraticEnergy(A=covariance, b=required_result,
@@ -57,4 +58,4 @@ class Test_Minimizers(unittest.TestCase):
                         rtol=1e-3, atol=1e-3)
 
 
-#MR FIXME: add Rosenbrock test
+# MR FIXME: add Rosenbrock test

test/test_operators/test_adjoint.py

@@ -39,6 +39,7 @@ def _check_adjointness(op, dtype=np.float64):
                         op.inverse_adjoint_times(f1).vdot(f2),
                         rtol=1e-8)
 
+
 _h_RG_spaces = [ift.RGSpace(7, distances=0.2, harmonic=True),
                 ift.RGSpace((12, 46), distances=(.2, .3), harmonic=True)]
 _h_spaces = _h_RG_spaces + [ift.LMSpace(17)]

test/test_operators/test_fft_operator.py

@@ -83,7 +83,6 @@ class FFTOperatorTests(unittest.TestCase):
         assert_allclose(ift.dobj.to_global_data(inp.val),
                         ift.dobj.to_global_data(out.val), rtol=tol, atol=tol)
 
-
     @expand(product([0, 1, 2],
                     [np.float64, np.float32, np.complex64, np.complex128]))
     def test_composed_fft(self, index, dtype):
@@ -98,9 +97,8 @@ class FFTOperatorTests(unittest.TestCase):
         assert_allclose(ift.dobj.to_global_data(inp.val),
                         ift.dobj.to_global_data(out.val), rtol=tol, atol=tol)
 
-
     @expand(product([ift.RGSpace(128, distances=3.76, harmonic=True),
-                     ift.RGSpace((15,27), distances=(1.7,3.33), harmonic=True),
+                     ift.RGSpace((15, 27), distances=(.7, .33), harmonic=True),
                      ift.RGSpace(73, distances=0.5643)],
                     [np.float64, np.float32, np.complex64, np.complex128]))
     def test_normalisation(self, space, tp):