Remove temporary files used during development

demos/find_amplitude_parameters.py

-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# 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-2019 Max-Planck-Society
-# Author: Philipp Arras
-#
-# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik.
-
-import numpy as np
-
-import nifty6 as ift
-import matplotlib.pyplot as plt
-
-
-def _default_pspace(dom):
-    return ift.PowerSpace(dom.get_default_codomain())
-
-
-if __name__ == '__main__':
-    np.random.seed(42)
-    fa = ift.CorrelatedFieldMaker.make(10, 0.1, '')
-    n_samps = 20
-    slope_means = [-2, -3]
-    fa.add_fluctuations(ift.RGSpace(128, 0.1), 10, 2, 1, 1e-6,
-                        2, 1e-6, slope_means[0], 0.2, 'spatial')
-    # fa.add_fluctuations(_default_pspace(ift.RGSpace((128, 64))), 10, 2, 1,
-    #                     1e-6, 2, 1e-6, slope_means[0], 0.2, 'spatial')
-    fa.add_fluctuations(ift.RGSpace(32), 3, 5, 1, 1e-6, 2,
-                        1e-6, slope_means[1], 1, 'freq')
-    correlated_field = fa.finalize()
-    amplitudes = fa.normalized_amplitudes
-    plt.style.use('seaborn-notebook')
-
-    tgt = correlated_field.target
-    if len(tgt.shape) == 1:
-        fig, axes = plt.subplots(nrows=1, ncols=2)
-        fig.set_size_inches(20, 10)
-    else:
-        fig, axes = plt.subplots(nrows=3, ncols=3)
-        fig.set_size_inches(20, 16)
-    axs = (ax for ax in axes.ravel())
-    for ii, aa in enumerate(amplitudes):
-        ax = next(axs)
-        pspec = aa**2
-        ax.set_xscale('log')
-        ax.set_yscale('log')
-        for _ in range(n_samps):
-            fld = pspec(ift.from_random('normal', pspec.domain))
-            klengths = fld.domain[0].k_lengths
-            ycoord = fld.val_rw()
-            ycoord[0] = ycoord[1]
-            ax.plot(klengths, ycoord, alpha=1)
-
-        ymin, ymax = ax.get_ylim()
-        color = plt.rcParams['axes.prop_cycle'].by_key()['color'][0]
-        lbl = 'Mean slope (k^{})'.format(2*slope_means[ii])
-        for fac in np.linspace(np.log(ymin), np.log(ymax**2/ymin)):
-            xs = np.linspace(np.amin(klengths[1:]), np.amax(klengths[1:]))
-            ys = xs**(2*slope_means[ii])*np.exp(fac)
-            xs = np.insert(xs, 0, 0)
-            ys = np.insert(ys, 0, ys[0])
-            ax.plot(xs, ys, zorder=1, color=color, linewidth=0.3, label=lbl)
-            lbl = None
-
-        ax.set_ylim([ymin, ymax])
-        ax.set_xlim([None, np.amax(klengths)])
-        ax.legend()
-
-    if len(tgt.shape) == 2:
-        foo = []
-        for ax in axs:
-            pos = ift.from_random('normal', correlated_field.domain)
-            fld = correlated_field(pos).val
-            foo.append((ax, fld))
-        mi, ma = np.inf, -np.inf
-        for _, fld in foo:
-            mi = min([mi, np.amin(fld)])
-            ma = max([ma, np.amax(fld)])
-        nxdx, nydy = tgt.shape
-        if len(tgt) == 2:
-            nxdx *= tgt[0].distances[0]
-            nydy *= tgt[1].distances[0]
-        else:
-            nxdx *= tgt[0].distances[0]
-            nydy *= tgt[0].distances[1]
-        for ax, fld in foo:
-            im = ax.imshow(fld.T,
-                           extent=[0, nxdx, 0, nydy],
-                           aspect='auto',
-                           origin='lower',
-                           vmin=mi,
-                           vmax=ma)
-        fig.colorbar(im, ax=axes.ravel().tolist())
-    elif len(tgt.shape) == 1:
-        ax = next(axs)
-        flds = []
-        for _ in range(n_samps):
-            pos = ift.from_random('normal', correlated_field.domain)
-            ax.plot(correlated_field(pos).val)
-
-    plt.savefig('correlated_fields.png')
-    plt.close()

demos/multi_amplitudes_consistency.py

