diff --git a/demos/nonlinear_critical_filter.py b/demos/nonlinear_critical_filter.py
index 4e8f0e825a678b1c71cd7126bf11b90e8f2b2fe5..afa14cd55477cf76435c66abd854b899a06886c9 100644
--- a/demos/nonlinear_critical_filter.py
+++ b/demos/nonlinear_critical_filter.py
@@ -1,6 +1,5 @@
 import nifty2go as ift
-from nifty2go.library import NonlinearWienerFilterEnergy, NonlinearPowerEnergy
-from nifty2go.library.nonlinearities import *
+from nifty2go.library.nonlinearities import Exponential
 import numpy as np
 np.random.seed(42)
 
@@ -32,9 +31,10 @@ if __name__ == "__main__":
     p_space = ift.PowerSpace(h_space,
                              binbounds=ift.PowerSpace.useful_binbounds(
                                  h_space, logarithmic=True))
-    s_spec = ift.Field(p_space,val=1.)
-    # Choosing the prior correlation structure and defining correlation operator
-    p = ift.Field(p_space,val = p_spec(p_space.k_lengths))
+    s_spec = ift.Field(p_space, val=1.)
+    # Choosing the prior correlation structure and defining
+    # correlation operator
+    p = ift.Field(p_space, val=p_spec(p_space.k_lengths))
     log_p = ift.log(p)
     S = ift.create_power_operator(h_space, power_spectrum=s_spec)
 
@@ -42,40 +42,40 @@ if __name__ == "__main__":
     sp = ift.Field(p_space,  val=s_spec)
     sh = ift.power_synthesize(sp)
 
-
     # Choosing the measurement instrument
     # Instrument = SmoothingOperator(s_space, sigma=0.01)
     mask = np.ones(s_space.shape)
     mask[6000:8000] = 0.
-    mask = ift.Field(s_space,val=mask)
+    mask = ift.Field(s_space, val=mask)
 
     MaskOperator = ift.DiagonalOperator(mask)
     InstrumentResponse = ift.ResponseOperator(s_space, sigma=[0.0])
-    MeasurementOperator = ift.ComposedOperator([MaskOperator, InstrumentResponse])
+    MeasurementOperator = ift.ComposedOperator([MaskOperator,
+                                                InstrumentResponse])
     d_space = MeasurementOperator.target
 
     noise_covariance = ift.Field(d_space, val=noise_level**2).weight()
     N = ift.DiagonalOperator(noise_covariance)
     n = ift.Field.from_random(domain=d_space,
-                          random_type='normal',
-                          std=noise_level,
-                          mean=0)
-    Projection = ift.PowerProjectionOperator(domain= h_space, power_space=p_space)
+                              random_type='normal',
+                              std=noise_level,
+                              mean=0)
+    Projection = ift.PowerProjectionOperator(domain=h_space,
+                                             power_space=p_space)
     power = Projection.adjoint_times(ift.exp(0.5 * log_p))
     # Creating the mock data
     true_sky = nonlinearity(FFT.adjoint_times(power * sh))
     d = MeasurementOperator(true_sky) + n
 
-
-
-    flat_power = ift.Field(p_space,val=10e-8)
+    flat_power = ift.Field(p_space, val=1e-7)
     m0 = ift.power_synthesize(flat_power)
-    t0 = ift.Field(p_space,val=-4.)
+    t0 = ift.Field(p_space, val=-4.)
     power0 = Projection.adjoint_times(ift.exp(0.5 * t0))
 
     IC1 = ift.GradientNormController(verbose=True, iteration_limit=100,
                                      tol_abs_gradnorm=1e-3)
