def test_zerofreq():
dt = 0.01
n = 700
f = np.zeros(n, float)
f[10:110] = 1.0 # area = 1
f[110:210] = -1.0 # area = -1
f[300:400] = -1.0
f[400:500] = 1.0
frq = 0.0
sh, resp = srs.srs(f, 1 / dt, frq, 25, stype="relacce", getresp=True)
np.allclose(resp["hist"][:, 0, 0], -f)
sh, resp = srs.srs(f, 1 / dt, frq, 25, stype="relvelo", getresp=True)
np.allclose(resp["hist"][110, 0, 0], -1.0)
np.allclose(resp["hist"][210:400, 0, 0], 0.0)
np.allclose(resp["hist"][400, 0, 0], 1.0)
np.allclose(resp["hist"][500:, 0, 0], 0.0)
sh, resp = srs.srs(f, 1 / dt, frq, 25, stype="reldisp", getresp=True)
# area under velo triangle = -1 @ 210
np.allclose(resp["hist"][210:300, 0, 0], -1.0)
# comes back to initial position after second velo triangle:
np.allclose(resp["hist"][500:, 0, 0], 0.0)
for stype in ["absacce", "pvelo", "pacce"]:
sh, resp = srs.srs(f, 1 / dt, frq, 25, stype=stype, getresp=True)
np.allclose(sh, 0.0)
np.allclose(resp["hist"], 0.0)
def test_odd_fft_srs():
t = np.linspace(0, 3, 101)
sr = 1 / t[1] # 1/.03 = 33
sig = np.sin(2 * np.pi * 2 * t)
Q = 35
frq = 5.0
sh1 = srs.srs(sig, sr, frq, Q, rolloff="fft")
sh2 = srs.srs(sig[:-1], sr, frq, Q, rolloff="fft")
assert np.allclose(sh1, sh2)
def test_auto_parallel():
sr = 1000
t = np.arange(0, 5, 1 / sr)
sig = np.ones((11, 1)).dot(np.sin(2 * np.pi * 15 * t)[None, :]).T
# 1000 * 5 * 11 = 75000
Q = 35
frq = np.linspace(5, 50, 5)
sh = srs.srs(sig, sr, frq, Q)
sh1 = srs.srs(sig, sr, frq, Q, parallel="no", maxcpu=None)
assert np.allclose(sh, sh1)
sh1 = srs.srs(sig, sr, frq, Q, parallel="auto", maxcpu=None)
assert np.allclose(sh, sh1)
sh1 = srs.srs(sig, sr, frq, Q, parallel="yes", maxcpu=2)
assert np.allclose(sh, sh1)
def test_eqsine():
sr = 200
t = np.arange(0, 5, 1 / sr)
sig = np.ones((11, 1)).dot(np.sin(2 * np.pi * 15 * t)[None, :])
Q = 35
frq = np.linspace(5, 10, 5)
sh = srs.srs(sig, sr, frq, Q, rolloff="none", eqsine=1)
sh1 = srs.srs(sig, sr, frq, Q, rolloff="none") / Q
assert np.allclose(sh, sh1)
sh, resp = srs.srs(sig, sr, frq, Q, rolloff="none", eqsine=1, getresp=1)
sh1, resp1 = srs.srs(sig, sr, frq, Q, rolloff="none", getresp=1)
assert np.allclose(sh, sh1 / Q)
assert np.all(resp["t"] == resp1["t"])
assert np.allclose(resp["hist"], resp1["hist"] / Q)
def test_srs_multiple_signals():
Q, freq, nfreq, j, k, sr, t, w, B, K, cut, zdd = get_params_2()
ic = "zero"
zdd = zdd[:cut]
zddm = np.vstack((zdd, zdd, zdd)).T
for stype in [
"absacce", "relacce", "relvelo", "reldisp", "pacce", "pvelo"
]:
for time in ["primary", "total", "residual"]:
for ic in ["steady", "shift", "zero", "mshift"]:
sh = srs.srs(zdd, sr, freq, Q, ic=ic, stype=stype, time=time)
shr, resp = srs.srs(zdd,
sr,
freq,
Q,
ic=ic,
stype=stype,
time=time,
getresp=True)
shm = srs.srs(zddm, sr, freq, Q, ic=ic, stype=stype, time=time)
shmr, respm = srs.srs(zddm,
sr,
freq,
Q,
ic=ic,
stype=stype,
time=time,
getresp=True)
assert np.all(sh.shape == (nfreq, ))
assert np.all(sh.shape == shr.shape)
assert np.all(shm.shape == (nfreq, 3))
assert np.all(shm.shape == shmr.shape)
assert np.all(resp["t"] == respm["t"])
assert resp["sr"] == respm["sr"]
resp_sz = len(resp["t"]), 1, nfreq
respm_sz = len(resp["t"]), 3, nfreq
assert np.all(resp["hist"].shape == resp_sz)
assert np.all(respm["hist"].shape == respm_sz)
for i in range(3):
assert np.all(shm[:, i] == sh)
assert np.all(shmr[:, i] == shr)
assert np.all(resp["hist"][:, 0] == respm["hist"][:, i])
def test_srsmap():
from pyyeti import ytools, dsp
sig, ts, fs = ytools.gensweep(10, 1, 50, 4)
sr = 1 / ts[1]
frq = np.arange(1.0, 50.1)
Q = 20
mp, t, f = srs.srsmap(2, 0.5, sig, sr, frq, Q, 0.02, eqsine=1)
assert np.all(f == frq)
dt = 1.0
segments = int(np.floor(ts[-1] / dt)) - 1
assert len(t) == segments
t_should_be = np.arange(segments) * dt + dt
assert np.allclose(t, t_should_be)
# test segment 63:
seg = 63
pv = np.logical_and(ts >= t[seg] - dt, ts < t[seg] + dt)
sh = srs.srs(dsp.windowends(sig[pv], 0.02), sr, frq, Q, eqsine=1)
assert np.allclose(sh, mp[:, seg])
def test_srs_rolloff():
sr = 200
t = np.arange(0, 5, 1 / sr)
offset = 12
sig = np.sin(2 * np.pi * 15 * t) + 3 * np.sin(2 * np.pi * 35 * t) + offset
Q = 50
frq = [5, 10, 35, 38]
sh1 = srs.srs(sig, sr, frq, Q, rolloff="fft", ppc=5)
sh2 = srs.srs(sig, sr, frq, Q, rolloff=None, ppc=5)
sh3 = srs.srs(sig, sr, frq, Q, rolloff="none", ppc=5)
sh4 = srs.srs(sig, sr, frq, Q, rolloff="lanczos", ppc=5)
assert np.all(sh1 == sh2)
assert np.all(sh1 == sh3)
assert np.all(sh1 == sh4)
sh1 = srs.srs(sig, sr, frq, Q, rolloff="fft", ppc=10)
assert np.all(sh1 >= sh2)
sh2 = srs.srs(sig, sr, frq, Q, rolloff="fft", ppc=15)
sh1_fft = sh1
sh2_fft = sh2
# compare sh1, sh2; first two should nearly match:
assert abs(sh1[:2] - sh2[:2]).max() < 0.005 * abs(sh1[:2]).max()
# sh2 should be higher on other 2:
assert np.all(sh2[2:] > sh1[2:])
assert np.max(sh2) > 140 + offset and np.max(sh2) < 160 + offset
sh1, resp = srs.srs(sig, sr, frq, Q, rolloff="fft", ppc=15, getresp=True)
assert sh1[0] >= sh2[0]
assert sh1[-1] == sh2[-1]
sh1l = srs.srs(sig, sr, frq, Q, rolloff="linear", ppc=15)
assert sh1l[0] < sh2[0]
assert sh1l[-1] < sh2[-1]
# prefilter doesn't pay attention to the ppc; if input, it's
# just used:
sh1 = srs.srs(sig, sr, frq, Q, rolloff="prefilter", ppc=5)
sh2, resp = srs.srs(sig,
sr,
frq,
Q,
rolloff="prefilter",
ppc=15,
getresp=True)
assert np.all(sh1 == sh2)
sh1 = srs.srs(sig, sr, frq, Q, rolloff="lanczos", ppc=10)
# compare sh1, sh4; first two should nearly match:
assert abs(sh1[:2] - sh4[:2]).max() < 0.005 * abs(sh1[:2]).max()
# sh1 should be higher on other 2:
assert np.all(sh1[2:] > sh4[2:])
sh2 = srs.srs(sig, sr, frq, Q, rolloff="lanczos", ppc=15)
# compare sh1, sh2; first two should nearly match:
assert abs(sh1[:2] - sh2[:2]).max() < 0.005 * abs(sh1[:2]).max()
# sh2 should be higher on other 2:
assert np.all(sh2[2:] > sh1[2:])
assert np.max(sh2) > 140 + offset and np.max(sh2) < 160 + offset
# compare lanczos to fft ... should be pretty close:
assert abs(sh1_fft - sh1).max() < 0.001 * abs(sh1).max()
assert abs(sh2_fft - sh2).max() < 0.001 * abs(sh2).max()
# print('10: ', sh1, sh1_fft_10, sh1-sh1_fft_10, sh1l)
# print('15: ', sh2, sh2_fft_15, sh2-sh2_fft_15)
# test passing in functions
def rmsmeth(resp):
return np.sqrt(np.mean(resp**2, axis=0))
sh1 = srs.srs(sig, sr, frq, Q, rolloff=srs.fftroll, peak=rmsmeth)
sh2 = srs.srs(sig, sr, frq, Q, rolloff="fft", peak="rms")
assert np.all(sh1 == sh2)
sh1, resp1 = srs.srs(sig,
sr,
frq,
Q,
rolloff=srs.fftroll,
peak=rmsmeth,
getresp=True)
sh2, resp2 = srs.srs(sig,
sr,
frq,
Q,
rolloff="fft",
peak="rms",
getresp=True)
assert np.all(sh1 == sh2)
assert np.all(resp1["hist"] == resp2["hist"])
def do_srs_sol(
zdd,
sr,
freq,
Q,
ic="steady",
stype="absacce",
ppc=10,
rolloff="fft",
eqsine=False,
time="primary",
parallel="auto",
):
sh, resp = srs.srs(
zdd,
sr,
freq,
Q,
getresp=True,
ic=ic,
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
sh1 = srs.srs(
zdd,
sr,
freq,
Q,
ic=ic,
peak="abs",
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
shpos = srs.srs(
zdd,
sr,
freq,
Q,
ic=ic,
peak="pos",
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
shneg = srs.srs(
zdd,
sr,
freq,
Q,
ic=ic,
peak="neg",
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
shposs = srs.srs(
zdd,
sr,
freq,
Q,
ic=ic,
peak="poss",
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
shnegs = srs.srs(
zdd,
sr,
freq,
Q,
ic=ic,
peak="negs",
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
shrms = srs.srs(
zdd,
sr,
freq,
Q,
ic=ic,
peak="rms",
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
sh0, resp0 = srs.srs(
zdd[0],
sr,
freq,
Q,
getresp=True,
ic=ic,
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
sh01 = srs.srs(
zdd[0],
sr,
freq,
Q,
ic=ic,
stype=stype,
rolloff=rolloff,
eqsine=eqsine,
time=time,
parallel=parallel,
)
return (sh, resp, sh1, shpos, shneg, shposs, shnegs, shrms, sh0, resp0,
sh01)
def func2(s):
return srs.srs(s, sr, frq, Q)