def set_stim(self, stim_prop, spike_train):
"""Gets the spike trains for each individual cell."""
self._train_vec = h.Vector(spike_train.get_times(
node_id=self.node_id)) #, population=self._population))
vecstim = h.VecStim()
vecstim.play(self._train_vec)
self._hobj = vecstim
def __init__(self, cf=None, sr=None, simulator=None):
"""
Parameters
----------
cf : float (default: None)
Required: the characteristic frequency for the SGC
sr : int (default None)
required : Selects the spontaneous rate group from the
Zilany et al (2010) model. 1 = LSR, 2 = MSR, 3 = HSR
simulator : 'cochlea' | 'matlab' | None (default None)
Sets the simulator interface that will be used. All models
currently use the Zilany et al. model, but the simulator can
be run though a Python-interface directly to the Matlab code
as publicy available, (simulator='matlab'), or can be run through
Rudnicki & Hemmert's Python interface to the simulator's C code
(simulator='cochlea').
"""
self._simulator = simulator
SGC.__init__(self, cf, sr)
self.vecstim = h.VecStim()
# this causes the terminal to receive events from the VecStim:
self.spike_source = self.vecstim
# just an empty section for holding the terminal
self.add_section(h.Section(), 'soma')
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 create_stim(self, S, syns, weights):
"""Create vecstim and netcon objects for simulation.
Parameters
----------
S : ndarray
presynaptic spike times
syns : list
neuron synapse objects
weights : ndarray
synaptic weights
Returns
-------
t_vec_list : list
spike time vectors
stim_list : list
vec_stim objects
con_list : list
netcon objects
"""
t_vec_list = []
stim_list = []
con_list = []
for k, (t_list, syn) in enumerate(zip(S, syns)):
stim = h.VecStim()
t_vec = h.Vector(t_list[~np.isinf(t_list)])
stim.play(t_vec)
t_vec_list.append(t_vec)
stim_list.append(stim)
con_list.append(h.NetCon(stim, syn, 0, 0, weights[k]))
return t_vec_list, stim_list, con_list
def connect_independent_stimuli(spiketrains,
synlist,
threshold=-20,
delay=0,
weight=1):
"""Create a list of VecStim object with event times from spiketrains,
and create NetCon objects to feed this to each synapse.
spiketrains: list of arrays containing stimulus time for each entry in synlist
synlist: list of synapses
Returns list of NetCon objects, VecStim object and the list of Vectors
containing stimulus times.
"""
netcons = []
stimtimes = []
stimlist = []
for st, syn in zip(spiketrains, synlist):
stimvec = h.Vector()
stimvec.append(*st)
stimtimes.append(stimvec)
vecstim = h.VecStim()
vecstim.play(stimvec)
stimlist.append(vecstim)
netcons.append(h.NetCon(vecstim, syn, threshold, delay, weight))
return netcons, stimlist, stimtimes
def connect_axon(self, axon):
# configure ExpSyn synapse
synapse = h.ExpSyn(1e-3, axon.allseclist) #1e-3
synapse.e = 10
synapse.i = 0.2
synapse.tau = 0.1
# get spike train
spikeTrain = self.spikeTrains[self.axonIndex]
self.axonIndex += 1
# configure input to synapse
vecStim = h.VecStim()
spikeVec = h.Vector(spikeTrain)
# axon.spikeVec = h.Vector([1,2,3])
vecStim.play(spikeVec)
# connect synapse and VecStim input
netCon = h.NetCon(vecStim, synapse)
netCon.weight[0] = 1
# add the variables to the axon instance in order to keep them alive
# delete after simulation
excitationMechanismVars = [
synapse, vecStim, spikeVec, spikeTrain, netCon
]
axon.append_ex_mech_vars(excitationMechanismVars)
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 apply_stimuli(self, stim_dict, weight=0.5):
"""This function applies stimuli based on stim_dict parameters.
:param stim_dict: key is target cell id and value is spike times list"""
for tgt_cell_id, times in stim_dict.iteritems():
# try:
if tgt_cell_id in self.cells_dict.keys():
tgt_cell = self.cells_dict[tgt_cell_id]
# DEBUG: The following line causes slowdown!!!
# This isn't due to creation time though, rather to
# the effect it has on simulation itslef.
syn = tgt_cell.create_synapses(1, return_syns=True)[0]
stim_train = h.Vector(times)
vplay = h.VecStim() # NOTE: this requires compiled vecstim.mod
vplay.play(stim_train)
nc = h.NetCon(vplay, syn)
nc.weight[0] = weight
# Now note, that if I'm going to be re running simulation
# and reinitalize it each time, the time will reset and
# each time network will be stimulated by old stimuli.
self.stim_conns.append((nc, syn))
self.vecStims.append(vplay)
self.stim_trains.append(stim_train)
def initialize(self, sim):
##### Make sure to save spikes vector and vector stim object
# Attach a NetCon/synapse on the high-level neuron(s) soma. We can use the NetCon.event(time) method to send
# a spike to the synapse. Which, is a spike occurs, the high-level neuron will inhibit the low-level neuron.
self._spikes = h.Vector() # start off with empty input
vec_stim = h.VecStim()
vec_stim.play(self._spikes)
self._vect_stim = vec_stim
self._high_level_neurons = list(
sim.net.get_node_set('high_level_neurons').gids())
self._pag_neurons = list(sim.net.get_node_set('pag_neurons').gids())
io.log_info('Found {} high level neurons'.format(
len(self._high_level_neurons)))
for gid in self._high_level_neurons:
cell = sim.net.get_cell_gid(gid)
self._spike_events[gid] = np.array([])
# Create synapse
# These values will determine how the high-level neuron behaves with the input
syn = h.Exp2Syn(0.5, cell.hobj.soma[0])
syn.e = 0.0
syn.tau1 = 0.1
syn.tau2 = 0.3
self._synapses[gid] = syn
nc = h.NetCon(self._vect_stim, syn)
nc.threshold = sim.net.spike_threshold
nc.weight[0] = 0.2
nc.delay = 1.0
self._netcons[gid] = nc
io.log_info('Found {} PAG neurons'.format(len(self._pag_neurons)))
for gid in self._pag_neurons:
trg_cell = sim.net.get_cell_gid(
gid) # network._rank_node_ids['LUT'][51]
self._spike_events[gid] = np.array([])
syn = h.Exp2Syn(0.5, sec=trg_cell.hobj.soma[0])
syn.e = 0.0
syn.tau1 = 0.1
syn.tau2 = 0.3
self._synapses[gid] = syn
nc = h.NetCon(self._vect_stim, syn)
nc.threshold = sim.net.spike_threshold
nc.weight[0] = 0.2
nc.delay = 1.0
self._netcons[gid] = nc
# Attach another netcon to the low-level neuron(s) that will record
self._low_level_neurons = list(
sim.net.get_node_set('low_level_neurons').gids())
io.log_info('Found {} low level neurons'.format(
len(self._low_level_neurons)))
self._set_spike_detector(sim)
pc.barrier()
def initialize(self, sim):
network = sim.net
##### Make sure to save spikes vector and vector stim object
# Attach a NetCon/synapse on the high-level neuron(s) soma. We can use the NetCon.event(time) method to send
# a spike to the synapse. Which, is a spike occurs, the high-level neuron will inhibit the low-level neuron.
self._spikes = h.Vector(np.array([])) # start off with empty input
vec_stim = h.VecStim()
vec_stim.play(self._spikes)
self._vect_stim = vec_stim
self._high_level_neurons = list(sim.net.get_node_set('high_level_neurons').gids())
self._pag_neurons = list(sim.net.get_node_set('pag_neurons').gids())
# self._pag_neurons = [i for i in np.arange(50,75)]
for gid in self._high_level_neurons:
cell = sim.net.get_cell_gid(gid)
# Create synapse
# These values will determine how the high-level neuron behaves with the input
new_syn = h.Exp2Syn(0.5, cell.hobj.soma[0])
new_syn.e = 0.0
new_syn.tau1 = 0.1
new_syn.tau2 = 0.3
nc = h.NetCon(self._vect_stim, new_syn)
##nc = h.NetCon(vec_stim, new_syn)
nc.weight[0] = 0.5
nc.delay = 1.0
self._synapses[gid] = new_syn
self._netcons[gid] = nc
io.log_info('Found {} PAG neurons'.format(len(self._pag_neurons)))
for gid in self._pag_neurons:
trg_cell = network.get_cell_gid(gid) # network._rank_node_ids['LUT'][51]
syn = h.Exp2Syn(0.5, sec=trg_cell.hobj.soma[0])
syn.e = 0.0
syn.tau1 = 0.1
syn.tau2 = 0.3
self._synapses[gid] = syn
nc = h.NetCon(self._vect_stim, syn)
nc.weight[0] = 0.5
nc.delay = 1.0
self._netcons[gid] = nc
# Attach another netcon to the low-level neuron(s) that will record
self._low_level_neurons = list(sim.net.get_node_set('low_level_neurons').gids())
for gid in self._low_level_neurons:
cell = sim.net.get_cell_gid(gid)
# NOTE: If you set the segment to 0.5 it will interfere with the record_spikes module. Neuron won't let
# us record from the same place multiple times, so for now just set to 0.0. TODO: read and save spikes in biosimulator.
nc = h.NetCon(cell.hobj.soma[0](0.0)._ref_v, None, sec=cell.hobj.soma[0])
self._netcons[gid] = nc
self._set_spike_detector(sim)
def __init__(self, sid):
self.s = h.VecStim()
self.nvec = inspk[np.where(inspk[:, 1].astype(int) == sid), 0][0]
self.vec = h.Vector(self.nvec.shape[0])
self.vec.from_python(self.nvec)
self.s.play(self.vec)
self.recorder = h.NetCon(self.s, None)
self.spk = h.Vector()
self.recorder.record(self.spk)
def initialize(self, sim):
# Attach a NetCon/synapse on the high-level neuron(s) soma. We can use the NetCon.event(time) method to send
# a spike to the synapse. Which, is a spike occurs, the high-level neuron will inhibit the low-level neuron.
spikes = h.Vector([]) # start off with empty input
vec_stim = h.VecStim()
vec_stim.play(spikes)
self._high_level_neurons = list(
sim.net.get_node_set('high_level_neurons').gids())
self._eus_neurons = list(sim.net.get_node_set('eus_neurons').gids())
for gid in self._high_level_neurons:
cell = sim.net.get_cell_gid(gid)
# Create synapse
# These values will determine how the high-level neuron behaves with the input
new_syn = h.Exp2Syn(0.7, cell.hobj.soma[0])
new_syn.e = 0.0
new_syn.tau1 = 1.0
new_syn.tau2 = 3.0
nc = h.NetCon(vec_stim, new_syn)
nc.weight[0] = 0.5
nc.delay = 1.0
self._synapses[gid] = new_syn
self._netcons[gid] = nc
for gid in self._eus_neurons:
cell = sim.net.get_cell_gid(gid)
# Create synapse
# These values will determine how the high-level neuron behaves with the input
new_syn = h.Exp2Syn(0.9, cell.hobj.soma[0])
new_syn.e = 0.0
new_syn.tau1 = 1.0
new_syn.tau2 = 3.0
nc = h.NetCon(vec_stim, new_syn)
nc.weight[0] = 0.5
nc.delay = 1.0
self._synapses[gid] = new_syn
self._netcons[gid] = nc
# Attach another netcon to the low-level neuron(s) that will record
self._low_level_neurons = list(
sim.net.get_node_set('low_level_neurons').gids())
for gid in self._low_level_neurons:
cell = sim.net.get_cell_gid(gid)
# NOTE: If you set the segment to 0.5 it will interfere with the record_spikes module. Neuron won't let
# us record from the same place multiple times, so for now just set to 0.0. TODO: read and save spikes in biosimulator.
nc = h.NetCon(cell.hobj.soma[0](0.0)._ref_v,
None,
sec=cell.hobj.soma[0])
self._netcons[gid] = nc
self._set_spike_detector(sim)
def set_stim(self, stim_prop, spike_train):
#spike_trains_handle = input_prop["spike_trains_handle"]
#self.spike_train = spike_trains_handle['%d/data' % self.stim_gid][:]
self.train_vec = h.Vector(spike_train[:])
vecstim = h.VecStim()
vecstim.play(self.train_vec)
self.hobj = vecstim
def play(self, port_name, signal, properties=[]):
"""
Injects current into the segment
Parameters
----------
port_name : str
The name of the receive port to play the signal into
signal : neo.AnalogSignal (current) | neo.SpikeTrain
Signal to play into the port
properties : list(nineml.Property)
The connection properties of the event port
"""
ext_is = self.build_component_class.annotations.get(
(BUILD_TRANS, PYPE9_NS), EXTERNAL_CURRENTS).split(',')
port = self.component_class.port(port_name)
if isinstance(port, EventPort):
if len(list(self.component_class.event_receive_ports)) > 1:
raise Pype9Unsupported9MLException(
"Multiple event receive ports ('{}') are not currently "
"supported".format("', '".join([
p.name
for p in self.component_class.event_receive_ports
])))
if signal.t_start < 1.0:
raise Pype9UsageError(
"Signal must start at or after 1 ms to handle delay in "
"neuron ({})".format(signal.t_start))
times = numpy.asarray(signal.times.rescale(pq.ms)) - 1.0
vstim = h.VecStim()
vstim_times = h.Vector(times)
vstim.play(vstim_times)
vstim_con = h.NetCon(vstim, self._hoc, sec=self._sec)
self._check_connection_properties(port_name, properties)
if len(properties) > 1:
raise NotImplementedError(
"Cannot handle more than one connection property per port")
elif properties:
vstim_con.weight[0] = self.unit_handler.scale_value(
properties[0].quantity)
self._inputs['vstim'] = vstim
self._input_auxs.extend((vstim_times, vstim_con))
else:
if port_name not in ext_is:
raise Pype9Unsupported9MLException(
"Can only play into external current ports ('{}'), not "
"'{}' port.".format("', '".join(ext_is), port_name))
iclamp = h.IClamp(0.5, sec=self._sec)
iclamp.delay = 0.0
iclamp.dur = 1e12
iclamp.amp = 0.0
iclamp_amps = h.Vector(pq.Quantity(signal, 'nA'))
iclamp_times = h.Vector(signal.times.rescale(pq.ms))
iclamp_amps.play(iclamp._ref_amp, iclamp_times)
self._inputs['iclamp'] = iclamp
self._input_auxs.extend((iclamp_amps, iclamp_times))
def set_stim(self, stim_prop, spike_train):
"""Gets the spike trains for each individual cell."""
spikes = spike_train.get_times(node_id=self.node_id)
assert(np.all(spikes >= 0))
spikes = np.sort(spikes) # sort the spikes for NEURON
self._train_vec = h.Vector(spikes)
vecstim = h.VecStim()
vecstim.play(self._train_vec)
self._hobj = vecstim
def __init__(self, event_times):
# Convert event times into nrn vector
self.nrn_eventvec = h.Vector()
self.nrn_eventvec.from_python(event_times)
# load eventvec into VecStim object
self.nrn_vecstim = h.VecStim()
self.nrn_vecstim.play(self.nrn_eventvec)
# create the cell and artificial NetCon
self.nrn_netcon = h.NetCon(self.nrn_vecstim, None)
def add_stim(self, where_what, tstim, w, name='default'):
"""
Create a synapse of a given type (Epx2Syn, NMDA, etc..) on a given
section and activate at the time in tstim with a given intensity set by
w. This is the where, what, when scheme. Tstim is determined by a
vecstim object that needs to be compiled with the vecstim.mod
Parameters
----------
where_when: triple (str, float, str)
(name of section, location between 0 and 1, type of synapse)
name: str
name of the synaptic object
tstim: list
different times at which the point process is activated
w: float
weight of the point process
Comments
--------
IMPORTANT: This method requires the pre-compiling of vecstim.mod by
NEURON.
By default we insert a single Exp2Syn object. This can be moved in
future version
The sort command is here to make sure that tstim are in the right order.
"""
# Select the location
segment = self.sections[where_what[0]](where_what[1])
# Define the type of point process to use
meca = getattr(h, where_what[2])
self.syn[name] = meca(segment)
# Try to change the time constant of the pt process
if where_what[2] == "Exp2syn":
self.syn[name].tau1 = 1
self.syn[name].tau2 = 2
if where_what[2] == "NmdaSynapse":
self.syn[name].tau1 = 0.1
self.syn[name].tau2 = 10
# Convert tstim into a NEURON vector (to play in NEURON)
self.stim[name] = h.Vector(np.sort(tstim))
# Create play vectors to interface with NEURON
self.vplay[name] = h.VecStim()
# Connect vector to VecStim object to play them
self.vplay[name].play(self.stim[name])
# Build the netcon object to connect the stims and the synapses
self.netcon[name] = h.NetCon(self.vplay[name], self.syn[name])
# Set the individual weights
self.netcon[name].weight[0] = w
def __init__(self, ty, celltype, p_ext, gid):
# VecStim setup
self.eventvec = h.Vector()
self.vs = h.VecStim()
# self.p_unique = p_unique[type]
self.p_ext = p_ext
self.celltype = celltype
self.ty = ty # feed type
self.gid = gid
self.set_prng() # sets seeds for random num generator
# sets event times into self.eventvec and plays into self.vs (VecStim)
self.set_event_times()
def __init__(self, node, population_name, bionetwork):
super(BioCellSpontSyn, self).__init__(node, population_name=population_name, bionetwork=bionetwork)
# Get the timestamp at which synapses
self._syn_timestamps = bionetwork.spont_syns_times
self._syn_timestamps = [self._syn_timestamps] if np.isscalar(self._syn_timestamps) else self._syn_timestamps
self._spike_trains = h.Vector(self._syn_timestamps)
self._vecstim = h.VecStim()
self._vecstim.play(self._spike_trains)
self._precell_filter = bionetwork.spont_syns_filter
assert(isinstance(self._precell_filter, dict))
def artificial_cell(event_times):
# Convert event times into nrn vector
nrn_eventvec = h.Vector()
nrn_eventvec.from_python(event_times)
# load eventvec into VecStim object
nrn_vecstim = h.VecStim()
nrn_vecstim.play(nrn_eventvec)
# create the cell and artificial NetCon
nrn_netcon = h.NetCon(nrn_vecstim, None)
return nrn_netcon
def setSpikeTrain(self, syn_index, syn_weight, spike_times):
# add spiketrain
spks = np.array(spike_times) + self.t_calibrate
spks_vec = h.Vector(spks.tolist())
vecstim = h.VecStim()
vecstim.play(spks_vec)
netcon = h.NetCon(vecstim, self.syns[syn_index], 0, self.dt,
syn_weight)
# store the objects
self.vecs.append(spks_vec)
self.vecstims.append(vecstim)
self.netcons.append(netcon)
def testSingleSyn(self, syn_type, layer, idx, t1, t2, weight):
Input = h.VecStim()
evec = h.Vector([200])
Input.play(evec)
self.synGroups[syn_type][layer][idx].tau1 = t1
self.synGroups[syn_type][layer][idx].tau2 = t2
if syn_type == 'GABA':
self.synGroups[syn_type][layer][idx].e = -75
else:
self.synGroups[syn_type][layer][idx].e = -0
self.syn_con = h.NetCon(Input, self.synGroups[syn_type][layer][idx])
self.syn_con.delay = 0
self.syn_con.weight[0] = weight
self.syn_con.threshold = 10.0
def __init__(self,
post_pop,
t_pattern,
spat_pattern,
target_segs,
tau_1,
tau_facil,
U,
tau_rec,
e,
weight,
rec_cond=False):
self.init_parameters = locals()
post_pop.add_connection(self)
synapses = []
netcons = []
t_pattern = list(t_pattern) # nrn does not like np.ndarrays?
target_cells = post_pop[spat_pattern]
self.pre_pop = 'Implicit'
self.post_pop = post_pop
self.vecstim = h.VecStim()
self.pattern_vec = h.Vector(t_pattern)
self.vecstim.play(self.pattern_vec)
conductances = []
for curr_cell in target_cells:
curr_seg_pool = curr_cell.get_segs_by_name(target_segs)
curr_conductances = []
for seg in curr_seg_pool:
curr_syn = h.tmgsyn(seg(0.5))
curr_syn.tau_1 = tau_1
curr_syn.tau_facil = tau_facil
curr_syn.U = U
curr_syn.tau_rec = tau_rec
curr_syn.e = e
curr_netcon = h.NetCon(self.vecstim, curr_syn)
curr_gvec = h.Vector()
curr_gvec.record(curr_syn._ref_g)
curr_conductances.append(curr_gvec)
curr_netcon.weight[0] = weight
netcons.append(curr_netcon)
synapses.append(curr_syn)
if rec_cond:
conductances.append(curr_conductances)
self.conductances = conductances
self.netcons = netcons
self.pre_cell_targets = np.array(spat_pattern)
self.synapses = synapses
def __init__(self, feed_type, target_cell_type, params, gid):
# VecStim setup
self.nrn_eventvec = h.Vector()
self.nrn_vecstim = h.VecStim()
self.params = params
# used to determine cell type-specific parameters for
# (not used for 'common', such as for rhythmic alpha/beta input)
self.cell_type = target_cell_type
self.feed_type = feed_type
self.gid = gid
self.set_prng() # sets seeds for random num generator
# sets event times into self.nrn_eventvec (Vector)
# and plays into self.nrn_vecstim (VecStim)
self.set_event_times()
def mknetcon_vecstim(syn, delay=0.1, weight=0, source=None):
"""
Creates a VecStim object to drive the provided synaptic point process,
and a network connection from the VecStim source to the synapse target.
:param syn: synapse point process
:param delay: float
:param weight: float
:return: :class:'h.NetCon', :class:'h.VecStim'
"""
vs = h.VecStim()
nc = h.NetCon(vs, syn)
nc.weight[0] = weight
nc.delay = delay
return nc, vs
def create_pn_output(spike_trains):
"""Create stimvec and vecstim for proxy of PN spikes"""
global model_dict
cfg.logger.info('Started creating PN output vecstims and stimvecs')
stimvecs = []
vecstims = []
for st in spike_trains:
stimvecs.append(h.Vector(st))
vecstims.append(h.VecStim())
vecstims[-1].play(stimvecs[-1])
model_dict['vecstim'] = vecstims
model_dict['stimvec'] = stimvecs
cfg.logger.info('Finished creating PN output vecstims and stimvecs')
return stimvecs, vecstims
def add_ExpSyn(self, section='soma', position=0.5, name='default', tstim=[50], w=.001):
"""
Create/replace an Expsyn synapse on a given section which is active at the time in tstim
Comments
--------
The sort command is here to make sure that tstim are in the right order. This method
requires the pre-compiling of vecstim.mod by NEURON.
"""
self.syn[name] = h.ExpSyn(self.cell.__getattribute__(section)(position))
self.stim[name] = h.Vector(np.sort(tstim)) # Converting tstim into a NEURON vector (to play in NEURON)
self.vplay[name] = h.VecStim() # Creating play vectors to interface with NEURON
self.vplay[name].play(self.stim[name]) # Connecting vector to VecStim object to play them
self.netcon[name] = h.NetCon(self.vplay[name], self.syn[name]) # Building the netcon object to connect the stims and the synapses
self.netcon[name].weight[0] = w # Setting the individual weights
def __init__(self, event_times, threshold, gid=None):
# Convert event times into nrn vector
self.nrn_eventvec = h.Vector()
self.nrn_eventvec.from_python(event_times)
# load eventvec into VecStim object
self.nrn_vecstim = h.VecStim()
self.nrn_vecstim.play(self.nrn_eventvec)
# create the cell and artificial NetCon
self.nrn_netcon = h.NetCon(self.nrn_vecstim, None)
self.nrn_netcon.threshold = threshold
self._gid = None
if gid is not None:
self.gid = gid # use setter method to check input argument gid
def generate_stimulus(single_cell, attachment_dend, times, weight,
n_dend_attach):
times = h.Vector(times) #eventvec move from seconds to ms
single_cell[0].tlist.append(times)
inputs = h.VecStim() #presyn
inputs.play(times)
single_cell[0].vslist.append(inputs)
for i in np.arange(n_dend_attach): #create synapses
synapse = h.ExpSyn(single_cell[0].dend[int(attachment_dend[i])](0.5))
synapse.tau = 2
single_cell[0].synlist.append(synapse)
ncstim = h.NetCon(inputs, synapse)
ncstim.weight[0] = weight
ncstim.threshold = -32.4
ncstim.delay = 1
single_cell[0].nclist.append(ncstim)
return single_cell
def create_VecStim(self, t_vec, synapse, weight):
"""
Creates a vector stream of events for given synapse.
Parameters
----------
t_vec : numpy.ndarray
the time vector
synapse : Synapse
synapse
weight : float
the stimulus weight
"""
vec = h.Vector(t_vec)
vec_stim = h.VecStim()
vec_stim.play(vec)
self.vec_stims.append(vec_stim)
nc = h.NetCon(vec_stim, synapse.synapse, 0, 0, weight)
nc.record(synapse.input_spikes)
self.net_cons.append(nc)
