def simulate(pool, tstop=50000, 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 run_cclamp(self): print "- running model", self.name rec_t = h.Vector() rec_t.record(h._ref_t) rec_v = h.Vector() rec_v.record(h.soma(0.5)._ref_v) h.stdinit() dt = 0.025 h.dt = dt h.steps_per_ms = 1 / dt h.v_init = -65 h.celsius = 34 h.init() h.tstop = 1600 h.run() t = numpy.array(rec_t) v = numpy.array(rec_v) return t, v
def test_direct_memory_transfer(): h('''create soma''') h.soma.L = 5.6419 h.soma.diam = 5.6419 h.soma.insert("hh") ic = h.IClamp(h.soma(.5)) ic.delay = .5 ic.dur = 0.1 ic.amp = 0.3 h.cvode.use_fast_imem(1) h.cvode.cache_efficient(1) v = h.Vector() v.record(h.soma(.5)._ref_v, sec=h.soma) i_mem = h.Vector() i_mem.record(h.soma(.5)._ref_i_membrane_, sec=h.soma) tv = h.Vector() tv.record(h._ref_t, sec=h.soma) h.run() vstd = v.cl() tvstd = tv.cl() i_memstd = i_mem.cl() pc = h.ParallelContext() h.stdinit() pc.nrncore_run("-e %g" % h.tstop, 0) assert (tv.eq(tvstd)) assert (v.cl().sub(vstd).abs().max() < 1e-10) assert (i_mem.cl().sub(i_memstd).abs().max() < 1e-10)
def run_cclamp_somatic_feature(self, section_rec, loc_rec): exec("self.sect_loc=h." + str(section_rec) + "(" + str(loc_rec) + ")") print "- running model", self.name rec_t = h.Vector() rec_t.record(h._ref_t) rec_v = h.Vector() rec_v.record(self.sect_loc._ref_v) h.stdinit() dt = 0.025 h.dt = dt h.steps_per_ms = 1 / dt h.v_init = -65 h.celsius = 34 h.init() h.tstop = 1600 h.run() t = numpy.array(rec_t) v = numpy.array(rec_v) return t, v
def getRMP(self, parameters, debug=False): if not self.stop: # Simulation parameters h.load_file('stdrun.hoc') h.load_file('negative_init.hoc') tstop = 100 dt = 0.025 h.stdinit() h.celsius = 37.0 h.tstop = tstop h.v_init = -65 # Instantiate and parameterize cells testCell = cell.Cell(0, (0, 0), self.synvars, 'granulecell', 'output0_updated.swc') self.parameterizeCell(testCell, parameters) # Instrument cells self.RMPv = h.Vector() self.RMPv.record(testCell.c.soma[0](0.5)._ref_v) # Run simulation h.run() # Get RMP self.RMP = self.RMPv[-1] if debug: return [np.array([self.RMP]), np.array([self.RMPv])] else: return np.array([self.RMP]) else: return 1e9
def restore_state(self, state_file='state.bin', keep_events=False): from neuron import h ns = h.SaveState() sf = h.File(os.path.join(self.get_permanent_model_directory(), state_file)) ns.fread(sf) h.stdinit() if keep_events: ns.restore(1) # Workaround - without the fixed step cycle, NEURON crashes with same error as in: # https://www.neuron.yale.edu/phpBB/viewtopic.php?f=2&t=3845&p=16542#p16542 # Only happens when there is a vector.play added after a state restore # Running one cycle using the fixed integration method addresses the problem h.cvode_active(0) prev_dt = h.dt h.dt = 0.000001 h.steprun() h.dt = prev_dt # END Workaround else: ns.restore() h.cvode_active(self.config.cvode_active)
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 run_syn(self): # initiate recording rec_t = h.Vector() rec_t.record(h._ref_t) rec_v = h.Vector() rec_v.record(h.somaA(0.5)._ref_v) rec_v_dend = h.Vector() rec_v_dend.record(self.dendrite(self.xloc)._ref_v) print "- running model", self.name # initialze and run #h.load_file("stdrun.hoc") h.stdinit() dt = 0.025 h.dt = dt h.steps_per_ms = 1 / dt h.v_init = -65 h.celsius = 34 h.init() h.tstop = 300 h.run() # get recordings t = numpy.array(rec_t) v = numpy.array(rec_v) v_dend = numpy.array(rec_v_dend) return t, v, v_dend
def run(mode): h.stdinit() if mode == 0: pc.psolve(h.tstop) elif mode == 1: while h.t < h.tstop: pc.psolve(h.t + 1.0) else: while h.t < h.tstop: h.continuerun(h.t + 0.5) pc.psolve(h.t + 0.5) corenrn_all_spike_t_py = corenrn_all_spike_t.to_python() corenrn_all_spike_gids_py = corenrn_all_spike_gids.to_python() # check spikes match assert len(nrn_spike_t) # check we've actually got spikes assert len(nrn_spike_t) == len(nrn_spike_gids) # matching no. of gids if nrn_spike_t != corenrn_all_spike_t_py: print(mode) print(nrn_spike_t) print(nrn_spike_gids) print(corenrn_all_spike_t_py) print(corenrn_all_spike_gids_py) print([ corenrn_all_spike_t[i] - nrn_spike_t[i] for i in range(len(nrn_spike_t)) ]) assert nrn_spike_t == corenrn_all_spike_t_py assert nrn_spike_gids == corenrn_all_spike_gids_py
def prun(): pc.barrier() # wait for all hosts to get to this point pc.set_maxstep(1); h.stdinit() if (pc.id()==0 and printflag>1): print("Parallel run is going to run till",h.tstop) pc.psolve(h.tstop); pc.barrier() # wait for all hosts to get to this point
def simulate(tstop=25): """Initialize and run a simulation. :param tstop: Duration of the simulation. """ h.tstop = tstop h.stdinit() h.run()
def getMembraneTimeConstant(self, parameters, debug=False): if not self.stop: ###################################### # Membrane Time Constant Experiments # ###################################### # Simulation parameters h.load_file('stdrun.hoc') h.load_file('negative_init.hoc') tstop = self.subthresh_dur + 300 dt = 0.025 h.stdinit() h.celsius = 37.0 h.tstop = tstop h.v_init = -65 # Instantiate and parameterize cells testCell = cell.Cell(0, (0, 0), self.synvars, 'granulecell', 'output0_updated.swc') self.parameterizeCell(testCell, parameters) # Make sure the cell doesn't spike # Create inputs for experiments stim = h.IClamp(0.5, sec=testCell.c.soma[0]) stim.amp = self.threshAmp # amp at which neuron no longer spikes stim.dur = self.subthresh_dur # subthresh is duration where neuron no longer spikes stim.delay = 0 # Instrument cells self.tauV = h.Vector() self.tauV.record(testCell.c.soma[0](0.5)._ref_v) t = h.Vector() t.record(h._ref_t) tvec = h.Vector() nc = testCell.connect_pre(None, 0, 0) nc.record(tvec) # Run simulation h.run() # Calculate membrane time constant self.tauV = np.array(self.tauV) t = np.array(t) t_idx = t >= self.subthresh_dur t = t[t_idx] - self.subthresh_dur v = self.tauV[t_idx] try: popt, pcov = curve_fit(self.expFunc, t, v, p0=(1, -0.1, -60)) self.tau = -1 / popt[1] except RuntimeError: self.tau = 1000 if debug: return [np.array([self.tau]), v, t, popt] else: return np.array([self.tau]) else: return 1e9
def prun(): pc.timeout(1) pc.multisplit() pc.set_maxstep(1) pc.setup_transfer() h.stdinit() if rank == 0: h.cvode.event(2.001, callback) # works when 2.0 pc.psolve(5)
def foo(s): print(s) h.stdinit() print("ri ", [seg.ri() for seg in cab.allseg()]) for freq in [1., 10., 100.]: imp.compute(freq, 1, 5000) x = [seg.x for seg in cab.allseg()] trans = [imp.transfer(i, sec=cab) for i in x] print('freq=%g transimped=' % (freq), trans)
def prun(runState): h.stdinit() if runState == 1: pnm.psolve(h.tstop / 2.) savestate() else: restorestate() h.frecord_init() pnm.psolve(h.tstop) pspike()
def simulate(cell, tstop=400, 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() if cell.numofmodel == 9 or cell.numofmodel == 10 or cell.numofmodel == 12: running_ = 1 if cell.numofmodel == 9: dl = 0 d_t = 60000 elif cell.numofmodel == 10: dl = 1000 d_t = 40 else: dl = 800 d_t = 10 h.stdinit() for n in range(3): cell.x_application = cell.x_application + dl if n == 0: cell.dl = 5000 cell.x_application = 0 print(cell.x_application) else: cell.dl = 30050 cell.x_application = -400 cell.distance() for item in cell.diffs: item.tx1 = h.t + 5 # item.initial = 0#item.atp # if n == 0: # item.c0cleft = 0.01#item.c0cleft # else: item.c0cleft = item.c0cleft item.h = cell.distances.get(cell.diffusions.get(item)) h.continuerun(h.t + d_t) h.continuerun(h.t + 500)
def runring(ncell=5, delay=1, tstop=100): ring = Ring(ncell, delay) pc.set_maxstep(10) h.stdinit() pc.psolve(tstop) spkcnt = pc.allreduce(len(ring.tvec), 1) tmax = pc.allreduce(ring.tvec.x[-1], 2) tt = h.Vector() idv = h.Vector() pc.allgather(ring.tvec.x[-1], tt) pc.allgather(ring.idvec.x[-1], idv) idmax = int(idv.x[int(tt.max_ind())]) return (int(spkcnt), tmax, idmax, (ncell, delay, tstop, (pc.id_world(), pc.nhost_world())))
def runring(ncell=5, delay=1, tstop=100): ring = Ring(ncell, delay) pc.set_maxstep(10) h.stdinit() pc.psolve(tstop) spkcnt = pc.allreduce(len(ring.tvec), 1) tmax = pc.allreduce(ring.tvec.x[-1], 2) tt = h.Vector() idv = h.Vector() pc.allgather(ring.tvec.x[-1], tt) pc.allgather(ring.idvec.x[-1], idv) idmax = int(idv.x[int(tt.max_ind())]) return (int(spkcnt), tmax, idmax, (ncell, delay, tstop, (rank, nhost)))
def _set_init_conditions(self): """Set up the initial conditions: either read from the h.SaveState or from config["condidtions"]""" pc.set_maxstep(10) h.stdinit() self.tstep = int(round(h.t/h.dt)) self.tstep_start_block = self.tstep if self._start_from_state: # io.read_state() io.log_info('Read the initial state saved at t_sim: {} ms'.format(h.t)) else: h.v_init = self.v_init h.celsius = self.celsius
def runring(ncell=5, delay=1, tstop=100): ring = Ring(ncell, delay) # ring is local, therefore destroyed upon exit pc.set_maxstep(10) # minimum NetCon delay h.stdinit() pc.psolve(tstop) spkcnt = pc.allreduce(len(ring.tvec), 1) # total number of spikes in ring tmax = pc.allreduce(ring.tvec.x[-1], 2) # last spike time # min time would be 3 aka first spike tt = h.Vector() idv = h.Vector() pc.allgather(ring.tvec.x[-1], tt) # all last times in tt pc.allgather(ring.idvec.x[-1], idv) # biggest ids idmax = int(idv.x[int(tt.max_ind())]) # identifier of cell that fired last return (int(spkcnt), tmax, idmax, (ncell, delay, tstop, (pc.id_world(), pc.nhost_world())))
def prun(self,tstop): #from neuron import h pc=h.ParallelContext() NCELL=self.NCELL SIZE=self.SIZE COMM = self.COMM RANK=self.RANK checkpoint_interval = 50000. #The following definition body is from the open source code at: #http://senselab.med.yale.edu/ModelDB/ShowModel.asp?model=151681 #with some minor modifications cvode = h.CVode() cvode.cache_efficient(1) # pc.spike_compress(0,0,1) pc.setup_transfer() mindelay = pc.set_maxstep(10) if RANK == 0: print 'mindelay = %g' % mindelay runtime = h.startsw() exchtime = pc.wait_time() inittime = h.startsw() h.stdinit() inittime = h.startsw() - inittime if RANK == 0: print 'init time = %g' % inittime while h.t < tstop: told = h.t tnext = h.t + checkpoint_interval if tnext > tstop: tnext = tstop pc.psolve(tnext) if h.t == told: if RANK == 0: print 'psolve did not advance time from t=%.20g to tnext=%.20g\n' \ % (h.t, tnext) break print 'working', h.t runtime = h.startsw() - runtime comptime = pc.step_time() splittime = pc.vtransfer_time(1) gaptime = pc.vtransfer_time() exchtime = pc.wait_time() - exchtime if RANK == 0: print 'runtime = %g' % runtime print comptime, exchtime, splittime, gaptime
def main(): h.load_file("multisplit.hoc") h('{nrn_load_dll("../specials/x86_64/.libs/libnrnmech.so")}') tstop = 1000 pc = h.ParallelContext() start = h.startsw() ###################################################### # load model cell = load_model("./1056.swc") ###################################################### # generate mcomplex.dat lb = h.MyLoadBalance() lb.ExperimentalMechComplex() #save_mcomplex(lb) pc.barrier() ###################################################### # set up multi split cplx = h.multisplit(lb) pc.multisplit() pc.set_maxstep(10) ###################################################### # set stim and record of v stim = set_iclamp("CellSwc[0].Dend[2000]", pc) vec_t = h.Vector() vec_t.record(h._ref_t) vec_v = set_vec_v("CellSwc[0].Dend[100]", pc) setup_time = h.startsw() - start ###################################################### # run simulation start = h.startsw() h.stdinit() pc.psolve(tstop) pc.barrier() calc_time = h.startsw() - start ###################################################### # disp info show_result(pc, setup_time, calc_time, cplx) #show_section() #if(vec_v != 0): # show_plot(vec_t, vec_v) pc.done()
def bpattrun(): netfcns.erasecue(pop_by_name,pc) for i in range(0, NPATT): if (pc.id()==0 and printflag>1): print("Cue pattern ", i) # print header once cuefstem = "{}_{}".format(fstem, i) #h.sprint(fstem, "Results/HAM_P5R%", i) netfcns.mkcue(FPATT, i, CFRAC, NPATT, pc); # cue from stored pattern pc.barrier() # wait for all hosts to get to this point #{pc.set_maxstep(10)} pc.set_maxstep(1); h.stdinit() pc.psolve(h.tstop); netfcns.spikeout(cells,fstem,pc) netfcns.vout(cells,results,fstem,pc) netfcns.erasecue(pop_by_name,pc)
def test_direct_memory_transfer(): h('''create soma''') h.soma.L = 5.6419 h.soma.diam = 5.6419 h.soma.insert("hh") ic = h.IClamp(h.soma(.5)) ic.delay = .5 ic.dur = 0.1 ic.amp = 0.3 #for testing external mod file h.soma.insert("Sample") h.cvode.use_fast_imem(1) h.cvode.cache_efficient(1) v = h.Vector() v.record(h.soma(.5)._ref_v, sec=h.soma) i_mem = h.Vector() i_mem.record(h.soma(.5)._ref_i_membrane_, sec=h.soma) tv = h.Vector() tv.record(h._ref_t, sec=h.soma) h.run() vstd = v.cl() tvstd = tv.cl() i_memstd = i_mem.cl() # Save current (after run) value to compare with transfer back from coreneuron tran_std = [h.t, h.soma(.5).v, h.soma(.5).hh.m] from neuron import coreneuron coreneuron.enable = True coreneuron.gpu = bool(os.environ.get('CORENRN_ENABLE_GPU', '')) pc = h.ParallelContext() h.stdinit() pc.psolve(h.tstop) tran = [h.t, h.soma(.5).v, h.soma(.5).hh.m] assert (tv.eq(tvstd)) assert ( v.cl().sub(vstd).abs().max() < 1e-10 ) # usually v == vstd, some compilers might give slightly different results # This check is disabled on GPU because fast imem is not implemented on # GPU: https://github.com/BlueBrain/CoreNeuron/issues/197 assert (coreneuron.gpu or i_mem.cl().sub(i_memstd).abs().max() < 1e-10) assert (h.Vector(tran_std).sub(h.Vector(tran)).abs().max() < 1e-10)
def run(argv=None): """Run a ring network simulation. Additional arguments on command line can be any Python statement to execute, but strings in the form ``"sim_var['<var>']=x"`` will run the simulation with a modification of those parameters.""" sim_var = process_args(argv) pc = h.ParallelContext() ring = Ring(sim_var['N'], sim_var['stim_w'], sim_var['stim_spike_num'], sim_var['syn_w'], sim_var['syn_delay']) pc.set_maxstep(10) h.stdinit() h.dt = 0.025 # Fixed dt pc.psolve(100) ring.write_spikes(sim_var['spike_out_file']) # After we are done, re-sort the file by spike times. exec_cmd = ('sort -k 1n,1n -k 2n,2n ' + sim_var['spike_out_file'] + ' > ' + 'sorted_' + sim_var['spike_out_file']) os.system(exec_cmd)
def run_from_steady_state(self, tstop): self._update_current_sources(tstop) self._pre_run() self.parallel_context.set_maxstep(self.default_maxstep) self.tstop = tstop h.stdinit() ns = h.SaveState() sf = h.File('steady_state.bin') ns.fread(sf) #print("Time before restore = %g ms" % h.t) ns.restore(0) h.cvode_active(0) #print("Time after restore = %g ms" % h.t) #logger.info("Running the simulation until %g ms" % tstop) if self.tstop > self.t: self.parallel_context.psolve(self.tstop)
def test_direct_memory_transfer(): h('''create soma''') h.soma.L = 5.6419 h.soma.diam = 5.6419 h.soma.insert("hh") ic = h.IClamp(h.soma(.5)) ic.delay = .5 ic.dur = 0.1 ic.amp = 0.3 #for testing external mod file h.soma.insert("Sample") h.cvode.use_fast_imem(1) h.cvode.cache_efficient(1) v = h.Vector() v.record(h.soma(.5)._ref_v, sec=h.soma) i_mem = h.Vector() i_mem.record(h.soma(.5)._ref_i_membrane_, sec=h.soma) tv = h.Vector() tv.record(h._ref_t, sec=h.soma) h.run() vstd = v.cl() tvstd = tv.cl() i_memstd = i_mem.cl() # Save current (after run) value to compare with transfer back from coreneuron tran_std = [h.t, h.soma(.5).v, h.soma(.5).hh.m] from neuron import coreneuron coreneuron.enable = True pc = h.ParallelContext() h.stdinit() pc.psolve(h.tstop) tran = [h.t, h.soma(.5).v, h.soma(.5).hh.m] assert (v.eq(vstd)) assert (tv.eq(tvstd)) assert (v.cl().sub(vstd).abs().max() < 1e-10) assert (i_mem.cl().sub(i_memstd).abs().max() < 1e-10) assert (h.Vector(tran_std).sub(h.Vector(tran)).abs().max() < 1e-10)
def set_init_conditions(self): ''' Set up the initial conditions: either read from the h.SaveState or from config["condidtions"] ''' pc.set_maxstep(10) h.stdinit() self.tstep = int(round(h.t / h.dt)) self.tstep_start_block = self.tstep if self._start_from_state == True: io.read_state() io.print2log0('Read the initial state saved at t_sim: %.2f ms' % (h.t)) else: h.v_init = self.conf["conditions"]["v_init"] h.celsius = self.conf["conditions"]["celsius"]
def run(mode): pc.set_maxstep(10) h.stdinit() if mode == 0: pc.psolve(h.tstop) elif mode == 1: while h.t < h.tstop: pc.psolve(h.t + 1.0) else: while h.t < h.tstop: h.continuerun(h.t + 0.5) pc.psolve(h.t + 0.5) tran = [h.t, h.soma(0.5).v, h.soma(0.5).hh.m] assert tv.eq(tvstd) assert ( v.cl().sub(vstd).abs().max() < 1e-10 ) # usually v == vstd, some compilers might give slightly different results assert i_mem.cl().sub(i_memstd).abs().max() < 1e-10 assert h.Vector(tran_std).sub(h.Vector(tran)).abs().max() < 1e-10
def runring(ring, pc, comm, tstop=100): pc.set_maxstep(10) h.stdinit() pc.psolve(tstop) ring.vecdict_to_pydict(ring.voltage_tvec, 't') ring.vecdict_to_pydict(ring.voltage_recvec, 'rec') nhost = int(pc.nhost()) #Use MPI Gather instead: #all_dicts = pc.py_alltoall([ring.pydicts for i in range(nhost)]) all_dicts = comm.gather(ring.pydicts, root=0) if int(pc.id()) == 0: t = { key: value for dict in all_dicts for key, value in dict['t'].iteritems() } rec = { key: value for dict in all_dicts for key, value in dict['rec'].iteritems() } return {'t': t, 'rec': rec} return None
def myrun(): global fit # pointer to FinitializeHandler needs to be global so doesn't disappear dastart = datetime.now() print 'started at:', dastart if dconf['useWM']: setupWMInputs() h.stdinit() ca[er].concentration = dconf['caerinit'] # 100e-6 ca[cyt].concentration = dconf['cacytinit'] # 100e-6 if dconf['cvodeactive']: h.cvode.re_init() h.continuerun(h.t + tstop) # run for tstop daend = datetime.now() print 'finished ', tstop, ' ms sim at:', daend dadiff = daend - dastart print 'runtime:', dadiff, '(', tstop / 1e3, ' s)' # concatenate the results so can view/save all at once global lspks, lids lspks, lids = array([]), array([]) for i in xrange(len(ltimevec)): lspks = concatenate((lspks, ltimevec[i])) lids = concatenate((lids, lidvec[i])) ion() plotnew(xl=(9.9, 11))
def checkSpontaneous(self, parameters): h.load_file('stdrun.hoc') h.load_file('negative_init.hoc') tstop = 500 dt = 0.025 h.stdinit() h.celsius = 37.0 h.tstop = tstop h.v_init = -65 # Instantiate and parameterize cells testCell = cell.Cell(0, (0, 0), self.synvars, 'granulecell', 'output0_updated.swc') self.parameterizeCell(testCell, parameters) # Instrument cells tvec = h.Vector() nc = testCell.connect_pre(None, 0, 0) nc.record(tvec) # Run simulation h.run() if len(tvec) > 0: self.spontaneous_flag = 1
def sim(self): tMax = self.gettMax() tData = 0 tNoise = 0 h.stdinit() x = h.Vector() Data = [] while tData < tMax: noiseTimes = [] tData += self.Mdt if tData > tMax: tData = tMax while tNoise < min(tMax,tData): tNoise += self.Ndt noiseTimes.append(tNoise) if tNoise > tMax: tNoise = tMax h.continuerun(tNoise) cvodewrap.states(x) x.x[0] += self.sp*(self.evalW(tNoise) - self.evalW(tNoise-self.Ndt)) cvodewrap.yscatter(x) cvodewrap.re_init() Data.append([noiseTimes, x.x[0] + self.sm*self.evalM(tData)]) return Data
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 ("MOPPCell", neurotree_dict=tree) cell2 = cells.make_neurotree_cell ("MOPPCell", 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("MOPPCellGJ.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()
def run_simulation(self): start = h.startsw() h.stdinit() self.pc.psolve(self.tstop) self.pc.barrier() self.calc_time = h.startsw() - start
'noise': inputProps['poissonNoise']}, connectionProps) n.addSomaticVoltageRecorder() stim = h.IClamp(n.soma(0.5)) stim.dur = np.random.uniform(high=inputProps['initialPulseDur']) stim.amp = np.random.uniform(low=-inputProps['initialPulseAmp'],high=inputProps['initialPulseAmp']) stim.delay = np.random.uniform(high=inputProps['initialPulseDelay']) initialPulses.append(stim) logger('Started the simulation...', myId) # run the simulation h.load_file('stdrun.hoc') h.tstop = simulationProps['tend'] h.dt = simulationProps['dt'] pc.set_maxstep(1) h.stdinit() pc.psolve(simulationProps['tend']) pc.barrier() # the simulation is finished. logger('Saving data...', myId) # save everything. if myId == 0: fid = h5.H5File(outfile, 'w', 'Common input simulation') fid.createGroup('/','Properties') fid.writeTable('/Properties', 'Simulation', SimulationProps, 'Simulation properties', simulationProps) fid.createGroup('/','Input') fid.writeTable('/Input', 'Properties', InputProps, 'Input properties', inputProps) fid.writeArray('/Input', 'PresynapticSpikes', tbl.Float64Atom(), fixedSpikeTimes) fid.close() pc.barrier()
def prun(tstop): ''' simulation control ''' pc.set_maxstep(10) h.stdinit() pc.psolve(tstop)