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