def plot_psd_resampled():
global t, ch1, ch2, sps, sampl, title
plt.clf()
nfft=2048 #int(2**np.ceil(np.log2(sampl)));
ax1=plt.subplot(211)
(Pxx, freqs)=plt.psd(ch1[::5], NFFT=nfft, Fs=sps/5, window=mlab.window_hanning, color='red')
plt.title('PSD (NFFT='+str(nfft)+', Fs='+str(sps/5)+'Hz, hann) from '+title)
plt.xlabel('')
ax2=plt.subplot(212)
(Pxx, freqs)=plt.psd(ch2[::5], NFFT=nfft, Fs=sps/5, window=mlab.window_hanning, color='green')
plt.ylabel('')
ax2.set_ylim(ax1.get_ylim())
fig=plt.gcf();
f_dpi=fig.get_dpi()
#print "dpi: %i" % (f_dpi)
#f_size=fig.get_size_inches()
#print "figure size in Inches", f_size
#print "or pixels %i x %i pixel" % (f_dpi*f_size[0], f_dpi*f_size[1])
#fig.set_size_inches([f_size[0]*2, f_size[1]]);
fig.set_size_inches(1200.0/f_dpi, 500.0/f_dpi);
#f_size=fig.get_size_inches()
#print "resized to %i x %i pixel" % (f_dpi*f_size[0], f_dpi*f_size[1])
plt.savefig(os.path.join(_LOCATION_CHARTS,"last_psd_res.png"), dpi=96, bbox_inches='tight')
plt.clf()
print "plotting psd_resampled finished"
def fftplt1(x,Mch,dtrnd=True,demean=True): fs=1 if demean: x = x - x.mean() if dtrnd: Pout = plt.psd(x, NFFT=Mch, detrend=pylab.detrend_linear, noverlap=Mch/2, Fs=fs) else: Pout = plt.psd(x, NFFT=Mch, detrend=pylab.detrend_none, noverlap=Mch/2, Fs=fs) xdtrnd = pylab.detrend_linear(x) xauto = mcmath.acorr_mlab(xdtrnd,2) rhoxauto = (xauto[1] + np.sqrt(abs(xauto[2])))/2 R = mcmath.redspec(rhoxauto,np.arange(Mch/2),Mch) P = Pout[0][:R.size] F = Pout[1][:R.size] Psum = P.sum() Rsum = R.sum() PRratio = Psum/Rsum Rcmp = R*PRratio plt.figure() plt.plot(F,P) plt.plot(F,Rcmp) return (F,P,Rcmp)
def inspect_source_psd(self, ic):
data = self._get_ica_data()
source = self.ica._transform_epochs(data, concatenate=True)[ic]
sfreq = data.info['sfreq']
plt.figure()
plt.psd(source, Fs=sfreq, NFFT=128, noverlap=0, pad_to=None)
plt.show()
def fftplt3(x,Mch,pval=0.1,dtrnd=True,demean=True,titlestr='',Dt=0.01):
"""Differs from fftplt3 solely by plotting the power spectral density
in log-form, 10*log10(P)."""
fs=1
titl_plc = (1.,1.)
if demean:
x = x - x.mean()
if dtrnd:
Pout = plt.psd(x, NFFT=Mch, detrend=pylab.detrend_linear, noverlap=Mch/2, Fs=fs)
else:
Pout = plt.psd(x, NFFT=Mch, detrend=pylab.detrend_none, noverlap=Mch/2, Fs=fs)
xdtrnd = pylab.detrend_linear(x)
xauto = mcmath.acorr_mlab(xdtrnd,2)
rhoxauto = (xauto[1] + np.sqrt(abs(xauto[2])))/2
R = mcmath.redspec(rhoxauto,np.arange(Mch/2),Mch)
P = Pout[0][:R.size]
F = Pout[1][:R.size]
Psum = P.sum()
Rsum = R.sum()
PRratio = Psum/Rsum
Rcmp = R*PRratio
dof = (x.size / (Mch/2.)) * 1.2
Fval = stats.f.isf(pval,dof,dof)
tst = P / Rcmp
pass1 = np.where(tst > Fval)[0]
maxs = mcmath.extrema_find(P,'max',t=F,dt=Dt)
max_ind = np.intersect1d(maxs,pass1)
Fmaxs = F[max_ind]
Fmaxs2 = np.append(Fmaxs,0.1)
Fmaxs2.sort()
Tmaxs = 1/(Fmaxs2)
Tmaxs = np.round(Tmaxs,2)
ax = plt.gca()
ax.plot(F,10*np.log10(Rcmp))
ax.set_xticks(Fmaxs2)
ax.set_xticklabels(Tmaxs)
my_fmt_xdate(ax,rot=90,hal='center')
multiline(Fmaxs,c='red',ls='--')
xtl = ax.get_xticklabels()
ytl = ax.get_yticklabels()
plt.setp(xtl,'size',10)
plt.setp(ytl,'size',9)
ppct = int((1 - pval)*100)
titl_str = '%s FFT (chunksize: %d) :: peak CL: %d%%' % (titlestr,Mch,ppct)
plt.text(titl_plc[0],titl_plc[1],titl_str,ha='right',va='bottom',size=12,transform=ax.transAxes)
plt.xlabel('Peak period (yrs)',size=11)
return (F,P,Rcmp)
def do_check_spectrum(hostData, DUTData, samplingRate, fLow, fHigh, margainLow, margainHigh):
# reduce FFT resolution to have averaging effects
N = 512 if (len(hostData) > 512) else len(hostData)
iLow = N * fLow / samplingRate + 1 # 1 for DC
if iLow > (N / 2 - 1):
iLow = N / 2 - 1
iHigh = N * fHigh / samplingRate + 1 # 1 for DC
if iHigh > (N / 2 + 1):
iHigh = N / 2 + 1
print fLow, iLow, fHigh, iHigh, samplingRate
Phh, freqs = plt.psd(
hostData,
NFFT=N,
Fs=samplingRate,
Fc=0,
detrend=plt.mlab.detrend_none,
window=plt.mlab.window_hanning,
noverlap=0,
pad_to=None,
sides="onesided",
scale_by_freq=False,
)
Pdd, freqs = plt.psd(
DUTData,
NFFT=N,
Fs=samplingRate,
Fc=0,
detrend=plt.mlab.detrend_none,
window=plt.mlab.window_hanning,
noverlap=0,
pad_to=None,
sides="onesided",
scale_by_freq=False,
)
print len(Phh), len(Pdd)
print "Phh", abs(Phh[iLow:iHigh])
print "Pdd", abs(Pdd[iLow:iHigh])
amplitudeRatio = np.sqrt(abs(Pdd[iLow:iHigh] / Phh[iLow:iHigh]))
ratioMean = np.mean(amplitudeRatio)
amplitudeRatio = amplitudeRatio / ratioMean
print "Normialized ratio", amplitudeRatio
print "ratio mean for normalization", ratioMean
positiveMax = abs(max(amplitudeRatio))
negativeMin = abs(min(amplitudeRatio))
passFail = (
True if (positiveMax < (margainHigh / 100.0 + 1.0)) and ((1.0 - negativeMin) < margainLow / 100.0) else False
)
RatioResult = np.zeros(len(amplitudeRatio), dtype=np.int16)
for i in range(len(amplitudeRatio)):
RatioResult[i] = amplitudeRatio[i] * 1024 # make fixed point
print "positiveMax", positiveMax, "negativeMin", negativeMin
return (passFail, negativeMin, positiveMax, RatioResult)
def problem_5():
"""
This function uses pyplot.psd to plot the spectrum for each of the time
series generated above.
Inputs:
None
Outputs:
This will automatically generate a plot for each of the 4 data-sets.
"""
plt.figure()
plt.psd(gdp)
plt.title('GDP Spectrum')
plt.show()
plt.figure()
plt.psd(cpi)
plt.title('CPI Spectrum')
plt.show()
plt.figure()
plt.psd(cons)
plt.title('Consumption Spectrum')
plt.show()
plt.figure()
plt.psd(inv)
plt.title('Investment Spectrum')
plt.show()
def chickling_csd_2ch(shotno, date=time.strftime("%Y%m%d")):
fname, data = file_finder(shotno,date)
data = quickextract_data(fname)
#reshape the array of x points (20M for 1s) into a 2d array each with 40k segments.
phasediff_co2 = np.unwrap(data[0]['phasediff_co2'])
phasediff_hene = np.unwrap(data[0]['phasediff_hene'])
fs = data[0]['samplerate']
plt.figure("2 Channels | Blue = PSD Scene | Orange = PSD Reference | Green = CSD | shot " + str(shotno) + " Date " + str(date))
plt.psd(phasediff_co2, Fs=fs)
plt.psd(phasediff_hene,Fs=fs)
plt.csd(phasediff_co2, phasediff_hene, Fs=fs)
plt.show()
def main(argv):
name = raw_input("Enter file prefix: ")
infileprefix = "out_%s" % name
outfilename = 'pyout_%s.csv' % name
FFT_SIZE = 64
freq_to_power = {}
for filename in sorted(listdir("out/")):
if filename.startswith(infileprefix):
Fc = int(
sub(r'[_\.csv]', '',
findall(r'_[0-9]+\.csv', filename)[0]))
print(Fc)
with open(path.join("out", filename), "rb") as file:
samples = bytes2iq(bytearray(file.read()))
mean = np.mean(samples)
samples = samples - mean
Ps, fs = plt.psd(samples, NFFT=FFT_SIZE, Fs=20, Fc=Fc)
for i in range(len(Ps)):
if (fs[i] % 1.0 == 0.0):
freq_to_power[fs[i]] = np.log(Ps[i])
with open(path.join('out', outfilename), 'a') as out:
for freq in freq_to_power:
out.write('%s,%s\n' % (freq, freq_to_power[freq]))
def calculate_amplitude(st):
"""
Calculate a noise proxy for the first trace in that station.
"""
res = plt.psd(st[0].data,Fs=st[0].stats.sampling_rate,NFFT=4096,noverlap=4096/2)
amp_sum = np.sum(res[0])
return amp_sum
def plt_walking_psd(data, sig, n_peaks=6, nFFT=256, delta=10, show_peaks=False):
plt.figure()
for si in list(set(data.subj)):
di = data[data.subj == si]
di = di[di.act == 4]
x = di[sig][:]
a,b,l = plt.psd(x, nFFT, 52., color='k', return_line=True)
# grab data from the plot
pwr, fq = l[0].get_ydata(), l[0].get_xdata()
#p = peak_detection(pwr, n_peaks, 0, .02, int(pk_dist*52))
#print pwr, fq
mx, mn = peakdet(pwr, delta=delta)
mx, mn = mx.astype(int), mn.astype(int)
if show_peaks:
#for pi in p:
#print pi
#plt.plot(fq[pi[0]], pi[1], 'ro')
for p in mx:
plt.plot(fq[p[0]], p[1], 'go')
for p in mn:
plt.plot(fq[p[0]], p[1], 'ro')
plt.tight_layout()
plt.show()
def load_audio_mfcc_plus(path, category, fileid):
print(fileid)
audio_file = mp.AudioFileClip(path, fps=16000);
audio = audio_file.to_soundarray()
audio = (audio[:, 0] + audio[:, 1]) / 2
mfcc_structure = psf.mfcc(audio, samplerate=16000, winlen=0.576, winstep=0.576, nfft=16384, numcep=26, nfilt=52)
mfcc_structure = np.asarray(mfcc_structure)
#plt.show()
r = int(len(mfcc_structure[:,0]))
for i in range(0, r):
a = audio[i * 9216 : (i + 1) * 9216]
m = mfcc_structure[i,:]
zero_crossings = ((a[:-1] * a[1:]) < 0).sum() # Source: https://stackoverflow.com/questions/30272538/python-code-for-counting-number-of-zero-crossings-in-an-array
zero_crossings = zero_crossings / (10 ** 3)
maximum_amplitude = np.max(plt.psd(a)[0])
spectral_centroid = librosa.feature.spectral_centroid(y=a, n_fft=16384, sr=16000)
spectral_centroid = np.resize(spectral_centroid, (1, 11))
spectral_centroid = spectral_centroid / (10 ** 3)
m = np.append(m, zero_crossings)
m = np.append(m, maximum_amplitude)
m = np.append(m, spectral_centroid)
m = utils.normalize(m)
spect_list_mfcc_plus.append(m)
category_list_mfcc_plus.append(category)
audio_file.close()
def readPSD(self, width: int):
samples = self.read(width)
return psd(samples,
NFFT=1024,
Fs=self.radio.sample_rate / 1e6,
Fc=self.radio.center_freq / 1e6,
return_line=True)
def _plot_fft(tdms, **kargs):
ti = kargs['ti']
fft_len = kargs['fft_len']
fft_scale = kargs['fft_scale']
p, f = plt.psd(tdms.wav.__getslice__(*ti),
fft_len,
tdms.fs)
if fft_scale == 'db':
plt.ylabel(r'Amplitude $\frac{mV^2}{Hz}$ ($dB$)')
elif fft_scale == 'linear':
plt.cla()
plt.plot(f, p)
plt.ylabel(r'Amplitude $\frac{mV^2}{Hz}$')
plt.xlabel(u'Frequency ($Hz$)')
return
fft = np.fft.fft(tdms.wav.__getslice__(*ti), fft_len)[:fft_len/2]
if fft_unit == 'pow':
fft = fft * fft.conjugate() / fft_len
elif fft_unit == 'amp':
fft = np.abs(fft / fft_len)
plt.ylabel('Amplitude mV/Hz')
plt.plot(np.fft.fftfreq(fft_len, 1/tdms.fs)[:fft_len/2], fft)
plt.grid()
def compute_and_plot_psd(data, sfreq, NFFT=512, show=True):
""" Computes the power spectral density and produces a plot.
Parameters
----------
data : ndarray (n_times)
The signal.
sfreq : float
Sampling frequency.
NFFT : int (power of 2)
Number of bins for each block of FFT.
show : bool
Display or hide plot. (Default is True)
Returns
-------
power : ndarray
The power spectral density of the signal.
freqs : ndarray
Frequencies.
"""
if show is False:
pl.ioff()
power, freqs = pl.psd(data, Fs=sfreq, NFFT=NFFT)
return power, freqs
def calc_heart_rate_freq(self, signal, fs):
# signal = self.detrend(signal, 8)
b, a = sig.butter(3, .05, btype='low') # currently high pass
# Remove DC Baseline
signal = self.detrend(signal, 4)
# Filter low values
signal = sig.lfilter(b, a, signal)
# signal = self.detrend(signal, 4)
#Take the PSD of the signal
#Calculate HR based on find peak
Pxx, Freqs = plt.psd(signal, NFFT=len(signal), Fs=fs)
plt.show()
# Filter the Pxx
# Pxx = sig.lfilter(b,a,Pxx)
slice_from = 3
peaks, _ = sig.find_peaks(Pxx[slice_from:], distance=20)
heart_freq = Freqs[slice_from:][peaks[0]]
return heart_freq * 60
def psd(self):
if self.is_on_cuda:
self.cpu()
plt.psd(self[0],
NFFT=16384,
Fs=self.fs_in_fiber,
window=np.hamming(16384))
plt.show()
self.cuda()
else:
plt.psd(self[0],
NFFT=16384,
Fs=self.fs_in_fiber,
window=np.hamming(16384))
plt.show()
def analyze_validation_data(station_id, validation_date, data_type):
duration=0.5
decimation_level=5
decimation_frequency=1/decimation_level
vd=ValidationData()
vd.populate(station_id,validation_date,data_type)
for wdx in np.arange(48):
selected_data=vd.data[int(wdx*1800):int((wdx+1)*1800)]
validation_data=signal.detrend(signal.decimate(selected_data,decimation_level,ftype='iir', axis=-1, zero_phase=True))
Pxx, freqs = plt.psd(validation_data, NFFT=1024, Fs=decimation_frequency, detrend='mean',scale_by_freq=True)
if wdx==0:
X_val=Pxx[0:100]/np.max(Pxx[0:100])
else:
X_val=np.vstack((X_val,Pxx[0:100]/np.max(Pxx[0:100])))
X_validation = preprocessing.scale(X_val,0)
# X_validation = X_val
prediction=clf.predict(X_validation)
prediction_proba=clf.predict_proba(X_validation)
vd.plot_prediction(prediction, prediction_proba, Fs=decimation_frequency,title=str(data_type)+'_'+str(validation_date.date()), x_label='UTC (hh:mm)', y_label='Frequency (Hz)')
classes = {0: 'noisy', 1: 'clean'}
colors = {0: 'red', 1: 'blue'}
fig, axes = plt.subplots(8,6)
fig.subplots_adjust(hspace=1)
for ax, wdx in zip(axes.flatten(), np.arange(48)):
ax.plot(freqs[0:100], X_validation[wdx], colors[prediction[wdx]])
ax.set(title=','.join((classes[prediction[wdx]],str(wdx))).upper())
fig.set_size_inches(37, 10)
plt.savefig(validation_date.strftime('%Y%m%d')+'_windows.png')
def do_check_spectrum_playback(hostData, samplingRate, fLow, fHigh, margainLow, margainHigh):
# reduce FFT resolution to have averaging effects
N = 512 if (len(hostData) > 512) else len(hostData)
iLow = N * fLow / samplingRate + 1 # 1 for DC
if iLow > (N / 2 - 1):
iLow = (N / 2 - 1)
iHigh = N * fHigh / samplingRate + 1 # 1 for DC
if iHigh > (N / 2 + 1):
iHigh = N / 2 + 1
print fLow, iLow, fHigh, iHigh, samplingRate
Phh, freqs = plt.psd(hostData, NFFT=N, Fs=samplingRate, Fc=0, detrend=plt.mlab.detrend_none,\
window=plt.mlab.window_hanning, noverlap=0, pad_to=None, sides='onesided',\
scale_by_freq=False)
print len(Phh)
print "Phh", abs(Phh[iLow:iHigh])
spectrum = np.sqrt(abs(Phh[iLow:iHigh]))
spectrumMean = np.mean(spectrum)
spectrum = spectrum / spectrumMean
print "Mean ", spectrumMean
print "Normalized spectrum", spectrum
positiveMax = abs(max(spectrum))
negativeMin = abs(min(spectrum))
passFail = True if (positiveMax < (margainHigh / 100.0 + 1.0)) and\
((1.0 - negativeMin) < margainLow / 100.0) else False
spectrumResult = np.zeros(len(spectrum), dtype=np.int16)
for i in range(len(spectrum)):
spectrumResult[i] = spectrum[i] * 1024 # make fixed point
print "positiveMax", positiveMax, "negativeMin", negativeMin
return (passFail, negativeMin, positiveMax, spectrumResult)
def doPSD(sdr, centerFrequency):
""" Odcita vzorky, ktore potom spracuje a vykresli do grafu.
Funkcia konci ulozenim grafu do .png formatu a ukoncenim kernel modulu."""
global hodnoty, frekvencie
# configuring device
sdr.sample_rate = 2.4e6
sdr.center_freq = centerFrequency
sdr.gain = 7.1 # Podporovane hodnoty gain: [-9.9; -4; 7.1; 17.9; 19.2]
samples = sdr.read_samples(number_of_FFT *
256) # == 262 144 komplexnych cisel
# Using matplotlib.pyplot to estimate and plot the Power Spectral Density
result = plt.psd(samples,
NFFT=number_of_FFT,
Fs=sdr.sample_rate,
Fc=sdr.center_freq)
hodnoty = result[0] # 'hodnoty' predstavuju vykon a maju absolutnu velkost
frekvencie = result[
1] # 'frekvencie' su hodnoty prisluchajuce jednotlivym hodnotam 'hodnoty'
# Save figure (Line2D object)
# Urobi graf: ['frekvencie', 'hodnoty'] ale hodnoty su uz premenene na db ako 10*log_10(hodnoty[_])
plt.savefig('/var/www/html/obrazky/power_spectral_density.png')
# Clearing figure
plt.clf()
def compute_and_plot_psd(data, sfreq, NFFT=512, show=True):
""" Computes the power spectral density and produces a plot.
Parameters
----------
data : ndarray (n_times)
The signal.
sfreq : float
Sampling frequency.
NFFT : int (power of 2)
Number of bins for each block of FFT.
show : bool
Display or hide plot. (Default is True)
Returns
-------
power : ndarray
The power spectral density of the signal.
freqs : ndarray
Frequencies.
"""
if show is False:
pl.ioff()
power, freqs = pl.psd(data, Fs=sfreq, NFFT=NFFT)
return power, freqs
def psd_processing(dev_id: str, time_range=['now() - 40m', 'now() - 30m']):
cli = InfluxData()
cli.set_client(config.INFLUXDB_HOST,
config.INFLUXDB_PORT,
config.INFLUXDB_ID,
config.INFLUXDB_PASSWORD,
database=config.INFLUXDB_DATABASE)
if time_range[0] == 'now() - 40m':
rs = cli.query(
f"select * from acc_data where dev_id='{dev_id}' and time >= {time_range[0]} AND time <= {time_range[1]}"
)
else:
rs = cli.query(
f"select * from acc_data where dev_id='{dev_id}' and time >= '{time_range[0]}' AND time <= '{time_range[1]}'"
)
data = cli.resultSetToDF(rs)
if type(data['acc_data']) is list: # it means empty data
logging.warning('empty data')
return dev_id
if len(data['acc_data']
) < EXPECT_DATASET_SIZE * 0.9: # not enough data size
logging.warning('not enough data size')
return dev_id
data = data['acc_data'] # convert dict_dataframe to dataframe
x = data['x'] * constants.g
y = data['y'] * constants.g
z = data['z'] * constants.g
offset_x = x - np.mean(x)
offset_y = y - np.mean(y)
offset_z = z - np.mean(z)
Pxx, freqs_x = plt.psd(offset_x, NFFT=200, Fs=100)
Pyy, freqs_y = plt.psd(offset_y, NFFT=200, Fs=100)
Pzz, freqs_z = plt.psd(offset_z, NFFT=200, Fs=100)
row = {
'dev_id': dev_id,
'Mean_PSD_x': np.mean(Pxx),
'Mean_PSD_y': np.mean(Pyy),
'Mean_PSD_z': np.mean(Pzz),
'MAX_PSD_x': np.max(Pxx),
'MAX_PSD_y': np.max(Pyy),
'MAX_PSD_z': np.max(Pzz),
'MIN_PSD_x': np.min(Pxx),
'MIN_PSD_y': np.min(Pyy),
'MIN_PSD_z': np.min(Pzz)
}
return row
def readPSD(self, width: int):
samples = self.read(width)
return psd(samples,
NFFT=1024,
Fs=self.radio.sample_rate / 1e6,
Fc=self.radio.center_freq / 1e6,
return_line=True)
# matplotlib.pyplot.savefig("./scan.png")
def plot_PSD(self, sensor: str):
"""
Plots Auto Power Spectrum
:param sensor: The value of the column name from the loaded files where the desired information is. [SENSOR NAME]
:param sampling_freq: The signal sampling frequency.
:return: Instance so that it can be linearly written in code.
"""
plt.psd(self.data_read[sensor], Fs=self.sampling_rate)
# Setup Plot Parameters.
plt.title('Auto-Power Spectrum of ' + sensor)
plt.show()
return self # Return Instance so that it can be linearly written in code.
def psd(self):
if self.is_on_cuda:
self.cpu()
plt.figure()
plt.psd(self.ds_in_fiber[0],
NFFT=16384,
Fs=self.fs_in_fiber,
scale_by_freq=True)
self.cuda()
plt.show()
else:
plt.figure()
plt.psd(self.ds_in_fiber[0],
NFFT=16384,
Fs=self.fs_in_fiber,
scale_by_freq=True)
plt.show()
def psd_maker(self):
"""
Adds a power and corresponding rfrequency column to data.
Args:
data (dataFrame): df with relevant eye data. Assumes data from only ONE feature_1
feature_1 (dataFrame column): feature from dataframe to filter unique values
feature_1 (dataFrame column): feature from dataframe to filter unique values
signal (dataFrame column): signal the PSD calculation will be run on
Returns:
output_df (dataFrame): original dataFrame with power and frequency columns with the same values
within each unique feature_2
"""
# Establish the output df
df = pd.DataFrame(
columns=[self.feature_2, 'power', 'freq', 'log_power'])
# The actual loop. Meant to run on one person at a time
for x in self.data[self.feature_1].unique():
df_1 = self.data[self.data[self.feature_1] == x]
for y in df_1[self.feature_2].unique():
# Subset data to just one feature_2 at a time per feature_1
q_data = df_1[df_1[self.feature_2] == y]
# Window size should always be bigger than the length of the data, and ideally a power of 2.
nfft = next_power_of_2(len(q_data))
# Do the actual psd.
power, freq = plt.psd(q_data[self.signal],
Fs=110,
NFFT=nfft,
window=signal.get_window('hamming',
Nx=nfft,
fftbins=True),
detrend='mean',
pad_to=nfft,
noverlap=nfft / 2)
plt.close()
log_power = np.log(power)
# Build the new row for the output df
psd_row = pd.DataFrame(
[[y, power, freq, log_power]],
columns=[self.feature_2, 'power', 'freq', 'log_power'])
# Add the next row of data
df = pd.concat([df, psd_row])
# Remerge w/ original data
# power and frequency repeat each row w/i a question so if there's a more optimal way to store data do that
output_df = self.data.merge(right=df, on=feature_2)
self.data = output_df
return self.data
def main():
L1norm = np.add(np.abs(data_array[:, 1]), np.abs(data_array[:, 2]),
np.abs(data_array[:, 3]))
b, a = sig.butter(3, 0.2, btype='low')
c, d = sig.butter(3, 0.5, btype='high')
lowsignal_filtered = sig.lfilter(b, a, L1norm)
highsignal_filtered = sig.lfilter(c, d, L1norm)
plt.subplot(321)
plt.plot(t, L1norm)
plt.subplot(322)
plt.psd(L1norm, NFFT=len(t), Fs=fs)
plt.subplot(323)
plt.plot(t, lowsignal_filtered)
plt.subplot(324)
plt.psd(lowsignal_filtered, NFFT=len(t), Fs=fs)
plt.subplot(325)
plt.plot(t, highsignal_filtered)
plt.subplot(326)
plt.psd(highsignal_filtered, NFFT=len(t), Fs=fs)
plt.show()
x = detrend(s, 15)
# plt.subplot(211)
# plt.plot(t, x)
# plt.subplot(212)
# plt.psd(x, NFFT=len(t), Fs=fs) #plot the power spectral density
# plt.show()
Pxx, freqs = plt.psd(x, NFFT=len(t), Fs=fs)
index = np.argmax(Pxx)
maxpower = freqs[index]
print(maxpower)
def calc_heart_rate_freq(signal, fs):
b, a = sig.butter(3, .2, btype='low')
signal = sig.detrend(signal, 4)
signal = sig.lfilter(b, a, signal)
Pxx, Freqs = plt.psd(signal, NFFT=len(signal), Fs=fs)
slice_from = 3
peaks, _ = sig.find_peaks(Pxx[slice_from:], distance=20)
heart_freq = Freqs[slice_from:][peaks[0]]
return heart_freq * 60
def plot_psd_resampled():
global t, ch1, ch2, sps, sampl, title
plt.clf()
nfft = 2048 #int(2**np.ceil(np.log2(sampl)));
ax1 = plt.subplot(211)
(Pxx, freqs) = plt.psd(ch1[::5],
NFFT=nfft,
Fs=sps / 5,
window=mlab.window_hanning,
color='red')
plt.title('PSD (NFFT=' + str(nfft) + ', Fs=' + str(sps / 5) +
'Hz, hann) from ' + title)
plt.xlabel('')
ax2 = plt.subplot(212)
(Pxx, freqs) = plt.psd(ch2[::5],
NFFT=nfft,
Fs=sps / 5,
window=mlab.window_hanning,
color='green')
plt.ylabel('')
ax2.set_ylim(ax1.get_ylim())
fig = plt.gcf()
f_dpi = fig.get_dpi()
#print "dpi: %i" % (f_dpi)
#f_size=fig.get_size_inches()
#print "figure size in Inches", f_size
#print "or pixels %i x %i pixel" % (f_dpi*f_size[0], f_dpi*f_size[1])
#fig.set_size_inches([f_size[0]*2, f_size[1]]);
fig.set_size_inches(1200.0 / f_dpi, 500.0 / f_dpi)
#f_size=fig.get_size_inches()
#print "resized to %i x %i pixel" % (f_dpi*f_size[0], f_dpi*f_size[1])
plt.savefig(os.path.join(_LOCATION_CHARTS, "last_psd_res.png"),
dpi=96,
bbox_inches='tight')
plt.clf()
print "plotting psd_resampled finished"
def pyplot_welch(data, NFFT_length, sampling_frequency, segment_pad_to_length):
import numpy as np
import matplotlib.pyplot as plt
overlap = int(np.size(NFFT_length)/ 2)
Pxx, freqs = plt.psd(data, NFFT=NFFT_length, Fs=sampling_frequency,
pad_to=segment_pad_to_length, noverlap=overlap)
return Pxx, freqs
def calculate_amplitude(st):
"""
Calculate a noise proxy for the first trace in that station.
"""
res = plt.psd(st[0].data,
Fs=st[0].stats.sampling_rate,
NFFT=4096,
noverlap=4096 / 2)
amp_sum = np.sum(res[0])
return amp_sum
def plotPowerSpectrum(data, samplingRate, ROICount):
plt.figure(3)
for x in range(0, ROICount):
plt.subplot(221 + x)
plt.psd(data[x][1], NFFT=240, Fs=samplingRate, noverlap=230)
plt.xlabel("frequency (Hz)")
plt.ylabel("Power (Pxx)")
plt.subplots_adjust(top=0.90,
bottom=0.10,
left=0.15,
right=0.95,
hspace=0.35,
wspace=0.45)
plt.show()
def _test_make_TDMA_slot_():
f_s = 2e9
t_s = np.arange(2**16) / f_s
# Test that power scales as expected
T_symbol = (
t_s.max() - t_s.min()
) / 2000. # Toal number of symbols, need >1000 for 1/N (>=200) to converge to < 10%
s = ASK_series(t_s, f_s / MHz / 4., T_symbol)
p = signal_power(s)
for N in [3, 4, 5]:
for S in range(N):
s_slot = _make_TDMA_slot_(
t_s, s, T_slot=T_symbol * 10, slot_no=S, N_slots=N
) # 10 symbols per slot, slots repeat every N*10 symbols
assert_isclose(p / float(N),
signal_power(s_slot),
"Slot %d/%d power not scaled as 1/Nslots" % (S, N),
rtol=0.1)
# A visual inspection
pyplot.figure()
pyplot.psd(s,
Fs=f_s,
NFFT=len(s) // 16,
scale_by_freq=True,
label="Continuous ASK signal")
pyplot.psd(s_slot,
Fs=f_s,
NFFT=len(s) // 16,
scale_by_freq=True,
label="Slot=%d/%d ASK signal" % (S, N),
hold=True)
pyplot.legend()
pyplot.title("_test_make_TDMA_slot_")
pyplot.figure()
pyplot.plot(t_s / 1e-6, s, label="Continuous ASK signal")
pyplot.plot(t_s / 1e-6, s_slot, label="Slot=%d/%d ASK signal" % (S, N))
pyplot.ylabel("amplitude")
pyplot.xlabel("time [microsec]")
pyplot.legend()
pyplot.title("_test_make_TDMA_slot_")
def plot():
df = pd.read_csv('filename_var.get()')
x = df['x']
y = df['y']
plt.figure("Time vs Frequency domain")
plt.subplot(211) #time domain
plt.plot(y, x, 'r')
plt.xlabel('Time [ns]')
plt.ylabel('Value (DEC)')
plt.title('Time and Frequency domain', fontsize=14)
plt.show()
plt.grid()
plt.subplot(212) #frequency domain
plt.psd(x, 2048, 250e3) #65536
plt.xlabel('Frequency [Hz]')
plt.ylabel('PSD [db/Hz]')
def plot_segment(filename, eeg, stage, step):
plt.figure()
_psd, f = plt.psd(eeg[step * fs * 30:(step + 1) * fs * 30],
Fs=fs,
return_line=False)
PSD_W.append(_psd) if stage == 'W' else PSD_1.append(_psd)
# plt.axis([0, 140, -90, -30])
# plt.suptitle('PSD of ' + filename + ' using pyplot.psd()', fontweight ="bold")
# plt.savefig('1220/PSD_' + filename + '_' + stage + '_' + str(step) + '.png')
plt.close()
pass
def _filter_meg_label_ts_parallel(p):
from mne.filter import high_pass_filter
label_data, label_ind, fs, low_freq_cut_off, do_plot = p
filter_label_data = np.empty(label_data.shape)
E = label_data.shape[1]
for epoch_ind in range(E):
x = label_data[:, epoch_ind]
if do_plot:
plt.psd(x, Fs=fs)
plt.show()
x_filter = high_pass_filter(x,
Fs=fs,
Fp=low_freq_cut_off,
n_jobs=1,
verbose=False)
if do_plot:
plt.psd(x_filter, Fs=fs)
plt.show()
filter_label_data[:, epoch_ind] = x_filter
return filter_label_data, label_ind
def plotPSDMean(samples, area, monkey, color, color_mean):
"""
plot the PSD mean and the PSD on the same graph for the samples
"""
psd_lst = []
f_axis = []
psd, f = plt.psd(samples[0],
NFFT=1024,
Fs=SAMPLE_RATE,
noverlap=896,
color=color,
label="area " + str(area))
for x in f:
if x < 150:
f_axis.append(x)
psd_lst.append(psd[:len(f_axis)])
i = 0
for x in tqdm(samples):
if i == 0:
i += 1
continue
psd, f = plt.psd(x,
NFFT=1024,
Fs=SAMPLE_RATE,
noverlap=896,
color=color)
psd_lst.append(psd[:len(f_axis)])
plt.show()
psd_lst = np.array(psd_lst)
# for p in psd_lst:
# plt.plot(f_axis,10 * np.log10(p), color=color)
psd_mean = psd_lst.mean(axis=0)
psd_mean = 10 * np.log10(psd_mean)
# plt.plot(f_axis, psd_mean, color=color_mean, label="Mean area "+str(area))
# plt.title(monkey + " area " + str(area) + " | PSD mean and PSD")
# plt.legend()
# plt.show()
return psd_lst, psd_mean, f_axis
def test_audio_mfcc_plus(path, start, length, FPS):
i = 0
v = 0
for this_start in range(start, start + length, 30):
j = 0
test_list_mfcc_plus = []
result = []
print(this_start)
audio, video = load_movie(path, this_start, 30, FPS)
audio_array = audio.to_soundarray()
audio_array = (audio_array[:, 0] + audio_array[:, 1]) / 2
mfcc_structure = psf.mfcc(audio_array, samplerate=16000, winlen=0.576, winstep=0.576, nfft=16384, numcep=26, nfilt=52)
mfcc_structure = np.asarray(mfcc_structure)
r = int(len(mfcc_structure[:,0]))
for k in range(0, r):
s = mfcc_structure[k,:]
a = audio_array[k * 9056 : (k + 1) * 9056]
zero_crossings = ((a[:-1] * a[1:]) < 0).sum() # Source: https://stackoverflow.com/questions/30272538/python-code-for-counting-number-of-zero-crossings-in-an-array
zero_crossings = zero_crossings / (10 ** 3)
maximum_amplitude = np.max(plt.psd(a)[0])
spectral_centroid = librosa.feature.spectral_centroid(y=a, n_fft=16384, sr=16000)
spectral_centroid = np.resize(spectral_centroid, (1, 11))
spectral_centroid = spectral_centroid / (10 ** 3)
s = np.append(s, zero_crossings)
s = np.append(s, maximum_amplitude)
s = np.append(s, spectral_centroid)
s = utils.normalize(s)
test_list_mfcc_plus.append(s)
for t in test_list_mfcc_plus:
t = t.reshape(1, 1, 39, 1)
result.append(cnn_mfcc_plus.predict(t))
for res in result:
m = max(res)
m = max(m)
i = i + 1
j = j + 1
if(res[0][0] == m):
print("Segment " + str(i) + " is non-violent.")
video.save_frame("Output/MFCC+/Non-Violent/Image/frame" + str(i) +".jpeg", t = (j - 1) * 0.566)
wav.write("Output/MFCC+/Non-Violent/Sound/frame" + str(i) + ".wav", FPS, audio_array[int((j - 1) * FPS * 0.566):int(j * FPS * 0.566)])
if(res[0][1] == m):
v = v + 1
print("Segment " + str(i) + " is violent.")
video.save_frame("Output/MFCC+/Violent/Image/frame" + str(i) +".jpeg", t = (j - 1) * 0.566)
wav.write("Output/MFCC+/Violent/Sound/frame" + str(i) + ".wav", FPS, audio_array[int((j - 1) * FPS * 0.566):int(j * FPS * 0.566)])
video.close()
audio.close()
print("Amount of violence: " + str(v / i * 100) + "%")
def test_compares_psd():
"""Test PSD estimation on raw for plt.psd and scipy.signal.welch
"""
raw = io.Raw(raw_fname)
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more
# picks MEG gradiometers
picks = pick_types(raw.info,
meg='grad',
eeg=False,
stim=False,
exclude=exclude)[:2]
tmin, tmax = 0, 10 # use the first 60s of data
fmin, fmax = 2, 70 # look at frequencies between 5 and 70Hz
n_fft = 2048
# Compute psds with the new implementation using Welch
psds_welch, freqs_welch = psd_welch(raw,
tmin=tmin,
tmax=tmax,
fmin=fmin,
fmax=fmax,
proj=False,
picks=picks,
n_fft=n_fft,
n_jobs=1)
# Compute psds with plt.psd
start, stop = raw.time_as_index([tmin, tmax])
data, times = raw[picks, start:(stop + 1)]
from matplotlib.pyplot import psd
out = [psd(d, Fs=raw.info['sfreq'], NFFT=n_fft) for d in data]
freqs_mpl = out[0][1]
psds_mpl = np.array([o[0] for o in out])
mask = (freqs_mpl >= fmin) & (freqs_mpl <= fmax)
freqs_mpl = freqs_mpl[mask]
psds_mpl = psds_mpl[:, mask]
assert_array_almost_equal(psds_welch, psds_mpl)
assert_array_almost_equal(freqs_welch, freqs_mpl)
assert_true(psds_welch.shape == (len(picks), len(freqs_welch)))
assert_true(psds_mpl.shape == (len(picks), len(freqs_mpl)))
assert_true(np.sum(freqs_welch < 0) == 0)
assert_true(np.sum(freqs_mpl < 0) == 0)
assert_true(np.sum(psds_welch < 0) == 0)
assert_true(np.sum(psds_mpl < 0) == 0)
def plotpsd(data: np.ndarray, fs: int, nmode: str):
ax = figure().gca()
Pxx, f = psd(data, NFFT=NFFT, Fs=fs, label="measured")
ax.set_xscale("log")
ax.set_xlim((100, None))
f2 = f[-2]
a2 = 10 * np.log10(Pxx[-2])
f1 = 100
octaves = np.log2(f2 / f1)
if nmode == "white":
ax.axhline(a2, linestyle="--", color="black", label="theoretical")
elif nmode == "pink":
ax.plot(
[f1, f2],
[3 * octaves + a2, a2],
linestyle="--",
color="black",
label="theoretical",
)
elif nmode == "blue":
ax.plot(
[f1, f2],
[-3 * octaves + a2, a2],
linestyle="--",
color="black",
label="theoretical",
)
elif nmode == "brown":
ax.plot(
[f1, f2],
[6 * octaves + a2, a2],
linestyle="--",
color="black",
label="theoretical",
)
elif nmode == "violet":
ax.plot(
[f1, f2],
[-6 * octaves + a2, a2],
linestyle="--",
color="black",
label="theoretical",
)
ax.set_title(f"{nmode} noise")
ax.legend(loc="best")
def wdm_test():
# grid_size = np.array([50, 50, 75, 50, 50, 75, 50, 100, 50, 75, 100, 75, 100])
# grid = [0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1]
# start_freq = 193.1e12
grid_size = np.array([50e9, 50e9, 50e9, 50e9])
grid = [1, 1, 1, 1]
modu = []
for i, g in enumerate(grid_size):
modu.append(
QamModulator(Laser(193.1e12 + g * i, 0, False), IQ(),
PulseShaping(0.2, 1024), DAC(),
SignalParam(sps_in_fiber=14)))
modu[-1].modulate('cpu')
wdm = Mux(modu, grid_size, 193.1e12, grid=grid)
wdm_signal = wdm.mux_signal('cpu')
print(len(wdm_signal.symbols))
import matplotlib.pyplot as plt
plt.psd(wdm_signal.samples_in_fiber[0])
plt.show()
def plot_psd():
global t, ch1, ch2, sps, sampl, title
plt.clf()
nfft=2048 #int(2**np.ceil(np.log2(sampl)));
ax1=plt.subplot(211)
(Pxx, freqs)=plt.psd(ch1, NFFT=nfft, Fs=sps, window=mlab.window_hanning)
plt.title('PSD (NFFT='+str(nfft)+', Fs='+str(sps)+'Hz, hann) from '+title)
plt.xlabel('')
ax2=plt.subplot(212)
(Pxx, freqs)=plt.psd(ch2, NFFT=nfft, Fs=sps, window=mlab.window_hanning)
plt.ylabel('')
ax2.set_ylim(ax1.get_ylim())
fig=plt.gcf()
f_dpi=fig.get_dpi()
fig.set_size_inches(1200.0/f_dpi, 500.0/f_dpi);
plt.savefig(os.path.join(_LOCATION_CHARTS,"last_psd.png"), dpi=96, bbox_inches='tight')
plt.clf()
print "plotting psd finished"
def plot_psd_OFDM_symbols(): # pragma: no cover
"""Plot the power spectral density of OFDM modulated symbols.
This function is not used in any unittest, but it is interesting to
visualize that the modulate method of the OFDM class is working as it
should.
"""
from matplotlib import pyplot as plt
# xxxxxxxxxx OFDM Details xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
fft_size = 64
cp_size = 12
num_used_subcarriers = 52
ofdm_object = ofdm.OFDM(fft_size, cp_size, num_used_subcarriers)
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# xxxxxxxxxx Input generation (not part of OFDM) xxxxxxxxxxxxxxxxxxxxxx
num_bits = 2500
# generating 1's and 0's
ip_bits = np.random.random_integers(0, 1, num_bits)
# Number of modulated symbols
# num_mod_symbols = num_bits * 1
# xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# BPSK modulation
# bit0 --> -1
# bit1 --> +1
ip_mod = 2 * ip_bits - 1
# OFDM Modulation
output = ofdm_object.modulate(ip_mod)
# xxxxxxxxxx Plot the PSD xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
# MATLAB code to plot the power spectral density
# close all
fsMHz = 20e6
Pxx, W = plt.psd(output, NFFT=fft_size, Fs=fsMHz)
# [Pxx,W] = pwelch(output,[],[],4096,20);
plt.plot(
W,
10 * np.log10(Pxx)
)
plt.xlabel('frequency, MHz')
plt.ylabel('power spectral density')
plt.title('Transmit spectrum OFDM (based on 802.11a)')
plt.show()
def test_compares_psd():
"""Test PSD estimation on raw for plt.psd and scipy.signal.welch
"""
raw = io.read_raw_fif(raw_fname)
exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more
# picks MEG gradiometers
picks = pick_types(raw.info, meg='grad', eeg=False, stim=False,
exclude=exclude)[:2]
tmin, tmax = 0, 10 # use the first 60s of data
fmin, fmax = 2, 70 # look at frequencies between 5 and 70Hz
n_fft = 2048
# Compute psds with the new implementation using Welch
psds_welch, freqs_welch = psd_welch(raw, tmin=tmin, tmax=tmax,
fmin=fmin, fmax=fmax,
proj=False, picks=picks,
n_fft=n_fft, n_jobs=1)
# Compute psds with plt.psd
start, stop = raw.time_as_index([tmin, tmax])
data, times = raw[picks, start:(stop + 1)]
from matplotlib.pyplot import psd
out = [psd(d, Fs=raw.info['sfreq'], NFFT=n_fft) for d in data]
freqs_mpl = out[0][1]
psds_mpl = np.array([o[0] for o in out])
mask = (freqs_mpl >= fmin) & (freqs_mpl <= fmax)
freqs_mpl = freqs_mpl[mask]
psds_mpl = psds_mpl[:, mask]
assert_array_almost_equal(psds_welch, psds_mpl)
assert_array_almost_equal(freqs_welch, freqs_mpl)
assert_true(psds_welch.shape == (len(picks), len(freqs_welch)))
assert_true(psds_mpl.shape == (len(picks), len(freqs_mpl)))
assert_true(np.sum(freqs_welch < 0) == 0)
assert_true(np.sum(freqs_mpl < 0) == 0)
assert_true(np.sum(psds_welch < 0) == 0)
assert_true(np.sum(psds_mpl < 0) == 0)
def _plot_freq_hist(tdms, **kargs):
ti = kargs['ti']
fi = kargs['fi']
fft_len = kargs['fft_len']
fft_scale = kargs['fft_scale']
n_bins = kargs['n_bins']
# bins = list()
s, f = plt.psd(tdms.wav.__getslice__(*ti),
fft_len,
tdms.fs)
sfi = None
ffi = None
for v, i in zip(f, xrange(len(f))):
if fi[0] is not None and v > fi[0]:
if sfi is None:
sfi = i
if fi[1] is not None and v > fi[1]:
ffi = i
break
if sfi is None:
sfi = 0
if ffi is None:
ffi = len(f)
s = s[sfi:ffi]
plt.cla()
# s = tdms.wav.__getslice__(*ti)
t = sum(s)
m = len(s) / n_bins
r = len(s) - m * n_bins
for i in xrange(n_bins):
step = i * m + (i if i < r else r)
b = step, step + m + (1 if i < r else 0)
# bins.append(b, sum(s.__getslice__(*b)))
plt.bar(b[0] + sfi, sum(s.__getslice__(*b))/t, b[1] - b[0])
plt.ylabel(r'Amplitude $\frac{mV^2}{Hz}$')
plt.xlabel(u'Frequency ($Hz$)')
def power_spectral_density(data_array, frequency, segment_size=256, window_method=False):
"""Return the power spectral density using matplotlib.pyplot.psd function."""
return psd(data_array, NFFT=segment_size, Fs = frequency)
# Generate source time courses from 2 dipoles and the correspond evoked data
times = np.arange(300, dtype=np.float) / raw.info['sfreq'] - 0.1
rng = np.random.RandomState(42)
def data_fun(times):
"""Function to generate random source time courses"""
return (1e-9 * np.sin(30. * times) *
np.exp(- (times - 0.15 + 0.05 * rng.randn(1)) ** 2 / 0.01))
stc = simulate_sparse_stc(fwd['src'], n_dipoles=2, times=times,
random_state=42, labels=labels, data_fun=data_fun)
###############################################################################
# Generate noisy evoked data
picks = mne.pick_types(raw.info, meg=True, exclude='bads')
iir_filter = fit_iir_model_raw(raw, order=5, picks=picks, tmin=60, tmax=180)[1]
snr = 6. # dB
evoked = simulate_evoked(fwd, stc, info, cov, snr, iir_filter=iir_filter)
###############################################################################
# Plot
plot_sparse_source_estimates(fwd['src'], stc, bgcolor=(1, 1, 1),
opacity=0.5, high_resolution=True)
plt.figure()
plt.psd(evoked.data[0])
evoked.plot()
def do_AGN_Kepler():
sname = 'Zw 229-15'
data = fits.open(data_dir + 'kepler_zw229_Q7.fits')[1].data
jdate = data['time']
flux = np.array(data['SAP_FLUX'], dtype=float)
ferr = np.array(data['SAP_FLUX_ERR'], dtype=float)
keep = np.where(np.logical_and(np.isfinite(jdate), np.isfinite(flux)))[0]
jdate = jdate[keep]
jdate -= jdate.min()
flux = flux[keep]
ferr = ferr[keep]
df = flux[1:] - flux[0:-1] # remove outliers
keep = np.where(np.abs(df) < 56.0)
jdate = jdate[keep]
flux = flux[keep]
ferr = ferr[keep]
load_pickle = True
if load_pickle:
carma_sample = cPickle.load(open(data_dir + 'zw229.pickle', 'rb'))
# rerun MLE
# carma_model = cm.CarmaModel(jdate, flux, ferr, p=carma_sample.p, q=carma_sample.q)
# mle = carma_model.get_map(carma_sample.p, carma_sample.q)
# carma_sample.add_map(mle)
else:
carma_sample = make_sampler_plots(jdate, flux, ferr, 7, 'zw229_', sname, njobs=1)
# transform the flux through end matching
tflux = flux - flux[0]
slope = (tflux[-1] - tflux[0]) / (jdate[-1] - jdate[0])
tflux -= slope * jdate
plt.subplot(111)
dt = jdate[1] - jdate[0]
pgram, freq = plt.psd(tflux, 512, 2.0 / dt, detrend=detrend_mean)
plt.clf()
ax = plt.subplot(111)
print 'Getting bounds on PSD...'
psd_low, psd_hi, psd_mid, frequencies = carma_sample.plot_power_spectrum(percentile=95.0, sp=ax, doShow=False,
color='SkyBlue', nsamples=5000)
psd_mle = cm.power_spectrum(frequencies, carma_sample.mle['sigma'], carma_sample.mle['ar_coefs'],
ma_coefs=np.atleast_1d(carma_sample.mle['ma_coefs']))
ax.loglog(freq / 2.0, pgram, 'o', color='DarkOrange')
psd_slope = 3.14
above_noise = np.where(freq / 2.0 < 1.0)[0]
psd_norm = np.mean(np.log(pgram[above_noise[1:]]) + 3.14 * np.log(freq[above_noise[1:]] / 2.0))
psd_plaw = np.exp(psd_norm) / (freq[1:] / 2.0) ** psd_slope
ax.loglog(freq[1:] / 2.0, psd_plaw, '-', lw=2, color='DarkOrange')
ax.loglog(frequencies, psd_mid, '--b', lw=2)
noise_level = 2.0 * dt * np.mean(ferr ** 2)
ax.loglog(frequencies, np.ones(frequencies.size) * noise_level, color='grey', lw=2)
ax.set_ylim(bottom=noise_level / 100.0)
ax.annotate("Measurement Noise Level", (3.0 * ax.get_xlim()[0], noise_level / 2.5))
ax.set_xlabel('Frequency [1 / day]')
ax.set_ylabel('Power Spectral Density [flux$^2$ day]')
plt.title(sname)
plt.savefig(base_dir + 'plots/zw229_psd.eps')
plt.clf()
carma_sample.plot_1dpdf('measerr_scale')
plt.savefig(base_dir + 'plots/zw229_measerr_scale.eps')
measerr_scale = carma_sample.get_samples('measerr_scale')
print "95% credibility interval on Kepler measurement error scale parameter:", np.percentile(measerr_scale, 2.5), \
np.percentile(measerr_scale, 97.5)
pfile = open(data_dir + 'zw229.pickle', 'wb')
cPickle.dump(carma_sample, pfile)
pfile.close()
import numpy as np
import matplotlib.pyplot as plt
data = np.loadtxt('/home/pauln/Dropbox/DocumentsF/' +
'_Research/LabjackDevelopment/2014-02-24_Data/2014_02_24-run01Data.txt',
skiprows=1)
dt = []
times = data[:, 0]
n = len(times) - 1
dt[0:n] = times[1:n] - times[0:n - 1]
deltaT = np.mean(dt)
print deltaT
tbSignal = data[:, 3]
tb = tbSignal[0:len(times)]
timeSlice = times[0:len(times)]
plt.subplot(211)
plt.plot(timeSlice, tb)
plt.subplot(212)
rawPSD = plt.psd(tb, NFFT=511, Fs=1.0 / deltaT)
plt.show()
# coding: utf-8
import console
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mlab as ml
# console.clear()
file_name = 'wc-cent-2.npy'
data = np.load(file_name)
fig_mag = plt.figure()
plt.psd(data[:, 0], NFFT=256, Fs=80, window=ml.window_hanning, detrend = ml.detrend_none, scale_by_freq = True, noverlap = 0, pad_to = None, sides = 'onesided')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Power/Frequency (dB/Hz)')
plt.title('PSD X')
plt.show()
raw.info['bads'] = ['MEG 2443', 'EEG 053'] # mark bad channels
# Set up pick list: Gradiometers - bad channels
picks = mne.pick_types(raw.info, meg='grad', exclude='bads')
order = 5 # define model order
picks = picks[:1]
# Estimate AR models on raw data
b, a = fit_iir_model_raw(raw, order=order, picks=picks, tmin=60, tmax=180)
d, times = raw[0, 10000:20000] # look at one channel from now on
d = d.ravel() # make flat vector
innovation = signal.convolve(d, a, 'valid')
d_ = signal.lfilter(b, a, innovation) # regenerate the signal
d_ = np.r_[d_[0] * np.ones(order), d_] # dummy samples to keep signal length
###############################################################################
# Plot the different time series and PSDs
plt.close('all')
plt.figure()
plt.plot(d[:100], label='signal')
plt.plot(d_[:100], label='regenerated signal')
plt.legend()
plt.figure()
plt.psd(d, Fs=raw.info['sfreq'], NFFT=2048)
plt.psd(innovation, Fs=raw.info['sfreq'], NFFT=2048)
plt.psd(d_, Fs=raw.info['sfreq'], NFFT=2048, linestyle='--')
plt.legend(('Signal', 'Innovation', 'Regenerated signal'))
plt.show()
import argparse
import sys
# Calculates sampling rate and plots 4 channel specgram of EEG data.csv passed in as in command line arg
eegData = pd.read_csv(sys.argv[1])
#eegData = pd.read_csv('Filtered_EEG3.csv')
time = (eegData['Timestamp (ms)'][eegData.shape[0] - 1] - eegData['Timestamp (ms)'][0]) / 1000
samples = eegData.shape[0] - 1
samplingRate = samples/time
print('estimated sampling rate: ', samplingRate)
plt.figure()
plt.subplot(2,2,1)
plt.psd(eegData['Electrode 1'], Fs=samplingRate)
plt.xlim(0,65)
plt.ylim(-60,20)
plt.subplot(2,2,2)
plt.psd(eegData['Electrode 2'], Fs=samplingRate)
plt.xlim(0,65)
plt.ylim(-60,20)
plt.ylabel('')
plt.subplot(2,2,3)
plt.psd(eegData['Electrode 3'], Fs=samplingRate)
plt.xlim(0,65)
plt.ylim(-60,20)
plt.ylabel('')
origin='upper',
#vmax=fft_vmax,
#vmin=fft_vmin,
)
#images's PSD
ax = fig.add_subplot(235)
ax.set_title("PSD")
imgWidth=originalImage.shape[1] #np.matrix has matrix-like dimensions, height first
assert imgWidth % 2 == 0, "Image width must be even"
#frames per second == 25; however the ticmarks won't fit on X axis, using default Fs=2
freq = originalImage.size * 25
psdShape = lambda m: np.reshape(m, m.size)
plt.psd(psdShape(originalImage), NFFT=imgWidth, label="original")
plt.psd(psdShape(encodedImage), NFFT=imgWidth, label="encoded")
plt.psd(psdShape(encodedImage-originalImage), NFFT=imgWidth, label="difference")
#filtered images' PSD
plt.psd(psdShape(encodedLaplace1), NFFT=imgWidth, label='laplace1')
#plt.psd(psdShape(encodedCanny), label='canny')
#plt.psd(psdShape(encodedSobel), label='sobel')
leg = ax.legend(('original', 'encoded', 'difference', 'laplace1'),
'upper center', shadow=True)
ax = fig.add_subplot(236)
ax.set_title("CannySharpen(Laplace1(enc))")
imshow(encodedCannyLaplace1, interpolation='nearest',
cmap=cm.gray,
origin='upper',
#vmax=spatial_vmax,
def do_simulated_regular():
# first generate some data assuming a CARMA(5,3) process on a uniform grid
sigmay = 2.3 # dispersion in lightcurve
p = 5 # order of AR polynomial
qpo_width = np.array([1.0/100.0, 1.0/100.0, 1.0/500.0])
qpo_cent = np.array([1.0/5.0, 1.0/50.0])
ar_roots = cm.get_ar_roots(qpo_width, qpo_cent)
ma_coefs = np.zeros(p)
ma_coefs[0] = 1.0
ma_coefs[1] = 4.5
ma_coefs[2] = 1.25
sigsqr = sigmay ** 2 / cm.carma_variance(1.0, ar_roots, ma_coefs=ma_coefs)
ny = 1028
time = np.arange(0.0, ny)
y0 = cm.carma_process(time, sigsqr, ar_roots, ma_coefs=ma_coefs)
ysig = np.ones(ny) * np.sqrt(1e-2)
# ysig = np.ones(ny) * np.sqrt(1e-6)
y = y0 + ysig * np.random.standard_normal(ny)
froot = base_dir + 'plots/car5_regular_'
plt.subplot(111)
plt.plot(time, y0, 'k-')
plt.plot(time, y, '.')
plt.xlim(time.min(), time.max())
plt.xlabel('Time')
plt.ylabel('CARMA(5,3) Process')
plt.savefig(froot + 'tseries.eps')
ar_coef = np.poly(ar_roots)
print 'Getting maximum-likelihood estimates...'
carma_model = cm.CarmaModel(time, y, ysig)
pmax = 7
MAP, pqlist, AIC_list = carma_model.choose_order(pmax, njobs=-1)
# convert lists to a numpy arrays, easier to manipulate
pqarray = np.array(pqlist)
pmodels = pqarray[:, 0]
qmodels = pqarray[:, 1]
AICc = np.array(AIC_list)
plt.clf()
plt.subplot(111)
for i in xrange(qmodels.max()+1):
plt.plot(pmodels[qmodels == i], AICc[qmodels == i], 's-', label='q=' + str(i), lw=2)
plt.legend()
plt.xlabel('p')
plt.ylabel('AICc(p,q)')
plt.xlim(0, pmodels.max() + 1)
plt.savefig(froot + 'aic.eps')
plt.close()
nsamples = 50000
carma_sample = carma_model.run_mcmc(nsamples)
carma_sample.add_mle(MAP)
plt.subplot(111)
pgram, freq = plt.psd(y)
plt.clf()
ax = plt.subplot(111)
print 'Getting bounds on PSD...'
psd_low, psd_hi, psd_mid, frequencies = carma_sample.plot_power_spectrum(percentile=95.0, sp=ax, doShow=False,
color='SkyBlue', nsamples=5000)
psd_mle = cm.power_spectrum(frequencies, carma_sample.mle['sigma'], carma_sample.mle['ar_coefs'],
ma_coefs=np.atleast_1d(carma_sample.mle['ma_coefs']))
ax.loglog(freq / 2.0, pgram, 'o', color='DarkOrange')
psd = cm.power_spectrum(frequencies, np.sqrt(sigsqr), ar_coef, ma_coefs=ma_coefs)
ax.loglog(frequencies, psd, 'k', lw=2)
ax.loglog(frequencies, psd_mle, '--b', lw=2)
noise_level = 2.0 * np.mean(ysig ** 2)
ax.loglog(frequencies, np.ones(frequencies.size) * noise_level, color='grey', lw=2)
ax.set_ylim(bottom=noise_level / 100.0)
ax.annotate("Measurement Noise Level", (3.0 * ax.get_xlim()[0], noise_level / 2.5))
ax.set_xlabel('Frequency')
ax.set_ylabel('Power Spectral Density')
plt.savefig(froot + 'psd.eps')
print 'Assessing the fit quality...'
carma_sample.assess_fit(doShow=False)
plt.savefig(froot + 'fit_quality.eps')
pfile = open(data_dir + froot + '.pickle', 'wb')
cPickle.dump(carma_sample, pfile)
pfile.close()
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.mlab as mlab
fs = 1000
t = np.linspace(0, 0.3, 301)
A = np.array([2, 8]).reshape(-1, 1)
f = np.array([150, 140]).reshape(-1, 1)
xn = (A * np.exp(2j * np.pi * f * t)).sum(axis=0) + 5 * np.random.randn(*t.shape)
yticks = np.arange(-50, 30, 10)
xticks = np.arange(-500, 550, 100)
plt.subplots_adjust(hspace=0.45, wspace=0.3)
ax = plt.subplot(1, 2, 1)
plt.psd(xn, NFFT=301, Fs=fs, window=mlab.window_none, pad_to=1024,
scale_by_freq=True)
plt.title('Periodogram')
plt.yticks(yticks)
plt.xticks(xticks)
plt.grid(True)
plt.xlim(-500, 500)
plt.subplot(1, 2, 2, sharex=ax, sharey=ax)
plt.psd(xn, NFFT=150, Fs=fs, window=mlab.window_none, noverlap=75, pad_to=512,
scale_by_freq=True)
plt.title('Welch')
plt.xticks(xticks)
plt.yticks(yticks)
plt.ylabel('')
plt.grid(True)
plt.xlim(-500, 500)
import pylab as pyl array = t2.copy() length = len(array) # Create time data for x axis based on array length x = sy.linspace(0.00001, length*0.00001, num=length) # Do FFT analysis of array FFT = sy.fft(array) # Getting the related frequencies freqs = syfp.fftfreq(array.size, d=(x[1]-x[0])) # Create subplot windows and show plot pyl.subplot(211) pyl.plot(x, array) pyl.subplot(212) pyl.plot(freqs, sy.log10(FFT), 'x') pyl.show() import matplotlib.pylab as plt import matplotlib.mlab as mlb Fs = 1./(d[1]- d[0]) # sampling frequency plt.psd(array, Fs=Fs, detrend=mlb.detrend_mean) plt.show() plot(X, 'b-') dataF = np.abs(np.fft.fftshift(np.fft.fft(t2))) plot(dataF, 'b-')
np.random.seed(19680801) dt = 0.01 t = np.arange(0, 10, dt) nse = np.random.randn(len(t)) r = np.exp(-t/0.05) cnse = np.convolve(nse, r)*dt cnse = cnse[:len(t)] s = 0.1*np.sin(2*np.pi*t) + cnse plt.subplot(211) plt.plot(t, s) plt.subplot(212) plt.psd(s, 512, 1/dt) plt.show() ############################################################################### # Compare this with the equivalent Matlab code to accomplish the same thing:: # # dt = 0.01; # t = [0:dt:10]; # nse = randn(size(t)); # r = exp(-t/0.05); # cnse = conv(nse, r)*dt; # cnse = cnse(1:length(t)); # s = 0.1*sin(2*pi*t) + cnse; # # subplot(211)
def plot_joint_psd(tdms_list, ti_list, fft_len=256, fft_scale='db', fi=None,
bar=False, figure_size=(8,6), output_fn=None, figure_resolution=80):
plt.figure(figsize=figure_size, dpi=figure_resolution)
psd_len = fft_len / 2 + 1
# data_list = np.zeros((len(tdms_list), psd_len))
data_dict = dict()
for tdms, ti, i, in zip(tdms_list, ti_list, xrange(len(tdms_list))):
ti = (int(round(ti[0] * tdms.fs)), int(round((ti[1] * tdms.fs))))
t = tdms.wav.__getslice__(*ti)
data, f_list = plt.psd(t, fft_len, Fs=tdms.fs)
if fft_scale == 'db':
data = 10 * np.log10(data)
if data_dict.has_key(tdms.group_id):
data_dict[tdms.group_id] = \
np.concatenate((data_dict[tdms.group_id], [data]))
else:
data_dict[tdms.group_id] = np.array([data])
if fi != None:
fi = (fi[0] if fi[0] is not None else 0,
fi[1] if fi[1] is not None else tdms_list[0].fs / 2)
f_start_idx = None
f_stop_idx = None
for f, i in zip(f_list, xrange(len(f_list))):
if f_start_idx is None and f > fi[0]:
f_start_idx = i - 1
if f_stop_idx is None and f > fi[1]:
f_stop_idx = i - 1
f_list = f_list[f_start_idx:f_stop_idx]
plt.cla()
if fft_scale == 'db':
plt.ylabel(r'Amplitude $\frac{mV^2}{Hz}$ ($dB$)')
elif fft_scale == 'linear':
plt.ylabel(r'Amplitude $\frac{mV^2}{Hz}$')
plt.xlabel(u'Frequency ($Hz$)')
xticks_list = ([], [])
for key, data, i in zip(data_dict.iterkeys(), data_dict.itervalues(), xrange(len(data_dict))):
data = data[:,f_start_idx:f_stop_idx]
if bar:
data_sum = data.sum(1)
plt.bar(i+0.1, data_sum.mean(), yerr=data_sum.std(),
error_kw=dict(elinewidth=6, capsize=10, ecolor='black'), color='white')
xticks_list[0].append(i+0.5)
xticks_list[1].append(key)
else:
plt.errorbar(f_list, data.mean(0), data.std(0), label=str(key), ecolor='b')
if bar:
plt.xlim((0, len(data_dict)))
plt.xticks(*xticks_list)
print xticks_list
else:
plt.legend()
plt.xlim((min(f_list), max(f_list)))
if output_fn is not None:
plt.savefig(output_fn)
plt.show()
def problem_6():
"""
This function uses the HP filter created before to filter the data
before repeating the same process as in problem 5. We will plot both the
trend and cycle produced by the HP filter.
Inputs:
None
Outputs:
This function automatically generates plots of the spectra for the
filtered data.
Notes:
This function uses the function hp_filter found in the file hp_filter.py
"""
gdpT, gdpC = hp.hp_filter(gdp)
cpiT, cpiC = hp.hp_filter(cpi)
consT, consC = hp.hp_filter(cons)
invT, invC = hp.hp_filter(inv)
plt.figure()
plt.psd(gdpT)
plt.title('GDP Trend Spectrum')
plt.show()
plt.figure()
plt.psd(cpiT)
plt.title('CPI Trend Spectrum')
plt.show()
plt.figure()
plt.psd(consT)
plt.title('Consumption Trend Spectrum')
plt.show()
plt.figure()
plt.psd(invT)
plt.title('Investment Trend Spectrum')
plt.show()
plt.figure()
plt.psd(gdpC)
plt.title('GDP Cycle Spectrum')
plt.show()
plt.figure()
plt.psd(cpiC)
plt.title('CPI Cycle Spectrum')
plt.show()
plt.figure()
plt.psd(consC)
plt.title('Consumption Cycle Spectrum')
plt.show()
plt.figure()
plt.psd(invC)
plt.title('Investment Cycle Spectrum')
plt.show()
def do_XRB():
sname = 'XTE 1550-564'
data_file = data_dir + 'LC_B_3.35-12.99keV_1div128s_total.fits'
data = fits.open(data_file)[1].data
tsecs = data['TIME']
flux = data['RATE']
dt = tsecs[1:] - tsecs[:-1]
gap = np.where(dt > 1)[0]
tsecs = tsecs[gap[0]+1:gap[1]][:40000]
flux = flux[gap[0]+1:gap[1]][:40000]
tsecs0 = tsecs.copy()
flux0 = flux.copy()
ndown_sample = 4000
idx = np.random.permutation(len(flux0))[:ndown_sample]
idx.sort()
tsecs = tsecs[idx]
logflux = np.log(flux[idx])
ferr = np.sqrt(flux[idx])
logf_err = ferr / flux[idx]
# # high-frequency sampling lightcurve
# high_cutoff = 10000
# tsecs_high = tsecs[:high_cutoff]
# logflux_high = np.log(flux[:high_cutoff])
# ferr_high = np.sqrt(flux[:high_cutoff])
# logferr_high = ferr_high / flux[:high_cutoff]
#
# ndown_sample_high = 1000
# idx_high = np.random.permutation(len(logflux_high))[:ndown_sample_high]
# idx_high.sort()
#
# # middle-frequency sampling lightcurve
# tsecs_mid = tsecs[high_cutoff:]
# logflux_mid = np.log(flux[high_cutoff:])
# ferr_mid = np.sqrt(flux[high_cutoff:])
# logf_err_mid = ferr_mid / flux[high_cutoff:]
# # logf_err = np.sqrt(0.00018002985939372774 / 2.0 / np.median(dt)) # eyeballed from periodogram
# # logf_err = np.ones(len(tsecs)) * logf_err
#
# ndown_sample_mid = 4000 - ndown_sample_high
# idx_mid = np.random.permutation(len(logflux_mid))[:ndown_sample_mid]
# idx_mid.sort()
#
# tsecs = np.concatenate((tsecs_high[idx_high], tsecs_mid[idx_mid]))
# logflux = np.concatenate((logflux_high[idx_high], logflux_mid[idx_mid]))
# logf_err = np.concatenate((logferr_high[idx_high], logf_err_mid[idx_mid]))
# idx = np.concatenate((idx_high, idx_mid))
plt.plot(tsecs0, np.log(flux0))
plt.errorbar(tsecs, logflux, yerr=logf_err)
print 'Measurement errors are', np.mean(logf_err) / np.std(logflux) * 100, ' % of observed standard deviation.'
print 'Mean time spacing:', np.mean(tsecs[1:] - tsecs[:-1])
# print 'Mean time spacing for high-frequency sampling:', np.mean(tsecs_high[idx_high[1:]]-tsecs_high[idx_high[:-1]])
# print 'Mean time spacing for low-frequency sampling:', np.mean(tsecs_mid[idx_mid[1:]]-tsecs_mid[idx_mid[:-1]])
plt.show()
plt.clf()
plt.plot(tsecs, logflux)
plt.show()
plt.hist(logflux, bins=100, normed=True)
plt.xlabel('log Flux')
print 'Standard deviation in lightcurve:', np.std(logflux)
print 'Typical measurement error:', np.mean(logf_err)
plt.show()
plt.clf()
assert np.all(np.isfinite(tsecs))
assert np.all(np.isfinite(logflux))
assert np.all(np.isfinite(logf_err))
dt_idx = tsecs[1:] - tsecs[:-1]
assert np.all(dt_idx > 0)
load_pickle = True
if load_pickle:
carma_sample = cPickle.load(open(data_dir + 'xte1550_p5q4.pickle', 'rb'))
else:
carma_sample = make_sampler_plots(tsecs, logflux, logf_err, 7, 'xte1550_', sname, njobs=7)
plt.subplot(111)
pgram, freq = plt.psd(np.log(flux0), 512, 2.0 / np.median(dt), detrend=detrend_mean)
plt.clf()
ax = plt.subplot(111)
print 'Getting bounds on PSD...'
psd_low, psd_hi, psd_mid, frequencies = carma_sample.plot_power_spectrum(percentile=95.0, sp=ax, doShow=False,
color='SkyBlue', nsamples=5000)
psd_mle = cm.power_spectrum(frequencies, carma_sample.mle['sigma'], carma_sample.mle['ar_coefs'],
ma_coefs=np.atleast_1d(carma_sample.mle['ma_coefs']))
ax.loglog(freq / 2, pgram, 'o', color='DarkOrange')
nyquist_freq = np.mean(0.5 / dt_idx)
nyquist_idx = np.where(frequencies <= nyquist_freq)[0]
ax.loglog(frequencies, psd_mle, '--b', lw=2)
# noise_level = 2.0 * np.mean(dt_idx) * np.mean(logf_err ** 2)
noise_level0 = 0.00018002985939372774 / 2.0 # scale the noise level seen in the PSD
noise_level = noise_level0 * (0.5 / np.median(dt)) / nyquist_freq
ax.loglog(frequencies[nyquist_idx], np.ones(len(nyquist_idx)) * noise_level, color='grey', lw=2)
# ax.loglog(frequencies, np.ones(len(frequencies)) * noise_level0)
ax.set_ylim(bottom=noise_level0 / 10.0)
ax.annotate("Measurement Noise Level", (3.0 * ax.get_xlim()[0], noise_level / 1.5))
ax.set_xlabel('Frequency [Hz]')
ax.set_ylabel('Power Spectral Density [fraction$^2$ Hz$^{-1}$]')
plt.title(sname)
plt.savefig(base_dir + 'plots/xte1550_psd.eps')
# plot the standardized residuals and compare with the standard normal
plt.clf()
kfilter, mu = carma_sample.makeKalmanFilter('map')
kfilter.Filter()
kmean = np.asarray(kfilter.GetMean())
kvar = np.asarray(kfilter.GetVar())
standardized_residuals = (carma_sample.y - mu - kmean) / np.sqrt(kvar)
plt.hist(standardized_residuals, bins=100, normed=True, color='SkyBlue', histtype='stepfilled')
plt.xlabel('Standardized Residuals')
plt.ylabel('Probability Distribution')
xlim = plt.xlim()
xvalues = np.linspace(xlim[0], xlim[1], num=100)
expected_pdf = np.exp(-0.5 * xvalues ** 2) / np.sqrt(2.0 * np.pi)
plt.plot(xvalues, expected_pdf, 'k', lw=3)
plt.title(sname)
plt.savefig(base_dir + 'plots/xte1550_resid_dist.eps')
# plot the autocorrelation function of the residuals and compare with the 95% confidence intervals for white
# noise
plt.clf()
maxlag = 50
wnoise_upper = 1.96 / np.sqrt(carma_sample.time.size)
wnoise_lower = -1.96 / np.sqrt(carma_sample.time.size)
plt.fill_between([0, maxlag], wnoise_upper, wnoise_lower, facecolor='grey')
lags, acf, not_needed1, not_needed2 = plt.acorr(standardized_residuals, maxlags=maxlag, lw=3)
plt.xlim(0, maxlag)
plt.ylim(-0.2, 0.2)
plt.xlabel('Time Lag')
plt.ylabel('ACF of Residuals')
plt.savefig(base_dir + 'plots/xte1550_resid_acf.eps')
# plot the autocorrelation function of the squared residuals and compare with the 95% confidence intervals for
# white noise
plt.clf()
squared_residuals = standardized_residuals ** 2
wnoise_upper = 1.96 / np.sqrt(carma_sample.time.size)
wnoise_lower = -1.96 / np.sqrt(carma_sample.time.size)
plt.fill_between([0, maxlag], wnoise_upper, wnoise_lower, facecolor='grey')
lags, acf, not_needed1, not_needed2 = plt.acorr(squared_residuals - squared_residuals.mean(), maxlags=maxlag,
lw=3)
plt.xlim(0, maxlag)
plt.ylim(-0.2, 0.2)
plt.xlabel('Time Lag')
plt.ylabel('ACF of Sqrd. Resid.')
plt.savefig(base_dir + 'plots/xte1550_sqrres_acf.eps')
if not load_pickle:
pfile = open(data_dir + 'xte1550_nonoise.pickle', 'wb')
cPickle.dump(carma_sample, pfile)
pfile.close()
