From 2d043117900818f6a5f90572114ee4b0d206d815 Mon Sep 17 00:00:00 2001 From: alexanderott Date: Sun, 10 May 2020 13:55:48 +0200 Subject: [PATCH] commit all.. --- Fitter.py | 120 +++++++++++------- helperFunctions.py | 11 +- introduction/test.py | 21 +-- main.py | 8 +- models/LIFACnoise.py | 41 ++++-- tests/ModelTests.py | 109 ++++++++-------- .../functionalityTests.py | 0 generalTests.py => tests/generalTests.py | 8 +- .../stimuli => unittests}/TestStepStimulus.py | 0 9 files changed, 177 insertions(+), 141 deletions(-) rename functionalityTests.py => tests/functionalityTests.py (100%) rename generalTests.py => tests/generalTests.py (97%) rename {tests/stimuli => unittests}/TestStepStimulus.py (100%) diff --git a/Fitter.py b/Fitter.py index 82b6b6d..ea1b17f 100644 --- a/Fitter.py +++ b/Fitter.py @@ -19,7 +19,7 @@ def main(): run_with_real_data() -def iget_start_parameters(mem_tau_list=None, input_scaling_list=None, noise_strength_list=None, dend_tau_list=None): +def iget_start_parameters(mem_tau_list=None, input_scaling_list=None, noise_strength_list=None, dend_tau_list=None, tau_a_list=None, delta_a_list=None): # mem_tau, input_scaling, noise_strength, dend_tau, # expand by tau_a, delta_a ? if mem_tau_list is None: @@ -27,9 +27,13 @@ def iget_start_parameters(mem_tau_list=None, input_scaling_list=None, noise_stre if input_scaling_list is None: input_scaling_list = [40, 60, 80] if noise_strength_list is None: - noise_strength_list = [0.02, 0.06] + noise_strength_list = [0.03] # [0.02, 0.06] if dend_tau_list is None: dend_tau_list = [0.001, 0.002] + # if tau_a_list is None: + # tau_a_list = + # if delta_a_list is None: + # delta_a_list = for mem_tau in mem_tau_list: for input_scaling in input_scaling_list: @@ -44,7 +48,8 @@ def run_with_real_data(): start_par_count = 0 for start_parameters in iget_start_parameters(): start_par_count += 1 - if start_par_count <= 4: + print("START PARAMETERS:", start_par_count) + if start_par_count <= 0: continue print("cell:", cell_data.get_data_path()) trace = cell_data.get_base_traces(trace_type=cell_data.V1) @@ -141,7 +146,6 @@ class Fitter: self.f_inf_values = [] self.f_inf_slope = 0 - self.f_zero_values = [] self.f_zero_slope = 0 self.f_zero_fit = [] @@ -175,7 +179,7 @@ class Fitter: # print("delta_a: {:.3f}".format(self.delta_a), "tau_a: {:.3f}".format(self.tau_a)) - return self.fit_routine_4(data, start_parameters) + return self.fit_routine_5(data, start_parameters) # return self.fit_model(fit_adaption=False) def fit_routine_1(self, cell_data=None): @@ -252,55 +256,76 @@ class Fitter: if start_parameters is None: x0 = np.array([0.02, 70, 0.001]) else: - x0 = np.array([start_parameters["mem_tau"], start_parameters["input_scaling"], start_parameters["dend_tau"]]) + x0 = np.array([start_parameters["mem_tau"], start_parameters["noise_strength"], + start_parameters["input_scaling"], start_parameters["dend_tau"]]) initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (0, 1, 5, 1, 2, 0, 0) - fmin = minimize(fun=self.cost_function_with_fixed_adaption_with_dend_tau_no_noise, + error_weights = (0, 5, 15, 1, 2, 1, 0) + fmin = minimize(fun=self.cost_function_with_fixed_adaption_with_dend_tau, args=(self.tau_a, self.delta_a, error_weights), x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex, "xatol": 0.001}) + options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxfev": 400, "maxiter": 400}) res_parameters = fmin.x - print_comparision_cell_model(cell_data, self.base_model.get_parameters()) + # print_comparision_cell_model(cell_data, self.base_model.get_parameters()) self.counter = 0 - x0 = np.array([res_parameters[0], res_parameters[1], self.tau_a, - self.delta_a, res_parameters[2]]) + x0 = np.array([self.tau_a, + self.delta_a, res_parameters[0]]) initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (0, 0, 0, 0, 0, 4, 2) - fmin = minimize(fun=self.cost_function_all_without_noise, + error_weights = (0, 1, 1, 2, 2, 4, 2) + fmin = minimize(fun=self.cost_function_only_adaption, args=(error_weights,), x0=x0, method="Nelder-Mead", options={"initial_simplex": initial_simplex, "xatol": 0.001}) res_parameters = fmin.x print(fmin) print_comparision_cell_model(cell_data, self.base_model.get_parameters()) - self.counter = 0 - x0 = np.array([res_parameters[0], - res_parameters[1], self.tau_a, - self.delta_a, res_parameters[2]]) - initial_simplex = create_init_simples(x0, search_scale=2) - error_weights = (0, 0, 1, 0, 0, 5, 2) - fmin = minimize(fun=self.cost_function_all_without_noise, - args=(error_weights,), x0=x0, method="Nelder-Mead", - options={"initial_simplex": initial_simplex, "xatol": 0.001}) - res_parameters = self.base_model.get_parameters() - - print_comparision_cell_model(cell_data, self.base_model.get_parameters()) - - # noise_strength = 0.03 + # + # # self.counter = 0 + # # x0 = np.array([res_parameters[0], + # # res_parameters[1], self.tau_a, + # # self.delta_a, res_parameters[2]]) + # # initial_simplex = create_init_simples(x0, search_scale=2) + # # error_weights = (1, 3, 1, 2, 1, 3, 2) + # # fmin = minimize(fun=self.cost_function_all_without_noise, + # # args=(error_weights,), x0=x0, method="Nelder-Mead", + # # options={"initial_simplex": initial_simplex, "xatol": 0.001}) + # # res_parameters = self.base_model.get_parameters() + # # + # # print_comparision_cell_model(cell_data, self.base_model.get_parameters()) + # # self.counter = 0 - # x0 = np.array([res_parameters["mem_tau"], noise_strength, - # res_parameters["input_scaling"], res_parameters["tau_a"], - # res_parameters["delta_a"], res_parameters["dend_tau"]]) + # x0 = np.array([res_parameters[0], start_parameters["noise_strength"], + # res_parameters[1], res_parameters[2], + # res_parameters[3], res_parameters[4]]) # initial_simplex = create_init_simples(x0, search_scale=2) - # error_weights = (0, 2, 2, 1, 1, 3, 2) + # error_weights = (0, 1, 2, 1, 1, 3, 2) # fmin = minimize(fun=self.cost_function_all, # args=(error_weights,), x0=x0, method="Nelder-Mead", - # options={"initial_simplex": initial_simplex, "xatol": 0.001}) + # options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxiter": 599}) # res_parameters = self.base_model.get_parameters() return fmin, self.base_model.get_parameters() + def fit_routine_5(self, cell_data=None, start_parameters=None): + global SAVE_PATH_PREFIX + SAVE_PATH_PREFIX = "fit_routine_5_" + # errors: [error_bf, error_vs, error_sc, error_f_inf, error_f_inf_slope, error_f_zero, error_f_zero_slope] + self.counter = 0 + # fit only v_offset, mem_tau, input_scaling, dend_tau + if start_parameters is None: + x0 = np.array([0.02, 70, 0.001]) + else: + x0 = np.array([start_parameters["mem_tau"], start_parameters["input_scaling"], + self.tau_a, self.delta_a, start_parameters["dend_tau"]]) + initial_simplex = create_init_simples(x0, search_scale=2) + error_weights = (0, 1, 1, 1, 1, 2, 1) + fmin = minimize(fun=self.cost_function_all_without_noise, + args=(error_weights,), x0=x0, method="Nelder-Mead", + options={"initial_simplex": initial_simplex, "xatol": 0.001, "maxfev": 400, "maxiter": 400}) + res_parameters = fmin.x + + return fmin, self.base_model.get_parameters() + def fit_model(self, x0=None, initial_simplex=None, fit_adaption=False): self.counter = 0 @@ -361,9 +386,10 @@ class Fitter: return sum(error_list) - def cost_function_only_adaption_and_v_offset(self, X, error_weights=None): + def cost_function_only_adaption(self, X, error_weights=None): self.base_model.set_variable("tau_a", X[0]) self.base_model.set_variable("delta_a", X[1]) + self.base_model.set_variable("mem_tau", X[2]) base_stimulus = SinusoidalStepStimulus(self.eod_freq, 0) # find right v-offset @@ -376,14 +402,6 @@ class Fitter: return sum(error_list) - def cost_function_only_adaption(self, X, error_weights=None): - self.base_model.set_variable("tau_a", X[0]) - self.base_model.set_variable("delta_a", X[1]) - - error_list = self.calculate_errors(error_weights) - - return sum(error_list) - def cost_function_with_fixed_adaption(self, X, tau_a, delta_a, error_weights=None): # set model parameters: model = self.base_model @@ -453,10 +471,20 @@ class Fitter: # f_infinities, f_infinities_slope = self.base_model.calculate_fi_markers(self.fi_contrasts, self.eod_freq) f_baselines, f_zeros, f_infinities = self.base_model.calculate_fi_curve(self.fi_contrasts, self.eod_freq) - f_infinities_fit = hF.fit_clipped_line(self.fi_contrasts, f_infinities) - f_infinities_slope = f_infinities_fit[0] + try: + f_infinities_fit = hF.fit_clipped_line(self.fi_contrasts, f_infinities) + except Exception as e: + print("EXCEPTION IN FIT LINE!") + print(e) + f_infinities_fit = [0, 0] - f_zeros_fit = hF.fit_boltzmann(self.fi_contrasts, f_zeros) + f_infinities_slope = f_infinities_fit[0] + try: + f_zeros_fit = hF.fit_boltzmann(self.fi_contrasts, f_zeros) + except Exception as e: + print("EXCEPTION IN FIT BOLTZMANN!") + print(e) + f_zeros_fit = [0, 0, 0, 0] f_zero_slope = fu.full_boltzmann_straight_slope(f_zeros_fit[0], f_zeros_fit[1], f_zeros_fit[2], f_zeros_fit[3]) # print("fi-curve features calculated!") # calculate errors with reference values @@ -478,7 +506,7 @@ class Fitter: error = sum(error_list) self.counter += 1 - if self.counter % 200 == 0 and False: # TODO currently shut off! + if self.counter % 200 == 0: # and False: # TODO currently shut off! print("\nCost function run times: {:}\n".format(self.counter), "Total weighted error: {:.4f}\n".format(error), "Baseline frequency - expected: {:.0f}, current: {:.0f}, error: {:.3f}\n".format( diff --git a/helperFunctions.py b/helperFunctions.py index 15f6a12..da217b2 100644 --- a/helperFunctions.py +++ b/helperFunctions.py @@ -3,6 +3,7 @@ from warnings import warn from thunderfish.eventdetection import detect_peaks, threshold_crossing_times, threshold_crossings from scipy.optimize import curve_fit import functions as fu +from numba import jit def fit_clipped_line(x, y): @@ -27,6 +28,11 @@ def fit_boltzmann(x, y): return popt +@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]) + + def merge_similar_intensities(intensities, spiketimes, trans_amplitudes): i = 0 @@ -151,7 +157,8 @@ def calculate_isi_frequency_trace(spiketimes, sampling_interval, time_in_ms=Fals def calculate_time_and_frequency_trace(spiketimes, sampling_interval, time_in_ms=False): if len(spiketimes) < 2: - pass # raise ValueError("Cannot compute a time and frequency vector with fewer than 2 spikes") + return [0], [0] + # raise ValueError("Cannot compute a time and frequency vector with fewer than 2 spikes") frequency = calculate_isi_frequency_trace(spiketimes, sampling_interval, time_in_ms) @@ -161,7 +168,6 @@ def calculate_time_and_frequency_trace(spiketimes, sampling_interval, time_in_ms if len(time) > len(frequency): time = time[:len(frequency)] - return time, frequency @@ -430,6 +436,7 @@ def detect_f_zero_in_frequency_trace(time, frequency, stimulus_start, sampling_i if len(freq_before) < 3: print("mäh") + return 0 min_before = min(freq_before) max_before = max(freq_before) diff --git a/introduction/test.py b/introduction/test.py index 73110b1..f3edf7b 100644 --- a/introduction/test.py +++ b/introduction/test.py @@ -2,27 +2,10 @@ import numpy as np import matplotlib.pyplot as plt import helperFunctions as hF import time +from stimuli.SinusoidalStepStimulus import SinusoidalStepStimulus -def main(): - - - time = np.arange(-1, 30, 0.0001) - eod = np.sin(2*np.pi * 600 * time) - - - signs = np.sign(eod[:-1]) != np.sign(eod[1:]) - delta = eod[:-1] < eod[1:] - - sign_changes = np.where(signs & delta)[0] - - plt.plot(time, eod) - plt.plot([time[i] for i in sign_changes], [0]*len(sign_changes), 'o') - plt.show() - - - print(sign_changes) - quit() +def main(): for freq in [700, 50, 100, 500, 1000]: reps = 1000 diff --git a/main.py b/main.py index 98f905a..fb5dc44 100644 --- a/main.py +++ b/main.py @@ -1,10 +1,6 @@ - -from FiCurve import FICurve from CellData import icelldata_of_dir -import os -import helperFunctions as hf -from AdaptionCurrent import Adaption -from functionalityTests import * + + # TODO command line interface needed/nice ? diff --git a/models/LIFACnoise.py b/models/LIFACnoise.py index f77716e..224de90 100644 --- a/models/LIFACnoise.py +++ b/models/LIFACnoise.py @@ -32,6 +32,7 @@ class LifacNoiseModel(AbstractModel): if self.parameters["step_size"] > 0.0001: warn("LifacNoiseModel: The step size is quite big simulation could fail.") self.voltage_trace = [] + self.input_voltage = [] self.adaption_trace = [] self.spiketimes = [] self.stimulus = None @@ -43,18 +44,19 @@ class LifacNoiseModel(AbstractModel): time = np.arange(0, total_time_s, self.parameters["step_size"]) output_voltage = np.zeros(len(time), dtype='float64') adaption = np.zeros(len(time), dtype='float64') + input_voltage = np.zeros(len(time), dtype='float64') spiketimes = [] current_v = self.parameters["v_zero"] current_a = self.parameters["a_zero"] + input_voltage[0] = fu.rectify(stimulus.value_at_time_in_s(time[0])) output_voltage[0] = current_v adaption[0] = current_a for i in range(1, len(time), 1): time_point = time[i] # rectified input: - stimulus_strength = fu.rectify(stimulus.value_at_time_in_s(time_point)) * self.parameters["input_scaling"] - + stimulus_strength = self._calculate_input_voltage_step(input_voltage[i-1], fu.rectify(stimulus.value_at_time_in_s(time_point))) v_next = self._calculate_voltage_step(current_v, stimulus_strength - current_a) a_next = self._calculate_adaption_step(current_a) @@ -65,6 +67,7 @@ class LifacNoiseModel(AbstractModel): output_voltage[i] = v_next adaption[i] = a_next + input_voltage[i] = stimulus_strength current_v = v_next current_a = a_next @@ -72,6 +75,7 @@ class LifacNoiseModel(AbstractModel): self.voltage_trace = output_voltage self.adaption_trace = adaption self.spiketimes = spiketimes + self.input_voltage = input_voltage return output_voltage, spiketimes @@ -91,6 +95,10 @@ class LifacNoiseModel(AbstractModel): step_size = self.parameters["step_size"] return current_a + (step_size * (-current_a)) / self.parameters["tau_a"] + def _calculate_input_voltage_step(self, current_i, rectified_input): + # input_voltage[i] = input_voltage[i - 1] + (-input_voltage[i - 1] + rectified_stimulus_array[i] * input_scaling) / dend_tau + return current_i + ((-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): v_zero = self.parameters["v_zero"] @@ -109,9 +117,10 @@ class LifacNoiseModel(AbstractModel): rectified_stimulus = rectify_stimulus_array(stimulus.as_array(time_start, total_time_s, step_size)) parameters = np.array([v_zero, a_zero, step_size, threshold, v_base, delta_a, tau_a, v_offset, mem_tau, noise_strength, time_start, input_scaling, dend_tau]) - voltage_trace, adaption, spiketimes = simulate_fast(rectified_stimulus, total_time_s, parameters) + voltage_trace, adaption, spiketimes, input_voltage = simulate_fast(rectified_stimulus, total_time_s, parameters) self.stimulus = stimulus + self.input_voltage = input_voltage self.voltage_trace = voltage_trace self.adaption_trace = adaption self.spiketimes = spiketimes @@ -207,32 +216,36 @@ class LifacNoiseModel(AbstractModel): def calculate_fi_curve(self, contrasts, stimulus_freq): - 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 + + stim_duration = 0.5 + stim_start = 0.5 + total_simulation_time = stim_duration + 2 * stim_start # print("Total simulation time (vs 2.5) {:.2f}".format(total_simulation_time)) sampling_interval = self.get_sampling_interval() f_infinities = [] f_zeros = [] f_baselines = [] - import matplotlib.pyplot as plt for c in contrasts: stimulus = SinusoidalStepStimulus(stimulus_freq, c, stim_start, stim_duration) _, spiketimes = self.simulate_fast(stimulus, total_simulation_time) + # if len(spiketimes) > 0: + # print("min:", min(spiketimes), "max:", max(spiketimes), "len:", len(spiketimes)) + # else: + # print("spiketimes empty") time, frequency = hF.calculate_time_and_frequency_trace(spiketimes, sampling_interval) # if c == contrasts[0] or c == contrasts[-1]: # plt.plot(frequency) # plt.show() - if len(time) == 0 or time[0] >= stim_start or len(spiketimes) < 5: + if len(spiketimes) < 10 or len(time) == 0 or min(time) > stim_start or max(time) < stim_start+stim_duration: + print("Too few spikes to calculate f_inf, f_0 and f_base") f_infinities.append(0) f_zeros.append(0) f_baselines.append(0) continue + f_inf = hF.detect_f_infinity_in_freq_trace(time, frequency, stim_start, stim_duration, sampling_interval) f_infinities.append(f_inf) @@ -242,7 +255,7 @@ class LifacNoiseModel(AbstractModel): f_baseline = hF.detect_f_baseline_in_freq_trace(time, frequency, stim_start, sampling_interval) f_baselines.append(f_baseline) - + # import matplotlib.pyplot as plt # fig, axes = plt.subplots(2, 1, sharex="all") # stim_time = np.arange(0,3.5, sampling_interval) # axes[0].set_title("Contrast: " + str(c)) @@ -359,8 +372,8 @@ def simulate_fast(rectified_stimulus_array, total_time_s, parameters: np.ndarray noise_value = np.random.normal() noise = noise_strength * noise_value / np.sqrt(step_size) - input_voltage[i] = input_voltage[i - 1] + (-input_voltage[i - 1] + rectified_stimulus_array[i] * input_scaling) / dend_tau - output_voltage[i] = output_voltage[i-1] + ((v_base - output_voltage[i-1] + v_offset + (rectified_stimulus_array[i] * input_scaling) - adaption[i-1] + noise) / mem_tau) * step_size + input_voltage[i] = input_voltage[i - 1] + ((-input_voltage[i - 1] + rectified_stimulus_array[i]) / dend_tau) * step_size + output_voltage[i] = output_voltage[i-1] + ((v_base - output_voltage[i-1] + v_offset + (input_voltage[i] * input_scaling) - adaption[i-1] + noise) / mem_tau) * step_size adaption[i] = adaption[i-1] + ((-adaption[i-1]) / tau_a) * step_size if output_voltage[i] > threshold: @@ -368,7 +381,7 @@ def simulate_fast(rectified_stimulus_array, total_time_s, parameters: np.ndarray spiketimes.append(i*step_size) adaption[i] += delta_a / tau_a - return output_voltage, adaption, spiketimes + return output_voltage, adaption, spiketimes, input_voltage diff --git a/tests/ModelTests.py b/tests/ModelTests.py index b79aad9..2984922 100644 --- a/tests/ModelTests.py +++ b/tests/ModelTests.py @@ -5,7 +5,7 @@ import helperFunctions as hf from models.FirerateModel import FirerateModel from models.LIFACnoise import LifacNoiseModel from stimuli.StepStimulus import StepStimulus -from stimuli.SinusAmplitudeModulation import SinusAmplitudeModulationStimulus +from stimuli.SinusoidalStepStimulus import SinusoidalStepStimulus import functions as fu @@ -52,16 +52,16 @@ def test_lifac_noise(): model = LifacNoiseModel() - start = 0.2 - duration = 30 + start = 1 + duration = 3 total_time = duration + 2*start - step_size = model.get_parameters()["step_size"]/1000 + step_size = model.get_parameters()["step_size"] time = np.arange(0, total_time, step_size) - stimulus = SinusAmplitudeModulationStimulus(700, 0.2, 10, 20, start, duration) + stimulus = SinusoidalStepStimulus(700, 0.2, start, duration) - model.simulate(stimulus, total_time) + model.simulate_fast(stimulus, total_time) - fig, axes = plt.subplots(nrows=3, sharex="col") + fig, axes = plt.subplots(nrows=4, sharex="col") sparse_time = np.arange(0, total_time, 1/5000) axes[0].plot(sparse_time, [stimulus.value_at_time_in_s(x) for x in sparse_time], label="given stimulus") axes[0].plot(sparse_time, [fu.rectify(stimulus.value_at_time_in_s(x)) for x in sparse_time], label="seen stimulus") @@ -69,54 +69,63 @@ def test_lifac_noise(): axes[0].set_ylabel("stimulus strength") axes[0].legend() - axes[1].plot(time, model.get_voltage_trace()) - axes[1].set_title("Voltage trace") - axes[1].set_ylabel("voltage") + input_voltage = model.input_voltage + axes[1].plot(time, input_voltage) + axes[1].set_title("Stimulus after dendtritic filter") + axes[1].set_ylabel("stimulus strength") - t, f = hf.calculate_isi_frequency_trace(model.get_spiketimes(), 0, step_size) - axes[2].plot(t, f) - axes[2].set_title("ISI frequency trace") - axes[2].set_ylabel("Frequency") + voltage_trace = model.get_voltage_trace() + axes[2].plot(time, voltage_trace) + axes[2].set_title("Voltage trace") + axes[2].set_ylabel("voltage") - spiketimes_small_step = model.get_spiketimes() + spiketimes = model.get_spiketimes() + t, f = hf.calculate_time_and_frequency_trace(spiketimes, step_size) + axes[3].plot(t, f) + axes[3].set_title("ISI frequency trace") + axes[3].set_ylabel("Frequency") - model.set_variable("step_size", 0.02) - model.simulate(stimulus, total_time) - print(model.get_adaption_trace()[int(0.1/(0.01/1000))]) - step_size = model.get_parameters()["step_size"] / 1000 - time = np.arange(0, total_time, step_size) - t, f = hf.calculate_isi_frequency_trace(model.get_spiketimes(), 0, step_size) - - axes[1].plot(time, model.get_voltage_trace()) - axes[2].plot(t, f) - - spiketimes_big_step = model.get_spiketimes() - - print("CV:") - print("small step:", hf.calculate_coefficient_of_variation(spiketimes_small_step)) - print("big step:", hf.calculate_coefficient_of_variation(spiketimes_big_step)) - - plt.show() - plt.close() - - max_lag = 5 - x = np.arange(1, max_lag+1, 1) - serial_cor_small = hf.calculate_serial_correlation(spiketimes_small_step, max_lag) - serial_cor_big = hf.calculate_serial_correlation(spiketimes_big_step, max_lag) - - print(serial_cor_small) - print(serial_cor_big) - plt.plot(x, serial_cor_small, 'o', label='small step',) - plt.plot(x, serial_cor_big, 'o', label='big step') - plt.ylim(-1, 1) - plt.legend() plt.show() - plt.close() - bins = np.arange(0, max(np.diff(spiketimes_small_step)), 0.0001) - plt.hist(np.diff(spiketimes_small_step), bins=bins, alpha=0.5) - plt.hist(np.diff(spiketimes_big_step), bins=bins, alpha=0.5) - plt.show() + # spiketimes_small_step = model.get_spiketimes() + # + # model.set_variable("step_size", 0.02) + # model.simulate(stimulus, total_time) + # print(model.get_adaption_trace()[int(0.1/(0.01/1000))]) + # step_size = model.get_parameters()["step_size"] / 1000 + # time = np.arange(0, total_time, step_size) + # t, f = hf.calculate_time_and_frequency_trace(model.get_spiketimes(), 0.02) + # + # axes[1].plot(time, model.get_voltage_trace()) + # axes[2].plot(t, f) + # + # spiketimes_big_step = model.get_spiketimes() + # + # print("CV:") + # print("small step:", hf.calculate_coefficient_of_variation(spiketimes_small_step)) + # print("big step:", hf.calculate_coefficient_of_variation(spiketimes_big_step)) + + # plt.show() + # plt.close() + # + # max_lag = 5 + # x = np.arange(1, max_lag+1, 1) + # serial_cor_small = hf.calculate_serial_correlation(spiketimes_small_step, max_lag) + # serial_cor_big = hf.calculate_serial_correlation(spiketimes_big_step, max_lag) + # + # print(serial_cor_small) + # print(serial_cor_big) + # plt.plot(x, serial_cor_small, 'o', label='small step',) + # plt.plot(x, serial_cor_big, 'o', label='big step') + # plt.ylim(-1, 1) + # plt.legend() + # plt.show() + # plt.close() + # + # bins = np.arange(0, max(np.diff(spiketimes_small_step)), 0.0001) + # plt.hist(np.diff(spiketimes_small_step), bins=bins, alpha=0.5) + # plt.hist(np.diff(spiketimes_big_step), bins=bins, alpha=0.5) + # plt.show() if __name__ == '__main__': diff --git a/functionalityTests.py b/tests/functionalityTests.py similarity index 100% rename from functionalityTests.py rename to tests/functionalityTests.py diff --git a/generalTests.py b/tests/generalTests.py similarity index 97% rename from generalTests.py rename to tests/generalTests.py index 0a58126..4190ce2 100644 --- a/generalTests.py +++ b/tests/generalTests.py @@ -28,7 +28,7 @@ def time_test_function(): def test_cell_data(): - for cell_data in icelldata_of_dir("./data/"): + for cell_data in icelldata_of_dir("../data/"): #if "2012-12-20-ad" not in cell_data.get_data_path(): # continue print() @@ -47,7 +47,7 @@ def test_cell_data(): def test_peak_detection(): - for cell_data in icelldata_of_dir("./data/"): + for cell_data in icelldata_of_dir("../data/"): print() print(cell_data.get_data_path()) times = cell_data.get_base_traces(cell_data.TIME) @@ -102,7 +102,7 @@ def test_simulation_speed(): def test_fi_curve_class(): - for cell_data in icelldata_of_dir("./data/"): + for cell_data in icelldata_of_dir("../data/"): fi_curve = FICurve(cell_data) fi_curve.get_f_zero_and_f_inf_intersection() fi_curve.plot_fi_curve() @@ -113,7 +113,7 @@ def test_fi_curve_class(): def test_adaption_class(): - for cell_data in icelldata_of_dir("./data/"): + for cell_data in icelldata_of_dir("../data/"): print() print(cell_data.get_data_path()) fi_curve = FICurve(cell_data) diff --git a/tests/stimuli/TestStepStimulus.py b/unittests/TestStepStimulus.py similarity index 100% rename from tests/stimuli/TestStepStimulus.py rename to unittests/TestStepStimulus.py