-    minimizer = ift.RelaxedNewton(IC1)
+    LS = ift.LineSearchStrongWolfe(c2=0.02)
+    minimizer = ift.RelaxedNewton(IC1, line_searcher=LS)
 
     ICI = ift.GradientNormController(verbose=False, name="ICI",
                                      iteration_limit=500,
@@ -85,22 +85,22 @@ if __name__ == "__main__":
     for i in range(20):
 
         power0 = Projection.adjoint_times(ift.exp(0.5*t0))
-        map0_energy = NonlinearWienerFilterEnergy(m0, d, MeasurementOperator,
-                                                  nonlinearity, FFT, power0, N, S, inverter=inverter)
+        map0_energy = ift.library.NonlinearWienerFilterEnergy(
+            m0, d, MeasurementOperator, nonlinearity, FFT, power0, N, S,
+            inverter=inverter)
 
         # Minimization with chosen minimizer
         map0_energy, convergence = minimizer(map0_energy)
         m0 = map0_energy.position
 
-
         # Updating parameters for correlation structure reconstruction
         D0 = map0_energy.curvature
 
         # Initializing the power energy with updated parameters
-        power0_energy = NonlinearPowerEnergy(position=t0, d=d, N=N, m=m0,
-                                      D=D0, FFT=FFT, Instrument=MeasurementOperator,
-                                             nonlinearity=nonlinearity,Projection=Projection,
-                                             sigma=1., samples=2, inverter=inverter)
+        power0_energy = ift.library.NonlinearPowerEnergy(
+            position=t0, d=d, N=N, m=m0, D=D0, FFT=FFT,
+            Instrument=MeasurementOperator, nonlinearity=nonlinearity,
+            Projection=Projection, sigma=1., samples=2, inverter=inverter)
 
         (power0_energy, convergence) = minimizer(power0_energy)
 
@@ -108,9 +108,11 @@ if __name__ == "__main__":
         t0_ = t0.copy()
         t0 = power0_energy.position
 
-        # break degeneracy between amplitude and excitation by setting excitation monopole to 1
-        m0, t0 = adjust_zero_mode(m0,t0)
+        # break degeneracy between amplitude and excitation by setting
+        # excitation monopole to 1
+        m0, t0 = adjust_zero_mode(m0, t0)
 
     ift.plotting.plot(true_sky)
-    ift.plotting.plot(nonlinearity(FFT.adjoint_times(power0*m0)),title='reconstructed_sky')
+    ift.plotting.plot(nonlinearity(FFT.adjoint_times(power0*m0)),
+                      title='reconstructed_sky')
     ift.plotting.plot(MeasurementOperator.adjoint_times(d))
diff --git a/demos/paper_demos/cartesian_wiener_filter.py b/demos/paper_demos/cartesian_wiener_filter.py
index a4dcfda4436e611fddeb34430421642077ab0d89..d64c6ad76e5dad2a32a93eb8815e919354683ea5 100644
--- a/demos/paper_demos/cartesian_wiener_filter.py
+++ b/demos/paper_demos/cartesian_wiener_filter.py
@@ -93,9 +93,8 @@ if __name__ == "__main__":
     j = R_harmonic.adjoint_times(N.inverse_times(data))
     ctrl = ift.GradientNormController(verbose=True, tol_abs_gradnorm=0.1)
     inverter = ift.ConjugateGradient(controller=ctrl)
-    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N,
-                                                         R=R_harmonic)
-    wiener_curvature = ift.InversionEnabler(wiener_curvature, inverter)
+    wiener_curvature = ift.library.WienerFilterCurvature(
+        S=S, N=N, R=R_harmonic, inverter=inverter)
 
     m_k = wiener_curvature.inverse_times(j)
     m = fft(m_k)
diff --git a/demos/paper_demos/wiener_filter.py b/demos/paper_demos/wiener_filter.py
index 9f414b9eb545b31ecb99c99d038bde81f8c21e26..306605c2bf978bd237a0c97546069c9d122f0d0d 100644
--- a/demos/paper_demos/wiener_filter.py
+++ b/demos/paper_demos/wiener_filter.py
@@ -49,9 +49,8 @@ if __name__ == "__main__":
     j = R_harmonic.adjoint_times(N.inverse_times(data))
     ctrl = ift.GradientNormController(verbose=True, tol_abs_gradnorm=0.1)
     inverter = ift.ConjugateGradient(controller=ctrl)
-    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N,
-                                                         R=R_harmonic)
-    wiener_curvature = ift.InversionEnabler(wiener_curvature, inverter)
+    wiener_curvature = ift.library.WienerFilterCurvature(
+        S=S, N=N, R=R_harmonic, inverter=inverter)
     m_k = wiener_curvature.inverse_times(j)
     m = fft(m_k)
 
diff --git a/demos/wiener_filter_easy.py b/demos/wiener_filter_easy.py
index f7f6251b32187c4645db5830324d19572e0db26c..2ff3709e729c87a7b2867f4c020a016999743faa 100644
--- a/demos/wiener_filter_easy.py
+++ b/demos/wiener_filter_easy.py
@@ -5,9 +5,10 @@ import nifty2go as ift
 # Note that the constructor of PropagatorOperator takes as arguments the
 # response R and noise covariance N operating on signal space and signal
 # covariance operating on harmonic space.
-class PropagatorOperator(ift.EndomorphicOperator):
-    def __init__(self, R, N, Sh):
-        super(PropagatorOperator, self).__init__()
+class PropagatorOperator(ift.InversionEnabler, ift.EndomorphicOperator):
+    def __init__(self, R, N, Sh, inverter):
+        ift.InversionEnabler.__init__(self, inverter)
+        ift.EndomorphicOperator.__init__(self)
 
         self.R = R
         self.N = N
@@ -84,7 +85,6 @@ if __name__ == "__main__":
     j = R.adjoint_times(N.inverse_times(d))
     IC = ift.GradientNormController(iteration_limit=500, tol_abs_gradnorm=0.1)
     inverter = ift.ConjugateGradient(controller=IC)
-    D = ift.InversionEnabler(PropagatorOperator(Sh=Sh, N=N, R=R),
-                             inverter=inverter)
+    D = PropagatorOperator(Sh=Sh, N=N, R=R, inverter=inverter)
 
     m = D(j)
diff --git a/demos/wiener_filter_via_curvature.py b/demos/wiener_filter_via_curvature.py
index fb2340e7f001a079d6188f4b12953dc8d6996e8f..3758085d47a13b05720d79ad5a263c75cb367d8e 100644
--- a/demos/wiener_filter_via_curvature.py
+++ b/demos/wiener_filter_via_curvature.py
@@ -69,10 +69,9 @@ if __name__ == "__main__":
     j = R_harmonic.adjoint_times(N.inverse_times(data))
     ctrl = ift.GradientNormController(
         verbose=True, tol_abs_gradnorm=1e-4/nu.K/(nu.m**(0.5*dimensionality)))
-    wiener_curvature = ift.library.WienerFilterCurvature(S=S, N=N,
-                                                         R=R_harmonic)
     inverter = ift.ConjugateGradient(controller=ctrl)
-    wiener_curvature = ift.InversionEnabler(wiener_curvature, inverter)
+    wiener_curvature = ift.library.WienerFilterCurvature(
+        S=S, N=N, R=R_harmonic, inverter=inverter)
 
     m = wiener_curvature.inverse_times(j)
     m_s = fft(m)
diff --git a/demos/wiener_filter_via_hamiltonian.py b/demos/wiener_filter_via_hamiltonian.py
index 3bf23165b515478c6377cd7a60257787eba3a893..354cbb76aa8dfaaff156bafbf634348c857da39f 100644
--- a/demos/wiener_filter_via_hamiltonian.py
+++ b/demos/wiener_filter_via_hamiltonian.py
@@ -71,7 +71,7 @@ if __name__ == "__main__":
 
     n_samples = 50
     for i in range(n_samples):
-        sample = fft(ift.sugar.generate_posterior_sample(m, D))
+        sample = fft(D.generate_posterior_sample(m))
         sample_variance += sample**2
         sample_mean += sample
     sample_mean /= n_samples
diff --git a/nifty/library/critical_power_curvature.py b/nifty/library/critical_power_curvature.py
index 9efe32706b7e855bca91d5bd2730e187f4f7c3d1..d84b3f91c7c45667d8fb3162c78fc28c037d9d0c 100644
--- a/nifty/library/critical_power_curvature.py
+++ b/nifty/library/critical_power_curvature.py
@@ -1,8 +1,7 @@
-from ..operators.endomorphic_operator import EndomorphicOperator
-from ..operators.diagonal_operator import DiagonalOperator
+from ..operators import EndomorphicOperator, InversionEnabler, DiagonalOperator
 
 
-class CriticalPowerCurvature(EndomorphicOperator):
+class CriticalPowerCurvature(InversionEnabler, EndomorphicOperator):
     """The curvature of the CriticalPowerEnergy.
 
     This operator implements the second derivative of the
@@ -17,15 +16,12 @@ class CriticalPowerCurvature(EndomorphicOperator):
         The smoothness prior contribution to the curvature.
     """
 
-    def __init__(self, theta, T):
-        super(CriticalPowerCurvature, self).__init__()
+    def __init__(self, theta, T, inverter):
+        EndomorphicOperator.__init__(self)
         self._theta = DiagonalOperator(theta)
+        InversionEnabler.__init__(self, inverter, self._theta.inverse_times)
         self._T = T
 
-    @property
-    def preconditioner(self):
-        return self._theta.inverse_times
-
     def _times(self, x):
         return self._T(x) + self._theta(x)
 
