def test_calculate_filter():
# Test a very small filter (n=3) with know result
f1 = fdesign._calculate_filter(n=3, spacing=0.77, shift=-0.08,
fI=[fdesign.j0_1(5), ], r_def=(1, 1, 2),
reim=np.real, name='success')
assert 'success' == f1.name
assert_allclose(f1.base, [0.42741493, 0.92311635, 1.99371553])
assert_allclose(f1.j0, [1.08179183, -0.11669046, 0.03220896])
assert_allclose(f1.factor, 2.1597662537849152)
# The above means just there was a solution to the inversion. The found
# solution is most likely a very bad filter, as n=3. So we check it with
# a transform pair that always works: lhs = 1, rhs = 1/r.
r = np.logspace(1, 2, 10)
rhs = np.dot(np.ones((r.size, f1.base.size)), f1.j0)/r
assert_allclose(1/r, rhs, atol=1e-3) # Only to 0.1 %, 3 pt filter!
# Test a very small filter (n=3) with no result (fail)
f2 = fdesign._calculate_filter(n=4, spacing=0.77, shift=-0.08,
fI=[fdesign.j0_1(5), ], r_def=(0, 0, 0.5),
reim=np.real, name='fail')
assert 'fail' == f2.name
assert_allclose(f2.base, [0.1978987, 0.42741493, 0.92311635, 1.99371553]),
assert_allclose(f2.j0, [0, 0, 0, 0])
assert_allclose(f2.factor, 2.1597662537849152)
def test_get_min_val(capsys):
# Some parameters
fI0 = fdesign.j0_1(5)
fI1 = fdesign.j1_1(5)
rdef = (1, 1, 2)
error = 0.01
# 1. "Normal" case
r = np.logspace(0, 2, 10)
fC = fdesign.j0_1(5)
fC.rhs = fC.rhs(r)
out = fdesign._get_min_val((0.05, -1.0), 201, [fI0, ], [fC, ], r, rdef,
error, np.real, 'amp', 0, 0, [])
assert_allclose(out, 2.386523e-05, rtol=1e-5)
# 2. "Normal" case j0 and j1; J0 is better than J1
fC1 = fdesign.j1_1(5)
fC1.rhs = fC1.rhs(r)
out = fdesign._get_min_val((0.05, -1.0), 201, [fI1, fI0], [fC1, fC], r,
rdef, error, np.real, 'amp', 0, 0, [])
assert_allclose(out, 2.386523e-05, rtol=1e-5)
# 3. f2
fC2 = fdesign.empy_hankel('j2', 950, 1000, 1, 1)
fC2.rhs = fC2.rhs(r)
out = fdesign._get_min_val((0.05, -1.0), 201, [fI0, fI1], [fC2, ], r, rdef,
error, np.real, 'amp', 0, 0, [])
assert_allclose(out, 6.831394e-08, rtol=1e-5)
# 4. No solution below error
out = fdesign._get_min_val((0.05, -10.0), 201, [fI0, ], [fC, ], r, rdef,
error, np.real, 'amp', 0, 0, [])
assert_allclose(out, np.inf)
# 5. All nan's; with max r
out = fdesign._get_min_val((0.05, 10.0), 201, [fI0, ], [fC, ], r, rdef,
error, np.real, 'r', 0, 0, [])
assert_allclose(out, np.inf)
# 6. r too small, with verbosity
log = {'cnt1': 1, 'cnt2': 9, 'totnr': 10, 'time': default_timer(),
'warn-r': 0}
r = np.logspace(0, 1.1, 10)
fC = fdesign.j0_1(5)
fC.rhs = fC.rhs(r)
out, _ = capsys.readouterr() # empty
fdesign._get_min_val((0.058, -1.26), 201, [fI0, ], [fC, ], r, rdef, error,
np.real, 'amp', 3, 0, log)
out, _ = capsys.readouterr()
assert "* WARNING :: all data have error < "+str(error)+";" in out
assert "brute fct calls : 10" in out
def test_design(self, capsys):
# Check it doesn't fail, message is correct, and input doesn't matter
# Same test as first in test_design
fI = (fdesign.j0_1(5), fdesign.j1_1(5))
dat1 = DATA['case1'][()]
_, _ = fdesign.design(fI=fI, verb=1, plot=2, **dat1[0])
out, _ = capsys.readouterr()
assert "* WARNING :: `matplotlib` is not installed, no " in out
def test_call_qc_transform_pairs2(self):
# plot_transform_pair J2
r = np.logspace(1, 2, 50)
fI = (fdesign.j0_1(5), fdesign.j1_1(5))
fC = fdesign.empy_hankel('j2', 950, 1000, 1, 1)
fC.rhs = fC.rhs(r)
fdesign._call_qc_transform_pairs(101, (0.06, 0.07, 0.01), (-1, 1, 0.3),
fI, [fC, ], r, (0, 0, 2), np.imag)
return plt.gcf()
def test_call_qc_transform_pairs1(self):
# plot_transform_pair "normal" case
r = np.logspace(1, 2, 50)
fI = (fdesign.j0_1(5), fdesign.j1_1(5))
fC = (fdesign.j0_3(5), fdesign.j1_3(5))
fC[0].rhs = fC[0].rhs(r)
fC[1].rhs = fC[1].rhs(r)
fdesign._call_qc_transform_pairs(101, (0.06, 0.07, 0.01), (-1, 1, 0.3),
fI, fC, r, (0, 0, 2), np.real)
return plt.gcf()
def test_plot_result1(self):
# Quick run `design` with all verb/plot on, just to check that no
# errors occur. Actually plots are checked in test below and the other
# tests.
dat2 = DATA['case2'][()]
fdesign.design(fI=fdesign.j0_1(5), verb=2, plot=2, **dat2[0])
# plot_result for min amplitude
dat1 = DATA['case1'][()]
fdesign.plot_result(dat1[1], dat1[2], prntres=True)
return plt.gcf()
def test_plot_inversion1(self):
# plot_inversion minimum amplitude
f = fdesign.j0_1(5)
filt = filters.key_201_2009()
n = filt.base.size
a = filt.base[-1]
b = filt.base[-2]
spacing = np.log(a) - np.log(b)
shift = np.log(a) - spacing * (n // 2)
cvar = 'amp'
r = np.logspace(0, 1.5, 100)
f.rhs = f.rhs(r)
k = filt.base / r[:, None]
rhs = np.dot(f.lhs(k), filt.j0) / r
rel_error = np.abs((rhs - f.rhs) / f.rhs)
imin = np.where(rel_error > 0.01)[0][0]
fdesign._plot_inversion(f, rhs, r, k, imin, spacing, shift, cvar)
return plt.gcf()
def test_design():
# 1. General case with various spacing and shifts
fI = (fdesign.j0_1(5), fdesign.j1_1(5))
dat1 = DATA['case1'][()]
_, out1 = fdesign.design(fI=fI, verb=0, plot=0, **dat1[0])
# First value is always the same.
# Second value jumps btw -2.722222 and -0.777778, so we don't check it.
assert_allclose(out1[0][0], dat1[2][0][0])
assert_allclose(out1[1], dat1[2][1], rtol=1e-3)
assert_allclose(out1[2], dat1[2][2])
# np.linalg(.qr) can have roundoff errors which are not deterministic,
# which can yield different results for badly conditioned matrices. This
# only affects the edge-cases, not the best result we are looking for.
# However, we have to limit the following comparison; we check that at
# least 50% are within a relative error of 0.1%.
rate = np.sum(np.abs((out1[3] - dat1[2][3]) / dat1[2][3]) < 1e-3)
assert rate > out1[3].size / 2
# 2. Specific model with only one spacing/shift
dat2 = DATA['case2'][()]
_, out2 = fdesign.design(fI=fI, verb=0, plot=0, **dat2[0])
assert_allclose(out2[0], dat2[2][0])
assert_allclose(out2[1], dat2[2][1], rtol=1e-3)
assert_allclose(out2[2], dat2[2][2])
assert_allclose(out2[3], dat2[2][3], rtol=1e-3)
# 3. Same, with only one transform
dat2b = DATA['case3'][()]
_, out2b = fdesign.design(fI=fI[0], verb=0, plot=0, **dat2b[0])
assert_allclose(out2b[0], dat2b[2][0])
assert_allclose(out2b[1], dat2b[2][1], rtol=1e-3)
assert_allclose(out2b[2], dat2b[2][2])
assert_allclose(out2b[3], dat2b[2][3], rtol=1e-3)
# 4.a Maximize r
dat4 = DATA['case4'][()]
dat4[0]['save'] = True
dat4[0]['name'] = 'tmpfilter'
_, out4 = fdesign.design(fI=fI, verb=0, plot=0, **dat4[0])
assert_allclose(out4[0], dat4[2][0])
assert_allclose(out4[1], dat4[2][1], rtol=1e-3)
assert_allclose(out4[2], dat4[2][2])
assert_allclose(out4[3], dat4[2][3], rtol=1e-3)
# Clean-up # Should be replaced eventually by tmpdir
os.remove('./filters/tmpfilter_base.txt')
os.remove('./filters/tmpfilter_j0.txt')
os.remove('./filters/tmpfilter_j1.txt')
os.remove('./filters/tmpfilter_full.txt')
# 4.b Without full output and all the other default inputs
dat4[0]['full_output'] = False
del dat4[0]['name']
dat4[0]['finish'] = 'Wrong input'
del dat4[0]['r']
dat4[0]['reim'] = np.imag # Set once to imag
fdesign.design(fI=fI, verb=2, plot=0, **dat4[0])
# Clean-up # Should be replaced eventually by tmpdir
os.remove('./filters/dlf_201_base.txt')
os.remove('./filters/dlf_201_j0.txt')
os.remove('./filters/dlf_201_j1.txt')
# 5. j2 for fI
with pytest.raises(ValueError, match="is only implemented for fC"):
fI2 = fdesign.empy_hankel('j2', 0, 50, 100, 1)
fdesign.design(fI=fI2, verb=0, plot=0, **dat4[0])
r"""Create data for test_fdesign."""
import numpy as np
from copy import deepcopy as dc
from empymod.scripts import fdesign
# Cannot pickle/shelve this; could dill it. For the moment, we just provide
# it separately here and in the tests.
fI = (fdesign.j0_1(5), fdesign.j1_1(5))
# Define main model
inp1 = {'spacing': (0.04, 0.1, 10),
'shift': (-3, -0.5, 10),
'n': 201,
'cvar': 'amp',
'save': False,
'full_output': True,
'r': np.logspace(0, 3, 10),
'r_def': (1, 1, 2),
'name': 'test',
'finish': None,
}
# 1. General case with various spacing and shifts
filt1, out1 = fdesign.design(verb=0, plot=0, fI=fI, **inp1)
case1 = (inp1, filt1, out1)
# 2. Specific model with only one spacing/shift
inp2 = dc(inp1)
inp2['spacing'] = 0.0641
inp2['shift'] = -1.2847
filt2, out2 = fdesign.design(verb=0, plot=0, fI=fI, **inp2)
