'membrane.T': 297.15} conditions.append(cm_conditions) # Inactivation kinetics (Sakakibara voltage shifted) protocols.append( myokit.pacing.steptrain_linear(-30, 10, 10, -140, 1000, 100) ) conditions.append(cm_conditions) # Recovery kinetics (Sakakibara voltage shifted) # Time used doesn't matter as we aren't fitting to # recovery curve directly twaits = [0,2,5,10,15,20,25,30,35,40,45,50,75,100,200,300,400,500,600,700,800,900,1000] for v in vsteps_th_depol: protocols.append( recovery(twaits, v, -20, -20, 1000, 1000, 1000) ) conditions.append(cm_conditions) # Create model and simulations m = myokit.load_model(modelfile) ena = m.get('na_conc.E_Na').value() v = m.get('membrane.V') v.demote() v.set_rhs(0) v.set_binding('pace') simulations, times = [], [] for p, c in zip(protocols, conditions): s = myokit.Simulation(m, p) for ci, vi in c.items():
prepulses_recov_taus, recov_taus, sd_recov_taus = data.TauS_Recov_Li() variances_recov_taus = [sd_**2 for sd_ in sd_recov_taus] li_recov_taus_dataset = np.asarray([prepulses_recov_taus, recov_taus, variances_recov_taus]) tpre = 10000 # ms tstep1 = 300 twaits_recov = [2**i for i in range(1,12)] tstep2 = 300 vstep1 = 10 vstep2 = 10 tmp_protocols = [] for v in prepulses_recov_taus: tmp_protocols.append( recovery(twaits_recov, v, vstep1, vstep2, tpre, tstep1, tstep2) ) li_recov_protocol = tmp_protocols[0] tsplit_recov = tmp_protocols[0].characteristic_time() for p in tmp_protocols[1:]: for e in p.events(): li_recov_protocol.add_step(e.level(), e.duration()) tsplits_recov = [t+tstep1+tstep2+tpre for t in twaits_recov] for i in range(len(tsplits_recov)-1): tsplits_recov[i+1] += tsplits_recov[i] 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):
vsteps_th_depol = [v_ + 20 for v_ in vsteps_th_depol] th_depol = [temperature_adjust(th_, 290, 310, Q10) for th_ in th_depol] max_th_depol = np.max(np.abs(th_depol)) th_depol = [th_ / max_th_depol for th_ in th_depol] variances_th_depol = [0.] * len(th_depol) # Protocol creation a little more complicated as multiple recovery protocols # need to be combined. We therefore create the protocols for each depolarisation # potential separately then combine them with a large time gap. twaits = [ 0, 2, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 75, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000 ] tmp_protocols = [] for v in vsteps_th_depol: tmp_protocols.append(recovery(twaits, v, -20, -20, 1000, 1000, 1000)) sakakibara_tauh_depol_protocol = tmp_protocols[0] for p in tmp_protocols[1:]: for e in p.events(): sakakibara_tauh_depol_protocol.add(e) twaits_split = [t + 3000 for t in twaits] for i in range(len(twaits_split) - 1): twaits_split[i + 1] += twaits_split[i] def sakakibara_tauh_depol_sum_stats(data): output = [] def simple_exp(t, tauh): return np.exp(-t / tauh)
description=rao_inact_desc, Q10=None, Q10_factor=0) # # Recovery [Rao2009] # rao_rec_desc = """Recovery curve for iCaL in HL-1 cells from Rao 2009. Measurements taken at room temperature. """ times_rec, rec, sd_rec = data.Rec_Rao() variances_rec = [sd**2 for sd in sd_rec] rao_rec_dataset = np.asarray([times_rec, rec, variances_rec]) rao_rec_protocol = recovery(times_rec, -80, -20, -20, 10000, 400, 400) split_times = [10800 + tw for tw in times_rec] for i, time in enumerate(split_times[:-1]): split_times[i + 1] += split_times[i] def rao_rec_sum_stats(data): pulse_traces = [] for i, time in enumerate(split_times): d_, data = data.split(time) pulse_traces.append( d_.trim(d_['engine.time'][0] + 10000, d_['engine.time'][0] + 10800 + times_rec[i], adjust=True)) output = []
variances_rec_taus = [sd_**2 for sd_ in sd_rec_taus] sakakibara_rec_taus_dataset = np.array( [prepulse_rec, rec_taus, variances_rec_taus]) tpre = 10000 # ms tstep1 = 1000 twaits_rec = [2**i for i in range(1,11)] tstep2 = 1000 vstep1 = -20 vstep2 = -20 vhold = -140 tmp_protocols = [] for v in prepulse_rec: tmp_protocols.append( recovery(twaits_rec,vhold,vstep1,vstep2,tpre,tstep1,tstep2,v) ) sakakibara_rec_protocol = tmp_protocols[0] tsplit_rec = tmp_protocols[0].characteristic_time() for p in tmp_protocols[1:]: for e in p.events(): sakakibara_rec_protocol.add_step(e.level(), e.duration()) tsplits_rec = [t+tstep1+tstep2+tpre for t in twaits_rec] for i in range(len(tsplits_rec)-1): tsplits_rec[i+1] += tsplits_rec[i] def sakakibara_rec_sum_stats(data, fast=True, slow=True): def double_exp(t, tau_r1, tau_r2, A0, A1, A2): return A0-A1*np.exp(-t/tau_r1)-A2*np.exp(-t/tau_r2) output1 = []
prepulse_recov_r2, tau_r2, sd_r2 = dataSch.Recovery_Schneider_tau_r2() variances_r2 = [sd_**2 for sd_ in sd_r2] schneider_taur2_dataset = np.array([prepulse_recov_r2, tau_r2, variances_r2]) tpre = 10000 #ms tstep1 = 200 twaits_recov = [2**i for i in range(1, 11)] tstep2 = 12 vstep1 = -20 vstep2 = -20 vhold = -135 tmp_protocols = [] for v in prepulse_recov_r2: tmp_protocols.append( recovery(twaits_recov, vhold, vstep1, vstep2, tpre, tstep1, tstep2, v)) schneider_recov_protocol = tmp_protocols[0] tsplit_recov = tmp_protocols[0].characteristic_time() for p in tmp_protocols[1:]: for e in p.events(): schneider_recov_protocol.add_step(e.level(), e.duration()) tsplits_recov = [t + tstep1 + tstep2 + tpre for t in twaits_recov] for i in range(len(tsplits_recov) - 1): tsplits_recov[i + 1] += tsplits_recov[i] def schneider_recov_sum_stats(data): def double_exp(t, tau_r1, tau_r2, A0, A1, A2): return A0 - A1 * np.exp(-t / tau_r1) - A2 * np.exp(-t / tau_r2)
We assume the SD is 10% of the given time constants as no error is reported. Two idential depolarizing voltage-clamp pulses from the holding potential were applied to a potential (+20 mV) that activated a large outward current, and the interval between the two pulses was varied. """ prepulses, tau_r, _ = data.Rec_Nygren() sd_taur = 0.1 * np.asarray(tau_r) variances_taur = [sd_**2 for sd_ in sd_taur] nygren_rec_dataset = np.asarray([prepulses, tau_r, variances_taur]) twaits = [2**i for i in range(1, 8)] nygren_rec_protocol = recovery(twaits, prepulses[0], 20, 20, 20000, 100, 100) tsplits_rec = [t + 100 + 100 + 20000 for t in twaits] for i in range(len(tsplits_rec) - 1): tsplits_rec[i + 1] += tsplits_rec[i] def nygren_rec_sum_stats(data): def single_exp(t, tau, A, A0): return A0 - A * np.exp(-t / tau) output = [] timename = 'engine.time' recov = [] for t in tsplits_rec: d_, data = data.split(t)
description=nakajima_desc, Q10=None, Q10_factor=0) # # Recovery [Zhang2013] # zhang_rec_desc = """Recovery curve for iNa in Zhang 2013. Experiments conducted at room temperature. """ tsteps_rec, rec, sd_rec = data.Recovery_Zhang() variances_rec = [sd_**2 for sd_ in sd_rec] zhang_rec_dataset = np.asarray([tsteps_rec, rec, variances_rec]) zhang_rec_protocol = recovery(tsteps_rec, -120, -30, -30, 3000, 20, 20) zhang_conditions = { 'extra.Na_o': 136e3, 'sodium.Na_i': 10e3, 'extra.K_o': 0., # Cs used to avoid contamination 'potassium.K_i': 0., 'phys.T': room_temp } split_times = [3040 + tw for tw in tsteps_rec] for i, time in enumerate(split_times[:-1]): split_times[i + 1] += split_times[i] def zhang_rec_sum_stats(data): dsplit = []
description=nguyen_inact_desc, Q10=None, Q10_factor=0) # # Recovery kinetics [Deng2009] # deng_rec_desc = """Recovery curve in HL-1 from Deng 2009 Fig 4B. Measurements taken at room temperature so no temp adjustment. """ tsteps_rec, rec, sd_rec = data.Rec_Deng() variances_rec = [sd**2 for sd in sd_rec] deng_rec_dataset = np.asarray([tsteps_rec, rec, variances_rec]) deng_rec_protocol = recovery(tsteps_rec, -80, -20, -20, 5000, 300, 300) deng_conditions = { 'extra.Ca_o': 5000, 'calcium.Ca_i': 0.2, # estimated LR1994 'phys.T': room_temp } split_times = [5600 + tw for tw in tsteps_rec] for i, time in enumerate(split_times[:-1]): split_times[i + 1] += split_times[i] def deng_rec_sum_stats(data): pulse_traces = [] for i, time in enumerate(split_times): d_, data = data.split(time)
prepulse_rec_cou_adjust = [v + cou_adjust for v in prepulse_rec] sakakibara_rec_taus_cou_adjust_dataset = np.array( [prepulse_rec_cou_adjust, rec_taus, variances_rec_taus]) tpre = 10000 # ms tstep1 = 1000 twaits_rec = [2**i for i in range(1, 11)] tstep2 = 1000 vstep1 = -20 vstep2 = -20 vhold = -140 tmp_protocols = [] for v in prepulse_rec: tmp_protocols.append( recovery(twaits_rec, vhold, vstep1, vstep2, tpre, tstep1, tstep2, v)) sakakibara_rec_protocol = tmp_protocols[0] tsplit_rec = tmp_protocols[0].characteristic_time() for p in tmp_protocols[1:]: for e in p.events(): sakakibara_rec_protocol.add_step(e.level(), e.duration()) tmp_protocols = [] for v in prepulse_rec_nyg_adjust: tmp_protocols.append( recovery(twaits_rec, vhold + nyg_adjust_inact, vstep1 + nyg_adjust_inact, vstep2 + nyg_adjust_inact, tpre, tstep1, tstep2, v)) sakakibara_rec_nyg_adjust_protocol = tmp_protocols[0] tsplit_rec = tmp_protocols[0].characteristic_time() for p in tmp_protocols[1:]:
no error is reported. The reactivation process was assessed by a paired-pulse protocol consisting of two identical pulses to +50 mV from a holding potential of -60 to +40 mV for 200 ms, at a variety of P1-P2 intervals. """ prepulses, tau_r, _ = data.Rec_Courtemanche() sd_taur = 0.1 * np.asarray(tau_r) variances_taur = [sd_**2 for sd_ in sd_taur] courtemanche_rec_dataset = np.asarray([prepulses, tau_r, variances_taur]) twaits = [2**i for i in range(1, 8)] tmp_protocols = [] for v in prepulses: tmp_protocols.append(recovery(twaits, v, 50, 50, 20000, 200, 200)) courtemanche_rec_protocol = tmp_protocols[0] tsplit_rec = tmp_protocols[0].characteristic_time() for p in tmp_protocols[1:]: for e in p.events(): courtemanche_rec_protocol.add_step(e.level(), e.duration()) tsplits_rec = [t + 200 + 200 + 20000 for t in twaits] for i in range(len(tsplits_rec) - 1): tsplits_rec[i + 1] += tsplits_rec[i] def courtemanche_rec_sum_stats(data): def single_exp(t, tau, A, A0): return A0 - A * np.exp(-t / tau)