diff --git a/nifty/library/critical_power_energy.py b/nifty/library/critical_power_energy.py
index 528ae5fa8438ff5294168f355178dadfa48b67ff..d38739780854ddde7426d6752eb8e0a0c4d321d3 100644
--- a/nifty/library/critical_power_energy.py
+++ b/nifty/library/critical_power_energy.py
@@ -1,11 +1,9 @@
 from ..minimization.energy import Energy
 from ..operators.smoothness_operator import SmoothnessOperator
 from ..operators.power_projection_operator import PowerProjectionOperator
-from ..operators.inversion_enabler import InversionEnabler
 from .critical_power_curvature import CriticalPowerCurvature
 from ..utilities import memo
 from .. import Field, exp
-from ..sugar import generate_posterior_sample
 
 
 class CriticalPowerEnergy(Energy):
@@ -67,14 +65,12 @@ class CriticalPowerEnergy(Energy):
         self._inverter = inverter
 
         if w is None:
-            # self.logger.info("Initializing w")
             P = PowerProjectionOperator(domain=self.m.domain,
                                         power_space=self.position.domain[0])
             if self.D is not None:
                 w = Field.zeros(self.position.domain, dtype=self.m.dtype)
                 for i in range(self.samples):
-                    # self.logger.info("Drawing sample %i" % i)
-                    sample = generate_posterior_sample(self.m, self.D)
+                    sample = self.D.generate_posterior_sample(self.m)
                     w += P(abs(sample)**2)
 
                 w *= 1./self.samples
@@ -82,15 +78,15 @@ class CriticalPowerEnergy(Energy):
                 w = P(abs(self.m)**2)
         self._w = w
 
-        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 = theta.integrate()
+        energy = self._theta.integrate()
         energy += self.position.integrate()*(self.alpha-0.5)
         energy += 0.5*self.position.vdot(Tt)
         self._value = energy.real
 
-        gradient = -theta
+        gradient = -self._theta
         gradient += self.alpha-0.5
         gradient += Tt
         self._gradient = gradient.real
@@ -99,7 +95,7 @@ class CriticalPowerEnergy(Energy):
         return self.__class__(position, self.m, D=self.D, alpha=self.alpha,
                               q=self.q, smoothness_prior=self.smoothness_prior,
                               logarithmic=self.logarithmic,
-                              samples=self.samples, w=self.w,
+                              samples=self.samples, w=self._w,
                               inverter=self._inverter)
 
     @property
@@ -113,8 +109,8 @@ class CriticalPowerEnergy(Energy):
     @property
     @memo
     def curvature(self):
-        curv = CriticalPowerCurvature(theta=self._theta, T=self.T)
-        return InversionEnabler(curv, inverter=self._inverter)
+        return CriticalPowerCurvature(theta=self._theta, T=self.T,
+                                      inverter=self._inverter)
 
     @property
     def logarithmic(self):
diff --git a/nifty/library/log_normal_wiener_filter_curvature.py b/nifty/library/log_normal_wiener_filter_curvature.py
index c7b0e4bd592971eeb51671e98747a6aead518444..068dba17a5b3ec1128e56f195155710a3445255b 100644
--- a/nifty/library/log_normal_wiener_filter_curvature.py
+++ b/nifty/library/log_normal_wiener_filter_curvature.py
@@ -1,9 +1,9 @@
-from ..operators import EndomorphicOperator
+from ..operators import EndomorphicOperator, InversionEnabler
 from ..utilities import memo
 from ..field import exp
 
 
-class LogNormalWienerFilterCurvature(EndomorphicOperator):
+class LogNormalWienerFilterCurvature(InversionEnabler, EndomorphicOperator):
     """The curvature of the LogNormalWienerFilterEnergy.
 
     This operator implements the second derivative of the
@@ -21,8 +21,9 @@ class LogNormalWienerFilterCurvature(EndomorphicOperator):
        The prior signal covariance
     """
 
-    def __init__(self, R, N, S, position, fft4exp):
-        super(LogNormalWienerFilterCurvature, self).__init__()
+    def __init__(self, R, N, S, position, fft4exp, inverter):
+        InversionEnabler.__init__(self, inverter)
+        EndomorphicOperator.__init__(self)
         self.R = R
         self.N = N
         self.S = S
