Commit 4d5cfe1a authored by Martin Reinecke's avatar Martin Reinecke
Browse files

Merge branch 'cosmetics' into 'NIFTy_6'

Cosmetics

See merge request !396
parents 76130897 bbeba660
Pipeline #65161 passed with stages
in 12 minutes and 34 seconds
...@@ -89,6 +89,14 @@ run_getting_started_3: ...@@ -89,6 +89,14 @@ run_getting_started_3:
paths: paths:
- '*.png' - '*.png'
run_getting_started_mf:
stage: demo_runs
script:
- python3 demos/getting_started_mf.py
artifacts:
paths:
- '*.png'
run_bernoulli: run_bernoulli:
stage: demo_runs stage: demo_runs
script: script:
......
# 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()
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)
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')
...@@ -206,8 +206,7 @@ class _Normalization(Operator): ...@@ -206,8 +206,7 @@ class _Normalization(Operator):
mode_multiplicity = pd.adjoint(full(pd.target, 1.)).val_rw() mode_multiplicity = pd.adjoint(full(pd.target, 1.)).val_rw()
zero_mode = (slice(None),)*self._domain.axes[space][0] + (0,) zero_mode = (slice(None),)*self._domain.axes[space][0] + (0,)
mode_multiplicity[zero_mode] = 0 mode_multiplicity[zero_mode] = 0
self._mode_multiplicity = makeField(self._domain, self._mode_multiplicity = makeField(self._domain, mode_multiplicity)
mode_multiplicity)
self._specsum = _SpecialSum(self._domain, space) self._specsum = _SpecialSum(self._domain, space)
def apply(self, x): def apply(self, x):
...@@ -299,14 +298,15 @@ class _Amplitude(Operator): ...@@ -299,14 +298,15 @@ class _Amplitude(Operator):
shift = DiagonalOperator(makeField(dom[space], foo), dom, space) shift = DiagonalOperator(makeField(dom[space], foo), dom, space)
vslope = DiagonalOperator( vslope = DiagonalOperator(
makeField(target[space], makeField(target[space], _relative_log_k_lengths(target[space])),
_relative_log_k_lengths(target[space])),
target, space) target, space)
foo, bar = [np.zeros(target[space].shape) for _ in range(2)] foo, bar = [np.zeros(target[space].shape) for _ in range(2)]
bar[1:] = foo[0] = totvol bar[1:] = foo[0] = totvol
vol0, vol1 = [DiagonalOperator(makeField(target[space], aa), vol0, vol1 = [
target, space) for aa in (foo, bar)] DiagonalOperator(makeField(target[space], aa), target, space)
for aa in (foo, bar)
]
# Prepare fields for Adder # Prepare fields for Adder
shift, vol0 = [op(full(op.domain, 1)) for op in (shift, vol0)] shift, vol0 = [op(full(op.domain, 1)) for op in (shift, vol0)]
...@@ -413,13 +413,11 @@ class CorrelatedFieldMaker: ...@@ -413,13 +413,11 @@ class CorrelatedFieldMaker:
self._prefix + prefix + 'flexibility', self._prefix + prefix + 'flexibility',
N) N)
asp = _LognormalMomentMatching(asperity_mean, asperity_stddev, asp = _LognormalMomentMatching(asperity_mean, asperity_stddev,
self._prefix + prefix + 'asperity', self._prefix + prefix + 'asperity', N)
N)
avgsl = _normal(loglogavgslope_mean, loglogavgslope_stddev, avgsl = _normal(loglogavgslope_mean, loglogavgslope_stddev,
self._prefix + prefix + 'loglogavgslope', N) self._prefix + prefix + 'loglogavgslope', N)
amp = _Amplitude(PowerSpace(harmonic_partner), amp = _Amplitude(PowerSpace(harmonic_partner), fluct, flex, asp, avgsl,
fluct, flex, asp, avgsl, self._azm, self._azm, position_space[-1].total_volume,
position_space[-1].total_volume,
self._prefix + prefix + 'spectrum', dofdex) self._prefix + prefix + 'spectrum', dofdex)
if index is not None: if index is not None:
......
...@@ -16,55 +16,56 @@ ...@@ -16,55 +16,56 @@
# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik. # NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik.
import pytest import pytest
from numpy.testing import assert_allclose
from numpy.random import seed from numpy.random import seed
from numpy.testing import assert_allclose
import nifty6 as ift import nifty6 as ift
@pytest.mark.parametrize('sspace', [ @pytest.mark.parametrize('sspace', [
ift.RGSpace(4), ift.RGSpace(4),
ift.RGSpace((4, 4), (0.123,0.4)), ift.RGSpace((4, 4), (0.123, 0.4)),
ift.HPSpace(8), ift.HPSpace(8),
ift.GLSpace(4) ift.GLSpace(4)
]) ])
@pytest.mark.parametrize('rseed', [13, 2]) @pytest.mark.parametrize('rseed', [13, 2])
@pytest.mark.parametrize('Astds', [[1.,3.],[0.2,1.4]]) @pytest.mark.parametrize('Astds', [[1., 3.], [0.2, 1.4]])
@pytest.mark.parametrize('offset_std', [1.,10.]) @pytest.mark.parametrize('offset_std', [1., 10.])
def testAmplitudesConsistency(rseed, sspace, Astds, offset_std): def testAmplitudesConsistency(rseed, sspace, Astds, offset_std):
def stats(op,samples): def stats(op, samples):
sc = ift.StatCalculator() sc = ift.StatCalculator()
for s in samples: for s in samples:
sc.add(op(s.extract(op.domain))) sc.add(op(s.extract(op.domain)))
return sc.mean.val, sc.var.sqrt().val return sc.mean.val, sc.var.sqrt().val
seed(rseed) seed(rseed)
nsam = 100 nsam = 100
fsspace = ift.RGSpace((12,), (0.4,)) fsspace = ift.RGSpace((12,), (0.4,))
fa = ift.CorrelatedFieldMaker.make(offset_std, 1E-8, '') fa = ift.CorrelatedFieldMaker.make(offset_std, 1E-8, '')
fa.add_fluctuations(sspace, Astds[0], 1E-8, 1.1, 2., 2.1, .5, fa.add_fluctuations(sspace, Astds[0], 1E-8, 1.1, 2., 2.1, .5, -2, 1.,
-2, 1., 'spatial') 'spatial')
fa.add_fluctuations(fsspace, Astds[1], 1E-8, 3.1, 1., .5, .1, fa.add_fluctuations(fsspace, Astds[1], 1E-8, 3.1, 1., .5, .1, -4, 1.,
-4, 1., 'freq') 'freq')
op = fa.finalize() op = fa.finalize()
samples = [ift.from_random('normal',op.domain) for _ in range(nsam)] samples = [ift.from_random('normal', op.domain) for _ in range(nsam)]
tot_flm, _ = stats(fa.total_fluctuation,samples) tot_flm, _ = stats(fa.total_fluctuation, samples)
offset_std,_ = stats(fa.amplitude_total_offset,samples) offset_std, _ = stats(fa.amplitude_total_offset, samples)
intergated_fluct_std0,_ = stats(fa.average_fluctuation(0),samples) intergated_fluct_std0, _ = stats(fa.average_fluctuation(0), samples)
intergated_fluct_std1,_ = stats(fa.average_fluctuation(1),samples) intergated_fluct_std1, _ = stats(fa.average_fluctuation(1), samples)
slice_fluct_std0,_ = stats(fa.slice_fluctuation(0),samples) slice_fluct_std0, _ = stats(fa.slice_fluctuation(0), samples)
slice_fluct_std1,_ = stats(fa.slice_fluctuation(1),samples) slice_fluct_std1, _ = stats(fa.slice_fluctuation(1), samples)
sams = [op(s) for s in samples] sams = [op(s) for s in samples]
fluct_total = fa.total_fluctuation_realized(sams) fluct_total = fa.total_fluctuation_realized(sams)
fluct_space = fa.average_fluctuation_realized(sams,0) fluct_space = fa.average_fluctuation_realized(sams, 0)
fluct_freq = fa.average_fluctuation_realized(sams,1) fluct_freq = fa.average_fluctuation_realized(sams, 1)
zm_std_mean = fa.offset_amplitude_realized(sams) zm_std_mean = fa.offset_amplitude_realized(sams)
sl_fluct_space = fa.slice_fluctuation_realized(sams,0) sl_fluct_space = fa.slice_fluctuation_realized(sams, 0)
sl_fluct_freq = fa.slice_fluctuation_realized(sams,1) sl_fluct_freq = fa.slice_fluctuation_realized(sams, 1)
assert_allclose(offset_std, zm_std_mean, rtol=0.5) assert_allclose(offset_std, zm_std_mean, rtol=0.5)
assert_allclose(intergated_fluct_std0, fluct_space, rtol=0.5) assert_allclose(intergated_fluct_std0, fluct_space, rtol=0.5)
...@@ -74,14 +75,12 @@ def testAmplitudesConsistency(rseed, sspace, Astds, offset_std): ...@@ -74,14 +75,12 @@ def testAmplitudesConsistency(rseed, sspace, Astds, offset_std):
assert_allclose(slice_fluct_std1, sl_fluct_freq, rtol=0.5) assert_allclose(slice_fluct_std1, sl_fluct_freq, rtol=0.5)
fa = ift.CorrelatedFieldMaker.make(offset_std, .1, '') fa = ift.CorrelatedFieldMaker.make(offset_std, .1, '')
fa.add_fluctuations(fsspace, Astds[1], 1., 3.1, 1., .5, .1, fa.add_fluctuations(fsspace, Astds[1], 1., 3.1, 1., .5, .1, -4, 1., 'freq')
-4, 1., 'freq')
m = 3. m = 3.
x = fa.moment_slice_to_average(m) x = fa.moment_slice_to_average(m)
fa.add_fluctuations(sspace, x, 1.5, 1.1, 2., 2.1, .5, fa.add_fluctuations(sspace, x, 1.5, 1.1, 2., 2.1, .5, -2, 1., 'spatial', 0)
-2, 1., 'spatial', 0)
op = fa.finalize() op = fa.finalize()
em, estd = stats(fa.slice_fluctuation(0),samples) em, estd = stats(fa.slice_fluctuation(0), samples)
assert_allclose(m, em, rtol=0.5) assert_allclose(m, em, rtol=0.5)
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment