def test_syn(): precell = BallStick() postcell = BallStick() nc = precell.connect2target(postcell.synlist[0]) nc.weight[0] = 0.01 nc.delay = 0 stim = h.IClamp(0.5, sec=precell.soma) stim.amp = 0.700 stim.delay = 700 stim.dur = 1000 vec = {} for var in 't', 'pre', 'post': vec[var] = h.Vector() vec['t'].record(h._ref_t) vec['pre'].record(precell.soma(0.5)._ref_v) vec['post'].record(postcell.soma(0.5)._ref_v) cvode = h.CVode() cvode.active(1) h.finitialize(-65) tstop = 2000 while h.t < tstop: h.fadvance() with open("vm.out", "w") as out: for time, vsoma in zip(vec['t'], vec['post']): out.write("%g %g\n" % (time, vsoma)) try: import matplotlib.pyplot as plt plt.plot(vec['t'], vec['pre'], vec['t'], vec['post']) plt.show() except ImportError: pass
def initialize(): global Epas h.celsius = celsius for sec in h.soma: h.distance() for sec in h.allsec(): sec.v = Epas sec.e_pas = Epas sec.insert("pas") sec.e_pas = Epas sec.g_pas = 1/Rm sec.Ra = rall sec.cm = cap sec.gnabar_hh2 = 0 sec.gkbar_hh2 = 0 dist = h.distance(0.5) # sec.gcabar_it2 = gcat_func(dist) sec.gcabar_it2 = gcat for sec in h.soma: sec.gnabar_hh2 = gna sec.gkbar_hh2 = gkdr # sec.gcabar_it2 = 0.1054*gcat sec.gcabar_it2 = gcat h.finitialize() h.fcurrent() cvode.re_init()
def test_cell(): cell = BallStick() stim = h.IClamp(0.5, sec=cell.soma) stim.amp = 0.620 stim.delay = 700 stim.dur = 1000 tm = h.Vector() vm = h.Vector() ca = h.Vector() tm.record(h._ref_t) vm.record(cell.soma(0.5)._ref_v) ca.record(cell.soma(0.5)._ref_cai) cvode = h.CVode() cvode.active(1) h.finitialize(-65) tstop = 2000 while h.t < tstop: h.fadvance() with open("vm.out", "w") as out: for time, vsoma in zip(tm, vm): out.write("%g %g\n" % (time, vsoma)) with open("ca.out", "w") as out: for time, conc in zip(tm, ca): out.write("%g %g\n" % (time, conc)) try: import matplotlib.pyplot as plt plt.plot(tm, vm) plt.show() except ImportError: pass
def initialize(Tdist): global Epas h.celsius = celsius for sec in h.soma: h.distance() for sec in h.allsec(): sec.v = Epas sec.e_pas = Epas sec.insert("pas") sec.e_pas = Epas sec.g_pas = 1/Rm sec.Ra = rall sec.cm = cap sec.gnabar_hh2 = 0 sec.gkbar_hh2 = 0 for seg in sec: if Tdist == 1: seg.gcabar_it2 = gcat if Tdist == 2: seg.gcabar_it2 = gcat * (1 + 0.04 * (h.distance(0) + sec.L * seg.x)) * 0.10539397661220173 for sec in h.soma: sec.gnabar_hh2 = gna sec.gkbar_hh2 = gkdr if Tdist == 1: seg.gcabar_it2 = gcat if Tdist == 2: seg.gcabar_it2 = gcat * 0.10539397661220173 h.finitialize() h.fcurrent() cvode.re_init()
def test_initializer_initialize(self): init = simulator.initializer orig_initialize = init._initialize init._initialize = Mock() h.finitialize(-65) self.assertTrue(init._initialize.called) init._initialize = orig_initialize
def simulate(pool, tstop=1000, vinit=-55): ''' simulation control Parameters ---------- cell: NEURON cell cell for simulation tstop: int (ms) simulation time vinit: int (mV) initialized voltage ''' h.finitialize(vinit) for i in pool: cell = pc.gid2cell(i) balance(cell) if h.cvode.active(): h.cvode.active() else: h.fcurrent() h.frecord_init() h.tstop = tstop h.v_init = vinit pc.set_maxstep(0.5) h.stdinit() pc.psolve(tstop)
def test_initializer_initialize(self): init = simulator.initializer orig_initialize = init._initialize init._initialize = Mock() h.finitialize(-65) init._initialize.assert_called() init._initialize = orig_initialize
def initialise(self, vrest=-65): """ Initialise the model, to launch before each simulations """ for sec in h.allsec(): h.finitialize(vrest, sec) h.fcurrent(sec) h.frecord_init()
def reset(self): """Reset the state of the current network to time t = 0.""" self.running = False self.t = 0 self.tstop = 0 self.t_start = 0 self.segment_counter += 1 h.finitialize()
def go(self): self.set_recording() h.dt = self.dt h.tstop = self.sim_time h.finitialize(-60)#self.v_init) h.init() h.run() self.rec_i = self.rec_ina.to_python()
def ivcurve(mechanism_name, i_type, vmin=-100, vmax=100, deltav=1, transient_time=50, test_time=50, rs=1, vinit=-665): """ Returns the (peak) current-voltage relationship for an ion channel. Args: mechanism_name = name of the mechanism (e.g. hh) i_type = which current to monitor (e.g. ik, ina) vmin = minimum voltage step to test vmax = maximum voltage step to test deltav = increment of voltage transient_time = how long to ignore for initial conditions to stabilize (ms) test_time = duration of the voltage clamp tests (ms) rs = resistance of voltage clamp in MOhm vinit = initialization voltage Returns: i = iterable of peak currents (in mA/cm^2) v = iterable of corresponding test voltages Note: The initialization potential (vinit) may affect the result. For example, consider the Hodgkin-Huxley sodium channel; a large fraction are inactivated at rest. Using a strongly hyperpolarizing vinit will uninactivate many channels, leading to more current. """ from neuron import h import numpy h.load_file('stdrun.hoc') sec = h.Section() sec.insert(mechanism_name) sec.L = 1 sec.diam = 1 seclamp = h.SEClamp(sec(0.5)) seclamp.amp1 = vinit seclamp.dur1 = transient_time seclamp.dur2 = test_time seclamp.rs = rs i_record = h.Vector() i_record.record(sec(0.5).__getattribute__('_ref_' + i_type)) result_i = [] result_v = numpy.arange(vmin, vmax, deltav) for test_v in result_v: seclamp.amp2 = test_v h.finitialize(vinit) h.continuerun(transient_time) num_transient_points = len(i_record) h.continuerun(test_time + transient_time) i_record2 = i_record.as_numpy()[num_transient_points:] baseline_i = i_record2[0] i_record_shift = i_record2 - baseline_i max_i = max(i_record_shift) min_i = min(i_record_shift) peak_i = max_i if abs(max_i) > abs(min_i) else min_i peak_i += baseline_i result_i.append(peak_i) return result_i, result_v
def run_single_simulation(config, interactive): axon = Axon(config) axon.insert_stim(config['stim_position'], config['stim_amplitude'], config['stim_start_time'], config['stim_duration']) # set up recording vectors for python plots and the csv file t = h.Vector() t.record(h._ref_t) num_v_traces = config['num_v_traces'] v_traces = [] for i in range(num_v_traces): v = h.Vector() v.record(axon.section_at_f( # record at num_v_traces points along the axon, equally spaced # from eachother and from the end points (since we don't care # about things like the impedance mismatch at the ends) (i + 1) * 1.0 / (num_v_traces + 1)) (Axon.middle)._ref_v) v_traces.append(v) # set up NEURON plotting code (if we're in an interactive session) if interactive: g = h.Graph() g.size(0, config['integration_time'], -80, 55) for i in range(num_v_traces): g.addvar('v(0.5)', sec=axon.section_at_f((i+1) * 1.0 / (num_v_traces + 1))) # initialize the simulation h.dt = config['max_time_step'] tstop = config['integration_time'] h.finitialize(config['initial_membrane_potential']) h.fcurrent() # run the simulation if interactive: g.begin() while h.t < tstop: h.fadvance() g.plot(h.t) g.flush() else: while h.t < tstop: h.fadvance() # save the data as a csv with open(config['csv_filename'], 'w') as csv_file: # start with a header of the form "t_ms, V0_mV, V1_mv, V2_mV,..." csv_file.write(", ".join( ["t_ms"] + ["V{0}_mV".format(i) for i in range(num_v_traces)] ) + "\n") # write the time and each of the recorded voltages at that time for row in zip(t, *v_traces): csv_file.write(", ".join([str(x) for x in row]) + "\n")
def run(self, v_init=-60, tstop=20000., dt=0.1, cvode=True, ga_use_half=False): ''' Simulates this cell and all desired vectors are recorded. Uses fixed or variable timestep depending on the `cvode=` boolean. Parameters: ---------- v_init : int, float The starting voltage of the simulation. tstop : int, float The maximum time of integration dt : float The desired integration step. cvode : bool Selects variable time step integration. Default is False. ga_use_half : bool Will only use the 2nd have of recordings for GA ''' h.load_file('stdrun.hoc') h.v_init = v_init h.tstop = tstop h.dt = dt #set the recording into the vecs dictionary #the _ref dictionary contain the hoc object attribute references for key in self._ref.keys(): #This makes sure we overwrite any vectors if we already ran a sim if isinstance(self.vecs['time'], np.ndarray): self.vecs[key] = h.Vector() self.vecs[key].record(self._ref[key]) else: self.vecs[key].record(self._ref[key]) if cvode: solver = h.CVode() solver.active(1) h.finitialize(h.v_init) solver.solve(h.tstop) else: h.CVode().active(0) h.finitialize() for t in range(0, int(h.tstop/h.dt)): h.fadvance() for key, val in self.vecs.iteritems(): self.vecs[key] = np.array(val) if ga_use_half: for key, val in self.vecs.iteritems(): self.vecs[key] = val[(val.size)/2:] return self.vecs
def integrate(a, b, c, t): # g.begin() k = 0 h.finitialize() while h.t < tstop: h.fadvance() a[k - 1] = cell.ek b[k - 1] = cell.ko c[k - 1] = cell.ik t[k - 1] = h.dt * (k - 1) k = k + 1
def benchmark_cell(): cell = BallStick() stim = h.IClamp(0.5, sec=cell.soma) stim.amp = 0.700 stim.delay = 0 stim.dur = 1e6 cvode = h.CVode() cvode.active(1) h.finitialize(-65) tstop = 1e6 while h.t < tstop: h.fadvance()
def _pre_run(self): if not self.running: self.running = True local_minimum_delay = self.parallel_context.set_maxstep(self.default_maxstep) if state.vargid_offsets: logger.info("Setting up transfer on MPI process {}".format(state.mpi_rank)) state.parallel_context.setup_transfer() h.finitialize() self.tstop = 0 logger.debug("default_maxstep on host #%d = %g" % (self.mpi_rank, self.default_maxstep )) logger.debug("local_minimum_delay on host #%d = %g" % (self.mpi_rank, local_minimum_delay)) if self.num_processes > 1: assert local_minimum_delay >= self.min_delay, \ "There are connections with delays (%g) shorter than the minimum delay (%g)" % (local_minimum_delay, self.min_delay)
def run(self, simtime): """Advance the simulation for a certain time.""" if not self.running: self.running = True local_minimum_delay = self.parallel_context.set_maxstep(self.default_maxstep) h.finitialize() self.tstop = 0 logger.debug("default_maxstep on host #%d = %g" % (self.mpi_rank, self.default_maxstep )) logger.debug("local_minimum_delay on host #%d = %g" % (self.mpi_rank, local_minimum_delay)) if self.num_processes > 1: assert local_minimum_delay >= self.min_delay, \ "There are connections with delays (%g) shorter than the minimum delay (%g)" % (local_minimum_delay, self.min_delay) self.tstop += simtime logger.info("Running the simulation for %g ms" % simtime) self.parallel_context.psolve(self.tstop)
def go(self, sim_time=None): """ Start the simulation once it's been intialized """ self.set_recording() h.dt = self.dt h.finitialize(self.v_init) neuron.init() if sim_time: neuron.run(sim_time) else: neuron.run(self.sim_time) self.go_already = True
def trivial_ecs(scale): from neuron import h, crxd as rxd import numpy import warnings warnings.simplefilter("ignore", UserWarning) h.load_file('stdrun.hoc') tstop = 10 if scale: #variable step case h.CVode().active(True) h.CVode().event(tstop) else: #fixed step case h.dt = 0.1 sec = h.Section() #NEURON requires at least 1 section # enable extracellular RxD rxd.options.enable.extracellular = True # simulation parameters dx = 1.0 # voxel size L = 9.0 # length of initial cube Lecs = 21.0 # lengths of ECS # define the extracellular region extracellular = rxd.Extracellular(-Lecs/2., -Lecs/2., -Lecs/2., Lecs/2., Lecs/2., Lecs/2., dx=dx, volume_fraction=0.2, tortuosity=1.6) # define the extracellular species k_rxd = rxd.Species(extracellular, name='k', d=2.62, charge=1, atolscale=scale, initial=lambda nd: 1.0 if abs(nd.x3d) <= L/2. and abs(nd.y3d) <= L/2. and abs(nd.z3d) <= L/2. else 0.0) # record the concentration at (0,0,0) ecs_vec = h.Vector() ecs_vec.record(k_rxd[extracellular].node_by_location(0, 0, 0)._ref_value) h.finitialize() h.continuerun(tstop) #run the simulation # compare with previous solution ecs_vec.sub(h.Vector(trivial_ecs_data[scale])) ecs_vec.abs() if ecs_vec.sum() > 1e-9: return -1 return 0
def min_sim(self, TSTOP=100): """ Launch a minimal simulation to test the model and determine its resting potential empirically """ vrec = h.Vector() vrec.record(self.soma(0.5)._ref_v) for sec in h.allsec(): h.finitialize(-65, sec) h.fcurrent(sec) h.frecord_init() while h.t < TSTOP: #Launch a simulation h.fadvance() vrest = np.array(vrec)[-1] return vrest
def init(self): """Set the vm_init from the spin button and prepare the simulator""" if not self.manager.refs.has_key('VecRef') : message = "No vector Created. Create at least one vector to run the simulation" logger.info(message) self.ui.statusbar.showMessage(message, 3500) return False else: v_init = self.ui.vSpinBox.value() # Set the v_init h.v_init = v_init h.finitialize(v_init) h.fcurrent() # Reset the time in the GUI self.ui.time_label.setNum(h.t) return True
def init(self, dt=None, celsius=None, tstop=None, t=None, finit=True): """Initialize the simulation. Parameters ---------- dt : float Optionally sets the simulation time step (in msec) celsius : float Optionally sets the simulation temperature (in degrees C) tstop : float Optionally sets the simulation stop time (in msec) t : float Optionally sets the simulation start time (in msec) finit : bool If True, this method calls NEURON's `finitialize()` routine. See also -------- http://www.neuron.yale.edu/neuron/static/new_doc/simctrl/programmatic.html#finitialize """ self._check_active() self._check_args(finit=bool) if finit and t is not None: raise TypeError("Cannot set t when finit==True.") if dt is not None: self.dt = dt if celsius is not None: self.celsius = celsius if tstop is not None: self.tstop = tstop if t is not None: self.t = t h.dt = self.dt h.celsius = self.celsius h.t = self.t if finit: h.finitialize() self._finitialized = True self.t = h.t
def is_blocked(axon): v = h.Vector() v.record(axon.section_at_x(axon.config['block_test_position']) (Axon.middle)._ref_v) # initialize the simulation h.dt = axon.config['max_time_step'] tstop = axon.config['integration_time'] v_init = axon.config['initial_membrane_potential'] h.finitialize(v_init) h.fcurrent() # run the simulation while h.t < tstop: h.fadvance() if max(v) >= axon.config['block_test_threshold']: return False else: return True
def main(): pkj = h.DSB94() h.dt = 0.02 Vrest = -74 h.celsius = 37 rec={} rec['v'] = h.Vector() rec['t'] = h.Vector() rec['v'].record(pkj.soma(0.5)._ref_v) rec['t'].record(h._ref_t) iclamp = h.IClamp(pkj.soma(0.5)) iclamp.amp = 0.300 iclamp.dur = 1000 iclamp.delay = 0 h.finitialize(Vrest) h.tstop = 700 h.run() plt.plot(rec['t'],rec['v']) plt.show() from ipdb import set_trace set_trace()
def simulate(cell, tstop=1500, vinit=-55): ''' simulation control Parameters ---------- cell: NEURON cell cell for simulation tstop: int (ms) simulation time vinit: int (mV) initialized voltage ''' h.finitialize(vinit) balance(cell) if h.cvode.active(): h.cvode.active() else: h.fcurrent() h.frecord_init() h.tstop = tstop h.v_init = vinit h.run()
def test_pop(): from random import random, choice ncells = 100 cells = [BallStick(random()*0.2+0.9) for i in range(ncells)] nclist = [] for postcell in cells: for i in range(20): precell = choice(cells) nc = precell.connect2target(postcell.synlist[0]) nc.weight[0] = 0.01 nc.delay = 0 nclist.append(nc) splist = [] stims = [] for (i, cell) in enumerate(cells): tvec = h.Vector() idvec = h.Vector() nc = h.NetCon(cell.axon(1)._ref_v, None, sec=cell.axon) nc.record(tvec, idvec, i+1) splist.append([tvec, idvec]) for cell in cells: stim = h.IClamp(0.5, sec=cell.soma) stim.amp = 0.700 stim.delay = 600 + 200*random() stim.dur = 1000 stims.append(stim) #cvode = h.CVode() #cvode.active(1) h.dt = 0.1 h.finitialize(-65) tstop = 2000 while h.t < tstop: h.fadvance() try: import matplotlib.pyplot as plt for spikes in splist: plt.scatter(spikes[0], spikes[1], marker='.') plt.show() except ImportError: pass
def scalar_bistable(rxdstr): if rxdstr == 'rxd': from neuron import rxd else: from neuron import crxd as rxd h.load_file('stdrun.hoc') s = h.Section(name='s') s.nseg = 101 cyt = rxd.Region(h.allsec()) c = rxd.Species(cyt, name='c', initial=lambda node: 1 if 0.4 < node.x < 0.6 else 0, d=1) r = rxd.Rate(c, -c * (1-c)*(0.3-c)) h.finitialize() h.run() #check the results result = h.Vector(c.nodes.concentration) cmpV = h.Vector(scalar_bistable_data[rxdstr]) cmpV.sub(result) cmpV.abs() if cmpV.sum() < 1e-6: sys.exit(0) sys.exit(-1)
def simple(): soma = h.Section() soma.insert('pas') soma.e_pas = -65 #soma.g_pas = 1./200e3 synapse = syn.AMPANMDASynapse(soma, 0.5, 0, 10000) synapse.set_presynaptic_spike_times([100]) h.nmdafactor_AmpaNmda = 0 rec = {} for lbl in 't','vsoma','vapical','vbasal','gampa','gnmda','iampa','inmda': rec[lbl] = h.Vector() rec['t'].record(h._ref_t) rec['vsoma'].record(soma(0.5)._ref_v) rec['gampa'].record(synapse.syn._ref_gampa) rec['gnmda'].record(synapse.syn._ref_gnmda) rec['iampa'].record(synapse.syn._ref_iampa) rec['inmda'].record(synapse.syn._ref_inmda) h.load_file('stdrun.hoc') h.celsius = 35 h.cvode_active(1) h.cvode.maxstep(10) h.tstop = 500 h.finitialize(soma.e_pas) h.run() p.subplot(3,1,1) p.plot(rec['t'],rec['vsoma'],'k',label='Soma') p.subplot(3,1,2) p.plot(rec['t'],np.array(rec['gampa'])*1e3,'k',label='AMPA') p.plot(rec['t'],np.array(rec['gnmda'])*1e3,'r',label='NMDA') p.legend(loc='best') p.ylabel('Conductance (nS)') p.subplot(3,1,3) p.plot(rec['t'],np.array(rec['iampa']),'k',label='AMPA') p.plot(rec['t'],np.array(rec['inmda']),'r',label='NMDA') p.legend(loc='best') p.xlabel('Time (ms)') p.ylabel('Current (nA)') p.show()
def main(par="./params-msn.json", \ sim='vm', \ amp=0.265, \ run=None, \ modulation=1, \ simDur=7000, \ stimDur=900, \ factors=None, \ section=None, \ randMod=None, \ testMode=False, \ target=None, \ chan2mod=['naf', 'kas', 'kaf', 'kir', 'cal12', 'cal13', 'can'] ): print(locals()) # initiate cell cell = MSN(params=par, factors=factors) # set cascade ---- move to MSN def? casc = h.D1_reduced_cascade2_0( 0.5, sec=cell.soma) # other cascades also possible... if target: cmd = 'pointer = casc._ref_' + target exec(cmd) base_mod = SUBSTRATES[target][0] max_mod = SUBSTRATES[target][1] else: pointer = casc._ref_Target1p #Target1p #totalActivePKA (if full cascade used) base_mod = casc.init_Target1p max_mod = 2317.1 # cAMP; init: 38.186016 # set edge of soma as reference for distance h.distance(1, sec=h.soma[0]) # set current injection stim = h.IClamp(0.5, sec=cell.soma) stim.amp = amp stim.delay = 100 stim.dur = stimDur # 2ms 2nA to elicit single AP, following Day et al 2008 Ca dyn # record vectors tm = h.Vector() tm.record(h._ref_t) vm = h.Vector() vm.record(cell.soma(0.5)._ref_v) # substrates pka = h.Vector() pka.record(casc._ref_Target1p) camp = h.Vector() camp.record(casc._ref_cAMP) gprot = h.Vector() gprot.record(casc._ref_D1RDAGolf) #D1RDAGolf gbg = h.Vector() gbg.record(casc._ref_Gbgolf) #Gbgolf # peak n dipp parameters da_peak = 500 # concentration [nM] da_tstart = 1000 # stimulation time [ms] da_tau = 500 # time constant [ms] tstop = simDur # [ms] # all channels to modulate mod_list = ['naf', 'kas', 'kaf', 'kir', 'cal12', 'cal13', 'can'] not2mod = [] #['kaf'] # find channels that should not be modulated for chan in mod_list: if chan not in chan2mod: not2mod.append(chan) # for random modulation: modValues = np.arange(0.1, 2.0, 0.1) ------------------------- if randMod == 1: # new factors every run mod_fact = calc_rand_Modulation(mod_list, range_list=[[0.6,0.8], \ [0.65,0.85], \ [0.78,0.82], \ [0.85,1.25], \ [1.0,2.0], \ [1.0,2.0], \ [0.0,1.0]] ) # keep old factors ''' if run == 0: mod_fact = calc_rand_Modulation(mod_list) else: mod_fact = RES['factors'] ''' else: mod_fact = [0.8, 0.8, 0.8, 1.25, 2.0, 2.0, 0.5] # noormalize factors to target values seen in simulation factors = [] for i, mech in enumerate(mod_list): factor = (mod_fact[i] - 1) / (max_mod - base_mod) #2317.1 factors.append(factor) #print(mech, mod_fact[i], factor) # -------------------------------------------------------- # set pointers for sec in h.allsec(): for seg in sec: # naf and kas is in all sections h.setpointer(pointer, 'pka', seg.kas) h.setpointer(pointer, 'pka', seg.naf) if sec.name().find('axon') < 0: # these channels are not in the axon section h.setpointer(pointer, 'pka', seg.kaf) h.setpointer(pointer, 'pka', seg.cal12) h.setpointer(pointer, 'pka', seg.cal13) h.setpointer(pointer, 'pka', seg.kir) #h.setpointer(pointerc, 'pka', seg.car ) if sec.name().find('soma') >= 0: # can is only distributed to the soma section h.setpointer(pointer, 'pka', seg.can) # synaptic modulation ================================================================ if sim == 'synMod': # draw random modulation factors (intervals given by range_list[[min,max]] glut_f, glut_f_norm = set_rand_synapse(['amp', 'nmd'], base_mod, max_mod, \ range_list=[[0.9,1.6], [0.9,1.6]] ) gaba_f, gaba_f_norm = set_rand_synapse(['gab'], base_mod, max_mod, \ range_list=[[0.6,1.4]] ) syn_fact = glut_f + gaba_f I_d = {} ns = {} nc = {} Syn = {} for sec in h.allsec(): if sec.name().find('dend') >= 0: # create a glut synapse make_random_synapse(ns, nc, Syn, sec, 0.5, \ NS_interval=1000.0/17.0, \ NC_conductance=0.15e-3, \ S_tau_dep=100 ) # create a gaba synapse make_random_synapse(ns, nc, Syn, sec, 0.0, \ Type='tmgabaa', \ NS_interval=1000.0/4.0, \ NC_conductance=0.45e-3 ) # set pointer(s) h.setpointer(pointer, 'pka', Syn[sec]) h.setpointer(pointer, 'pka', Syn[sec.name() + '_gaba']) # set (random?) modulation Syn[sec].base = base_mod #randMod? if randMod == 1: Syn[sec].f_ampa = glut_f_norm[0] Syn[sec].f_nmda = glut_f_norm[1] else: Syn[sec].f_ampa = 0 Syn[sec].f_nmda = 0 if randMod == 2: Syn[sec.name() + '_gaba'].base = base_mod Syn[sec.name() + '_gaba'].f_gaba = gaba_f_norm[0] else: Syn[sec.name() + '_gaba'].f_gaba = 0 ''' # record synaptic current from synapse I_d[sec.name()] = h.Vector() I_d[sec.name()].record(Syn[sec]._ref_i) I_d[sec.name()+'_gaba'] = h.Vector() I_d[sec.name()+'_gaba'].record(Syn[sec.name()+'_gaba']._ref_i) ''' elif sec.name().find('axon') >= 0: continue if randMod == 1: for seg in sec: for mech in seg: if mech.name() in not2mod: mech.factor = 0.0 print(mech.name(), 'and channel:', not2mod, mech.factor, sec.name()) elif mech.name() in mod_list: mech.base = base_mod index = mod_list.index(mech.name()) mech.factor = factors[index] # dynamical modulation elif sim == 'modulation': print('inne ', sim) for sec in h.allsec(): for seg in sec: for mech in seg: # if this first statement is active the axon will not be modulated '''if sec.name().find('axon') >= 0 \ and mech.name() in mod_list: mech.factor = 0.0 print(sec.name(), seg.x, mech.name() )''' if mech.name() in not2mod: mech.factor = 0.0 print(mech.name(), 'and channel:', not2mod, mech.factor, sec.name()) elif mech.name() in mod_list: mech.base = base_mod index = mod_list.index(mech.name()) mech.factor = factors[index] # static modulation elif sim == 'directMod': print('inne ', sim) for sec in h.allsec(): for seg in sec: for mech in seg: if mech.name() in mod_list: if sec.name().find( 'axon' ) < 10: # 0 no axon modulated; 10 all sections factor = mod_fact[mod_list.index(mech.name())] if mech.name() in not2mod: mech.factor = 0.0 elif mech.name()[0] == 'c': pbar = mech.pbar mech.pbar = pbar * factor #print(''.join(['setting pbar ', mech.name(), ' ', str(factor) ]) ) else: gbar = mech.gbar mech.gbar = gbar * factor #if seg.x < 0.2: #print(''.join(['setting gbar ', mech.name(), ' ', str(factor), ' ', str(gbar), ' ', str(factor*gbar) ]) ) else: print(sec.name(), seg.x, sec.name().find('axon')) # solver------------------------------------------------------------------------------ cvode = h.CVode() h.finitialize(cell.v_init) # run simulation while h.t < tstop: if modulation == 1: if h.t > da_tstart: # set DA and ACh values (using alpha function) casc.DA = alpha(da_tstart, da_peak, da_tau) #casc.ACh = ach_base - alpha(ach_tstart, ach_base, ach_tau) h.fadvance() # save output if sim in ['vm', 'directMod', 'modulation', 'synMod']: if testMode: mod_fact = mod_fact + syn_fact ID = '' for i, mech in enumerate(mod_list + syn_mod): ID = ID + mech + str(int(mod_fact[i] * 100)) save_vector(tm, vm, ''.join(['./spiking_', str(run), '_', ID, '.out'])) names = ['Target1p', 'cAMP', 'Gbgolf', 'D1RDAGolf'] data = {} for i, substrate in enumerate([pka, camp, gbg, gprot]): save_vector(tm, substrate, './substrate_' + names[i] + '.out') print(min(substrate), max(substrate)) data[names[i]] = [min(substrate), max(substrate)] print(ID) with open('substrates.json', 'w') as outfile: json.dump(data, outfile) #for key in I_d: #save_vector(tm, I_d[key], ''.join(['./I_', key, '_', str(run), '.out']) ) spikes = getSpikedata_x_y(tm, vm) RES[run] = {'factors': mod_fact + syn_fact, 'spikes': spikes}
cell1_X = h.Vector() cell1_X.record(cell1(0.5)._ref_xi) cell1_Xorg = h.Vector() cell1_Xorg.record(Xorg.nodes(cell1)(0.5)[0]._ref_concentration) cell1V = h.Vector() cell1V.record(cell1(0.5)._ref_v) cell2_X = h.Vector() cell2_X.record(cell2(0.5)._ref_xi) cell2_Xorg = h.Vector() cell2_Xorg.record(Xorg.nodes(cell2)(0.5)[0]._ref_concentration) cell2V = h.Vector() cell2V.record(cell2(0.5)._ref_v) # run and plot the results h.finitialize(-65) h.continuerun(1000) """ fig = pyplot.figure() pyplot.subplot(2, 2, 1) pyplot.plot(t_vec,cell1_X, label='cyt') pyplot.plot(t_vec,cell1_Xorg, label='org') pyplot.legend() pyplot.xlabel('t (ms)') pyplot.ylabel('cell 1 x (mM)') pyplot.subplot(2, 2, 2) pyplot.plot(t_vec,cell2_X, label='cyt') pyplot.plot(t_vec,cell2_Xorg, label='org') pyplot.xlabel('t (ms)') pyplot.ylabel('cell 2 x (mM)')
def simulate(tau_facil, tau_rec, stim_freq, celltype, tau_1=0.3, tau_2=0.6, u0=0.078, sampling_interval=0.5, v_clamp=-70.42, sec='proxd'): """Simulates a frequency stimulation of the tmgexp2syn meachnism onto a neuron and measure the conductance at the soma. Parameters ---------- tau_facil : numeric facilitation time constant of the tmgexp2syn mechanism tau_rec : numeric recovery time constant of the tmgexp2syn mechanism stim_freq : numeric stimulation frequency in Hz celltype : ouropy.GenNeuron A class that inherits from ouropy.GenNeuron tau_1 : numeric Synaptic rise time tau_2 : numeric Synaptic decay time u0 : float The u0 parameters as specified in tmgexp2syn sampling_interval : numeric The sampling interval in ms v_clamp : numeric Holding potential of the Returns ------- peaks_norm : ndarray Peak conductances normalized to first peak garr_norm : ndarray Conductance array normalized to first peak """ # Resolve simulation hyperparameters left_pad, right_pad = 50, 100 # in ms simdur = left_pad + right_pad + 10 * (1000 / stim_freq) # Create cell mycell = celltype() # Create synapse syn = h.tmgexp2syn(mycell.get_segs_by_name(sec)[0](0.5)) syn.tau_1 = tau_1 syn.tau_2 = tau_2 syn.tau_facil = tau_facil syn.tau_rec = tau_rec syn.u0 = u0 syn.e = 0 # Create stimulation stim_period_ms = 1000 / stim_freq stim = h.NetStim() stim.interval = stim_period_ms stim.start = left_pad stim.number = 10 nc = h.NetCon(stim, syn) nc.weight[0] = 0.001 # Create voltage clamp c = h.SEClamp(mycell.soma(0.5)) c.dur1 = simdur c.amp1 = v_clamp c.rs = 0.1 # Create recording vector ivec = h.Vector() ivec.record(c._ref_i) # Start simulation sample_period_ms = sampling_interval h.cvode.active(0) h.finitialize(-70.42) h.t = -2000 h.secondorder = 0 h.dt = 10 while h.t < -100: h.fadvance() h.secondorder = 0 h.t = 0 h.dt = sample_period_ms h.steps_per_ms = 1.0 / h.dt h.frecord_init() # Necessary after changing t to restart the vectors while h.t < simdur: h.fadvance() # Get Peaks from output iarr = np.array(ivec) garr = (iarr - iarr[0:50].mean()) / v_clamp stim_dtp = int(np.around(stim.interval / sampling_interval)) pad_dtp = int(left_pad / sampling_interval) t_stim = np.arange(pad_dtp, stim_dtp * 11 + pad_dtp, stim_dtp) #dtp_stim = np.array(t_stim / sampling_interval, dtype=np.int) dtp_stim = np.array(t_stim, dtype=np.int) gvec_split = np.array(np.split(garr, dtp_stim)[1:-1]) peaks = gvec_split.max(axis=1) peaks_norm = peaks / peaks[0] garr_norm = garr / peaks[0] return peaks_norm, garr_norm
def measure_gap_junction_coupling (env, template_class, tree, v_init, cell_dict={}): h('objref gjlist, cells, Vlog1, Vlog2') pc = env.pc h.cells = h.List() h.gjlist = h.List() cell1 = cells.make_neurotree_cell (template_class, neurotree_dict=tree) cell2 = cells.make_neurotree_cell (template_class, neurotree_dict=tree) h.cells.append(cell1) h.cells.append(cell2) ggid = 20000000 source = 10422930 destination = 10422670 weight = 5.4e-4 srcsec = int(cell1.somaidx.x[0]) dstsec = int(cell2.somaidx.x[0]) stimdur = 500 tstop = 2000 pc.set_gid2node(source, int(pc.id())) nc = cell1.connect2target(h.nil) pc.cell(source, nc, 1) soma1 = list(cell1.soma)[0] pc.set_gid2node(destination, int(pc.id())) nc = cell2.connect2target(h.nil) pc.cell(destination, nc, 1) soma2 = list(cell2.soma)[0] stim1 = h.IClamp(soma1(0.5)) stim1.delay = 250 stim1.dur = stimdur stim1.amp = -0.1 stim2 = h.IClamp(soma2(0.5)) stim2.delay = 500+stimdur stim2.dur = stimdur stim2.amp = -0.1 log_size = old_div(tstop,h.dt) + 1 h.tlog = h.Vector(log_size,0) h.tlog.record (h._ref_t) h.Vlog1 = h.Vector(log_size) h.Vlog1.record (soma1(0.5)._ref_v) h.Vlog2 = h.Vector(log_size) h.Vlog2.record (soma2(0.5)._ref_v) gjpos = 0.5 neuron_utils.mkgap(env, cell1, source, gjpos, srcsec, ggid, ggid+1, weight) neuron_utils.mkgap(env, cell2, destination, gjpos, dstsec, ggid+1, ggid, weight) pc.setup_transfer() pc.set_maxstep(10.0) h.stdinit() h.finitialize(v_init) pc.barrier() h.tstop = tstop pc.psolve(h.tstop)
rval = -1 return rval _callback = nonvint_block_prototype(nonvint_block) def activate_callback(activate): if (activate): set_nonvint_block(_callback) else: unset_nonvint_block(_callback) if __name__ == '__main__': exec(test) # see above string s = h.Section() print("fixed step finitialize") h.finitialize(0) print("fixed step fadvance") h.fadvance() h.load_file('stdgui.hoc') print("cvode active") h.cvode_active(1) print("cvode step finitialize") h.finitialize(0) print("cvode fadvance") h.fadvance()
def main( cell_type=None, mdl_ID=0 ): modeldir = './Striatal_network_models/{}/{}'.format(cell_type, cells_dirs[cell_type][mdl_ID]) par = '{}/parameters_with_modulation.json'.format(modeldir) mech = '{}/mechanisms.json'.format(modeldir) protocols = '{}/protocols.json'.format(modeldir) morphology = glob.glob(modeldir+'/*.swc')[0] # ONLY 1 swc file / model allowed. # initiate cell cell = build.CELL( params=par, mechanisms=mech, morphology=morphology, replace_axon=True, N=40.0, ffactor=ffactor ) # ADD SPINES---- SPINES = {} ID = 0 for sec in cell.dendlist: SPINES[sec.name()] = {} for i,seg in enumerate(sec): for j in range(10): SPINES[sec.name()][ID] = spine.Spine(h,sec,seg.x) ID += 1 print(ID) #return [1,1] #h.topology() # THIS PART IS OPTIONAL oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo # set input here # set current injection with open(protocols) as file: prot = json.load(file) # select first spiking prot all_keys = sorted(prot.keys()) key = all_keys[0] i=1 while 'sub' in key: key = all_keys[i] i += 1 print(key) stim = h.IClamp(0.5, sec=cell.soma) s0 = h.IClamp(0.5, sec=cell.soma) for stim_prot, stimuli, j in zip(prot[key]['stimuli'], [stim,s0], [0,1]): stimuli.amp = stim_prot['amp'] stimuli.delay = [200,0][j] stimuli.dur = stim_prot['duration'] # oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo # record vectors: set recordings here tm = h.Vector() tm.record(h._ref_t) vm = h.Vector() vm.record(cell.soma(0.5)._ref_v) tstop = 600 # sim time (ms) h.finitialize(cell.v_init) # run simulation while h.t < tstop: h.fadvance() # save output ------------------------------------------------------------------------ time = tm.to_python() voltage = vm.to_python() return [time, voltage]
# record currents inaf = h.Vector().record(soma(0.5)._ref_ina_naf) ikdr = h.Vector().record(soma(0.5)._ref_ik_kdr) isk = h.Vector().record(soma(0.5)._ref_ik_sk) inal = h.Vector().record(soma(0.5)._ref_ina_nal) ika = h.Vector().record(soma(0.5)._ref_ik_ka) ibk = h.Vector().record(soma(0.5)._ref_ik_bk) iih = h.Vector().record(soma(0.5)._ref_ih_ih) #ica = h.Vector().record(soma(0.5)._ref_ica) ican = h.Vector().record(soma(0.5)._ref_ica_can) icar = h.Vector().record(soma(0.5)._ref_ica_car) # record intracellular ca #caDat = h.Vector().record(ca.nodes[0]._ref_concentration) h.finitialize(-55) h.continuerun(1000) # plots plt.subplot(3, 1, 1) plt.plot(t, v) plt.ylabel('v (mV)') plt.subplot(3, 1, 2) plt.plot(t, inaf) plt.plot(t, ikdr) plt.plot(t, isk) plt.plot(t, inal) plt.plot(t, ika) plt.plot(t, ibk) plt.plot(t, iih)
def run(tstop): pc.set_maxstep(10) h.finitialize() pc.psolve(tstop)
def _simulate_single_trial(neuron_net, trial_idx): """Simulate one trial.""" from .dipole import Dipole global _PC, _CVODE h.load_file("stdrun.hoc") rank = _get_rank() nhosts = _get_nhosts() # Now let's simulate the dipole _PC.barrier() # sync for output to screen if rank == 0: print("running trial %d on %d cores" % (trial_idx + 1, nhosts)) # Set tstop before instantiating any classes h.tstop = neuron_net.net.params['tstop'] h.dt = neuron_net.net.params['dt'] # simulation duration and time-step h.celsius = neuron_net.net.params['celsius'] # 37.0 - set temperature times = neuron_net.net.cell_response.times # sets the default max solver step in ms (purposefully large) _PC.set_maxstep(10) # initialize cells to -65 mV, after all the NetCon # delays have been specified h.finitialize() def simulation_time(): print('Simulation time: {0} ms...'.format(round(h.t, 2))) if rank == 0: for tt in range(0, int(h.tstop), 10): _CVODE.event(tt, simulation_time) h.fcurrent() # initialization complete, but wait for all procs to start the solver _PC.barrier() # actual simulation - run the solver _PC.psolve(h.tstop) _PC.barrier() # these calls aggregate data across procs/nodes neuron_net.aggregate_data() _PC.allreduce(neuron_net.dipoles['L5_pyramidal'], 1) _PC.allreduce(neuron_net.dipoles['L2_pyramidal'], 1) # aggregate the currents and voltages independently on each proc vsoma_list = _PC.py_gather(neuron_net._vsoma, 0) isoma_list = _PC.py_gather(neuron_net._isoma, 0) # combine spiking data from each proc spike_times_list = _PC.py_gather(neuron_net._spike_times, 0) spike_gids_list = _PC.py_gather(neuron_net._spike_gids, 0) # only rank 0's lists are complete if rank == 0: for spike_vec in spike_times_list: neuron_net._all_spike_times.append(spike_vec) for spike_vec in spike_gids_list: neuron_net._all_spike_gids.append(spike_vec) for vsoma in vsoma_list: neuron_net._vsoma.update(vsoma) for isoma in isoma_list: neuron_net._isoma.update(isoma) _PC.barrier() # get all nodes to this place before continuing dpl_data = np.c_[np.array(neuron_net.dipoles['L2_pyramidal'].to_python()) + np.array(neuron_net.dipoles['L5_pyramidal'].to_python()), np.array(neuron_net.dipoles['L2_pyramidal'].to_python()), np.array(neuron_net.dipoles['L5_pyramidal'].to_python())] dpl = Dipole(times, dpl_data) return dpl
def run_model(cell_index, ci): # 1s low input; 0.3s ramping input; 0.2s high input tstop = 1500 modOnTime = 1000 nbg = 5 tau = 300 conditions = ['ACh+DA', 'ACh', 'DA', 'ctrl'] c = conditions[ci] # channel distribution parameter library path = '../Libraries' with open('{}/D2_34bestFit_updRheob.pkl'.format(path), 'rb') as f: model_sets = pickle.load(f, encoding="latin1") parameters = model_sets[cell_index]['variables'] par = '../params_iMSN.json' morphology = '../Morphologies/WT-dMSN_P270-20_1.02_SGA1-m24.swc' cell = build.MSN( params=par, \ morphology=morphology, \ variables=parameters ) # record vectors tm = h.Vector() vm = h.Vector() tm.record(h._ref_t) vm.record(cell.soma(0.5)._ref_v) # transient to play transient = h.Vector([ use.alpha(ht, modOnTime, 1, tau) if ht >= modOnTime else 0 for ht in np.arange(0, tstop, h.dt) ]) # result dict res = {} for i in range(20): res[i] = {} # draw random factors modulation_DA = { 'intr': { 'naf': np.random.uniform(0.95, 1.1), 'kaf': np.random.uniform(1.0, 1.1), 'kas': np.random.uniform(1.0, 1.1), 'kir': np.random.uniform(0.8, 1.0), 'can': np.random.uniform(0.9, 1.0), 'car': np.random.uniform(0.6, 0.8), 'cal12': np.random.uniform(0.7, 0.8), 'cal13': np.random.uniform(0.7, 0.8) }, 'syn': { 'NMDA': np.random.uniform(0.85, 1.05), 'AMPA': np.random.uniform(0.7, 0.9), 'GABA': np.random.uniform(0.90, 1.1) } } modulation_ACh = { 'intr': { 'naf': np.random.uniform(1.0, 1.2), 'kir': np.random.uniform(0.5, 0.7), 'can': np.random.uniform(0.65, 0.85), 'cal12': np.random.uniform(0.3, 0.7), 'cal13': np.random.uniform(0.3, 0.7), 'Im': np.random.uniform(0.0, 0.4) }, 'syn': { 'NMDA': np.random.uniform(1.0, 1.05), 'AMPA': np.random.uniform(0.99, 1.01), 'GABA': np.random.uniform(0.99, 1.01) } } res[i][ci] = {'factors': {'da': modulation_DA, 'ach': modulation_ACh}} # ACh factor sets used == 0 and 2 (since giving less inward rectification and higher excitability) V = {} for key in modulation_ACh['intr']: V[key] = transient for key in ['glut', 'gaba']: V[key] = transient # Master seed -> reset for all factor combinations #np.random.seed(seed=1000) # TODO no seed... will bg be different over workers? # set bg (constant+ramping). fgaba = 24.0 Syn, nc, ns, mapper = use.set_ramping_stimuli(cell, [], low=modOnTime, high=modOnTime + tau) RAMP = {'s': Syn.copy(), 'nc': nc.copy(), 'ns': ns.copy} Syn, nc, ns = use.set_bg_noise(cell, fglut=12.0, fgaba=fgaba) # Clean DA = modulate.DA(cell, modulation_DA['intr'], modulation='uniform', play=V, syn_dict=modulation_DA['syn']) ACh = modulate.ACh(cell, modulation_ACh['intr'], shift_kaf=0, play=V, syn_dict=modulation_ACh['syn']) for bg in range(nbg): print(cell_index, c, bg) # finalize and run h.finitialize(-80) while h.t < tstop: h.fadvance() # downsample data and store in array if not 'time' in res: res['time'] = [t for ind, t in enumerate(tm) if ind % 4 == 0] res[i][bg] = [vm[ind] for ind, t in enumerate(tm) if ind % 4 == 0] # save with open( 'inVivo_ramping_{}_{}_model{}.json'.format(conditions[ci], tag, cell_index), 'wt') as f: json.dump(res, f, indent=4)
weight=args.gmax) if args.rec <= 0: rec = [(n, data['orig']) for n, data in g.nodes(data=True) if data['orig'] is not None] else: rec = [(n, g.nodes[n]['orig']) for n in nu.select_good_nodes_by_sid( g, stype_node_map.keys(), [args.rec] * len(stype_node_map))] syn = zip(synnodes, synsecs) rec = list(set(rec + syn)) recnodes, recsecs = zip(*rec) h.tstop = t_stop t_vec = h.Vector(np.arange(0, h.tstop, 10 * h.dt)) # Record data tabs = [nu.setup_recording(sec, field='v', t=t_vec) for sec in recsecs] ts = datetime.now() h.finitialize(args.Em) h.fcurrent() while h.t < h.tstop: h.fadvance() # h.run() sys.stdout.flush() te = datetime.now() delta = te - ts print('Time for', h.tstop * 1e-3, 's simulation =', delta.days * 86400 + delta.seconds + 1e-6 * delta.microseconds) if args.outfile == '': outfilename = 'data/Vm_inhpoisson_stim_series_{}.h5'.format( ts.strftime('%Y%m%d_%H%M%S')) else: outfilename = args.outfile with h5.File(outfilename) as fd:
chans = {'nav1.7': ['a1p7', 'b1p7', 'c1p7'], 'nav1.8': ['a1p8', 'b1p8', 'c1p8']} traces = ['minf', 'mtau', 'hinf', 'htau'] data = {} for nav in chans: for chan in chans[nav]: data[chan] = {} for trace in traces: data[chan][trace] = [] soma.insert(chan) vs = np.linspace(-70,30,100) for v in vs: h.finitialize(v) data['a1p7']['minf'].append(getval( soma(0.5), 'a1p7', 'minf') data['a1p7']['mtau'].append(soma(0.5).a1p7.mtau) data['a1p7']['hinf'].append(soma(0.5).a1p7.hinf) data['a1p7']['htau'].append(soma(0.5).a1p7.htau) data['a1p8']['minf'].append(soma(0.5).a1p8.minf) data['a1p8']['mtau'].append(soma(0.5).a1p8.mtau) data['a1p8']['hinf'].append(soma(0.5).a1p8.hinf) data['a1p8']['htau'].append(soma(0.5).a1p8.htau) data['b1p7']['minf'].append(soma(0.5).b1p7.minf) data['b1p7']['mtau'].append(soma(0.5).b1p7.mtau) data['b1p7']['hinf'].append(soma(0.5).b1p7.hinf) data['b1p7']['htau'].append(soma(0.5).b1p7.htau)
def run(tstop): spiketime.resize(0) gidvec.resize(0) pc.set_maxstep(10) h.finitialize() pc.psolve(tstop)
def plot_voltage(self, ax=None, delay=2, duration=100, dt=0.2, amplitude=1, show=True): """Plot voltage on soma for an injected current Parameters ---------- ax : instance of matplotlib axis | None An axis object from matplotlib. If None, a new figure is created. delay : float (in ms) The start time of the injection current. duration : float (in ms) The duration of the injection current. dt : float (in ms) The integration time step amplitude : float (in nA) The amplitude of the injection current. show : bool Call plt.show() if True. Set to False if working in headless mode (e.g., over a remote connection). """ import matplotlib.pyplot as plt from neuron import h h.load_file('stdrun.hoc') soma = self.soma h.tstop = duration h.dt = dt h.celsius = 37 iclamp = h.IClamp(soma(0.5)) iclamp.delay = delay iclamp.dur = duration iclamp.amp = amplitude v_membrane = h.Vector().record(self.soma(0.5)._ref_v) times = h.Vector().record(h._ref_t) print('Simulating soma voltage') h.finitialize() def simulation_time(): print('Simulation time: {0} ms...'.format(round(h.t, 2))) for tt in range(0, int(h.tstop), 10): h.CVode().event(tt, simulation_time) h.continuerun(duration) print('[Done]') if ax is None: fig, ax = plt.subplots(1, 1) ax.plot(times, v_membrane) ax.set_xlabel('Time (ms)') ax.set_ylabel('Voltage (mV)') if show: plt.show()
def setup_transfer_verify(): if rank == 0: print("setup_transfer_verify") h.finitialize(-65) frac = rank2frac(rank) for sec in h.allsec(): sec.v = -1 - frac for seg in src2sids: seg.v = src2sids[seg][0] + frac for tar in tar2sid: tar.vgap = -2.0 # do the parallel transfer h.finitialize() # note that FInitializeHandlers may destroy v but the transfer takes place # before any callback except type 3. So all the targets should have proper # value of firstsrcsid.rank # test 0. No transferred values are negative for tar in tar2sid: if tar.vgap < 0.0: print(("%d %s sid=%d vgap=%g" % (rank, tar.hname(), tar2sid[tar], tar.vgap))) raise RuntimeError # test 1. All the transferred values make sense in terms of rank for tar in tar2sid: if frac2rank(tar.vgap) >= nhost: print(("%d %s has invalid rank code %d with value %g" % (rank, tar.hname(), frac2rank(tar.vgap), tar.vgap))) raise RuntimeError # test 2. All the targets for a given sid should have the same value for sid in sid2tars: x0 = sid2tars[sid][0].vgap for tar in sid2tars[sid]: if tar.vgap != x0: print(("%d %s %g != %g %s" % (rank, sid2tars[sid][0].hname(), x0, tar.vgap, tar.hname()))) raise RuntimeError # test 3. Send sid and vgap's sid back to rank it came from and verify on # the source rank that those sid's exist and have the same source # Because of test 2, only need to test first target of an sid data = [None] * nhost for sid, segs in list(sid2tars.items()): r, ssid = decode_vgap_val(segs[0].vgap) if data[r] == None: data[r] = [] data[r].append((sid, ssid)) # pr(data, 'source') data = pc.py_alltoall(data) # pr(data, 'destination') for r, x in enumerate(data): if x: for pair in x: for sid in pair: if sid not in sid2src: print(( "%d target sid %d from %d not associated with source here" % (rank, sid, r))) raise RuntimeError
def initialize(): h.finitialize() h.run()
for run in runs: nw = net_tunedrev.TunedNetwork(10000, temporal_patterns[0 + run:24 + run], PP_to_GCs[0 + run:24 + run], PP_to_BCs[0 + run:24 + run]) # Attach voltage recordings to all cells nw.populations[0].voltage_recording(range(2000)) nw.populations[1].voltage_recording(range(60)) nw.populations[2].voltage_recording(range(24)) nw.populations[3].voltage_recording(range(24)) # Run the model """Initialization for -2000 to -100""" h.cvode.active(0) dt = 0.1 h.steps_per_ms = 1.0 / dt h.finitialize(-60) h.t = -2000 h.secondorder = 0 h.dt = 10 while h.t < -100: h.fadvance() h.secondorder = 2 h.t = 0 h.dt = 0.1 """Setup run control for -100 to 1500""" h.frecord_init() # Necessary after changing t to restart the vectors while h.t < 600: h.fadvance() print("Done Running")
def setup_sim(self): h.dt = self.simParams.dt h.tstop = self.simParams.tstop h.celsius = self.simParams.celsius h.finitialize(self.simParams.v_init)
syn.onset = 5.0 syn.tau = 0.1 syn.gmax = 0.05 cvode = h.CVode() cvode.active(1) cvode.atol(1.0e-5) a = [] b = np.zeros(4) dt = 0.01 tstop = 20 v_init = -65 h.finitialize(v_init) while h.t < tstop: cvode.solve() #cvode.solve() -> calculate by defalt steps | cvode.solve(h.t+dt) -> calculate by dt steps b[0] = h.t b[1] = soma(0.5).v b[2] = ap_dend(0.1).v b[3] = ap_dend(0.9).v print '%lf,%lf,%lf,%lf' %(b[0],b[1],b[2],b[3]) a.append(copy.deepcopy(b)) a=np.array(a) print 'Calculation Complete.' for i in range(1,4): plt.plot(a[:,0],a[:,i]) plt.xlim([0,tstop]) plt.ylim([-100,100])
self.somaV = h.Vector() self.somaV.record(self.soma(0.5)._ref_v, rec) # Randomly distribute the neurons all_neurons = [ Neuron( (numpy.random.random() * 2.0 - 1.0) * (Lx / 2.0), (numpy.random.random() * 2.0 - 1.0) * (Ly / 2.0), (numpy.random.random() * 2.0 - 1.0) * (Lz / 2.0), 100, ) for i in range(0, Ncell) ] # initialize and set the intracellular concentrations h.finitialize(-70) h.dt = 1 # use a large time step as we are not focusing on spiking behaviour # but on slower diffusion h.continuerun(100) if __name__ == "__main__": from matplotlib import pyplot pyplot.imshow(k[ecs].states3d.mean(2), extent=k[ecs].extent("xy")) for sec in h.allsec(): pyplot.plot( [sec.x3d(i) for i in range(sec.n3d())], [sec.y3d(i) for i in range(sec.n3d())], "o",
""" from matplotlib.pyplot import figure, show from neuron import h from CA3Neuronlibrary import * from CA3simulations import HocVector h.load_file('stdrun.hoc') h.v_init = -62.94 h.tstop = 50 h.dt = 1/5. h.finitialize(-75) # cell with morphology and biophysics mycell = create_cell(CA3NeuronJonas) # stimulator stim = h.IClamp(0.5, sec= mycell.dend[141]) stim.amp = .7 stim.dur = 5 stim.delay = 10 # Load HocVectors soma_AP = HocVector(seg = mycell.soma(0.5)) dend_AP = HocVector(seg = mycell.dend[141](0.5)) # run simulation (stimulate in the dendrite)
from neuron import h from neuron.units import ms, mV import matplotlib.pyplot as plt from ring import Ring ring = Ring() pc = h.ParallelContext() pc.set_maxstep(10 * ms) t = h.Vector().record(h._ref_t) h.finitialize(-65 * mV) pc.psolve(100 * ms) # send all spike time data to node 0 local_data = {cell._gid: list(cell.spike_times) for cell in ring.cells} all_data = pc.py_alltoall([local_data] + [None] * (pc.nhost() - 1)) if pc.id() == 0: # combine the data from the various processes data = {} for process_data in all_data: data.update(process_data) # plot it plt.figure() for i, spike_times in data.items(): plt.vlines(spike_times, i + 0.5, i + 1.5) plt.show() pc.barrier() pc.done()
def go(): h.finitialize(v_init) while h.t < tstop: h.fadvance()
def run(self, t_max, downsample=1, record_from_syns=False, record_from_iclamps=False, record_from_vclamps=False, record_from_channels=False, record_v_deriv=False, record_concentrations=[], pprint=False): """ Run the NEURON simulation. Records at all locations stored under the name 'rec locs' on `self` (see `MorphTree.storeLocs()`) Parameters ---------- t_max: float Duration of the simulation downsample: int (> 0) Records the state of the model every `downsample` time-steps record_from_syns: bool (default ``False``) Record currents of synapstic point processes (in `self.syns`). Accessible as `np.ndarray` in the output dict under key 'i_syn' record_from_iclamps: bool (default ``False``) Record currents of iclamps (in `self.iclamps`) Accessible as `np.ndarray` in the output dict under key 'i_clamp' record_from_vclamps: bool (default ``False``) Record currents of vclamps (in `self.vclamps`) Accessible as `np.ndarray` in the output dict under key 'i_vclamp' record_from_channels: bool (default ``False``) Record channel state variables from `neat` defined channels in `self`, at locations stored under 'rec locs' Accessible as `np.ndarray` in the output dict under key 'chan' record_v_deriv: bool (default ``False``) Record voltage derivative at locations stored under 'rec locs' Accessible as `np.ndarray` in the output dict under key 'dv_dt' record_from_concentrations: bool (default ``False``) Record ion concentration at locations stored under 'rec locs' Accessible as `np.ndarray` in the output dict with as key the ion's name Returns ------- dict Dictionary with the results of the simulation. Contains time and voltage as `np.ndarray` at locations stored under the name ' rec locs', respectively with keys 't' and 'v_m'. Also contains traces of other recorded variables if the option to record them was set to ``True`` """ assert isinstance(downsample, int) and downsample > 0 # simulation time recorder res = {'t': h.Vector()} res['t'].record(h._ref_t) # voltage recorders res['v_m'] = [] for loc in self.getLocs('rec locs'): res['v_m'].append(h.Vector()) res['v_m'][-1].record(self.sections[loc['node']](loc['x'])._ref_v) # synapse current recorders if record_from_syns: res['i_syn'] = [] for syn in self.syns: res['i_syn'].append(h.Vector()) res['i_syn'][-1].record(syn._ref_i) # current clamp current recorders if record_from_iclamps: res['i_clamp'] = [] for iclamp in self.iclamps: res['i_clamp'].append(h.Vector()) res['i_clamp'][-1].record(iclamp._ref_i) # voltage clamp current recorders if record_from_vclamps: res['i_vclamp'] = [] for vclamp in self.vclamps: res['i_vclamp'].append(h.Vector()) res['i_vclamp'][-1].record(vclamp._ref_i) # channel state variable recordings if record_from_channels: res['chan'] = {} channel_names = self.getChannelsInTree() for channel_name in channel_names: res['chan'][channel_name] = {str(var): [] for var in self.channel_storage[channel_name].statevars} for loc in self.getLocs('rec locs'): for ind, varname in enumerate(self.channel_storage[channel_name].statevars): var = str(varname) # assure xcoordinate is refering to proper neuron section (not endpoint) xx = loc['x'] if xx < 1e-3: xx += 1e-3 elif xx > 1. - 1e-3: xx -= 1e-3 # create the recorder try: rec = h.Vector() exec('rec.record(self.sections[loc[0]](xx).' + mechname[channel_name] + '._ref_' + str(var) +')') res['chan'][channel_name][var].append(rec) except AttributeError: # the channel does not exist here res['chan'][channel_name][var].append([]) if len(record_concentrations) > 0: for c_ion in record_concentrations: res[c_ion] = [] for loc in self.getLocs('rec locs'): res[c_ion].append(h.Vector()) exec('res[c_ion][-1].record(self.sections[loc[\'node\']](loc[\'x\'])._ref_' + c_ion + 'i)') # record voltage derivative if record_v_deriv: res['dv_dt'] = [] for ii, loc in enumerate(self.getLocs('rec locs')): res['dv_dt'].append(h.Vector()) # res['dv_dt'][-1].deriv(res['v_m'][ii], self.dt) # initialize # neuron.celsius=37. h.finitialize(self.v_init) h.dt = self.dt # simulate if pprint: print('>>> Simulating the NEURON model for ' + str(t_max) + ' ms. <<<') start = time.process_time() neuron.run(t_max + self.t_calibrate) stop = time.process_time() if pprint: print('>>> Elapsed time: ' + str(stop-start) + ' seconds. <<<') runtime = stop-start # compute derivative if 'dv_dt' in res: for ii, loc in enumerate(self.getLocs('rec locs')): res['dv_dt'][ii].deriv(res['v_m'][ii], h.dt, 2) res['dv_dt'][ii] = np.array(res['dv_dt'][ii])[self.indstart:][::downsample] res['dv_dt'] = np.array(res['dv_dt']) # cast recordings into numpy arrays res['t'] = np.array(res['t'])[self.indstart:][::downsample] - self.t_calibrate for key in set(res.keys()) - {'t', 'chan', 'dv_dt'}: if key in res and len(res[key]) > 0: res[key] = np.array([np.array(reslist)[self.indstart:][::downsample] \ for reslist in res[key]]) if key in ('i_syn', 'i_clamp', 'i_vclamp'): res[key] *= -1. # cast channel recordings into numpy arrays if 'chan' in res: for channel_name in channel_names: channel = self.channel_storage[channel_name] for ind0, varname in enumerate(channel.statevars): var = str(varname) for ind1 in range(len(self.getLocs('rec locs'))): res['chan'][channel_name][var][ind1] = \ np.array(res['chan'][channel_name][var][ind1])[self.indstart:][::downsample] if len(res['chan'][channel_name][var][ind1]) == 0: res['chan'][channel_name][var][ind1] = np.zeros_like(res['t']) res['chan'][channel_name][var] = \ np.array(res['chan'][channel_name][var]) # compute P_open # sv = np.zeros((len(channel.statevars), len(self.getLocs('rec locs')), len(res['t']))) sv = {} for varname in channel.statevars: var = str(varname) sv[var] = res['chan'][channel_name][var] res['chan'][channel_name]['p_open'] = channel.computePOpen(res['v_m'], **sv) return res
def get_base_vm_cli(neuron_model=None, default_cli=4, **kwargs): """ Determine steady-state internal chloride concentration by 1) instantiating a class that extends BaseNeuron (NOTE: class should not have spiking at default values) 2) adding KCC2 using the add_kcc2() method 3) setting [Cl]_i to an arbitrary value (can be set in method invocation) 4) running a fast simulation for a long time 5) checking if chloride is at steady state (repeat 4 until it is) 6) return steady state Vm and [Cl]_i :param neuron_model: class extending BaseNeuron :param default_cli: arbitrary value of [Cl]_i hopefully close to steady state :return: steady state Vm and [Cl]_i """ from baseneuron import BaseNeuron remove_kcc2 = False if neuron_model is None: neuron_model = BaseNeuron if isinstance(neuron_model, BaseNeuron): # is instantiation of class base = neuron_model if not base.kcc2_inserted: base.add_kcc2() remove_kcc2 = True base.set_cl(default_cli) else: # is BaseNeuron class (or child class) base = neuron_model(**kwargs) base.add_kcc2() base.set_cl(default_cli) h.tstop = 50000 h.useCV() h.finitialize(-65) h.run() def at_steady_state(continue_dt): """ check if [Cl]_i is at steady state :param continue_dt: amount of time to run :return: [Cl]_i if at steady state, False otherwise """ v_start = base.soma(.5)._ref_v[0] cli_start = base.soma(.5)._ref_cli[0] h.continuerun(h.tstop + continue_dt) h.tstop += continue_dt v_after = base.soma(.5)._ref_v[0] cli_after = base.soma(.5)._ref_cli[0] if v_after - v_start < 1e-6 and cli_after - cli_start < 1e-6: return cli_after else: return False num_steady_state_checks = 0 while not at_steady_state(1): h.continuerun(h.tstop + 10000) h.tstop += 10000 num_steady_state_checks += 1 if num_steady_state_checks > 10: print("not at steady state even after {} ms".format( 50000 + num_steady_state_checks * 10000)) exit(-1) h.disableCV() vm, cli = base.soma(.5)._ref_v[0], base.soma(.5)._ref_cli[0] logger.info("steady state [Cl]_i {}".format(cli)) logger.info("steady state Vm {}".format(vm)) logger.info( "took {} ms (simulation time)".format(50000 + num_steady_state_checks * 10000)) if remove_kcc2: base.remove_kcc2() h.finitialize(vm) return vm, cli
def gap_junction_test(tree, v_init): h('objref gjlist, cells, Vlog1, Vlog2') h.pc = h.ParallelContext() h.cells = h.List() h.gjlist = h.List() cell1 = cells.make_neurotree_cell("NGFCell", neurotree_dict=tree) cell2 = cells.make_neurotree_cell("NGFCell", neurotree_dict=tree) h.cells.append(cell1) h.cells.append(cell2) ggid = 20000000 source = 10422930 destination = 10422670 srcbranch = 1 dstbranch = 2 weight = 5.4e-4 stimdur = 500 tstop = 2000 h.pc.set_gid2node(source, int(h.pc.id())) nc = cell1.connect2target(h.nil) h.pc.cell(source, nc, 1) h.pc.set_gid2node(destination, int(h.pc.id())) nc = cell2.connect2target(h.nil) h.pc.cell(destination, nc, 1) stim1 = h.IClamp(cell1.sections[0](0.5)) stim1.delay = 250 stim1.dur = stimdur stim1.amp = -0.1 stim2 = h.IClamp(cell2.sections[0](0.5)) stim2.delay = 500 + stimdur stim2.dur = stimdur stim2.amp = -0.1 log_size = old_div(tstop, h.dt) + 1 h.tlog = h.Vector(log_size, 0) h.tlog.record(h._ref_t) h.Vlog1 = h.Vector(log_size) h.Vlog1.record(cell1.sections[0](0.5)._ref_v) h.Vlog2 = h.Vector(log_size) h.Vlog2.record(cell2.sections[0](0.5)._ref_v) h.mkgap(h.pc, h.gjlist, source, srcbranch, ggid, ggid + 1, weight) h.mkgap(h.pc, h.gjlist, destination, dstbranch, ggid + 1, ggid, weight) h.pc.setup_transfer() h.pc.set_maxstep(10.0) h.stdinit() h.finitialize(v_init) h.pc.barrier() h.tstop = tstop h.pc.psolve(h.tstop) f = open("NGFCellGJ.dat", 'w') for (t, v1, v2) in zip(h.tlog, h.Vlog1, h.Vlog2): f.write("%f %f %f\n" % (t, v1, v2)) f.close()
# set current injection rheobase = model_sets[cell_index]['rheobase'] Istim = h.IClamp(0.5, sec=cell.soma) Istim.delay = 100 Istim.dur = 1000 Istim.amp = (rheobase) * 1e-3 # record vectors tm = h.Vector() tm.record(h._ref_t) vm = h.Vector() vm.record(cell.soma(0.5)._ref_v) # run simulation h.finitialize(-80) # run simulation while h.t < 1000: h.fadvance() OUT[cell_index] = { 'tm': tm.to_python(), 'vm': vm.to_python, 'rheo': rheobase } # plot for cell_index in OUT: plt.plot(OUT[cell_index]['tm'], OUT[cell_index]['vm'], \ label='mdl:{} rhb:{:.0f}'.format(cell_index,OUT[cell_index]['rheo']))
def nrngo(tstop, vinit): h.finitialize(vinit) h.fcurrent() while h.t < tstop: h.fadvance()
def wave_search(size, size_segments, time_period, times, au, Du): # needed for standard run system h.load_file('stdrun.hoc') global dend dend = h.Section() dend.L = size dend.nseg = size_segments # WHERE the dynamics will take place where = rxd.Region(h.allsec()) # WHO the actors are global u global z global v u = rxd.Species(where, d=Du, initial=0.5) # activator z = rxd.Species(where, d=20, initial=0.5) # inhibitor v = rxd.Species(where, d=0, initial=(1 / dend.L) * 30) # modulator # HOW they act a = au b = -0.4 c = 0.6 d = -0.8 u0 = 0.5 z0 = 0.5 av = 5.0 kz = 0.001 bistable_reaction1 = rxd.Rate(u, (a * (u - u0) + b * (z - z0) - av * (u - u0)**3) * (v**-2)) bistable_reaction2 = rxd.Rate(z, (c * (u - u0) + d * (z - z0)) * (v**-2)) # initial conditions h.finitialize() for node in u.nodes: if node.x < .2: node.concentration = 0.6 if node.x > .8: node.concentration = 0.6 for node in z.nodes: if node.x < .2: node.concentration = 0.6 if node.x > .8: node.concentration = 0.6 # Setting up time frame global u_timespace T_d = times T = time_period u_timespace = [] for i in np.arange(0, T_d): h.continuerun(i * T) u_timespace.append(u.nodes.concentration) # activator FFT source files u_fft_y = u.nodes.concentration u_fft_y = u_fft_y - np.mean(u_fft_y) u_fft_x = u.nodes.x global u_fft_x_norm u_fft_x_norm = dend.L * np.array(u_fft_x) # inhibitor FFT source files z_fft_y = z.nodes.concentration z_fft_y = z_fft_y - np.mean(z_fft_y) z_fft_x = z.nodes.x z_fft_x_norm = dend.L * np.array(u_fft_x) # activator FFT Y1 = np.fft.fft(u_fft_y) N = len(Y1) / 2 + 1 dt = dend.L / dend.nseg fa = 1.0 / dt X = np.linspace(0, fa / 2, N, endpoint=True) # inhibitor FFT Y2 = np.fft.fft(z_fft_y) X2 = np.linspace(0, fa / 2, N, endpoint=True) # # if ((np.amax(Y1) - np.amin(Y1) < .01) or (np.amax(Y2) - np.amin(Y2) < .01)): # return 0 if (len(X) == len(2.0 * np.abs(Y1[:N] / N))): u_maxx = (np.argmax(2.0 * np.abs(Y1[:N] / N))) wavelen = np.around(1 / X[u_maxx]) plot_it(time_period, times, u_timespace) plt.savefig('results/plots/{0}_{1}_{2}_{3}_{4}_{5}.png'.format( size, size_segments, time_period, times, au, Du)) return wavelen
ip3r = rxd.MultiCompartmentReaction(ca[er]!=ca[cyt], k, k, membrane=cyt_er_membrane) ip3rg = rxd.Rate(h_gate, (1. / (1 + 1000. * ca[cyt] / (0.3)) - h_gate) / ip3rtau) v1 = h.Vector() v1.record(sec(0.5)._ref_v) ca1 = h.Vector() ca1.record(sec(0.5)._ref_cai) v2 = h.Vector() v2.record(sec(0.25)._ref_v) ca2 = h.Vector() ca2.record(sec(0.25)._ref_cai) times = h.Vector() times.record(h._ref_t) h.finitialize() cae_init = (0.0017 - cac_init * fc) / fe ca[er].concentration = cae_init #ip3.nodes.concentration = 2 for node in ip3.nodes: if node.x<.8 and node.x>=.6 and node.sec._sec==sec: node.concentration = 2 h.CVode().re_init() s.variable('cai') #s.scale(-70, -50) s.scale(0, 2e-3)
ip3 = rxd.Species(cyt, d=ip3Diff, name="ip3", initial=ip3_init) ip3r_gate_state = rxd.Species(cyt_er_membrane, name="gate", initial=0.8) h_gate = ip3r_gate_state[cyt_er_membrane] minf = ip3[cyt] * 1000. * ca[cyt] / (ip3[cyt] + kip3) / (1000. * ca[cyt] + kact) k = gip3r * (minf * h_gate) ** 3 ip3r = rxd.MultiCompartmentReaction(ca[er],ca[cyt], k, k, membrane=cyt_er_membrane) serca = rxd.MultiCompartmentReaction(ca[cyt],ca[er], gserca/((kserca / (1000. * ca[cyt])) ** 2 + 1), membrane=cyt_er_membrane, custom_dynamics=True) leak = rxd.MultiCompartmentReaction(ca[er],ca[cyt], gleak, gleak, membrane=cyt_er_membrane) ip3r = rxd.MultiCompartmentReaction(ca[er],ca[cyt], k, k, membrane=cyt_er_membrane) ip3rg = rxd.Rate(h_gate, (1. / (1 + 1000. * ca[cyt] / (0.3)) - h_gate) / ip3rtau) h.finitialize() cacyt_trace = h.Vector() cacyt_trace.record(ca[cyt].nodes(sec)(.5)[0]._ref_concentration) caer_trace = h.Vector() caer_trace.record(ca[er].nodes(sec)(.5)[0]._ref_concentration) ip3_trace = h.Vector() ip3_trace.record(ip3.nodes(sec)(.5)[0]._ref_concentration) times = h.Vector() times.record(h._ref_t) h.finitialize()
def main(): args = parse_args() # TODO: standardise Erev normalize = args.normalize # normalize all traces between 0 and 1 plotting = args.plotting # plot traces mod_name = args.mod_type input_directory = args.mod_loc result_directory = args.results_dir var_dt = args.variable_dt if var_dt == 0: var_dt = False elif var_dt == 1: var_dt = True else: var_dt = True try: current_type = { 'kv': 'outward', 'nav': 'inward', 'cav': 'outward', 'kca': 'outward', 'ih': 'outward' }[mod_name] except KeyError: print('Incorrect argument mod_type') # 2. PREPARE DIR - clean up, then add all mod files and compile if os.path.isdir(input_directory): input_path = input_directory mod_files = glob.glob(os.path.join(input_path, '*.mod')) # should use glob instead elif os.path.isfile(input_directory): input_path = os.path.dirname(os.path.abspath(input_directory)) mod_files = [input_directory] print('Processing %d mod files,' % (len(mod_files))) orig_directory = getcwd() with cd(input_path): unique_id = str(int(time.time() * 1000)) folder_temp = "compiled_files_" + unique_id compiled_dir = create_dir(folder_temp) print(mod_files) custom_files = {} # python hack - copy all mod files to the directory and compile # NOTE: each file is given a new name (tmpmodX.mod) and suffix (suff_X), where X is the index in list mod_files for (m_idx, mpath) in enumerate(mod_files): m = os.path.basename(mpath) print("{} is tmpmod{}".format(m, m_idx)) dest_file = 'tmpmod' + str(m_idx) + '.mod' new_suffix = 'suff_' + str(m_idx) rename_suffix(m, join(compiled_dir, dest_file), new_suffix) if isfile( abspath( join(orig_directory, '../', 'custom_code', 'customcode_' + splitext(m)[0] + '.hoc'))): custom_files[m_idx] = abspath( join(orig_directory, '../', 'custom_code', 'customcode_' + splitext(m)[0] + '.hoc')) with cd(compiled_dir): # compile the mod files mod_files = nrnivmodl(len(mod_files), mod_files) # remove mode files which caused an issue mod_files = [m for m in mod_files] # this must be done AFTER compiling of mechanisms is complete # import within the same directory as compiled mod files to have them loaded automatically into NEURON from neuron import h, gui print(custom_files) # SET UP NEURON ENVIRONMENT h.celsius = 37.0 h.finitialize(-80.0) # because nrnutils has neuron import statement, these should be placed after this file's neuron import from vClampCell import ICGCell from protocols import protocol_dict, plotting_done, \ Activation, Inactivation, Deactivation, Ramp, ActionPotential # 3. LOOP THROUGH AND RUN ALL MOD FILES for (m_idx, m) in enumerate(mod_files): print('*' * 50 + '\n' + 'Running protocols for modfile: ', m) if m is None: continue fname = m.replace('.mod', '') new_suffix = 'suff_' + str(m_idx) print('suffix =', new_suffix) # create the cell and insert the ion channel conductance cell = ICGCell(mod_name, current_type) # some files require custom_code: if extra hoc file exists, then run it with cd(orig_directory): open('../customcode.hoc', 'w').close() # empty the file if m_idx in custom_files.keys(): print('This mod requires additional files. Loading...') copyfile(custom_files[m_idx], '../customcode.hoc') h('load("../customcode.hoc")') cell.insert_distributed_channel(new_suffix) # loop through protocols protocol_list = protocol_dict.keys() for p in protocol_list: print('Running protocol: ', p) # create protocol and run protocol = protocol_dict[p]( h, dt=0.025, var_dt=var_dt ) # should generate an instance of the correct protocol protocol.clampCell(cell) # create SEClamp attached to soma protocol.run(cell) # run the protocol with cd(orig_directory): ff = fname.rsplit('/', 1)[-1] protocol.saveMat( ff, result_directory) # save voltage, current and time # optional plotting if plotting: # plot each run from the matrices protocol.plot() rmtree(folder_temp, ignore_errors=True) plotting_done()