diff --git a/nifty/library/log_normal_wiener_filter_energy.py b/nifty/library/log_normal_wiener_filter_energy.py
index f1ecc3725644ea9ec59d82159295d6d49394b179..5d1c760be0a8c4d40f2a4dc323f294c69c5b05ba 100644
--- a/nifty/library/log_normal_wiener_filter_energy.py
+++ b/nifty/library/log_normal_wiener_filter_energy.py
@@ -2,7 +2,6 @@ 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 ..operators.inversion_enabler import InversionEnabler
 
 
 class LogNormalWienerFilterEnergy(Energy):
@@ -58,11 +57,9 @@ class LogNormalWienerFilterEnergy(Energy):
     @property
     @memo
     def curvature(self):
-        return InversionEnabler(
-            LogNormalWienerFilterCurvature(R=self.R, N=self.N, S=self.S,
-                                           position=self.position,
-                                           fft4exp=self._fft),
-            inverter=self._inverter)
+        return LogNormalWienerFilterCurvature(
+            R=self.R, N=self.N, S=self.S, position=self.position,
+            fft4exp=self._fft, inverter=self._inverter)
 
     @property
     @memo
@@ -72,7 +69,7 @@ class LogNormalWienerFilterEnergy(Energy):
     @property
     @memo
     def _Rexppd(self):
-        expp = self._fft.adjoint_times(self.curvature.op._expp_sspace)
+        expp = self._fft.adjoint_times(self.curvature._expp_sspace)
         return self.R(expp) - self.d
 
     @property
@@ -84,5 +81,5 @@ class LogNormalWienerFilterEnergy(Energy):
     @memo
     def _exppRNRexppd(self):
         return self._fft.adjoint_times(
-                    self.curvature.op._expp_sspace *
+                    self.curvature._expp_sspace *
                     self._fft(self.R.adjoint_times(self._NRexppd)))
diff --git a/nifty/library/noise_energy.py b/nifty/library/noise_energy.py
index 66acb8f5de26360850d6053dc8b417446d969814..137bc8b6c1d2cfc678095b2f3e5ff0b6f1600de3 100644
--- a/nifty/library/noise_energy.py
+++ b/nifty/library/noise_energy.py
@@ -1,6 +1,5 @@
 from .. import Field, exp
 from ..operators.diagonal_operator import DiagonalOperator
-from ..sugar import generate_posterior_sample
 from ..minimization.energy import Energy
 from ..utilities import memo
 
@@ -31,7 +30,7 @@ class NoiseEnergy(Energy):
                 sample_list.append(self.m)
             else:
                 for i in range(samples):
-                    sample = generate_posterior_sample(m, D)
+                    sample = D.generate_posterior_sample(m)
                     sample = FFT(Field(FFT.domain, val=(
                         FFT.adjoint_times(sample).val)))
                     sample_list.append(sample)
diff --git a/nifty/library/nonlinear_power_curvature.py b/nifty/library/nonlinear_power_curvature.py
index 6c51404853611a42fd7f1260040d482624cebc58..d2845013690edc09efff284c1e18c977e08bea61 100644
--- a/nifty/library/nonlinear_power_curvature.py
+++ b/nifty/library/nonlinear_power_curvature.py
@@ -1,12 +1,13 @@
-from ..operators.endomorphic_operator import EndomorphicOperator
+from ..operators import EndomorphicOperator, InversionEnabler
 from .response_operators import LinearizedPowerResponse
 
 
-class NonlinearPowerCurvature(EndomorphicOperator):
+class NonlinearPowerCurvature(InversionEnabler, EndomorphicOperator):
 
     def __init__(self, position, FFT, Instrument, nonlinearity,
-                 Projection, N, T, sample_list):
-        super(NonlinearPowerCurvature, self).__init__()
+                 Projection, N, T, sample_list, inverter):
+        InversionEnabler.__init__(self, inverter)
+        EndomorphicOperator.__init__(self)
         self.N = N
         self.FFT = FFT
         self.Instrument = Instrument
diff --git a/nifty/library/nonlinear_power_energy.py b/nifty/library/nonlinear_power_energy.py
index f774d5745a0c9663bbe3f603ed54267397f1db16..a79f4c825b0c17f38037088b56901f0864484db2 100644
--- a/nifty/library/nonlinear_power_energy.py
+++ b/nifty/library/nonlinear_power_energy.py
@@ -1,11 +1,9 @@
 from .. import exp
 from ..utilities import memo
 from ..operators.smoothness_operator import SmoothnessOperator
-from ..sugar import generate_posterior_sample
 from .nonlinear_power_curvature import NonlinearPowerCurvature
 from .response_operators import LinearizedPowerResponse
 from ..minimization.energy import Energy
