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