def wavel(signal, cadence): mother = 'morlet' sig_level = 0.95 #/ signal.std() t1 = np.linspace(0, cadence * signal.size, signal.size) wave, scales, freqs, coi = wavelet.cwt((signal - signal.mean()), cadence, wavelet=mother, dj=1 / 100.) power = (np.abs(wave))**2 # / scales[:,None] period = 1 / freqs alpha = 0.0 ## (variance=1 for the normalized SST) signif, fft_theor = wavelet.significance(signal, period, scales, 0, alpha, significance_level=sig_level, wavelet=mother) sig95 = np.ones([1, signal.size]) * signif[:, None] sig95 = power / sig95 ## indices for stuff idx = find_closest(period, coi.max()) ## Into minutes t1 /= 60 period /= 60 coi /= 60 return wave, scales, sig95, idx, t1, coi, period, power
def __get_significance(self, alpha, threshold, variance=1., dof=None, test_type=None): test_id = { "global": 0, "scale-average": 2, } def unknown_test_error(key): raise KeyError( f"Unknown test type {key}. Select from {test_id.keys()}") return wavelet.significance(variance, self.feature.dt, self.get_scales(), test_id.get(test_type, unknown_test_error), alpha, significance_level=threshold, wavelet=self.feature.mother, **({} if dof is None else { "dof": dof }))
mother = wavelet.Morlet(6) # Morlet mother wavelet with m=6 # The following routines perform the wavelet transform and siginificance # analysis for the chosen data set. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(dat, ds.dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, ds.dt, dj, mother) # Normalized wavelet and Fourier power spectra power = (numpy.abs(wave)) ** 2 fft_power = numpy.abs(fft) ** 2 period = 1 / freqs # Significance test. Where ratio power/sig95 > 1, power is significant. signif, fft_theor = wavelet.significance(1.0, ds.dt, scales, 0, alpha, significance_level=slevel, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 # Power rectification as of Liu et al. (2007). TODO: confirm if significance # test ratio should be calculated first. # power /= scales[:, None] # Calculates the global wavelet spectrum and determines its significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(std2, ds.dt, scales, 1, alpha, significance_level=slevel, dof=dof, wavelet=mother)
if True: alpha1, _, _ = wavelet.ar1(s1) # Lag-1 autocorrelation for red noise alpha2, _, _ = wavelet.ar1(s2) # Lag-1 autocorrelation for red noise else: alpha1 = alpha2 = 0.0 # Lag-1 autocorrelation for white noise # The following routines perform the wavelet transform and siginificance # analysis for two data sets. mother = 'morlet' W1, scales1, freqs1, coi1, _, _ = wavelet.cwt(s1/std1, dt, dj, s0, J, mother) signif1, fft_theor1 = wavelet.significance(1.0, dt, scales1, 0, alpha1, significance_level=slevel, wavelet=mother) W2, scales2, freqs2, coi2, _, _ = wavelet.cwt(s2/std2, dt, dj, s0, J, mother) signif2, fft_theor2 = wavelet.significance(1.0, dt, scales2, 0, alpha2, significance_level=slevel, wavelet=mother) power1 = (np.abs(W1)) ** 2 # Normalized wavelet power spectrum power2 = (np.abs(W2)) ** 2 # Normalized wavelet power spectrum ##--- RECTIFICATION OF BIAS (Liu et al, 2007; Veleda et al (2012)) powers1 = np.zeros_like(power1) for k in range(len(scales1)): powers1[k,:] = power1[k,:] / np.sqrt(scales1[k])
def main(): # Then, we load the dataset and define some data related parameters. In this # case, the first 19 lines of the data file contain meta-data, that we ignore, # since we set them manually (*i.e.* title, units). url = 'http://paos.colorado.edu/research/wavelets/wave_idl/nino3sst.txt' dat = numpy.genfromtxt(url, skip_header=19) title = 'NINO3 Sea Surface Temperature' label = 'NINO3 SST' units = 'degC' t0 = 1871.0 dt = 0.25 # In years #%% # We also create a time array in years. N = dat.size t = numpy.arange(0, N) * dt + t0 #%% # We write the following code to detrend and normalize the input data by its # standard deviation. Sometimes detrending is not necessary and simply # removing the mean value is good enough. However, if your dataset has a well # defined trend, such as the Mauna Loa CO\ :sub:`2` dataset available in the # above mentioned website, it is strongly advised to perform detrending. # Here, we fit a one-degree polynomial function and then subtract it from the # original data. p = numpy.polyfit(t - t0, dat, 1) dat_notrend = dat - numpy.polyval(p, t - t0) std = dat_notrend.std() # Standard deviation var = std ** 2 # Variance dat_norm = dat_notrend / std # Normalized dataset #%% # The next step is to define some parameters of our wavelet analysis. We # select the mother wavelet, in this case the Morlet wavelet with # :math:`\omega_0=6`. mother = wavelet.Morlet(6) s0 = 2 * dt # Starting scale, in this case 2 * 0.25 years = 6 months dj = 1 / 12 # Twelve sub-octaves per octaves J = 7 / dj # Seven powers of two with dj sub-octaves alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise #%% # The following routines perform the wavelet transform and inverse wavelet # transform using the parameters defined above. Since we have normalized our # input time-series, we multiply the inverse transform by the standard # deviation. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std #%% # We calculate the normalized wavelet and Fourier power spectra, as well as # the Fourier equivalent periods for each wavelet scale. power = (numpy.abs(wave)) ** 2 fft_power = numpy.abs(fft) ** 2 period = 1 / freqs #%% # We could stop at this point and plot our results. However we are also # interested in the power spectra significance test. The power is significant # where the ratio ``power / sig95 > 1``. signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 #%% # Then, we calculate the global wavelet spectrum and determine its # significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) #%% # We also calculate the scale average between 2 years and 8 years, and its # significance level. sel = find((period >= 2) & (period < 8)) Cdelta = mother.cdelta scale_avg = (scales * numpy.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance(var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) #%% # Finally, we plot our results in four different subplots containing the # (i) original series anomaly and the inverse wavelet transform; (ii) the # wavelet power spectrum (iii) the global wavelet and Fourier spectra ; and # (iv) the range averaged wavelet spectrum. In all sub-plots the significance # levels are either included as dotted lines or as filled contour lines. # Prepare the figure pyplot.close('all') pyplot.ioff() figprops = dict(figsize=(11, 8), dpi=72) fig = pyplot.figure(**figprops) #%% # First sub-plot, the original time series anomaly and inverse wavelet # transform. ax = pyplot.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(t, iwave, '-', linewidth=1, color=[0.5, 0.5, 0.5]) ax.plot(t, dat, 'k', linewidth=1.5) ax.set_title('a) {}'.format(title)) ax.set_ylabel(r'{} [{}]'.format(label, units))
def wavelet_analysis(z, tm, lon=None, lat=None, mother='Morlet', alpha=0.0, siglvl=0.95, loc=None, onlyloc=False, periods=None, sel_periods=[], show=False, save='', dsave='', prefix='', labels=dict(), title=None, name=None, fpath='', fpattern='', std=dict(), crange=None, levels=None, cmap=cm.GMT_no_green, debug=False): """Continuous wavelet transform and significance analysis. The analysis is made using the methodology and statistical approach suggested by Torrence and Compo (1998). Depending on the dimensions of the input array, three different kinds of approaches are taken. If the input array is one-dimensional then only a simple analysis is performed. If the array is bi- or three-dimensional then spectral Hovmoller diagrams are drawn for each Fourier period given within a range of +/-25%. PARAMETERS z (array like) : Input data. The data array should have one of these forms, z[tm], z[tm, lat] or z[tm, lat, lon]. tm (array like) : Time axis. It should contain values in matplotlib date format (i.e. number of days since 0001-01-01 UTC). lon (array like, optional) : Longitude. lat (array like, optional) : Latitude. mother (string, optional) : Gives the name of the mother wavelet to be used. Possible values are 'Morlet' (default), 'Paul' or 'Mexican hat'. alpha (float or dictionary, optional) : Lag-1 autocorrelation for background noise. Default value is 0.0 (white noise). If different autocorrelation coefficients should be used for different locations, then the input should contain a dictionary with 'lon', 'lat', 'map' keys as for the std parameter. siglvl (float, optional) : Significance level. Default value is 0.95. loc (array like, optional) : Special locations of interest. If the input array is of higher dimenstions, the output of the simple wavelet analysis of each of the locations is output. The list should contain the pairs of (lon, lat) for each locations of interest. onlyloc (boolean, optional) : If set to true then only the specified locations are analysed. The default is false. periods (array like, optional) : Special Fourier periods of interest in case of analysis of higher dimensions (in years). sel_periods (array like, optional) : Select which Fourier periods spectral power are averaged. show (boolean, optional) : If set to true the the resulting maps are shown on screen. save (string, optional) : The path in which the resulting plots are to be saved. If not set, then no images will be saved. dsave (string, optional) : If set, saves the scale averaged power spectrum series to this path. This is especially useful if memory is an issue. prefix (string, optional) : Prefix to retain naming conventions such as basin. labels (dictionary, optional) : Sets the labels for the plot axis. title (string, array like, optional) : Title of each of the selected periods. name (string, array like, optional) : Name of each of the selected periods. Used when saving the results to files. fpath (string, optional) : Path for the source files to be loaded when memory issues are a concern. fpattern (string, optional) : Regular expression pattern to match file names. std (dictionary, optional) : A dictionary containing a map of the standard deviation of the analysed time series. To set the longitude and latitude coordinates of the map, they should be included as separate 'lon' and 'lat' key items. If they are omitted, then the regular input parameters are assumed. Accepted standard deviation error is set in key 'err' (default value is 1e-2). crange (array like, optional) : Array of power levels to be used in average Hovmoler colour bar. levels (array like, optional) : Array of power levels to be used in spectrogram colour bar. cmap (colormap, optional) : Sets the colour map to be used in the plots. The default is the Generic Mapping Tools (GMT) no green. debug (boolean, optional) : If set to True then warnings are shown. OUTPUT If show or save are set, plots either on screen and or on file according to the specified parameters. If dsave parameter is set, also saves the scale averaged power series to files. RETURNS wave (dictionary) : Dictionary containing the resulting calculations from the wavelet analysis according to the input parameters. The output items might be: scale -- Wavelet scales. period -- Equivalent Fourier periods (in days). power_spectrum -- Wavelet power spectrum (in units**2). power_significance -- Relative significance of the power spectrum. global_power -- Global wavelet power spectrum (in units**2). scale_spectrum -- Scale averaged wavelet spectra (in units**2) according to selected periods. scale_significance -- Relative significance of the scale averaged wavelet spectra. fft -- Fourier spectrum. fft_first -- Fourier spectrum of the first half of the time-series. fft_second -- Fourier spectrum of the second half of the time-series. fft_period -- Fourier periods (in days). trend -- Signal trend (in units/yr). wavelet_trend -- Wavelet spectrum trends (in units**2/yr). """ t1 = time() result = {} # Resseting unit labels for hovmoller plots hlabels = dict(labels) hlabels['units'] = '' # Setting some titles and paths if name == None: name = title # Working with the std parameter and setting its properties: if 'val' in std.keys(): if 'lon' not in std.keys(): std['lon'] = lon std['lon180'] = common.lon180(std['lon']) if 'lat' not in std.keys(): std['lat'] = lat if 'err' not in std.keys(): std['err'] = 1e-2 std['map'] = True else: std['map'] = False # Lag-1 autocorrelation parameter if type(alpha).__name__ == 'dict': if 'lon' not in alpha.keys(): alpha['lon'] = lon alpha['lon180'] = common.lon180(alpha['lon']) if 'lat' not in alpha.keys(): alpha['lat'] = lat alpha['mean'] = alpha['val'].mean() alpha['map'] = True alpha['calc'] = False else: if alpha == -1: alpha = {'mean': -1, 'calc': True} else: alpha = {'val': alpha, 'mean': alpha, 'map': False, 'calc': False} # Shows some of the options on screen. print ('Average Lag-1 autocorrelation for background noise: %.2f' % (alpha['mean'])) if save: print 'Saving result figures in \'%s\'.' % (save) if dsave: print 'Saving result data in \'%s\'.' % (dsave) if fpath: # Gets the list of files to be loaded individually extracts all the # latitudes and loads the first file to get the main parameters. flist = os.listdir(fpath) flist, match = common.reglist(flist, fpattern) if len(flist) == 0: raise Warning, 'No files matched search pattern.' flist = numpy.asarray(flist) lst_lat = [] for item in match: y = string.atof(item[-2]) if item[-1].upper() == 'S': y *= -1 lst_lat.append(y) # Detect file type from file name ftype = fm.detect_ftype(flist[0]) x, y, tm, z = fm.load_map('%s/%s' % (fpath, flist[0]), ftype=ftype, masked=True) if lon == None: lon = x lat = numpy.unique(lst_lat) dim = 2 else: # Transforms input arrays in numpy arrays and numpy masked arrays. tm = numpy.asarray(tm) z = numpy.ma.asarray(z) z.mask = numpy.isnan(z) # Determines the number of dimensions of the variable to be plotted and # the sizes of each dimension. a = b = c = None dim = len(z.shape) if dim == 3: c, b, a = z.shape elif dim == 2: c, a = z.shape b = 1 z = z.reshape(c, b, a) else: c = z.shape[0] a = b = 1 z = z.reshape(c, b, a) if tm.size != c: raise Warning, 'Time and data lengths do not match.' # Transforms coordinate arrays into numpy arrays s = type(lat).__name__ if s in ['int', 'float', 'float64']: lat = numpy.asarray([lat]) elif s != 'NoneType': lat = numpy.asarray(lat) s = type(lon).__name__ if s in ['int', 'float', 'float64']: lon = numpy.asarray([lon]) elif s != 'NoneType': lon = numpy.asarray(lon) # Starts the mother wavelet class instance and determines important # analysis parameters mother = mother.lower() if mother == 'morlet': mother = wavelet.Morlet() elif mother == 'paul': mother = wavelet.Paul() elif mother in ['mexican hat', 'mexicanhat', 'mexican_hat']: mother = wavelet.Mexican_hat() else: raise Warning, 'Mother wavelet unknown.' t = tm / common.daysinyear # Time array in years dt = tm[1] - tm[0] # Temporal sampling interval try: # Zonal sampling interval dx = lon[1] - lon[0] except: dx = 1 try: # Meridional sampling interval dy = lat[1] - lat[0] except: dy = dx if numpy.isnan(dt): dt = 1 if numpy.isnan(dx): dx = 1 if numpy.isnan(dy): dy = dx dj = 0.25 # Four sub-octaves per octave s0 = 2 * dt # Smallest scale J = 7 / dj - 1 # Seven powers of two with dj sub-octaves scales = period = None if type(crange).__name__ == 'NoneType': crange = numpy.arange(0, 1.1, 0.1) if type(levels).__name__ == 'NoneType': levels = 2. ** numpy.arange(-3, 6) if fpath: N = lat.size # TODO: refactoring # lon = numpy.arange(-81. - dx / 2., 290. + dx / 2, dx) # TODO: refactoring # lat = numpy.unique(numpy.asarray(lst_lat)) c, b, a = tm.size, lat.size, lon.size else: N = a * b # Making sure that the longitudes range from -180 to 180 degrees and # setting the squared search radius R2. try: lon180 = common.lon180(lon) except: lon180 = None R2 = dx ** 2 + dy ** 2 if numpy.isnan(R2): R2 = 65535. if loc != None: loc = numpy.asarray([[common.lon180(item[0]), item[1]] for item in loc]) # Initializes important result variables such as the global wavelet power # spectrum map, scale avaraged spectrum time-series and their significance, # wavelet power trend map. global_power = numpy.ma.empty([J + 1, b, a]) * numpy.nan try: C = len(periods) + 1 dT = numpy.diff(periods) pmin = numpy.concatenate([[periods[0] - dT[0] / 2], 0.5 * (periods[:-1] + periods[1:])]) pmax = numpy.concatenate([0.5 * (periods[:-1] + periods[1:]), [periods[-1] + dT[-1] / 2]]) except: # Sets the lowest period to null and the highest to half the time # series length. C = 1 pmin = numpy.array([0]) pmax = numpy.array([(tm[-1] - tm[0]) / 2]) if type(sel_periods).__name__ in ['int', 'float']: sel_periods = [sel_periods] elif len(sel_periods) == 0: sel_periods = [-1.] try: if fpath: raise Warning, 'Process files individually' avg_spectrum = numpy.ma.empty([C, c, b, a]) * numpy.nan mem_error = False except: avg_spectrum = numpy.ma.empty([C, c, a]) * numpy.nan mem_error = True avg_spectrum_signif = numpy.ma.empty([C, b, a]) * numpy.nan trend = numpy.ma.empty([b, a]) * numpy.nan wavelet_trend = numpy.ma.empty([C, b, a]) * numpy.nan fft_trend = numpy.ma.empty([C, b, a]) * numpy.nan std_map = numpy.ma.empty([b, a]) * numpy.nan zero = numpy.ma.empty([c, a]) fft_spectrum = None fft_spectrum1 = None fft_spectrum2 = None # Walks through each latitude and then through each longitude to perform # the temporal wavelet analysis. if N == 1: plural = '' else: plural = 's' s = 'Spectral analysis of %d location%s... ' % (N, plural) stdout.write(s) stdout.flush() for j in range(b): t2 = time() isloc = False # Ressets 'is special location' flag hloc = [] # Cleans location list for Hovmoller plots zero *= numpy.nan if mem_error: # Clears average spectrum for next step. avg_spectrum *= numpy.nan avg_spectrum.mask = False if fpath: findex = pylab.find(lst_lat == lat[j]) if len(findex) == 0: continue ftype = fm.detect_ftype(flist[findex[0]]) try: x, y, tm, z = fm.load_dataset(fpath, flist=flist[findex], ftype=ftype, masked=True, lon=lon, lat=lat[j:j+1], verbose=True) except: continue z = z[:, 0, :] x180 = common.lon180(x) # Determines the first and second halves of the time-series and some # constants for the FFT fft_ta = numpy.ceil(t.min()) fft_tb = numpy.floor(t.max()) fft_tc = numpy.round(fft_ta + fft_tb) / 2 fft_ia = pylab.find((t >= fft_ta) & (t <= fft_tc)) fft_ib = pylab.find((t >= fft_tc) & (t <= fft_tb)) fft_N = int(2 ** numpy.ceil(numpy.log2(max([len(fft_ia), len(fft_ib)])))) fft_N2 = fft_N / 2 - 1 fft_dt = t[fft_ib].mean() - t[fft_ia].mean() for i in range(a): # Some string output. try: Y, X = common.num2latlon(lon[i], lat[j], mode='each', padding=False) except: Y = X = '?' # Extracts individual time-series from the whole dataset and # sets or calculates its standard deviation, squared standard # deviation and finally the normalized time-series. if fpath: try: ilon = pylab.find(x == lon[i])[0] fz = z[:, ilon] except: continue else: fz = z[:, j, i] if fz.mask.all(): continue if std['map']: try: u = pylab.find(std['lon180'] == lon180[i])[0] v = pylab.find(std['lat'] == lat[j])[0] except: if debug: warnings.warn('Unable to locate standard deviation ' 'for (%s, %s)' % (X, Y), Warning) continue fstd = std['val'][v, u] estd = fstd - fz.std() if (estd < 0) & (abs(estd) > std['err']): if debug: warnings.warn('Discrepant input standard deviation ' '(%f) location (%.3f, %.3f) will be ' 'disregarded.' % (estd, lon180[i], lat[j])) continue else: fstd = fz.std() fstd2 = fstd ** 2 std_map[j, i] = fstd zero[:, i] = fz fz = (fz - fz.mean()) / fstd # Calculates the distance of the current point to any special # location set in the 'loc' parameter. If only special locations # are to be analysed, then skips all other ones. If the input # array is one dimensional, then do the analysis anyway. if dim == 1: dist = numpy.asarray([0.]) else: try: dist = numpy.asarray([((item[0] - (lon180[i])) ** 2 + (item[1] - lat[j]) ** 2) for item in loc]) except: dist = [] if (dist > R2).all() & (loc != 'all') & onlyloc: continue # Determines the lag-1 autocorrelation coefficient to be used in # the significance test from the input parameter if alpha['calc']: ac = acorr(fz) alpha_ij = (ac[c + 1] + ac[c + 2] ** 0.5) / 2 elif alpha['map']: try: u = pylab.find(alpha['lon180'] == lon180[i])[0] v = pylab.find(alpha['lat'] == lat[j])[0] alpha_ij = alpha['val'][v, u] except: if debug: warnings.warn('Unable to locate standard deviation ' 'for (%s, %s) using mean value instead' % (X, Y), Warning) alpha_ij = alpha['mean'] else: alpha_ij = alpha['mean'] # Calculates the continuous wavelet transform using the wavelet # Python module. Calculates the wavelet and Fourier power spectrum # and the periods in days. Also calculates the Fourier power # spectrum for the first and second halves of the timeseries. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(fz, dt, dj, s0, J, mother) power = abs(wave * wave.conj()) fft_power = abs(fft * fft.conj()) period = 1. / freqs fftperiod = 1. / fftfreqs psel = pylab.find(period <= pmax.max()) # Calculates the Fourier transform for the first and the second # halves ot the time-series for later trend analysis. fft_1 = numpy.fft.fft(fz[fft_ia], fft_N)[1:fft_N/2] / fft_N ** 0.5 fft_2 = numpy.fft.fft(fz[fft_ib], fft_N)[1:fft_N/2] / fft_N ** 0.5 fft_p1 = abs(fft_1 * fft_1.conj()) fft_p2 = abs(fft_2 * fft_2.conj()) # Creates FFT return array and stores the spectrum accordingly try: fft_spectrum[:, j, i] = fft_power * fstd2 fft_spectrum1[:, j, i] = fft_p1 * fstd2 fft_spectrum2[:, j, i] = fft_p2 * fstd2 except: fft_spectrum = (numpy.ma.empty([len(fft_power), b, a]) * numpy.nan) fft_spectrum1 = (numpy.ma.empty([fft_N2, b, a]) * numpy.nan) fft_spectrum2 = (numpy.ma.empty([fft_N2, b, a]) * numpy.nan) # fft_spectrum[:, j, i] = fft_power * fstd2 fft_spectrum1[:, j, i] = fft_p1 * fstd2 fft_spectrum2[:, j, i] = fft_p2 * fstd2 # Performs the significance test according to the article by # Torrence and Compo (1998). The wavelet power is significant # if the ratio power/sig95 is > 1. signif, fft_theor = wavelet.significance(1., dt, scales, 0, alpha_ij, significance_level=siglvl, wavelet=mother) sig95 = (signif * numpy.ones((c, 1))).transpose() sig95 = power / sig95 # Calculates the global wavelet power spectrum and its # significance. The global wavelet spectrum is the average of the # wavelet power spectrum over time. The degrees of freedom (dof) # have to be corrected for padding at the edges. glbl_power = power.mean(axis=1) dof = c - scales glbl_signif, tmp = wavelet.significance(1., dt, scales, 1, alpha_ij, significance_level=siglvl, dof=dof, wavelet=mother) global_power[:, j, i] = glbl_power * fstd2 # Calculates the average wavelet spectrum along the scales and its # significance according to Torrence and Compo (1998) eq. 24. The # scale_avg_full variable is used multiple times according to the # selected periods range. # # Also calculates the average Fourier power spectrum. Cdelta = mother.cdelta scale_avg_full = (scales * numpy.ones((c, 1))).transpose() scale_avg_full = power / scale_avg_full for k in range(C): if k == 0: sel = pylab.find((period >= pmin[0]) & (period <= pmax[-1])) pminmax = [period[sel[0]], period[sel[-1]]] les = pylab.find((fftperiod >= pmin[0]) & (fftperiod <= pmax[-1])) fminmax = [fftperiod[les[0]], fftperiod[les[-1]]] else: sel = pylab.find((period >= pmin[k - 1]) & (period < pmax[k - 1])) pminmax = [pmin[k-1], pmax[k-1]] les = pylab.find((fftperiod >= pmin[k - 1]) & (fftperiod <= pmax[k - 1])) fminmax = [fftperiod[les[0]], fftperiod[les[-1]]] scale_avg = numpy.ma.array((dj * dt / Cdelta * scale_avg_full[sel, :].sum(axis=0))) scale_avg_signif, tmp = wavelet.significance(1., dt, scales, 2, alpha_ij, significance_level=siglvl, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) scale_avg.mask = (scale_avg < scale_avg_signif) if mem_error: avg_spectrum[k, :, i] = scale_avg else: avg_spectrum[k, :, j, i] = scale_avg avg_spectrum_signif[k, j, i] = scale_avg_signif # Trend analysis using least square polynomial fit of one # degree of the original input data and scale averaged # wavelet power. The wavelet power trend is calculated only # where the cone of influence spans the highest analyzed # period. In the end, the returned value for the trend is in # units**2. # # Also calculates the trends in the Fourier power spectrum. # Note that the FFT power spectrum is already multiplied by # the signal's standard deviation. incoi = pylab.find(coi >= pmax[-1]) if len(incoi) == 0: incoi = numpy.arange(c) polyw = numpy.polyfit(t[incoi], scale_avg[incoi].data, 1) wavelet_trend[k, j, i] = polyw[0] * fstd2 fft_trend[k, j, i] = (fft_spectrum2[les[les<fft_N2], j, i] - fft_spectrum1[les[les<fft_N2], j, i]).mean() / fft_dt if k == 0: polyz = numpy.polyfit(t, fz * fstd, 1) trend[j, i] = polyz[0] # Plots the wavelet analysis results for the individual # series. The plot is only generated if the dimension of the # input variable z is one, if a special location is within a # range of the search radius R and if the show or save # parameters are set. if (show | (save != '')) & ((k in sel_periods)): if (dist < R2).any() | (loc == 'all') | (dim == 1): # There is an interesting spot within the search # radius of location (%s, %s).' % (Y, X) isloc = True if (dist < R2).any(): try: hloc.append(loc[(dist < R2)][0, 0]) except: pass if save: try: sv = '%s/tz_%s_%s_%d' % (save, prefix, common.num2latlon(lon[i], lat[j]), k) except: sv = '%s' % (save) else: sv = '' graphics.wavelet_plot(tm, period[psel], fz, power[psel, :], coi, glbl_power[psel], scale_avg.data, fft=fft, fft_period=fftperiod, power_signif=sig95[psel, :], glbl_signif=glbl_signif[psel], scale_signif=scale_avg_signif, pminmax=pminmax, labels=labels, normalized=True, std=fstd, ztrend=polyz, wtrend=polyw, show=show, save=sv, levels=levels, cmap=cmap) # Saves and/or plots the intermediate results as zonal temporal # diagrams. if dsave: for k in range(C): if k == 0: sv = '%s/%s/%s_%s.xt.gz' % (dsave, 'global', prefix, common.num2latlon(lon[i], lat[j], mode='each')[0]) else: sv = '%s/%s/%s_%s.xt.gz' % (dsave, name[k - 1].lower(), prefix, common.num2latlon(lon[i], lat[j], mode='each')[0]) if mem_error: fm.save_map(lon, tm, avg_spectrum[k, :, :].data, sv, lat[j]) else: fm.save_map(lon, tm, avg_spectrum[k, :, j, :].data, sv, lat[j]) if ((dim > 1) and (show or (save != '')) & (not onlyloc) and len(hloc) > 0): hloc = common.lon360(numpy.unique(hloc)) if save: sv = '%s/xt_%s_%s' % (save, prefix, common.num2latlon(lon[i], lat[j], mode='each')[0]) else: sv = '' if mem_error: # To include overlapping original signal, use zz=zero gis.hovmoller(lon, tm, avg_spectrum[1:, :, :], zo=avg_spectrum_signif[1:, j, :], title=title, crange=crange, show=show, save=sv, labels=hlabels, loc=hloc, cmap=cmap, bottom='avg', right='avg', std=std_map[j, :]) else: gis.hovmoller(lon, tm, avg_spectrum[1:, :, j, :], zo=avg_spectrum_signif[1:, j, :], title=title, crange=crange, show=show, save=sv, labels=hlabels, loc=hloc, cmap=cmap, bottom='avg', right='avg', std=std_map[j, :]) # Flushing profiling text. stdout.write(len(s) * '\b') s = 'Spectral analysis of %d location%s (%s)... %s ' % (N, plural, Y, common.profiler(b, j + 1, 0, t1, t2)) stdout.write(s) stdout.flush() stdout.write('\n') result['scale'] = scales result['period'] = period if dim == 1: result['power_spectrum'] = power * fstd2 result['power_significance'] = sig95 result['cwt'] = wave result['fft'] = fft result['global_power'] = global_power result['scale_spectrum'] = avg_spectrum if fpath: result['lon'] = lon result['lat'] = lat result['scale_significance'] = avg_spectrum_signif result['trend'] = trend result['wavelet_trend'] = wavelet_trend result['fft_power'] = fft_spectrum result['fft_first'] = fft_spectrum1 result['fft_second'] = fft_spectrum2 result['fft_period'] = fftperiod result['fft_trend'] = fft_trend return result
def get_graph_from_file(in_filepath, out_folder, out_filename): # Get data # TODO there are differents formats of file # TODO implement differents parsers by parameters of function p1 = numpy.genfromtxt(in_filepath) # TODO fix this shit dat = p1 title = 'NINO3 Sea Surface Temperature' label = 'NINO3 SST' units = 'degC' # Values for calculations # TODO spike about args t0 = 12.0 # start time dt = 0.5 # step of differentiation - in minutes N = dat.size t = numpy.arange(0, N) * dt + t0 p = numpy.polyfit(t - t0, dat, 1) dat_notrend = dat - numpy.polyval(p, t - t0) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset mother = wavelet.Morlet(6) s0 = 2 * dt # Starting scale, in this case 2 * 0.25 years = 6 months dj = 1 / 12 # Twelve sub-octaves per octaves J = 7 / dj # Seven powers of two with dj sub-octaves alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std power = (numpy.abs(wave))**2 fft_power = numpy.abs(fft)**2 period = 1 / freqs power /= scales[:, None] signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) sel = find((period >= 2) & (period < 8)) Cdelta = mother.cdelta scale_avg = (scales * numpy.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance( var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) # Prepare the figure pyplot.close('all') #pyplot.ioff() figprops = dict(dpi=144) fig = pyplot.figure(**figprops) # Second sub-plot, the normalized wavelet power spectrum and significance # level contour lines and cone of influece hatched area. Note that period # scale is logarithmic. bx = pyplot.axes([0.1, 0.37, 0.65, 0.28]) levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] bx.contourf(t, period, numpy.log2(power), numpy.log2(levels), extend='both', cmap=pyplot.cm.viridis) extent = [t.min(), t.max(), 0, max(period)] bx.contour(t, period, sig95, [-99, 1], colors='k', linewidths=2, extent=extent) bx.set_title('{} Wavelet Power Spectrum ({})'.format(label, mother.name)) bx.set_ylabel('Period (minutes)') # #Yticks = 2 ** numpy.arange(numpy.ceil(numpy.log2(period.min())), # numpy.ceil(numpy.log2(period.max()))) #bx.set_yticks(numpy.log2(Yticks)) #bx.set_yticklabels(Yticks) bx.set_ylim([2, 20]) # Save graph to file # TODO implement #pyplot.savefig('{}/{}.png'.format(out_folder, out_filename)) # ---------------------------------------------- # or show the graph pyplot.show()
def wavelet_analysis(z, tm, lon=None, lat=None, mother='Morlet', alpha=0.0, siglvl=0.95, loc=None, onlyloc=False, periods=None, sel_periods=[], show=False, save='', dsave='', prefix='', labels=dict(), title=None, name=None, fpath='', fpattern='', std=dict(), crange=None, levels=None, cmap=cm.GMT_no_green, debug=False): """Continuous wavelet transform and significance analysis. The analysis is made using the methodology and statistical approach suggested by Torrence and Compo (1998). Depending on the dimensions of the input array, three different kinds of approaches are taken. If the input array is one-dimensional then only a simple analysis is performed. If the array is bi- or three-dimensional then spectral Hovmoller diagrams are drawn for each Fourier period given within a range of +/-25%. PARAMETERS z (array like) : Input data. The data array should have one of these forms, z[tm], z[tm, lat] or z[tm, lat, lon]. tm (array like) : Time axis. It should contain values in matplotlib date format (i.e. number of days since 0001-01-01 UTC). lon (array like, optional) : Longitude. lat (array like, optional) : Latitude. mother (string, optional) : Gives the name of the mother wavelet to be used. Possible values are 'Morlet' (default), 'Paul' or 'Mexican hat'. alpha (float or dictionary, optional) : Lag-1 autocorrelation for background noise. Default value is 0.0 (white noise). If different autocorrelation coefficients should be used for different locations, then the input should contain a dictionary with 'lon', 'lat', 'map' keys as for the std parameter. siglvl (float, optional) : Significance level. Default value is 0.95. loc (array like, optional) : Special locations of interest. If the input array is of higher dimenstions, the output of the simple wavelet analysis of each of the locations is output. The list should contain the pairs of (lon, lat) for each locations of interest. onlyloc (boolean, optional) : If set to true then only the specified locations are analysed. The default is false. periods (array like, optional) : Special Fourier periods of interest in case of analysis of higher dimensions (in years). sel_periods (array like, optional) : Select which Fourier periods spectral power are averaged. show (boolean, optional) : If set to true the the resulting maps are shown on screen. save (string, optional) : The path in which the resulting plots are to be saved. If not set, then no images will be saved. dsave (string, optional) : If set, saves the scale averaged power spectrum series to this path. This is especially useful if memory is an issue. prefix (string, optional) : Prefix to retain naming conventions such as basin. labels (dictionary, optional) : Sets the labels for the plot axis. title (string, array like, optional) : Title of each of the selected periods. name (string, array like, optional) : Name of each of the selected periods. Used when saving the results to files. fpath (string, optional) : Path for the source files to be loaded when memory issues are a concern. fpattern (string, optional) : Regular expression pattern to match file names. std (dictionary, optional) : A dictionary containing a map of the standard deviation of the analysed time series. To set the longitude and latitude coordinates of the map, they should be included as separate 'lon' and 'lat' key items. If they are omitted, then the regular input parameters are assumed. Accepted standard deviation error is set in key 'err' (default value is 1e-2). crange (array like, optional) : Array of power levels to be used in average Hovmoler colour bar. levels (array like, optional) : Array of power levels to be used in spectrogram colour bar. cmap (colormap, optional) : Sets the colour map to be used in the plots. The default is the Generic Mapping Tools (GMT) no green. debug (boolean, optional) : If set to True then warnings are shown. OUTPUT If show or save are set, plots either on screen and or on file according to the specified parameters. If dsave parameter is set, also saves the scale averaged power series to files. RETURNS wave (dictionary) : Dictionary containing the resulting calculations from the wavelet analysis according to the input parameters. The output items might be: scale -- Wavelet scales. period -- Equivalent Fourier periods (in days). power_spectrum -- Wavelet power spectrum (in units**2). power_significance -- Relative significance of the power spectrum. global_power -- Global wavelet power spectrum (in units**2). scale_spectrum -- Scale averaged wavelet spectra (in units**2) according to selected periods. scale_significance -- Relative significance of the scale averaged wavelet spectra. fft -- Fourier spectrum. fft_first -- Fourier spectrum of the first half of the time-series. fft_second -- Fourier spectrum of the second half of the time-series. fft_period -- Fourier periods (in days). trend -- Signal trend (in units/yr). wavelet_trend -- Wavelet spectrum trends (in units**2/yr). """ t1 = time() result = {} # Resseting unit labels for hovmoller plots hlabels = dict(labels) hlabels['units'] = '' # Setting some titles and paths if name == None: name = title # Working with the std parameter and setting its properties: if 'val' in std.keys(): if 'lon' not in std.keys(): std['lon'] = lon std['lon180'] = common.lon180(std['lon']) if 'lat' not in std.keys(): std['lat'] = lat if 'err' not in std.keys(): std['err'] = 1e-2 std['map'] = True else: std['map'] = False # Lag-1 autocorrelation parameter if type(alpha).__name__ == 'dict': if 'lon' not in alpha.keys(): alpha['lon'] = lon alpha['lon180'] = common.lon180(alpha['lon']) if 'lat' not in alpha.keys(): alpha['lat'] = lat alpha['mean'] = alpha['val'].mean() alpha['map'] = True alpha['calc'] = False else: if alpha == -1: alpha = {'mean': -1, 'calc': True} else: alpha = {'val': alpha, 'mean': alpha, 'map': False, 'calc': False} # Shows some of the options on screen. print('Average Lag-1 autocorrelation for background noise: %.2f' % (alpha['mean'])) if save: print 'Saving result figures in \'%s\'.' % (save) if dsave: print 'Saving result data in \'%s\'.' % (dsave) if fpath: # Gets the list of files to be loaded individually extracts all the # latitudes and loads the first file to get the main parameters. flist = os.listdir(fpath) flist, match = common.reglist(flist, fpattern) if len(flist) == 0: raise Warning, 'No files matched search pattern.' flist = numpy.asarray(flist) lst_lat = [] for item in match: y = string.atof(item[-2]) if item[-1].upper() == 'S': y *= -1 lst_lat.append(y) # Detect file type from file name ftype = fm.detect_ftype(flist[0]) x, y, tm, z = fm.load_map('%s/%s' % (fpath, flist[0]), ftype=ftype, masked=True) if lon == None: lon = x lat = numpy.unique(lst_lat) dim = 2 else: # Transforms input arrays in numpy arrays and numpy masked arrays. tm = numpy.asarray(tm) z = numpy.ma.asarray(z) z.mask = numpy.isnan(z) # Determines the number of dimensions of the variable to be plotted and # the sizes of each dimension. a = b = c = None dim = len(z.shape) if dim == 3: c, b, a = z.shape elif dim == 2: c, a = z.shape b = 1 z = z.reshape(c, b, a) else: c = z.shape[0] a = b = 1 z = z.reshape(c, b, a) if tm.size != c: raise Warning, 'Time and data lengths do not match.' # Transforms coordinate arrays into numpy arrays s = type(lat).__name__ if s in ['int', 'float', 'float64']: lat = numpy.asarray([lat]) elif s != 'NoneType': lat = numpy.asarray(lat) s = type(lon).__name__ if s in ['int', 'float', 'float64']: lon = numpy.asarray([lon]) elif s != 'NoneType': lon = numpy.asarray(lon) # Starts the mother wavelet class instance and determines important # analysis parameters mother = mother.lower() if mother == 'morlet': mother = wavelet.Morlet() elif mother == 'paul': mother = wavelet.Paul() elif mother in ['mexican hat', 'mexicanhat', 'mexican_hat']: mother = wavelet.Mexican_hat() else: raise Warning, 'Mother wavelet unknown.' t = tm / common.daysinyear # Time array in years dt = tm[1] - tm[0] # Temporal sampling interval try: # Zonal sampling interval dx = lon[1] - lon[0] except: dx = 1 try: # Meridional sampling interval dy = lat[1] - lat[0] except: dy = dx if numpy.isnan(dt): dt = 1 if numpy.isnan(dx): dx = 1 if numpy.isnan(dy): dy = dx dj = 0.25 # Four sub-octaves per octave s0 = 2 * dt # Smallest scale J = 7 / dj - 1 # Seven powers of two with dj sub-octaves scales = period = None if type(crange).__name__ == 'NoneType': crange = numpy.arange(0, 1.1, 0.1) if type(levels).__name__ == 'NoneType': levels = 2.**numpy.arange(-3, 6) if fpath: N = lat.size # TODO: refactoring # lon = numpy.arange(-81. - dx / 2., 290. + dx / 2, dx) # TODO: refactoring # lat = numpy.unique(numpy.asarray(lst_lat)) c, b, a = tm.size, lat.size, lon.size else: N = a * b # Making sure that the longitudes range from -180 to 180 degrees and # setting the squared search radius R2. try: lon180 = common.lon180(lon) except: lon180 = None R2 = dx**2 + dy**2 if numpy.isnan(R2): R2 = 65535. if loc != None: loc = numpy.asarray([[common.lon180(item[0]), item[1]] for item in loc]) # Initializes important result variables such as the global wavelet power # spectrum map, scale avaraged spectrum time-series and their significance, # wavelet power trend map. global_power = numpy.ma.empty([J + 1, b, a]) * numpy.nan try: C = len(periods) + 1 dT = numpy.diff(periods) pmin = numpy.concatenate([[periods[0] - dT[0] / 2], 0.5 * (periods[:-1] + periods[1:])]) pmax = numpy.concatenate( [0.5 * (periods[:-1] + periods[1:]), [periods[-1] + dT[-1] / 2]]) except: # Sets the lowest period to null and the highest to half the time # series length. C = 1 pmin = numpy.array([0]) pmax = numpy.array([(tm[-1] - tm[0]) / 2]) if type(sel_periods).__name__ in ['int', 'float']: sel_periods = [sel_periods] elif len(sel_periods) == 0: sel_periods = [-1.] try: if fpath: raise Warning, 'Process files individually' avg_spectrum = numpy.ma.empty([C, c, b, a]) * numpy.nan mem_error = False except: avg_spectrum = numpy.ma.empty([C, c, a]) * numpy.nan mem_error = True avg_spectrum_signif = numpy.ma.empty([C, b, a]) * numpy.nan trend = numpy.ma.empty([b, a]) * numpy.nan wavelet_trend = numpy.ma.empty([C, b, a]) * numpy.nan fft_trend = numpy.ma.empty([C, b, a]) * numpy.nan std_map = numpy.ma.empty([b, a]) * numpy.nan zero = numpy.ma.empty([c, a]) fft_spectrum = None fft_spectrum1 = None fft_spectrum2 = None # Walks through each latitude and then through each longitude to perform # the temporal wavelet analysis. if N == 1: plural = '' else: plural = 's' s = 'Spectral analysis of %d location%s... ' % (N, plural) stdout.write(s) stdout.flush() for j in range(b): t2 = time() isloc = False # Ressets 'is special location' flag hloc = [] # Cleans location list for Hovmoller plots zero *= numpy.nan if mem_error: # Clears average spectrum for next step. avg_spectrum *= numpy.nan avg_spectrum.mask = False if fpath: findex = pylab.find(lst_lat == lat[j]) if len(findex) == 0: continue ftype = fm.detect_ftype(flist[findex[0]]) try: x, y, tm, z = fm.load_dataset(fpath, flist=flist[findex], ftype=ftype, masked=True, lon=lon, lat=lat[j:j + 1], verbose=True) except: continue z = z[:, 0, :] x180 = common.lon180(x) # Determines the first and second halves of the time-series and some # constants for the FFT fft_ta = numpy.ceil(t.min()) fft_tb = numpy.floor(t.max()) fft_tc = numpy.round(fft_ta + fft_tb) / 2 fft_ia = pylab.find((t >= fft_ta) & (t <= fft_tc)) fft_ib = pylab.find((t >= fft_tc) & (t <= fft_tb)) fft_N = int(2**numpy.ceil(numpy.log2(max([len(fft_ia), len(fft_ib)])))) fft_N2 = fft_N / 2 - 1 fft_dt = t[fft_ib].mean() - t[fft_ia].mean() for i in range(a): # Some string output. try: Y, X = common.num2latlon(lon[i], lat[j], mode='each', padding=False) except: Y = X = '?' # Extracts individual time-series from the whole dataset and # sets or calculates its standard deviation, squared standard # deviation and finally the normalized time-series. if fpath: try: ilon = pylab.find(x == lon[i])[0] fz = z[:, ilon] except: continue else: fz = z[:, j, i] if fz.mask.all(): continue if std['map']: try: u = pylab.find(std['lon180'] == lon180[i])[0] v = pylab.find(std['lat'] == lat[j])[0] except: if debug: warnings.warn( 'Unable to locate standard deviation ' 'for (%s, %s)' % (X, Y), Warning) continue fstd = std['val'][v, u] estd = fstd - fz.std() if (estd < 0) & (abs(estd) > std['err']): if debug: warnings.warn('Discrepant input standard deviation ' '(%f) location (%.3f, %.3f) will be ' 'disregarded.' % (estd, lon180[i], lat[j])) continue else: fstd = fz.std() fstd2 = fstd**2 std_map[j, i] = fstd zero[:, i] = fz fz = (fz - fz.mean()) / fstd # Calculates the distance of the current point to any special # location set in the 'loc' parameter. If only special locations # are to be analysed, then skips all other ones. If the input # array is one dimensional, then do the analysis anyway. if dim == 1: dist = numpy.asarray([0.]) else: try: dist = numpy.asarray([ ((item[0] - (lon180[i]))**2 + (item[1] - lat[j])**2) for item in loc ]) except: dist = [] if (dist > R2).all() & (loc != 'all') & onlyloc: continue # Determines the lag-1 autocorrelation coefficient to be used in # the significance test from the input parameter if alpha['calc']: ac = acorr(fz) alpha_ij = (ac[c + 1] + ac[c + 2]**0.5) / 2 elif alpha['map']: try: u = pylab.find(alpha['lon180'] == lon180[i])[0] v = pylab.find(alpha['lat'] == lat[j])[0] alpha_ij = alpha['val'][v, u] except: if debug: warnings.warn( 'Unable to locate standard deviation ' 'for (%s, %s) using mean value instead' % (X, Y), Warning) alpha_ij = alpha['mean'] else: alpha_ij = alpha['mean'] # Calculates the continuous wavelet transform using the wavelet # Python module. Calculates the wavelet and Fourier power spectrum # and the periods in days. Also calculates the Fourier power # spectrum for the first and second halves of the timeseries. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( fz, dt, dj, s0, J, mother) power = abs(wave * wave.conj()) fft_power = abs(fft * fft.conj()) period = 1. / freqs fftperiod = 1. / fftfreqs psel = pylab.find(period <= pmax.max()) # Calculates the Fourier transform for the first and the second # halves ot the time-series for later trend analysis. fft_1 = numpy.fft.fft(fz[fft_ia], fft_N)[1:fft_N / 2] / fft_N**0.5 fft_2 = numpy.fft.fft(fz[fft_ib], fft_N)[1:fft_N / 2] / fft_N**0.5 fft_p1 = abs(fft_1 * fft_1.conj()) fft_p2 = abs(fft_2 * fft_2.conj()) # Creates FFT return array and stores the spectrum accordingly try: fft_spectrum[:, j, i] = fft_power * fstd2 fft_spectrum1[:, j, i] = fft_p1 * fstd2 fft_spectrum2[:, j, i] = fft_p2 * fstd2 except: fft_spectrum = (numpy.ma.empty([len(fft_power), b, a]) * numpy.nan) fft_spectrum1 = (numpy.ma.empty([fft_N2, b, a]) * numpy.nan) fft_spectrum2 = (numpy.ma.empty([fft_N2, b, a]) * numpy.nan) # fft_spectrum[:, j, i] = fft_power * fstd2 fft_spectrum1[:, j, i] = fft_p1 * fstd2 fft_spectrum2[:, j, i] = fft_p2 * fstd2 # Performs the significance test according to the article by # Torrence and Compo (1998). The wavelet power is significant # if the ratio power/sig95 is > 1. signif, fft_theor = wavelet.significance(1., dt, scales, 0, alpha_ij, significance_level=siglvl, wavelet=mother) sig95 = (signif * numpy.ones((c, 1))).transpose() sig95 = power / sig95 # Calculates the global wavelet power spectrum and its # significance. The global wavelet spectrum is the average of the # wavelet power spectrum over time. The degrees of freedom (dof) # have to be corrected for padding at the edges. glbl_power = power.mean(axis=1) dof = c - scales glbl_signif, tmp = wavelet.significance(1., dt, scales, 1, alpha_ij, significance_level=siglvl, dof=dof, wavelet=mother) global_power[:, j, i] = glbl_power * fstd2 # Calculates the average wavelet spectrum along the scales and its # significance according to Torrence and Compo (1998) eq. 24. The # scale_avg_full variable is used multiple times according to the # selected periods range. # # Also calculates the average Fourier power spectrum. Cdelta = mother.cdelta scale_avg_full = (scales * numpy.ones((c, 1))).transpose() scale_avg_full = power / scale_avg_full for k in range(C): if k == 0: sel = pylab.find((period >= pmin[0]) & (period <= pmax[-1])) pminmax = [period[sel[0]], period[sel[-1]]] les = pylab.find((fftperiod >= pmin[0]) & (fftperiod <= pmax[-1])) fminmax = [fftperiod[les[0]], fftperiod[les[-1]]] else: sel = pylab.find((period >= pmin[k - 1]) & (period < pmax[k - 1])) pminmax = [pmin[k - 1], pmax[k - 1]] les = pylab.find((fftperiod >= pmin[k - 1]) & (fftperiod <= pmax[k - 1])) fminmax = [fftperiod[les[0]], fftperiod[les[-1]]] scale_avg = numpy.ma.array( (dj * dt / Cdelta * scale_avg_full[sel, :].sum(axis=0))) scale_avg_signif, tmp = wavelet.significance( 1., dt, scales, 2, alpha_ij, significance_level=siglvl, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) scale_avg.mask = (scale_avg < scale_avg_signif) if mem_error: avg_spectrum[k, :, i] = scale_avg else: avg_spectrum[k, :, j, i] = scale_avg avg_spectrum_signif[k, j, i] = scale_avg_signif # Trend analysis using least square polynomial fit of one # degree of the original input data and scale averaged # wavelet power. The wavelet power trend is calculated only # where the cone of influence spans the highest analyzed # period. In the end, the returned value for the trend is in # units**2. # # Also calculates the trends in the Fourier power spectrum. # Note that the FFT power spectrum is already multiplied by # the signal's standard deviation. incoi = pylab.find(coi >= pmax[-1]) if len(incoi) == 0: incoi = numpy.arange(c) polyw = numpy.polyfit(t[incoi], scale_avg[incoi].data, 1) wavelet_trend[k, j, i] = polyw[0] * fstd2 fft_trend[k, j, i] = ( fft_spectrum2[les[les < fft_N2], j, i] - fft_spectrum1[les[les < fft_N2], j, i]).mean() / fft_dt if k == 0: polyz = numpy.polyfit(t, fz * fstd, 1) trend[j, i] = polyz[0] # Plots the wavelet analysis results for the individual # series. The plot is only generated if the dimension of the # input variable z is one, if a special location is within a # range of the search radius R and if the show or save # parameters are set. if (show | (save != '')) & ((k in sel_periods)): if (dist < R2).any() | (loc == 'all') | (dim == 1): # There is an interesting spot within the search # radius of location (%s, %s).' % (Y, X) isloc = True if (dist < R2).any(): try: hloc.append(loc[(dist < R2)][0, 0]) except: pass if save: try: sv = '%s/tz_%s_%s_%d' % ( save, prefix, common.num2latlon(lon[i], lat[j]), k) except: sv = '%s' % (save) else: sv = '' graphics.wavelet_plot(tm, period[psel], fz, power[psel, :], coi, glbl_power[psel], scale_avg.data, fft=fft, fft_period=fftperiod, power_signif=sig95[psel, :], glbl_signif=glbl_signif[psel], scale_signif=scale_avg_signif, pminmax=pminmax, labels=labels, normalized=True, std=fstd, ztrend=polyz, wtrend=polyw, show=show, save=sv, levels=levels, cmap=cmap) # Saves and/or plots the intermediate results as zonal temporal # diagrams. if dsave: for k in range(C): if k == 0: sv = '%s/%s/%s_%s.xt.gz' % ( dsave, 'global', prefix, common.num2latlon(lon[i], lat[j], mode='each')[0]) else: sv = '%s/%s/%s_%s.xt.gz' % ( dsave, name[k - 1].lower(), prefix, common.num2latlon(lon[i], lat[j], mode='each')[0]) if mem_error: fm.save_map(lon, tm, avg_spectrum[k, :, :].data, sv, lat[j]) else: fm.save_map(lon, tm, avg_spectrum[k, :, j, :].data, sv, lat[j]) if ((dim > 1) and (show or (save != '')) & (not onlyloc) and len(hloc) > 0): hloc = common.lon360(numpy.unique(hloc)) if save: sv = '%s/xt_%s_%s' % (save, prefix, common.num2latlon( lon[i], lat[j], mode='each')[0]) else: sv = '' if mem_error: # To include overlapping original signal, use zz=zero gis.hovmoller(lon, tm, avg_spectrum[1:, :, :], zo=avg_spectrum_signif[1:, j, :], title=title, crange=crange, show=show, save=sv, labels=hlabels, loc=hloc, cmap=cmap, bottom='avg', right='avg', std=std_map[j, :]) else: gis.hovmoller(lon, tm, avg_spectrum[1:, :, j, :], zo=avg_spectrum_signif[1:, j, :], title=title, crange=crange, show=show, save=sv, labels=hlabels, loc=hloc, cmap=cmap, bottom='avg', right='avg', std=std_map[j, :]) # Flushing profiling text. stdout.write(len(s) * '\b') s = 'Spectral analysis of %d location%s (%s)... %s ' % ( N, plural, Y, common.profiler(b, j + 1, 0, t1, t2)) stdout.write(s) stdout.flush() stdout.write('\n') result['scale'] = scales result['period'] = period if dim == 1: result['power_spectrum'] = power * fstd2 result['power_significance'] = sig95 result['cwt'] = wave result['fft'] = fft result['global_power'] = global_power result['scale_spectrum'] = avg_spectrum if fpath: result['lon'] = lon result['lat'] = lat result['scale_significance'] = avg_spectrum_signif result['trend'] = trend result['wavelet_trend'] = wavelet_trend result['fft_power'] = fft_spectrum result['fft_first'] = fft_spectrum1 result['fft_second'] = fft_spectrum2 result['fft_period'] = fftperiod result['fft_trend'] = fft_trend return result
def cwt(signal, t, obspy=None): # from __future__ import division import numpy from matplotlib import pyplot import pycwt as wavelet from pycwt.helpers import find signal = signal[10000:11000] t = t[10000:11000] url = 'http://paos.colorado.edu/research/wavelets/wave_idl/nino3sst.txt' dat = numpy.genfromtxt(url, skip_header=19) title = 'DICARDIA' label = 'DICARDIA SST' units = 'degC' t0 = 1871.0 dt = 0.25 # In years N = signal.shape[0] print(N) p = numpy.polyfit(t, signal, 1) dat_notrend = signal - numpy.polyval(p, t) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset mother = wavelet.Morlet(6) s0 = 2 * dt # Starting scale, in this case 2 * 0.25 years = 6 months dj = 1 / 12 # Twelve sub-octaves per octaves J = 7 / dj # Seven powers of two with dj sub-octaves alpha, _, _ = wavelet.ar1( signal) # Lag-1 autocorrelation for red noise wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std power = (numpy.abs(wave))**2 fft_power = numpy.abs(fft)**2 period = 1 / freqs power /= scales[:, None] signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) sel = find((period >= 2) & (period < 8)) Cdelta = mother.cdelta scale_avg = (scales * numpy.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance( var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) # Prepare the figure pyplot.close('all') pyplot.ioff() figprops = dict(figsize=(11, 8), dpi=72) fig = pyplot.figure(**figprops) # First sub-plot, the original time series anomaly and inverse wavelet # transform. ax = pyplot.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(t, iwave, '-', linewidth=1, color=[0.5, 0.5, 0.5]) ax.plot(t, signal, 'k', linewidth=1.5) ax.set_title('a) {}'.format(title)) ax.set_ylabel(r'{} [{}]'.format(label, units)) # Second sub-plot, the normalized wavelet power spectrum and significance # level contour lines and cone of influece hatched area. Note that period # scale is logarithmic. bx = pyplot.axes([0.1, 0.37, 0.65, 0.28], sharex=ax) levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] bx.contourf(t, numpy.log2(period), numpy.log2(power), numpy.log2(levels), extend='both', cmap=pyplot.cm.viridis) extent = [t.min(), t.max(), 0, max(period)] bx.contour(t, numpy.log2(period), sig95, [-99, 1], colors='k', linewidths=2, extent=extent) bx.fill(numpy.concatenate( [t, t[-1:] + dt, t[-1:] + dt, t[:1] - dt, t[:1] - dt]), numpy.concatenate([ numpy.log2(coi), [1e-9], numpy.log2(period[-1:]), numpy.log2(period[-1:]), [1e-9] ]), 'k', alpha=0.3, hatch='x') bx.set_title('b) {} Wavelet Power Spectrum ({})'.format( label, mother.name)) bx.set_ylabel('Period (years)') # Yticks = 2**numpy.arange(numpy.ceil(numpy.log2(period.min())), numpy.ceil(numpy.log2(period.max()))) bx.set_yticks(numpy.log2(Yticks)) bx.set_yticklabels(Yticks) # Third sub-plot, the global wavelet and Fourier power spectra and theoretical # noise spectra. Note that period scale is logarithmic. cx = pyplot.axes([0.77, 0.37, 0.2, 0.28], sharey=bx) cx.plot(glbl_signif, numpy.log2(period), 'k--') cx.plot(var * fft_theor, numpy.log2(period), '--', color='#cccccc') cx.plot(var * fft_power, numpy.log2(1. / fftfreqs), '-', color='#cccccc', linewidth=1.) cx.plot(var * glbl_power, numpy.log2(period), 'k-', linewidth=1.5) cx.set_title('c) Global Wavelet Spectrum') cx.set_xlabel(r'Power [({})^2]'.format(units)) cx.set_xlim([0, glbl_power.max() + var]) cx.set_ylim(numpy.log2([period.min(), period.max()])) cx.set_yticks(numpy.log2(Yticks)) cx.set_yticklabels(Yticks) pyplot.setp(cx.get_yticklabels(), visible=False) # Fourth sub-plot, the scale averaged wavelet spectrum. dx = pyplot.axes([0.1, 0.07, 0.65, 0.2], sharex=ax) dx.axhline(scale_avg_signif, color='k', linestyle='--', linewidth=1.) dx.plot(t, scale_avg, 'k-', linewidth=1.5) dx.set_title('d) {}--{} year scale-averaged power'.format(2, 8)) dx.set_xlabel('Time (year)') dx.set_ylabel(r'Average variance [{}]'.format(units)) ax.set_xlim([t.min(), t.max()]) pyplot.show()
mother = wavelet.Morlet(6) # Morlet mother wavelet with m=6 slevel = 0.95 # Significance level dj = 1/12 # Twelve sub-octaves per octaves s0 = -1 # 2 * dt # Starting scale, here 6 months J = -1 # 7 / dj # Seven powers of two with dj sub-octaves if True: alpha1, _, _ = wavelet.ar1(s1) # Lag-1 autocorrelation for red noise alpha2, _, _ = wavelet.ar1(s2) # Lag-1 autocorrelation for red noise else: alpha1 = alpha2 = 0.0 # Lag-1 autocorrelation for white noise # The following routines perform the wavelet transform and siginificance # analysis for two data sets. W1, scales1, freqs1, coi1, _, _ = wavelet.cwt(s1/std1, dt, dj, s0, J, mother) signif1, fft_theor1 = wavelet.significance(1.0, dt, scales1, 0, alpha1, significance_level=slevel, wavelet=mother) W2, scales2, freqs2, coi2, _, _ = wavelet.cwt(s2/std2, dt, dj, s0, J, mother) signif2, fft_theor2 = wavelet.significance(1.0, dt, scales2, 0, alpha2, significance_level=slevel, wavelet=mother) power1 = (np.abs(W1)) ** 2 # Normalized wavelet power spectrum power2 = (np.abs(W2)) ** 2 # Normalized wavelet power spectrum period1 = 1/freqs1 period2 = 1/freqs2 sig95_1 = np.ones([1, n1]) * signif1[:, None] sig95_1 = power1 / sig95_1 # Where ratio > 1, power is significant sig95_2 = np.ones([1, n2]) * signif2[:, None] sig95_2 = power2 / sig95_2 # Where ratio > 1, power is significant
mother = wavelet.Morlet(f0=6) alpha, _, _ = wavelet.ar1(eta) dj = 0.25 s0 = 2 * dt J = 7 / dj wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(signal = eta, dt = dt,\ dj = dj, s0 = s0, J = J,\ wavelet = mother) power = np.abs(wave)**2 fft_power = np.abs(fft)**2 period = 1 / freqs signif, fft_theor = wavelet.significance(signal = 1.0, dt = dt,\ scales = scales, alpha = alpha,\ significance_level = 0.95,\ wavelet = mother) sig95 = np.ones([1, len(eta)]) * signif[:, None] sig95 = power / sig95 phase = np.zeros(np.shape(wave), dtype=float) for jj in range(len(period)): for ii in range(len(i)): real = wave[jj, ii].real imag = wave[jj, ii].imag phase[jj, ii] = np.arctan(imag / real) fig, sub = plt.subplots(figsize=(10, 4)) sub1 = sub.twinx() contf = sub.contourf(i, period, power, cmap="Greys", zorder=7) cont = sub.contour(i, period, sig95,\
def wavelet(self, signal, mother='morlet', plot=True): """ Takes a 1D signal and perfroms a continous wavelet transform. Parameters ---------- time: ndarray The 1D time series for the data data: ndarray The actual 1D data mother: string The name of the family. Acceptable values are Paul, Morlet, DOG, Mexican_hat plot: bool If True, will return a plot of the result. Returns ------- Examples -------- """ sig_level = 0.95 std2 = signal.std() ** 2 signal_orig = signal[:] signal = (signal - signal.mean())/ signal.std() t1 = np.linspace(0,self.period*signal.size,signal.size) wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(signal, self.period, wavelet=mother, dj=1/100) power = (np.abs(wave)) ** 2 period = 1/freqs # alpha, _, _ = wavelet.ar1(signal) alpha = 0.0 ## (variance=1 for the normalized SST) signif, fft_theor = wavelet.significance(1.0, self.period, scales, 0, alpha, significance_level=sig_level, wavelet=mother) sig95 = np.ones([1, signal.size]) * signif[:, None] sig95 = power / sig95 glbl_power = std2 * power.mean(axis=1) dof = signal.size - scales glbl_signif, tmp = wavelet.significance(std2, self.period, scales, 1, alpha, significance_level=sig_level, dof=dof, wavelet=mother) ## indices for stuff idx = self.find_closest(period,coi.max()) ## Into minutes t1 /= 60 period /= 60 coi /= 60 if plot: plt.figure(figsize=(12,12)) ax = plt.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(t1, signal_orig-signal_orig.mean(), 'k', linewidth=1.5) extent = [t1.min(),t1.max(),0,max(period)] bx = plt.axes([0.1, 0.1, 0.65, 0.55], sharex=ax) im = NonUniformImage(bx, interpolation='nearest', extent=extent) im.set_cmap('cubehelix') im.set_data(t1, period[:idx], power[:idx,:]) bx.images.append(im) bx.contour(t1, period[:idx], sig95[:idx,:], [-99,1], colors='w', linewidths=2, extent=extent) bx.fill(np.concatenate([t1, t1[-1:]+self.period, t1[-1:]+self.period,t1[:1]-self.period, t1[:1]-self.period]), (np.concatenate([coi,[1e-9], period[-1:], period[-1:], [1e-9]])), 'k', alpha=0.3,hatch='x', zorder=100) bx.set_xlim(t1.min(),t1.max()) cx = plt.axes([0.77, 0.1, 0.2, 0.55], sharey=bx) cx.plot(glbl_signif[:idx], period[:idx], 'k--') cx.plot(glbl_power[:idx], period[:idx], 'k-', linewidth=1.5) cx.set_ylim(([min(period), period[idx]])) plt.setp(cx.get_yticklabels(), visible=False) plt.show() return wave, scales, freqs, coi, power
def plot_wavelet(t, dat, dt, pl, pr, period_pltlim=None, ax=None, ax2=None, stscale=2, siglev=0.95, cmap='viridis', title='', levels=None, label='', units='', tunits='', sav_img=False): import pycwt as wavelet from pycwt.helpers import find import numpy as np import matplotlib.pyplot as plt from copy import copy import numpy.ma as ma t_ = copy(t) t0 = t[0] # print(Time(t[-1:], format='plot_date').iso) # We also create a time array in years. N = dat.size t = np.arange(0, N) * dt + t0 # print(Time(t[-1:], format='plot_date').iso) # We write the following code to detrend and normalize the input data by its # standard deviation. Sometimes detrending is not necessary and simply # removing the mean value is good enough. However, if your dataset has a well # defined trend, such as the Mauna Loa CO\ :sub:`2` dataset available in the # above mentioned website, it is strongly advised to perform detrending. # Here, we fit a one-degree polynomial function and then subtract it from the # original data. p = np.polyfit(t - t0, dat, 1) dat_notrend = dat - np.polyval(p, t - t0) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset # The next step is to define some parameters of our wavelet analysis. We # select the mother wavelet, in this case the Morlet wavelet with # :math:`\omega_0=6`. mother = wavelet.Morlet(6) s0 = stscale * dt # Starting scale, in this case 2 * 0.25 years = 6 months dj = 1 / 12 # Twelve sub-octaves per octaves J = -1 # 7 / dj # Seven powers of two with dj sub-octaves alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise # The following routines perform the wavelet transform and inverse wavelet # transform using the parameters defined above. Since we have normalized our # input time-series, we multiply the inverse transform by the standard # deviation. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std # We calculate the normalized wavelet and Fourier power spectra, as well as # the Fourier equivalent periods for each wavelet scale. power = (np.abs(wave))**2 fft_power = np.abs(fft)**2 period = 1 / freqs # We could stop at this point and plot our results. However we are also # interested in the power spectra significance test. The power is significant # where the ratio ``power / sig95 > 1``. signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=siglev, wavelet=mother) sig95 = np.ones([1, N]) * signif[:, None] sig95 = power / sig95 # Then, we calculate the global wavelet spectrum and determine its # significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=siglev, dof=dof, wavelet=mother) # We also calculate the scale average between 2 years and 8 years, and its # significance level. sel = find((period >= pl) & (period < pr)) Cdelta = mother.cdelta scale_avg = (scales * np.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance( var, dt, scales, 2, alpha, significance_level=siglev, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) # levels = [0.25, 0.5, 1, 2, 4, 8, 16,32] if levels is None: levels = np.linspace(0.0, 128., 256) # ax.contourf(t, np.log2(period), np.log2(power), np.log2(levels), extend='both', cmap=plt.cm.viridis) im = ax.contourf(t_, np.array(period) * 24 * 60, power, levels, extend='both', cmap=cmap, zorder=-20) # for pathcoll in im.collections: # pathcoll.set_rasterized(True) ax.set_rasterization_zorder(-10) # im = ax.pcolormesh(t_, np.array(period) * 24 * 60, power,vmax=32.,vmin=0, cmap=cmap) # im = ax.contourf(t, np.array(period)*24*60, np.log2(power), np.log2(levels), extend='both', cmap=cmap) extent = [t_.min(), t_.max(), 0, max(period) * 24 * 60] # ax.contour(t, np.log2(period), sig95, [-99, 1], colors='k', linewidths=1, extent=extent) CS = ax.contour(t_, np.array(period) * 24 * 60, sig95 * siglev, [-99, 1.0 * siglev], colors='k', linewidths=1, extent=extent) ax.clabel(CS, inline=1, fmt='%1.3f') ax.fill(np.concatenate( [t_, t_[-1:] + dt, t_[-1:] + dt, t_[:1] - dt, t_[:1] - dt]), np.concatenate([ np.array(coi), [2**(1e-9)], np.array(period[-1:]), np.array(period[-1:]), [2**(1e-9)] ]) * 24 * 60, color='k', alpha=0.75, edgecolor='None', facecolor='k', hatch='x') # ### not Matplotlib does not display hatching when rendering to pdf. Here is a workaround. # ax.fill(np.concatenate([t_, t_[-1:] + dt, t_[-1:] + dt, t_[:1] - dt, t_[:1] - dt]), # np.concatenate( # [np.array(coi), [2 ** (1e-9)], np.array(period[-1:]), np.array(period[-1:]), # [2 ** (1e-9)]]) * 24 * 60, # color='None', alpha=1.0, edgecolor='k', hatch='x') # ax.set_title('b) {} Wavelet Power Spectrum ({})'.format(label, mother.name)) # # ax.set_rasterization_zorder(20) # Yticks = np.arange(np.ceil(np.array(period.min()*24*60)), np.ceil(np.array(period.max()*24*60))) # ax.set_yticks(np.array(Yticks)) # ax.set_yticklabels(Yticks) ax2.plot(glbl_signif, np.array(period) * 24 * 60, 'k--') # ax2.plot(var * fft_theor, np.array(period) * 24 * 60, '--', color='#cccccc') # ax2.plot(var * fft_power, np.array(1. / fftfreqs) * 24 * 60, '-', color='#cccccc', # linewidth=1.) ax2.plot(var * glbl_power, np.array(period) * 24 * 60, 'k-', linewidth=1) mperiod = ma.masked_outside(np.array(period), period_pltlim[0], period_pltlim[1]) mpower = ma.masked_array(var * glbl_power, mask=mperiod.mask) # ax2.set_title('c) Global Wavelet Spectrum') ax2.set_xlabel(r'Power'.format(units)) ax2.set_xlim([0, mpower.compressed().max() + var]) # print(glbl_power) # ax2.set_ylim(np.array([period.min(), period.max()])) # ax2.set_yticks(np.array(Yticks)) # ax2.set_yticklabels(Yticks) plt.setp(ax2.get_yticklabels(), visible=False) if period_pltlim: ax.set_ylim(np.array(period_pltlim) * 24 * 60) else: ax.set_ylim(np.array([period.min(), period.max()]) * 24 * 60) return im
def do_wavelet_transform(dat, dt): t0 = 0 # dt = 0.25 # In years # We also create a time array in years. N = dat.size t = np.arange(0, N) * dt + t0 ''' We write the following code to detrend and normalize the input data by its standard deviation. Sometimes detrending is not necessary and simply removing the mean value is good enough. However, if your dataset has a well defined trend, such as the Mauna Loa CO\ :sub:`2` dataset available in the above mentioned website, it is strongly advised to perform detrending. Here, we fit a one-degree polynomial function and then subtract it from the original data. ''' p = np.polyfit(t - t0, dat, 1) dat_notrend = dat - np.polyval(p, t - t0) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset # The next step is to define some parameters of our wavelet analysis. We # select the mother wavelet, in this case the Morlet wavelet with # :math:`\omega_0=6`. mother = wavelet.Morlet(6) s0 = 2 * dt # Starting scale, in this case 2 * 0.25 years = 6 months dj = 1 / 12 # Twelve sub-octaves per octaves J = 7 / dj # Seven powers of two with dj sub-octaves sr = pd.Series(dat) alpha = sr.autocorr(lag=1) # Lag-1 autocorrelation for red noise ''' The following routines perform the wavelet transform and inverse wavelet transform using the parameters defined above. Since we have normalized our input time-series, we multiply the inverse transform by the standard deviation. ''' wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std # We calculate the normalized wavelet and Fourier power spectra, as well as # the Fourier equivalent periods for each wavelet scale. power = (np.abs(wave))**2 fft_power = np.abs(fft)**2 period = 1 / freqs ''' We could stop at this point and plot our results. However we are also interested in the power spectra significance test. The power is significant where the ratio ``power / sig95 > 1``. ''' signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = np.ones([1, N]) * signif[:, None] sig95 = power / sig95 # Then, we calculate the global wavelet spectrum and determine its # significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) # We also calculate the scale average between 2 years and 8 years, and its # significance level. sel = find((period >= 2) & (period < 8)) Cdelta = mother.cdelta scale_avg = (scales * np.ones((N, 1))).transpose() # As in Torrence and Compo (1998) equation 24 scale_avg = power / scale_avg scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance( var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) return dat, t, \ period, power, coi, wave, \ scales, dt, dj, mother, sig95, \ glbl_power, glbl_signif, \ scale_avg_signif, scale_avg, \ std, iwave, var, \ fft_theor, fft_power, fftfreqs
def parse_frames(image_file, sig=0.95): """ """ cap = cv2.VideoCapture(image_file) if verbose: print("Video successfully loaded") FRAME_COUNT = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) FPS = cap.get(cv2.CAP_PROP_FPS) if verbose > 1: FRAME_HEIGHT = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) FRAME_WIDTH = cap.get(cv2.CAP_PROP_FRAME_WIDTH) print( "INFO: \n Frame count: ", FRAME_COUNT, "\n", "FPS: ", FPS, " \n", "FRAME_HEIGHT: ", FRAME_HEIGHT, " \n", "FRAME_WIDTH: ", FRAME_WIDTH, " \n", ) directory = os.getcwd( ) + '\\analysis\\{}_{}_{}_{}({})_{}_{}_scaled\\'.format( date, trial_type, name, wavelet, order, per_min, per_max) if not os.path.exists(directory): os.makedirs(directory) made = False frame_idx = 0 idx = 0 dropped = 0 skip = True thresh = None df_wav = pd.DataFrame() df_auc = pd.DataFrame() df_for = pd.DataFrame() df_pow = pd.DataFrame() for i in range(FRAME_COUNT): a, img = cap.read() if a: frame_idx += 1 if made == False: #first we need to manually determine the boundaries and angle res = bg.manual_format(img) #print(res) x, y, w, h, angle = res horizon_begin = x horizon_end = x + w vert_begin = y vert_end = y + h #scale_array = np.zeros((FRAME_COUNT, abs(horizon_begin - horizon_end))) #area_time = np.zeros((FRAME_COUNT)) #df['] print("Now Select the Red dot") red_res = bg.manual_format(img, stop_sign=True) red_x, red_y, red_w, red_h = red_res box_h_begin = red_x box_h_end = red_x + red_w box_v_begin = red_y box_v_end = red_y + red_h made = True #dims = (vert_begin, vert_end, horizon_begin, horizon_end) real_time = i / FPS rows, cols, chs = img.shape M = cv2.getRotationMatrix2D((cols / 2, rows / 2), angle, 1) rot_img = cv2.warpAffine(img, M, (cols, rows)) roi = rot_img[vert_begin:vert_end, horizon_begin:horizon_end, :] red_box = img[box_v_begin:box_v_end, box_h_begin:box_h_end, 2] if thresh == None: thresh = np.mean(red_box) #print(np.mean(red_box)) percent_drop = 1 - (np.mean(red_box) / thresh) print(percent_drop) if percent_drop >= 0.18: #cv2.imshow("Red Image", red_box) #cv2.waitKey(0) skip = False if skip: if verbose >= 1: print('Frame is skipped {} / {}'.format( frame_idx, FRAME_COUNT)) continue if verbose >= 1: print('Processing frame {} / {}'.format( frame_idx, FRAME_COUNT)) idx += 1 begin_code, data_line = extract_frame(roi) #We need to detrend the data before sending it away N = len(data_line) dt = su / N t = np.arange(0, N) * dt t = t - np.mean(t) var, std, dat_norm = detrend(data_line) ################################################################### if wavelet == 'DOG': mother = cwt.DOG(order) elif wavelet == 'Paul': mother = cwt.Paul(order) elif wavelet == 'Morlet': mother = cwt.Morlet(order) elif wavelet == 'MexicanHat': mother = cwt.MexicanHat(order) s0 = 4 * dt try: alpha, _, _ = cwt.ar1(dat_norm) except: alpha = 0.95 wave, scales, freqs, coi, fft, fftfreqs = cwt.cwt( dat_norm, dt, dj, s0, J, mother) iwave = cwt.icwt( wave, scales, dt, dj, mother) * std #This is a reconstruction of the wave power = (np.abs(wave))**2 #This is the power spectra fft_power = np.abs(fft)**2 #This is the fourier power period = 1 / freqs #This is the periods of the wavelet analysis in cm power /= scales[:, None] #This is an option suggested by Liu et. al. #Next we calculate the significance of the power spectra. Significane where power / sig95 > 1 signif, fft_theor = cwt.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = np.ones([1, N]) * signif[:, None] sig95 = power / sig95 #This is the significance of the global wave glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = cwt.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) sel = find((period >= per_min) & (period < per_max)) Cdelta = mother.cdelta scale_avg = (scales * np.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 #scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) #scale_array[i,:] = scale_array[i,:]/np.max(scale_array[i,:]) #data_array[i,:] = data_array[i,:]/np.max(data_array[i,:]) scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = cwt.significance( var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) Yticks = 2**np.arange(np.ceil(np.log2(period.min())), np.ceil(np.log2(period.max()))) plt.close('all') plt.ioff() figprops = dict(figsize=(11, 8), dpi=72) fig = plt.figure(**figprops) wx = plt.axes([0.77, 0.75, 0.2, 0.2]) imz = 0 for idxy in range(0, len(period), 10): wx.plot(t, mother.psi(t / period[idxy]) + imz, linewidth=1.5) imz += 1 wx.xaxis.set_ticklabels([]) #wx.set_ylim([-10,10]) # First sub-plot, the original time series anomaly and inverse wavelet # transform. ax = plt.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(t, data_line - np.mean(data_line), 'k', label="Original Data") ax.plot(t, iwave, '-', linewidth=1, color=[0.5, 0.5, 0.5], label="Reconstructed wave") ax.plot(t, dat_norm, '--k', linewidth=1.5, color=[0.5, 0.5, 0.5], label="Denoised Wave") ax.set_title( 'a) {:10.2f} from beginning of trial.'.format(real_time)) ax.set_ylabel(r'{} [{}]'.format("Amplitude", unit)) ax.legend(loc=1) ax.set_ylim([-200, 200]) #If the non-serrated section, bounds are 200 - # Second sub-plot, the normalized wavelet power spectrum and significance # level contour lines and cone of influece hatched area. Note that period # scale is logarithmic. bx = plt.axes([0.1, 0.37, 0.65, 0.28], sharex=ax) levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] cont = bx.contourf(t, np.log2(period), np.log2(power), np.log2(levels), extend='both', cmap=plt.cm.viridis) extent = [t.min(), t.max(), 0, max(period)] bx.contour(t, np.log2(period), sig95, [-99, 1], colors='k', linewidths=2, extent=extent) bx.fill(np.concatenate( [t, t[-1:] + dt, t[-1:] + dt, t[:1] - dt, t[:1] - dt]), np.concatenate([ np.log2(coi), [1e-9], np.log2(period[-1:]), np.log2(period[-1:]), [1e-9] ]), 'k', alpha=0.3, hatch='x') bx.set_title( 'b) {} Octaves Wavelet Power Spectrum [{}({})]'.format( octaves, mother.name, order)) bx.set_ylabel('Period (cm)') # Yticks = 2**np.arange(np.ceil(np.log2(period.min())), np.ceil(np.log2(period.max()))) bx.set_yticks(np.log2(Yticks)) bx.set_yticklabels(Yticks) cbar = fig.colorbar(cont, ax=bx) # Third sub-plot, the global wavelet and Fourier power spectra and theoretical # noise spectra. Note that period scale is logarithmic. cx = plt.axes([0.77, 0.37, 0.2, 0.28], sharey=bx) cx.plot(glbl_signif, np.log2(period), 'k--') cx.plot(var * fft_theor, np.log2(period), '--', color='#cccccc') cx.plot(var * fft_power, np.log2(1. / fftfreqs), '-', color='#cccccc', linewidth=1.) cx.plot(var * glbl_power, np.log2(period), 'k-', linewidth=1.5) cx.set_title('c) Global Wavelet Spectrum') cx.set_xlabel(r'Power [({})^2]'.format(unit)) #cx.set_xlim([0, (var*fft_theor).max()]) plt.xscale('log') cx.set_ylim(np.log2([period.min(), period.max()])) cx.set_yticks(np.log2(Yticks)) cx.set_yticklabels(Yticks) #if sig_array == []: yvals = np.linspace(Yticks.min(), Yticks.max(), len(period)) plt.xscale('linear') plt.setp(cx.get_yticklabels(), visible=False) # Fourth sub-plot, the scale averaged wavelet spectrum. dx = plt.axes([0.1, 0.07, 0.65, 0.2], sharex=ax) dx.axhline(scale_avg_signif, color='k', linestyle='--', linewidth=1.) dx.plot(t, scale_avg, 'k-', linewidth=1.5) dx.set_title('d) {}-{}cm scale-averaged power'.format( per_min, per_max)) dx.set_xlabel('Distance from center(cm)') dx.set_ylabel(r'Average variance [{}]'.format(unit)) #dx.set_ylim([0,500]) ax.set_xlim([t.min(), t.max()]) #plt.savefig(directory+'{}_analysis_frame-{}.png'.format(name, idx), bbox = 'tight') if verbose >= 2: print('*' * int((i / FRAME_COUNT) * 100)) df_wav[real_time] = (pd.Series(dat_norm, index=t)) df_pow[real_time] = (pd.Series(var * glbl_power, index=np.log2(period))) df_for[real_time] = (pd.Series(var * fft_power, index=np.log2(1. / fftfreqs))) df_auc[real_time] = [np.trapz(data_line)] else: print("Frame #{} has dropped".format(i)) dropped += 1 if verbose >= 1: print('All images saved') if verbose >= 1: print("{:10.2f} % of the frames have dropped".format( (dropped / FRAME_COUNT) * 100)) #Plotting and saving tyhe row, cols = df_pow.shape time = np.arange(0, cols) / FPS plt.close('all') plt.ioff() plt.contourf(time, df_pow.index.tolist(), df_pow) plt.contour(time, df_pow.index.tolist(), df_pow) plt.title("Global Power over Time") plt.ylabel("Period[cm]") plt.xlabel("Time") cax = plt.gca() #plt.xscale('log') cax.set_ylim(np.log2([period.min(), period.max()])) cax.set_yticks(np.log2(Yticks)) cax.set_yticklabels(Yticks) plt.savefig(directory + '{}_global_power-{}.png'.format(name, idx), bbox='tight') row, cols = df_for.shape time = np.arange(0, cols) / FPS plt.close('all') plt.ioff() plt.contourf(time, df_for.index.tolist(), df_for) plt.contour(time, df_for.index.tolist(), df_for) plt.title("Fourier Power over Time") plt.ylabel("Period[cm]") plt.xlabel("Time") cax = plt.gca() #plt.xscale('log') cax.set_ylim(np.log2([period.min(), period.max()])) cax.set_yticks(np.log2(Yticks)) cax.set_yticklabels(Yticks) plt.savefig(directory + '{}_fourier_power-{}.png'.format(name, idx), bbox='tight') plt.close('all') plt.ioff() rows, cols = df_auc.shape time = np.arange(0, cols) / FPS plt.plot(time, df_auc.T) plt.xlabel("Time") plt.ylabel("Area under the curve in cm") plt.title("Area under the curve over time") plt.savefig(directory + '{}_area_under_curve-{}.png'.format(name, idx), bbox='tight') df_wav['Mean'] = df_wav.mean(axis=1) df_pow['Mean'] = df_pow.mean(axis=1) df_for['Mean'] = df_for.mean(axis=1) df_auc['Mean'] = df_auc.mean(axis=1) df_wav['Standard Deviation'] = df_wav.std(axis=1) df_pow['Standard Deviation'] = df_pow.std(axis=1) df_for['Standard Deviation'] = df_for.std(axis=1) df_auc['Standard Deviation'] = df_auc.std(axis=1) ##[Writing analysis to excel]############################################## print("Writing files") writer = pd.ExcelWriter(directory + "analysis{}.xlsx".format(trial_name)) df_wav.to_excel(writer, "Raw Waveforms") df_auc.to_excel(writer, "Area Under the Curve") df_for.to_excel(writer, "Fourier Spectra") df_pow.to_excel(writer, "Global Power Spectra") writer.save() ##[Writing means to a single file]######################################### #filename = 'C:\\pyscripts\\wavelet_analysis\\Overall_Analysis.xlsx' #append_data(filename, df_pow['Mean'].values, str(trial_name), Yticks) ##[Plotting mean power and foruier]######################################## plt.close('all') plt.ioff() plt.plot(df_pow['Mean'], df_pow.index.tolist(), label="Global Power") plt.plot(df_for['Mean'], df_for.index.tolist(), label="Fourier Power") plt.title("Global Power averaged over Time") plt.ylabel("Period[cm]") plt.xlabel("Power[cm^2]") cax = plt.gca() #plt.xscale('log') cax.set_ylim(np.log2([period.min(), period.max()])) cax.set_yticks(np.log2(Yticks)) cax.set_yticklabels(Yticks) plt.legend() plt.savefig(directory + '{}_both_{}.png'.format(name, idx), bbox='tight') plt.close('all') plt.ioff() plt.plot(df_pow['Mean'], df_pow.index.tolist(), label="Global Power") plt.title("Global Power averaged over Time") plt.ylabel("Period[cm]") plt.xlabel("Power[cm^2]") cax = plt.gca() #plt.xscale('log') cax.set_ylim(np.log2([period.min(), period.max()])) cax.set_yticks(np.log2(Yticks)) cax.set_yticklabels(Yticks) plt.legend() plt.savefig(directory + '{}_global_power_{}.png'.format(name, idx), bbox='tight') plt.close('all') plt.ioff() plt.plot(df_for['Mean'], df_for.index.tolist(), label="Fourier Power") plt.title("Fourier averaged over Time") plt.ylabel("Period[cm]") plt.xlabel("Power[cm^2]") cax = plt.gca() #plt.xscale('log') cax.set_ylim(np.log2([period.min(), period.max()])) cax.set_yticks(np.log2(Yticks)) cax.set_yticklabels(Yticks) plt.legend() plt.savefig(directory + '{}_fourier_{}.png'.format(name, idx), bbox='tight') cap.release() return directory
def wavelet_transform(dat, mother, s0, dj, J, dt, lims=[20, 120], t0=0): """ Plot the continous wavelet transform for a given signal. Make sure to detrend and normalize the data before calling this funcion. This is a function wrapper around the pycwt simple_sample example with some modifications. ---------- Args: dat (Mandatory [array like]): input signal data. mother (Mandatory [str]): the wavelet mother name. s0 (Mandatory [float]): starting scale. dj (Mandatory [float]): number of sub-octaves per octaves. j (Mandatory [float]): powers of two with dj sub-octaves. dt (Mandatory [float]): same frequency in the same unit as the input. lims (Mandatory [list]): Period interval to integrate the local power spectrum. label (Mandatory [str]): the plot y-label. title (Mandatory [str]): the plot title. ---------- Return: No """ # also create a time array in years. N = dat.size t = np.arange(0, N) * dt + t0 # write the following code to detrend and normalize the input data by its # standard deviation. Sometimes detrending is not necessary and simply # removing the mean value is good enough. However, if your dataset has a # well defined trend, such as the Mauna Loa CO\ :sub:`2` dataset available # in the above mentioned website, it is strongly advised to perform # detrending. Here, we fit a one-degree polynomial function and then # subtract it from the # original data. p = np.polyfit(t - t0, dat, 1) dat_notrend = dat - np.polyval(p, t - t0) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise # the following routines perform the wavelet transform and inverse wavelet # transform using the parameters defined above. Since we have normalized # our input time-series, we multiply the inverse transform by the standard # deviation. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std # calculate the normalized wavelet and Fourier power spectra, as well as # the Fourier equivalent periods for each wavelet scale. power = (np.abs(wave))**2 fft_power = np.abs(fft)**2 period = 1 / freqs # inverse transform but only considering lims idx1 = np.argmin(np.abs(period - LIMS[0])) idx2 = np.argmin(np.abs(period - LIMS[1])) _wave = wave.copy() _wave[0:idx1, :] = 0 igwave = wavelet.icwt(_wave, scales, dt, dj, mother) * std # could stop at this point and plot our results. However we are also # interested in the power spectra significance test. The power is # significant where the ratio ``power / sig95 > 1``. signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = np.ones([1, N]) * signif[:, None] sig95 = power / sig95 # calculate the global wavelet spectrum and determine its # significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) return t, dt, power, period, coi, sig95, iwave, igwave
def takewav_makefig(dd,moornum): if moornum==8: dt=1 dat=pd.read_csv(dd,header=12,sep='\s*') date=unique([datetime.datetime(int(dat.ix[ii,0]), int(dat.ix[ii,1]), int(dat.ix[ii,2]), int(dat.ix[ii,3])) for ii in range(len(dat))]) utest=array(dat.ix[:,6]/100) vtest=array(dat.ix[:,7]/100) nomd=int(nanmean(array(dat.ix[:,5]))) dat=utest**2+vtest**2 savetit='M1-'+str(nomd)+'m' else: dataset=xr.open_dataset(dd) date=dataset['TIME'] ke=dataset['UCUR']**2+dataset['VCUR']**2 dat=ke.values.flatten() dt=0.5 nomd=int(dataset.geospatial_vertical_min) savetit=dataset.platform_code[-3:]+'-'+str(nomd)+'m' dat[isnan(dat)]=nanmean(dat) alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise N=len(dat) #in hours t = numpy.arange(0, N) * dt std=dat.std() var=std**2 dat_norm=dat/std # The following routines perform the wavelet transform and inverse wavelet transform using the parameters defined above. Since we have normalized our input time-series, we multiply the inverse transform by the standard deviation. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(dat_norm,dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std # We calculate the normalized wavelet and Fourier power spectra, as well as the Fourier equivalent periods for each wavelet scale. power = (numpy.abs(wave)) ** 2 fft_power = numpy.abs(fft) ** 2 period = 1 / freqs # Optionally, we could also rectify the power spectrum according to the suggestions proposed by Liu et al. (2007)[2] power /= scales[:, None] # We could stop at this point and plot our results. However we are also interested in the power spectra significance test. The power is significant where the ratio power / sig95 > 1. signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 # Then, we calculate the global wavelet spectrum and determine its significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) # We also calculate the scale average between pmin and pmax, and its significance level. f,dx = pyplot.subplots(6,1,figsize=(12,12),sharex=True) bands=[1,2,8,16,48,128,512] for ii in range(len(bands)-1): pmin=bands[ii] pmax=bands[ii+1] sel = find((period >= pmin) & (period < pmax)) Cdelta = mother.cdelta scale_avg = (scales * numpy.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance(var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) dx[ii].axhline(scale_avg_signif, color='C'+str(ii), linestyle='--', linewidth=1.) dx[ii].plot(date, scale_avg, '-', color='C'+str(ii), linewidth=1.5,label='{}--{} hour band'.format(pmin,pmax)) [dx[ii].axvline(dd,color=clist[jj],linewidth=3) for jj,dd in enumerate(dlist)] dx[ii].legend() dx[0].set_title('Scale-averaged power: '+savetit) dx[3].set_ylabel(r'Average variance [{}]'.format(units)) if moornum ==8: dx[0].set_xlim(date[0],date[-1]) else: dx[0].set_xlim(date[0].values,date[-1].values) savefig(figdir+'ScaleSep_'+savetit+'.png',bbox_inches='tight') pmin=2 pmax=24 sel = find((period >= pmin) & (period < pmax)) Cdelta = mother.cdelta scale_avg = (scales * numpy.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance(var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) figprops = dict(figsize=(11, 8), dpi=72) fig = pyplot.figure(**figprops) # First sub-plot, the original time series anomaly and inverse wavelet # transform. ax = pyplot.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(date, dat, linewidth=1.5, color=[0.5, 0.5, 0.5]) ax.plot(date, iwave, 'k-', linewidth=1,zorder=100) if moornum ==8: ax.set_xlim(date[0],date[-1]) else: ax.set_xlim(date[0].values,date[-1].values) # ax.set_title('a) {}'.format(title)) ax.set_ylabel(r'{} [{}]'.format(label, units)) # Second sub-plot, the normalized wavelet power spectrum and significance # level contour lines and cone of influece hatched area. Note that period # scale is logarithmic. bx = pyplot.axes([0.1, 0.37, 0.65, 0.28]) levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] bx.contourf(t, numpy.log2(period), numpy.log2(power), numpy.log2(levels), extend='both', cmap=pyplot.cm.viridis) extent = [t.min(), t.max(), 0, max(period)] bx.contour(t, numpy.log2(period), sig95, [-99, 1], colors='k', linewidths=2, extent=extent) bx.fill(numpy.concatenate([t, t[-1:] + dt, t[-1:] + dt, t[:1] - dt, t[:1] - dt]), numpy.concatenate([numpy.log2(coi), [1e-9], numpy.log2(period[-1:]), numpy.log2(period[-1:]), [1e-9]]), 'k', alpha=0.3, hatch='x') bx.set_title('{} Wavelet Power Spectrum ({})'.format(label, mother.name)) bx.set_ylabel('Period (hours)') # Yticks = 2 ** numpy.arange(numpy.ceil(numpy.log2(period.min())), numpy.ceil(numpy.log2(period.max()))) bx.set_yticks(numpy.log2(Yticks)) bx.set_yticklabels(Yticks) bx.set_xticklabels('') bx.set_xlim(t.min(),t.max()) # Third sub-plot, the global wavelet and Fourier power spectra and theoretical # noise spectra. Note that period scale is logarithmic. cx = pyplot.axes([0.77, 0.37, 0.2, 0.28], sharey=bx) cx.plot(glbl_signif, numpy.log2(period), 'k--') cx.plot(var * fft_theor, numpy.log2(period), '--', color='#cccccc') cx.plot(var * fft_power, numpy.log2(1./fftfreqs), '-', color='#cccccc', linewidth=1.) cx.plot(var * glbl_power, numpy.log2(period), 'k-', linewidth=1.5) cx.set_title('Global Wavelet Spectrum') cx.set_xlabel(r'Power [({})^2]'.format(units)) cx.set_xlim([0, glbl_power.max() + var]) cx.set_ylim(numpy.log2([period.min(), period.max()])) cx.set_yticks(numpy.log2(Yticks)) cx.set_yticklabels(Yticks) pyplot.setp(cx.get_yticklabels(), visible=False) spowdic={} spowdic['sig']=scale_avg_signif if moornum==8: spowdic['date']=date else: spowdic['date']=date.values spowdic['spow']=scale_avg # Fourth sub-plot, the scale averaged wavelet spectrum. dx = pyplot.axes([0.1, 0.07, 0.65, 0.2], sharex=ax) dx.axhline(scale_avg_signif, color='k', linestyle='--', linewidth=1.) dx.plot(date, scale_avg, 'k-', linewidth=1.5) dx.set_title('{}--{} hour scale-averaged power'.format(pmin,pmax)) # [dx.axvline(dd,color=clist[ii],linewidth=3) for ii,dd in enumerate(dlist)] # dx.set_xlabel('Time (hours)') dx.set_ylabel(r'Average variance [{}]'.format(units)) if moornum ==8: dx.set_xlim(date[0],date[-1]) else: dx.set_xlim(date[0].values,date[-1].values) fig.suptitle(savetit) savefig(figdir+'Wavelet_'+savetit+'.png',bbox_inches='tight') return nomd,spowdic
alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt(dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std power = (numpy.abs(wave))**2 fft_power = numpy.abs(fft)**2 period = 1 / freqs power /= scales[:, None] signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof,
def calc_wPowerSpectrum(dat, sample_times, min_freq=1, max_freq=256, detrend=True, c_sig=False, resolution=12): """ Calculate wavelet power spectrum using pycwt. TODO is this function needed? Parameters ---------- dat : np.ndarray The values of the waveform. sample_times : : np.ndarray The times at which waveform samples occur. min_freq : float Supposed to be minimum frequency, but not quite working. max_freq : float Supposed to be max frequency, but not quite working. c_sig : bool, default False Optional. Calculate significance. detrend : bool, default False Optional. Detrend and normalize the input data by its standard deviation. resolution : int How many wavelets should be at each level. Number of sub-octaves per octaves """ t = np.asarray(sample_times) dt = np.mean(np.diff(t)) dj = resolution s0 = min_freq * dt if s0 < 2 * dt: s0 = 2 * dt max_J = max_freq * dt J = dj * np.int(np.round(np.log2(max_J / np.abs(s0)))) # alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red artf if detrend: p = np.polyfit(t - t[0], dat, 1) dat_notrend = dat - np.polyval(p, t - t[0]) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset else: std = dat.std() # Standard deviation dat_nomean = dat - np.mean(dat) dat_norm = dat_nomean / std # Normalized dataset wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J) power = (np.abs(wave))**2 fft_power = np.abs(fft)**2 period = 1 / freqs if c_sig: # calculate the normalized wavelet and Fourier power spectra, and the Fourier equivalent periods for each wavelet scale. signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = np.ones([1, N]) * signif[:, None] sig95 = power / sig95 # Calculate the global wavelet spectrum and determine its significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother)
def graph_wavelet(data_xs, title, lims, font = 11, params = default_params): a_lims, b_lims, d_lims = lims plt.rcParams.update({'font.size': font}) return_data = {} N = len(data_xs) dt = (2*params['per_pixel'])/N #This is how much cm each pixel equals t = np.arange(0, N) * dt t = t - np.mean(t) t0 = 0 per_min = params['min_per'] per_max = params['max_per'] units = params['units'] sx = params['sx'] octaves = params['octaves'] dj = 1/params['suboctaves'] #suboctaves order = params['order'] var, std, dat_norm = detrend(data_xs) mother = cwt.DOG(order) #This is the Mother Wavelet s0 = sx * dt #This is the starting scale, which in out case is two pixels or 0.04cm/40um\ J = octaves/dj #This is powers of two with dj suboctaves return_data['var'] = var return_data['std'] = std try: alpha, _, _ = cwt.ar1(dat_norm) #This calculates the Lag-1 autocorrelation for red noise except: alpha = 0.95 wave, scales, freqs, coi, fft, fftfreqs = cwt.cwt(dat_norm, dt, dj, s0, J, mother) return_data['scales'] = scales return_data['freqs'] = freqs return_data['fft'] = fft iwave = cwt.icwt(wave, scales, dt, dj, mother) * std power = (np.abs(wave)) ** 2 fft_power = np.abs(fft) ** 2 period = 1 / freqs power /= scales[:, None] #This is an option suggested by Liu et. al. #Next we calculate the significance of the power spectra. Significane where power / sig95 > 1 signif, fft_theor = cwt.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = np.ones([1, N]) * signif[:, None] sig95 = power / sig95 glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = cwt.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) sel = find((period >= per_min) & (period < per_max)) Cdelta = mother.cdelta scale_avg = (scales * np.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = cwt.significance(var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) # Prepare the figure plt.close('all') plt.ioff() figprops = dict(figsize=(11, 11), dpi=72) fig = plt.figure(**figprops) wx = plt.axes([0.77, 0.75, 0.2, 0.2]) imz = 0 for idxy in range(0,len(period), 10): wx.plot(t, mother.psi(t / period[idxy]) + imz, linewidth = 1.5) imz+=1 wx.xaxis.set_ticklabels([]) ax = plt.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(t, data_xs, 'k', linewidth=1.5) ax.plot(t, iwave, '-', linewidth=1, color=[0.5, 0.5, 0.5]) ax.plot(t, dat_norm, '--', linewidth=1.5, color=[0.5, 0.5, 0.5]) if a_lims != None: ax.set_ylim([-a_lims, a_lims]) ax.set_title('a) {}'.format(title)) ax.set_ylabel(r'Displacement [{}]'.format(units)) #ax.set_ylim([-20,20]) bx = plt.axes([0.1, 0.37, 0.65, 0.28], sharex=ax) levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] bx.contourf(t, np.log2(period), np.log2(power), np.log2(levels), extend='both', cmap=plt.cm.viridis) extent = [t.min(), t.max(), 0, max(period)] bx.contour(t, np.log2(period), sig95, [-99, 1], colors='k', linewidths=2, extent=extent) bx.fill(np.concatenate([t, t[-1:] + dt, t[-1:] + dt, t[:1] - dt, t[:1] - dt]), np.concatenate([np.log2(coi), [1e-9], np.log2(period[-1:]), np.log2(period[-1:]), [1e-9]]), 'k', alpha=0.3, hatch='x') bx.set_title('b) {} Octaves Wavelet Power Spectrum [{}({})]'.format(octaves, mother.name, order)) bx.set_ylabel('Period (cm)') # Yticks = 2 ** np.arange(np.ceil(np.log2(period.min())), np.ceil(np.log2(period.max()))) bx.set_yticks(np.log2(Yticks)) bx.set_yticklabels(Yticks) # Third sub-plot, the global wavelet and Fourier power spectra and theoretical # noise spectra. Note that period scale is logarithmic. cx = plt.axes([0.77, 0.37, 0.2, 0.28], sharey=bx) cx.plot(glbl_signif, np.log2(period), 'k--') cx.plot(var * fft_theor, np.log2(period), '--', color='#cccccc') cx.plot(var * fft_power, np.log2(1./fftfreqs), '-', color='#cccccc', linewidth=1.) return_data['global_power'] = var * glbl_power return_data['fourier_spectra'] = var * fft_power return_data['per'] = np.log2(period) return_data['amp'] = np.log2(1./fftfreqs) cx.plot(var * glbl_power, np.log2(period), 'k-', linewidth=1.5) cx.set_title('c) Power Spectrum') cx.set_xlabel(r'Power [({})^2]'.format(units)) if b_lims != None: cx.set_xlim([0,b_lims]) #cx.set_xlim([0,max(glbl_power.max(), var*fft_power.max())]) #print(max(glbl_power.max(), var*fft_power.max())) cx.set_ylim(np.log2([period.min(), period.max()])) cx.set_yticks(np.log2(Yticks)) cx.set_yticklabels(Yticks) return_data['yticks'] = Yticks plt.setp(cx.get_yticklabels(), visible=False) # Fourth sub-plot, the scale averaged wavelet spectrum. dx = plt.axes([0.1, 0.07, 0.65, 0.2], sharex=ax) dx.axhline(scale_avg_signif, color='k', linestyle='--', linewidth=1.) dx.plot(t, scale_avg, 'k-', linewidth=1.5) dx.set_title('d) {}--{} cm scale-averaged power'.format(per_min, per_max)) dx.set_xlabel('Displacement (cm)') dx.set_ylabel(r'Average variance [{}]'.format(units)) ax.set_xlim([t.min(), t.max()]) if d_lims != None: dx.set_ylim([0,d_lims]) plt.savefig("C:\pyscripts\wavelet_analysis\Calibrated Images\{}".format(title)) return fig, return_data
def simple_sample(sls): # Then, we load the dataset and define some data related parameters. In this # case, the first 19 lines of the data file contain meta-data, that we ignore, # since we set them manually (*i.e.* title, units). # url = 'http://paos.colorado.edu/research/wavelets/wave_idl/nino3sst.txt' # dat = numpy.genfromtxt(url, skip_header=19) title = 'Sentence Length' label = 'Zhufu Sentence Length' units = 'Characters' t0 = 1 dt = 1 # In years dat = numpy.array(sls) # We also create a time array in years. N = dat.size t = numpy.arange(0, N) * dt + t0 # We write the following code to detrend and normalize the input data by its # standard deviation. Sometimes detrending is not necessary and simply # removing the mean value is good enough. However, if your dataset has a well # defined trend, such as the Mauna Loa CO\ :sub:`2` dataset available in the # above mentioned website, it is strongly advised to perform detrending. # Here, we fit a one-degree polynomial function and then subtract it from the # original data. p = numpy.polyfit(t - t0, dat, 1) dat_notrend = dat - numpy.polyval(p, t - t0) std = dat_notrend.std() # Standard deviation var = std**2 # Variance dat_norm = dat_notrend / std # Normalized dataset # The next step is to define some parameters of our wavelet analysis. We # select the mother wavelet, in this case the Morlet wavelet with # :math:`\omega_0=6`. mother = wavelet.Morlet(6) s0 = 2 * dt # Starting scale, in this case 2 * 0.25 years = 6 months dj = 1 / 12 # Twelve sub-octaves per octaves J = 7 / dj # Seven powers of two with dj sub-octaves alpha, _, _ = wavelet.ar1(dat) # Lag-1 autocorrelation for red noise # The following routines perform the wavelet transform and inverse wavelet # transform using the parameters defined above. Since we have normalized our # input time-series, we multiply the inverse transform by the standard # deviation. wave, scales, freqs, coi, fft, fftfreqs = wavelet.cwt( dat_norm, dt, dj, s0, J, mother) iwave = wavelet.icwt(wave, scales, dt, dj, mother) * std # We calculate the normalized wavelet and Fourier power spectra, as well as # the Fourier equivalent periods for each wavelet scale. power = (numpy.abs(wave))**2 fft_power = numpy.abs(fft)**2 period = 1 / freqs # We could stop at this point and plot our results. However we are also # interested in the power spectra significance test. The power is significant # where the ratio ``power / sig95 > 1``. signif, fft_theor = wavelet.significance(1.0, dt, scales, 0, alpha, significance_level=0.95, wavelet=mother) sig95 = numpy.ones([1, N]) * signif[:, None] sig95 = power / sig95 # Then, we calculate the global wavelet spectrum and determine its # significance level. glbl_power = power.mean(axis=1) dof = N - scales # Correction for padding at edges glbl_signif, tmp = wavelet.significance(var, dt, scales, 1, alpha, significance_level=0.95, dof=dof, wavelet=mother) # We also calculate the scale average between 2 years and 8 years, and its # significance level. sel = find((period >= 2) & (period < 8)) Cdelta = mother.cdelta scale_avg = (scales * numpy.ones((N, 1))).transpose() scale_avg = power / scale_avg # As in Torrence and Compo (1998) equation 24 scale_avg = var * dj * dt / Cdelta * scale_avg[sel, :].sum(axis=0) scale_avg_signif, tmp = wavelet.significance( var, dt, scales, 2, alpha, significance_level=0.95, dof=[scales[sel[0]], scales[sel[-1]]], wavelet=mother) # Finally, we plot our results in four different subplots containing the # (i) original series anomaly and the inverse wavelet transform; (ii) the # wavelet power spectrum (iii) the global wavelet and Fourier spectra ; and # (iv) the range averaged wavelet spectrum. In all sub-plots the significance # levels are either included as dotted lines or as filled contour lines. # Prepare the figure pyplot.close('all') pyplot.ioff() figprops = dict(figsize=(11, 8), dpi=72) fig = pyplot.figure(**figprops) # First sub-plot, the original time series anomaly and inverse wavelet # transform. ax = pyplot.axes([0.1, 0.75, 0.65, 0.2]) ax.plot(t, iwave, '-', linewidth=1, color=[0.5, 0.5, 0.5]) ax.plot(t, dat, 'k', linewidth=1.5) ax.set_title('a) {}'.format(title)) ax.set_ylabel(r'{} [{}]'.format(label, units)) # Second sub-plot, the normalized wavelet power spectrum and significance # level contour lines and cone of influece hatched area. Note that period # scale is logarithmic. bx = pyplot.axes([0.1, 0.37, 0.65, 0.28], sharex=ax) levels = [0.0625, 0.125, 0.25, 0.5, 1, 2, 4, 8, 16] bx.contourf(t, numpy.log2(period), numpy.log2(power), numpy.log2(levels), extend='both', cmap=pyplot.cm.viridis) extent = [t.min(), t.max(), 0, max(period)] bx.contour(t, numpy.log2(period), sig95, [-99, 1], colors='k', linewidths=2, extent=extent) bx.fill(numpy.concatenate( [t, t[-1:] + dt, t[-1:] + dt, t[:1] - dt, t[:1] - dt]), numpy.concatenate([ numpy.log2(coi), [1e-9], numpy.log2(period[-1:]), numpy.log2(period[-1:]), [1e-9] ]), 'k', alpha=0.3, hatch='x') bx.set_title('b) {} Wavelet Power Spectrum ({})'.format( label, mother.name)) bx.set_ylabel('Period (years)') # Yticks = 2**numpy.arange(numpy.ceil(numpy.log2(period.min())), numpy.ceil(numpy.log2(period.max()))) bx.set_yticks(numpy.log2(Yticks)) bx.set_yticklabels(Yticks) # Third sub-plot, the global wavelet and Fourier power spectra and theoretical # noise spectra. Note that period scale is logarithmic. cx = pyplot.axes([0.77, 0.37, 0.2, 0.28], sharey=bx) cx.plot(glbl_signif, numpy.log2(period), 'k--') cx.plot(var * fft_theor, numpy.log2(period), '--', color='#cccccc') cx.plot(var * fft_power, numpy.log2(1. / fftfreqs), '-', color='#cccccc', linewidth=1.) cx.plot(var * glbl_power, numpy.log2(period), 'k-', linewidth=1.5) cx.set_title('c) Global Wavelet Spectrum') cx.set_xlabel(r'Power [({})^2]'.format(units)) cx.set_xlim([0, glbl_power.max() + var]) cx.set_ylim(numpy.log2([period.min(), period.max()])) cx.set_yticks(numpy.log2(Yticks)) cx.set_yticklabels(Yticks) pyplot.setp(cx.get_yticklabels(), visible=False) # Third sub-plot, the global wavelet and Fourier power spectra and theoretical # noise spectra. Note that period scale is logarithmic. dx = pyplot.axes([0.1, 0.07, 0.65, 0.2]) dx.plot(numpy.log2(fftfreqs), numpy.log2(fft_power), 'k') dx.plot(numpy.log2(freqs), var * fft_theor, '--', color='#cccccc') dx.plot(numpy.log2(1. / fftfreqs), var * fft_power, '-', color='#cccccc', linewidth=1.) dx.plot(fftfreqs, fft_power, 'k-', linewidth=1.5) dx.set_title('d) Global Wavelet Spectrum') dx.set_ylabel(r'Power [({})^2]'.format(units)) dx.set_xlim([0, 2 * fftfreqs.max()]) Yticks = 2**numpy.arange(numpy.ceil(numpy.log2(fft_power.min())), numpy.ceil(numpy.log2(fft_power.max()))) dx.set_ylim(numpy.log2([fft_power.min(), fft_power.max()])) dx.set_yticks(numpy.log2(Yticks)) dx.set_yticklabels(Yticks) pyplot.setp(dx.get_yticklabels(), visible=False) pyplot.show()