-from ..operators.inversion_enabler import InversionEnabler
 
 
 class NonlinearPowerEnergy(Energy):
@@ -56,7 +54,7 @@ class NonlinearPowerEnergy(Energy):
             if samples is None or samples == 0:
                 sample_list = [m]
             else:
-                sample_list = [generate_posterior_sample(m, D)
+                sample_list = [D.generate_posterior_sample(m)
                                for _ in range(samples)]
         self.sample_list = sample_list
         self.inverter = inverter
@@ -105,7 +103,7 @@ class NonlinearPowerEnergy(Energy):
     @property
     @memo
     def curvature(self):
-        curvature = NonlinearPowerCurvature(
+        return NonlinearPowerCurvature(
             self.position, self.FFT, self.Instrument, self.nonlinearity,
-            self.Projection, self.N, self.T, self.sample_list)
-        return InversionEnabler(curvature, inverter=self.inverter)
+            self.Projection, self.N, self.T, self.sample_list,
+            inverter=self.inverter)
diff --git a/nifty/library/nonlinear_wiener_filter_energy.py b/nifty/library/nonlinear_wiener_filter_energy.py
index 1781332e7f7931649716b6fb977cf9e45ab40906..065ecb6b8a4edc17428c4b75fc4f89837d1b0a62 100644
--- a/nifty/library/nonlinear_wiener_filter_energy.py
+++ b/nifty/library/nonlinear_wiener_filter_energy.py
@@ -1,7 +1,6 @@
 from .wiener_filter_curvature import WienerFilterCurvature
 from ..utilities import memo
 from ..minimization.energy import Energy
-from ..operators.inversion_enabler import InversionEnabler
 from .response_operators import LinearizedSignalResponse
 
 
@@ -45,6 +44,5 @@ class NonlinearWienerFilterEnergy(Energy):
     @property
     @memo
     def curvature(self):
-        curvature = WienerFilterCurvature(R=self.LinearizedResponse,
-                                          N=self.N, S=self.S)
-        return InversionEnabler(curvature, inverter=self.inverter)
+        return WienerFilterCurvature(R=self.LinearizedResponse, N=self.N,
+                                     S=self.S, inverter=self.inverter)
diff --git a/nifty/library/response_operators.py b/nifty/library/response_operators.py
index f2f05c129672310d93da2b31e9206ed707342ffe..7b698c9b25640765ccf3a1fd7ca733dfdd2a58a7 100644
--- a/nifty/library/response_operators.py
+++ b/nifty/library/response_operators.py
@@ -42,7 +42,7 @@ class LinearizedPowerResponse(LinearOperator):
         self.Instrument = Instrument
         self.FFT = FFT
         self.Projection = Projection
-        self.power = exp(0.5 * t)
+        self.power = exp(0.5*t)
         self.m = m
         position = FFT.adjoint_times(
             self.Projection.adjoint_times(self.power) * self.m)
diff --git a/nifty/library/wiener_filter_curvature.py b/nifty/library/wiener_filter_curvature.py
index 20f55637375ddd20cf3d78c56d719c580e2072c4..50933501acbbce8a08580062b6e36396355474c7 100644
--- a/nifty/library/wiener_filter_curvature.py
+++ b/nifty/library/wiener_filter_curvature.py
@@ -1,7 +1,9 @@
-from ..operators import EndomorphicOperator
+from ..operators import EndomorphicOperator, InversionEnabler
+from ..field import Field, sqrt
+from ..sugar import power_analyze, power_synthesize
 
 
-class WienerFilterCurvature(EndomorphicOperator):
+class WienerFilterCurvature(InversionEnabler, EndomorphicOperator):
     """The curvature of the WienerFilterEnergy.
 
     This operator implements the second derivative of the
@@ -19,16 +21,13 @@ class WienerFilterCurvature(EndomorphicOperator):
        The prior signal covariance
     """
 
-    def __init__(self, R, N, S):
-        super(WienerFilterCurvature, self).__init__()
+    def __init__(self, R, N, S, inverter):
+        EndomorphicOperator.__init__(self)
+        InversionEnabler.__init__(self, inverter, S.times)
         self.R = R
         self.N = N
         self.S = S
 
-    @property
-    def preconditioner(self):
-        return self.S.times
-
     @property
     def domain(self):
         return self.S.domain
@@ -45,3 +44,40 @@ class WienerFilterCurvature(EndomorphicOperator):
         res = self.R.adjoint_times(self.N.inverse_times(self.R(x)))
         res += self.S.inverse_times(x)
         return res
+
+    def generate_posterior_sample(self, mean):
+        """ Generates a posterior sample from a Gaussian distribution with
+        given mean and covariance.
+
+        This method generates samples by setting up the observation and
+        reconstruction of a mock signal in order to obtain residuals of the
+        right correlation which are added to the given mean.
+
+        Parameters
+        ----------
+        mean : Field
+            the mean of the posterior Gaussian distribution
+
+        Returns
+        -------
+        sample : Field
+            Returns the a sample from the Gaussian of given mean and
+            covariance.
+        """
+
+        power = sqrt(power_analyze(self.S.diagonal()))
+        mock_signal = power_synthesize(power, real_signal=True)
+
+        noise = self.N.diagonal().weight(-1)
+
+        mock_noise = Field.from_random(random_type="normal",
+                                       domain=self.N.domain,
+                                       dtype=noise.dtype.type)
+        mock_noise *= sqrt(noise)
+
+        mock_data = self.R(mock_signal) + mock_noise
+
+        mock_j = self.R.adjoint_times(self.N.inverse_times(mock_data))
+        mock_m = self.inverse_times(mock_j)
+        sample = mock_signal - mock_m + mean
+        return sample
diff --git a/nifty/library/wiener_filter_energy.py b/nifty/library/wiener_filter_energy.py
index 7b8ef0cac73376ff4395a4f61bbcba716797d5a8..3bf42e8046ce2087f929101422757ce23cc5283d 100644
--- a/nifty/library/wiener_filter_energy.py
+++ b/nifty/library/wiener_filter_energy.py
@@ -1,5 +1,4 @@
 from ..minimization.energy import Energy
-from ..operators.inversion_enabler import InversionEnabler
 from .wiener_filter_curvature import WienerFilterCurvature
 
 
@@ -28,8 +27,7 @@ class WienerFilterEnergy(Energy):
         self.R = R
         self.N = N
         self.S = S
-        self._curvature = InversionEnabler(WienerFilterCurvature(R, N, S),
-                                           inverter=inverter)
+        self._curvature = WienerFilterCurvature(R, N, S, inverter=inverter)
         self._inverter = inverter
         if _j is None:
             _j = self.R.adjoint_times(self.N.inverse_times(d))
diff --git a/nifty/minimization/conjugate_gradient.py b/nifty/minimization/conjugate_gradient.py
index 9de83875c32372b035b76fca2dede3a8466d1a2b..31457c17d0e7af8050d0e7763c12fc9dc896907a 100644
--- a/nifty/minimization/conjugate_gradient.py
+++ b/nifty/minimization/conjugate_gradient.py
@@ -32,9 +32,6 @@ class ConjugateGradient(Minimizer):
     ----------
     controller : IterationController
         Object that decides when to terminate the minimization.
-    preconditioner : Operator *optional*
-        This operator can be provided which transforms the variables of the
-        system to improve the conditioning (default: None).
 
     References
     ----------
@@ -42,8 +39,7 @@ class ConjugateGradient(Minimizer):
     2006, Springer-Verlag New York
     """
 
-    def __init__(self, controller, preconditioner=None):
-        self._preconditioner = preconditioner
+    def __init__(self, controller):
         self._controller = controller
 
     def __call__(self, energy, preconditioner=None):
@@ -54,6 +50,9 @@ class ConjugateGradient(Minimizer):
         energy : Energy object at the starting point of the iteration.
             Its curvature operator must be independent of position, otherwise
             linear conjugate gradient minimization will fail.
+        preconditioner : Operator *optional*
+            This operator can be provided which transforms the variables of the
+            system to improve the conditioning (default: None).
 
         Returns
         -------
@@ -62,9 +61,6 @@ class ConjugateGradient(Minimizer):
         status : integer
             Can be controller.CONVERGED or controller.ERROR
         """
-        if preconditioner is None:
-            preconditioner = self._preconditioner
-
         controller = self._controller
         status = controller.start(energy)
         if status != controller.CONTINUE:
diff --git a/nifty/operators/inversion_enabler.py b/nifty/operators/inversion_enabler.py
index fa0e3634d458089b338ef708bf60e5c9ec2f7338..719da004bc99c723be73b7f56ad0eb7c04017d7f 100644
--- a/nifty/operators/inversion_enabler.py
+++ b/nifty/operators/inversion_enabler.py
@@ -18,57 +18,29 @@
 
 from ..minimization.quadratic_energy import QuadraticEnergy
 from ..field import Field
-from .linear_operator import LinearOperator
 
 
-class InversionEnabler(LinearOperator):
+class InversionEnabler(object):
 
-    def __init__(self, op, inverter, preconditioner=None):
-        self._op = op
-        self._inverter = inverter
-        if preconditioner is None and hasattr(op, "preconditioner"):
-            self._preconditioner = op.preconditioner
-        else:
-            self._preconditioner = preconditioner
+    def __init__(self, inverter, preconditioner=None):
         super(InversionEnabler, self).__init__()
+        self._inverter = inverter
+        self._preconditioner = preconditioner
 
-    @property
-    def domain(self):
-        return self._op.domain
-
-    @property
-    def target(self):
-        return self._op.target
-
-    @property
-    def unitary(self):
-        return self._op.unitary
-
-    @property
-    def op(self):
-        return self._op
-
-    def _operation(self, x, o1, o2, tdom):
-        try:
-            return o1(x)
-        except NotImplementedError:
-            x0 = Field.zeros(tdom, dtype=x.dtype)
-            energy = QuadraticEnergy(A=o2, b=x, position=x0)
-            r = self._inverter(energy, preconditioner=self._preconditioner)[0]
-            return r.position
+    def _operation(self, x, op, tdom):
+        x0 = Field.zeros(tdom, dtype=x.dtype)
+        energy = QuadraticEnergy(A=op, b=x, position=x0)
+        r = self._inverter(energy, preconditioner=self._preconditioner)[0]
+        return r.position
 
     def _times(self, x):
-        return self._operation(x, self._op._times,
-                               self._op.inverse_times, self.target)
+        return self._operation(x, self._inverse_times, self.target)
 
     def _adjoint_times(self, x):
-        return self._operation(x, self._op._adjoint_times,
-                               self._op._adjoint_inverse_times, self.domain)
+        return self._operation(x, self._adjoint_inverse_times, self.domain)
 
     def _inverse_times(self, x):
-        return self._operation(x, self._op._inverse_times,
-                               self._op._times, self.domain)
+        return self._operation(x, self._times, self.domain)
 
     def _adjoint_inverse_times(self, x):
-        return self._operation(x, self._op._adjoint_inverse_times,
-                               self._op._adjoint_times, self.target)
+        return self._operation(x, self._adjoint_times, self.target)
diff --git a/nifty/sugar.py b/nifty/sugar.py
index 08e30f9ca83ada3705effdbb5575de2a52c07dc2..da15940964f76a90e57c45bede6b019e3a538ffa 100644
--- a/nifty/sugar.py
+++ b/nifty/sugar.py
@@ -27,7 +27,6 @@ __all__ = ['PS_field',
            'power_synthesize_special',
            'create_power_field',
            'create_power_operator',
-           'generate_posterior_sample',
            'create_composed_fft_operator']
 
 
@@ -251,49 +250,6 @@ def create_power_operator(domain, power_spectrum, space=None, dtype=None):
         spaces=space)
 
 