-import nifty6 as ift
-import numpy as np
-
-
-
-
-def testAmplitudesConsistency(seed, sspace):
-    def stats(op,samples):
-        sc = ift.StatCalculator()
-        for s in samples:
-            sc.add(op(s.extract(op.domain)))
-        return sc.mean.val, sc.var.sqrt().val
-    np.random.seed(seed)
-    offset_std = .1
-    intergated_fluct_std0 = .003
-    intergated_fluct_std1 = 0.1
-
-    nsam = 1000
-
-
-    fsspace = ift.RGSpace((12,), (0.4,))
-
-    fa = ift.CorrelatedFieldMaker.make(offset_std, 1E-8, '')
-    fa.add_fluctuations(sspace, intergated_fluct_std0, 1E-8, 1.1, 2., 2.1, .5,
-                        -2, 1., 'spatial')
-    fa.add_fluctuations(fsspace, intergated_fluct_std1, 1E-8, 3.1, 1., .5, .1,
-                        -4, 1., 'freq')
-    op = fa.finalize()
-
-    samples = [ift.from_random('normal',op.domain) for _ in range(nsam)]
-    tot_flm, _ = stats(fa.total_fluctuation,samples)
-    offset_std,_ = stats(fa.amplitude_total_offset,samples)
-    intergated_fluct_std0,_ = stats(fa.average_fluctuation(0),samples)
-    intergated_fluct_std1,_ = stats(fa.average_fluctuation(1),samples)
-
-    slice_fluct_std0,_ = stats(fa.slice_fluctuation(0),samples)
-    slice_fluct_std1,_ = stats(fa.slice_fluctuation(1),samples)
-
-    sams = [op(s) for s in samples]
-    fluct_total = fa.total_fluctuation_realized(sams)
-    fluct_space = fa.average_fluctuation_realized(sams,0)
-    fluct_freq = fa.average_fluctuation_realized(sams,1)
-    zm_std_mean = fa.offset_amplitude_realized(sams)
-    sl_fluct_space = fa.slice_fluctuation_realized(sams,0)
-    sl_fluct_freq = fa.slice_fluctuation_realized(sams,1)
-
-    print("Expected  offset Std: " + str(offset_std))
-    print("Estimated offset Std: " + str(zm_std_mean))
-
-    print("Expected  integrated fluct. space Std: " +
-          str(intergated_fluct_std0))
-    print("Estimated integrated fluct. space Std: " + str(fluct_space))
-
-    print("Expected  integrated fluct. frequency Std: " +
-          str(intergated_fluct_std1))
-    print("Estimated integrated fluct. frequency Std: " + str(fluct_freq))
-
-    print("Expected  slice fluct. space Std: " +
-          str(slice_fluct_std0))
-    print("Estimated slice fluct. space Std: " + str(sl_fluct_space))
-
-    print("Expected  slice fluct. frequency Std: " +
-          str(slice_fluct_std1))
-    print("Estimated slice fluct. frequency Std: " + str(sl_fluct_freq))
-
-    print("Expected  total fluct. Std: " + str(tot_flm))
-    print("Estimated total fluct. Std: " + str(fluct_total))
-
-
-    np.testing.assert_allclose(offset_std, zm_std_mean, rtol=0.5)
-    np.testing.assert_allclose(intergated_fluct_std0, fluct_space, rtol=0.5)
-    np.testing.assert_allclose(intergated_fluct_std1, fluct_freq, rtol=0.5)
-    np.testing.assert_allclose(tot_flm, fluct_total, rtol=0.5)
-    np.testing.assert_allclose(slice_fluct_std0, sl_fluct_space, rtol=0.5)
-    np.testing.assert_allclose(slice_fluct_std1, sl_fluct_freq, rtol=0.5)
-
-
-    fa = ift.CorrelatedFieldMaker.make(offset_std, .1, '')
-    fa.add_fluctuations(fsspace, intergated_fluct_std1, 1., 3.1, 1., .5, .1,
-                        -4, 1., 'freq')
-    m = 3.
-    x = fa.moment_slice_to_average(m)
-    fa.add_fluctuations(sspace, x, 1.5, 1.1, 2., 2.1, .5,
-                        -2, 1., 'spatial', 0)
-    op = fa.finalize()
-    em, estd = stats(fa.slice_fluctuation(0),samples)
-    print("Forced   slice fluct. space Std: "+str(m))
-    print("Expected slice fluct. Std: " + str(em))
-    np.testing.assert_allclose(m, em, rtol=0.5)
-
-    assert op.target[0] == sspace
-    assert op.target[1] == fsspace
-
-
-# Move to tests
-# FIXME This test fails but it is not relevant for the final result
-# assert_allclose(ampl(from_random('normal', ampl.domain)).val[0], vol) or 1??
-# End move to tests
-
-# move to tests
-# assert_allclose(
-#     smooth(from_random('normal', smooth.domain)).val[0:2], 0)
-# end move to tests
-for seed in [1, 42]:
-    for sp in [
-            ift.RGSpace((32, 64), (1.1, 0.3)),
-            ift.HPSpace(32),
-            ift.GLSpace(32)
-    ]:
-        testAmplitudesConsistency(seed, sp)

demos/newamplitudes.py

-import nifty6 as ift
-import numpy as np
-np.random.seed(42)
-
-sspace = ift.RGSpace((128,))
-
-fa = ift.CorrelatedFieldMaker.make(10, 0.1, '')
-fa.add_fluctuations(sspace, 10, 2, 1, 1e-6, 2, 1e-6, -2, 1e-6, 'spatial')
-op = fa.finalize()
-A = fa.amplitude
-
-cstpos = ift.from_random('normal', op.domain)
-p1, p2 = [ift.Plot() for _ in range(2)]
-lst1 = []
-skys1, skys2 = [], []
-for _ in range(8):
-    pos = ift.from_random('normal', op.domain)
-
-    foo = ift.MultiField.union([cstpos, pos.extract(A.domain)])
-    skys2.append(op(foo))
-
-    sky = op(pos)
-    skys1.append(sky)
-    lst1.append(A.force(pos))
-
-for pp, ll in [(p1, skys1), (p2, skys2)]:
-    mi, ma = None, None
-    if False:
-        mi, ma = np.inf, -np.inf
-        for ss in ll:
-            mi = min([mi, np.amin(ss.val)])
-            ma = max([ma, np.amax(ss.val)])
-    for ss in ll:
-        pp.add(ss, zmin=mi, zmax=ma)
-
-p1.add(lst1)
-p2.add(lst1)
-p1.output(name='full.png')
-p2.output(name='xi_fixed.png')