def test_get_spline_values(): # 9. get_spline_values
# Check one example
filt = filters.key_81_CosSin_2009()
out, new_inp = transform.get_spline_values(filt, np.arange(1, 6), -1)
# Expected values
oout = np.array([[6.70925256e-05, 8.19469958e-05, 1.00090287e-04,
1.22250552e-04, 1.49317162e-04, 1.82376393e-04,
2.22755030e-04, 2.72073608e-04, 3.32311455e-04,
4.05886127e-04, 4.95750435e-04, 6.05510949e-04,
7.39572743e-04, 9.03316189e-04, 1.10331288e-03,
1.34758940e-03, 1.64594941e-03, 2.01036715e-03,
2.45546798e-03, 2.99911536e-03, 3.66312778e-03,
4.47415437e-03, 5.46474449e-03, 6.67465399e-03,
8.15244080e-03, 9.95741367e-03, 1.21620125e-02,
1.48547156e-02, 1.81435907e-02, 2.21606317e-02,
2.70670566e-02, 3.30597776e-02, 4.03793036e-02,
4.93193928e-02, 6.02388424e-02, 7.35758882e-02,
8.98657928e-02, 1.09762327e-01, 1.34064009e-01,
1.63746151e-01, 2.00000000e-01, 2.44280552e-01,
2.98364940e-01, 3.64423760e-01, 4.45108186e-01,
5.43656366e-01, 6.64023385e-01, 8.11039993e-01,
9.90606485e-01, 1.20992949e+00, 1.47781122e+00,
1.80500270e+00, 2.20463528e+00, 2.69274761e+00,
3.28892935e+00, 4.01710738e+00, 4.90650604e+00,
5.99282001e+00, 7.31964689e+00, 8.94023690e+00,
1.09196300e+01, 1.33372662e+01, 1.62901737e+01,
1.98968631e+01, 2.43020835e+01, 2.96826318e+01,
3.62544484e+01, 4.42812832e+01, 5.40852815e+01,
6.60599120e+01, 8.06857587e+01, 9.85498082e+01,
1.20369008e+02, 1.47019038e+02, 1.79569458e+02,
2.19326632e+02, 2.67886153e+02, 3.27196886e+02,
3.99639179e+02, 4.88120396e+02, 5.96191597e+02,
7.28190061e+02, 8.89413350e+02, 1.08633192e+03,
1.32684880e+03, 1.62061679e+03, 1.97942581e+03,
2.41767615e+03, 2.95295631e+03, 3.60674899e+03]])
onew_inp = np.array([5., 4.09365377, 3.35160023, 2.74405818, 2.24664482,
1.83939721, 1.50597106, 1.23298482, 1.00948259,
0.82649444])
# Comparison
assert_allclose(out, oout)
assert_allclose(new_inp, onew_inp)
# Ensure output dimension
hfilt = filters.anderson_801_1982()
out, _ = transform.get_spline_values(hfilt, np.array([1, 1.1]), -1)
assert_allclose(out.size, 804)
# Check a hypothetical short filter, with small pts_per_dec, and ensure
# at least four points are returned
filt = filters.DigitalFilter('shortest')
filt.base = np.array([1., 1.1])
out, new_inp = transform.get_spline_values(filt, np.array([1.]), 1)
assert_allclose(out.size, 4)
# Check standard example
ffilt = filters.key_81_CosSin_2009()
inp = np.arange(1, 6)
out, new_inp = transform.get_spline_values(ffilt, inp, 0)
assert_allclose(inp, new_inp)
assert_allclose(out, ffilt.base/inp[:, None])
def __init__(self, **kwargs):
BaseEM1DSurvey.__init__(self, **kwargs)
if self.time is None:
raise Exception("time is required!")
# Use Sin filter for frequency to time transform
self.fftfilt = filters.key_81_CosSin_2009()
self.set_frequency()
if self.src_type == "VMD":
if self.offset is None:
raise Exception("offset is required!")
if self.offset.size == 1:
self.offset = self.offset * np.ones(self.n_frequency)
def __init__(self, **kwargs):
BaseEM1DSurvey.__init__(self, **kwargs)
if self.time is None:
raise Exception("time is required!")
# Use Sin filter for frequency to time transform
self.fftfilt = filters.key_81_CosSin_2009()
self.set_frequency()
if self.src_type == "VMD":
if self.offset is None:
raise Exception("offset is required!")
if self.offset.size == 1:
self.offset = self.offset * np.ones(self.n_frequency)
def test_sincos():
# Check with Key81-filter if analytical transform pairs for sine and cosine
# are correct
filt = filters.key_81_CosSin_2009()
for sc in ['1', '2', '3']:
if sc == '1':
r = np.logspace(0, 0.7, 100)
else:
r = np.logspace(0, 1, 100)
k = filt.base / r[:, None]
tps = getattr(fdesign, 'sin_' + sc)()
tpc = getattr(fdesign, 'cos_' + sc)()
rhs1a = tps.rhs(r)
rhs1c = np.dot(tps.lhs(k), filt.sin) / r
assert_allclose(rhs1a, rhs1c, rtol=1e-3)
rhs2a = tpc.rhs(r)
rhs2c = np.dot(tpc.lhs(k), filt.cos) / r
assert_allclose(rhs2a, rhs2c, rtol=1e-3)
# Check inverse
for sc in ['1', '2', '3']:
if sc == '1':
r = np.logspace(0, 0.7, 100)
else:
r = np.logspace(0, 1, 100)
k = filt.base / r[:, None]
tps = getattr(fdesign, 'sin_' + sc)()
tpc = getattr(fdesign, 'cos_' + sc)()
tps_i = getattr(fdesign, 'sin_' + sc)(inverse=True)
tpc_i = getattr(fdesign, 'cos_' + sc)(inverse=True)
rhs1a = tps.rhs(r)
rhs1c = tps_i.lhs(r)
assert_allclose(rhs1a, rhs1c)
rhs2a = tpc.rhs(r)
rhs2c = tpc_i.lhs(r)
assert_allclose(rhs2a, rhs2c)
def test_check_time(capsys):
time = np.array([3])
# # DLF # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'dlf', {}, 4)
out, _ = capsys.readouterr()
assert " time [s] : 3" in out
assert " Fourier : DLF (Sine-Filter)" in out
assert "> DLF type : Lagged Convolution" in out
assert ft == 'dlf'
assert ftarg['dlf'].name == filters.key_201_CosSin_2012().name
assert ftarg['pts_per_dec'] == -1
f1 = np.array([
4.87534752e-08, 5.60237934e-08, 6.43782911e-08, 7.39786458e-08,
8.50106448e-08, 9.76877807e-08, 1.12255383e-07, 1.28995366e-07,
1.48231684e-07
])
f2 = np.array([
2.88109455e+04, 3.31073518e+04, 3.80444558e+04, 4.37178011e+04,
5.02371788e+04, 5.77287529e+04, 6.63375012e+04, 7.62300213e+04,
8.75977547e+04
])
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 201 + 3)
assert ftarg['kind'] == 'sin'
# filter-string and unknown parameter
_, f, _, ftarg = utils.check_time(time, -1, 'dlf', {
'dlf': 'key_201_CosSin_2012',
'kind': 'cos',
'notused': 1
}, 4)
out, _ = capsys.readouterr()
outstr = " time [s] : 3\n"
outstr += " Fourier : DLF (Cosine-Filter)\n > Filter"
assert outstr in out
assert "WARNING :: Unknown ftarg {'notused': 1} for method 'dlf'" in out
assert ft == 'dlf'
assert ftarg['dlf'].name == filters.key_201_CosSin_2012().name
assert ftarg['pts_per_dec'] == -1
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 201 + 3)
assert ftarg['kind'] == 'cos'
# filter instance
_, _, _, ftarg = utils.check_time(time, 1, 'dlf', {
'dlf': filters.key_201_CosSin_2012(),
'kind': 'sin'
}, 0)
assert ftarg['dlf'].name == filters.key_201_CosSin_2012().name
assert ftarg['pts_per_dec'] == -1
assert ftarg['kind'] == 'sin'
# pts_per_dec
out, _ = capsys.readouterr() # clear buffer
_, _, _, ftarg = utils.check_time(time, 0, 'dlf', {'pts_per_dec': 30}, 4)
assert ftarg['dlf'].name == filters.key_201_CosSin_2012().name
assert ftarg['pts_per_dec'] == 30
assert ftarg['kind'] == 'sin'
out, _ = capsys.readouterr()
assert " > DLF type : Splined, 30.0 pts/dec" in out
# filter-string and pts_per_dec
_, _, _, ftarg = utils.check_time(time, 0, 'dlf', {
'dlf': 'key_81_CosSin_2009',
'pts_per_dec': -1,
'kind': 'cos'
}, 4)
out, _ = capsys.readouterr()
assert " > DLF type : Lagged Convolution" in out
assert ftarg['dlf'].name == filters.key_81_CosSin_2009().name
assert ftarg['pts_per_dec'] == -1
assert ftarg['kind'] == 'cos'
# pts_per_dec
_, freq, _, ftarg = utils.check_time(time, 0, 'dlf', {
'pts_per_dec': 0,
'kind': 'sin'
}, 4)
out, _ = capsys.readouterr()
assert " > DLF type : Standard" in out
assert ftarg['pts_per_dec'] == 0
f_base = filters.key_201_CosSin_2012().base
assert_allclose(np.ravel(f_base / (2 * np.pi * time[:, None])), freq)
# filter-string and pts_per_dec
_, _, _, ftarg = utils.check_time(time, 0, 'dlf', {
'dlf': 'key_81_CosSin_2009',
'pts_per_dec': 50,
'kind': 'cos'
}, 0)
assert ftarg['dlf'].name == filters.key_81_CosSin_2009().name
assert ftarg['pts_per_dec'] == 50
assert ftarg['kind'] == 'cos'
# just kind
_, f, _, ftarg = utils.check_time(time, 0, 'dlf', {'kind': 'sin'}, 0)
assert ftarg['pts_per_dec'] == -1
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 204)
# Assert it can be called repetitively
_, _ = capsys.readouterr()
_, _, _, ftarg = utils.check_time(time, 0, 'dlf', {}, 1)
_, _, _, _ = utils.check_time(time, 0, 'dlf', ftarg, 1)
out, _ = capsys.readouterr()
assert out == ""
# # QWE # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'qwe', {}, 4)
out, _ = capsys.readouterr()
outstr = " Fourier : Quadrature-with-Extrapolation\n > rtol"
assert out[24:87] == outstr
assert ft == 'qwe'
assert ftarg['rtol'] == 1e-8
assert ftarg['atol'] == 1e-20
assert ftarg['nquad'] == 21
assert ftarg['maxint'] == 200
assert ftarg['pts_per_dec'] == 20
assert ftarg['diff_quad'] == 100
f1 = np.array([
3.16227766e-03, 3.54813389e-03, 3.98107171e-03, 4.46683592e-03,
5.01187234e-03, 5.62341325e-03, 6.30957344e-03, 7.07945784e-03,
7.94328235e-03
])
f2 = np.array([
1.00000000e+02, 1.12201845e+02, 1.25892541e+02, 1.41253754e+02,
1.58489319e+02, 1.77827941e+02, 1.99526231e+02, 2.23872114e+02,
2.51188643e+02
])
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 99)
assert ftarg['a'] is None
assert ftarg['b'] is None
assert ftarg['limit'] is None
assert ftarg['sincos'] is np.sin
# only limit
_, _, _, ftarg = utils.check_time(time, 1, 'qwe', {'limit': 30}, 0)
assert ftarg['rtol'] == 1e-8
assert ftarg['atol'] == 1e-20
assert ftarg['nquad'] == 21
assert ftarg['maxint'] == 200
assert ftarg['pts_per_dec'] == 20
assert ftarg['diff_quad'] == 100
assert ftarg['a'] is None
assert ftarg['b'] is None
assert ftarg['limit'] == 30
assert ftarg['sincos'] is np.sin
# all arguments
_, _, _, ftarg = utils.check_time(
time, -1, 'qwe', {
'rtol': 1e-3,
'atol': 1e-4,
'nquad': 31,
'maxint': 20,
'pts_per_dec': 30,
'diff_quad': 200,
'a': 0.01,
'b': 0.2,
'limit': 100
}, 3)
out, _ = capsys.readouterr()
assert " > a (quad): 0.01" in out
assert " > b (quad): 0.2" in out
assert " > limit (quad): 100" in out
assert ftarg['rtol'] == 1e-3
assert ftarg['atol'] == 1e-4
assert ftarg['nquad'] == 31
assert ftarg['maxint'] == 20
assert ftarg['pts_per_dec'] == 30
assert ftarg['diff_quad'] == 200
assert ftarg['a'] == 0.01
assert ftarg['b'] == 0.2
assert ftarg['limit'] == 100
assert ftarg['sincos'] is np.cos
# Assert it can be called repetitively
_, _ = capsys.readouterr()
_, _, _, ftarg = utils.check_time(time, 0, 'qwe', {}, 1)
_, _, _, _ = utils.check_time(time, 0, 'qwe', ftarg, 1)
out, _ = capsys.readouterr()
assert out == ""
# # FFTLog # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'fftlog', {}, 4)
out, _ = capsys.readouterr()
outstr = " Fourier : FFTLog\n > pts_per_dec"
assert outstr in out
assert ft == 'fftlog'
assert ftarg['pts_per_dec'] == 10
assert_allclose(ftarg['add_dec'], np.array([-2., 1.]))
assert ftarg['q'] == 0
tres = np.array([
0.3571562, 0.44963302, 0.56605443, 0.71262031, 0.89713582, 1.12942708,
1.42186445, 1.79002129, 2.25350329, 2.83699255, 3.57156202, 4.49633019,
5.66054433, 7.1262031, 8.97135818, 11.29427079, 14.2186445,
17.90021288, 22.53503287, 28.36992554, 35.71562019, 44.96330186,
56.60544331, 71.26203102, 89.71358175, 112.94270785, 142.18644499,
179.00212881, 225.35032873, 283.69925539
])
assert ftarg['mu'] == 0.5
assert_allclose(ftarg['tcalc'], tres)
assert_allclose(ftarg['dlnr'], 0.23025850929940461)
assert_allclose(ftarg['kr'], 1.0610526667295022)
assert_allclose(ftarg['rk'], 0.016449035064149849)
fres = np.array([
0.00059525, 0.00074937, 0.00094341, 0.00118768, 0.0014952, 0.00188234,
0.00236973, 0.00298331, 0.00375577, 0.00472823, 0.00595249, 0.00749374,
0.00943407, 0.01187678, 0.01495199, 0.01882343, 0.0236973, 0.02983313,
0.03755769, 0.04728233, 0.05952493, 0.07493744, 0.09434065, 0.11876785,
0.14951986, 0.18823435, 0.23697301, 0.29833134, 0.3755769, 0.47282331
])
assert_allclose(f, fres, rtol=1e-5)
# Several parameters
_, _, _, ftarg = utils.check_time(time, -1, 'fftlog', {
'pts_per_dec': 10,
'add_dec': [-3, 4],
'q': 2
}, 0)
assert ftarg['pts_per_dec'] == 10
assert_allclose(ftarg['add_dec'], np.array([-3., 4.]))
assert ftarg['q'] == 1 # q > 1 reset to 1...
assert ftarg['mu'] == -0.5
assert_allclose(ftarg['dlnr'], 0.23025850929940461)
assert_allclose(ftarg['kr'], 0.94312869748639161)
assert_allclose(ftarg['rk'], 1.8505737940600746)
# Assert it can be called repetitively
_, _ = capsys.readouterr()
_, _, _, ftarg = utils.check_time(time, 0, 'fftlog', {}, 1)
_, _, _, _ = utils.check_time(time, 0, 'fftlog', ftarg, 1)
out, _ = capsys.readouterr()
assert out == ""
# # FFT # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'fft', {}, 4)
out, _ = capsys.readouterr()
assert "Fourier : Fast Fourier Transform FFT\n > dfreq" in out
assert " > pts_per_dec : (linear)" in out
assert ft == 'fft'
assert ftarg['dfreq'] == 0.002
assert ftarg['nfreq'] == 2048
assert ftarg['ntot'] == 2048
assert ftarg['pts_per_dec'] is None
fres = np.array(
[0.002, 0.004, 0.006, 0.008, 0.01, 4.088, 4.09, 4.092, 4.094, 4.096])
assert_allclose(f[:5], fres[:5])
assert_allclose(f[-5:], fres[-5:])
# Several parameters
_, _, _, ftarg = utils.check_time(time, 0, 'fft', {
'dfreq': 1e-3,
'nfreq': 2**15 + 1,
'ntot': 3
}, 0)
assert ftarg['dfreq'] == 0.001
assert ftarg['nfreq'] == 2**15 + 1
assert ftarg['ntot'] == 2**16
# Several parameters; pts_per_dec
_, f, _, ftarg = utils.check_time(time, 0, 'fft', {'pts_per_dec': 5}, 3)
out, _ = capsys.readouterr()
assert " > pts_per_dec : 5" in out
assert ftarg['dfreq'] == 0.002
assert ftarg['nfreq'] == 2048
assert ftarg['ntot'] == 2048
assert ftarg['pts_per_dec'] == 5
outf = np.array([
2.00000000e-03, 3.22098066e-03, 5.18735822e-03, 8.35419026e-03,
1.34543426e-02, 2.16680888e-02, 3.48962474e-02, 5.62000691e-02,
9.05096680e-02, 1.45764945e-01, 2.34753035e-01, 3.78067493e-01,
6.08874043e-01, 9.80585759e-01, 1.57922389e+00, 2.54332480e+00,
4.09600000e+00
])
assert_allclose(f, outf)
# Assert it can be called repetitively
_, _ = capsys.readouterr()
_, _, _, ftarg = utils.check_time(time, 0, 'fft', {}, 1)
_, _, _, _ = utils.check_time(time, 0, 'fft', ftarg, 1)
out, _ = capsys.readouterr()
assert out == ""
# # Various # #
# minimum time
_ = utils.check_time(0, 0, 'dlf', {
'dlf': 'key_201_CosSin_2012',
'kind': 'cos'
}, 1)
out, _ = capsys.readouterr()
assert out[:21] == "* WARNING :: Times < "
# Signal != -1, 0, 1
with pytest.raises(ValueError):
utils.check_time(time, -2, 'dlf', {}, 0)
# ft != cos, sin, dlf, qwe, fftlog,
with pytest.raises(ValueError):
utils.check_time(time, 0, 'bla', {}, 0)
# filter missing attributes
with pytest.raises(AttributeError):
utils.check_time(time, 0, 'dlf', {'dlf': 'key_201_2012'}, 1)
# filter with wrong kind
with pytest.raises(ValueError):
utils.check_time(time, 0, 'dlf', {'kind': 'wrongkind'}, 1)
def test_check_time(capsys):
time = np.array([3])
# # FFHT # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'ffht', None, 4)
out, _ = capsys.readouterr()
assert " time [s] : 3" in out
assert " Fourier : DLF (Sine-Filter)" in out
assert "> DLF type : Lagged Convolution" in out
assert ft == 'ffht'
assert ftarg[0].name == filters.key_201_CosSin_2012().name
assert ftarg[1] is -1
f1 = np.array([
4.87534752e-08, 5.60237934e-08, 6.43782911e-08, 7.39786458e-08,
8.50106448e-08, 9.76877807e-08, 1.12255383e-07, 1.28995366e-07,
1.48231684e-07
])
f2 = np.array([
2.88109455e+04, 3.31073518e+04, 3.80444558e+04, 4.37178011e+04,
5.02371788e+04, 5.77287529e+04, 6.63375012e+04, 7.62300213e+04,
8.75977547e+04
])
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 201 + 3)
assert ftarg[2] == 'sin'
# [filter str]
_, f, _, ftarg = utils.check_time(time, -1, 'cos', 'key_201_CosSin_2012',
4)
out, _ = capsys.readouterr()
outstr = " time [s] : 3\n"
outstr += " Fourier : DLF (Cosine-Filter)\n > Filter"
assert out[:79] == outstr
assert ft == 'ffht'
assert ftarg[0].name == filters.key_201_CosSin_2012().name
assert ftarg[1] is -1
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 201 + 3)
assert ftarg[2] == 'cos'
# [filter inst]
_, _, _, ftarg = utils.check_time(time, 1, 'sin',
filters.key_201_CosSin_2012(), 0)
assert ftarg[0].name == filters.key_201_CosSin_2012().name
assert ftarg[1] is -1
assert ftarg[2] == 'sin'
# ['', pts_per_dec]
out, _ = capsys.readouterr() # clear buffer
_, _, _, ftarg = utils.check_time(time, 0, 'ffht', ['', 30], 4)
assert ftarg[0].name == filters.key_201_CosSin_2012().name
assert ftarg[1] == 30
assert ftarg[2] == 'sin'
out, _ = capsys.readouterr()
assert " > DLF type : Splined, 30 pts/dec" in out
# [filter str, pts_per_dec]
_, _, _, ftarg = utils.check_time(time, 0, 'cos',
['key_81_CosSin_2009', -1], 4)
out, _ = capsys.readouterr()
assert " > DLF type : Lagged Convolution" in out
assert ftarg[0].name == filters.key_81_CosSin_2009().name
assert ftarg[1] == -1
assert ftarg[2] == 'cos'
# ['', 0]
_, freq, _, ftarg = utils.check_time(time, 0, 'sin', {'pts_per_dec': 0}, 4)
out, _ = capsys.readouterr()
assert " > DLF type : Standard" in out
assert ftarg[1] == 0
f_base = filters.key_201_CosSin_2012().base
assert_allclose(np.ravel(f_base / (2 * np.pi * time[:, None])), freq)
# [filter str, pts_per_dec] :: dict, deprecated
_, _, _, ftarg = utils.check_time(time, 0, 'cos', {
'fftfilt': 'key_81_CosSin_2009',
'pts_per_dec': 50
}, 0)
assert ftarg[0].name == filters.key_81_CosSin_2009().name
assert ftarg[1] == 50
assert ftarg[2] == 'cos'
# ['', 0] :: dict, deprecated
_, f, _, ftarg = utils.check_time(time, 0, 'sin', {'pts_per_dec': None}, 0)
assert ftarg[1] == -1
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 204)
# # QWE # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'qwe', None, 4)
out, _ = capsys.readouterr()
outstr = " Fourier : Quadrature-with-Extrapolation\n > rtol"
assert out[24:87] == outstr
assert ft == 'fqwe'
assert_allclose(ftarg[:-4], [1e-8, 1e-20, 21, 200, 20, 100])
f1 = np.array([
3.16227766e-03, 3.54813389e-03, 3.98107171e-03, 4.46683592e-03,
5.01187234e-03, 5.62341325e-03, 6.30957344e-03, 7.07945784e-03,
7.94328235e-03
])
f2 = np.array([
1.00000000e+02, 1.12201845e+02, 1.25892541e+02, 1.41253754e+02,
1.58489319e+02, 1.77827941e+02, 1.99526231e+02, 2.23872114e+02,
2.51188643e+02
])
assert_allclose(f[:9], f1)
assert_allclose(f[-9:], f2)
assert_allclose(f.size, 99)
assert ftarg[-4] is None
assert ftarg[-3] is None
assert ftarg[-2] is None
assert ftarg[-1] is np.sin
# only last argument
_, _, _, ftarg = utils.check_time(time, 1, 'fqwe',
['', '', '', '', '', '', '', '', 30], 0)
assert_allclose(ftarg[:-4], [1e-8, 1e-20, 21, 200, 20, 100])
assert ftarg[-4] is None
assert ftarg[-3] is None
assert ftarg[-2] == 30
assert ftarg[-1] is np.sin
# all arguments
_, _, _, ftarg = utils.check_time(
time, -1, 'qwe', [1e-3, 1e-4, 31, 20, 30, 200, 0.01, .2, 100], 3)
out, _ = capsys.readouterr()
assert " > a (quad): 0.01" in out
assert " > b (quad): 0.2" in out
assert " > limit (quad): 100" in out
assert_allclose(ftarg[:-1], [1e-3, 1e-4, 31, 20, 30, 200, 0.01, .2, 100])
assert ftarg[-1] is np.cos
# # FFTLog # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'fftlog', None, 4)
out, _ = capsys.readouterr()
outstr = " Fourier : FFTLog\n > pts_per_dec"
assert outstr in out
assert ft == 'fftlog'
assert ftarg[0] == 10
assert_allclose(ftarg[1], np.array([-2., 1.]))
assert ftarg[2] == 0
tres = np.array([
0.3571562, 0.44963302, 0.56605443, 0.71262031, 0.89713582, 1.12942708,
1.42186445, 1.79002129, 2.25350329, 2.83699255, 3.57156202, 4.49633019,
5.66054433, 7.1262031, 8.97135818, 11.29427079, 14.2186445,
17.90021288, 22.53503287, 28.36992554, 35.71562019, 44.96330186,
56.60544331, 71.26203102, 89.71358175, 112.94270785, 142.18644499,
179.00212881, 225.35032873, 283.69925539
])
assert ftarg[3] == 0.5
assert_allclose(ftarg[4], tres)
assert_allclose(
ftarg[5:],
[0.23025850929940461, 1.0610526667295022, 0.016449035064149849])
fres = np.array([
0.00059525, 0.00074937, 0.00094341, 0.00118768, 0.0014952, 0.00188234,
0.00236973, 0.00298331, 0.00375577, 0.00472823, 0.00595249, 0.00749374,
0.00943407, 0.01187678, 0.01495199, 0.01882343, 0.0236973, 0.02983313,
0.03755769, 0.04728233, 0.05952493, 0.07493744, 0.09434065, 0.11876785,
0.14951986, 0.18823435, 0.23697301, 0.29833134, 0.3755769, 0.47282331
])
assert_allclose(f, fres, rtol=1e-5)
# Several parameters
_, _, _, ftarg = utils.check_time(time, -1, 'fftlog', [10, [-3, 4], 2], 0)
assert ftarg[0] == 10
assert_allclose(ftarg[1], np.array([-3., 4.]))
assert ftarg[2] == 1 # q > 1 reset to 1...
assert ftarg[3] == -0.5
assert_allclose(
ftarg[5:],
[0.23025850929940461, 0.94312869748639161, 1.8505737940600746])
# # FFT # #
# verbose
_, f, ft, ftarg = utils.check_time(time, 0, 'fft', None, 4)
out, _ = capsys.readouterr()
assert "Fourier : Fast Fourier Transform FFT\n > dfreq" in out
assert " > pts_per_dec : (linear)" in out
assert ft == 'fft'
assert ftarg[0] == 0.002
assert ftarg[1] == 2048
assert ftarg[2] == 2048
assert ftarg[3] is None
fres = np.array(
[0.002, 0.004, 0.006, 0.008, 0.01, 4.088, 4.09, 4.092, 4.094, 4.096])
assert_allclose(f[:5], fres[:5])
assert_allclose(f[-5:], fres[-5:])
# Several parameters
_, _, _, ftarg = utils.check_time(time, 0, 'fft', [1e-3, 2**15 + 1, 3], 0)
assert ftarg[0] == 0.001
assert ftarg[1] == 2**15 + 1
assert ftarg[2] == 2**16
# Several parameters; pts_per_dec
_, f, _, ftarg = utils.check_time(time, 0, 'fft', ['', '', '', 5], 3)
out, _ = capsys.readouterr()
assert " > pts_per_dec : 5" in out
assert ftarg[0] == 0.002
assert ftarg[1] == 2048
assert ftarg[2] == 2048
assert ftarg[3] == 5
outf = np.array([
2.00000000e-03, 3.22098066e-03, 5.18735822e-03, 8.35419026e-03,
1.34543426e-02, 2.16680888e-02, 3.48962474e-02, 5.62000691e-02,
9.05096680e-02, 1.45764945e-01, 2.34753035e-01, 3.78067493e-01,
6.08874043e-01, 9.80585759e-01, 1.57922389e+00, 2.54332480e+00,
4.09600000e+00
])
assert_allclose(f, outf)
# # Various # #
# minimum time
_ = utils.check_time(0, 0, 'cos', 'key_201_CosSin_2012', 1)
out, _ = capsys.readouterr()
assert out[:21] == "* WARNING :: Times < "
# Signal != -1, 0, 1
with pytest.raises(ValueError):
utils.check_time(time, -2, 'ffht', None, 0)
# ft != cos, sin, ffht, qwe, hqwe, fftlog,
with pytest.raises(ValueError):
utils.check_time(time, 0, 'fht', None, 0)
