def test_netcon_inter(self): from neuron import h s1 = h.NetStim() s2 = h.NetStim() s3 = p.NetStim() s4 = p.NetStim() # Test that only Python objects that play by the rules can be connected. self.assertRaises(NotConnectableError, p.NetCon, s1, s2) self.assertRaises(NotConnectableError, p.NetCon, s3, s2) self.assertRaises(NotConnectableError, p.NetCon, s1, s4) self.assertEqual(patch.objects.NetCon, type(p.NetCon(s3, s4)), "Valid NetCon failed")
def get_netstim(start, number, interval, noise): stim = h.NetStim() stim.start = start stim.number = number stim.interval = interval stim.noise = noise return stim
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 Add_NMDA_SingleSynapticEventToSegment(segment, activationTime, synapseWeight, exc_inh): if exc_inh == 0: # inhibitory synapse = h.ProbGABAAB_EMS(segment) #GABAA/B synapse.tau_r_GABAA = 0.2 synapse.tau_d_GABAA = 8 synapse.tau_r_GABAB = 3.5 synapse.tau_d_GABAB = 260.9 # synapse.gmax = .001 synapse.e_GABAA = -80 synapse.e_GABAB = -97 synapse.GABAB_ratio = 0.0 else: # excitatory synapse = h.ProbAMPANMDA2(segment) synapse.gmax = .0004 synapse.Use = 1.0 synapse.Dep = 0 synapse.Fac = 0 netStimulation = h.NetStim() netStimulation.number = 1 netStimulation.start = activationTime netConnection = h.NetCon(netStimulation, synapse) netConnection.delay = 0 netConnection.weight[0] = synapseWeight return netStimulation, netConnection, synapse
def __init__(self, mechname): #set variables in case of exception so that __del__ still works. self.nc = None self.stim = None self.syn = None self.vc = None self.s = None self.mechname = mechname constructor = h.__getattribute__(mechname) self.soma = h.Section(name='soma') s = self.soma s.L = 10. s.diam = 10. / h.PI s.insert('pas') seg = s(0.5) seg.e_pas = -65.0 seg.g_pas = 0.0001 self.syn = constructor(seg) self.stim = h.NetStim() self.stim.number = 2 self.stim.interval = 5 self.stim.start = 1 self.nc = h.NetCon(self.stim, self.syn) self.nc.delay = 1 self.nc.weight[0] = .001 if use_voltage_clamp: self.vc = h.SEClamp(seg) self.vc.amp1 = -65.0 self.vc.dur1 = 1e9
def __init__(self, N=5, stim_w=0.04, stim_t=9, stim_delay=1, syn_w=0.01, syn_delay=5, r=50): """ :param N: Number of cells. :param stim_w: Weight of the stimulus :param stim_t: time of the stimulus (in ms) :param stim_delay: delay of the stimulus (in ms) :param syn_w: Synaptic weight :param syn_delay: Delay of the synapse :param r: radius of the network """ self._N = N self.set_gids() ### assign gids to processors self._syn_w = syn_w self._syn_delay = syn_delay self._create_cells( r) ### changed to use self._N instead of passing in N self._connect_cells() ### the 0th cell only exists on one process... that's the only one that gets a netstim if pc.gid_exists(0): self._netstim = h.NetStim() self._netstim.number = 1 self._netstim.start = stim_t self._nc = h.NetCon( self._netstim, pc.gid2cell( 0).syn) ### grab cell with gid==0 wherever it exists self._nc.delay = stim_delay self._nc.weight[0] = stim_w
def izhstim () : stim=h.NetStim(0.5) stim.number = stim.start = 1 nc = h.NetCon(stim,izh) nc.delay = 2 nc.weight = 0.1 izh.erev = -5
def __init__(self, spike_train=None, position = np.array([0,0,0]),whatami ='mossy',record_all = 0): self.record_all = record_all self.spike_train = spike_train self.whatami = whatami self.position = position if spike_train is not None: self.spk_vector = h.Vector() # Populate Vector for time in spike_train: self.spk_vector.append(float(time)) self.output = h.VecStim() self.output.play(self.spk_vector) else: self.output = h.NetStim(0.5) self.output.start = -10 self.output.number = 0 self.output.interval = 1e9 self.record = {} self.nc_spike = h.NetCon(self.output,None) self.record['spk'] = h.Vector() self.nc_spike.record(self.record['spk'])
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 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 setIPClamp(seg, delay, freq, number, dur, amp): ns = h.NetStim() ns.start, ns.interval, ns.number = delay, 1000 / freq, number ipstim = h.IPClamp(seg) ipstim.dur, ipstim.amp = dur, amp nc = h.NetCon(ns, ipstim, 0, 0.5, 1) return [ns, nc, ipstim]
def addGABA(self, weightMap, numStims, jitter=False): tstart = self.stimStart tstop = self.stimStop for tuple in weightMap: loc = tuple[0] synapseWeight = tuple[1] treeNum = loc[0] tree = self.trees[treeNum] section = tree[loc[1]] segLoc = self.getSegLoc(loc) # syn = h.ExpSyn(self.getSegLoc(i),sec=self.dend) syn = h.ProbGABAAB_EMS(segLoc, sec=section) if self.Current: syn = h.ProbGABAAB_EMS_Current(segLoc, sec=section) #syn.GABAB_ratio = 0.33 self.synapses[loc].append(syn) if jitter == True: stimTimes = np.random.randint( tstart, tstop, size=numStims) # 2 in 50 ms = 40Hz else: stimTimes = range(tstart, tstop, (tstop - tstart) / numStims) for time in stimTimes: stim = h.NetStim() stim.number = 1 stim.start = time ncstim = h.NetCon(stim, syn) self.netStims[loc].append(stim) #ncstim.delay = 0.25 ncstim.weight[0] = synapseWeight self.netCons[loc].append(ncstim)
def __init__(self, spike_train=None, position=np.array([0, 0, 0]), background=3.9, cv=1, whatami='glom'): self.whatami = whatami self.background = background self.position = position self.mfncpc = [] self.record = {} if spike_train is not None: self.spk_vector = h.Vector() # Populate Vector for time in spike_train: self.spk_vector.append(float(time)) self.spike = h.VecStim() self.spike.play(self.spk_vector) else: self.spike = h.NetStim(0.5) self.spike.start = -10 self.spike.number = 1 self.spike.interval = 1e9 self.nc_spike = h.NetCon(self.spike, None) self.record['spk'] = h.Vector() self.nc_spike.record(self.record['spk'])
def set_NetStim(self, noise=0.0): """ Creates, sets and returns a NetStim. Parameters ---------- noise : float the fractional randomness (default is 0.0) Returns ------- neuron.hoc.HocObject NetStim """ stim = h.NetStim() stim.seed(self.setting['netstim']['NETSTIM_SEED']) stim.start = np.random.rand( ) * self.setting['netstim']['NETSTIM_START'] if self.setting['netstim']['NETSTIM_FREQUENCY'] == 0: stim.interval = 1e9 else: stim.interval = 1000 / self.setting['netstim']['NETSTIM_FREQUENCY'] stim.number = self.setting['netstim']['NETSTIM_NUMBER'] stim.noise = noise return stim
def synon () : "Turn on a synapse" global ns, nc ns = h.NetStim() nc = h.NetCon(ns,izh,0,1,10) ns.start, ns.interval, ns.number = 10, 10, 10 nc.weight[0] = 2 izh.taug = 3
def __init__(self, parallelContext, neuralNetwork, amplitude, frequency, burstsFrequency, pulsesNumber, species="rat", stim_start=5): """ Object initialization. Keyword arguments: parallelContext -- Neuron parallelContext object. neuralNetwork -- EES object with the number of pulse and the frequency of the pulses during each burst amplitude -- Aplitude of stimulation. It could either be an integer value between _minCur and _maxCur or a list containing the percentages of recruited primary afferents, secondary afferents and motoneurons. frequency -- Stimulation frequency in Hz; It has to be set in a way that new bursts are not occuring while old burst are still ongoing. burstsFrequency -- Burst stimulation frequency in Hz; it has to be lower than the maximum stimulation frequency imposed by the AfferentFiber model. pulsesNumber -- number of pulses to send. """ self._pc = parallelContext self._burstStim = EES(parallelContext, neuralNetwork, amplitude, burstsFrequency, pulsesNumber, species) self._burstStimId = self._burstStim.get_id() self._BurstingEesId = 1000001 burstPulses = self._burstStim.get_n_pulses() burstFreq = self._burstStim.get_frequency() totBurstDuration = 1000. / burstFreq * burstPulses self._maxFrequency = 1000. / totBurstDuration # Create the netStim Object in the first process if rank == 0: # Tell this host it has this cellId self._pc.set_gid2node(self._BurstingEesId, rank) # Create the stim objetc self._stim = h.NetStim() self._stim.number = 100000 self._stim.start = stim_start #lets give few ms for init purposes self._stim.noise = 0 self._pulses = h.Vector() # Associate the cell with this host and id # the nc is also necessary to use this cell as a source for all other hosts nc = h.NetCon(self._stim, None) self._pc.cell(self._BurstingEesId, nc) # Record the stimulation pulses nc.record(self._pulses) # Connect the stimulation to all dof of the neural network self._connect_to_burstStim() # Set stimulation frequency self.set_frequency(frequency)
def __init__(self,parallelContext,neuralNetwork,amplitude,frequency,pulsesNumber=100000,species="rat",stim_start=5): """ Object initialization. Keyword arguments: parallelContext -- Neuron parallelContext object. neuralNetwork -- NeuralNetwork instance to connect to this object. amplitude -- Aplitude of stimulation. It could either be an integer value between _minCur and _maxCur or a list containing the percentages of recruited primary afferents, secondary afferents and motoneurons. frequency -- Stimulation frequency in Hz; it has to be lower than the maximum stimulation frequency imposed by the AfferentFiber model. pulsesNumber -- number of pulses to send (default 100000). species -- rat or human (it loads different recruitment curves) """ self._pc = parallelContext self._nn = neuralNetwork self._species = species # Lets assign an Id to the stim object (high value to be sure is not already take from some cell) self._eesId = 1000000 # Initialize a dictionary to contain all the connections between this object and the stimulated cells self._connections = {} self._maxFrequency = AfferentFiber.get_max_ees_frequency() self._current = None self._percIf= None self._percIIf= None self._percMn = None # Create the netStim Object in the first process if rank==0: # Tell this host it has this cellId self._pc.set_gid2node(self._eesId, rank) # Create the stim objetc self._stim = h.NetStim() self._stim.number = pulsesNumber self._stim.start = stim_start #lets give few ms for init purposes self._stim.noise = 0 self._pulses = h.Vector() # Associate the cell with this host and id # the nc is also necessary to use this cell as a source for all other hosts nc = h.NetCon(self._stim,None) self._pc.cell(self._eesId, nc) # Record the stimulation pulses nc.record(self._pulses) # Load the recruitment data self._load_rec_data() # lets define which type of cells are recruited by the stimulation self._recruitedCells = sum([self._nn.get_afferents_names(),self._nn.get_motoneurons_names()],[]) # Connect the stimulation to all muscles of the neural network self._connect_to_network() # Set stimulation parameters self.set_amplitude(amplitude) self.set_frequency(frequency)
def mkstim(self): if not self.pc.gid_exists(0): return self.stim = h.NetStim() self.stim.number = 1 self.stim.start = 0 self.ncstim = h.NetCon(self.stim, self.pc.gid2cell(0).synlist[0]) self.ncstim.delay = 0 self.ncstim.weight[0] = 0.01
def _create_ees_objects(self): """ Create different ees objects with the defined stimulation frequencies. """ scale = rnd.random() for i in range(len(self._eesFrequencies)): self._eesList.append(h.NetStim()) self._eesList[i].interval = 1000.0 / self._eesFrequencies[i] self._eesList[i].number = 10000 self._eesList[i].start = 10.0 * scale self._eesList[i].noise = 0
def connect_stim(self): """Connect a spiking generator to the first cell to get the network going.""" self.stim = h.NetStim() self.stim.number = self.stim_number self.stim.start = 9 self.ncstim = h.NetCon(self.stim, self.cells[0].synlist[0]) self.ncstim.delay = 1 self.ncstim.weight[0] = self.stim_w # NetCon weight is a vector.
def set_netstim_netcon(self, interval): self.ns = h.NetStim() self.ns.interval = interval self.ns.number = 0 self.ns.start = self.start self.ampa_nc = h.NetCon(self.ns, self.ampa, 0, 0, 0) self.nmda_nc = h.NetCon(self.ns, self.nmda, 0, 0, 0)
def mkstim(self): if not pc.gid_exists(0): return self.stim = h.NetStim() self.stim.number = 1 self.stim.start = 0 ncstim = h.NetCon(self.stim, pc.gid2cell(self.gidstart).synlist[0]) ncstim.delay = 1 ncstim.weight[0] = 0.01 self.nclist.append(ncstim)
def makeStimulus(soma, simTime): stimNc = h.NetStim() stimNc.noise = 1 stimNc.start = 0 stimNc.number = simTime stimNc.interval = 10 syn = h.ExpSyn(0.5, sec=soma) nc = h.NetCon(stimNc, syn) nc.weight[0] = 20 return (stimNc, syn, nc)
def make_stim(self): # random external input for first 50 ms # The first N_STIM (excitatory) cells are stimulated. self.N_STIM = int(self.NCELL / 50) # number of neurons stimulated self.STOPSTIM = 50 # duration of stimulation (ms) self.NSYN_STIM = 20 # nb of stim (exc) synapses per neuron self.STIM_INTERVAL = 70 # mean interval between stims (ms) self.stimList = list() self.ncStimList = list() self.stvec = h.Vector() self.svec = h.Vector() h.mcell_ran4_init(self.run_random_low_start) for i in range(self.N_STIM): # The ith cell and its corresponding RandomStream. cell = self.cellList[i] rs = self.ranList[ i] # The ith cell and its corresponding RandomStream. stim = h.NetStim() stim.interval = self.STIM_INTERVAL stim.number = 1000 # but will shut off after STOPSTIM stim.noise = 1 stim.start = 0 stim.noiseFromRandom(rs.r) rs.r.negexp(1) rs.start() nc = h.NetCon(stim, cell.synlist.object(0)) nc.delay = self.STIM_DELAY # =1 to be consistent with Brette nc.weight[0] = self.AMPA_GMAX nc.record(self.stvec, self.svec, i) self.ncStimList.append(nc) self.stimList.append(stim) stim = h.NetStim() # will turn off all the others stim.number = 1 stim.start = self.STOPSTIM for st in self.stimList: nc = h.NetCon(stim, st) nc.delay = 1 # to be consistent with Brette nc.weight[0] = -1 self.ncStimList.append(nc) self.stimList.append(stim)
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 add_Estims(model, locs, sstart=20.0, sinterval=20, snumber=1, snoise=0): model.Estimlist = [] lidx = 0 for loc in locs: Estim = h.NetStim() Estim.interval = sinterval Estim.number = snumber Estim.start = sstart Estim.noise = snoise model.Estimlist.append(Estim) lidx += 1
def makeStimulus( soma, simTime ): interval = 25 stimNc = h.NetStim() stimNc.noise = 1 stimNc.start = ceil(25*rand(1,1)) stimNc.number = simTime stimNc.interval = interval syn = h.ExpSyn (0.5, sec = soma) nc = h.NetCon(stimNc, syn) nc.weight[0] = 20 return (stimNc, syn, nc)
def makeStimulus( soma, simTime,NCstrengthStim ): interval = 25 stimNc = h.NetStim() stimNc.noise = 1 stimNc.start = 0 stimNc.number = simTime stimNc.interval = interval syn = h.ExpSyn (0.5, sec = soma) nc = h.NetCon(stimNc, syn) nc.weight[0] = NCstrengthStim return (stimNc, syn, nc)
def mkstim(): ''' stimulate gid 0 with NetStim to start ring ''' global stim, ncstim if not pc.gid_exists(0): return stim = h.NetStim() stim.number = 1 stim.start = 0 ncstim = h.NetCon(stim, pc.gid2cell(0).synlist[0]) ncstim.delay = 0 ncstim.weight[0] = 0.01
def add_spike(self, t, weight, target=0): stim = h.NetStim() stim.number = 1 stim.start = 0 nc = h.NetCon(stim, self.synapses[target]) nc.delay = t nc.weight[0] = weight self.stims.append(stim) self.netcons.append(nc)