def test_cached_coherence(): """Testing the cached coherence functions """ NFFT = 64 # This is the default behavior n_freqs = NFFT // 2 + 1 ij = [(0, 1), (1, 0)] ts = np.loadtxt(os.path.join(test_dir_path, 'tseries12.txt')) freqs, cache = tsa.cache_fft(ts, ij) # Are the frequencies the right ones? npt.assert_equal(freqs, utils.get_freqs(2 * np.pi, NFFT)) # Check that the fft of the first window is what we expect: hann = mlab.window_hanning(np.ones(NFFT)) w_ts = ts[0][:NFFT] * hann w_ft = fftpack.fft(w_ts)[0:n_freqs] # This is the result of the function: first_window_fft = cache['FFT_slices'][0][0] npt.assert_equal(w_ft, first_window_fft) coh_cached = tsa.cache_to_coherency(cache, ij)[0, 1] f, c = tsa.coherency(ts) coh_direct = c[0, 1] npt.assert_almost_equal(coh_direct, coh_cached) # Only welch PSD works and an error is thrown otherwise. This tests that # the error is thrown: with pytest.raises(ValueError) as e_info: tsa.cache_fft(ts, ij, method=methods[2]) # Take the method in which the window is defined on input: freqs, cache1 = tsa.cache_fft(ts, ij, method=methods[3]) # And compare it to the method in which it isn't: freqs, cache2 = tsa.cache_fft(ts, ij, method=methods[4]) npt.assert_equal(cache1, cache2) # Do the same, while setting scale_by_freq to False: freqs, cache1 = tsa.cache_fft(ts, ij, method=methods[3], scale_by_freq=False) freqs, cache2 = tsa.cache_fft(ts, ij, method=methods[4], scale_by_freq=False) npt.assert_equal(cache1, cache2) # Test cache_to_psd: psd1 = tsa.cache_to_psd(cache, ij)[0] # Against the standard get_spectra: f, c = tsa.get_spectra(ts) psd2 = c[0][0] npt.assert_almost_equal(psd1, psd2) # Test that prefer_speed_over_memory doesn't change anything: freqs, cache1 = tsa.cache_fft(ts, ij) freqs, cache2 = tsa.cache_fft(ts, ij, prefer_speed_over_memory=True) psd1 = tsa.cache_to_psd(cache1, ij)[0] psd2 = tsa.cache_to_psd(cache2, ij)[0] npt.assert_almost_equal(psd1, psd2)
def test_cached_coherence(): """Testing the cached coherence functions """ NFFT = 64 #This is the default behavior n_freqs = NFFT//2 + 1 ij = [(0,1),(1,0)] ts = np.loadtxt(os.path.join(test_dir_path,'tseries12.txt')) freqs,cache = tsa.cache_fft(ts,ij) #Are the frequencies the right ones? yield npt.assert_equal,freqs,ut.get_freqs(2*np.pi,NFFT) #Check that the fft of the first window is what we expect: hann = mlab.window_hanning(np.ones(NFFT)) w_ts = ts[0][:NFFT]*hann w_ft = np.fft.fft(w_ts)[0:n_freqs] #This is the result of the function: first_window_fft = cache['FFT_slices'][0][0] yield npt.assert_equal,w_ft,first_window_fft coh_cached = tsa.cache_to_coherency(cache,ij)[0,1] f,c = tsa.coherency(ts) coh_direct = c[0,1] yield npt.assert_almost_equal,coh_direct,coh_cached
def test_cache_to_phase(): """ Test phase calculations from cached windowed FFT """ ij = [(0, 1), (1, 0)] x = np.sin(t) + np.sin(2 * t) + np.sin(3 * t) + np.random.rand(t.shape[-1]) y = np.sin(t) + np.sin(2 * t) + np.sin(3 * t) + np.random.rand(t.shape[-1]) ts = np.vstack([x, y]) freqs, cache = tsa.cache_fft(ts, ij) ph = tsa.cache_to_phase(cache, ij)
def cache(self): """Caches the fft windows required by the other methods of the SparseCoherenceAnalyzer. Calculate only once and reuse """ data = self.input.data f,cache = tsa.cache_fft(data,self.ij, lb=self.lb,ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) return cache
def test_coherency_cached(): """Tests that the cached coherency gives the same result as the standard coherency""" f1, c1 = tsa.coherency(tseries) ij = [(0, 1), (1, 0)] f2, cache = tsa.cache_fft(tseries, ij) c2 = tsa.cache_to_coherency(cache, ij) npt.assert_array_almost_equal(c1[1, 0], c2[1, 0]) npt.assert_array_almost_equal(c1[0, 1], c2[0, 1])
def cache(self): """Caches the fft windows required by the other methods of the SparseCoherenceAnalyzer. Calculate only once and reuse """ data = self.input.data f, cache = tsa.cache_fft( data, self.ij, lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) return cache
def target_cache(self): data = self.target.data #Make a cache with all the fft windows for each of the channels in the #target. #This is the kind of input that cache_fft expects: ij = list(zip(np.arange(data.shape[0]), np.arange(data.shape[0]))) f, cache = tsa.cache_fft(data, ij, lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) return cache
def test_coherency_cached(): """Tests that the cached coherency gives the same result as the standard coherency""" t = np.linspace(0,16*np.pi,1024) x = np.sin(t) + np.sin(2*t) + np.sin(3*t) + np.random.rand(t.shape[-1]) y = x + np.random.rand(t.shape[-1]) f1,c1 = tsa.coherency(np.vstack([x,y])) ij = [(0,1),(1,0)] f2,cache = tsa.cache_fft(np.vstack([x,y]),ij) c2 = tsa.cache_to_coherency(cache,ij) npt.assert_array_almost_equal(c1[1,0],c2[1,0]) npt.assert_array_almost_equal(c1[0,1],c2[0,1])
def test_cache_to_coherency(): """ Test cache_to_coherency against the standard coherency calculation """ ij = [(0, 1), (1, 0)] ts = np.loadtxt(os.path.join(test_dir_path, 'tseries12.txt')) freqs, cache = tsa.cache_fft(ts, ij) Cxy = tsa.cache_to_coherency(cache, ij) f, c = tsa.coherency(ts) npt.assert_almost_equal(Cxy[0][1], c[0, 1]) # Check that it doesn't matter if you prefer_speed_over_memory: freqs, cache2 = tsa.cache_fft(ts, ij, prefer_speed_over_memory=True) Cxy2 = tsa.cache_to_coherency(cache2, ij) npt.assert_equal(Cxy2, Cxy) # XXX Calculating the angle of the averaged psd and calculating the average # of the angles calculated over different windows does not yield exactly # the same number, because the angle is not a linear functions (arctan), # so it is unclear how to test this, but we make sure that it runs, # whether or not you prefer_speed_over_memory: freqs, cache = tsa.cache_fft(ts, ij) tsa.cache_to_relative_phase(cache, ij) freqs, cache = tsa.cache_fft(ts, ij, prefer_speed_over_memory=True) tsa.cache_to_relative_phase(cache, ij) # Check that things run alright, even if there is just one window for the # entire ts: freqs, cache = tsa.cache_fft(ts, ij, method=dict(this_method='welch', NFFT=ts.shape[-1], n_overlap=0)) cxy_one_window = tsa.cache_to_coherency(cache, ij) ph_one_window = tsa.cache_to_relative_phase(cache, ij) # And whether or not you prefer_speed_over_memory freqs, cache = tsa.cache_fft(ts, ij, method=dict(this_method='welch', NFFT=ts.shape[-1], n_overlap=0), prefer_speed_over_memory=True) cxy_one_window = tsa.cache_to_coherency(cache, ij) ph_one_window = tsa.cache_to_relative_phase(cache, ij)
def target_cache(self): data = self.target.data #Make a cache with all the fft windows for each of the channels in the #target. #This is the kind of input that cache_fft expects: ij = list(zip(np.arange(data.shape[0]), np.arange(data.shape[0]))) f, cache = tsa.cache_fft( data, ij, lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) return cache
def test_cache_to_coherency(): """ Test cache_to_coherency against the standard coherency calculation """ ij = [(0,1),(1,0)] ts = np.loadtxt(os.path.join(test_dir_path,'tseries12.txt')) freqs,cache = tsa.cache_fft(ts,ij) Cxy = tsa.cache_to_coherency(cache,ij) f,c = tsa.coherency(ts) npt.assert_almost_equal(Cxy[0][1],c[0,1]) # Check that it doesn't matter if you prefer_speed_over_memory: freqs,cache2 = tsa.cache_fft(ts,ij,prefer_speed_over_memory=True) Cxy2 = tsa.cache_to_coherency(cache2,ij) npt.assert_equal(Cxy2,Cxy) # XXX Calculating the angle of the averaged psd and calculating the average of the # angles calculated over different windows does not yield exactly the same # number, because the angle is not a linear functions (arctan), so it is # unclear how to test this, but we make sure that it runs, whether or not # you prefer_speed_over_memory: freqs,cache = tsa.cache_fft(ts,ij) tsa.cache_to_relative_phase(cache,ij) freqs,cache = tsa.cache_fft(ts,ij,prefer_speed_over_memory=True) tsa.cache_to_relative_phase(cache,ij) # Check that things run alright, even if there is just one window for the # entire ts: freqs,cache = tsa.cache_fft(ts,ij,method=dict(this_method='welch', NFFT=ts.shape[-1], n_overlap=0)) cxy_one_window = tsa.cache_to_coherency(cache,ij) ph_one_window = tsa.cache_to_relative_phase(cache,ij) # And whether or not you prefer_speed_over_memory freqs,cache = tsa.cache_fft(ts,ij,method=dict(this_method='welch', NFFT=ts.shape[-1], n_overlap=0), prefer_speed_over_memory=True) cxy_one_window = tsa.cache_to_coherency(cache,ij) ph_one_window = tsa.cache_to_relative_phase(cache,ij)
def coherency(self): #Pre-allocate the final result: if len(self.seed.shape) > 1: Cxy = np.empty((self.seed.data.shape[0], self.target.data.shape[0], self.frequencies.shape[0]), dtype=np.complex) else: Cxy = np.empty((self.target.data.shape[0], self.frequencies.shape[0]), dtype=np.complex) #Get the fft window cache for the target time-series: cache = self.target_cache #A list of indices for the target: target_chan_idx = np.arange(self.target.data.shape[0]) #This is a list of indices into the cached fft window libraries, #setting the index of the seed to be -1, so that it is easily #distinguished from the target indices: ij = list(zip(np.ones_like(target_chan_idx) * -1, target_chan_idx)) #If there is more than one channel in the seed time-series: if len(self.seed.shape) > 1: for seed_idx, this_seed in enumerate(self.seed.data): #Here ij is 0, because it is just one channel and we stack the #channel onto itself in order for the input to the function to #make sense: f, seed_cache = tsa.cache_fft( np.vstack([this_seed, this_seed]), [(0, 0)], lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) #Insert the seed_cache into the target_cache: cache['FFT_slices'][-1] = seed_cache['FFT_slices'][0] #If this is true, the cache contains both FFT_slices and #FFT_conj_slices: if self.prefer_speed_over_memory: cache['FFT_conj_slices'][-1] = \ seed_cache['FFT_conj_slices'][0] #This performs the caclulation for this seed: Cxy[seed_idx] = tsa.cache_to_coherency(cache, ij) #In the case where there is only one channel in the seed time-series: else: f, seed_cache = tsa.cache_fft( np.vstack([self.seed.data, self.seed.data]), [(0, 0)], lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) cache['FFT_slices'][-1] = seed_cache['FFT_slices'][0] if self.prefer_speed_over_memory: cache['FFT_conj_slices'][-1] = \ seed_cache['FFT_conj_slices'][0] Cxy = tsa.cache_to_coherency(cache, ij) return Cxy.squeeze()
def coherency(self): #Pre-allocate the final result: if len(self.seed.shape) > 1: Cxy = np.empty((self.seed.data.shape[0], self.target.data.shape[0], self.frequencies.shape[0]), dtype=np.complex) else: Cxy = np.empty( (self.target.data.shape[0], self.frequencies.shape[0]), dtype=np.complex) #Get the fft window cache for the target time-series: cache = self.target_cache #A list of indices for the target: target_chan_idx = np.arange(self.target.data.shape[0]) #This is a list of indices into the cached fft window libraries, #setting the index of the seed to be -1, so that it is easily #distinguished from the target indices: ij = list(zip(np.ones_like(target_chan_idx) * -1, target_chan_idx)) #If there is more than one channel in the seed time-series: if len(self.seed.shape) > 1: for seed_idx, this_seed in enumerate(self.seed.data): #Here ij is 0, because it is just one channel and we stack the #channel onto itself in order for the input to the function to #make sense: f, seed_cache = tsa.cache_fft( np.vstack([this_seed, this_seed]), [(0, 0)], lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) #Insert the seed_cache into the target_cache: cache['FFT_slices'][-1] = seed_cache['FFT_slices'][0] #If this is true, the cache contains both FFT_slices and #FFT_conj_slices: if self.prefer_speed_over_memory: cache['FFT_conj_slices'][-1] = \ seed_cache['FFT_conj_slices'][0] #This performs the caclulation for this seed: Cxy[seed_idx] = tsa.cache_to_coherency(cache, ij) #In the case where there is only one channel in the seed time-series: else: f, seed_cache = tsa.cache_fft( np.vstack([self.seed.data, self.seed.data]), [(0, 0)], lb=self.lb, ub=self.ub, method=self.method, prefer_speed_over_memory=self.prefer_speed_over_memory, scale_by_freq=self.scale_by_freq) cache['FFT_slices'][-1] = seed_cache['FFT_slices'][0] if self.prefer_speed_over_memory: cache['FFT_conj_slices'][-1] = \ seed_cache['FFT_conj_slices'][0] Cxy = tsa.cache_to_coherency(cache, ij) return Cxy.squeeze()
def coherency(self): f,cache = tsa.cache_fft(cache_fft) coherency = tsa.cache_to_coherency(cache,self.ij) return coherency