def makeNoiseNetStim(cel, nsl, ncl, nrl, nrlsead, syn, w, ISI, time_limit,
sead):
rd2 = h.Random()
rd2.ACG(sead)
rd2.uniform(0, 1e3)
ns = h.NetStim()
ns.interval = ISI
ns.noise = 1
ns.number = 2 * time_limit / ISI # create enough spikes for extra time, in case goes over limit
ns.start = 0 # tstart
if type(syn) == str: nc = h.NetCon(ns, cel.__dict__[syn].syn)
else: nc = h.NetCon(ns, syn)
nc.delay = h.dt * 2 # 0
nc.weight[0] = w
rds = h.Random()
rds.negexp(
1) # set random # generator using negexp(1) - avg interval in NetStim
rds.MCellRan4(sead, sead) # seeds are in order, shouldn't matter
ns.noiseFromRandom(rds) # use random # generator for this NetStim
ns.start = 0. # rd2.repick() # start inputs random time btwn 0-1e3 ms to avoid artificial sync
nsl.append(ns)
ncl.append(nc)
nrl.append(rds)
nrlsead.append(sead)
cel.infod[syn] = [
ns, nc
] #store pointers to NetStim,NetCon for easier manipulation
def __init__(self, seed=None, parallel_safe=True):
WrappedRNG.__init__(self, seed, parallel_safe)
if self.seed is None:
self.rng = h.Random()
else:
self.rng = h.Random(self.seed)
self.last_distribution = None
def celltypeinfo(type, nbranch, ncompart):
r = h.Random()
r.Random123(type, 2)
nb = int(r.discunif(nbranch[0], nbranch[1]))
secpar = h.Vector(nb)
segvec = h.Vector(nb)
r.discunif(ncompart[0], ncompart[1])
for i in range(nb):
segvec.x[i] = int(r.repick())
# nb branches and every branch has 0, 1, or 2 children
# ie. no integer in secpar appears more than twice
x = [[0, 0]]
for i in range(1, nb):
a = int(r.discunif(0, len(x) - 1))
secpar.x[i] = x[a][0]
x[a][1] += 1
if x[a][1] > 1:
x[a][0] = i
x[a][1] = 0
else:
x.append([i, 0])
#print type, secpar.to_python()
return secpar, segvec
def addNetStim (self, params, stimContainer=None):
from .. import sim
if not stimContainer:
self.stims.append(Dict(params.copy())) # add new stim to Cell object
stimContainer = self.stims[-1]
if sim.cfg.verbose: print((' Created %s NetStim for cell gid=%d'% (params['source'], self.gid)))
if sim.cfg.createNEURONObj:
rand = h.Random()
stimContainer['hRandom'] = rand # add netcon object to dict in conns list
if isinstance(params['rate'], str):
if params['rate'] == 'variable':
try:
netstim = h.NSLOC()
netstim.interval = 0.1**-1*1e3 # inverse of the frequency and then convert from Hz^-1 to ms (set very low)
netstim.noise = params['noise']
except:
print('Error: tried to create variable rate NetStim but NSLOC mechanism not available')
else:
print('Error: Unknown stimulation rate type: %s'%(h.params['rate']))
else:
netstim = h.NetStim()
netstim.interval = params['rate']**-1*1e3 # inverse of the frequency and then convert from Hz^-1 to ms
netstim.noise = params['noise'] # note: random number generator initialized via Random123() from sim.preRun()
netstim.start = params['start']
netstim.number = params['number']
stimContainer['hNetStim'] = netstim # add netstim object to dict in stim list
return stimContainer['hNetStim']
def ValidateFunction(strFunc, netParamsVars):
''' returns True if "strFunc" can be evaluated'''
rand = h.Random()
stringFuncRandMethods = ['binomial', 'discunif', 'erlang', 'geometric', 'hypergeo',
'lognormal', 'negexp', 'normal', 'poisson', 'uniform', 'weibull']
for randmeth in stringFuncRandMethods: strFunc = strFunc.replace(randmeth, 'rand.'+randmeth)
variables = {
"pre_x" : 1, "pre_y" : 1, "pre_z" : 1,
"post_x" : 1, "post_y" : 1, "post_z" : 1,
"dist_x" : 1, "dist_y" : 1, "dist_z" : 1,
"pre_xnorm" : 1, "pre_ynorm" : 1, "pre_znorm" : 1,
"post_xnorm" : 1, "post_ynorm" : 1, "post_znorm" : 1,
"dist_xnorm" : 1, "dist_ynorm" : 1, "dist_znorm" : 1,
"dist_3D" : 1, "dist_3D_border" : 1, "dist_2D" : 1,
"dist_norm3D": 1, "dist_norm2D" : 1, "rand": rand
}
# add netParams variables
for k, v in netParamsVars.iteritems():
if isinstance(v, Number):
variables[k] = v
try:
eval(strFunc, variables)
return True
except:
return False
def __init__(self, gid):
self.soma = h.Section(name="soma", cell=self)
if gid % 2 == 0:
# CoreNEURON permutation not the identity if cell topology not homogeneous
self.dend = h.Section(name="dend", cell=self)
self.dend.connect(self.soma(0.5))
self.gid = gid
pc.set_gid2node(gid, pc.id())
self.r = h.Random()
self.r.Random123(gid, 0, 0)
self.syn = h.DAsyn(self.soma(0.5))
pc.cell(gid, h.NetCon(self.soma(0.5)._ref_v, None, sec=self.soma))
# random start times for the internal events
self.syn.tau0 = 10 * self.r.uniform(0.9, 1.1)
self.syn.tau1 = 3 * self.r.uniform(0.9, 1.1)
self.syn.dur = 6 * self.r.uniform(1, 10)
self.ns = h.NetStim()
self.ns.noise = 1
self.ns.start = 0
self.ns.number = 1e9
self.ns.interval = 6
self.ns.noiseFromRandom123(gid, 0, 1)
self.nc = h.NetCon(self.ns, self.syn)
self.nc.weight[0] = 0.1 * self.r.uniform(0.9, 1.1)
self.nc.delay = 1
self.msgvec = h.Vector()
self.msgvec.record(self.syn._ref_msg, sec=self.soma)
def validateFunction(strFunc, netParamsVars):
''' returns True if "strFunc" can be evaluated'''
from math import exp, log, sqrt, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, pi, e
rand = h.Random()
stringFuncRandMethods = ['binomial', 'discunif', 'erlang', 'geometric', 'hypergeo',
'lognormal', 'negexp', 'normal', 'poisson', 'uniform', 'weibull']
for randmeth in stringFuncRandMethods: strFunc = strFunc.replace(randmeth, 'rand.'+randmeth)
variables = {
"pre_x" : 1, "pre_y" : 1, "pre_z" : 1,
"post_x" : 1, "post_y" : 1, "post_z" : 1,
"dist_x" : 1, "dist_y" : 1, "dist_z" : 1,
"pre_xnorm" : 1, "pre_ynorm" : 1, "pre_znorm" : 1,
"post_xnorm" : 1, "post_ynorm" : 1, "post_znorm" : 1,
"dist_xnorm" : 1, "dist_ynorm" : 1, "dist_znorm" : 1,
"dist_3D" : 1, "dist_3D_border" : 1, "dist_2D" : 1,
"dist_norm3D": 1, "dist_norm2D" : 1, "rand": rand,
"exp": exp, "log":log, "sqrt": sqrt,
"sin":sin, "cos":cos, "tan":tan, "asin":asin,
"acos":acos, "atan":atan, "sinh":sinh, "cosh":cosh,
"tanh":tanh, "pi":pi,"e": e
}
# add netParams variables
for k, v in netParamsVars.items():
if isinstance(v, Number):
variables[k] = v
try:
eval(strFunc, variables)
return True
except:
return False
def __init__(self, params=None):
self.params = params
# params that can be expressed using string-based functions in connections
self.connStringFuncParams = ['weight', 'delay', 'synsPerConn', 'loc']
# params that can be expressed using string-based functions in stims
self.stimStringFuncParams = [
'delay', 'dur', 'amp', 'gain', 'rstim', 'tau1', 'tau2', 'onset',
'tau', 'gmax', 'e', 'i', 'interval', 'rate', 'number', 'start',
'noise'
]
# list of h.Random() methods allowed in string-based functions (both for conns and stims)
self.stringFuncRandMethods = [
'binomial', 'discunif', 'erlang', 'geometric', 'hypergeo',
'lognormal', 'negexp', 'normal', 'poisson', 'uniform', 'weibull'
]
self.rand = h.Random() # random number generator
self.pops = ODict() # list to store populations ('Pop' objects)
self.cells = [] # list to store cells ('Cell' objects)
self.cells_dpls = {
} # dict with vectors of dipole over time for each cell
self.cells_dpl = {
} # dict with vectors of dipole at one time for each cell
self.gid2lid = {
} # Empty dict for storing GID -> local index (key = gid; value = local id) -- ~x6 faster than .index()
self.lastGid = 0 # keep track of last cell gid
self.lastGapId = 0 # keep track of last gap junction gid
def RandUnifVec (rdmS,sz,amp): vrd = Vector(sz) rdm = h.Random() rdm.ACG(rdmS) rdm.uniform(-amp,amp) vrd = Vector(sz) vrd.setrand(rdm) return vrd
def RandNormVec (rdmS,sz,mu,std): vrd = Vector(sz) rdm = h.Random() rdm.ACG(rdmS) rdm.normal(mu,std**2) # takes mean and variance (std**2) vrd = Vector(sz) vrd.setrand(rdm) return vrd
def __init__(self, **kwargs):
super(GaussianNoiseCurrentSource, self).__init__()
for k in kwargs: self.__dict__[k] = kwargs[k]
self.randgen = h.Random(self.seed)
self.randgen.normal(0.0, 1.0)
self.signal = h.Vector(int(self.stop*h.steps_per_ms)) # prepare the vectors to play.
self.signal.setrand(self.randgen) # assign the random number genetor to the vectors.
self.electrodes = []
def synapse_seg_counts(layer_density_dicts,
sec_index_dict,
seglist,
seed,
neurotree_dict=None):
"""Computes per-segment relative counts of synapse placement. """
segcounts_dict = {}
layers_dict = {}
segcount_total = 0
if neurotree_dict is not None:
secnodes_dict = neurotree_dict['section_topology']['nodes']
else:
secnodes_dict = None
for (syn_type, layer_density_dict) in layer_density_dicts.iteritems():
rans = {}
for (layer, density_dict) in layer_density_dict.iteritems():
ran = h.Random(seed)
ran.normal(density_dict['mean'], density_dict['variance'])
rans[layer] = ran
segcounts = []
layers = []
for seg in seglist:
L = seg.sec.L
nseg = seg.sec.nseg
if neurotree_dict is not None:
secindex = sec_index_dict[seg.sec]
secnodes = secnodes_dict[secindex]
layer = get_node_attribute('layer', neurotree_dict, seg.sec,
secnodes, seg.x)
else:
layer = -1
layers.append(layer)
ran = None
if layer > -1:
if rans.has_key(layer):
ran = rans[layer]
elif rans.has_key('default'):
ran = rans['default']
else:
ran = None
elif rans.has_key('default'):
ran = rans['default']
else:
ran = None
if ran is not None:
l = L / nseg
dens = ran.repick()
rc = dens * l
segcount_total += rc
segcounts.append(rc)
else:
segcounts.append(0)
segcounts_dict[syn_type] = segcounts
layers_dict[syn_type] = layers
return (segcounts_dict, segcount_total, layers_dict)
def init_v():
# to get nontrivial initialized i_membrane_, initialize to random voltage.
r = h.Random()
r.Random123(0, 1, 0)
for sec in h.allsec():
for seg in sec.allseg():
# don't care if some segments counted twice
seg.v = -65.0 + r.uniform(0, 5)
h.finitialize()
def __init__(self, gid):
self.soma = h.Section(name="soma", cell=self)
self.gid = gid
pc.set_gid2node(gid, pc.id())
self.r = h.Random()
self.r.Random123(gid, 0, 0)
self.syn = h.ForNetConTest(self.soma(.5))
pc.cell(gid, h.NetCon(self.syn, None))
# random start times for the internal events
self.syn.tbegin = self.r.discunif(0, 100) * h.dt
def generateLocations(cell, number_of_synapses):
locs = []
seed = 1
rd = h.Random(seed)
total_basal_L, total_L = getLengths(cell)
print number_of_synapses
for i in range(number_of_synapses):
loc = random_synapse(cell, rd, total_L, total_basal_L)
locs.append(loc)
return locs
def nativeRNG_pick(n, rng, distribution='uniform', parameters=[0, 1]):
"""
Pick random numbers from a Hoc Random object.
Return a Numpy array.
"""
native_rng = h.Random(0 or rng.seed)
rarr = [getattr(native_rng, distribution)(*parameters)]
rarr.extend([native_rng.repick() for j in xrange(n - 1)])
return numpy.array(rarr)
def test_NetStim_noise():
# Can use noiseFromRandom
use_noiseFromRandom123 = False
cells = {
gid: (h.NetStim(), h.Random())
for gid in range(pc.id(), 5, pc.nhost())
}
for gid, cell in cells.items():
pc.set_gid2node(gid, pc.id())
pc.cell(gid, h.NetCon(cell[0], None))
cell[1].Random123(gid, 2, 3)
cell[1].negexp(1)
if use_noiseFromRandom123:
cell[0].noiseFromRandom123(gid, 2, 3)
else:
cell[0].noiseFromRandom(cell[1])
cell[0].interval = gid + 1
cell[0].number = 100
cell[0].start = 0
cell[0].noise = 1
spiketime = h.Vector()
spikegid = h.Vector()
pc.spike_record(-1, spiketime, spikegid)
pc.set_maxstep(10)
tstop = 100
for cell in cells.values():
cell[1].seq(0) # only _ran_compat==2 initializes the streams
h.finitialize()
pc.psolve(tstop)
spiketime_std = spiketime.c()
spikegid_std = spikegid.c()
print("spiketime_std.size %d" % spiketime_std.size())
spiketime.resize(0)
spikegid.resize(0)
from neuron import coreneuron
h.CVode().cache_efficient(True)
coreneuron.verbose = 0
coreneuron.enable = True
for cell in cells.values():
cell[1].seq(0)
h.finitialize()
while h.t < tstop:
h.continuerun(h.t + 5)
pc.psolve(h.t + 5)
print("spiketime.size %d" % spiketime.size())
assert spiketime.eq(spiketime_std)
assert spikegid.eq(spikegid_std)
pc.gid_clear()
def run(tstop, ics, tolerance):
# to get nontrivial initialized i_membrane_, initialize to random voltage.
r = h.Random()
r.Random123(0, 1, 0)
for sec in h.allsec():
for seg in sec.allseg():
# don't care if some segments counted twice
seg.v = -65.0 + r.uniform(0, 5)
h.finitialize()
balanced(ics, tolerance)
while h.t < 1.0:
h.fadvance()
balanced(ics, tolerance)
def initRandom(self):
from .. import sim
rand = h.Random()
self.stims.append(Dict()) # add new stim to Cell object
randContainer = self.stims[-1]
randContainer['hRandom'] = rand
randContainer['type'] = self.tags['cellType']
seed = sim.cfg.seeds['stim']
randContainer['seed'] = seed
self.secs['soma']['pointps'][self.tags['cellType']].hObj.noiseFromRandom(rand) # use random number generator
sim._init_stim_randomizer(rand, self.tags['pop'], self.tags['cellLabel'], seed)
randContainer['hRandom'].negexp(1)
def __init__(self):
self.cells = [Cell(i) for i in range(5)]
cvode.use_fast_imem(1)
# a few intrinsically firing ARTIFICIAL_CELLS with and without gids
self.acells = [h.IntervalFire() for _ in range(8)]
r = h.Random()
r.Random123(6, 0, 0)
for a in self.acells:
a.tau = r.uniform(2, 5)
a.invl = r.uniform(2, 4)
for i, a in enumerate(self.acells[5:]):
pc.set_gid2node(i + 5, pc.id())
pc.cell(i + 5, h.NetCon(a, None))
def __init__(self, gid):
self.soma = h.Section(name="soma", cell=self)
if gid % 2 == 0:
# CoreNEURON permutation not the identity if cell topology not homogeneous
self.dend = h.Section(name="dend", cell=self)
self.dend.connect(self.soma(0.5))
self.gid = gid
pc.set_gid2node(gid, pc.id())
self.r = h.Random()
self.r.Random123(gid, 0, 0)
self.syn = h.ForNetConTest(self.soma(0.5))
pc.cell(gid, h.NetCon(self.syn, None))
# random start times for the internal events
self.syn.tbegin = self.r.discunif(0, 100) * h.dt
def __init__(self, id, nsec):
r = h.Random()
r.Random123(id, 0, 0)
nsec += int(r.discunif(0, 4)) # for nontrivial cell_permute=1
self.id = id
self.secs = [
h.Section(name="d" + str(i), cell=self) for i in range(nsec)
]
# somewhat random tree, d[0] plays role of soma with connections to
# d[0](0.5) and all others to 1.0
for i in range(1, nsec):
iparent = int(r.discunif(0, i - 1))
x = 0.5 if iparent == 0 else 1.0
self.secs[i].connect(self.secs[iparent](x))
# uniform L and diam but somewhat random passive g and e
for i, sec in enumerate(self.secs):
sec.L = 10 if i > 0 else 5
sec.diam = 1 if i > 0 else 5
sec.insert("pas")
sec.g_pas = 0.0001 * r.uniform(1.0, 1.1)
sec.e_pas = -65 * r.uniform(1.0, 1.1)
# IClamp and ExpSyn at every location (even duplicates) with random
# parameters (would rather use a Shunt, but ...)
self.ics = []
self.syns = []
self.netcons = []
self.netstim = h.NetStim()
self.netstim.number = 1
self.netstim.start = 0.0
for sec in self.secs:
for seg in sec.allseg():
ic = h.IClamp(seg)
ic.delay = 0.1
ic.dur = 1.0
ic.amp = 0.001 * r.uniform(1.0, 1.1)
self.ics.append(ic)
syn = h.ExpSyn(seg)
syn.e = -65 * r.uniform(1.0, 1.1)
syn.tau = r.uniform(0.1, 1.0)
self.syns.append(syn)
nc = h.NetCon(self.netstim, syn)
nc.delay = 0.2
nc.weight[0] = 0.001 * r.uniform(1.0, 1.1)
self.netcons.append(nc)
def __init__(self):
self.cells = [Cell(i) for i in range(5)]
# This is not supported on GPU, see:
# https://github.com/BlueBrain/CoreNeuron/issues/197
cvode.use_fast_imem(not enable_gpu)
# a few intrinsically firing ARTIFICIAL_CELLS with and without gids
self.acells = [h.IntervalFire() for _ in range(8)]
r = h.Random()
r.Random123(6, 0, 0)
for a in self.acells:
a.tau = r.uniform(2, 5)
a.invl = r.uniform(2, 4)
for i, a in enumerate(self.acells[5:]):
pc.set_gid2node(i + 5, pc.id())
pc.cell(i + 5, h.NetCon(a, None))
def activate_functional_synapse(syn, cell, preSynCell, synParameters, tChange=None, synParametersChange=None):
'''Default method to activate single synapse.
Currently, this implementation expects all presynaptic spike
times to be pre-computed; can thus not be used in recurrent
network models at this point.'''
releaseTimes = []
if synParameters.has_key('releaseProb') and synParameters.releaseProb != 'dynamic':
prel = synParameters.releaseProb
if tChange is not None:
prelChange = synParametersChange.releaseProb
for t in preSynCell.spikeTimes:
if tChange is not None:
if t >= tChange:
if np.random.rand() < prelChange:
releaseTimes.append(t)
continue
if np.random.rand() < prel:
releaseTimes.append(t)
else:
releaseTimes = preSynCell.spikeTimes[:]
if not len(releaseTimes):
return
releaseTimes.sort()
releaseSite = PointCell(releaseTimes)
releaseSite.play()
receptors = synParameters.receptors
syn.activate_hoc_syn(releaseSite, preSynCell, cell, receptors)
if synParameters.has_key('releaseProb') and synParameters.releaseProb == 'dynamic':
syn.hocRNG = h.Random(int(1000000*np.random.rand()))
syn.hocRNG.negexp(1)
# set properties for all receptors here
for recepStr in receptors.keys():
recep = receptors[recepStr]
for param in recep.parameter.keys():
# try treating parameters as hoc range variables,
# then as hoc global variables
try:
paramStr = 'syn.receptors[\'' + recepStr + '\'].'
paramStr += param + '=' + str(recep.parameter[param])
exec(paramStr)
except LookupError:
paramStr = param + '_' + recepStr + '='
paramStr += str(recep.parameter[param])
h(paramStr)
if synParameters.has_key('releaseProb') and synParameters.releaseProb == 'dynamic':
paramStr = 'syn.receptors[\'' + recepStr + '\'].setRNG(syn.hocRNG)'
exec(paramStr)
def __init__(self, gid):
nsec = 5
self.gid = gid
r = h.Random()
self.r = r
r.Random123(gid, 0, 0)
self.secs = [h.Section(name="s%d" % i, cell=self) for i in range(nsec)]
s0 = self.secs[0]
# random connect to exercise permute
for i, s in enumerate(self.secs[1:]):
s.connect(self.secs[int(r.discunif(0, i))])
# hh and pas everywhere with random gkbar_hh and g_pas for intrinsic firing.
# everywhere but s0.
s = self.secs[0]
s.L = 10
s.diam = 10
s.insert("hh")
for s in self.secs[1:]:
s.nseg = 4
s.L = 50
s.diam = 1
s.insert("pas")
s.e_pas = -65
s.g_pas = r.uniform(.0001, .0002)
s.insert("hh")
s.gkbar_hh = r.uniform(.01, .02)
pc.set_gid2node(gid, pc.id())
pc.cell(gid, h.NetCon(s0(.5)._ref_v, None, sec=s0))
# add a few random Netstim -> NetCon -> Exp2Syn connections to verify
# correct data return for ARTIFICIAL_CELL and POINT_PROCESS
nsyn = 3
self.stims = [h.NetStim() for _ in range(nsyn)]
self.syns = [
h.Exp2Syn(self.secs[int(r.discunif(0, nsec - 1))](.5))
for _ in range(nsyn)
]
self.ncs = [h.NetCon(self.stims[i], self.syns[i]) for i in range(nsyn)]
for stim in self.stims:
stim.start = int(r.uniform(0, 1) / h.dt) * h.dt
stim.interval = int(r.uniform(1, 2) / h.dt) * h.dt
for nc in self.ncs:
nc.weight[0] = r.uniform(0.0, .001)
nc.delay = int(r.discunif(5, 20)) * h.dt
def cellran(gid, nclist):
r = h.Random()
r.Random123(gid)
r.uniform(1.0, 1.1)
cell = pc.gid2cell(gid)
for sec in cell.all:
sec.L *= r.repick()
for seg in sec:
seg.diam *= r.repick()
seg.cm *= r.repick()
#print 'diam ', seg.diam, 'cm ', seg.cm
#mechanism variables
for mech in seg:
ms = h.MechanismStandard(mech.name(), 1)
for i in range(int(ms.count())):
varname = h.ref("")
sz = ms.name(varname, i)
n = varname[0]
x = seg.__getattribute__(n)
setattr(seg, n, x * r.repick())
#print n, seg.__getattribute__(n)
#point process parameters
for p in seg.point_processes():
n = p.hname()
n = n[:n.index('[')]
if n == 'HalfGap':
continue
ms = h.MechanismStandard(n, 1)
for i in range(int(ms.count())):
varname = h.ref("")
ms.name(varname, i)
x = p.__getattribute__(varname[0])
setattr(p, varname[0], x * r.repick())
#print varname[0], p.__getattribute__(varname[0])
#netcons targeting the cell
for nc in nclist:
if nc.postcell() == cell:
nc.weight[0] *= r.repick()
nc.delay *= r.repick()
pc.threshold(gid, pc.threshold(gid) + r.uniform(-9, 0))
def __init__(self, gid):
self.soma = h.Section(name="soma", cell=self)
if gid % 2 == 0:
# CoreNEURON permutation not the identity if cell topology not homogeneous
self.dend = h.Section(name="dend", cell=self)
self.dend.connect(self.soma(0.5))
self.gid = gid
pc.set_gid2node(gid, pc.id())
self.r = h.Random()
self.r.Random123(gid, 0, 0)
self.syn = h.Bounce(self.soma(0.5))
pc.cell(gid, h.NetCon(self.soma(0.5)._ref_v, None, sec=self.soma))
self.syn.noiseFromRandom123(gid, 0, 1)
self.t1vec = h.Vector()
self.t1vec.record(self.syn._ref_t1, sec=self.soma)
self.xvec = h.Vector()
self.xvec.record(self.syn._ref_x, sec=self.soma)
self.rvec = h.Vector()
self.rvec.record(self.syn._ref_r, sec=self.soma)
def __init__(self, id, nsec):
r = h.Random()
r.Random123(id, 0, 0)
nsec += int(r.discunif(0, 4)) # for nontrivial cell_permute=1
self.id = id
self.secs = [
h.Section(name="d" + str(i), cell=self) for i in range(nsec)
]
# somewhat random tree, d0 plays role of soma with child connections to
# d0(.5) and all others to 1.0
for i in range(1, nsec):
iparent = int(r.discunif(0, i - 1))
x = 0.5 if iparent == 0 else 1.0
self.secs[i].connect(self.secs[iparent](x))
# uniform L and diam but somewhat random passive g and e
for i, sec in enumerate(self.secs):
sec.nseg = int(r.discunif(3, 5)) if i > 0 else 1
sec.L = 200 if i > 0 else 5
sec.diam = 1 if i > 0 else 5
sec.insert("pas")
sec.g_pas = 0.0001 * r.uniform(1.0, 1.1)
sec.e_pas = -65 * r.uniform(1.0, 1.1)
self.secs[0].insert("hh")
# IClamp at d2(0)
# As i_membane_ does not include ELECTRODE_CURRENT, comparison with
# im_axial should be done after ic completes.
ic = h.IClamp(self.secs[2](0))
ic.delay = 0.0
ic.dur = 0.2
ic.amp = 5.0
self.ic = ic
# axial at every internal segment, a unique AxialPP at root
# and at every sec(1) zero area node.
self.axialpps = [h.AxialPP(self.secs[0](0))]
for sec in self.secs:
sec.insert("axial")
self.axialpps.append(h.AxialPP(sec(1)))
def __init__(self, el=-60):
self.soma = h.Section(name='soma')
self.soma.nseg = 1
self.soma.diam = 500 # um
self.soma.L = 500 # um
self.soma.cm = 1 # uF
self.soma.insert('leak')
self.soma.insert('na')
self.soma.insert('k')
self.soma.nao = 79.8
self.soma.ki = 69.35
self.soma.el_leak = el # mV
self.gl = 0.0003 # leak channel S/cm2
self.gna = 0.12 # Sodium channel S/cm2
self.gk = 0.036 # Potassium channel S/cm2
self.stim = h.IClamp(self.soma(0.5)) # current injection object
self.stim.delay = 0
self.stim.dur = h.tstop
self.rand = h.Random() # random number generator
self.inj = h.Vector() # current inject vector
self.i = h.Vector() # current injection record
self.i.record(self.stim._ref_i)
self.v = h.Vector() # membrane voltage record
self.v.record(self.soma(0.5)._ref_v)
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
