def test_sim_knee(): # Build the signal and run a smoke test sig = sim_knee(N_SECONDS, FS, EXP1, EXP2, KNEE) check_sim_output(sig) # Check against the power spectrum when you take the Fourier transform sig_len = int(FS * N_SECONDS) freqs = np.linspace(0, FS / 2, num=sig_len // 2, endpoint=True) # Ignore the DC component to avoid division by zero in the Lorentzian freqs = freqs[1:] true_psd = np.array( [1 / (freq**-EXP1 * (freq**(-EXP2 - EXP1) + KNEE)) for freq in freqs]) # Only look at the frequencies (ignoring DC component) up to the nyquist rate sig_hat = np.fft.fft(sig)[1:sig_len // 2] numerical_psd = np.abs(sig_hat)**2 np.allclose(true_psd, numerical_psd, atol=EPS) # Accuracy test for a single exponent sig = sim_knee(n_seconds=N_SECONDS, fs=FS, chi1=0, chi2=EXP2, knee=KNEE) freqs, powers = compute_spectrum(sig, FS, f_range=(1, 200)) def _estimate_single_knee(xs, offset, knee, exponent): return np.zeros_like(xs) + offset - np.log10(xs**exponent + knee) ap_params, _ = curve_fit(_estimate_single_knee, freqs, np.log10(powers)) _, _, EXP2_hat = ap_params[:] assert -round(EXP2_hat) == EXP2
def test_make_bursts(): is_osc = np.array([False, False, True, True, False, True, False, True, True, False]) cycle = np.ones([10]) sig = make_bursts(N_SECONDS, FS, is_osc, cycle) check_sim_output(sig)
def test_sim_combined(): simulations = { 'sim_oscillation': { 'freq': FREQ1 }, 'sim_powerlaw': { 'exponent': -2 } } out = sim_combined(N_SECONDS, FS, simulations) check_sim_output(out) # Test case with multiple uses of same function simulations = { 'sim_oscillation': [{ 'freq': FREQ1 }, { 'freq': FREQ2 }], 'sim_powerlaw': { 'exponent': -2 } } variances = [0.5, 0.5, 1] out = sim_combined(N_SECONDS, FS, simulations, variances) check_sim_output(out) # Check the variance mismatch error variances = [0.5, 1] with raises(ValueError): out = sim_combined(N_SECONDS, FS, simulations, variances)
def test_sim_synaptic_kernel(): # Check that valid parameter configurations do not return negative values for params in [[0., 0.02], [0.005, 0.02], [0.02, 0.02]]: tau_r, tau_d = params kernel = sim_synaptic_kernel(N_SECONDS, FS, tau_r, tau_d) check_sim_output(kernel) assert np.all(kernel >= 0.)
def test_sim_powerlaw(): sig = sim_powerlaw(N_SECONDS, FS) check_sim_output(sig) # Test with a filter applied sig = sim_powerlaw(N_SECONDS, FS, f_range=(2, None)) check_sim_output(sig)
def test_sim_peak_oscillation(): sig_ap = sim_powerlaw(N_SECONDS, FS) sig = sim_peak_oscillation(sig_ap, FS, FREQ1, bw=5, height=10) check_sim_output(sig) # Ensure the peak is at or close (+/- 5hz) to FREQ1 _, powers_ap = compute_spectrum(sig_ap, FS) _, powers = compute_spectrum(sig, FS) assert abs(np.argmax(powers - powers_ap) - FREQ1) < 5
def test_sim_frac_brownian_motion(chi): # Simulate & check time series sig = sim_frac_brownian_motion(N_SECONDS, FS, chi=chi) check_sim_output(sig) # Linear fit the log-log power spectrum & check error based on expected 1/f exponent freqs = np.linspace(1, FS // 2, num=FS // 2) powers = np.abs(np.fft.fft(sig)[1:FS // 2 + 1])**2 [_, chi_hat], _ = curve_fit(check_exponent, np.log10(freqs), np.log10(powers)) assert abs(chi_hat - chi) < 0.4
def test_phase_shift_cycle(): cycle = sim_cycle(N_SECONDS, FS, 'sine') # Check cycle does not change if not rotated cycle_noshift = phase_shift_cycle(cycle, 0.) check_sim_output(cycle_noshift) assert np.array_equal(cycle, cycle_noshift) # Check cycle does change if rotated cycle_shifted = phase_shift_cycle(cycle, 0.25) check_sim_output(cycle_shifted) assert not np.array_equal(cycle, cycle_shifted)
def test_make_bursts(): is_osc = np.array( [False, False, True, True, False, True, False, True, True, False]) cycle = np.ones([10]) sig = make_bursts(N_SECONDS, FS, is_osc, cycle) check_sim_output(sig) # Test make bursts with uneven division of signal and cycle divisions # In this test, there aren't enough samples in the signal to add last cycle is_osc = np.array([False, True, True]) cycle = np.ones([7]) sig = make_bursts(2, 10, is_osc, cycle) assert sum(sig) > 0
def test_sim_oscillation(): sig = sim_oscillation(N_SECONDS, FS, FREQ1) check_sim_output(sig) # Check some different frequencies, that they get expected length, etc for freq in [3.5, 7.0, 13.]: check_sim_output(sim_oscillation(N_SECONDS, FS, freq)) # Check that nothing goes weird with different time & sampling rate inputs check_sim_output(sim_oscillation(N_SECONDS_ODD, FS, FREQ1), n_seconds=N_SECONDS_ODD) check_sim_output(sim_oscillation(N_SECONDS, FS_ODD, FREQ1), fs=FS_ODD)
def test_sim_action_potential(): stds = (.25, .2) alphas = (8, .2) centers = (.25, .5) heights = (15, 2.5) cycle = sim_action_potential(N_SECONDS, FS, centers, stds, alphas, heights) check_sim_output(cycle, n_seconds=N_SECONDS) cycle = sim_action_potential(N_SECONDS_ODD, FS, centers, stds, alphas, heights) check_sim_output(cycle, n_seconds=N_SECONDS_ODD) cycle = sim_action_potential(N_SECONDS, FS_ODD, centers, stds, alphas, heights) check_sim_output(cycle, n_seconds=N_SECONDS, fs=FS_ODD) cycle = sim_action_potential(N_SECONDS, FS, centers, stds, alphas, heights) check_sim_output(cycle, n_seconds=N_SECONDS)
def test_sim_damped_oscillation(): sig1 = sim_damped_oscillation(N_SECONDS, FS, FREQ1, .1) sig2 = sim_damped_oscillation(N_SECONDS, FS, FREQ1, 50) sig3 = sim_damped_oscillation(N_SECONDS, FS, FREQ1, 25, 0.1) check_sim_output(sig1) check_sim_output(sig2) check_sim_output(sig3) # Large gammas range between (0, 1), whereas small gammas range between (-1, 1) assert sig1.sum() < sig2.sum() assert len(sig1) == len(sig2)
def test_sim_bursty_oscillation(): # Check default values work sig1 = sim_bursty_oscillation(N_SECONDS, FS, FREQ1) check_sim_output(sig1) # Check probability burst approach sig2 = sim_bursty_oscillation(N_SECONDS, FS, FREQ1, \ burst_def='prob', burst_params={'enter_burst' : 0.3, 'leave_burst' : 0.3}) check_sim_output(sig2) # Check durations burst approach sig3 = sim_bursty_oscillation(N_SECONDS, FS, FREQ1, \ burst_def='durations', burst_params={'n_cycles_burst' : 2, 'n_cycles_off' : 2}) check_sim_output(sig3)
def test_create_powerlaw(): sig = _create_powerlaw(int(N_SECONDS * FS), FS, -2) check_sim_output(sig)
def test_create_cycle_time(): times = create_cycle_time(N_SECONDS, FS) check_sim_output(times)
def test_sim_gaussian_cycle(): cycle = sim_gaussian_cycle(N_SECONDS, FS, 2) check_sim_output(cycle)
def test_sim_sawtooth_cycle(): cycle = sim_sawtooth_cycle(N_SECONDS, FS, 0.5) check_sim_output(cycle)
def test_sim_asine_cycle(): cycle = sim_asine_cycle(N_SECONDS, FS, 0.25) check_sim_output(cycle)
def test_sim_normalized_cycle(): cycle = sim_normalized_cycle(N_SECONDS, FS, 'sine') check_sim_output(cycle)
def test_sim_cycle(): cycle = sim_cycle(N_SECONDS, FS, 'sine') check_sim_output(cycle) cycle = sim_cycle(N_SECONDS, FS, 'asine', rdsym=0.75) check_sim_output(cycle) cycle = sim_cycle(N_SECONDS, FS, 'sawtooth', width=0.5) check_sim_output(cycle) cycle = sim_cycle(N_SECONDS, FS, 'gaussian', std=2) check_sim_output(cycle) cycle = sim_cycle(N_SECONDS, FS, 'exp', tau_d=0.2) check_sim_output(cycle) cycle = sim_cycle(N_SECONDS, FS, '2exp', tau_r=0.2, tau_d=0.2) check_sim_output(cycle) with raises(ValueError): sim_cycle(N_SECONDS, FS, 'not_a_cycle')
def test_sim_oscillation(): sig = sim_oscillation(N_SECONDS, FS, FREQ1) check_sim_output(sig)
def test_sim_poisson_pop(): sig = sim_poisson_pop(N_SECONDS, FS) check_sim_output(sig)
def test_sim_synaptic_current(): sig = sim_synaptic_current(N_SECONDS, FS) check_sim_output(sig)
def test_sim_random_walk(): sig = sim_random_walk(N_SECONDS, FS) check_sim_output(sig)