diff --git a/demos/nonlinear_critical_filter.py b/demos/nonlinear_critical_filter.py index 2627fdc698fff114fc42d0bf9d89914551b833e4..cc903044b59b2a33f04d50292c0d8aabfdcbf486 100644 --- a/demos/nonlinear_critical_filter.py +++ b/demos/nonlinear_critical_filter.py @@ -59,9 +59,8 @@ if __name__ == "__main__": d_space = MeasurementOperator.target - Projection = ift.PowerProjectionOperator(domain=h_space, - power_space=p_space) - power = Projection.adjoint_times(ift.exp(0.5*log_p)) + Distributor = ift.PowerDistributor(target=h_space, power_space=p_space) + power = Distributor(ift.exp(0.5*log_p)) # Creating the mock data true_sky = nonlinearity(HT(power*sh)) noiseless_data = MeasurementOperator(true_sky) @@ -75,7 +74,7 @@ if __name__ == "__main__": m0 = ift.power_synthesize(ift.Field(p_space, val=1e-7)) t0 = ift.Field(p_space, val=-4.) - power0 = Projection.adjoint_times(ift.exp(0.5 * t0)) + power0 = Distributor.times(ift.exp(0.5 * t0)) IC1 = ift.GradientNormController(name="IC1", iteration_limit=100, tol_abs_gradnorm=1e-3) @@ -87,7 +86,7 @@ if __name__ == "__main__": inverter = ift.ConjugateGradient(controller=ICI) for i in range(20): - power0 = Projection.adjoint_times(ift.exp(0.5*t0)) + power0 = Distributor(ift.exp(0.5*t0)) map0_energy = ift.library.NonlinearWienerFilterEnergy( m0, d, MeasurementOperator, nonlinearity, HT, power0, N, S, inverter=inverter) @@ -103,7 +102,7 @@ if __name__ == "__main__": power0_energy = ift.library.NonlinearPowerEnergy( position=t0, d=d, N=N, xi=m0, D=D0, ht=HT, Instrument=MeasurementOperator, nonlinearity=nonlinearity, - Projection=Projection, sigma=1., samples=2, inverter=inverter) + Distributor=Distributor, sigma=1., samples=2, inverter=inverter) power0_energy = minimizer(power0_energy)[0] diff --git a/demos/wiener_filter_via_hamiltonian.py b/demos/wiener_filter_via_hamiltonian.py index 8c6e11105d556ab1b75bcfedc04b67718703a7ba..8dd1fb854e87ae535d43b116a838a9311fad5753 100644 --- a/demos/wiener_filter_via_hamiltonian.py +++ b/demos/wiener_filter_via_hamiltonian.py @@ -70,7 +70,8 @@ if __name__ == "__main__": # Generate plots zmax = max(ht(sh).max(), ht(m).max()) zmin = min(ht(sh).min(), ht(m).min()) - plotdict = {"zmax": zmax, "zmin": zmin, "colormap": "Planck-like"} + plotdict = {"zmax": zmax, "zmin": zmin,"colormap": "Planck-like"} + plotdict2 = {"colormap": "Planck-like"} ift.plot(ht(sh), name="mock_signal.png", **plotdict) ift.plot(ht(m), name="reconstruction.png", **plotdict) @@ -79,10 +80,10 @@ if __name__ == "__main__": sample_mean = ift.Field.zeros(s_space) mean, variance = ift.probe_with_posterior_samples(curv, ht, 50) - ift.plot(variance, name="posterior_variance.png", **plotdict) + ift.plot(variance, name="posterior_variance.png", **plotdict2) ift.plot(mean+ht(m), name="posterior_mean.png", **plotdict) # try to do the same with diagonal probing variance = ift.probe_diagonal(ht*curv.inverse*ht.adjoint, 100) - #sm = ift.FFTSmoothingOperator(s_space, sigma=0.015) - ift.plot(variance, name="posterior_variance2.png", **plotdict) + #sm = ift.FFTSmoothingOperator(s_space, sigma=0.005) + ift.plot(variance, name="posterior_variance2.png", **plotdict2) diff --git a/docs/source/concepts/operators.rst b/docs/source/concepts/operators.rst index f6ebfcf6c08611039c36ab1ca1180861b6379b4d..21a95926665e3127576298820e260bd802c1f3e1 100644 --- a/docs/source/concepts/operators.rst +++ b/docs/source/concepts/operators.rst @@ -12,7 +12,7 @@ Description of Operators ScalingOperator <../mod/nifty4.operators.scaling_operator> DiagonalOperator <../mod/nifty4.operators.diagonal_operator> HarmonicTransformOperator <../mod/nifty4.operators.harmonic_transform_operator> - PowerProjectionOperator <../mod/nifty4.operators.power_projection_operator> + PowerDistributor <../mod/nifty4.operators.power_distributor> .. toctree:: :maxdepth: 1 @@ -26,7 +26,7 @@ Description of Operators .. Adjoint <../mod/nifty4.operators.adjoint_operator> .. Chain <../mod/nifty4.operators.chain_operator> -.. DOF Projection <../mod/nifty4.operators.dof_projection_operator> +.. DOF Distributor <../mod/nifty4.operators.dof_distributor> .. Inverse <../mod/nifty4.operators.inverse_operator> .. Laplace <../mod/nifty4.operators.linear_operator> .. Sum <../mod/nifty4.operators.sum_operator> diff --git a/nifty4/library/critical_power_energy.py b/nifty4/library/critical_power_energy.py index bc08071314556928f6baa177aa419e3d9f46473b..f94ceb16e8dc9d8df8fc786e3f311f76b83892c5 100644 --- a/nifty4/library/critical_power_energy.py +++ b/nifty4/library/critical_power_energy.py @@ -18,7 +18,7 @@ from ..minimization.energy import Energy from ..operators.smoothness_operator import SmoothnessOperator -from ..operators.power_projection_operator import PowerProjectionOperator +from ..operators.power_distributor import PowerDistributor from .critical_power_curvature import CriticalPowerCurvature from ..utilities import memo from .. import Field, exp @@ -86,17 +86,17 @@ class CriticalPowerEnergy(Energy): self._inverter = inverter if w is None: - P = PowerProjectionOperator(domain=self.m.domain, - power_space=self.position.domain[0]) + Dist = PowerDistributor(target=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): sample = self.D.draw_sample() + self.m - w += P(abs(sample)**2) + w += Dist.adjoint_times(abs(sample)**2) w *= 1./self.samples else: - w = P(abs(self.m)**2) + w = Dist.adjoint_times(abs(self.m)**2) self._w = w self._theta = exp(-self.position) * (self.q + self._w*0.5) diff --git a/nifty4/library/noise_energy.py b/nifty4/library/noise_energy.py index 465b3a621d56cae0085ae1d028dff33dd618b874..419df97f3d3229d9161bb38ffc0709e2b568935d 100644 --- a/nifty4/library/noise_energy.py +++ b/nifty4/library/noise_energy.py @@ -25,7 +25,7 @@ from ..minimization.energy import Energy class NoiseEnergy(Energy): def __init__(self, position, d, xi, D, t, ht, Instrument, - nonlinearity, alpha, q, Projection, samples=3, + nonlinearity, alpha, q, Distribution, samples=3, xi_sample_list=None, inverter=None): super(NoiseEnergy, self).__init__(position=position) self.xi = xi @@ -40,8 +40,8 @@ class NoiseEnergy(Energy): self.alpha = alpha self.q = q - self.Projection = Projection - self.power = self.Projection.adjoint_times(exp(0.5 * self.t)) + self.Distribution = Distribution + self.power = self.Distribution(exp(0.5 * self.t)) if xi_sample_list is None: if samples is None or samples == 0: xi_sample_list = [xi] @@ -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 = Distribution(exp(.5*self.t)) self._gradient = None for sample in self.xi_sample_list: @@ -81,7 +81,7 @@ class NoiseEnergy(Energy): return self.__class__( position, self.d, self.xi, self.D, self.t, self.ht, self.Instrument, self.nonlinearity, self.alpha, self.q, - self.Projection, xi_sample_list=self.xi_sample_list, + self.Distribution, xi_sample_list=self.xi_sample_list, samples=self.samples, inverter=self.inverter) @property diff --git a/nifty4/library/nonlinear_power_energy.py b/nifty4/library/nonlinear_power_energy.py index 670757d1f64c25efa18dc471e02eafe41c3b2034..dc78a904b8f398c521d08f8beb2513be065142b0 100644 --- a/nifty4/library/nonlinear_power_energy.py +++ b/nifty4/library/nonlinear_power_energy.py @@ -52,7 +52,7 @@ class NonlinearPowerEnergy(Energy): """ def __init__(self, position, d, N, xi, D, ht, Instrument, nonlinearity, - Projection, sigma=0., samples=3, xi_sample_list=None, + Distribution, sigma=0., samples=3, xi_sample_list=None, inverter=None): super(NonlinearPowerEnergy, self).__init__(position) self.xi = xi @@ -64,7 +64,7 @@ class NonlinearPowerEnergy(Energy): self.ht = ht self.Instrument = Instrument self.nonlinearity = nonlinearity - self.Projection = Projection + self.Distribution = Distribution self.sigma = sigma if xi_sample_list is None: if samples is None or samples == 0: @@ -75,7 +75,7 @@ class NonlinearPowerEnergy(Energy): self.xi_sample_list = xi_sample_list self.inverter = inverter - A = Projection.adjoint_times(exp(.5 * position)) + A = Distribution(exp(.5 * position)) map_s = self.ht(A * xi) Tpos = self.T(position) @@ -83,7 +83,7 @@ class NonlinearPowerEnergy(Energy): for xi_sample in self.xi_sample_list: map_s = self.ht(A * xi_sample) LinR = LinearizedPowerResponse( - self.Instrument, self.nonlinearity, self.ht, self.Projection, + self.Instrument, self.nonlinearity, self.ht, self.Distribution, self.position, xi_sample) residual = self.d - \ @@ -106,7 +106,7 @@ class NonlinearPowerEnergy(Energy): def at(self, position): return self.__class__(position, self.d, self.N, self.xi, self.D, self.ht, self.Instrument, self.nonlinearity, - self.Projection, sigma=self.sigma, + self.Distribution, sigma=self.sigma, samples=len(self.xi_sample_list), xi_sample_list=self.xi_sample_list, inverter=self.inverter) @@ -124,5 +124,5 @@ class NonlinearPowerEnergy(Energy): def curvature(self): return NonlinearPowerCurvature( self.position, self.ht, self.Instrument, self.nonlinearity, - self.Projection, self.N, self.T, self.xi_sample_list, + self.Distribution, self.N, self.T, self.xi_sample_list, self.inverter) diff --git a/nifty4/library/response_operators.py b/nifty4/library/response_operators.py index ec7edfe783b18957ec34208fe88c6f9c45f0f3f9..b1fbec30767c277751ecad31e5feedb77b3424fd 100644 --- a/nifty4/library/response_operators.py +++ b/nifty4/library/response_operators.py @@ -23,8 +23,9 @@ def LinearizedSignalResponse(Instrument, nonlinearity, ht, power, m): return Instrument * nonlinearity.derivative(m) * ht * power -def LinearizedPowerResponse(Instrument, nonlinearity, ht, Projection, tau, xi): +def LinearizedPowerResponse(Instrument, nonlinearity, ht, Distribution, tau, + xi): power = exp(0.5*tau) - position = ht(Projection.adjoint_times(power)*xi) + position = ht(Distribution(power)*xi) linearization = nonlinearity.derivative(position) - return 0.5*Instrument*linearization*ht*xi*Projection.adjoint*power + return 0.5*Instrument*linearization*ht*xi*Distribution*power diff --git a/nifty4/operators/__init__.py b/nifty4/operators/__init__.py index 200776217b4501a340be4404b11efe1182ac62fc..d2d1207802ea3751ad18054b8dc0cb1583e6072b 100644 --- a/nifty4/operators/__init__.py +++ b/nifty4/operators/__init__.py @@ -7,10 +7,10 @@ from .fft_operator import FFTOperator from .fft_smoothing_operator import FFTSmoothingOperator from .geometry_remover import GeometryRemover from .laplace_operator import LaplaceOperator -from .power_projection_operator import PowerProjectionOperator +from .power_distributor import PowerDistributor from .inversion_enabler import InversionEnabler __all__ = ["LinearOperator", "EndomorphicOperator", "ScalingOperator", "DiagonalOperator", "HarmonicTransformOperator", "FFTOperator", "FFTSmoothingOperator", "GeometryRemover", - "LaplaceOperator", "PowerProjectionOperator", "InversionEnabler"] + "LaplaceOperator", "PowerDistributor", "InversionEnabler"] diff --git a/nifty4/operators/dof_projection_operator.py b/nifty4/operators/dof_distributor.py similarity index 79% rename from nifty4/operators/dof_projection_operator.py rename to nifty4/operators/dof_distributor.py index 1ab10f26d7a63d3aa6fab23cf92d863a74b72872..ebd8b8277449473203348a44e9f940dce164ca36 100644 --- a/nifty4/operators/dof_projection_operator.py +++ b/nifty4/operators/dof_distributor.py @@ -25,15 +25,15 @@ from .. import dobj from ..domains.dof_space import DOFSpace -class DOFProjectionOperator(LinearOperator): - def __init__(self, dofdex, domain=None, space=None): - super(DOFProjectionOperator, self).__init__() +class DOFDistributor(LinearOperator): + def __init__(self, dofdex, target=None, space=None): + super(DOFDistributor, self).__init__() - if domain is None: - domain = dofdex.domain - self._domain = DomainTuple.make(domain) - space = infer_space(self._domain, space) - partner = self._domain[space] + if target is None: + target = dofdex.domain + self._target = DomainTuple.make(target) + space = infer_space(self._target, space) + partner = self._target[space] if not isinstance(dofdex, Field): raise TypeError("dofdex must be a Field") if not len(dofdex.domain) == 1: @@ -64,41 +64,41 @@ class DOFProjectionOperator(LinearOperator): def _init2(self, dofdex, space, other_space): self._space = space - tgt = list(self._domain) - tgt[self._space] = other_space - self._target = DomainTuple.make(tgt) + dom = list(self._target) + dom[self._space] = other_space + self._domain = DomainTuple.make(dom) if dobj.default_distaxis() in self._domain.axes[self._space]: dofdex = dobj.local_data(dofdex) else: # dofdex must be available fully on every task dofdex = dobj.to_global_data(dofdex) self._dofdex = dofdex.ravel() - firstaxis = self._domain.axes[self._space][0] - lastaxis = self._domain.axes[self._space][-1] - arrshape = dobj.local_shape(self._domain.shape, 0) + firstaxis = self._target.axes[self._space][0] + lastaxis = self._target.axes[self._space][-1] + arrshape = dobj.local_shape(self._target.shape, 0) presize = np.prod(arrshape[0:firstaxis], dtype=np.int) postsize = np.prod(arrshape[lastaxis+1:], dtype=np.int) - self._hshape = (presize, self._target[self._space].shape[0], postsize) + self._hshape = (presize, self._domain[self._space].shape[0], postsize) self._pshape = (presize, self._dofdex.size, postsize) - def _times(self, x): + def _adjoint_times(self, x): arr = dobj.local_data(x.val) arr = arr.reshape(self._pshape) oarr = np.zeros(self._hshape, dtype=x.dtype) np.add.at(oarr, (slice(None), self._dofdex, slice(None)), arr) if dobj.distaxis(x.val) in x.domain.axes[self._space]: - oarr = dobj.np_allreduce_sum(oarr).reshape(self._target.shape) - res = Field(self._target, dobj.from_global_data(oarr)) + oarr = dobj.np_allreduce_sum(oarr).reshape(self._domain.shape) + res = Field(self._domain, dobj.from_global_data(oarr)) else: - oarr = oarr.reshape(dobj.local_shape(self._target.shape, + oarr = oarr.reshape(dobj.local_shape(self._domain.shape, dobj.distaxis(x.val))) - res = Field(self._target, - dobj.from_local_data(self._target.shape, oarr, + res = Field(self._domain, + dobj.from_local_data(self._domain.shape, oarr, dobj.default_distaxis())) return res - def _adjoint_times(self, x): - res = Field.empty(self._domain, dtype=x.dtype) + def _times(self, x): + res = Field.empty(self._target, dtype=x.dtype) if dobj.distaxis(x.val) in x.domain.axes[self._space]: arr = dobj.to_global_data(x.val) else: diff --git a/nifty4/operators/power_projection_operator.py b/nifty4/operators/power_distributor.py similarity index 78% rename from nifty4/operators/power_projection_operator.py rename to nifty4/operators/power_distributor.py index c6a01aeee1c1c7919524c38cf91a4e58a63bd5ee..5810e2e0d38f79ddd3a5cf0eb261f60deba98b25 100644 --- a/nifty4/operators/power_projection_operator.py +++ b/nifty4/operators/power_distributor.py @@ -16,20 +16,20 @@ # NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik # and financially supported by the Studienstiftung des deutschen Volkes. -from .dof_projection_operator import DOFProjectionOperator +from .dof_distributor import DOFDistributor from ..domain_tuple import DomainTuple from ..utilities import infer_space from ..domains.power_space import PowerSpace -class PowerProjectionOperator(DOFProjectionOperator): - def __init__(self, domain, power_space=None, space=None): +class PowerDistributor(DOFDistributor): + def __init__(self, target, power_space=None, space=None): # Initialize domain and target - self._domain = DomainTuple.make(domain) - self._space = infer_space(self._domain, space) - hspace = self._domain[self._space] + self._target = DomainTuple.make(target) + self._space = infer_space(self._target, space) + hspace = self._target[self._space] if not hspace.harmonic: - raise ValueError("Operator acts on harmonic spaces only") + raise ValueError("Operator requires harmonic target space") if power_space is None: power_space = PowerSpace(hspace) else: diff --git a/nifty4/sugar.py b/nifty4/sugar.py index f3204c3ac63e8763d03bfc9ab0668d07df98e5d2..16f2dd70537ea997a18323818aa2c6ccb2667fb3 100644 --- a/nifty4/sugar.py +++ b/nifty4/sugar.py @@ -21,7 +21,7 @@ from .domains.structured_domain import StructuredDomain from .domains.power_space import PowerSpace from .field import Field, sqrt from .operators.diagonal_operator import DiagonalOperator -from .operators.power_projection_operator import PowerProjectionOperator +from .operators.power_distributor import PowerDistributor from .operators.harmonic_transform_operator import HarmonicTransformOperator from .domain_tuple import DomainTuple from . import dobj, utilities @@ -45,8 +45,8 @@ def PS_field(pspace, func, dtype=None): def _single_power_analyze(field, idx, binbounds): power_domain = PowerSpace(field.domain[idx], binbounds) - ppo = PowerProjectionOperator(field.domain, power_domain, idx) - return ppo(field.weight(1)).weight(-1) # divides by bin size + pd = PowerDistributor(field.domain, power_domain, idx) + return pd.adjoint_times(field.weight(1)).weight(-1) # divides by bin size def power_analyze(field, spaces=None, binbounds=None, @@ -125,8 +125,8 @@ def power_synthesize_nonrandom(field, spaces=None): spec = sqrt(field) for i in spaces: result_domain[i] = field.domain[i].harmonic_partner - ppo = PowerProjectionOperator(result_domain, field.domain[i], i) - spec = ppo.adjoint_times(spec) + pd = PowerDistributor(result_domain, field.domain[i], i) + spec = pd(spec) return spec @@ -203,7 +203,7 @@ def create_power_field(domain, power_spectrum, dtype=None): power_domain = PowerSpace(domain) fp = PS_field(power_domain, power_spectrum, dtype) - return PowerProjectionOperator(domain, power_domain).adjoint_times(fp) + return PowerDistributor(domain, power_domain)(fp) def create_power_operator(domain, power_spectrum, space=None, dtype=None): diff --git a/test/test_energies/test_map.py b/test/test_energies/test_map.py index e00bda8b550bd80a2149b8af14530e84b562a469..21f296aaa0b10ce1cf34c877c062561b8ea86eea 100644 --- a/test/test_energies/test_map.py +++ b/test/test_energies/test_map.py @@ -11,7 +11,7 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # -# Copyright(C) 2013-2017 Max-Planck-Society +# Copyright(C) 2013-2018 Max-Planck-Society # # NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik # and financially supported by the Studienstiftung des deutschen Volkes. @@ -39,12 +39,12 @@ class Energy_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, target=space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=False) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi0 = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 1 / (1 + k**2)**dim pspec = ift.PS_field(pspace, pspec) - A = P.adjoint_times(ift.sqrt(pspec)) + A = Dist(ift.sqrt(pspec)) n = ift.Field.from_random(domain=space, random_type='normal') s0 = xi0 * A Instrument = ift.ScalingOperator(10., space) @@ -85,12 +85,12 @@ class Energy_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, target=space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=False) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi0 = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 1 / (1 + k**2)**dim pspec = ift.PS_field(pspace, pspec) - A = P.adjoint_times(ift.sqrt(pspec)) + A = Dist(ift.sqrt(pspec)) n = ift.Field.from_random(domain=space, random_type='normal') s = ht(xi0 * A) R = ift.ScalingOperator(10., space) @@ -129,12 +129,12 @@ class Curvature_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, target=space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=False) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi0 = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 1 / (1 + k**2)**dim pspec = ift.PS_field(pspace, pspec) - A = P.adjoint_times(ift.sqrt(pspec)) + A = Dist(ift.sqrt(pspec)) n = ift.Field.from_random(domain=space, random_type='normal') s0 = xi0 * A Instrument = ift.ScalingOperator(10., space) @@ -178,12 +178,12 @@ class Curvature_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, target=space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=False) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi0 = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 1 / (1 + k**2)**dim pspec = ift.PS_field(pspace, pspec) - A = P.adjoint_times(ift.sqrt(pspec)) + A = Dist(ift.sqrt(pspec)) n = ift.Field.from_random(domain=space, random_type='normal') s = ht(xi0 * A) R = ift.ScalingOperator(10., space) diff --git a/test/test_energies/test_noise.py b/test/test_energies/test_noise.py index 30d6d256fd64752be1ed4d2bf2c2cfde9a414329..dde5bf9006e318664f55e21db1ce92f78ef6a106 100644 --- a/test/test_energies/test_noise.py +++ b/test/test_energies/test_noise.py @@ -11,7 +11,7 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. # -# Copyright(C) 2013-2017 Max-Planck-Society +# Copyright(C) 2013-2018 Max-Planck-Society # # NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik # and financially supported by the Studienstiftung des deutschen Volkes. @@ -41,12 +41,12 @@ class Noise_Energy_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, target=space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=False) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 1 / (1 + k**2)**dim tau = ift.PS_field(pspace, pspec) - A = P.adjoint_times(ift.sqrt(tau)) + A = Dist(ift.sqrt(tau)) var = 1. n = ift.Field.from_random( domain=space, @@ -86,7 +86,7 @@ class Noise_Energy_Tests(unittest.TestCase): energy0 = ift.library.NoiseEnergy( position=eta0, d=d, xi=xi, D=D, t=tau, Instrument=R, - alpha=alpha, q=q, Projection=P, nonlinearity=f, + alpha=alpha, q=q, Distribution=Dist, nonlinearity=f, ht=ht, samples=10) energy1 = energy0.at(eta1) diff --git a/test/test_energies/test_power.py b/test/test_energies/test_power.py index 2386232602595a3b9de759d7eaf8360d30528ef3..31a093de4d3455470330ca7fa21dfb656871f40b 100644 --- a/test/test_energies/test_power.py +++ b/test/test_energies/test_power.py @@ -39,13 +39,13 @@ class Energy_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=True) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 64 / (1 + k**2)**dim pspec = ift.PS_field(pspace, pspec) tau0 = ift.log(pspec) - A = P.adjoint_times(ift.sqrt(pspec)) + A = Dist(ift.sqrt(pspec)) n = ift.Field.from_random(domain=space, random_type='normal', std=.01) N = ift.DiagonalOperator(n**2) s = xi * A @@ -91,12 +91,12 @@ class Energy_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=True) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 1 / (1 + k**2)**dim tau0 = ift.PS_field(pspace, pspec) - A = P.adjoint_times(ift.sqrt(tau0)) + A = Dist(ift.sqrt(tau0)) n = ift.Field.from_random(domain=space, random_type='normal') s = ht(xi * A) R = ift.ScalingOperator(10., space) @@ -132,7 +132,7 @@ class Energy_Tests(unittest.TestCase): xi=xi, D=D, Instrument=R, - Projection=P, + Distribution=Dist, nonlinearity=f, ht=ht, N=N, @@ -160,13 +160,13 @@ class Curvature_Tests(unittest.TestCase): ht = ift.HarmonicTransformOperator(hspace, space) binbounds = ift.PowerSpace.useful_binbounds(hspace, logarithmic=True) pspace = ift.PowerSpace(hspace, binbounds=binbounds) - P = ift.PowerProjectionOperator(domain=hspace, power_space=pspace) + Dist = ift.PowerDistributor(target=hspace, power_space=pspace) xi = ift.Field.from_random(domain=hspace, random_type='normal') def pspec(k): return 64 / (1 + k**2)**dim pspec = ift.PS_field(pspace, pspec) tau0 = ift.log(pspec) - A = P.adjoint_times(ift.sqrt(pspec)) + A = Dist(ift.sqrt(pspec)) n = ift.Field.from_random(domain=space, random_type='normal', std=.01) N = ift.DiagonalOperator(n**2) s = xi * A diff --git a/test/test_operators/test_adjoint.py b/test/test_operators/test_adjoint.py index 0579f857d261c3f7bf4cf63cf318137f92dec043..078b6663c4599f5aee24ffb59ad9bd0871802587 100644 --- a/test/test_operators/test_adjoint.py +++ b/test/test_operators/test_adjoint.py @@ -35,15 +35,15 @@ _p_spaces = _p_RG_spaces + [ift.HPSpace(17), ift.GLSpace(8, 13)] class Consistency_Tests(unittest.TestCase): @expand(product(_h_spaces, [np.float64, np.complex128])) def testPPO(self, sp, dtype): - op = ift.PowerProjectionOperator(sp) + op = ift.PowerDistributor(target=sp) ift.extra.consistency_check(op, dtype, dtype) ps = ift.PowerSpace( sp, ift.PowerSpace.useful_binbounds(sp, logarithmic=False, nbin=3)) - op = ift.PowerProjectionOperator(sp, ps) + op = ift.PowerDistributor(target=sp, power_space=ps) ift.extra.consistency_check(op, dtype, dtype) ps = ift.PowerSpace( sp, ift.PowerSpace.useful_binbounds(sp, logarithmic=True, nbin=3)) - op = ift.PowerProjectionOperator(sp, ps) + op = ift.PowerDistributor(target=sp, power_space=ps) ift.extra.consistency_check(op, dtype, dtype) @expand(product(_h_RG_spaces+_p_RG_spaces,