def test_compute_fluctuations_dfa():
# Note: these tests need a high sampling rate, so we use local simulations
# Test white noise: expected DFA of 0.5
fs = 1000
white = sim_powerlaw(N_SECONDS, fs, exponent=0)
t_scales, flucs, exp = compute_fluctuations(white, fs, method='dfa')
assert np.isclose(exp, 0.5, atol=0.1)
# Test brown noise: expected DFA of 1.5
brown = sim_powerlaw(N_SECONDS, fs, exponent=-2)
t_scales, flucs, exp = compute_fluctuations(brown, fs, method='dfa')
assert np.isclose(exp, 1.5, atol=0.1)
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
# # Neural signals display 1/f-like activity, whereby power decreases linearly across # increasing frequencies, when plotted in log-log. # # Let's start with a powerlaw signal, specifically a brown noise process, or a signal # for which the power spectrum is distributed as 1/f^2. # ################################################################################################### # Setting for the simulation exponent = -2 # Simulate powerlaw activity, specifically brown noise times = create_times(n_seconds, fs) br_noise = sim.sim_powerlaw(n_seconds, fs, exponent) ################################################################################################### # Plot the simulated data, in the time domain plot_time_series(times, br_noise) ################################################################################################### # Plot the simulated data, in the frequency domain freqs, psd = spectral.compute_spectrum(br_noise, fs) plot_power_spectra(freqs, psd) ################################################################################################### # # Simulate Filtered 1/f Activity
###################################################################################################
# Set time and sampling rate
n_seconds_burst = 1
n_seconds_noise = 2
fs = 1000
# Create a times vector
times = create_times(n_seconds_burst + n_seconds_noise, fs)
# Simulate a signal component with an oscillation
components = {'sim_powerlaw': {'exponent': 0}, 'sim_oscillation': {'freq': 10}}
s1 = sim_combined(n_seconds_burst, fs, components, [0.1, 1])
# Simulate a signal component with just noise
s2 = sim_powerlaw(n_seconds_noise, fs, 0, variance=0.1)
# Join signals together to approximate a 'burst'
sig = np.append(s1, s2)
###################################################################################################
# Plot example signal
plot_time_series(times, sig)
###################################################################################################
# Compute lagged coherence for an alpha oscillation
# -------------------------------------------------
#
# We can compute lagged coherence with the :func:`~.compute_lagged_coherence` function.
#
# ################################################################################################### # Autocorrelation of Aperiodic Signals # ------------------------------------ # # Next, lets consider the autocorrelation of aperiodic signals. # # Here we will use white noise, as an example of a signal without autocorrelation, and # pink noise, which does, by definition, have temporal auto-correlations. # ################################################################################################### # Simulate a white noise signal sig_wn = sim_powerlaw(n_seconds, fs, exponent=0) # Simulate a pink noise signal sig_pn = sim_powerlaw(n_seconds, fs, exponent=-1) ################################################################################################### # Compute autocorrelation on the aperiodic time series timepoints_wn, autocorrs_wn = compute_autocorr(sig_wn) timepoints_pn, autocorrs_pn = compute_autocorr(sig_pn) ################################################################################################### # Plot the autocorrelations of the aperiodic signals _, ax = plt.subplots(figsize=(5, 4)) ax.plot(timepoints_wn, autocorrs_wn, label='White Noise')
osc_freq_rand,
cycle='asine',
rdsym=asine_rdsym)
simulation_features['asine_rdsym'][aa] = asine_rdsym
# roll signal to have different phase every simulation
signal = np.roll(signal, random.randint(0, signal_length))
# get random exponential
exp_rand = random.uniform(exp[0], exp[1])
# simulate 50x brown noise on top to get reliable slope
n_brown_noise = 50
for br in range(n_brown_noise):
br_noise = sim.sim_powerlaw(n_seconds, fs, exp_rand)
signal = signal + br_noise
try:
# run FOOOF
# compute frequency spectrum
freq_mean, psd_mean = spectral.compute_spectrum(signal,
fs,
method='welch',
avg_type='mean',
nperseg=fs * 2)
# Initialize FOOOF model
fm = FOOOF(peak_width_limits=bw_lims,
background_mode='fixed',
###################################################################################################
# Simulate a signal component with an oscillation
components = {
'sim_oscillation': {
'freq': freq
},
'sim_powerlaw': {
'exponent': exp,
'f_range': (1, None)
}
}
s1 = sim_combined(t_osc, fs, components, [1, 0.5])
# Simulate a signal component with only aperiodic activity
s2 = sim_powerlaw(t_ap, fs, exp, variance=0.5)
# Join signals together to approximate a 'burst'
sig = np.append(s1, s2)
###################################################################################################
# Plot example signal
plot_time_series(times, sig)
###################################################################################################
# Compute lagged coherence on simulated data
# ------------------------------------------
#
# We can compute lagged coherence with the :func:`~.compute_lagged_coherence` function.
#
# ################################################################################################### # Simulation settings s_rate = 1000 n_seconds = 4 times = create_times(n_seconds, s_rate) # Set random seed, for consistency generating simulated data set_random_seed(21) ################################################################################################### # Simulate a signal of aperiodic activity: pink noise sig = sim_powerlaw(n_seconds, s_rate, exponent=-1) ################################################################################################### # Plot our simulated time series plot_time_series(times, sig) ################################################################################################### # Filtering Aperiodic Signals # ~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # Now that we have a simulated signal, let's filter it into each of our frequency bands. # # To do so, we will loop across our band definitions, and plot the filtered version # of the signal. #
################################################################################################### # Pink Noise # ^^^^^^^^^^ # # Other 'colors' of noise refer to different patterns of power distributions # in the power spectrum. # # For example, pink noise is a signal where power systematically decreases across # frequencies in the power spectrum. # ################################################################################################### # Generate a pink noise signal pink_sig = sim.sim_powerlaw(n_seconds, s_rate, exponent=-1) ################################################################################################### # Plot the pink noise time series plot_time_series(times, pink_sig) ################################################################################################### # Compute the power spectrum of the pink noise signal freqs, powers = compute_spectrum_welch(pink_sig, s_rate) ################################################################################################### # Visualize the power spectrum of the pink noise signal plot_power_spectra(freqs, powers)
def tsig_brown():
yield sim_powerlaw(N_SECONDS_LONG, FS_HIGH, exponent=-2)
def tsig_white():
yield sim_powerlaw(N_SECONDS_LONG, FS_HIGH, exponent=0)
