def CalcInputR(sec): im = h.Impedance() im.loc(0.5, sec=sec) im.compute(0, 1) # 1st argument: impedance frequency to compute; 2nd argument: when ==1, the calculation considers the effect of differential gating states Rinput = im.input(0.5, sec=sec) return Rinput
def make_seg_df(cell): seg_locs = cell.morphology.seg_coords['p05'] px = seg_locs[0] py = seg_locs[1] pz = seg_locs[2] df = pd.DataFrame() i = 0 j = 0 lens = [] diams = [] bmtk_ids = [] sec_ids = [] full_names = [] xs = [] parts = [] distances = [] elec_distances = [] h.distance(sec=cell.hobj.soma[0]) zz = h.Impedance() zz.loc(cell.hobj.soma[0](0.5)) zz.compute(25, 1) for sec in cell.hobj.all: for seg in sec: lens.append(seg.sec.L) diams.append(seg.sec.diam) distances.append(h.distance(seg)) bmtk_ids.append(i) xs.append(seg.x) fullsecname = sec.name() sec_ids.append(int(fullsecname.split("[")[2].split("]")[0])) sec_type = fullsecname.split(".")[1][:4] parts.append(sec_type) full_names.append(str(seg)) elec_distances.append(zz.ratio(seg)) j += 1 i += 1 df["BMTK ID"] = bmtk_ids df["X"] = xs df["Type"] = parts df["Sec ID"] = sec_ids df["Distance"] = distances df["Section_L"] = lens df["Section_diam"] = diams df["Coord X"] = px df["Coord Y"] = py df["Coord Z"] = pz df["Elec_distance"] = elec_distances df.to_csv("Segments.csv", index=False)
def compare_pas(filename, param_list=None): """Change input resistance by adjusting the passive leak channel. The leak channel has K+, Na+, and Cl- conductances with a set ratio (see config.hoc). Calling h.changePas(<new passive K conductance>) respects the ratio. Saved filenames include the relative change in PAS, the Input Resistance, the steady-state cli (at 0 input), and membrane potential. """ rel_gkpbar = param_list if not rel_gkpbar: rel_gkpbar = [0.8, 1, 1.2, 1.5] print("rel_gkpbar:{}".format(rel_gkpbar)) load_file(filename) # list of (exc,inh) synapses numbers imp = h.Impedance() imp.loc(0.5, sec=h.soma) for p in rel_gkpbar: h.changePas(h.g_pas_k_config*p) vm, cli = get_base_vm_cli(filename, compartment=h.soma) imp.compute(0, 1) # calculate impedance at 0 Hz (i.e. resistance) ir = imp.input(0.5, sec=h.soma) # input resistance at 0.5 print("when p={}, Rm={}, [Cl]i={}, and Vm={}".format(p, ir, cli, vm)) save_run("{}_[{},{:.2f},{:.2f},{:.2f}]".format(filename, p, ir, cli, vm))
def measure_input_impedance_of_subtree(subtree_root_section, frequency): '''measures the input impedance of the subtree with the given root section (at the "0" tip, the soma-proximal end), returns the Impedance hoc object and the input impedance as a complex value ''' imp_obj = h.Impedance() CLOSE_TO_SOMA_EDGE = 0 # sets origin for impedance calculations (soma-proximal end of root section) imp_obj.loc(CLOSE_TO_SOMA_EDGE, sec=subtree_root_section) # computes transfer impedance from every segment in the model in relation # to the origin location above imp_obj.compute(frequency + 1 / 9e9, 0) # in Ohms (impedance measured at soma-proximal end of root section) root_input_impedance = imp_obj.input(CLOSE_TO_SOMA_EDGE, sec=subtree_root_section) * 1000000 root_input_phase = imp_obj.input_phase(CLOSE_TO_SOMA_EDGE, sec=subtree_root_section) # creates a complex impedance value out of the given polar coordinates root_input_impedance = cmath.rect(root_input_impedance, root_input_phase) return imp_obj, root_input_impedance
def test_partrans(): # no transfer targets or sources. mkmodel(4) run() # invalid source or target sid. if 0 in model[0]: cell = model[0][0] s = cell.soma expect_error(pc.source_var, (s(0.5)._ref_v, -1), sec=s) expect_error(pc.target_var, (cell.ic, cell.ic._ref_amp, -1)) # target with no source. if pc.gid_exists(1): cell = pc.gid2cell(1) pc.target_var(cell.ic, cell.ic._ref_amp, 1) expect_error(run, ()) mkmodel(4) # source with no target (not an error). if pc.gid_exists(1): cell = pc.gid2cell(1) pc.source_var(cell.soma(0.5)._ref_v, 1, sec=cell.soma) run() # No point process for target if pc.gid_exists(1): cell = pc.gid2cell(1) pc.target_var(cell.vc._ref_amp3, 1) try: run() # ok if test_fast_imem.py not prior except: pass pc.nthread(2) expect_error(run, ()) # Do not know the POINT_PROCESS target pc.nthread(1) # Wrong sec for source ref and wrong point process for target ref. mkmodel(1) if pc.gid_exists(0): cell = pc.gid2cell(0) sec = h.Section(name="dend") expect_error(pc.source_var, (cell.soma(0.5)._ref_v, 1), sec=sec) expect_error(pc.source_var, (cell.soma(0.5)._ref_nai, 2), sec=sec) del sec expect_error(pc.target_var, (cell.ic, cell.vc._ref_amp3, 1)) # source sid already in use expect_error(pc.source_var, (cell.soma(0.5)._ref_nai, 1), sec=cell.soma) # partrans update: could not find parameter index # pv2node checks the parent mkmodel(1) s1 = h.Section(name="dend") s2 = h.Section(name="soma") ic = h.IClamp(s1(0.5)) pc.source_var(s1(0)._ref_v, rank, sec=s1) pc.target_var(ic, ic._ref_amp, rank) run() assert s1(0).v == ic.amp """ # but following changes the source node and things get screwed up # because of continuing to use a freed Node*. The solution is # beyond the scope of this pull request and would involve replacing # description in terms of Node* with (Section*, arc_position) s1.connect(s2(.5)) run() print(s1(0).v, ic.amp) assert(s1(0).v == ic.amp) """ # non_vsrc_update property disappears from Node* s1.insert("pas") # not allowed to uninsert ions :( pc.source_var(s1(0.5)._ref_e_pas, rank + 10, sec=s1) pc.target_var(ic, ic._ref_delay, rank + 10) run() assert s1(0.5).e_pas == ic.delay s1.uninsert("pas") expect_error(run, ()) teardown() del ic, s1, s2 # missing setup_transfer mkmodel(4) transfer1() expect_error(h.finitialize, (-65, )) # round robin transfer v to ic.amp and vc.amp1, nai to vc.amp2 ncell = 5 mkmodel(ncell) transfer1() init_values() run() check_values() # nrnmpi_int_alltoallv_sparse h.nrn_sparse_partrans = 1 mkmodel(5) transfer1() init_values() run() check_values() h.nrn_sparse_partrans = 0 # impedance error (number of gap junction not equal to number of pc.transfer_var) imp = h.Impedance() if 0 in model[0]: imp.loc(model[0][0].soma(0.5)) expect_error(imp.compute, (1, 1)) del imp # For impedance, pc.target_var requires that its first arg be a reference to the POINT_PROCESS" mkmodel(2) if pc.gid_exists(0): cell = pc.gid2cell(0) pc.source_var(cell.soma(0.5)._ref_v, 1000, sec=cell.soma) cell.hgap[1] = h.HGap(cell.soma(0.5)) pc.target_var(cell.hgap[1], cell.hgap[1]._ref_e, 1001) if pc.gid_exists(1): cell = pc.gid2cell(1) pc.source_var(cell.soma(0.5)._ref_v, 1001, sec=cell.soma) cell.hgap[0] = h.HGap(cell.soma(0.5)) pc.target_var(cell.hgap[0], cell.hgap[0]._ref_e, 1000) pc.setup_transfer() imp = h.Impedance() h.finitialize(-65) if pc.gid_exists(0): imp.loc(pc.gid2cell(0).soma(0.5)) expect_error(imp.compute, (10, 1, 100)) del imp, cell # impedance ncell = 5 mkmodel(ncell) mkgaps(list(range(ncell - 1))) pc.setup_transfer() imp = h.Impedance() h.finitialize(-65) if 0 in model[0]: imp.loc(model[0][0].soma(0.5)) niter = imp.compute(10, 1, 100) if rank == 0: print("impedance iterations=%d" % niter) # tickle execution of target_ptr_update for one more line of coverage. if 0 in model[0]: model[0][0].hgap[1].loc(model[0][0].soma(0)) model[0][0].hgap[1].loc(model[0][0].soma(0.5)) niter = imp.compute(10, 1, 100) del imp # CoreNEURON gap file generation mkmodel(ncell) transfer1() # following is a bit tricky and need some user help in the docs. # cannot be cache_efficient if general sparse matrix solver in effect. cvode = h.CVode() assert cvode.use_mxb(0) == 0 assert cvode.cache_efficient(1) == 1 pc.setup_transfer() h.finitialize(-65) pc.nrncore_write("tmp") # CoreNEURON: one thread empty of gaps mkmodel(1) transfer1() s = h.Section("dend") pc.set_gid2node(rank + 10, rank) pc.cell(rank + 10, h.NetCon(s(0.5)._ref_v, None, sec=s)) pc.nthread(2) pc.setup_transfer() h.finitialize(-65) pc.nrncore_write("tmp") pc.nthread(1) teardown() del s # There are single thread circumstances where target POINT_PROCESS is needed s = h.Section("dend") pc.set_gid2node(rank, rank) pc.cell(rank, h.NetCon(s(0.5)._ref_v, None, sec=s)) pc.source_var(s(0.5)._ref_v, rank, sec=s) ic = h.IClamp(s(0.5)) pc.target_var(ic._ref_amp, rank) pc.setup_transfer() expect_error(h.finitialize, (-65, )) teardown() del ic, s # threads mkmodel(ncell) transfer1() pc.nthread(2) init_values() run() check_values() pc.nthread(1) # extracellular means use v = vm+vext[0] for cell in model[0].values(): cell.soma.insert("extracellular") init_values() run() check_values() teardown()
from neuron import h as nrn # nrn.nrn_load_dll('x86_64/.libs/libnrnmech.so') # nrnivmodl h.mod kdr2.mod kca.mod cad2.mod it2.mod SlowCa.mod hh3.mod km.mod kap.mod nrn.xopen("build_cell.hoc") # nrn.ca_hot_zone() import numpy as np import matplotlib.pylab as plt freq = np.logspace(-1.1, np.log(500.) / np.log(10), 50) imped, phase = 0. * freq, 0. * freq Z = nrn.Impedance(sec=nrn.soma) Z.loc(0.5) for i in range(len(freq)): Z.compute(freq[i], 0.5) imped[i] = Z.input(0.5, sec=nrn.soma) phase[i] = Z.input_phase(0.5, sec=nrn.soma) fig, AX = plt.subplots(1, 2, figsize=(10, 3)) AX[0].loglog(freq, imped) AX[1].semilogx(freq, -phase) plt.show() np.save('data/larkum_imped_data.npy', [freq, imped, phase])
# run over all the compartments in the model h.distance(0,0.5,sec=HCell.soma[0]) num_secs = len([sec for sec in HCell.all ]) bar = progressbar.ProgressBar(max_value=num_secs, widgets=[' [', progressbar.Timer(), '] ', progressbar.Bar(), ' (', progressbar.ETA(), ') ', ]) for jx,sec in enumerate(HCell.all): dend_sref = h.SectionRef(sec = sec) Xs = [seg.x for seg in sec] Xs = Xs + [1] for x in Xs: h.finitialize(V_INIT) dist = h.distance(x,sec=sec) z = h.Impedance() z.loc(x,sec=sec) z.compute(0,1) IR = z.input(x,sec=sec) z.compute(FREQ,1) IMP = z.input(x,sec=sec) SynList = [] ConList = [] HCell.delete_spine() # delete the previous spines SynList,ConList = add_synapse_at_spine(1,dend_sref,x,SynList,ConList) run_and_save_simulation(dend_sref,x,on_spine=True) f_output.write("%g,%g,%g\n"%(IR,IMP,dist)) SynList = [] ConList = []
diam = 10 L = 100/(PI*diam) insert pas g_pas = .001 e_pas = -65 } } endtemplate Cell ''') ncell = 2 cells = {} for gid in range(rank, ncell, nhost): cells[gid] = h.Cell() imp = h.Impedance() if 0 in cells: imp.loc(.5, sec=cells[0].soma) def foo(freq): if rank == 0: print("impedance") # all ranks must participate in the compute imp.compute(freq, 1) for gid in cells: print("cell[%d].soma transfer %g" % (gid, imp.transfer(.5, sec=cells[gid].soma))) if nhost == 1: foo(0) #should print 1000.0 and 0.0
def simulate_single_param(args): """ Simulates a specific input parameter vector :param args: The parameters for the simulation: The list of excitatory presynpatic inputs, The list of inhibitory presynpatic inputs, and the input parameter dictionary :returns: The voltage trace of the simulation """ from neuron import h from neuron import gui h.load_file("nrngui.hoc") h.load_file("import3d.hoc") param_dict = args[0] hoc_code = '''h("create soma") h("access soma") h("nseg = 1") h("L = 20") h("diam = 20") h("insert pas") h("cm = 1") h("Ra = 150") h("forall nseg = 1") h("forall e_pas = -90") h("soma insert Ca_LVAst ") h("soma insert Ca_HVA ") h("soma insert SKv3_1 ") h("soma insert SK_E2 ") h("soma insert K_Tst ") h("soma insert K_Pst ") h("soma insert Nap_Et2 ") h("soma insert NaTa_t") h("soma insert CaDynamics_E2") h("soma insert Ih") h("ek = -85") h("ena = 50") h("gIhbar_Ih = 0.0002") h("g_pas = 1.0 / 12000 ") h("celsius = 36") ''' exec(hoc_code) exec('h("tstop = {}")'.format(simulation_length)) exec('h("v_init = {}")'.format(v_init)) for key in param_dict.keys(): h(key + " = " + str(param_dict[key])) iclamp = h.IClamp(0.5) iclamp.delay = 500 iclamp.dur = 1400 amp = 0.05 iclamp.amp = amp im = h.Impedance() h("access soma") h("nseg = 1") im.loc(0.5) im.compute(0) Ri = im.input(0.5) semitrial_start = time.time() ### Set the protocol h.finitialize() ### Simulate! voltageVector = h.Vector() voltageVector.record(eval("h.soma(0.5)._ref_v")) timeVector = h.Vector() timeVector.record(h._ref_t) h.run() timeVector = np.array(timeVector) voltageVector = np.array(voltageVector) trace = {} trace['T'] = timeVector[4000:] trace['V'] = np.array(voltageVector)[4000:] trace['stim_start'] = [500] trace['stim_end'] = [1900] del voltageVector, timeVector return trace
diam = 10 L = 100/(PI*diam) insert pas g_pas = .001 e_pas = -30 } } endtemplate Cell ''') ncell = 2 cells = {} for gid in range(rank, ncell, nhost): cells[gid] = h.Cell() imp_ = h.Impedance() if 0 in cells: imp_.loc(.5, sec=cells[0].soma) def imp(freq): pc.setup_transfer() h.finitialize(-65) if rank == 0: print ("impedance") # all ranks must participate in the compute iter = imp_.compute(freq, 1) print("freq=%g iter=%g"% (freq, iter)) for gid in cells: print ("cell[%d].soma transfer %g" %(gid, imp_.transfer(.5, sec=cells[gid].soma))) def run(tstop):
def run_model(model, morph_file, path="human_spines_simulations/", file_prefix="simulating_spines_"): print model HCell = create_model(model, morph_file) output_file = path + file_prefix + model + ".txt" f_output = open(output_file, 'w') f_output.write( "Spine,shaft_name,shaft_x,max_soma_v,max_shaft_v,max_spine_v,soma_v_integ,shaft_v_integ,spine_v_integ,ir_shaft,z_shaft,dist_shaft\n" ) # run over all the compartments in the model h.distance(0, 0.5, sec=HCell.soma[0]) num_secs = len([sec for sec in HCell.all]) bar = progressbar.ProgressBar(max_value=num_secs, widgets=[ ' [', progressbar.Timer(), '] ', progressbar.Bar(), ' (', progressbar.ETA(), ') ', ]) for jx, sec in enumerate(HCell.all): dend_sref = h.SectionRef(sec=sec) Xs = [seg.x for seg in sec] Xs = Xs + [1] for x in Xs: h.finitialize(V_INIT) dist = h.distance(x, sec=sec) z = h.Impedance() z.loc(x, sec=sec) z.compute(0, 1) IR = z.input(x, sec=sec) z.compute(FREQ, 1) IMP = z.input(x, sec=sec) SynList = [] ConList = [] HCell.delete_spine() # delete the previous spines SynList, ConList = add_synapse_at_spine(HCell, 1, dend_sref, x, SynList, ConList) run_and_save_simulation(HCell, dend_sref, x, f_output, on_spine=True) f_output.write("%g,%g,%g\n" % (IR, IMP, dist)) HCell.delete_spine() SynList = [] ConList = [] SynList, ConList = add_synapse_at_shaft(HCell, 1, dend_sref, x, SynList, ConList) run_and_save_simulation(HCell, dend_sref, x, f_output, on_spine=False) f_output.write("%g,%g,%g\n" % (IR, IMP, dist)) bar.update(jx) f_output.close()
def test_deleted_sec(): for sec in h.allsec(): h.delete_section(sec=sec) s = h.Section() s.insert("hh") seg = s(0.5) ic = h.IClamp(seg) mech = seg.hh rvlist = [rv for rv in mech] vref = seg._ref_v gnabarref = mech._ref_gnabar sec_methods_ok = set([s.cell, s.name, s.hname, s.same, s.hoc_internal_name]) sec_methods_chk = set( [ getattr(s, n) for n in dir(s) if "__" not in n and type(getattr(s, n)) == type(s.x3d) and getattr(s, n) not in sec_methods_ok ] ) seg_methods_chk = set( [ getattr(seg, n) for n in dir(seg) if "__" not in n and type(getattr(seg, n)) == type(seg.area) ] ) mech_methods_chk = set( [ getattr(mech, n) for n in dir(mech) if "__" not in n and type(getattr(mech, n)) == type(mech.segment) ] ) rv_methods_chk = set( [ getattr(rvlist[0], n) for n in dir(rvlist[0]) if "__" not in n and type(getattr(rvlist[0], n)) == type(rvlist[0].name) ] ) rv_methods_chk.remove(rvlist[0].name) h.delete_section(sec=s) for methods in [sec_methods_chk, seg_methods_chk, mech_methods_chk, rv_methods_chk]: for m in methods: # Most would fail because of no args, but expect a check # for valid section first. words = str(m).split() print("m is " + words[4] + "." + words[2]) expect_err("m()") assert str(s) == "<deleted section>" assert str(seg) == "<segment of deleted section>" assert str(mech) == "<mechanism of deleted section>" expect_err("h.sin(0.0, sec=s)") expect_err("print(s.L)") expect_err("s.L = 100.") expect_err("s.nseg") expect_err("s.nseg = 5") expect_err("print(s.v)") expect_err("print(s.orientation())") expect_err("s.insert('pas')") expect_err("s.insert(h.pas)") expect_err("s(.5)") expect_err("s(.5).v") expect_err("seg.v") expect_err("seg._ref_v") expect_err("s(.5).v = -65.") expect_err("seg.v = -65.") expect_err("seg.gnabar_hh") expect_err("mech.gnabar") expect_err("seg.gnabar_hh = .1") expect_err("mech.gnabar = .1") expect_err("rvlist[0][0]") expect_err("rvlist[0][0] = .1") expect_err("for sg in s: pass") expect_err("for m in seg: pass") expect_err("for r in mech: pass") assert s == s # See https://github.com/neuronsimulator/nrn/issues/1343 if sys.version_info >= (3, 8): expect_err("dir(s)") expect_err("dir(seg)") expect_err("dir(mech)") assert type(dir(rvlist[0])) == list expect_err("help(s)") expect_err("help(seg)") expect_err("help(mech)") help(rvlist[0]) # not an error since it does not access s dend = h.Section() expect_err("dend.connect(s)") expect_err("dend.connect(seg)") # Note vref and gnabarref if used may cause segfault or other indeterminate result assert ic.get_segment() == None assert ic.has_loc() == 0.0 expect_err("ic.get_loc()") expect_err("ic.amp") expect_err("ic.amp = .001") ic.loc(dend(0.5)) assert ic.get_segment() == dend(0.5) imp = h.Impedance() expect_err("imp.loc(seg)") expect_err("h.distance(0, seg)") expect_hocerr(imp.loc, (seg,)) expect_hocerr(h.distance, (0, seg)) del ic, imp, dend locals() return s, seg, mech, rvlist, vref, gnabarref
def simulate_single_param(args): """ Simulates a specific input parameter vector :param args: The parameters for the simulation: The list of excitatory presynpatic inputs, The list of inhibitory presynpatic inputs, and the input parameter dictionary :returns: The voltage trace of the simulation """ from neuron import h from neuron import gui h.load_file("nrngui.hoc") h.load_file("import3d.hoc") E_events_list = args[0] I_events_list = args[1] param_dict = args[2] action_potential_at_soma = pickle.load(open('action_potential_at_soma.pickle', 'rb')) hoc_code = '''h("create soma") h("access soma") h("nseg = 1") h("L = 20") h("diam = 20") h("insert pas") h("cm = 1") h("Ra = 150") h("forall nseg = 1") h("forall e_pas = -90") h("soma insert Ca_LVAst") h("soma insert Ca_HVA") h("soma insert SKv3_1") h("soma insert SK_E2 ") h("soma insert NaTa_t") h("soma insert CaDynamics_E2") h("soma insert Im ") h("soma insert Ih") h("ek = -85") h("ena = 50") h("gIhbar_Ih = 0.0128597") h("g_pas = 1.0 / 12000 ") h("celsius = 36") ''' exec(hoc_code) exec('h("tstop = {}")'.format(simulation_length)) exec('h("v_init = {}")'.format(v_init)) im = h.Impedance() h("access soma") im.loc(0.5) im.compute(0) Ri = im.input(0.5) h("access soma") h("nseg = 1") eSynlist = [] eNetconlist = [] iSynlist = [] iNetconlist = [] E_vcs = [] I_vcs = [] eSynlist.append(h.ProbAMPANMDA2_RATIO(0.5)) eSynlist[-1].gmax = 0.0004 eSynlist[-1].mgVoltageCoeff = 0.08 iSynlist.append(h.ProbUDFsyn2_lark(0.5)) iSynlist[-1].tau_r = 0.18 iSynlist[-1].tau_d = 5 iSynlist[-1].e = - 80 iSynlist[-1].gmax = 0.001 semitrial_start = time.time() for key in param_dict.keys(): if key is not "rate_E" and key is not "rate_I": h(key + " = " + str(param_dict[key])) E_events = np.array(E_events_list)[np.argmin(np.abs(np.array(E_events_list).mean(axis=1) - param_dict["rate_E"] / 1000.0))] I_events = np.array(I_events_list)[np.argmin(np.abs(np.array(I_events_list).mean(axis=1) - param_dict["rate_I"] / 1000.0))] E_vcs_events = [] I_vcs_events = [] E_vcs = h.VecStim() I_vcs = h.VecStim() I_vcs_events.append(h.Vector()) events = np.where(I_events[:])[0] + 100 for event in events: I_vcs_events[-1].append(event) E_vcs_events.append(h.Vector()) events = np.where(E_events[:])[0] + 100 for event in events: E_vcs_events[-1].append(event) eNetconlist = h.NetCon(E_vcs, eSynlist[-1]) eNetconlist.weight[0] = 1 eNetconlist.delay = 0 E_vcs.play(E_vcs_events[-1]) iNetconlist = h.NetCon(I_vcs, iSynlist[-1]) iNetconlist.weight[0] = 1 iNetconlist.delay = 0 I_vcs.play(I_vcs_events[-1]) ### Set the protocol h.finitialize() ### Simulate! prev_voltageVector = h.Vector() prev_voltageVector.record(eval("h.soma(0.5)._ref_v")) prev_timeVector = h.Vector() prev_timeVector.record(h._ref_t) h.tstop = 160 h.run() h.tstop = 200 voltageVector = h.Vector() voltageVector.record(eval("h.soma(0.5)._ref_v")) timeVector = h.Vector() timeVector.record(h._ref_t) # Simulate AP h('''objref clamp soma clamp = new SEClamp(.5) {clamp.dur1 = 1e9 clamp.rs=1e9} ''') active_timeVector = h.Vector(np.arange(0, h.tstop, 0.025)) active_ones = np.array([float(1e9)] * len(active_timeVector)) play_vector = np.array([0.0] * len(active_timeVector)) action_potential_neuron_vector = h.Vector(list(np.maximum(np.array(prev_voltageVector)[int(150 / 0.025) : int(154 / 0.025)], attenuate_action_potential(np.array(np.copy(action_potential_at_soma)), param_dict["percentage_AP"])))) active_ones[int(ap_time / 0.025) : int((ap_time + 4) / 0.025)] = 0.00001 play_vector[int(ap_time / 0.025) : int((ap_time + 4) / 0.025)] = action_potential_neuron_vector active_ones = h.Vector(active_ones) play_vector = h.Vector(play_vector) play_vector.play(h.clamp._ref_amp1, active_timeVector, 0) active_ones.play(h.clamp._ref_rs, active_timeVector, 0) h.run() timeVector = np.array(timeVector) voltageVector = np.array(voltageVector) trace = {} trace['T'] = timeVector[4000:] trace['V'] = np.array(voltageVector)[4000:] h.clamp = None active_ones = None play_vector = None del voltageVector, timeVector, prev_voltageVector, prev_timeVector, action_potential_neuron_vector return trace