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

rectify stimulus in simulate fast, add marker calculation

Browse Source
This commit is contained in:
a.ott 2020-02-18 16:29:09 +01:00
parent 04ba55bbc5
commit 251ca4f2ef
1 changed files with 38 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
models/LIFACnoise.py
View File

@ -4,7 +4,9 @@ from models.AbstractModel import AbstractModel
import numpy as np import numpy as np
import functions as fu import functions as fu
from numba import jit from numba import jit
import time import helperFunctions as hF
from stimuli.SinusAmplitudeModulation import SinusAmplitudeModulationStimulus
from scipy.optimize import curve_fit
class LifacNoiseModel(AbstractModel): class LifacNoiseModel(AbstractModel):
@ -64,7 +66,7 @@ class LifacNoiseModel(AbstractModel):
return output_voltage, spiketimes return output_voltage, spiketimes
def simulate_fast(self, stimulus: AbstractStimulus, total_time_s): def simulate_fast(self, stimulus: AbstractStimulus, total_time_s, time_start=0):
v_zero = self.parameters["v_zero"] v_zero = self.parameters["v_zero"]
a_zero = self.parameters["a_zero"] a_zero = self.parameters["a_zero"]
@ -77,10 +79,12 @@ class LifacNoiseModel(AbstractModel):
mem_tau = self.parameters["mem_tau"] mem_tau = self.parameters["mem_tau"]
noise_strength = self.parameters["noise_strength"] noise_strength = self.parameters["noise_strength"]
stimulus_array = stimulus.as_array(total_time_s, step_size) stimulus_array = stimulus.as_array(time_start, total_time_s, step_size)
rectified_stimulus = rectify_stimulus_array(stimulus_array)
parameters = np.array([v_zero, a_zero, step_size, threshold, v_base, delta_a, tau_a, v_offset, mem_tau, noise_strength]) parameters = np.array([v_zero, a_zero, step_size, threshold, v_base, delta_a, tau_a, v_offset, mem_tau, noise_strength])
voltage_trace, adaption, spiketimes = simulate_fast(stimulus_array, total_time_s, parameters)
voltage_trace, adaption, spiketimes = simulate_fast(rectified_stimulus, total_time_s, parameters)
self.stimulus = stimulus self.stimulus = stimulus
self.voltage_trace = voltage_trace self.voltage_trace = voltage_trace
@ -146,35 +150,53 @@ 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=750): def calculate_baseline_markers(self, base_stimulus_freq, max_lag=1):
""" """
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
:return: baseline_freq, vs, sc :return: baseline_freq, vs, sc
""" """
base_stimulus = SinusAmplitudeModulationStimulus(base_stimulus_freq, 0, 0)
_, spiketimes = self.simulate_fast(base_stimulus, 30)
baseline_freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, 5)
relative_spiketimes = np.array([s % (1 / base_stimulus_freq) for s in spiketimes])
eod_durations = np.full((len(spiketimes)), 1 / base_stimulus_freq)
vector_strength = hF.__vector_strength__(relative_spiketimes, eod_durations)
serial_correlation = hF.calculate_serial_correlation(np.array(spiketimes), max_lag)
return baseline_freq, vector_strength, serial_correlation
pass def calculate_fi_markers(self, contrasts, base_freq, modulation_frequency):
def calculate_fi_markers(self, contrasts, ):
""" """
calculates the fi markers f_infinity, f_infinity_slope for given contrasts calculates the fi markers f_infinity, f_infinity_slope for given contrasts
based on simulated 2 seconds for each contrast based on simulated 2 seconds for each contrast
:return: :return: f_inf_values_list, f_inf_slope
""" """
f_infinities = []
for contrast in contrasts:
stimulus = SinusAmplitudeModulationStimulus(base_freq, contrast, modulation_frequency)
_, spiketimes = self.simulate_fast(stimulus, 0.5)
if len(spiketimes) < 2:
f_infinities.append(0)
else:
f_infinity = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, 0.4)
f_infinities.append(f_infinity)
popt, pcov = curve_fit(fu.line, contrasts, f_infinities, maxfev=10000)
def stimulus_to_numpy_array(stimulus: AbstractStimulus, total_time_s, step_size): f_infinities_slope = popt[0]
total_time_points = int(total_time_s * 1000 / step_size)
stimulus_values = np.zeros(total_time_points)
for idx in range(len(stimulus_values)):
# rectified input:
stimulus_values[idx] = fu.rectify(stimulus.value_at_time_in_ms(step_size*idx))
return stimulus_values return f_infinities, f_infinities_slope
@jit(nopython=True)
def rectify_stimulus_array(stimulus_array:np.ndarray):
return np.array([x if x > 0 else 0 for x in stimulus_array])
@jit(nopython=True) @jit(nopython=True)