def li_iv_sum_stats(data):
output = []
for d in data.split_periodic(10300, adjust=True, closed_intervals=False):
d = d.trim_left(10000, adjust=True)
current = d['ical.i_CaL'][:-1] # the last value for some models can be NaN
# magnitude measured as difference between peak and steady-state at end of step
output = output + [max(current, key=abs)-current[-1]]
return output
def li_use_inact_sum_stats(data):
def single_exp(n, k, D):
return (1-D)+D*np.exp(-k*n)
output1 = []
output2 = []
# split separate vholds
for dvhold in data.split_periodic(sum(tsplits), adjust=True, closed_intervals=False):
for i, f in enumerate(freq):
pulses = [] # to hold the fitting data
period = 1000./f
dtrain, dvhold = dvhold.split(sum(tsplits[:i+1]))
t0 = dtrain['engine.time'][0]
dtrain['engine.time'] = [t-t0 for t in dtrain['engine.time']]
dtrain = dtrain.trim_left(tpre, adjust=True)
for d in dtrain.split_periodic(period, adjust=True, closed_intervals=False):
d = d.trim_right(period-tpulse)
current = d['ical.i_CaL']
pulses = pulses + [max(current, key=abs)]
# fit to exponential equation
with warnings.catch_warnings():
warnings.simplefilter('error', so.OptimizeWarning)
warnings.simplefilter('error', RuntimeWarning)
try:
# normalise to first pulse
norm = pulses[0]
for i in range(len(pulses)):
pulses[i] /= norm
popt, _ = so.curve_fit(single_exp,
list(range(npulses)),
pulses,
p0 = [0.2, 0.2],
bounds = (0.,
[np.inf, 1.0]),
max_nfev=1000)
fit = [single_exp(n, popt[0], popt[1]) for n in range(npulses)]
# Calculate r2
ss_res = np.sum((np.array(pulses)-np.array(fit))**2)
ss_tot = np.sum((np.array(pulses)-np.mean(np.array(pulses)))**2)
r2 = 1 - (ss_res / ss_tot)
pulse_const = 1./popt[0]
ss_decay = 1.-popt[1]
if r2 > fit_threshold:
output1 = output1+[pulse_const]
output2 = output2+[ss_decay]
else:
raise RuntimeWarning('scipy.optimize.curve_fit found a poor fit')
except:
output1 = output1 + [float('inf')]
output2 = output2 + [float('inf')]
return output1+output2
def li_inact_kin_sum_stats(data, fast=True, slow=True):
def double_exp(t, tauh, taus, Ah, As, A0):
return A0 + Ah*np.exp(-t/tauh) + As*np.exp(-t/taus)
output_fast = []
output_slow = []
for d in data.split_periodic(10300, adjust=True, closed_intervals=False):
d = d.trim_left(10000, adjust=True)
current = d['ical.i_CaL'][:-1]
time = d['engine.time'][:-1]
index = np.argmax(np.abs(current))
# Set time zero to peak current
current = current[index:]
time = time[index:]
t0 = time[0]
time = [t-t0 for t in time]
with warnings.catch_warnings():
warnings.simplefilter('error', OptimizeWarning)
warnings.simplefilter('error', RuntimeWarning)
try:
current = [c/current[0] for c in current]
if len(time)<=1 or len(current)<=1:
raise Exception('Failed simulation')
popt, _ = so.curve_fit(double_exp,
time,
current,
p0=[10,80,0.5,0.5,0],
bounds=(0.,
[np.inf, np.inf, 1.0, 1.0, 1.0]),
max_nfev=1000)
fit = [double_exp(t,popt[0],popt[1],popt[2],popt[3],popt[4]) for t in time]
# Calculate r2
ss_res = np.sum((np.array(current)-np.array(fit))**2)
ss_tot = np.sum((np.array(current)-np.mean(np.array(current)))**2)
r2 = 1 - (ss_res / ss_tot)
tauh = min(popt[0],popt[1])
taus = max(popt[0],popt[1])
if r2 > fit_threshold:
output_fast = output_fast+[tauh]
output_slow = output_slow+[taus]
else:
raise RuntimeWarning('scipy.optimize.curve_fit found a poor fit')
except:
output_fast = output_slow+[float('inf')]
output_slow = output_slow+[float('inf')]
output = []
if fast:
output += output_fast
if slow:
output += output_slow
return output
def li_act_sum_stats(data, ss=True, act_tau_10=False):
def single_exp(t, tau, A):
return 1-A*np.exp(-t/tau)
output = []
output_tau = []
for d in data.split_periodic(10300, adjust=True, closed_intervals=False):
d = d.trim_left(10000, adjust=True)
act_gate = d['ical.g']
if ss:
output = output + [max(act_gate, key=abs)]
if act_tau_10 and np.isclose(d['membrane.V'][0], 10.0):
time = d['engine.time']
index = np.argmax(act_gate)
# trim anything after peak
act_gate = act_gate[:index]
time = time[:index]
with warnings.catch_warnings():
warnings.simplefilter('error', OptimizeWarning)
warnings.simplefilter('error', RuntimeWarning)
try:
norm = max(act_gate, key=abs)
act_gate = [a/norm for a in act_gate]
if len(time)<=1 or len(act_gate)<=1:
raise Exception('Failed simulation')
popt, _ = so.curve_fit(single_exp,
time,
act_gate,
p0=[0.5, 1],
bounds=(0., np.inf),
max_nfev=1000)
fit = [single_exp(t,popt[0],popt[1]) for t in time]
# Calculate r2
ss_res = np.sum((np.array(act_gate)-np.array(fit))**2)
ss_tot = np.sum((np.array(act_gate)-np.mean(np.array(act_gate)))**2)
r2 = 1 - (ss_res / ss_tot)
tau = popt[0]
if r2 > fit_threshold:
output_tau = [tau]
else:
raise RuntimeWarning('scipy.optimize.curve_fit found a poor fit')
except:
output_tau = [float('inf')]
if ss:
norm = max(output)
for i in range(len(output)):
output[i] /= norm
return output+output_tau
def li_inact_sum_stats(data, tstep):
output = []
for d in data.split_periodic(10300+tstep, adjust=True, closed_intervals=False):
d = d.trim_left(10000+tstep, adjust=True)
inact_gate = d['ical.g']
output = output + [max(inact_gate, key=abs)]
norm = output[0] # absence of prepulse
for i in range(len(output)):
output[i] /= norm
# account for incomplete voltage-dependent inactivation
# (only if fitting to Boltzmann function
#fmin = min(output)
#for i in range(len(output)):
# output[i] = (output[i]-fmin)/(1-fmin)
return output
def li_recov_sum_stats(data, fast=True, slow=True):
def double_exp(t, tau_f, tau_s, Af, As, A0):
return A0-Af*np.exp(-t/tau_f)-As*np.exp(-t/tau_s)
def single_exp(t, tau_s, As, A0):
return A0-As*np.exp(-t/tau_s)
output1 = []
output2 = []
timename = 'engine.time'
for i,d in enumerate(data.split_periodic(tsplit_recov, adjust=True, closed_intervals=False)):
recov = []
for t in tsplits_recov:
d_, d = d.split(t)
step1 = d_.trim(d_[timename][0]+10000,
d_[timename][0]+10300,
adjust=True)
step2 = d_.trim_left(t-300, adjust=True)
try:
max1 = max(step1['ical.i_CaL'], key=abs)
max2 = max(step2['ical.i_CaL'], key=abs)
recov = recov + [max2/max1]
except:
recov = recov + [float('inf')]
# Now fit output to single/double exponential
with warnings.catch_warnings():
warnings.simplefilter('error', so.OptimizeWarning)
warnings.simplefilter('error', RuntimeWarning)
if i > 0:
try:
popt, _ = so.curve_fit(double_exp,
twaits_recov,
recov,
p0=[50.,500.,0.5,0.5,0.],
bounds=(0.,
[np.inf,np.inf,1.0,1.0,1.0]),
max_nfev=1000)
fit = [double_exp(t,popt[0],popt[1],popt[2],popt[3],popt[4])
for t in twaits_recov]
# Calculate r2
ss_res = np.sum((np.array(recov)-np.array(fit))**2)
ss_tot = np.sum((np.array(recov)-np.mean(np.array(recov)))**2)
r2 = 1 - (ss_res / ss_tot)
tauf = min(popt[0],popt[1])
taus = max(popt[0],popt[1])
if r2 > fit_threshold:
output1 = output1+[tauf]
output2 = output2+[taus]
else:
raise RuntimeWarning('scipy.optimize.curve_fit found a poor fit')
except:
output1 = output1+[float('inf')]
output2 = output2+[float('inf')]
else:
try:
popt, _ = so.curve_fit(single_exp,
twaits_recov,
recov,
p0=[50.,0.5,0.],
bounds=(0.,
[np.inf,1.0,1.0]),
max_nfev=1000)
fit = [single_exp(t,popt[0],popt[1],popt[2])
for t in twaits_recov]
# Calculate r2
ss_res = np.sum((np.array(recov)-np.array(fit))**2)
ss_tot = np.sum((np.array(recov)-np.mean(np.array(recov)))**2)
r2 = 1 - (ss_res / ss_tot)
taus = popt[0]
if r2 > fit_threshold:
output2 = output2+[taus]
else:
raise RuntimeWarning('scipy.optimize.curve_fit found a poor fit')
except:
output2 = output2+[float('inf')]
output = []
if fast:
output += output1
if slow:
output += output2
return output