def test_plot_burst_detect_params(only_result):
"""Test plotting burst detection."""
# Simulate oscillating time series
n_seconds = 25
fs = 1000
freq = 10
f_range = (6, 14)
osc_kwargs = {
'amplitude_fraction_threshold': 0,
'amplitude_consistency_threshold': .5,
'period_consistency_threshold': .5,
'monotonicity_threshold': .8,
'n_cycles_min': 3
}
sig = sim_oscillation(n_seconds, fs, freq)
df = compute_features(sig, fs, f_range)
fig = plot_burst_detect_params(sig,
fs,
df,
osc_kwargs,
plot_only_result=only_result)
if not only_result:
for param in fig:
assert param is not None
else:
assert fig is not None
def tsig_sine_long():
yield sim_oscillation(N_SECONDS_LONG,
FS,
freq=FREQ_SINE,
variance=None,
mean=None)
def sim_args():
sig = sim_oscillation(N_SECONDS, FS, FREQ)
df_shapes = compute_shape_features(sig, FS, F_RANGE)
df_burst = compute_burst_features(df_shapes, sig)
df_features = compute_features(sig, FS, F_RANGE)
threshold_kwargs = {
'amp_fraction_threshold': 0.,
'amp_consistency_threshold': .5,
'period_consistency_threshold': .5,
'monotonicity_threshold': .5,
'min_n_cycles': 3
}
yield {
'sig': sig,
'fs': FS,
'f_range': F_RANGE,
'df_features': df_features,
'df_shapes': df_shapes,
'df_burst': df_burst,
'threshold_kwargs': threshold_kwargs
}
def sim_stationary():
sig = sim_oscillation(N_SECONDS,
FS,
FREQ,
phase=0.15,
cycle="asine",
rdsym=.3)
yield sig
def sim_args():
# Simulate oscillating time series
n_seconds = 10
fs = 500
freq = 10
f_range = (6, 14)
sig = sim_oscillation(n_seconds, fs, freq)
df = compute_features(sig, fs, f_range)
yield {'df': df, 'sig': sig, 'fs': fs}
# Simulate a Stationary Oscillation # --------------------------------- # # Let's start by simulating an oscillation. We'll start with a simple, sinusoidal, oscillation. # # Continuous peridic signals can be created with :func:`~neurodsp.sim.periodic.sim_oscillation`. # ################################################################################################### # Simulation settings n_seconds = 1 osc_freq = 6.6 # Simulate a sinusoidal oscillation osc_sine = sim.sim_oscillation(n_seconds, fs, osc_freq, cycle='sine') # Create a times vector for our simulation times = create_times(n_seconds, fs) # Plot the simulated data, in the time domain plot_time_series(times, osc_sine) ################################################################################################### # Cycle Kernels # ------------- # # To simulate oscillations, we can use a sinusoidal kernel, as above, or any of a # selection of other cycle kernels. # # Different kernels represent different shapes and properties that may be useful to
# in phase, they will line up exactly (have a high correlation), while at others, when they # are out of phase, they will have either low or anti-correlation. # ################################################################################################### # Simulation settings n_seconds = 10 fs = 1000 # Define the frequencies for the sinusoids freq1 = 10 freq2 = 20 # Simulate sinusoids sig_osc1 = sim_oscillation(n_seconds, fs, freq1) sig_osc2 = sim_oscillation(n_seconds, fs, freq2) ################################################################################################### # Compute autocorrelation on the periodic time series timepoints_osc1, autocorrs_osc1 = compute_autocorr(sig_osc1) timepoints_osc2, autocorrs_osc2 = compute_autocorr(sig_osc2) ################################################################################################### # Autocorrelation of a sinusoidal signal # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # The autocorrelation of the first sine wave is plotted below. #
# time it
start = time.time()
# simulate oscillation
# get random oscillation between frequency ranges
# osc_freq_rand = random.randint(osc_freq[0], osc_freq[1])
osc_freq_rand = random.choice(freq_list)
# if sinusiod
asine_or_sine = random.choice(lf_waveform)
if asine_or_sine == 'sine':
signal = sim.sim_oscillation(n_seconds,
fs,
osc_freq_rand,
cycle='sine')
simulation_features['asine_rdsym'][aa] = .5
elif asine_or_sine == 'asine':
asine_rdsym = random.choice(lf_rdsym)
signal = sim.sim_oscillation(n_seconds,
fs,
osc_freq_rand,
cycle='asine',
rdsym=asine_rdsym)
simulation_features['asine_rdsym'][aa] = asine_rdsym
# rhythmic activity. # ################################################################################################### # Sinusoidal Signals # ~~~~~~~~~~~~~~~~~~ # # There are many different rhythmic signals we could simulate, in terms of different # rhythmic shapes, and or temporal properties (such as rhythmic bursts). For this # example, we will stick to simulating continuous sinusoidal signals. # ################################################################################################### # Generate an oscillating signal osc_sig = sim.sim_oscillation(n_seconds, s_rate, freq=10) ################################################################################################### # Plot the oscillating time series plot_time_series(times, osc_sig) ################################################################################################### # Compute the power spectrum of the oscillating signal freqs, powers = compute_spectrum_welch(osc_sig, s_rate) ################################################################################################### # Visualize the power spectrum of the oscillating signal plot_power_spectra(freqs, powers)
import matplotlib.pyplot as plt
from neurodsp.sim import sim_oscillation, sim_bursty_oscillation
from neurodsp.utils import set_random_seed
from neurodsp.utils import create_times
from neurodsp.plts.time_series import plot_time_series
time = 1.5
sampling_rate = 100
oscillation_freq = 1
set_random_seed(0)
oscillation_sine = sim_oscillation(time,
sampling_rate,
oscillation_freq,
cycle='sine')
timeSequenceMatrix = create_times(time, sampling_rate)
print("TIME : " + str(len(timeSequenceMatrix)))
print(timeSequenceMatrix)
print("OSCILACION : " + str(len(oscillation_sine)))
print(oscillation_sine)
plt.scatter(timeSequenceMatrix, oscillation_sine)
plt.show()
plot_time_series(timeSequenceMatrix, oscillation_sine)
################################################################################################### # # Simulate a stationary oscillator # -------------------------------- # # In addition to noise, you may also want to simulate an oscillatory process. # We can do that with neurodsp, with arbitrary rise-decay symmetry. # ################################################################################################### # Simulate symmetric oscillator n_seconds = 1 fs = 1000 osc_freq = 6.6 osc_a = sim.sim_oscillation(n_seconds, fs, osc_freq, cycle='asine', rdsym=.5) osc_b = sim.sim_oscillation(n_seconds, fs, osc_freq, cycle='asine', rdsym=.2) # HACK: REMOVE WHEN SIM UPDATED osc_a = osc_a[0:n_seconds*fs] osc_b = osc_b[0:n_seconds*fs] times = create_times(n_seconds, fs) ################################################################################################### # Plot the simulated data, in the time domain plot_time_series(times, [osc_a, osc_b], ['rdsym='+str(.5), 'rdsym='+str(.3)]) ###################################################################################################
fs = 200. # Hz
n_points = int(n_seconds * fs)
f_beta = (14, 28)
high_fq = 80.0 # Hz; carrier frequency
low_fq = 24.0 # Hz; driver frequency
low_fq_width = 2.0 # Hz
noise_level = 0.25
# Simulate beta-gamma pac
sig_pac = simulate_pac(n_points=n_points, fs=fs, high_fq=high_fq, low_fq=low_fq,
low_fq_width=low_fq_width, noise_level=noise_level)
# Simulate 10 Hz spiking which couples to about 60 Hz
spikes = sim_oscillation(n_seconds, fs, 10, cycle='gaussian', std=0.005)
noise = normalize_variance(pink_noise(n_points, slope=1.), variance=.5)
sig_spurious_pac = spikes + noise
# Simulate a sine wave that is the driver frequency
sig_low_fq = sim_oscillation(n_seconds, fs, low_fq)
# Add the sine wave to pink noise to make a control, no pac signal
sig_no_pac = sig_low_fq + noise
####################################################################################################
# Check comodulogram for PAC
# ~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# Now, we will use the tools from pactools to compute the comodulogram which
# is a visualization of phase amplitude coupling. The stronger the driver
