many changes

models/AbstractModel.py

@@ -27,12 +27,13 @@ class AbstractModel:
     def simulates_spiketimes(self) -> bool:
         raise NotImplementedError("NOT IMPLEMENTED")
 
-    def simulate(self, stimulus: AbstractStimulus, total_time_s):
+    def simulate(self, stimulus: AbstractStimulus, total_time_s, time_start=0):
         """
         Simulate the given stimulus in the model
         and simulate up to the given total time
         and saves the simulated data in the model.
 
+        :param time_start: when the simulation should start
         :param stimulus: given stimulus
         :param total_time_s: time to simulate
         :return: depending on availability: [voltage, spiketimes, frequency]

models/LIFACnoise.py

@@ -40,7 +40,7 @@ class LifacNoiseModel(AbstractModel):
         self.stimulus = None
         # self.frequency_trace = []
 
-    def simulate(self, stimulus: AbstractStimulus, total_time_s):
+    def simulate_slow(self, stimulus: AbstractStimulus, total_time_s):
 
         self.stimulus = stimulus
         time = np.arange(0, total_time_s, self.parameters["step_size"])
@@ -108,7 +108,7 @@ class LifacNoiseModel(AbstractModel):
                     (-current_i + rectified_input * self.parameters["input_scaling"]) / self.parameters["dend_tau"]) * \
                self.parameters["step_size"]
 
-    def simulate_fast(self, stimulus: AbstractStimulus, total_time_s, time_start=0):
+    def simulate(self, stimulus: AbstractStimulus, total_time_s, time_start=0):
 
         v_zero = self.parameters["v_zero"]
         a_zero = self.parameters["a_zero"]
@@ -234,7 +234,7 @@ def binary_search_base_freq(model: LifacNoiseModel, base_stimulus, goal_frequenc
 def test_v_offset(model: LifacNoiseModel, v_offset, base_stimulus, simulation_length):
     model.set_variable("v_offset", v_offset)
     try:
-        v, spiketimes = model.simulate_fast(base_stimulus, simulation_length)
+        v, spiketimes = model.simulate(base_stimulus, simulation_length)
 
         freq = hF.mean_freq_of_spiketimes_after_time_x(spiketimes, simulation_length / 3)
     except ZeroDivisionError:

models/smallModels.py

@@ -0,0 +1,149 @@
+
+import numpy as np
+import matplotlib.pyplot as plt
+import helperFunctions as hF
+
+
+def main():
+    pass
+
+
+def pif_simulation(stimulus, step_size):
+
+    v_0 = 0
+    v_base = 0
+    threshold = 1
+    v_offset = 0.15
+    mem_tau = 0.015
+
+    v_1 = np.zeros(len(stimulus))
+    v_1[0] = v_0
+    spikes = []
+
+    for i in range(1, len(v_1), 1):
+        # dvdt =  (v_offset + stimulus[i]) / mem_tau
+        v_1[i] = v_1[i - 1] + ((v_offset + stimulus[i]) / mem_tau) * step_size
+
+        if v_1[i] > threshold:
+            v_1[i] = v_base
+            spikes.append(i*step_size)
+
+    return v_1, spikes
+
+
+def lif_simulation(stimulus, step_size):
+    v_0 = 0
+    v_base = 0
+    threshold = 1
+    v_offset = 1.0013
+    mem_tau = 0.015
+
+    v_1 = np.zeros(len(stimulus))
+    v_1[0] = v_0
+    spikes = []
+
+    for i in range(1, len(v_1), 1):
+        v_1[i] = v_1[i - 1] + ((v_offset - v_1[i-1] + stimulus[i]) / mem_tau) * step_size
+
+        if v_1[i] > threshold:
+            v_1[i] = v_base
+            spikes.append(i * step_size)
+
+    return v_1, spikes
+
+
+def lifac_simulation(stimulus, step_size):
+    v_0 = 0
+    v_base = 0
+    threshold = 1
+    v_offset = 1.35
+    mem_tau = 0.015
+    adaption_tau = 0.1
+    adaption_step = 0.05
+
+    adaption = np.zeros(len(stimulus))
+    adaption[0] = 0.5
+    v_1 = np.zeros(len(stimulus))
+    v_1[0] = v_0
+    spikes = []
+
+    for i in range(1, len(v_1), 1):
+        v_1[i] = v_1[i - 1] + ((v_offset - v_1[i-1] - adaption[i-1] + stimulus[i]) / mem_tau) * step_size
+        adaption[i] = adaption[i-1] + (-adaption[i-1] / adaption_tau) * step_size
+        if v_1[i] > threshold:
+            v_1[i] = v_base
+            spikes.append(i * step_size)
+            adaption[i] += adaption_step / adaption_tau
+
+    return v_1, spikes
+
+
+def lifac_ref_simulation(stimulus, step_size):
+    v_0 = 0
+    v_base = 0
+    threshold = 1
+    v_offset = 1.35
+    mem_tau = 0.015
+    adaption_tau = 0.1
+    adaption_step = 0.05
+    ref_time = 0.005
+    adaption = np.zeros(len(stimulus))
+    adaption[0] = 0.5
+    v_1 = np.zeros(len(stimulus))
+    v_1[0] = v_0
+    spikes = []
+
+    for i in range(1, len(v_1), 1):
+        if len(spikes) > 0 and i*step_size < spikes[-1] + ref_time:
+            v_1[i] = v_base
+        else:
+            v_1[i] = v_1[i - 1] + ((v_offset - v_1[i-1] - adaption[i-1] + stimulus[i]) / mem_tau) * step_size
+
+        adaption[i] = adaption[i-1] + (-adaption[i-1] / adaption_tau) * step_size
+        if v_1[i] > threshold:
+            v_1[i] = v_base
+            spikes.append(i * step_size)
+            adaption[i] += adaption_step / adaption_tau
+
+    return v_1, spikes
+
+
+def lifac_ref_noise_simulation(stimulus, step_size):
+    v_0 = 0
+    v_base = 0
+    threshold = 1
+    v_offset = 1.32
+    mem_tau = 0.015
+    adaption_tau = 0.1
+    adaption_step = 0.05
+    ref_time = 0.005
+
+    noise_strength = 0.05
+
+    adaption = np.zeros(len(stimulus))
+    adaption[0] = 1
+    v_1 = np.zeros(len(stimulus))
+    v_1[0] = v_0
+    spikes = []
+
+    for i in range(1, len(v_1), 1):
+
+        noise_value = np.random.normal()
+        noise = noise_strength * noise_value / np.sqrt(step_size)
+
+        if len(spikes) > 0 and i*step_size < spikes[-1] + ref_time:
+            v_1[i] = v_base
+        else:
+            v_1[i] = v_1[i - 1] + ((v_offset - v_1[i-1] - adaption[i-1] + stimulus[i] + noise) / mem_tau) * step_size
+
+        adaption[i] = adaption[i-1] + (-adaption[i-1] / adaption_tau) * step_size
+        if v_1[i] > threshold:
+            v_1[i] = v_base
+            spikes.append(i * step_size)
+            adaption[i] += adaption_step / adaption_tau
+
+    return v_1, spikes
+
+
+if __name__ == '__main__':
+    main()