-def generate_posterior_sample(mean, covariance):
-    """ Generates a posterior sample from a Gaussian distribution with given
-    mean and covariance
-
-    This method generates samples by setting up the observation and
-    reconstruction of a mock signal in order to obtain residuals of the right
-    correlation which are added to the given mean.
-
-    Parameters
-    ----------
-    mean : Field
-        the mean of the posterior Gaussian distribution
-    covariance : WienerFilterCurvature
-        The posterior correlation structure consisting of a
-        response operator, noise covariance and prior signal covariance
-
-    Returns
-    -------
-    sample : Field
-        Returns the a sample from the Gaussian of given mean and covariance.
-    """
-
-    S = covariance.op.S
-    R = covariance.op.R
-    N = covariance.op.N
-
-    power = sqrt(power_analyze(S.diagonal()))
-    mock_signal = power_synthesize(power, real_signal=True)
-
-    noise = N.diagonal().weight(-1)
-
-    mock_noise = Field.from_random(random_type="normal", domain=N.domain,
-                                   dtype=noise.dtype.type)
-    mock_noise *= sqrt(noise)
-
-    mock_data = R(mock_signal) + mock_noise
-
-    mock_j = R.adjoint_times(N.inverse_times(mock_data))
-    mock_m = covariance.inverse_times(mock_j)
-    sample = mock_signal - mock_m + mean
-    return sample
-
-
 def create_composed_fft_operator(domain, codomain=None, all_to='other'):
     fft_op_list = []