Alexander/P-unit_model
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

use same type of calculations for characteristics as in the data

Browse Source
This commit is contained in:
AlexanderOtt 2020-04-02 10:07:17 +02:00
parent b4d5cc2714
commit af40a60189
1 changed files with 29 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
models/LIFACnoise.py
View File

@ -8,7 +8,7 @@ import helperFunctions as hF
from stimuli.SinusoidalStepStimulus import SinusoidalStepStimulus from stimuli.SinusoidalStepStimulus import SinusoidalStepStimulus
from scipy.optimize import curve_fit from scipy.optimize import curve_fit
from warnings import warn from warnings import warn
import matplotlib.pyplot as plt
class LifacNoiseModel(AbstractModel): class LifacNoiseModel(AbstractModel):
# all times in milliseconds # all times in milliseconds
@ -157,7 +157,7 @@ class LifacNoiseModel(AbstractModel):
def get_model_copy(self): def get_model_copy(self):
return LifacNoiseModel(self.parameters) return LifacNoiseModel(self.parameters)
def calculate_baseline_markers(self, stimulus_freq, max_lag=1): def calculate_baseline_markers(self, stimulus_freq, max_lag=1, simulation_time=30):
""" """
calculates the baseline markers baseline frequency, vector strength and serial correlation calculates the baseline markers baseline frequency, vector strength and serial correlation
based on simulated 30 seconds with a standard Sinusoidal stimulus with the given frequency based on simulated 30 seconds with a standard Sinusoidal stimulus with the given frequency
@ -165,7 +165,7 @@ class LifacNoiseModel(AbstractModel):
:return: baseline_freq, vs, sc :return: baseline_freq, vs, sc
""" """
base_stimulus = SinusoidalStepStimulus(stimulus_freq, 0) base_stimulus = SinusoidalStepStimulus(stimulus_freq, 0)
_, spiketimes = self.simulate_fast(base_stimulus, 30) _, spiketimes = self.simulate_fast(base_stimulus, simulation_time)
time_x = 5 time_x = 5
baseline_freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, time_x) baseline_freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, time_x)
@ -187,24 +187,31 @@ class LifacNoiseModel(AbstractModel):
based on simulated 2 seconds for each contrast based on simulated 2 seconds for each contrast
:return: f_inf_values_list, f_inf_slope :return: f_inf_values_list, f_inf_slope
""" """
stimulus_start = 0.3
stimulus_duration = 1
f_infinities = [] f_infinities = []
for contrast in contrasts: for contrast in contrasts:
stimulus = SinusoidalStepStimulus(stimulus_freq, contrast) stimulus = SinusoidalStepStimulus(stimulus_freq, contrast, stimulus_start, stimulus_duration)
_, spiketimes = self.simulate_fast(stimulus, 1) _, spiketimes = self.simulate_fast(stimulus, stimulus_start*2+stimulus_duration)
time, freq = hF.calculate_time_and_frequency_trace(spiketimes, self.get_sampling_interval())
f_infinity = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, 0.3) f_inf = hF.detect_f_infinity_in_freq_trace(time, freq, stimulus_start, stimulus_duration, self.get_sampling_interval())
f_infinities.append(f_infinity) f_infinities.append(f_inf)
popt, pcov = curve_fit(fu.line, contrasts, f_infinities, maxfev=10000) popt = hF.fit_clipped_line(contrasts, f_infinities)
f_infinities_slope = popt[0] f_infinities_slope = popt[0]
return f_infinities, f_infinities_slope return f_infinities, f_infinities_slope
def calculate_fi_curve(self, contrasts, stimulus_freq): def calculate_fi_curve(self, contrasts, stimulus_freq):
stim_duration = 1
stim_start = 1 max_time_constant = max([self.parameters["tau_a"], self.parameters["mem_tau"]])
factor_to_equilibrium = 5
stim_duration = max_time_constant * factor_to_equilibrium
stim_start = max_time_constant * factor_to_equilibrium
total_simulation_time = max_time_constant * factor_to_equilibrium * 3
# print("Total simulation time (vs 2.5) {:.2f}".format(total_simulation_time))
sampling_interval = self.get_sampling_interval() sampling_interval = self.get_sampling_interval()
f_infinities = [] f_infinities = []
f_zeros = [] f_zeros = []
@ -212,10 +219,12 @@ class LifacNoiseModel(AbstractModel):
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
for c in contrasts: for c in contrasts:
stimulus = SinusoidalStepStimulus(stimulus_freq, c, stim_start, stim_duration) stimulus = SinusoidalStepStimulus(stimulus_freq, c, stim_start, stim_duration)
_, spiketimes = self.simulate_fast(stimulus, 3.5) _, spiketimes = self.simulate_fast(stimulus, total_simulation_time)
time, frequency = hF.calculate_time_and_frequency_trace(spiketimes, sampling_interval) time, frequency = hF.calculate_time_and_frequency_trace(spiketimes, sampling_interval)
# if c == contrasts[0] or c == contrasts[-1]:
# plt.plot(frequency)
# plt.show()
f_inf = hF.detect_f_infinity_in_freq_trace(time, frequency, stim_start, stim_duration, sampling_interval) f_inf = hF.detect_f_infinity_in_freq_trace(time, frequency, stim_start, stim_duration, sampling_interval)
f_infinities.append(f_inf) f_infinities.append(f_inf)
@ -290,10 +299,13 @@ def binary_search_base_freq(model: LifacNoiseModel, base_stimulus, goal_frequenc
def test_v_offset(model: LifacNoiseModel, v_offset, base_stimulus, simulation_length): def test_v_offset(model: LifacNoiseModel, v_offset, base_stimulus, simulation_length):
model.set_variable("v_offset", v_offset) model.set_variable("v_offset", v_offset)
try:
v, spiketimes = model.simulate_fast(base_stimulus, simulation_length) v, spiketimes = model.simulate_fast(base_stimulus, simulation_length)
freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, simulation_length / 3) freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, simulation_length / 3)
except ZeroDivisionError:
print("divide by zero!")
freq = 0
# if freq > 10000: # if freq > 10000:
# from IPython import embed # from IPython import embed
# import matplotlib.pyplot as plt # import matplotlib.pyplot as plt