def get_args(freqtime, ft, ftarg):
time, freq, ft, ftarg = utils.check_time(
freqtime, signal, ft, ftarg, verb)
# Compute eta, zeta
etaH = 1/res + np.outer(2j*np.pi*freq, epermH*epsilon_0)
etaV = 1/(res*aniso*aniso) + np.outer(2j*np.pi*freq,
epermV*epsilon_0)
zetaH = np.outer(2j*np.pi*freq, mpermH*mu_0)
zetaV = np.outer(2j*np.pi*freq, mpermV*mu_0)
# `model.fem`-signature changed on 9bed72b0
# (29/04/2018; bef. v1.4.1)
inp = (ab, off, angle, zsrc, zrec, lsrc, lrec, depth, freq,
etaH, etaV, zetaH, zetaV, False, False, ht, htarg,
msrc, mrec, loop_freq, loop_off)
try:
if not VERSION2:
inp = (*inp[:17], use_ne_eval, *inp[17:])
out = model.fem(*inp)
except VariableCatch:
out = model.fem(*inp[:17], True, *inp[17:])
# `model.fem` returned in the beginning only fEM;
# then (fEM, kcount) and finally (fEM, kcount, conv).
if isinstance(out, tuple):
fEM = np.squeeze(out[0])
else:
fEM = np.squeeze(out)
return (fEM, time, freq, ftarg)
def set_frequency(self):
"""
Compute Frequency reqired for frequency to time transform
"""
if self.wave_type == "general":
_, frequency, ft, ftarg = check_time(
self.time_int, 0, 'sin',
{'pts_per_dec': 3, 'fftfilt': self.fftfilt}, 0
)
elif self.wave_type == "stepoff":
_, frequency, ft, ftarg = check_time(
self.time, 0, 'sin',
{'pts_per_dec': 3, 'fftfilt': self.fftfilt}, 0
)
else:
raise Exception("wave_type must be either general or stepoff")
self.frequency = frequency
self.ftarg = ftarg
def set_frequency(self):
"""
Compute Frequency reqired for frequency to time transform
"""
if self.wave_type == "general":
_, frequency, ft, ftarg = check_time(
self.time_int, 0, 'sin',
{'pts_per_dec': 3, 'fftfilt': self.fftfilt}, 0
)
elif self.wave_type == "stepoff":
_, frequency, ft, ftarg = check_time(
self.time, 0, 'sin',
{'pts_per_dec': 3, 'fftfilt': self.fftfilt}, 0
)
else:
raise Exception("wave_type must be either general or stepoff")
self.frequency = frequency
self.ftarg = ftarg
DC = test_time(res, off, 1000000, 1)
resp = DC - resp
return resp
# Time-domain solution
res = 20 # Ohm.m
off = 4000 # m
t = np.logspace(-1.5, 1, 20) # s
tEM0 = test_time(res, off, t, 0)
tEM1 = test_time(res, off, t, 1)
tEM2 = test_time(res, off, t, -1)
# # B -- FFTLog # #
# Signal = 0
_, f, _, ftarg = utils.check_time(t, 0, 'fftlog', ['', [-3, 2]], 0)
fEM = test_freq(res, off, f)
fftlog0 = {'fEM': fEM, 'f': f, 'ftarg': ftarg}
# Signal = 1
_, f, _, ftarg = utils.check_time(t, 1, 'fftlog', [30, [-3, 2], -.5], 0)
fEM = test_freq(res, off, f)
fftlog1 = {'fEM': fEM, 'f': f, 'ftarg': ftarg}
# Signal = -1
_, f, _, ftarg = utils.check_time(t, -1, 'fftlog', [30, [-5, 2], .1], 0)
fEM = test_freq(res, off, f)
fftlog2 = {'fEM': fEM, 'f': f, 'ftarg': ftarg}
# # C -- FFHT # #
# Signal = 0
_, f, _, ftarg = utils.check_time(t, 0, 'cos', None, 0)
fEM = test_freq(res, off, f)
inp4 = deepcopy(inp2)
inp4['loop_off'] = True
EM4, kcount4, _ = fem(**inp4)
# 5. 36/63
inp5 = deepcopy(inp2)
inp5['ab'] = 36
inp5['msrc'] = True
EM5, kcount5, _ = fem(**inp5)
# # B -- TEM # #
# Same parameters as for fem, except frequency, time, ab; plus signal
# ab = 22
time = [1, 2, 3]
time, freq, ft, ftarg = utils.check_time(time, 0, 'fftlog', None, 0)
frequency = utils.check_frequency(freq, res, aniso, epermH, epermV, mpermH,
mpermV, 0)
freq, etaH, etaV, zetaH, zetaV = frequency
tinp = deepcopy(inp2)
tinp['freq'] = freq
tinp['etaH'] = etaH
tinp['etaV'] = etaV
tinp['zetaH'] = zetaH
tinp['zetaV'] = zetaV
fEM, _, _ = fem(**tinp)
# 6. TIME; SIGNAL = 0
inp6 = {
'fEM': fEM,
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)
DC = test_time(res, off, 1000000, 1)
resp = DC - resp
return resp
# Time-domain solution
res = 20 # Ohm.m
off = 4000 # m
t = np.logspace(-1.5, 1, 20) # s
tEM0 = test_time(res, off, t, 0)
tEM1 = test_time(res, off, t, 1)
tEM2 = test_time(res, off, t, -1)
# # B -- Fourier FFTLog # #
# Signal = 0
_, f, _, ftarg = utils.check_time(t, 0, 'fftlog', {'add_dec': [-3, 2]}, 0)
fEM = test_freq(res, off, f)
fourier_fftlog0 = {'fEM': fEM, 'f': f, 'ftarg': ftarg}
# Signal = 1
_, f, _, ftarg = utils.check_time(t, 1, 'fftlog', {
'pts_per_dec': 30,
'add_dec': [-3, 2],
'q': -.5
}, 0)
fEM = test_freq(res, off, f)
fourier_fftlog1 = {'fEM': fEM, 'f': f, 'ftarg': ftarg}
# Signal = -1
_, f, _, ftarg = utils.check_time(t, -1, 'fftlog', {
'pts_per_dec': 30,
'add_dec': [-5, 2],
'q': .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)
def setup_cache(self):
"""setup_cache is not parametrized, so we do it manually. """
data = {}
for size in self.params[0]: # size
tdat = {}
# One big, one small model
if size == 'Small':
freqtime = np.array([2.])
else:
freqtime = np.logspace(-1, 1, 11)
# Define survey
lsrc = 1
lrec = 1
angle = np.array([0])
off = np.array([5000])
ab = 11
msrc = False
mrec = False
if VERSION2:
zsrc = 250.
zrec = 300.
else:
zsrc = np.array([250.]) # Not sure if this distinction
zrec = np.array([300.]) # is actually needed
use_ne_eval = False
# Define model
depth = np.array([-np.infty, 0, 300, 2000, 2100])
res = np.array([2e14, .3, 1, 50, 1])
aniso = np.ones(res.shape)
epermH = np.ones(res.shape)
epermV = np.ones(res.shape)
mpermH = np.ones(res.shape)
mpermV = np.ones(res.shape)
# Other parameters
verb = 0
loop_freq = True
loop_off = False
signal = 0
# Get Hankel arguments
if VERSION2:
ht, htarg = utils.check_hankel(
'dlf', {'pts_per_dec': -1}, verb)
else:
# `pts_per_dec` changed at 9bed72b0 (29/04/2018; bef. v1.4.1)
try:
ht, htarg = utils.check_hankel('fht', ['', -1], verb)
except VariableCatch:
# `check_hankel`-signature changed at c73d6647
try:
ht, htarg = utils.check_hankel('fht', None, verb)
except VariableCatch:
ht, htarg = utils.check_hankel('fht', None, ab, verb)
# Get frequency-domain stuff for time-domain computation
def get_args(freqtime, ft, ftarg):
time, freq, ft, ftarg = utils.check_time(
freqtime, signal, ft, ftarg, verb)
# Compute eta, zeta
etaH = 1/res + np.outer(2j*np.pi*freq, epermH*epsilon_0)
etaV = 1/(res*aniso*aniso) + np.outer(2j*np.pi*freq,
epermV*epsilon_0)
zetaH = np.outer(2j*np.pi*freq, mpermH*mu_0)
zetaV = np.outer(2j*np.pi*freq, mpermV*mu_0)
# `model.fem`-signature changed on 9bed72b0
# (29/04/2018; bef. v1.4.1)
inp = (ab, off, angle, zsrc, zrec, lsrc, lrec, depth, freq,
etaH, etaV, zetaH, zetaV, False, False, ht, htarg,
msrc, mrec, loop_freq, loop_off)
try:
if not VERSION2:
inp = (*inp[:17], use_ne_eval, *inp[17:])
out = model.fem(*inp)
except VariableCatch:
out = model.fem(*inp[:17], True, *inp[17:])
# `model.fem` returned in the beginning only fEM;
# then (fEM, kcount) and finally (fEM, kcount, conv).
if isinstance(out, tuple):
fEM = np.squeeze(out[0])
else:
fEM = np.squeeze(out)
return (fEM, time, freq, ftarg)
# Define function name of transform
fft_and_ffht = True
if VERSION2:
name_dlf = 'fourier_dlf'
name_fqwe = 'fourier_qwe'
name_fftlog = 'fourier_fftlog'
name_fft = 'fourier_fft'
else:
name_fqwe = 'fqwe'
name_fftlog = 'fftlog'
name_fft = 'fft'
# ffht used to be fft until the introduction of fft
try:
getattr(transform, 'ffht')
name_ffht = 'ffht'
except VariableCatch:
fft_and_ffht = False
name_ffht = 'fft'
name_dlf = name_ffht
# Store functions
tdat['fourier_dlf'] = getattr(transform, name_dlf)
tdat['fourier_qwe'] = getattr(transform, name_fqwe)
tdat['fourier_fftlog'] = getattr(transform, name_fftlog)
tdat['fourier_fft'] = getattr(transform, name_fft)
# Check default pts_per_dec to see if new or old case
if VERSION2:
old_case = False
else:
try:
test = utils.check_time(freqtime, signal, 'sin',
['key_201_CosSin_2012', 'test'], 0)
old_case = test[3][1] is None
except VariableCatch:
old_case = True
# Get fourier_dlf arguments
if old_case and not VERSION2:
tdat['dlf_st'] = () # Standard was not possible in old case
tdat['dlf_la'] = get_args(freqtime, name_ffht, None)
elif VERSION2:
tdat['dlf_st'] = get_args(
freqtime, 'dlf',
{'dlf': 'key_201_CosSin_2012', 'pts_per_dec': 0})
tdat['dlf_la'] = get_args(
freqtime, 'dlf',
{'dlf': 'key_201_CosSin_2012', 'pts_per_dec': -1})
else:
tdat['dlf_st'] = get_args(
freqtime, name_ffht, ['key_201_CosSin_2012', 0])
tdat['dlf_la'] = get_args(
freqtime, name_ffht, ['key_201_CosSin_2012', -1])
if VERSION2:
tdat['dlf_sp'] = get_args(
freqtime, 'dlf',
{'dlf': 'key_201_CosSin_2012', 'pts_per_dec': 10})
# Get fourier_qwe arguments
tdat['qwe'] = get_args(freqtime, 'qwe', {'pts_per_dec': 10})
# Get fourier_fftlog arguments
tdat['fftlog'] = get_args(freqtime, 'fftlog', {})
# Get fourier_fft arguments
tdat['fft'] = get_args(freqtime, 'fft', {})
else:
tdat['dlf_sp'] = get_args(
freqtime, name_ffht, ['key_201_CosSin_2012', 10])
# Get fourier_qwe arguments
tdat['qwe'] = get_args(freqtime, 'fqwe', ['', '', '', '', 10])
# Get fourier_fftlog arguments
tdat['fftlog'] = get_args(freqtime, 'fftlog', None)
# Get fourier_fft arguments
if fft_and_ffht:
tdat['fft'] = get_args(freqtime, 'fft', None)
else:
tdat['fft'] = () # Will fail
data[size] = tdat
return data
