def get_rate_from_trace(times, volts): analysis_var = { 'peak_delta': 0, 'baseline': 0, 'dvdt_threshold': 0, 'peak_threshold': 0 } try: analysis_data = analysis.IClampAnalysis(volts, times, analysis_var, start_analysis=0, end_analysis=times[-1], smooth_data=False, show_smoothed_data=False) analysed = analysis_data.analyse() #pp.pprint(analysed) return analysed['mean_spike_frequency'] except: return 0
def __init__(self, analysis_start_time, controller, analysis_end_time, target_data_path, parameters, analysis_var, weights, targets=None, automatic=False): super(IClampEvaluator, self).__init__(parameters, weights, targets, controller) self.analysis_start_time = analysis_start_time self.analysis_end_time = analysis_end_time self.target_data_path = target_data_path self.analysis_var = analysis_var print('target data path in evaluator:' + target_data_path) if automatic == True: t, v_raw = analysis.load_csv_data(target_data_path) v = numpy.array(v_raw) v_smooth = list(analysis.smooth(v)) ic_analysis = analysis.IClampAnalysis( v_smooth, t, analysis_var, start_analysis=analysis_start_time, end_analysis=analysis_end_time) ic_analysis.analyse() self.targets = ic_analysis.analysis_results print('Obtained targets are:') print(self.targets)
def evaluate(self, candidates, args): print("\n>>>>> Evaluating: ") for cand in candidates: print(">>>>> %s" % cand) simulations_data = self.controller.run(candidates, self.parameters) fitness = [] for data in simulations_data: times = data[0] samples = data[1] data_analysis = analysis.IClampAnalysis( samples, times, self.analysis_var, start_analysis=self.analysis_start_time, end_analysis=self.analysis_end_time, target_data_path=self.target_data_path) try: data_analysis.analyse() except: data_analysis.analysable_data = False fitness_value = self.evaluate_fitness( data_analysis, self.targets, self.weights, cost_function=normalised_cost_function) fitness.append(fitness_value) print('Fitness: %s\n' % fitness_value) return fitness
def get_rate_from_trace(times, volts): analysis_var={'peak_delta':0,'baseline':0,'dvdt_threshold':0, 'peak_threshold':0} try: analysis_data=analysis.IClampAnalysis(volts, times, analysis_var, start_analysis=0, end_analysis=times[-1], smooth_data=False, show_smoothed_data=False, verbose=True) analysed = analysis_data.analyse() import pprint; pp = pprint.PrettyPrinter() #pp.pprint(analysed) return analysed['mean_spike_frequency'] except Exception as e: print("Problem getting rate: %s"%e) return 0
from pyelectro import analysis as pye_analysis from matplotlib import pyplot file_name = '100pA_1a.csv' t, v = pye_analysis.load_csv_data(file_name) analysis_var = { 'peak_delta': 0.1, 'baseline': 0, 'dvdt_threshold': 2, 'peak_threshold': 0 } analysis = pye_analysis.IClampAnalysis(v, t, analysis_var, start_analysis=150, end_analysis=900) res = analysis.analyse() print res pyplot.plot(t, v) pyplot.suptitle('Data read in from: %s' % file_name) pyplot.show()
def simple_iclamp_analysis( volts, times, analysis_var=None, start_analysis=0, end_analysis=None, plot=False, show_plot_already=True, ): """ A utility function to quickly carry out a simple current clamp analysis (IClampAnalysis). :param v: time-dependent variable (usually voltage) :type v: iterable :param t: time-array (1-to-1 correspondence with v_array) :type t: iterable :param start_analysis: time in v,t where analysis is to start :type start_analysis: float :param end_analysis: time in v,t where analysis is to end :type end_analysis: float :returns: dictionary of analysis results """ if analysis_var is None: analysis_var = { "peak_delta": 0, "baseline": 0, "dvdt_threshold": 0, "peak_threshold": 0, } analysed = analysis.IClampAnalysis( volts, times, analysis_var, start_analysis=start_analysis, end_analysis=end_analysis if end_analysis is not None else times[-1], smooth_data=False, show_smoothed_data=False, max_min_method=analysis.max_min_simple, ) analysed.analyse() analysis.print_comment_v(pp.pformat(analysed.analysis_results)) maxmin = analysed.max_min_dictionary if plot: fig = pylab.figure() pylab.get_current_fig_manager().set_window_title( "Data analysed (%i traces at %i time points)" % (len(volts), len(times))) pylab.xlabel("Time (ms)") pylab.ylabel("Voltage (mV)") pylab.grid("on") if analysed.analysis_results: if "average_maximum" in analysed.analysis_results: _add_horizontal_line( analysed.analysis_results["average_maximum"], times) if "average_minimum" in analysed.analysis_results: _add_horizontal_line( analysed.analysis_results["average_minimum"], times) if maxmin: for i in range(len(maxmin["maxima_times"])): pylab.plot(maxmin["maxima_times"][i], maxmin["maxima_values"][i], "ro") for i in range(len(maxmin["minima_times"])): pylab.plot(maxmin["minima_times"][i], maxmin["minima_values"][i], "go") pylab.plot(times, volts) if show_plot_already: pylab.show() return analysed.analysis_results
parameters = [ 'axon_gbar_na', 'axon_gbar_kv', 'axon_gbar_kv3', 'soma_gbar_na', 'soma_gbar_kv', 'soma_gbar_kv3' ] #This seed should always "win" because it is the solution. #dud_seed = [3661.79, 23.23, 0.26, 79.91, 0.58, 1.57] surrogate_t, surrogate_v = controller.run_individual(sim_var, show=False) analysis_var = {'peak_delta': 1e-4, 'baseline': 0, 'dvdt_threshold': 0.0} surrogate_analysis = analysis.IClampAnalysis(surrogate_v, surrogate_t, analysis_var, start_analysis=0, end_analysis=900, smooth_data=False, show_smoothed_data=False) # The output of the analysis will serve as the basis for model optimization: surrogate_targets = surrogate_analysis.analyse() assert (surrogate_targets['max_peak_no'] == 13) weights = { 'average_minimum': 1.0, 'spike_frequency_adaptation': 1.0, 'trough_phase_adaptation': 1.0, 'mean_spike_frequency': 1.0, 'average_maximum': 1.0,
data_fname = "redacted_data.txt" dt = 0.0002 #load the voltage: file = open(data_fname) #make voltage into a numpy array in mV: v = np.array([float(i) for i in file.readlines()]) * 1000 t_init = 0.0 t_final = len(v) * dt t = np.linspace(t_init, t_final, len(v)) * 1000 pyplot.plot(t, v) pyplot.show() analysis_var = {'peak_delta': 0.0, 'baseline': 5, 'dvdt_threshold': 0.0} analysis_i = analysis.IClampAnalysis(v, t, analysis_var, start_analysis=0, end_analysis=5000, smooth_data=True, show_smoothed_data=True, smoothing_window_len=33) analysis_i.analyse() print(analysis_i.analysis_results)
swc.run_individual(sim_vars, showPlots, False) times, volts = swc.run_individual(sim_vars, False) analysis_var = { 'peak_delta': 0, 'baseline': 0, 'dvdt_threshold': 0, 'peak_threshold': 0 } surrogate_analysis = analysis.IClampAnalysis(volts, times, analysis_var, start_analysis=0, end_analysis=1000, smooth_data=False, show_smoothed_data=False) # The output of the analysis will serve as the basis for model optimization: surrogate_targets = surrogate_analysis.analyse() pp = pprint.PrettyPrinter(indent=4) weights = { 'average_minimum': 1.0, 'spike_frequency_adaptation': 0, 'trough_phase_adaptation': 0, 'mean_spike_frequency': 1, 'average_maximum': 1.0, 'trough_decay_exponent': 0,
def test_iclamp_analysis_data(self, show=False): print("- test_iclamp_analysis_data()") analysis_var = { 'peak_delta': 0, 'baseline': 0, 'dvdt_threshold': 0, 'peak_threshold': 0 } times, volts = self.get_real_data() max_min_methods = [analysis.max_min, analysis.max_min_simple] for max_min_method in max_min_methods: print('-------------- Analysing with: %s' % max_min_method) analysis_data = analysis.IClampAnalysis( volts, times, analysis_var, start_analysis=0, end_analysis=1000, smooth_data=False, show_smoothed_data=False, max_min_method=max_min_method) analysed = analysis_data.analyse() pp.pprint(analysed) test_data = \ {'average_maximum': 20.332122777777784, 'average_minimum': -78.491198000000011, 'first_spike_time': 108.44, 'interspike_time_covar': 0.019741062134352557, 'max_peak_no': 18, 'mean_spike_frequency': 34.545824019508231, 'min_peak_no': 17, 'peak_decay_exponent': -0.064912249086890028, 'peak_linear_gradient': -0.0020092762353974025, 'spike_broadening': 1.0495985656104889, 'spike_frequency_adaptation': 0.015301587514290844, 'spike_width_adaptation': 0.0078514736435321177, 'trough_decay_exponent': 0.0043242589967645087, 'trough_phase_adaptation': 0.01048418950808087} for key in analysed.keys(): self.assertAlmostEqual(analysed[key], test_data[key]) if show: import matplotlib.pyplot as pylab fig = pylab.figure() fig.canvas.set_window_title( "Data loaded (%i traces at %i time points)" % (len(volts), len(times))) pylab.xlabel('Time (ms)') pylab.ylabel('Voltage (mV)') pylab.grid('on') maxmin = analysis_data.max_min_dictionary pp.pprint(maxmin) self.add_horizontal_line( analysis_data.analysis_results['average_maximum'], times) self.add_horizontal_line( analysis_data.analysis_results['average_minimum'], times) for i in range(len(maxmin['maxima_times'])): pylab.plot(maxmin['maxima_times'][i], maxmin['maxima_values'][i], 'go') for i in range(len(maxmin['minima_times'])): pylab.plot(maxmin['minima_times'][i], maxmin['minima_values'][i], 'ro') pylab.plot(times, volts) if show: pylab.show()
from matplotlib import pyplot as plt file_name = '100pA_1.csv' t, v = io.load_csv_data(file_name) analysis_var = { 'peak_delta': 0.1, 'baseline': 0, 'dvdt_threshold': 2, 'peak_threshold': 0 } analysis = analysis.IClampAnalysis(v, t, analysis_var, start_analysis=150, end_analysis=900, smooth_data=True, show_smoothed_data=True) analysis.analyse() print analysis.analysable_data print analysis.analysis_results plt.xlabel('Time (ms)') plt.ylabel('Membrane potential (mV)') plt.grid('on') plt.suptitle('Data read in from: %s' % file_name) plt.plot(t, v)
def simple_iclamp_analysis(volts, times, analysis_var=None, start_analysis=0, end_analysis=None, plot=False, show_plot_already=True): if analysis_var == None: analysis_var = { 'peak_delta': 0, 'baseline': 0, 'dvdt_threshold': 0, 'peak_threshold': 0 } analysed = analysis.IClampAnalysis( volts, times, analysis_var, start_analysis=start_analysis, end_analysis=end_analysis if end_analysis is not None else times[-1], smooth_data=False, show_smoothed_data=False, max_min_method=analysis.max_min_simple) analysed.analyse() analysis.print_comment_v(pp.pformat(analysed.analysis_results)) maxmin = analysed.max_min_dictionary if plot: fig = pylab.figure() fig.canvas.set_window_title( "Data analysed (%i traces at %i time points)" % (len(volts), len(times))) pylab.xlabel('Time (ms)') pylab.ylabel('Voltage (mV)') pylab.grid('on') if analysed.analysis_results: if analysed.analysis_results.has_key('average_maximum'): _add_horizontal_line( analysed.analysis_results['average_maximum'], times) if analysed.analysis_results.has_key('average_minimum'): _add_horizontal_line( analysed.analysis_results['average_minimum'], times) if maxmin: for i in range(len(maxmin['maxima_times'])): pylab.plot(maxmin['maxima_times'][i], maxmin['maxima_values'][i], 'ro') for i in range(len(maxmin['minima_times'])): pylab.plot(maxmin['minima_times'][i], maxmin['minima_values'][i], 'go') pylab.plot(times, volts) if show_plot_already: pylab.show() return analysed.analysis_results