def test_Morlet():
"""Compare against \Psi_0(0) in Table 2 of TC98.
Value at frequency = 0 should be 0.
"""
npt.assert_almost_equal(wavelets.Morlet()(0), np.pi**-.25, 3)
npt.assert_almost_equal(wavelets.Morlet().frequency(0), 0, 6)
def compare_morlet(N=2000):
"""Compare scipy morlet with my morlet (same, but correct
argument order).
"""
data = np.random.random(N)
wave_anal = WaveletAnalysis(data, wavelet='ricker')
scales = wave_anal.scales[::-1]
cwt = wavelets.cwt
cwt_sp = cwt(data, scipy.signal.morlet, scales)
cwt_me = cwt(data, wavelets.Morlet(), scales)
cwt_ri = cwt(data, scipy.signal.ricker, scales)
t = np.indices(data.shape)
T, S = np.meshgrid(t, scales)
fig, ax = plt.subplots(nrows=3)
ax[0].set_title('Scipy morlet')
ax[0].contourf(T, S, cwt_sp, 100)
ax[1].set_title('My morlet')
ax[1].contourf(T, S, cwt_me, 100)
ax[2].set_title('Scipy Ricker')
ax[2].contourf(T, S, cwt_ri, 100)
fig.tight_layout()
return fig
def wavelet(self, ax):
ax.set_title('Wavelet power spectrum (morlet)')
ax.set_xlabel('time after front passage (s)')
ax.set_ylabel('equivalent fourier frequency (Hz)')
sig = self.u[20, 20, :]
wa = wavelets.WaveletAnalysis(sig, dt=0.01, wavelet=wavelets.Morlet(),
unbias=True)
fourier_freqs = 1 / wa.fourier_periods
T, S = np.meshgrid(wa.time, fourier_freqs)
contourf = ax.contourf(T, S, wa.wavelet_power, 100)
# shade the region between the edge and coi
C, S = wa.coi
# fourier period
Fp = wa.fourier_period(S)
# fourier freqs
Ff = 1 / Fp
ff_min = fourier_freqs.min()
ax.fill_between(x=C, y1=Ff, y2=ff_min, color='gray', alpha=0.3)
ax.set_yscale('log')
return contourf
def plot_morlet():
"""
TODO: make a pretty plot of the morlet for the README
"""
morlet = wavelets.Morlet().time
s = 1
T = np.linspace(-5 * s, 5 * s, 200)
Y = morlet(T, s=s)
f, a = plt.subplots()
a.plot(T, Y, 'k')
a.set_title('Morlet wavelet')
a.set_xlabel('t / s')
f.savefig('morlet.png')
def test_fourier_frequencies():
# Just some signal, no special meaning
dt = .1
x = np.arange(5000) * dt
signal = np.cos(1. * x) + np.cos(2. * x) + np.cos(3. * x)
wa = WaveletAnalysis(signal,
dt=dt,
wavelet=wavelets.Morlet(),
unbias=False)
# Set frequencies and check if they match when retrieving them again
frequencies = np.linspace(1., 100., 100)
wa.fourier_frequencies = frequencies
npt.assert_array_almost_equal(wa.fourier_frequencies, frequencies)
# Check periods
npt.assert_array_almost_equal(wa.fourier_periods, 1. / frequencies)
# Set periods and re-check
wa.fourier_periods = 1. / frequencies
npt.assert_array_almost_equal(wa.fourier_frequencies, frequencies)
npt.assert_array_almost_equal(wa.fourier_periods, 1. / frequencies)
elif source == 1:
Un = 'current.dat'
elif source == 2:
Un = Jfile
eJ = []
with open(file_path + Un, 'r') as f:
info = f.readlines()
for i in info:
eJ.append(float(i.split()[0]))
eJ = np.array(eJ)
at = np.gradient(eJ, delta)[::take]
tc = np.linspace(0., laser.cycles, len(at))
if wvlet == 'Morlet':
wave = wavelets.Morlet(w0=w0)
elif wvlet == 'Paul':
wave = wavelets.Paul(m=m)
elif wvlet == 'DOG':
wave = wavelets.DOG(m=m)
elif wvlet == 'Ricker' or wvlet == 'Marr' or wvlet == 'Mexican_hat':
wave = wavelets.Ricker()
else:
print('Invalid choice of wavelet')
analysis = transform.WaveletAnalysis(data=at,
time=tc,
dt=delta * take,
dj=dj,
wavelet=wave,
unbias=unbias,
2 * np.pi * fbasal2 * time)
x += np.random.normal(size=len(x)) * ampruido
x2 = 1.2 * np.cos(2 * np.pi * 0.8 *
(time - chrpini)**2) * (time - chrpini) * np.exp(
-(time - chrpini) / 10)
x2[(time < chrpini) + (time > chrpstp)] = 0
x += x2
#%% Wavelet transfom - linearly spaced scales
desiredFreq = np.arange(1, 40, 0.2) # Frequencies we want to analyse
desiredPeriods = 1 / (desiredFreq * dt)
scales = desiredPeriods / wavelets.Morlet.fourierwl # scales
wavel1 = wavelets.Morlet(x, scales=scales)
pwr1 = np.sqrt(wavel1.getnormpower()) # Normalized power
fmin = min(desiredFreq)
fmax = max(desiredFreq)
#%% Plot the results - add a spectrogram for comparison
plt.figure(1, figsize=(12, 4))
plt.clf()
plt.subplot(311)
plt.plot(time, x, alpha=1)
plt.xlabel('Time (s)')
plt.xlim((0, 50))
def __init__(self, **kwargs):
super(MorletTransform, self).__init__(**kwargs)
self.wavelet = wavelets.Morlet()
def test_power_bias():
"""See if the global wavelet spectrum is biased or not.
Wavelet transform a signal of 3 distinct Fourier frequencies.
The power spectrum should contain peaks at the frequencies, all
of which should be the same height.
"""
dt = 0.1
x = np.arange(5000) * dt
T1 = 20 * dt
T2 = 100 * dt
T3 = 500 * dt
w1 = 2 * np.pi / T1
w2 = 2 * np.pi / T2
w3 = 2 * np.pi / T3
signal = np.cos(w1 * x) + np.cos(w2 * x) + np.cos(w3 * x)
wa = WaveletAnalysis(signal,
dt=dt,
wavelet=wavelets.Morlet(),
unbias=False)
power_biased = wa.global_wavelet_spectrum
wa.unbias = True
power = wa.global_wavelet_spectrum
wa.mask_coi = True
power_coi = wa.global_wavelet_spectrum
freqs = wa.fourier_periods
fig, ax = plt.subplots(nrows=2)
ax_transform = ax[0]
fig_info = (r"Wavelet transform of "
r"$cos(2 \pi / {T1}) + cos(2 \pi / {T2}) + cos(2 \pi / {T3})$")
ax_transform.set_title(fig_info.format(T1=T1, T2=T2, T3=T3))
X, Y = np.meshgrid(wa.time, wa.fourier_periods)
ax_transform.set_xlabel('time')
ax_transform.set_ylabel('fourier period')
ax_transform.set_ylim(10 * dt, 1000 * dt)
ax_transform.set_yscale('log')
ax_transform.contourf(X, Y, wa.wavelet_power, 100)
# shade the region between the edge and coi
C, S = wa.coi
F = wa.fourier_period(S)
f_max = F.max()
ax_transform.fill_between(x=C, y1=F, y2=f_max, color='gray', alpha=0.3)
ax_power = ax[1]
ax_power.set_title('Global wavelet spectrum '
'(estimator for power spectrum)')
ax_power.plot(freqs, power, 'k', label=r'unbiased all domain')
ax_power.plot(freqs, power_coi, 'g', label=r'unbiased coi only')
ax_power.set_xscale('log')
ax_power.set_xlim(10 * dt, wa.time.max())
ax_power.set_xlabel('fourier period')
ax_power.set_ylabel(r'power / $\sigma^2$ (bias corrected)')
ax_power_bi = ax_power.twinx()
ax_power_bi.plot(freqs, power_biased, 'r', label='biased all domain')
ax_power_bi.set_xlim(10 * dt, wa.time.max())
ax_power_bi.set_ylabel(r'power / $\sigma^2$ (bias uncorrected)')
ax_power_bi.set_yticklabels(ax_power_bi.get_yticks(), color='r')
label = "T={0}"
for T in (T1, T2, T3):
ax_power.axvline(T)
ax_power.annotate(label.format(T), (T, 1))
ax_power.legend(fontsize='x-small', loc='lower right')
ax_power_bi.legend(fontsize='x-small', loc='upper right')
fig.tight_layout()
fig.savefig('tests/test_power_bias.png')
return fig
