def __init__(self,
pc,
tstop,
max_walltime_hours,
results_write_time,
setup_time,
dt_status=1.0,
dt_checksimtime=10.0):
if (int(pc.id()) == 0):
logger.info("*** allocated wall time is %.2f hours" %
(max_walltime_hours))
wt = time.time()
self.pc = pc
self.tstop = tstop
self.walltime_status = wt
self.walltime_checksimtime = wt
self.dt_status = dt_status
self.tcsum = 0.
self.tcma = 0.
self.nsimsteps = 0
self.walltime_max = max_walltime_hours * 3600. - setup_time
self.results_write_time = results_write_time
self.dt_checksimtime = dt_checksimtime
self.fih_checksimtime = h.FInitializeHandler(1, self.checksimtime)
self.fih_simstatus = h.FInitializeHandler(1, self.simstatus)
if (int(self.pc.id()) == 0):
logger.info(
"*** max wall time is %.2f s; max setup time was %.2f s" %
(self.walltime_max, setup_time))
def test_ste():
m1 = model()
# one state ste with two self transitions
var = m1["s"](0.5)._ref_v
thresh1 = h.ref(-50)
thresh2 = h.ref(-10)
result = []
ste = h.StateTransitionEvent(1)
ste.transition(0, 0, var, thresh1, (act, (1, m1, thresh1, result)))
ste.transition(0, 0, var, thresh2, (act, (2, m1, thresh2, result)))
fih = h.FInitializeHandler((on_finit, (ste, result)))
run(5)
print("final v=%g" % m1["s"](0.5).v)
chk_result(2, result, m1)
h.cvode_active(1)
run(20)
chk_result(2, result, m1)
h.cvode_active(1)
h.cvode.condition_order(2)
run(5)
chk_result(2, result, m1)
h.cvode.condition_order(1)
h.cvode_active(0)
# ste associated with point process
del fih, ste
ste = h.StateTransitionEvent(2, m1["ic"])
fih = h.FInitializeHandler((on_finit, (ste, result)))
run(5)
# transition with hoc callback
h("""proc foo() { printf("foo called at t=%g\\n", t) }""")
thresh3 = h.ref(-30)
ste.transition(0, 0, var, thresh3, "foo()")
run(5)
# transition with hoc callback in hoc object
h("""
begintemplate FooSTEtest
objref this
proc foo() { printf("foo in %s called at t=%g\\n", this, t) }
endtemplate FooSTEtest
""")
thresh4 = h.ref(-20)
obj = h.FooSTEtest()
ste.transition(0, 0, var, thresh4, "foo()", obj)
run(5)
del ste, fih
assert h.List("StateTransitionEvent").count() == 0
assert h.List("FInitializeHandler").count() == 0
def reset(self):
wt = time.time()
self.walltime_max = self.walltime_max - self.tcsum
self.tcsum = 0.
self.tcma = 0.
self.nsimsteps = 0
self.walltime_status = wt
self.walltime_checksimtime = wt
self.fih_checksimtime = h.FInitializeHandler(1, self.checksimtime)
self.fih_simstatus = h.FInitializeHandler(1, self.simstatus)
def cellset ():
global cell07, cell03, izh, vref, uvvset, fih, izhtype
if newmodel():
cell07 = choices[izhtype][0]()
izh = cell07.izh
def uvvset () : pass
else:
cell03 = h.Section(name="cell2003") # this cell will be used for 2003/4; different cell created in izhi2007Wrapper for those
izh = choices[izhtype][0]()
def uvvset () : vref[0], izh.u = vviv, vviv*izh.b
cell03.L, cell03.diam = 6.37, 5 # empirically tuned -- cell size only used for Izh1
fih = [h.FInitializeHandler(uvvset), h.FInitializeHandler(0,Isend)]
vref = choices[izhtype][1]() # can define this afterwards even though used in uvvset above
def __init__(self,
label,
pc,
pop_gid_dict,
pos,
rho=333.0,
fdst=0.1,
maxEDist=100.,
dt_lfp=0.5,
seed=1):
self.label = label
self.pc = pc
self.dt_lfp = dt_lfp
self.seed = seed
self.epoint = pos
self.maxEDist = maxEDist
self.rho = rho ## extracellular resistivity, [ohm cm]
self.fdst = fdst ## percent of distant cells to include in the computation
self.meanlfp = []
self.t = []
self.lfp_ids = {}
self.lfp_types = {}
self.lfp_coeffs = {}
self.pop_gid_dict = pop_gid_dict
self.fih_lfp = h.FInitializeHandler(1, self.sample_lfp)
self.setup_lfp()
def setup(self):
h.cvode.use_fast_imem(
1
) # enables fast calculation of transmembrane current (nA) at each segment
self.bscallback = h.beforestep_callback(h.cas()(.5))
self.bscallback.set_callback(self.callback)
fih = h.FInitializeHandler(1, self.LFPinit)
def test_finithandler():
soma = h.Section(name="soma")
fih = h.FInitializeHandler(1, (callback, (0)))
for i in range(2):
h.finitialize()
fih = h.FInitializeHandler(1, (callback, (1)))
for i in range(1):
expect_err("h.finitialize()")
del fih # a mysterious consequence of expect_err is that need this
locals() # in order for the callback to be deleted in time for next
if __name__ == "__main__":
print("another test")
fih = h.FInitializeHandler(1, (callback, (2)))
h.finitialize()
print("this line gets printed in interactive mode")
def __init__(self):
"""
Create an `FinitializeHandler` object in Hoc, which will call the
`_initialize()` method when NEURON is initialized.
"""
h('objref initializer')
h.initializer = self
self.fih = h.FInitializeHandler(1, "initializer._initialize()")
self.clear()
def _do_nbs_register():
global _has_nbs_registered, _nbs, _fih, _fih2
if not _has_nbs_registered:
from neuron import nonvint_block_supervisor as _nbs
_has_nbs_registered = True
_nbs.register(_callbacks)
#
# register the initialization handler and the ion register handler
#
_fih = h.FInitializeHandler(_init)
_fih2 = h.FInitializeHandler(3, initializer._do_ion_register)
#
# register scatter/gather mechanisms
#
_cvode_object.extra_scatter_gather(0, _after_advance)
def set_ecp_recording(self):
'''
Set recording of the ExtraCellular Potential
'''
self.rel = RecXElectrode(self.conf)
for gid in self.gids['biophysical']:
cell = self.net.cells[gid]
self.rel.calc_transfer_resistance(gid, cell.get_seg_coords())
h.cvode.use_fast_imem(1) # make i_membrane_ a range variable
self.fih1 = h.FInitializeHandler(0, self.set_pointers)
def run_simulation(shotnoise_input, cables, params, tstop=2000.,\
dt=0.025, seed=3, recordings='full', recordings2='', nmda_on=False, Ca_spikes_on=False, HH_on=False,\
synchronous_stim={'location':[4,14], 'spikes':[]}):
"""
recordings is a set of tuple of the form : [branch_generation, branch_number, xseg]
"""
exc_synapses, exc_netcons, exc_Ks, exc_spike_trains,\
inh_synapses, inh_netcons, inh_Ks, inh_spike_trains,\
area_lists, spkout = Constructing_the_ball_and_tree(params, cables, nmda_on=nmda_on, Ca_spikes_on=Ca_spikes_on, HH_on=HH_on)
# then synapses manually
set_presynaptic_spikes_manually(shotnoise_input, cables, params,\
exc_spike_trains, exc_Ks,
inh_spike_trains, inh_Ks, tstop, seed=seed,\
synchronous_stim=synchronous_stim)
## QUEUING OF PRESYNAPTIC EVENTS
init_spike_train = queue_presynaptic_events_in_NEURON([exc_netcons, exc_spike_trains, inh_netcons, inh_spike_trains])
## --- launching the simulation
fih = nrn.FInitializeHandler((init_spike_train, [exc_netcons, exc_spike_trains, inh_netcons, inh_spike_trains]))
## --- recording
t_vec = nrn.Vector()
t_vec.record(nrn._ref_t)
V = []
if recordings is 'soma':
V.append(nrn.Vector())
exec('V[0].record(nrn.cable_0_0(0)._ref_v)')
if recordings2 is 'cable_end':
V.append(nrn.Vector())
exec('V[1].record(nrn.cable_5_15(1)._ref_v)')
## --- launching the simulation
nrn.finitialize(params['El']*1e3)
nrn.dt = dt
if recordings is 'full':
V.append(get_v(cables))
while nrn.t<(tstop-dt):
nrn.fadvance()
if recordings is 'full':
V.append(get_v(cables))
print("=======================================")
nrn('forall delete_section()')
print(" --- checking if the neuron is destroyed")
nrn.topology()
print("=======================================")
return np.array(t_vec), V
def setup_recorder(self):
h = self.h
collector_stim = h.NetStim(0.5)
collector_stim.start = 0
collector_stim.interval = self.sampling_period
collector_stim.number = 1e9
collector_stim.noise = 0
collector_con = h.NetCon(collector_stim, None)
collector_con.record(self.collect)
self.collector_stim = collector_stim
self.collector_con = collector_con
# Clear previously recorded activity on h.run()
self.fih = h.FInitializeHandler(self.clear)
def from_skeletal_blender_group(self, blender_group, node):
self.node = node
self.name = blender_group['name']
self.save_recording_params(blender_group)
# Initialize selected roots and their children
for blender_root in blender_group["roots"]:
section = NeuronSection()
section.from_skeletal_blender_root(blender_root, group=self)
if section.name != '':
self.roots[section.name] = section
# Clear previously recorded activity on h.run()
self.fih = h.FInitializeHandler(self.clear_activity)
# Setup to collect activity during h.run()
self.create_collector()
def preRun():
from .. import sim
# set initial v of cells
for cell in sim.net.cells:
sim.fih.append(h.FInitializeHandler(0, cell.initV))
# cvode variables
sim.cvode.active(int(sim.cfg.cvode_active))
sim.cvode.cache_efficient(int(sim.cfg.cache_efficient))
sim.cvode.atol(sim.cfg.cvode_atol)
# set h global params
sim.setGlobals()
# set h.dt
h.dt = sim.cfg.dt
# set v_init if doesn't exist
if 'v_init' not in sim.cfg.hParams: sim.cfg.hParams['v_init'] = -65.0
# parallelcontext vars
sim.pc.set_maxstep(10)
mindelay = sim.pc.allreduce(sim.pc.set_maxstep(10),
2) # flag 2 returns minimum value
if sim.rank == 0 and sim.cfg.verbose:
print(('Minimum delay (time-step for queue exchange) is %.2f' %
(mindelay)))
sim.pc.setup_transfer() # setup transfer of source_var to target_var
# handler for printing out time during simulation run
if sim.rank == 0 and sim.cfg.printRunTime:
def printRunTime():
print('%.1fs' % (h.t / 1000.0))
sim.cvode.event(h.t + int(sim.cfg.printRunTime * 1000.0),
sim.printRunTime)
sim.printRunTime = printRunTime
sim.fih.append(h.FInitializeHandler(1, sim.printRunTime))
# set global index used by all instances of the Random123 instances of Random
if sim.cfg.rand123GlobalIndex is not None:
rand = h.Random()
rand.Random123_globalindex(int(sim.cfg.rand123GlobalIndex))
# reset all netstim randomizers so runs are always equivalent
for cell in sim.net.cells:
if cell.tags.get('cellModel') == 'NetStim':
#cell.hRandom.Random123(sim.hashStr('NetStim'), cell.gid, cell.params['seed'])
utils._init_stim_randomizer(cell.hRandom, 'NetStim', cell.gid,
cell.params['seed'])
cell.hRandom.negexp(1)
cell.hPointp.noiseFromRandom(cell.hRandom)
pop = sim.net.pops[cell.tags['pop']]
if 'originalFormat' in pop.tags and pop.tags[
'originalFormat'] == 'NeuroML2_SpikeSource':
if sim.cfg.verbose:
print("== Setting random generator in NeuroML spike generator")
cell.initRandom()
else:
for stim in cell.stims:
if 'hRandom' in stim:
#stim['hRandom'].Random123(sim.hashStr(stim['source']), cell.gid, stim['seed'])
utils._init_stim_randomizer(stim['hRandom'], stim['type'],
cell.gid, stim['seed'])
stim['hRandom'].negexp(1)
# Check if noiseFromRandom is in stim['hObj']; see https://github.com/Neurosim-lab/netpyne/issues/219
if not isinstance(stim['hObj'].noiseFromRandom, dict):
stim['hObj'].noiseFromRandom(stim['hRandom'])
# handler for recording LFP
if sim.cfg.recordLFP:
def recordLFPHandler():
sim.cvode.event(h.t + float(sim.cfg.recordStep), sim.calculateLFP)
sim.cvode.event(h.t + float(sim.cfg.recordStep), recordLFPHandler)
sim.recordLFPHandler = recordLFPHandler
sim.fih.append(h.FInitializeHandler(
0, sim.recordLFPHandler)) # initialize imemb
# stimulate
stimB = h.IClamp(somaB(0.5))
stimB.delay = 50
stimB.amp = 1
stimB.dur = 50
# record
tvec = h.Vector().record(h._ref_t)
vvecB = h.Vector().record(somaB(0.5)._ref_v)
kvecB = h.Vector().record(somaB(0.5)._ref_ik)
navecB = h.Vector().record(somaB(0.5)._ref_ina)
mvecB = h.Vector().record(somaB(0.5).hh._ref_m)
nvecB = h.Vector().record(somaB(0.5).hh._ref_n)
hvecB = h.Vector().record(somaB(0.5).hh._ref_h)
fih = h.FInitializeHandler(1, restoreSS)
h.finitialize()
h.continuerun(100)
# while h.t < tstop:
# # pc.psolve(h.t + h.dt)
# h.fadvance()
# print(h.t)
# plotting
fig = pyplot.figure()
# pyplot.plot(tvec, vvecA, label="rxd")
pyplot.plot(tvec, vvecB, label="mod")
pyplot.xlabel('t (ms)')
pyplot.ylabel('V$_m$ (mV)')
for a in range(Ncells):
cells[a].soma.el_clarke =\
(cells[a].soma.ina_clarke + cells[a].soma.ikrect_clarke\
+ cells[a].soma.icaN_clarke + cells[a].soma.icaL_clarke\
+ cells[a].soma.ikca_clarke + cells[a].soma.inap_clarke\
+ cells[a].soma.gl_clarke*cells[a].soma.v) / cells[a].soma.gl_clarke
cells[a].dend.e_pas =\
(cells[a].dend.g_pas * cells[a].dend.v) / cells[a].dend.g_pas
# print 'hello from inside init'
h.celsius = 37
net = ClarkeNetwork()
h.v_init = -65
fih = h.FInitializeHandler(2, (tweak_leak, (net.cells, len(net.cells))))
shape_window = h.PlotShape()
shape_window.exec_menu('Show Diam')
soma_v_vec, soma_m_vec, soma_h_vec, soma_n_vec,\
soma_inap_vec, soma_idap_vec, soma_ical_vec,\
soma_ican_vec, soma_ikca_vec, soma_ina_vec, soma_ikrect_vec,\
dend_v_vec, t_vec\
= simrun.set_recording_vectors(net.cells[0])
simrun.simulate(tstop=10000)
simrun.show_output(soma_v_vec, dend_v_vec, t_vec)
pyplot.show()
spikes = net.get_spikes()
sp = spikeplot.SpikePlot(savefig=True)
sp.plot_spikes(spikes)
# record all segments voltage
if collectAndSaveDVTs:
recVoltage_allSegments = []
for segInd, segment in enumerate(allSegments):
voltageRecSegment = h.Vector()
voltageRecSegment.record(segment._ref_v)
recVoltage_allSegments.append(voltageRecSegment)
preparationDurationInSeconds = time.time() - preparationStartTime
print("preparing for single simulation took %.4f seconds" %
(preparationDurationInSeconds))
## simulate the cell
simulationStartTime = time.time()
# make sure the following line will be run after h.finitialize()
fih = h.FInitializeHandler('nrnpython("AddAllSynapticEvents()")')
h.finitialize(-76)
neuron.run(totalSimDurationInMS)
singleSimulationDurationInMinutes = (time.time() -
simulationStartTime) / 60
print("single simulation took %.2f minutes" %
(singleSimulationDurationInMinutes))
## extract the params from the simulation
# collect all relevent recoding vectors (input spike times, dendritic voltage traces, soma voltage trace)
collectionStartTime = time.time()
origRecordingTime = np.array(recTime.to_python())
origSomaVoltage = np.array(recVoltageSoma.to_python())
origNexusVoltage = np.array(recVoltageNexus.to_python())
def __init__(self):
self.fih = h.FInitializeHandler(1, self.callback)
def setup(self):
"""Enables fast calculation of transmembrane current (nA) at
each segment."""
h.cvode.use_fast_imem(1)
self.bscallback = h.cvode.extra_scatter_gather(0, self.callback)
fih = h.FInitializeHandler(1, self.LFPinit)
from neuron import h
h.load_file('nrngui.hoc')
def callback1(tol=0.01):
print("callback1: t=%s" % h.t)
1 / 0
print("I just made a divide-by-zero error")
interval = 10000
print("next callback1 at %s" % (h.t + interval))
h.cvode.event(h.t + interval, callback1)
#return(interval)
h.cvode_active(1)
fih = h.FInitializeHandler(callback1)
h.stdinit()
h.cvode.solve(50000)
def get_cell(env, gid, population):
"""
:param env:
:param gid:
:param population:
:return:
"""
h.load_file("nrngui.hoc")
h.load_file("loadbal.hoc")
h('objref fi_status, fi_checksimtime, pc, nclist, nc, nil')
h('strdef datasetPath')
h('numCells = 0')
h('totalNumCells = 0')
h('max_walltime_hrs = 0')
h('mkcellstime = 0')
h('mkstimtime = 0')
h('connectcellstime = 0')
h('connectgjstime = 0')
h('results_write_time = 0')
h.nclist = h.List()
datasetPath = os.path.join(env.datasetPrefix, env.datasetName)
h.datasetPath = datasetPath
## new ParallelContext object
# h.pc = h.ParallelContext()
# env.pc = h.pc
rank = int(env.pc.id())
nhosts = int(env.pc.nhost())
## polymorphic value template
h.load_file("./templates/Value.hoc")
## randomstream template
h.load_file("./templates/ranstream.hoc")
## stimulus cell template
h.load_file("./templates/StimCell.hoc")
h.xopen("./lib.hoc")
h.dt = env.dt
h.tstop = env.tstop
if env.optldbal or env.optlptbal:
lb = h.LoadBalance()
if not os.path.isfile("mcomplex.dat"):
lb.ExperimentalMechComplex()
if (env.pc.id() == 0):
mkspikeout(env, env.spikeoutPath)
env.pc.barrier()
h.startsw()
mkcells(env)
env.mkcellstime = h.stopsw()
env.pc.barrier()
if (env.pc.id() == 0):
print "*** Cells created in %g seconds" % env.mkcellstime
print "*** Rank %i created %i cells" % (env.pc.id(), len(env.cells))
h.startsw()
mkstim(env)
env.mkstimtime = h.stopsw()
if (env.pc.id() == 0):
print "*** Stimuli created in %g seconds" % env.mkstimtime
env.pc.barrier()
h.startsw()
connectcells(env)
env.connectcellstime = h.stopsw()
env.pc.barrier()
if (env.pc.id() == 0):
print "*** Connections created in %g seconds" % env.connectcellstime
print "*** Rank %i created %i connections" % (env.pc.id(), int(h.nclist.count()))
h.startsw()
# connectgjs(env)
env.connectgjstime = h.stopsw()
if (env.pc.id() == 0):
print "*** Gap junctions created in %g seconds" % env.connectgjstime
env.pc.setup_transfer()
env.pc.set_maxstep(10.0)
h.max_walltime_hrs = env.max_walltime_hrs
h.mkcellstime = env.mkcellstime
h.mkstimtime = env.mkstimtime
h.connectcellstime = env.connectcellstime
h.connectgjstime = env.connectgjstime
h.results_write_time = env.results_write_time
h.fi_checksimtime = h.FInitializeHandler("checksimtime(pc)")
if (env.pc.id() == 0):
print "dt = %g" % h.dt
print "tstop = %g" % h.tstop
h.fi_status = h.FInitializeHandler("simstatus()")
h.v_init = env.v_init
h.stdinit()
h.finitialize(env.v_init)
env.pc.barrier()
if env.optldbal or env.optlptbal:
cx(env)
ld_bal(env)
if env.optlptbal:
lpt_bal(env)
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(0.5))
ic.delay = 0.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(0.5)._ref_v, sec=h.soma)
i_mem = h.Vector()
i_mem.record(h.soma(0.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(0.5).v, h.soma(0.5).hh.m]
from neuron import coreneuron
coreneuron.enable = True
coreneuron.verbose = 0
coreneuron.gpu = enable_gpu
pc = h.ParallelContext()
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
for mode in [0, 1, 2]:
run(mode)
cnargs = coreneuron.nrncore_arg(h.tstop)
h.stdinit()
assert tv.size() == 1 and tvstd.size() != 1
pc.nrncore_run(cnargs, 1)
assert tv.eq(tvstd)
# print warning if HocEvent on event queue when CoreNEURON starts
def test_hoc_event():
print("in test_hoc_event() at t=%g" % h.t)
if h.t < 1.001:
h.CVode().event(h.t + 1.0, test_hoc_event)
fi = h.FInitializeHandler(2, test_hoc_event)
coreneuron.enable = False
run(0)
coreneuron.enable = True
run(0)
matrix[row, i] = 0
else:
matrix[row, :] = 0
global _mat_for_zero_volume_nodes
_mat_for_zero_volume_nodes = matrix.tocsr()
def _init():
# TODO: check about the 0<x<1 problem alluded to in the documentation
h.define_shape()
section1d._purge_cptrs()
for sr in species._get_all_species().values():
s = sr()
if s is not None:
s._register_cptrs()
s._finitialize()
_setup_matrices()
#
# register the initialization handler and the advance handler
#
_fih = h.FInitializeHandler(_init)
#
# register scatter/gather mechanisms
#
_cvode_object.extra_scatter_gather(0, _after_advance)
nrn('create soma')
nrn.soma.insert('pas')
nrn.soma.L, nrn.soma.diam = 58, 58
nrn.soma.g_pas, nrn.soma.e_pas = 5e-5, -70.
syn = nrn.my_glutamate(0.5, sec=nrn.soma)
netcon = nrn.NetCon(nrn.nil, syn)
netcon.weight[0] = 1
syn.gmax = 4
def init_spike_train(ALL):
netcon, spikes = ALL
for spk in spikes:
netcon.event(spk)
syn.nmda_on = ntar
fih = nrn.FInitializeHandler(
(init_spike_train, [netcon, np.arange(10) * 7. + 50.]))
t_vec = nrn.Vector()
t_vec.record(nrn._ref_t)
V = nrn.Vector()
V.record(nrn.soma(0.5)._ref_v)
A = nrn.Vector()
A.record(syn._ref_gampa)
nrn.finitialize(-70.)
while nrn.t < 400.:
nrn.fadvance()
plt.plot(np.array(t_vec), V, '-', color=color, label=label)
plt.legend()
plt.ylim([-80, -30])
plt.show()
# make a 2003a STATE {u,vv} cell (used for 2003, 2004)
iz03a = h.Izhi2003a(0.5, sec=dummy)
iz03a.Iin = 4
# make a 2003b (Section v) cell
sec03b = h.Section() # this section will actually be used
sec03b.L, sec03b.diam = 5, 6.3 # empirically tuned
iz03b = h.Izhi2003b(0.5, sec=sec03b)
iz03b.Iin = 4
def iz03b_init():
sec03b(0.5).v, iz03b.u = -65, -65 * iz03b.b
fih.append(h.FInitializeHandler(iz03b_init))
# make a 2007a (NMODL) cell
iz07a = h.Izhi2007a(0.5, sec=dummy)
iz07a.Iin = 70
# make a 2007b (section) cell
sec07b = h.Section()
sec07b.L, sec07b.diam = 5, 6.3
iz07b = h.Izhi2007b(0.5, sec=sec07b)
iz07b.Iin = 70
def iz07b_init():
sec07b.v = -60
rds.negexp(1)
fihSIGns = h.FInitializeHandler(0, initSigNetStims)
setStims() # create the inputs based on contents of nqm
#this should be called @ beginning of each sim - done in an FInitializeHandler
def init_NetStims():
for i in xrange(len(nrl)):
rds = nrl[i]
sead = nrlsead[i]
rds.MCellRan4(sead, sead)
rds.negexp(1)
fihns = h.FInitializeHandler(0, init_NetStims)
#
def printt():
sys.stdout.write('\rt: {0} ...'.format(h.t))
sys.stdout.flush()
# handler for printing out time during simulation run
def fi():
for i in xrange(int(tstart), int(tstart + tstop), 100):
h.cvode.event(i, printt)
fih = h.FInitializeHandler(1, fi)
def __init__(self, eventTime, cvode, nrnSim):
self.eventTime = eventTime
self.cvode = cvode
self.fih = h.FInitializeHandler(1, self.callback)
def setupWMInputs():
global nqm, rnnsl, rnncl, rnrds, rnseed, fihSIGns
if os.path.exists(dconf['nqm']): # read nqm if it exists
nqm = h.NQS(dconf['nqm'])
else: # setup nqm here if nqm file path non-existant
nqm = h.NQS('vid', 'startt', 'endt', 'rate', 'w')
nqm.odec('vid')
lvid = []
nMem = dconf['nMem']
memstartt = dconf['memstartt']
memintert = dconf['memintert']
memdurt = dconf['memdurt']
memstartt += tstart # this only has an effect when loadstate != 0
startt = memstartt
endt = startt + memdurt
if verbose:
print 'startt:', startt, ',memstartt:', memstartt, ',tstart:', tstart, ',loadstate:', loadstate
for i in xrange(nMem): # number of stimuli
lvid.append(h.Vector())
vtmp = Vector()
vtmp.append(0) # only one cell
lvid[-1].append(vtmp)
nqm.append(lvid[-1], startt, endt, dconf['memrate'], dconf['memW'])
startt += (memdurt + memintert)
if i == nMem - 2 and dconf['lastmemdurt'] != memdurt:
endt = startt + dconf['lastmemdurt']
else:
endt = startt + memdurt
# backup the nqm file for later retrieval
fnqwm = 'meminput/' + simstr + '_nqm.nqs'
if os.path.exists(fnqwm):
os.remove(fnqwm)
nqm.sv(fnqwm)
if verbose:
print 'this is nqm:'
nqm.pr()
def createNetStims(vid,
rate,
w,
startt,
endt,
seed=1234,
syn='Adend3AMPA'):
global rnnsl, rnncl, rnrds, rnseed # based on row number in nqm
rnnsl.append([]) # a list for each row of nqm
rnncl.append([])
rnrds.append([])
rnseed.append([])
sidx = -1
slist = [cell.Adend3, cell.Adend2, cell.Adend1]
if syn.count('AMPA'): sidx = 0
elif syn.count('NMDA'): sidx = 1
elif syn.count('GABAss'): sidx = 2
elif syn.count('mGLUR'): sidx = 3
if syn.count('0'): slist = [cell.Adend3, cell.Adend2, cell.Adend1]
elif syn.count('1'): slist = [cell.Adend1]
elif syn.count('2'): slist = [cell.Adend2]
elif syn.count('3'): slist = [cell.Adend3]
if sidx == -1:
ns = h.NetStim()
ns.start = startt
ns.number = (endt - startt) * rate / 1e3
if verbose:
print 'createNetStims:', startt, endt, ns.number, rate, w
ns.interval = 1e3 / rate
ns.noise = 1
rnnsl[-1].append(ns)
nc = h.NetCon(ns, ce[0].__dict__[syn].syn)
nc.delay = h.dt * 2
nc.weight[0] = w
rnncl[-1].append(nc)
rds = h.Random()
rds.negexp(1)
rds.MCellRan4(seed, seed)
ns.noiseFromRandom(rds)
rnrds[-1].append(rds)
rnseed[-1].append(seed)
else:
tmpseed = seed
for sec in slist:
llsy = cell.dsy[sec]
for lsy in llsy:
ns = h.NetStim()
ns.start = startt
ns.number = (endt - startt) * rate / 1e3
if verbose:
print 'createNetStims:', startt, endt, ns.number, rate, w
ns.interval = 1e3 / rate
ns.noise = 1
rnnsl[-1].append(ns)
nc = h.NetCon(ns, lsy[sidx].syn)
nc.delay = h.dt * 2
nc.weight[0] = w
rnncl[-1].append(nc)
rds = h.Random()
rds.negexp(1)
rds.MCellRan4(tmpseed, tmpseed)
ns.noiseFromRandom(rds)
rnrds[-1].append(rds)
rnseed[-1].append(tmpseed)
tmpseed += 1
def createNetStimsFromNQ(nqm, row, seed=1234, syn='Adend3AMPA', wfctr=1.0):
nqm.tog("DB")
vid = h.Vector()
rate = nqm.getcol("rate").x[row]
w = nqm.getcol("w").x[row] * wfctr # wfctr is weight scaling factor
vid.copy(nqm.get("vid", row).o[0])
startt = float(nqm.getcol("startt").x[row]) # + tstart
endt = float(nqm.getcol("endt").x[row]) # + tstart
createNetStims(vid, rate, w, startt, endt, seed, syn)
def setStims():
global nqm
lapicIDX = []
try:
lapicIDX = [int(dconf['apicIDX'])]
except:
for i in dconf['apicIDX'].split(','):
lapicIDX.append(int(i))
nqm.tog("DB")
sz = int(nqm.v[0].size())
lastmGLURON = dconf['lastmGLURON']
nMemInhib = dconf['nMemInhib']
if lastmGLURON:
for i in xrange(sz):
if i == sz - 1:
for j in lapicIDX:
createNetStimsFromNQ(nqm,
i,
seed=(i + 1) * 12345,
syn='Adend' + str(j) + 'mGLUR',
wfctr=mGLURRWM)
else:
for j in lapicIDX:
createNetStimsFromNQ(nqm,
i,
seed=(i + 1) * 12345,
syn='Adend' + str(j) + 'AMPA',
wfctr=AMRWM)
createNetStimsFromNQ(nqm,
i,
seed=(i + 1) * 12345,
syn='Adend' + str(j) + 'NMDA',
wfctr=NMAMRWM)
elif nMemInhib > 0:
for i in xrange(0, sz - nMemInhib, 1):
for j in lapicIDX:
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'AMPA',
wfctr=AMRWM)
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'NMDA',
wfctr=NMAMRWM)
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'mGLUR',
wfctr=mGLURRWM)
for i in xrange(sz - nMemInhib, sz, 1):
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'GABAss',
wfctr=GARWM)
else:
for i in xrange(sz):
for j in lapicIDX:
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'AMPA',
wfctr=AMRWM)
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'NMDA',
wfctr=NMAMRWM)
createNetStimsFromNQ(nqm,
i,
seed=j * (i + 1) * 12345,
syn='Adend' + str(j) + 'mGLUR',
wfctr=mGLURRWM)
def initSigNetStims():
for i in xrange(len(rnnsl)):
for j in xrange(len(rnnsl[i])):
rds = rnrds[i][j]
sead = rnseed[i][j]
rds.MCellRan4(sead, sead)
rds.negexp(1)
fihSIGns = h.FInitializeHandler(0, initSigNetStims)
setStims() # create the inputs based on contents of nqm
(cells[a].soma.ina_clarke + cells[a].soma.ikrect_clarke\
+ cells[a].soma.icaN_clarke + cells[a].soma.icaL_clarke\
+ cells[a].soma.ikca_clarke + cells[a].soma.inap_clarke\
+ cells[a].soma.gl_clarke*cells[a].soma.v) / cells[a].soma.gl_clarke
cells[a].dend.e_pas =\
(cells[a].dend.g_pas * cells[a].dend.v) / cells[a].dend.g_pas
cells = []
N = 3
r = 50 # Radius of cell locations from origin (0,0,0) in microns
h.celsius = 37
h.v_init = -65
h.dt = 0.01
fih = h.FInitializeHandler(2, (tweak_leak, (cells, N)))
#Set up Draw
fig1 = pyplot.figure(figsize=(8, 4))
ax1a = fig1.add_subplot(2, 1, 1)
ax2a = fig1.add_subplot(2, 1, 2, sharex=ax1a)
fig2 = pyplot.figure(figsize=(5, 16))
ax1b = fig2.add_subplot(3, 1, 1)
ax2b = fig2.add_subplot(3, 1, 2, sharex=ax1b)
ax3b = fig2.add_subplot(3, 1, 3, sharex=ax1b)
ax1b.set_xlim([0, 20])
ax1b.set_ylim([0, 1])
#ax1b.set_ylim([-72,-60])
#step = 2.5e-2 #CaN