def test_multi_dim():
data = np.random.random((10, 100))
wa = WaveletAnalysis(data, frequency=True)
ns = len(wa.scales)
assert (wa.wavelet_transform.shape == (ns, 10, 100))
wan = WaveletAnalysis(data[0], frequency=True)
assert (wan.wavelet_transform.shape == (ns, 100))
npt.assert_array_almost_equal(wa.wavelet_transform[:, 0, :],
wan.wavelet_transform[:, :],
decimal=13)
def test_reconstruction_freq():
"""In principle one can reconstruct the input data from the
wavelet transform.
Check within 10% when computing with frequency representation of
wavelet.
"""
wa = WaveletAnalysis(anomaly_sst, frequency=True)
rdata = wa.reconstruction()
err = wa.data - rdata
assert(np.abs(err.mean()) < 0.02)
def test_reconstruction_freq():
"""In principle one can reconstruct the input data from the
wavelet transform.
Check within 10% when computing with frequency representation of
wavelet.
"""
wa = WaveletAnalysis(anomaly_sst, frequency=True)
rdata = wa.reconstruction()
err = wa.data - rdata
assert (np.abs(err.mean()) < 0.02)
def test_multi_dim_axis_nd_time():
data = np.random.random((3, 4, 100, 5))
wa = WaveletAnalysis(data, frequency=False, axis=2)
ns = len(wa.scales)
print(wa.wavelet_transform.shape)
print(ns)
assert (wa.wavelet_transform.shape == (ns, 3, 4, 100, 5))
wan = WaveletAnalysis(data[0, 0, :, 0], frequency=False)
print(wan.wavelet_transform.shape)
assert (wan.wavelet_transform.shape == (ns, 100))
npt.assert_array_almost_equal(wa.wavelet_transform[:, 0, 0, :, 0],
wan.wavelet_transform[:, :],
decimal=13)
def cwt(attr, old, new):
calculateCWT.button_type = "warning"
# Perform wavelet transform
tStep = np.int(wvtTimestep.value)
yWvt = np.array(ds_analysis.data['y'])[0::tStep]
wa = WaveletAnalysis(yWvt,
wavelet=Morlet(w0=np.float(wvtWidth.value)),
dt=sampling_dt * tStep,
dj=np.float(wvtFreqstep.value))
wvt = wa.time
wvfreq = wa.fourier_frequencies
wvpower = np.flipud(wa.wavelet_power)
wvt_ds.data = {
'image': [wvpower],
'dw': [wvpower.shape[1]],
'dh': [wvpower.shape[0]],
'wv_time': [wvt],
'wv_freq': [wvfreq]
}
p_wavelet.x_range.end = wvpower.shape[
1] # need to set ranges before creating image, and not using Range1d?
p_wavelet.y_range.end = wvpower.shape[
0] # need to set ranges before creating image, and not using Range1d?
calculateCWT.button_type = "success"
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 analyse_song():
"""Compute the wavelet transform of a song."""
fs, song = wavfile.read('alarma.wav')
# select first part of one channel
stride = 1
# time step is inverse sample rate * stride
dt = stride / fs
# number of seconds of song to analyse
t_s = 1
n_s = fs * t_s
# sub sample song on a single channel
sub_song = song[:n_s:stride, 0]
wa = WaveletAnalysis(sub_song, dt=dt)
fig, ax = plt.subplots()
T, F = np.meshgrid(wa.time, wa.fourier_periods)
freqs = 1 / F
ax.contourf(T, freqs, wa.wavelet_power, 100)
ax.set_yscale('log')
ax.set_ylabel('frequency (Hz)')
ax.set_xlabel('time (s)')
ax.set_ylim(100, 10000)
fig.savefig('alarma_wavelet.png')
def _calculate_wavelet(self):
'''
Get a list of WaveletAnalyses, one for every node
'''
from wavelets import WaveletAnalysis
wavelets = [
WaveletAnalysis(force, time=self._time, dt=self.sampling_period)
for force in self.force.T
]
frequencies = wavelets[
0].fourier_frequencies / self._normalized_frequency_by
f_mask = numpy.multiply(frequencies - self.frequency_min,
frequencies - self.frequency_max) <= 0
self._wavelet_frequency = frequencies[f_mask]
wavelet_dominant_frequencies = []
self._wavelet_power = []
# for i in range(len(self.wavelet)):
for wavelet_ in wavelets:
power = wavelet_.wavelet_power
power = power[f_mask]
wavelet_power_spectral_density_max_index = numpy.argmax(power,
axis=0)
self._wavelet_power.append(power)
wavelet_dominant_frequencies.append(
self.
_wavelet_frequency[wavelet_power_spectral_density_max_index])
# _wavelet_power[node, time, frequency]
# self._wavelet_power=numpy.stack(wavelet_power)
# wavelet_dominant_frequencies[node, time]
self._wavelet_dominant_frequencies = numpy.stack(
wavelet_dominant_frequencies)
def paul_wav(time, flux):
"""Using Aaron O'Leary's wavelet package to compute the paul wavelet.
Paul wavelet is used in computing the Gradient of the Power Spectrum.
Args:
time (List): Time values from processed data file.
flux (List): Flux values from processed data file.
"""
dt = time[1] - time[0]
# Package implementation
wa = WaveletAnalysis(data=flux, time=time, wavelet=Paul(), dt=dt)
power = wa.wavelet_power
scales = wa.scales
periods = wa.fourier_periods
frequencies = wa.fourier_frequencies
t = wa.time
GPS(time, frequencies, periods, np.sum(power, axis=1))
#Attempting to plot period values on a 1-D grid.
plt.plot(scales, np.sum(power, axis=1))
plt.show()
# Plotting wavelet results on 2D map.
fig, ax = plt.subplots()
T, S = np.meshgrid(t, scales)
ax.contourf(T, S, power, 100)
ax.set_yscale('log')
plt.show()
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)
def get_wavelet(channel, time, im_size=[1024, 1024]):
wa = WaveletAnalysis(channel, time=time)
# power_im = np.log(wa.wavelet_power)
# power_norm = power_im - power_im.mean()
# power_norm = power_norm / power_norm.ptp()
# power_norm = np.flip(scipy.ndimage.interpolation.zoom(power_im, [im_size[0]/power_im.shape[0], im_size[1]/power_im.shape[1]], order=5, prefilter=False), axis=0)
df = pd.DataFrame(data=wa.wavelet_power, columns=time / 1000)
df.insert(0, 'frequency', wa.fourier_frequencies)
df = df.set_index('frequency')
return df
def MyWavelets(data,MyWidths):
Widths = MyWidths
''' 将int型data转为float型sig '''
sig = np.ones(len(data),np.float) #产生空的float型sig
for i in range(0,len(data)):
sig[i] = float(data[i])
sig = np.array( sig )
wa = WaveletAnalysis(sig, wavelet=Morlet() )
# wavelet power spectrum
power = wa.wavelet_power
# scales
scales = wa.scales
# associated time vector
t = wa.time
# reconstruction of the original data
rx = wa.reconstruction()
########################################
# 数据逐帧 0-1标准化
# print(power.shape)
# power = np.transpose(power) #转置
power = power.T
# print(power.shape)
# # power_out = np.array([])
power_out = []
for i in power:
# # np.append(power_out, minmax_scale(i), axis = 0)
# power_out.append( minmax_scale(i).tolist() )
power_out.append( minmax_scale(i))
# print(max( minmax_scale(i) ))
# power_out = np.array(power_out)
return power_out
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)
def test_var_freq():
"""The wavelet transform conserves total energy, i.e. variance.
The variance of the data should be the same as the variance of
the wavelet.
Check that they are within 1%% for the frequency representation.
N.B. the performance of this test does depend on the input data.
If e.g. np.random.random is used for the input, the variance
difference is larger.
"""
wa = WaveletAnalysis(anomaly_sst, frequency=True)
rdiff = 1 - wa.data_variance / wa.wavelet_variance
assert_less(rdiff, 0.01)
def aren_wavelet(x,filename,fs):
'''
Does the same continuous wavelet transmform as the mlpy_cwt
'''
from wavelets import WaveletAnalysis
dt=1/fs
wa = WaveletAnalysis(x, dt=dt)
# wavelet power spectrum
power = wa.wavelet_power
# scales
scales = wa.scales
import mlpy.wavelet as wave
freqs=[math.pow(i,-1) for i in wave.fourier_from_scales(scales, 'morlet',2)]
# associated time vector
t = wa.time
# reconstruction of the original data
rx = wa.reconstruction()
fig, ax = plt.subplots()
T, S = np.meshgrid(t, scales)
ax.contourf(T, S, power)
#ax.set_ylim(freqs[-1],freqs[0])
#ax.set_yscale('log')
fig.savefig(filename+'.pdf')
def compare_cwt():
"""Compare the output of Scipy's cwt (using direct convolution)
and my cwt (using fft convolution).
"""
cwt = scipy.signal.cwt
fft_cwt = wavelets.cwt
data = np.random.random(2000)
wave_anal = WaveletAnalysis(data, wavelet=wavelets.Ricker())
widths = wave_anal.scales[::-1]
morlet = scipy.signal.morlet
cwt = cwt(data, morlet, widths)
fft_cwt = fft_cwt(data, morlet, widths)
npt.assert_array_almost_equal(cwt, fft_cwt, decimal=13)
def Plot_cwt():
calculateCWT.button_type = "warning"
# Perform initial wavelet transform
tStep = np.int(wvtTimestep.value)
yWvt = np.array(ds_analysis.data['y'])[0::tStep]
wa = WaveletAnalysis(yWvt,
wavelet=Morlet(w0=np.float(wvtWidth.value)),
dt=sampling_dt * tStep,
dj=np.float(wvtFreqstep.value))
wvt = wa.time
wvfreq = wa.fourier_frequencies
wvpower = np.flipud(wa.wavelet_power)
# Plot wavelet transform as image
wvt_ds.data = {
'image': [wvpower],
'dw': [wvpower.shape[1]],
'dh': [wvpower.shape[0]],
'wv_time': [wvt],
'wv_freq': [wvfreq]
}
p_wavelet.x_range.end = wvpower.shape[
1] # need to set ranges before creating image, and not using Range1d?
p_wavelet.y_range.end = wvpower.shape[
0] # need to set ranges before creating image, and not using Range1d?
newLabels = {}
for i in range(p_wavelet.x_range.start, p_wavelet.x_range.end):
newLabels[i] = str(round_sig(wvt[i], 2))
p_wavelet.xaxis.major_label_overrides = newLabels
#ipdb.set_trace()
newLabelsY = {}
for i in range(p_wavelet.y_range.start, p_wavelet.y_range.end):
newLabelsY[i] = str(
np.round(np.array(np.flipud(wvfreq))[i] * 1550.0e-9 / 2.0, 1))
p_wavelet.yaxis.major_label_overrides = newLabelsY
p_wavelet.image(image='image',
source=wvt_ds,
x=0,
y=0,
dw='dw',
dh='dh',
palette=viridis(200))
calculateCWT.button_type = "success"
def simple_wavelet_transform(signal,
sampling_rate,
scaling_factor=0.25,
wave_lowpass=None,
wave_highpass=None):
"""
Simple wavelet transformation of signal
Parameters
----------
signal : (N,1) array_like
Signal to be transformed
sampling_rate : int
Sampling rate of signal
scaling_factor : float, optional
Determines amount of log-space frequencies M in output, by default 0.25
wave_highpass : int, optional
Cut of frequencies below, by default 2
wave_lowpass : int, optional
Cut of frequencies above, by default 30000
Returns
-------
wavelet_power : (N, M) array_like
Wavelet transformed signal
wavelet_frequencies : (M, 1) array_like
Corresponding frequencies to wavelet_power
wavelet_obj : object
WaveletTransform Object
"""
wavelet_obj = WaveletAnalysis(signal,
dt=1 / sampling_rate,
dj=scaling_factor)
wavelet_power = wavelet_obj.wavelet_power
wavelet_frequencies = wavelet_obj.fourier_frequencies
if wave_lowpass or wave_highpass:
wavelet_power = wavelet_power[(wavelet_frequencies < wave_lowpass) &
(wavelet_frequencies > wave_highpass), :]
wavelet_frequencies = wavelet_frequencies[
(wavelet_frequencies < wave_lowpass)
& (wavelet_frequencies > wave_highpass)]
return (wavelet_power, wavelet_frequencies, wavelet_obj)
def clean_tranform(self, s_data_subject):
wa = WaveletAnalysis(data=s_data_subject, wavelet=Ricker(), dt=1 / 128)
max_freq = self.get_max_freq(wa.wavelet_power)
return wa, max_freq
def defringeflat(flat_file,
wbin=10,
start_col=10,
end_col=980,
clip1=0,
diagnostic=True,
save_to_path=None,
filename=None):
"""
This function is to remove the fringe pattern using
the method described in Rojo and Harrington (2006).
Use a fifth order polynomial to remove the continuum.
Parameters
----------
flat_file : fits
original flat file
Optional Parameters
-------------------
wbin : int
the bin width to calculate each
enhance row
Default is 32
start_col : int
starting column number for the
wavelet analysis
Default is 10
end_col : int
ending column number for the
wavelet analysis
Default is 980
diagnostic : boolean
output the diagnostic plots
Default is True
Returns
-------
defringe file : fits
defringed flat file
"""
# the path to save the diagnostic plots
#save_to_path = 'defringeflat/allflat/'
#print(flat_file)
data = fits.open(flat_file, ignore_missing_end=True)
# Use the data to figure out the values to mask through the image (low counts/order edges)
hist, bins = np.histogram(data[0].data.flatten(),
bins=int(np.sqrt(len(data[0].data.flatten()))))
bins = bins[0:-1]
index1 = np.where((bins > np.percentile(data[0].data.flatten(), 10))
& (bins < np.percentile(data[0].data.flatten(), 30)))
try:
lowval = bins[index1][np.where(hist[index1] == np.min(hist[index1]))]
#print(lowval, len(lowval))
if len(lowval) >= 2: lowval = np.min(lowval)
except:
lowval = 0 #if no values for index1
flat = data
# initial flat plot
if diagnostic is True:
# Save the images to a separate folder
save_to_image_path = save_to_path + '/images/'
if not os.path.exists(save_to_image_path):
os.makedirs(save_to_image_path)
fig = plt.figure(figsize=(8, 8))
fig.suptitle("original flat", fontsize=12)
gs = gridspec.GridSpec(2, 1, height_ratios=[6, 1])
ax0 = plt.subplot(gs[0])
# Create an ImageNormalize object
norm = ImageNormalize(flat[0].data, interval=ZScaleInterval())
ax0.imshow(flat[0].data,
cmap='gray',
norm=norm,
origin='lower',
aspect='auto')
ax0.set_ylabel("Row number")
ax1 = plt.subplot(gs[1], sharex=ax0)
ax1.plot(flat[0].data[60, :],
'k-',
alpha=0.5,
label='60th row profile')
ax1.set_ylabel("Amp (DN)")
ax1.set_xlabel("Column number")
plt.legend()
plt.savefig(save_to_image_path + "defringeflat_{}_0_original_flat.png"\
.format(filename), bbox_inches='tight')
plt.close()
defringeflat_img = data
defringe_data = np.array(defringeflat_img[0].data, dtype=float)
for k in np.arange(0, 1024 - wbin, wbin):
#print(k)
#if k != 310: continue
"""
# Use the data to figure out the values to mask through the image (low counts/order edges)
hist, bins = np.histogram(flat[0].data[k:k+wbin+1, 0:1024-clip1].flatten(),
bins=int(np.sqrt(len(flat[0].data[k:k+wbin+1, 0:1024-clip1].flatten()))))
bins = bins[0:-1]
index1 = np.where( (bins > np.percentile(flat[0].data[k:k+wbin+1, 0:1024-clip1].flatten(), 10)) &
(bins < np.percentile(flat[0].data[k:k+wbin+1, 0:1024-clip1].flatten(), 30)) )
lowval = bins[index1][np.where(hist[index1] == np.min(hist[index1]))]
#print(lowval, len(lowval))
if len(lowval) >= 2: lowval = np.min(lowval)
"""
# Find the mask
mask = np.zeros(flat[0].data[k:k + wbin + 1, 0:1024 - clip1].shape)
baddata = np.where(
flat[0].data[k:k + wbin + 1, 0:1024 - clip1] <= lowval)
mask[baddata] = 1
# extract the patch from the fits file
#flat_patch = np.ma.array(flat[0].data[k:k+wbin,:], mask=mask)
flat_patch = np.array(flat[0].data[k:k + wbin + 1, 0:1024 - clip1])
# median average the selected region in the order
flat_patch_median = np.ma.median(flat_patch, axis=0)
# continuum fit
# smooth the continuum (Chris's method)
smoothed = sp.ndimage.uniform_filter1d(flat_patch_median, 30)
splinefit = sp.interpolate.interp1d(np.arange(len(smoothed)),
smoothed,
kind='cubic')
cont_fit = splinefit(np.arange(0, 1024 - clip1)) #smoothed
# Now fit a polynomial
#pcont = np.ma.polyfit(np.arange(0, 1024-clip1),
# cont_fit, 10)
#cont_fit2 = np.polyval(pcont, np.arange(0,1024))
#plt.plot(flat_patch_median, c='r')
#plt.plot(smoothed, c='b')
#plt.savefig(save_to_image_path + "TEST.png", bbox_inches='tight')
#plt.close()
#plt.show()
#sys.exit()
#pcont = np.ma.polyfit(np.arange(start_col,end_col),
# flat_patch_median[start_col:end_col],10)
#cont_fit = np.polyval(pcont, np.arange(0,1024))
# use wavelets package: WaveletAnalysis
enhance_row = flat_patch_median - cont_fit
dt = 0.1
wa = WaveletAnalysis(enhance_row[start_col:end_col], dt=dt)
# wavelet power spectrum
power = wa.wavelet_power
# scales
cales = wa.scales
# associated time vector
t = wa.time
# reconstruction of the original data
rx = wa.reconstruction()
# reconstruct the fringe image
reconstruct_image = np.zeros(defringe_data[k:k + wbin + 1,
0:1024 - clip1].shape)
for i in range(wbin + 1):
for j in np.arange(start_col, end_col):
reconstruct_image[i, j] = rx[j - start_col]
defringe_data[k:k + wbin + 1,
0:1024 - clip1] -= reconstruct_image[0:1024 - clip1]
# Add in something for the edges/masked out data in the reconstructed image
defringe_data[k:k + wbin + 1, 0:1024 -
clip1][baddata] = flat[0].data[k:k + wbin + 1,
0:1024 - clip1][baddata]
#print("{} row starting {} is done".format(filename,k))
# diagnostic plots
if diagnostic is True:
print("Generating diagnostic plots")
# middle cut plot
fig = plt.figure(figsize=(10, 6))
fig.suptitle("middle cut at row {}".format(k + wbin // 2),
fontsize=12)
ax1 = fig.add_subplot(2, 1, 1)
norm = ImageNormalize(flat_patch, interval=ZScaleInterval())
ax1.imshow(flat_patch,
cmap='gray',
norm=norm,
origin='lower',
aspect='auto')
ax1.set_ylabel("Row number")
ax2 = fig.add_subplot(2, 1, 2, sharex=ax1)
ax2.plot(flat_patch[wbin // 2, :], 'k-', alpha=0.5)
ax2.set_ylabel("Amp (DN)")
ax2.set_xlabel("Column number")
plt.tight_layout()
plt.subplots_adjust(top=0.85, hspace=0.5)
plt.savefig(save_to_image_path + \
'defringeflat_{}_flat_start_row_{}_middle_profile.png'\
.format(filename,k), bbox_inches='tight')
plt.close()
# continuum fit plot
fig = plt.figure(figsize=(10, 6))
fig.suptitle("continuum fit row {}-{}".format(k, k + wbin),
fontsize=12)
gs = gridspec.GridSpec(2, 1, height_ratios=[3, 1])
ax0 = plt.subplot(gs[0])
ax0.plot(flat_patch_median,
'k-',
alpha=0.5,
label='mean average patch')
ax0.plot(cont_fit, 'r-', alpha=0.5, label='continuum fit')
#ax0.plot(cont_fit2,'m-', alpha=0.5, label='continuum fit poly')
ax0.set_ylabel("Amp (DN)")
plt.legend()
ax1 = plt.subplot(gs[1])
ax1.plot(flat_patch_median - cont_fit,
'k-',
alpha=0.5,
label='residual')
ax1.set_ylabel("Amp (DN)")
ax1.set_xlabel("Column number")
plt.legend()
plt.tight_layout()
plt.subplots_adjust(top=0.85, hspace=0.5)
plt.savefig(save_to_image_path + \
"defringeflat_{}_start_row_{}_continuum_fit.png".\
format(filename,k), bbox_inches='tight')
#plt.show()
#sys.exit()
plt.close()
# enhance row vs. reconstructed wavelet plot
try:
fig = plt.figure(figsize=(10, 6))
fig.suptitle("reconstruct fringe comparison row {}-{}".\
format(k,k+wbin), fontsize=10)
ax1 = fig.add_subplot(3, 1, 1)
ax1.set_title('enhance_row start row')
ax1.plot(enhance_row,
'k-',
alpha=0.5,
label="enhance_row start row {}".format(k))
ax1.set_ylabel("Amp (DN)")
#plt.legend()
ax2 = fig.add_subplot(3, 1, 2, sharex=ax1)
ax2.set_title('reconstructed fringe pattern')
ax2.plot(rx,
'k-',
alpha=0.5,
label='reconstructed fringe pattern')
ax2.set_ylabel("Amp (DN)")
#plt.legend()
ax3 = fig.add_subplot(3, 1, 3, sharex=ax1)
ax3.set_title('residual')
ax3.plot(enhance_row[start_col:end_col] - rx,
'k-',
alpha=0.5,
label='residual')
ax3.set_ylabel("Amp (DN)")
ax3.set_xlabel("Column number")
#plt.legend()
plt.tight_layout()
plt.subplots_adjust(top=0.85, hspace=0.5)
plt.savefig(save_to_image_path + \
"defringeflat_{}_start_row_{}_reconstruct_profile.png".\
format(filename,k), bbox_inches='tight')
plt.close()
except RuntimeError:
print("CANNOT GENERATE THE PLOT defringeflat\
_{}_start_row_{}_reconstruct_profile.png" \
.format(filename,k))
pass
# reconstruct image comparison plot
fig = plt.figure(figsize=(10, 6))
fig.suptitle("reconstructed image row {}-{}".\
format(k,k+wbin), fontsize=12)
ax1 = fig.add_subplot(3, 1, 1)
ax1.set_title('raw flat image')
norm = ImageNormalize(flat_patch, interval=ZScaleInterval())
ax1.imshow(flat_patch,
cmap='gray',
norm=norm,
origin='lower',
label='raw flat image',
aspect='auto')
ax1.set_ylabel("Row number")
#plt.legend()
ax2 = fig.add_subplot(3, 1, 2, sharex=ax1)
ax2.set_title('reconstructed fringe image')
norm = ImageNormalize(reconstruct_image, interval=ZScaleInterval())
ax2.imshow(reconstruct_image,
cmap='gray',
norm=norm,
origin='lower',
label='reconstructed fringe image',
aspect='auto')
ax2.set_ylabel("Row number")
#plt.legend()
ax3 = fig.add_subplot(3, 1, 3, sharex=ax1)
ax3.set_title('residual')
norm = ImageNormalize(flat_patch - reconstruct_image,
interval=ZScaleInterval())
ax3.imshow(flat_patch - reconstruct_image,
norm=norm,
origin='lower',
cmap='gray',
label='residual',
aspect='auto')
ax3.set_ylabel("Row number")
ax3.set_xlabel("Column number")
#plt.legend()
plt.tight_layout()
plt.subplots_adjust(top=0.85, hspace=0.5)
plt.savefig(save_to_image_path + \
"defringeflat_{}_start_row_{}_reconstruct_image.png".\
format(filename,k), bbox_inches='tight')
plt.close()
# middle residual comparison plot
fig = plt.figure(figsize=(10, 6))
fig.suptitle("middle row comparison row {}-{}".\
format(k,k+wbin), fontsize=12)
ax1 = fig.add_subplot(3, 1, 1)
ax1.plot(flat_patch[wbin // 2, :],
'k-',
alpha=0.5,
label='original flat row {}'.format(k + wbin / 2))
ax1.set_ylabel("Amp (DN)")
plt.legend()
ax2 = fig.add_subplot(3, 1, 2, sharex=ax1)
ax2.plot(flat_patch[wbin//2,:]-\
reconstruct_image[wbin//2,:],'k-',
alpha=0.5, label='defringed flat row {}'.format(k+wbin/2))
ax2.set_ylabel("Amp (DN)")
plt.legend()
ax3 = fig.add_subplot(3, 1, 3, sharex=ax1)
ax3.plot(reconstruct_image[wbin // 2, :],
'k-',
alpha=0.5,
label='difference')
ax3.set_ylabel("Amp (DN)")
ax3.set_xlabel("Column number")
plt.legend()
plt.tight_layout()
plt.subplots_adjust(top=0.85, hspace=0.5)
plt.savefig(save_to_image_path + \
"defringeflat_{}_start_row_{}_defringe_middle_profile.png".\
format(filename,k), bbox_inches='tight')
plt.close()
#if k > 30: sys.exit() # for testing purposes
# final diagnostic plot
if diagnostic is True:
fig = plt.figure(figsize=(8, 8))
fig.suptitle("defringed flat", fontsize=12)
gs = gridspec.GridSpec(2, 1, height_ratios=[6, 1])
ax0 = plt.subplot(gs[0])
norm = ImageNormalize(defringe_data, interval=ZScaleInterval())
ax0.imshow(defringe_data,
cmap='gray',
norm=norm,
origin='lower',
aspect='auto')
ax0.set_ylabel("Row number")
ax1 = plt.subplot(gs[1], sharex=ax0)
ax1.plot(defringe_data[60, :],
'k-',
alpha=0.5,
label='60th row profile')
ax1.set_ylabel("Amp (DN)")
ax1.set_xlabel("Column number")
plt.legend()
plt.tight_layout()
plt.subplots_adjust(top=0.85, hspace=0.5)
plt.savefig(save_to_image_path + "defringeflat_{}_0_defringe_flat.png"\
.format(filename), bbox_inches='tight')
plt.close()
hdu = fits.PrimaryHDU(data=defringe_data)
hdu.header = flat[0].header
return hdu
def find_peaks_cwt(bins,
width,
snr,
min_length_percentage=0.4,
peak_range=(0.5, np.inf),
peak_separation=0,
gap_scale=0.05,
gap_thresh=2,
noise_window=1.0):
"""
Find peaks in APT spectra through CWT, ridge lines and filtering
Args:
(REQUIRED)
bins: mass histogram bins (need linear scaling!) (1D list)
width: the width of the bins
snr: required signal-to-noise ratio for significant peaks
(OPTIONAL)
min_length_percentage: minimum percentage of scales where the peak should exist
peak_range: looks for peaks in this range (now from 0.5 to inf -> so peaks before 0.5 are removed)
peak_separation: an optional distance between peaks (peaks below this threshold are merged)
gap_scale: width between scales given in units of 2^width having width as linear scale with gap_scale separation
gap_thresh: threshold of allowed gap for levels where peaks are not present before saving it as new ridge line (depends on the amount of scales used)
noise_window: window on real scale to compute the noise
Returns:
Tuple with
- list of masses
- list of scales
- 2D array of ridges (see find_ridge_lines)
- 1D list of information on peaks (see find_ridge_lines)
"""
# select the wavelet object to use - the ricker (mexican hat) wavelet gives good results
wavelet = Ricker()
# select the minimum and maximum applicable scale levels
min_scale = np.log2(4 * width)
max_scale = np.log2(2) #this are 2 amu at the moment
# compute the logarithm of the height as the CWT performs better here on typical spectra
height_log = bins['height'].astype(np.float)
height_log += 1 # add one to circumvent the problem of zero height
height_log = np.log(height_log)
# initialize the wavelet library
wav = WaveletAnalysis(height_log, wavelet=wavelet, dt=width)
wav.time = bins['edge'] + width / 2 # use mass to charge as the time scale
scales = wav.scales = 2**(np.arange(min_scale, max_scale,
gap_scale)) # build a set of scales
# apply the continous wavelet transform and keep the real part (in theory there should be no imaginary part)
cwt = np.real(wav.wavelet_transform)
#ridge is 2D array of tuples where each tuple contains (see function above)
#(cwt-intensity, local-max-yes-no, previous-point-on-line, scale-gap-to-previous-point, start-of-ridge, current-length-of-ridge)
#peak_info 1D list of tuples where each tuple contains (see function above)
#(scale-of-ridge-start(row), mass-of-ridge-start(col), start-of-ridge, max-length-of-ridge, max-intensity, scale-of-max-intensity)
#called with: cwt-object (3D array scale, mass, intensities), bin-width, left and right window for ridge lines
#scale levels that it skips before ridge line ends, window to check noise at lowest scale level)
ridge, peak_info = find_ridge_lines(cwt, width, scales / 2, scales / 2,
gap_thresh, noise_window)
#TODO: limiting what ridge saves is saving a LOT OF MEMORY
# correct maxima for snr and push them down deleting any that does not work
for ind, (row, col, ridge_max, _, loc, length,
noise) in np.ndenumerate(peak_info):
# delete peaks that:
# - are not in parameter peak_range or
# - dont appear as a single line for enough scale or
# - too low snr (noise comes from wavelet estimate)
if not (peak_range[0] <= wav.time[loc] <=
peak_range[1]) or length < min_length_percentage * len(
scales) or ridge_max / noise < snr:
delete_ridge(ridge, row, col)
peak_info['row'][ind] = -1
continue
peak_info = peak_info[peak_info['row'] != -1]
# find a guess of the maximum row that does not include the asymmetric behavior
scale_row = np.zeros(shape=peak_info.shape, dtype=np.int32)
scale_row_strength = np.zeros(shape=peak_info.shape, dtype=np.int32)
for ind, (row, col, ridge_max, _, loc, length,
noise) in np.ndenumerate(peak_info):
#traversing down the ridge
while ridge['from'][row, col] != -1:
# stop at first peak that is near the start location and not above the original maximum
if abs(wav.time[loc] -
wav.time[col]) < 10 * width and not np.isclose(
ridge['max'][row, col], ridge_max):
scale_row[ind] = row
scale_row_strength[ind] = ridge['cwt'][row, col]
break
col = ridge['from'][row, col]
row = row - 1
# delete all that do not have expected range by estimating their uncertainty behaviour
# coeff is tuple of 2 (steepness of a line fit, const. line fit=0)
coeff = nppoly.polyfit(np.sqrt(wav.time[peak_info['loc']]),
scales[scale_row], [1],
w=peak_info['max'])
#resulting linear fit
#print(coeff)
y_scale_fit = coeff[1] * np.sqrt(wav.time) + coeff[0]
# find the cwt coefficient at the nearest scale level and compare to snr
for ind, (row, col, ridge_max, _, loc, length,
noise) in np.ndenumerate(peak_info):
exp_scale = y_scale_fit[loc]
strength = 0
trow = row
tcol = col
#if the expected row is never reached (peak only exists on higher scales) -> strength stays 0
#after this loop peaks that dont exist at the expected strength are 0 and peaks that exist have their intensity in strength
while ridge['from'][trow, tcol] != -1:
if scales[trow] < exp_scale:
#if the first row on the traverse down is below the scale -> strength stays 0
#if exp_scale > max_scale than the fit is bad and we just keep everything
if trow != row or exp_scale > max_scale:
strength = cwt[trow, tcol]
break
tcol = ridge['from'][trow, tcol]
trow = trow - 1
#print(wav.time[loc], exp_scale, ridge_max, strength, noise) #, length, scales[trow], trow)
#kicks out peaks that dont have enough signal at the expected scale level at this point in the mass spectrum
if strength / noise < snr:
# delete if not significant at the expected scale level
delete_ridge(ridge, row, col)
peak_info['row'][ind] = -1
elif strength > scale_row_strength[ind]:
# optimize if previous scale estimation step was too aggressive
peak_info[ind]['max_row'] = trow
peak_info[ind]['loc'] = tcol
else:
#else just accept the previous estimate as actual max row
peak_info[ind]['max_row'] = scale_row[ind]
# remove all filtered peaks
peak_info = peak_info[peak_info['row'] != -1]
# delete not well separated peaks (optional step)
max_ridges = np.sort(peak_info, order="max")[::-1]
for rdg in max_ridges:
# find peaks near others
bef, idx, aft = np.searchsorted(peak_info['loc'], [
rdg['loc'] - peak_separation / width, rdg['loc'],
rdg['loc'] + peak_separation / width
])
# remove the peak if larger is inside the separation range
if bef == aft or idx == peak_info.shape[
0] or peak_info[idx]['loc'] != rdg['loc']:
continue
peak_info['row'][bef:idx] = -1
peak_info['row'][idx + 1:aft] = -1
peak_info = peak_info[peak_info['row'] != -1]
# return the list of masses (center of the bins), scales (defined above), ridge information and the peak information including their related ridge (from the find_ridge_lines function)
return wav.time, wav.scales, ridge, peak_info
def defringetelluric():
if not os.path.exists(save_to_path):
os.makedirs(save_to_path)
############################################
print(tell_data_name)
tell_sp = nspf.Spectrum(name=tell_data_name, order=order, path=tell_path)
clickpoints = []
def onclick(event):
print(event)
global clickpoints
clickpoints.append([event.xdata])
print(clickpoints)
plt.axvline(event.xdata, c='r', ls='--')
plt.draw()
if len(clickpoints) == 2:
print('Closing Figure')
plt.axvspan(clickpoints[0][0], clickpoints[1][0], color='0.5', alpha=0.5, zorder=-100)
plt.draw()
plt.pause(1)
plt.close('all')
### Draw the figure with the power spectrum
cal1 = tell_sp.flux#[pixel_range_start:pixel_range_end]
xdim = len(cal1)#[pixel_range_start:pixel_range_end])
nfil = xdim//2 + 1
# Smooth the continuum
cal1smooth = sp.ndimage.median_filter(cal1, size=30)
# Do the FFT
cal1fft = fftpack.rfft(cal1-cal1smooth)
yp = abs(cal1fft[0:nfil])**2
yp = yp / np.max(yp)
fig, ax1 = plt.subplots(figsize=(12,6))
cid = fig.canvas.mpl_connect('button_press_event', onclick)
freq = np.arange(nfil)
yp[0:3] = 0 # Fix for very low order noise
ax1.plot(freq, yp)
#ax1.axvline(f_high*2, c='r', ls='--')
#ax1.axvline(f_low*2, c='r', ls='--')
ax1.set_ylabel('Power Spectrum')
ax1.set_xlabel('1 / (1024 pix)')
ax1.set_title('Select the range you would like to filter out')
ax1.set_xlim(0, np.max(freq))
plt.show()
plt.close('all')
f_high = np.max(clickpoints)/2
f_low = np.min(clickpoints)/2
if method == 'wavelet':
#### Wavelets
from wavelets import WaveletAnalysis
xdim = len(tell_sp.flux)#[pixel_range_start:pixel_range_end])
cal1 = tell_sp.flux#[pixel_range_start:pixel_range_end]
# Smooth the continuum
smoothed = sp.ndimage.uniform_filter1d(cal1, 30)
splinefit = sp.interpolate.interp1d(np.arange(len(smoothed)), smoothed, kind='cubic')
cal1smooth = splinefit(np.arange(0, len(cal1))) #smoothed
# use wavelets package: WaveletAnalysis
enhance_row = cal1 - cal1smooth
#print(enhance_row)
dt = 0.1
wa = WaveletAnalysis(enhance_row, dt=dt, axis=0)
# wavelet power spectrum
power = wa.wavelet_power
# scales
scales = wa.scales
# associated time vector
t = wa.time
# reconstruction of the original data
rx = wa.reconstruction()
defringe_data = np.array(cal1.data, dtype=float)
# reconstruct the fringe image
#reconstruct_image = np.zeros(defringe_data.shape)
reconstruct_image = np.real(rx)
defringe_data -= reconstruct_image
newSpectrum = defringe_data
if PLOT:
fig = plt.figure(figsize=(12,6))
ax1 = plt.subplot2grid((3, 1), (0, 0))
ax2 = plt.subplot2grid((3, 1), (1, 0), rowspan=2)
#freq = np.arange(nfil)
ax1.plot(power**2)
ax1.axvline(f_high*2, c='r', ls='--')
ax1.axvline(f_low*2, c='r', ls='--')
ax1.set_ylabel('Power Spectrum')
ax1.set_xlabel('1 / (1024 pix)')
#ax1.set_xlim(0, np.max(freq))
ax2.plot(cal1[0:-23], label='original', alpha=0.5, lw=1, c='b')
ax2.plot(newSpectrum[0:-23]+0.5*np.median(newSpectrum[0:-23]), label='defringed', alpha=0.8, lw=1, c='r')
ax2.legend()
ax2.set_ylabel('Flux')
ax2.set_xlabel('Pixel')
ax2.set_xlim(0, len(cal1[0:-23]))
plt.tight_layout()
plt.savefig(save_to_path+"defringed_spectrum.png", bbox_inches='tight')
plt.show()
if method == 'hanningnotch':
## REDSPEC version
cal1 = tell_sp.flux#[pixel_range_start:pixel_range_end]
xdim = len(cal1)#[pixel_range_start:pixel_range_end])
nfil = xdim//2 + 1
#print(xdim, nfil//2+1)
freq = np.arange(nfil//2+1) / (nfil / float(xdim))
fil = np.zeros(len(freq), dtype=np.float)
fil[np.where((freq < f_low) | (freq > f_high))] = 1.
fil = np.append(fil, np.flip(fil[1:],axis=0))
fil = np.real(np.fft.ifft(fil))
fil = np.roll(fil, nfil//2)
fil = fil*np.hanning(nfil)
# Smooth the continuum
#smoothed = sp.ndimage.uniform_filter1d(cal1, 30)
#splinefit = sp.interpolate.interp1d(np.arange(len(smoothed)), smoothed, kind='cubic')
#cal1smooth = splinefit(np.arange(0, len(cal1))) #smoothed
cal1smooth = sp.ndimage.median_filter(cal1, size=30)
"""
plt.figure()
plt.plot(abs(np.real(fftpack.fft(cal1orig-cal1smooth)))**2, c='k', lw=0.5)
plt.plot(abs(np.real(fftpack.fft( sp.ndimage.convolve(cal1orig-cal1smooth, fil, mode='wrap') ) ))**2, c='r', lw=0.5)
plt.ylim(0,25000)
#plt.xlim(0,800)
plt.show()
#sys.exit()
plt.figure(figsize=(10,6))
plt.plot(cal1-cal1smooth, lw=0.5, c='k')
plt.plot(sp.ndimage.convolve(cal1-cal1smooth, fil, mode='wrap'), lw=0.5, c='r')
plt.plot(sp.ndimage.median_filter(cal1-cal1smooth, 10), lw=0.5, c='m')
plt.show(block=False)
#sys.exit()
plt.figure()
plt.plot( (cal1-cal1smooth)-sp.ndimage.convolve(cal1-cal1smooth, fil, mode='wrap'), lw=0.5, c='k')
plt.show(block=True)
#sys.exit()
"""
newSpectrum = sp.ndimage.convolve(cal1-cal1smooth, fil, mode='wrap') + cal1smooth
if PLOT:
# Do the FFT
cal1fft = fftpack.rfft(cal1-cal1smooth)
yp = abs(cal1fft[0:nfil])**2
yp = yp / np.max(yp)
yp[0:3] = 0 # Fix for very low order noise
fig = plt.figure(figsize=(12,6))
ax1 = plt.subplot2grid((3, 1), (0, 0))
ax2 = plt.subplot2grid((3, 1), (1, 0), rowspan=2)
freq = np.arange(nfil)
ax1.plot(freq, yp)
ax1.axvline(f_high*2, c='r', ls='--')
ax1.axvline(f_low*2, c='r', ls='--')
ax1.set_ylabel('Power Spectrum')
ax1.set_xlabel('1 / (1024 pix)')
ax1.set_xlim(0, np.max(freq))
ax2.plot(cal1[0:-23], label='original', alpha=0.5, lw=1, c='b')
ax2.plot(newSpectrum[0:-23]+0.5*np.median(newSpectrum[0:-23]), label='defringed', alpha=0.8, lw=1, c='r')
ax2.legend()
ax2.set_ylabel('Flux')
ax2.set_xlabel('Pixel')
ax2.set_xlim(0, len(cal1[0:-23]))
plt.tight_layout()
plt.savefig(save_to_path+"defringed_spectrum.png", bbox_inches='tight')
plt.show()
if method == 'flatfilter':
cal1 = tell_sp.flux#[pixel_range_start:pixel_range_end]
W = fftpack.fftfreq(cal1.size, d=1./1024)
fftval = fftpack.rfft(cal1.astype(float))
fftval[np.where((W > f_low) & (W < f_high))] = 0
newSpectrum = fftpack.irfft(fftval)
if PLOT:
xdim = len(cal1)#[pixel_range_start:pixel_range_end])
nfil = xdim//2 + 1
freq = np.arange(nfil)
# Smooth the continuum
smoothed = sp.ndimage.uniform_filter1d(cal1, 30)
splinefit = sp.interpolate.interp1d(np.arange(len(smoothed)), smoothed, kind='cubic')
cal1smooth = splinefit(np.arange(0, len(cal1))) #smoothed
# Do the FFT
cal1fft = fftpack.rfft(cal1-cal1smooth)
yp = abs(cal1fft[0:nfil])**2 # Power
yp = yp / np.max(yp)
fig = plt.figure(figsize=(12,6))
ax1 = plt.subplot2grid((3, 1), (0, 0))
ax2 = plt.subplot2grid((3, 1), (1, 0), rowspan=2)
ax1.plot(freq, yp)
ax1.axvline(f_high, c='r', ls='--')
ax1.axvline(f_low, c='r', ls='--')
ax1.set_ylabel('Power Spectrum')
ax1.set_xlabel('1 / (1024 pix)')
ax1.set_xlim(0, np.max(freq))
ax2.plot(cal1[0:-23], label='original', alpha=0.5, lw=1, c='b')
ax2.plot(newSpectrum[0:-23]+0.5*np.median(newSpectrum[0:-23]), label='defringed', alpha=0.8, lw=1, c='r')
ax2.legend()
ax2.set_ylabel('Flux')
ax2.set_xlabel('Pixel')
ax2.set_xlim(0, len(cal1[0:-23]))
plt.tight_layout()
plt.savefig(save_to_path+"defringed_spectrum.png", bbox_inches='tight')
#plt.show()
fullpath = tell_path + '/' + tell_data_name + '_' + str(order) + '_all.fits'
save_name = save_to_path + '%s_defringe_%s_all.fits'%(tell_data_name, order)
hdulist = fits.open(fullpath)
hdulist.append(fits.PrimaryHDU())
hdulist[-1].data = tell_sp.flux
hdulist[1].data = newSpectrum
hdulist[-1].header['COMMENT'] = 'Raw Extracted Spectrum'
hdulist[1].header['COMMENT'] = 'Defringed Spectrum'
try:
hdulist.writeto(save_name, overwrite=True)
except FileNotFoundError:
hdulist.writeto(save_name)
fs = 240//decimation
cardSig = 10
numElec = 10
elec = slice(lenSig*numElec,lenSig*numElec+lenSig)
frameSize = 0.2
p300 = np.where(y==1)[0]
nonp300 = np.where(y==-1)[0][:cardSig]
for numSig in range(cardSig):
signal = X[p300[numSig],elec]
dt = 1.0/fs
wa = WaveletAnalysis(signal, dt=dt)
# wavelet power spectrum
power = wa.wavelet_power
# scales
scales = wa.fourier_frequencies
# associated time vector
t = wa.time
print wa.fourier_frequencies
# reconstruction of the original data
rx = wa.reconstruction()
fig, ax = plt.subplots()
T, S = np.meshgrid(t, scales)
ax.contourf(T, S, power, 100)
print(S)
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
Value at frequency = 0 should be 0.
"""
npt.assert_almost_equal(wavelets.DOG(m=2)(0), 0.867, 3)
npt.assert_almost_equal(wavelets.DOG(m=6)(0), 0.884, 3)
npt.assert_almost_equal(wavelets.DOG(m=2).frequency(0), 0, 6)
npt.assert_almost_equal(wavelets.DOG(m=6).frequency(0), 0, 6)
test_data = np.loadtxt('tests/nino3data.asc', skiprows=3)
nino_time = test_data[:, 0]
nino_dt = np.diff(nino_time).mean()
anomaly_sst = test_data[:, 2]
wa = WaveletAnalysis(anomaly_sst, time=nino_time, dt=nino_dt)
def test_N():
assert_equal(anomaly_sst.size, wa.N)
def compare_cwt():
"""Compare the output of Scipy's cwt (using direct convolution)
and my cwt (using fft convolution).
"""
cwt = scipy.signal.cwt
fft_cwt = wavelets.cwt
data = np.random.random(2000)
wave_anal = WaveletAnalysis(data, wavelet=wavelets.Ricker())
def generate_datasets(data_source):
print "Preparing to load data from %s" % data_source
data_var = 'data'
if "Patient" in data_source:
patient_data = []
patient_data.insert(0, load_for_patient(data_source))
else:
start_time_load = time.time()
patient_data = load_all_patients(data_source)
print "Time taken to load %d patients: %f" % (
len(patient_data), time.time() - start_time_load)
wav_ictal_data = []
wav_interictal_data = []
pnum = 1
start_time_patient_process = time.time()
for patient in patient_data:
print "Processing data for patient %d" % pnum
freq = patient[0]
ictal_files = patient[1]
interictal_files = patient[2]
num_files = min(len(ictal_files), len(interictal_files))
datasize = int(round(freq / 10))
for index in range(0, num_files):
ictal_channels = ictal_files[index].get(data_var)
for channel in ictal_channels:
channel = ss.decimate(channel, datasize)
ictal_wavelets = np.transpose(
np.real(WaveletAnalysis(channel).wavelet_transform))
wav_ictal_data.extend(ictal_wavelets)
interictal_channels = interictal_files[index].get(data_var)
for channel in interictal_channels:
channel = ss.decimate(channel, datasize)
interictal_wavelets = np.transpose(
np.real(WaveletAnalysis(channel).wavelet_transform))
wav_interictal_data.extend(interictal_wavelets)
pnum += 1
pca = PCA(n_components=16)
ictal_data = pca.fit_transform(wav_ictal_data)
interictal_data = pca.fit_transform(wav_interictal_data)
print "Generating datasets"
num_datapts = len(ictal_data)
np.random.shuffle(ictal_data)
np.random.shuffle(interictal_data)
num_test = int(round(num_datapts / 5))
num_valid = int((num_datapts - num_test) / 4)
num_train = num_datapts - num_valid - num_test
train_data = np.array(
np.vstack([ictal_data[:num_train], interictal_data[:num_train]]))
train_labels = np.concatenate([np.ones(num_train), np.zeros(num_train)])
seed = np.random.get_state()
np.random.shuffle(train_data)
np.random.set_state(seed)
np.random.shuffle(train_labels)
valid_data = np.array(
np.vstack([
ictal_data[num_train:num_train + num_valid],
interictal_data[num_train:num_train + num_valid]
]))
valid_labels = np.concatenate([np.ones(num_valid), np.zeros(num_valid)])
seed = np.random.get_state()
np.random.shuffle(valid_data)
np.random.set_state(seed)
np.random.shuffle(valid_labels)
test_data = np.array(
np.vstack([
ictal_data[num_train + num_valid:num_datapts],
interictal_data[num_train + num_valid:num_datapts]
]))
test_labels = np.concatenate([np.ones(num_test), np.zeros(num_test)])
print "Time taken to process files: %f" % (time.time() -
start_time_patient_process)
return train_data, train_labels, valid_data, valid_labels, test_data, test_labels
metavar='depth_level',
type=int,
help='number of depths in file')
args = parser.parse_args()
for level in range(0, args.depth_level, 1):
print level
mooring = args.mooring
(raw_data, x, dt, time, variance, time_base, depth) = \
ADCP_2D(args.DataFile+mooring+'/'+mooring+'_ABS.txt', \
args.DataFile+'/'+mooring+'/'+mooring+'_dates.txt', \
args.DataFile+'/'+mooring+'/'+mooring+'_depth.txt', level=level)
fig_name_base = 'images/' + mooring + '_ADCP'
"""-----------------------------wavelet analysis ---------------------------"""
wa = WaveletAnalysis(x, time=time, dt=dt, dj=0.125)
# wavelet power spectrum
power = wa.wavelet_power
transform = wa.wavelet_transform
# scales
scales = wa.scales
# associated time vector
t = wa.time / 24.
# reconstruction of the original data
rx = wa.reconstruction()
# determine acor factor for red noise
# print(t1) sig = np.sin(4 *2 * np.pi * t) sig = sig.tolist() sig1 = np.sin(6 *2 * np.pi * t1) sig1 = sig1.tolist() sig2 = np.sin(10 *2 * np.pi * t2) sig2 = sig2.tolist() sig_data = sig + sig1 + sig2 print(type(sig_data)) sig_data = np.array( sig_data ) widths = np.arange(1, 64) # cwtmatr = cwt(sig_data, wavelet=Morlet() , widths=widths) wa = WaveletAnalysis(sig_data, wavelet=Morlet() ) # wavelet power spectrum power = wa.wavelet_power # scales scales = wa.scales plt.plot(scales) plt.show() # associated time vector t = wa.time plt.plot(t) plt.show() # reconstruction of the original data rx = wa.reconstruction()
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
Created on Fri Jul 7 19:59:05 2017 @author: tdong """ 'Wavelet transformation' import numpy as np from wavelets import WaveletAnalysis from matplotlib import pyplot as plt # given a signal x(t) x = np.random.randn(1000) # and a sample spacing dt = 1.0 / 512 wa = WaveletAnalysis(x, dt=dt) #wa = WaveletAnalysis(last1second, dt=dt) # wavelet power spectrum power = wa.wavelet_power re = wa.wavelet_transform.imag im = wa.wavelet_transform.real phase = np.arctan(im / re) # scales scales = wa.scales # associated time vector t = wa.time # reconstruction of the original data
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 9 13:46:53 2018
@author: amoody
"""
import pywt
from wavelets import WaveletAnalysis
wa = WaveletAnalysis((s-s.mean()).values, dt=1/365)
# wavelet power spectrum
power = wa.wavelet_power
# scales
scales = wa.scales
# associated time vector
t = wa.time
# reconstruction of the original data
rx = wa.reconstruction()
fig, ax = plt.subplots()
T, S = np.meshgrid(t, scales)
c1=ax.contourf(T, S, power, 100,cmap='jet')
plt.colorbar(c1)
ax.set_yscale('log')
chisquare(power,axis=1)
#%%
plt.style.use('bmh')
data=DataNull.loc[DataNull.WellNumber == '01N 05E 17BCA1','WaterLevelBelowLSD']
