def __getitem__(self, index):
id_index = self._get_index_or_add('id', -1)
if id_index > 0:
id = int(self.array[index][id_index])
assert (self.array[index][0] == index)
else:
id = index
pre_cell_id = int(self.array[index][self._get_index_or_add(
'pre_cell_id', 1)])
post_cell_id = int(self.array[index][self._get_index_or_add(
'post_cell_id', 2)])
pre_segment_id = int(self._get_value(index, 'pre_segment_id', 0))
post_segment_id = int(self._get_value(index, 'post_segment_id', 0))
pre_fraction_along = float(
self._get_value(index, 'pre_fraction_along', 0.5))
post_fraction_along = float(
self._get_value(index, 'post_fraction_along', 0.5))
input = neuroml.Connection(
id=id,
pre_cell_id="../%s/%i/%s" %
(self.presynaptic_population, pre_cell_id, "???"),
post_cell_id="../%s/%i/%s" %
(self.postsynaptic_population, post_cell_id, "???"),
pre_segment_id=pre_segment_id,
post_segment_id=post_segment_id,
pre_fraction_along=pre_fraction_along,
post_fraction_along=post_fraction_along)
return input
def handleConnection(self, proj_id, conn_id, prePop, postPop, synapseType, \
preCellId, \
postCellId, \
preSegId = 0, \
preFract = 0.5, \
postSegId = 0, \
postFract = 0.5, \
delay=0,
weight=1):
#self.printConnectionInformation(proj_id, conn_id, prePop, postPop, synapseType, preCellId, postCellId, weight)
if not self.weightDelays[proj_id] and delay == 0 and weight == 1:
connection = neuroml.Connection(id=conn_id, \
pre_cell_id="../%s/%i/%s"%(prePop,preCellId,self.populations[prePop].component), \
pre_segment_id=preSegId, \
pre_fraction_along=preFract,
post_cell_id="../%s/%i/%s"%(postPop,postCellId,self.populations[postPop].component), \
post_segment_id=postSegId,
post_fraction_along=postFract)
self.projections[proj_id].connections.append(connection)
else:
connection = neuroml.ConnectionWD(id=conn_id, \
pre_cell_id="../%s/%i/%s"%(prePop,preCellId,self.populations[prePop].component), \
pre_segment_id=preSegId, \
pre_fraction_along=preFract,
post_cell_id="../%s/%i/%s"%(postPop,postCellId,self.populations[postPop].component), \
post_segment_id=postSegId,
post_fraction_along=postFract,
weight=weight,
delay='%sms'%(delay*1000.0))
self.projections[proj_id].connection_wds.append(connection)
def create_GoC_network( duration, dt, seed, runid, run=False):
### ---------- Load Params
noPar = True
pfile = Path('params_file.pkl')
if pfile.exists():
print('Reading parameters from file:')
file = open('params_file.pkl','rb')
params_list = pkl.load(file)
if len(params_list)>runid:
p = params_list[runid]
file.close()
if noPar:
p = inp.get_simulation_params( runid )
### ---------- Component types
goc_filename = 'GoC.cell.nml' # Golgi cell with channels
goc_file = pynml.read_neuroml2_file( goc_filename )
goc_type = goc_file.cells[0]
goc_ref = nml.IncludeType( href=goc_filename )
MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs
mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename )
MFSyn_type = mfsyn_file.exp_three_synapses[0]
mfsyn_ref = nml.IncludeType( href=MFSyn_filename )
MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input
mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename )
MF20Syn_type = mf20syn_file.exp_three_synapses[0]
mf20syn_ref = nml.IncludeType( href=MF20Syn_filename )
mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs
mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" ) # Not tuned to any data - qqq !
mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input)
mf_burst = nml.TransientPoissonFiringSynapse( id="MF_Burst", average_rate="100 Hz", delay="2000 ms", duration="500 ms", synapse=MF20Syn_type.id, spike_target='./{}'.format(MF20Syn_type.id) )
gj = nml.GapJunction( id="GJ_0", conductance="426pS" ) # GoC synapse
### --------- Populations
# Build network to specify cells and connectivity
net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" )
# Create GoC population
goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=p["nGoC"] )
for goc in range( p["nGoC"] ):
inst = nml.Instance( id=goc )
goc_pop.instances.append( inst )
inst.location = nml.Location( x=p["GoC_pos"][goc,0], y=p["GoC_pos"][goc,1], z=p["GoC_pos"][goc,2] )
net.populations.append( goc_pop )
### MF population
MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=p["nMF"])
for mf in range( p["nMF"] ):
inst = nml.Instance(id=mf)
MF_Poisson_pop.instances.append( inst )
inst.location = nml.Location( x=p["MF_pos"][mf,0], y=p["MF_pos"][mf,1], z=p["MF_pos"][mf,2] )
net.populations.append( MF_Poisson_pop )
# Create NML document for network specification
net_doc = nml.NeuroMLDocument( id=net.id )
net_doc.networks.append( net )
net_doc.includes.append( goc_ref )
net_doc.includes.append( mfsyn_ref )
net_doc.includes.append( mf20syn_ref )
net_doc.spike_generator_poissons.append( mf_poisson )
net_doc.transient_poisson_firing_synapses.append( mf_burst )
net_doc.gap_junctions.append(gj)
### ------------ Connectivity
### 1. Background excitatory inputs: MF to GoC populations
MFProjection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id)
net.projections.append(MFProjection)
# MF_> GoC synapses (with syn_count equivalent to integer scaling of Mf synapse strength)
nMFSyn = p["MF_GoC_pairs"].shape[1]
ctr=0
for syn in range( nMFSyn ):
mf, goc = p["MF_GoC_pairs"][:, syn]
for syn_count in range(p["MF_GoC_wt"][ctr]):
conn2 = nml.Connection(id=ctr, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5") #on soma
MFProjection.connections.append(conn2)
ctr+=1
### 2. Perturbation as High Freq MF Inputs
ctr=0
for goc in p["Burst_GoC"]:
for jj in range( p["nBurst"] ): # Each Perturbed GoC gets nBurst random Burst sources
inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id))
net.explicit_inputs.append( inst )
ctr += 1
### 3. Electrical coupling between GoCs
GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id )
net.electrical_projections.append( GoCCoupling )
dend_id = [1,2,5]
for jj in range( p["GJ_pairs"].shape[0] ):
conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,0], goc_type.id), pre_segment=dend_id[p["GJ_loc"][jj,0]], pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, p["GJ_pairs"][jj,1], goc_type.id), post_segment=dend_id[p["GJ_loc"][jj,1]], post_fraction_along='0.5', synapse=gj.id, weight=p["GJ_wt"][jj] )
GoCCoupling.electrical_connection_instance_ws.append( conn )
### -------------- Write files
net_filename = 'gocNetwork.nml'
pynml.write_neuroml2_file( net_doc, net_filename )
simid = 'sim_gocnet_'+goc_type.id+'_run_{}'.format(runid)
ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed )
ls.assign_simulation_target( net.id )
ls.include_neuroml2_file( net_filename)
ls.include_neuroml2_file( goc_filename)
ls.include_neuroml2_file( MFSyn_filename)
ls.include_neuroml2_file( MF20Syn_filename)
# Specify outputs
eof0 = 'Events_file'
ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME')
for jj in range( goc_pop.size):
ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' )
of0 = 'Volts_file'
ls.create_output_file(of0, "%s.v.dat"%simid)
for jj in range( goc_pop.size ):
ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id))
#Create Lems file to run
lems_simfile = ls.save_to_file()
if run:
res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", nogui=True, plot=False)
else:
res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False)
return res
input_list = neuroml.InputList(id="il%i" % pre,
component=pg.id,
populations=pop0.id)
input = neuroml.Input(id=pre,
target="../%s[%i]" % (pop0.id, pre),
destination="synapses")
input_list.input.append(input)
net.input_lists.append(input_list)
# Connect cells with defined probability
prob_connection = 0.5
for post in range(0, size1):
if random.random() <= prob_connection:
conn = \
neuroml.Connection(id=conn_count, \
pre_cell_id="../%s[%i]" % (pop0.id, pre),
post_cell_id="../%s[%i]" % (pop1.id, post))
proj1.connections.append(conn)
conn_count += 1
#########################################################
import neuroml.writers as writers
nml_file = 'simplenet.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file)
print("Written network file to: " + nml_file)
###### Validate the NeuroML ######
from neuroml.utils import validate_neuroml2
def create_GoC_network(duration,
dt,
seed,
N_goc=0,
N_mf=15,
run=False,
prob_type='Boltzmann',
GJw_type='Vervaeke2010'):
### ---------- Component types
goc_filename = 'GoC.cell.nml' # Golgi cell with channels
goc_file = pynml.read_neuroml2_file(goc_filename)
goc_type = goc_file.cells[0]
goc_ref = nml.IncludeType(href=goc_filename)
MFSyn_filename = 'MF_GoC_Syn.nml' # small conductance synapse for background inputs
mfsyn_file = pynml.read_neuroml2_file(MFSyn_filename)
MFSyn_type = mfsyn_file.exp_three_synapses[0]
mfsyn_ref = nml.IncludeType(href=MFSyn_filename)
MF20Syn_filename = 'MF_GoC_SynMult.nml' # multi-syn conductance for strong/coincident transient input
mf20syn_file = pynml.read_neuroml2_file(MF20Syn_filename)
MF20Syn_type = mf20syn_file.exp_three_synapses[0]
mf20syn_ref = nml.IncludeType(href=MF20Syn_filename)
mf_type2 = 'spikeGeneratorPoisson' # Spike source for background inputs
mf_poisson = nml.SpikeGeneratorPoisson(
id="MF_Poisson", average_rate="5 Hz") # Not tuned to any data - qqq !
mf_bursttype = 'transientPoissonFiringSynapse' # Burst of MF input (as explicit input)
mf_burst = nml.TransientPoissonFiringSynapse(id="MF_Burst",
average_rate="100 Hz",
delay="2000 ms",
duration="500 ms",
synapse=MF20Syn_type.id,
spike_target='./{}'.format(
MF20Syn_type.id))
gj = nml.GapJunction(id="GJ_0", conductance="426pS") # GoC synapse
### --------- Populations
# Build network to specify cells and connectivity
net = nml.Network(id="gocNetwork",
type="networkWithTemperature",
temperature="23 degC")
### Golgi cells
if N_goc > 0:
GoC_pos = nu.GoC_locate(N_goc)
else:
GoC_pos = nu.GoC_density_locate()
N_goc = GoC_pos.shape[0]
# Create GoC population
goc_pop = nml.Population(id=goc_type.id + "Pop",
component=goc_type.id,
type="populationList",
size=N_goc)
for goc in range(N_goc):
inst = nml.Instance(id=goc)
goc_pop.instances.append(inst)
inst.location = nml.Location(x=GoC_pos[goc, 0],
y=GoC_pos[goc, 1],
z=GoC_pos[goc, 2])
net.populations.append(goc_pop)
### MF population
MF_Poisson_pop = nml.Population(id=mf_poisson.id + "_pop",
component=mf_poisson.id,
type="populationList",
size=N_mf)
MF_pos = nu.GoC_locate(N_mf)
for mf in range(N_mf):
inst = nml.Instance(id=mf)
MF_Poisson_pop.instances.append(inst)
inst.location = nml.Location(x=MF_pos[mf, 0],
y=MF_pos[mf, 1],
z=MF_pos[mf, 2])
net.populations.append(MF_Poisson_pop)
# Create NML document for network specification
net_doc = nml.NeuroMLDocument(id=net.id)
net_doc.networks.append(net)
net_doc.includes.append(goc_ref)
net_doc.includes.append(mfsyn_ref)
net_doc.includes.append(mf20syn_ref)
net_doc.spike_generator_poissons.append(mf_poisson)
net_doc.transient_poisson_firing_synapses.append(mf_burst)
net_doc.gap_junctions.append(gj)
### ------------ Connectivity
### background excitatory inputs: MF to GoC populations
MFProjection = nml.Projection(id="MFtoGoC",
presynaptic_population=MF_Poisson_pop.id,
postsynaptic_population=goc_pop.id,
synapse=MFSyn_type.id)
net.projections.append(MFProjection)
#Get list of MF->GoC synapse
mf_synlist = nu.randdist_MF_syn(N_mf, N_goc,
pConn=0.3) # Not tuned to any data - qqq!
nMFSyn = mf_synlist.shape[1]
for syn in range(nMFSyn):
mf, goc = mf_synlist[:, syn]
conn2 = nml.Connection(
id=syn,
pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf,
mf_poisson.id),
post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id),
post_segment_id='0',
post_fraction_along="0.5") #on soma
MFProjection.connections.append(conn2)
### Add few burst inputs
n_bursts = 4
gocPerm = np.random.permutation(
N_goc) # change to central neurons later -qqq !!!
ctr = 0
for gg in range(4):
goc = gocPerm[gg]
for jj in range(n_bursts):
inst = nml.ExplicitInput(
id=ctr,
target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id),
input=mf_burst.id,
synapse=MF20Syn_type.id,
spikeTarget='./{}'.format(MF20Syn_type.id))
net.explicit_inputs.append(inst)
ctr += 1
### Electrical coupling between GoCs
# get GJ connectivity
GJ_pairs, GJWt = nu.GJ_conn(GoC_pos, prob_type, GJw_type)
#tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt )
#print("Number of gap junctions per cell: ", tmp1)
#print("Net GJ conductance per cell:", tmp2)
# Add electrical synapses
GoCCoupling = nml.ElectricalProjection(id="gocGJ",
presynaptic_population=goc_pop.id,
postsynaptic_population=goc_pop.id)
nGJ = GJ_pairs.shape[0]
for jj in range(nGJ):
conn = nml.ElectricalConnectionInstanceW(
id=jj,
pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 0],
goc_type.id),
pre_segment='1',
pre_fraction_along='0.5',
post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj, 1],
goc_type.id),
post_segment='1',
post_fraction_along='0.5',
synapse=gj.id,
weight=GJWt[jj])
GoCCoupling.electrical_connection_instance_ws.append(conn)
net.electrical_projections.append(GoCCoupling)
### -------------- Write files
net_filename = 'gocNetwork.nml'
pynml.write_neuroml2_file(net_doc, net_filename)
#lems_filename = 'instances.xml'
#pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False )
simid = 'sim_gocnet' + goc_type.id
ls = LEMSSimulation(simid, duration=duration, dt=dt, simulation_seed=seed)
ls.assign_simulation_target(net.id)
ls.include_neuroml2_file(net_filename)
ls.include_neuroml2_file(goc_filename)
ls.include_neuroml2_file(MFSyn_filename)
ls.include_neuroml2_file(MF20Syn_filename)
#ls.include_lems_file( lems_filename, include_included=False)
# Specify outputs
eof0 = 'Events_file'
ls.create_event_output_file(eof0, "%s.v.spikes" % simid, format='ID_TIME')
for jj in range(goc_pop.size):
ls.add_selection_to_event_output_file(
eof0, jj, '{}/{}/{}'.format(goc_pop.id, jj, goc_type.id), 'spike')
of0 = 'Volts_file'
ls.create_output_file(of0, "%s.v.dat" % simid)
for jj in range(goc_pop.size):
ls.add_column_to_output_file(
of0, jj, '{}/{}/{}/v'.format(goc_pop.id, jj, goc_type.id))
#Create Lems file to run
lems_simfile = ls.save_to_file()
if run:
res = pynml.run_lems_with_jneuroml_neuron(lems_simfile,
max_memory="2G",
nogui=True,
plot=False)
else:
res = pynml.run_lems_with_jneuroml_neuron(lems_simfile,
max_memory="2G",
only_generate_scripts=True,
compile_mods=False,
nogui=True,
plot=False)
return res
def handle_connection(self, proj_id, conn_id, prePop, postPop, synapseType, \
preCellId, \
postCellId, \
preSegId = 0, \
preFract = 0.5, \
postSegId = 0, \
postFract = 0.5, \
delay=0,
weight=1):
#self.printConnectionInformation(proj_id, conn_id, prePop, postPop, synapseType, preCellId, postCellId, weight)
pre_cell_path = "../%s/%i/%s" % (prePop, preCellId,
self.populations[prePop].component)
if self.populations[prePop].type == None:
pre_cell_path = "../%s[%i]" % (prePop, preCellId)
post_cell_path = "../%s/%i/%s" % (postPop, postCellId,
self.populations[postPop].component)
if self.populations[postPop].type == None:
post_cell_path = "../%s[%i]" % (postPop, postCellId)
if isinstance(self.projections[proj_id], neuroml.ElectricalProjection):
instances = False
if len(self.populations[prePop].instances) > 0 or len(
self.populations[postPop].instances) > 0:
instances = True
if not instances:
conn = neuroml.ElectricalConnection(id=conn_id, \
pre_cell="%s"%(preCellId), \
pre_segment=preSegId, \
pre_fraction_along=preFract,
post_cell="%s"%(postCellId), \
post_segment=postSegId,
post_fraction_along=postFract,
synapse=self.projection_syns[proj_id])
self.projections[proj_id].electrical_connections.append(conn)
else:
if weight == 1:
conn = neuroml.ElectricalConnectionInstance(id=conn_id, \
pre_cell=pre_cell_path, \
pre_segment=preSegId, \
pre_fraction_along=preFract,
post_cell=post_cell_path, \
post_segment=postSegId,
post_fraction_along=postFract,
synapse=self.projection_syns[proj_id])
self.projections[
proj_id].electrical_connection_instances.append(conn)
else:
conn = neuroml.ElectricalConnectionInstanceW(id=conn_id, \
pre_cell=pre_cell_path, \
pre_segment=preSegId, \
pre_fraction_along=preFract,
post_cell=post_cell_path, \
post_segment=postSegId,
post_fraction_along=postFract,
synapse=self.projection_syns[proj_id],
weight=weight)
self.projections[
proj_id].electrical_connection_instance_ws.append(conn)
elif isinstance(self.projections[proj_id],
neuroml.ContinuousProjection):
instances = False
if len(self.populations[prePop].instances) > 0 or len(
self.populations[postPop].instances) > 0:
instances = True
if not instances:
if weight != 1:
raise Exception(
"Case not (yet) supported: weight!=1 when not an instance based population..."
)
conn = neuroml.ContinuousConnection(id=conn_id, \
pre_cell="%s"%(preCellId), \
pre_segment=preSegId, \
pre_fraction_along=preFract,
post_cell="%s"%(postCellId), \
post_segment=postSegId,
post_fraction_along=postFract,
pre_component=self.projection_syns_pre[proj_id],
post_component=self.projection_syns[proj_id])
self.projections[proj_id].continuous_connections.append(conn)
else:
if weight == 1:
conn = neuroml.ContinuousConnectionInstance(id=conn_id, \
pre_cell=pre_cell_path, \
pre_segment=preSegId, \
pre_fraction_along=preFract,
post_cell=post_cell_path, \
post_segment=postSegId,
post_fraction_along=postFract,
pre_component=self.projection_syns_pre[proj_id],
post_component=self.projection_syns[proj_id])
self.projections[
proj_id].continuous_connection_instances.append(conn)
else:
conn = neuroml.ContinuousConnectionInstanceW(id=conn_id, \
pre_cell=pre_cell_path, \
pre_segment=preSegId, \
pre_fraction_along=preFract,
post_cell=post_cell_path, \
post_segment=postSegId,
post_fraction_along=postFract,
pre_component=self.projection_syns_pre[proj_id],
post_component=self.projection_syns[proj_id],
weight=weight)
self.projections[
proj_id].continuous_connection_instance_ws.append(conn)
else:
if not self.weightDelays[proj_id] and delay == 0 and weight == 1:
connection = neuroml.Connection(id=conn_id, \
pre_cell_id=pre_cell_path, \
pre_segment_id=preSegId, \
pre_fraction_along=preFract,
post_cell_id=post_cell_path, \
post_segment_id=postSegId,
post_fraction_along=postFract)
self.projections[proj_id].connections.append(connection)
else:
connection = neuroml.ConnectionWD(id=conn_id, \
pre_cell_id=pre_cell_path, \
pre_segment_id=preSegId, \
pre_fraction_along=preFract,
post_cell_id=post_cell_path, \
post_segment_id=postSegId,
post_fraction_along=postFract,
weight=weight,
delay='%sms'%(delay))
self.projections[proj_id].connection_wds.append(connection)
def XF_input_models_3D_region_specific_import(popID, cellType, cellNML2Type,
input_group_parameters,
cell_positions, seed_number,
sim_params):
random.seed(seed_number)
parentDir = None
simID = sim_params['simID']
expID = sim_params['experimentID']
libID = sim_params['libraryID']
saveCellID = sim_params['saveCellID']
lib_params = sim_params['libraryParams']
input_receiving_cells = []
if 'currentDir' in sim_params:
currDir = sim_params['currentDir']
if 'parentDir' in sim_params:
parentDir = sim_params['parentDir']
if parentDir != None:
cellTypeFile = parentDir + "/NeuroML2" + "/" + cellType
else:
cellTypeFile = cellType
fraction_to_target_per_pop = input_group_parameters['fractionToTarget']
dim_array = np.shape(cell_positions)
region_specific_targets_per_cell_group = []
for region in range(0, len(input_group_parameters['regionList'])):
for cell in range(0, dim_array[0]):
if input_group_parameters['regionList'][region]['xVector'][0] < cell_positions[cell,0] \
and cell_positions[cell,0] < input_group_parameters['regionList'][region]['xVector'][1]:
if input_group_parameters['regionList'][region]['yVector'][0] < cell_positions[cell,1] \
and cell_positions[cell,1] < input_group_parameters['regionList'][region]['yVector'][1] :
if input_group_parameters['regionList'][region]['zVector'][0] < cell_positions[cell,2] \
and cell_positions[cell,2] < input_group_parameters['regionList'][region]['zVector'][1]:
region_specific_targets_per_cell_group.append(cell)
target_cells = random.sample(
region_specific_targets_per_cell_group,
int(
round(fraction_to_target_per_pop *
len(region_specific_targets_per_cell_group))))
synapse_list = input_group_parameters['synapseList']
label = input_group_parameters['inputLabel']
input_pop_array = []
spike_arrays = []
proj_arrays = []
synapse_name_array = []
if input_group_parameters['colocalizeSynapses']:
print("will add block for localizing synapses")
if input_group_parameters[
'targetingModel'] == "segments and subsegments":
segment_target_array = extract_morphology_information(
[cellTypeFile], {cellTypeFile: cellNML2Type},
["segments", input_group_parameters['segmentList']])
if input_group_parameters[
'targetingModel'] == "segment groups and segments":
segment_target_array = extract_morphology_information(
[cellTypeFile], {cellTypeFile: cellNML2Type},
["segment groups", input_group_parameters['segmentGroupList']])
cell_counter = 0
for target_cell in target_cells:
if saveCellID:
input_receiving_cells.append(target_cell)
if input_group_parameters[
'numberModel'] == "constant number of inputs per cell":
no_of_inputs = input_group_parameters['noInputs']
if input_group_parameters[
'numberModel'] == "variable number of inputs per cell":
if input_group_parameters['distribution'] == "binomial":
no_of_inputs=np.random.binomial(input_group_parameters['maxNoInputs'],\
input_group_parameters['averageNoInputs']/input_group_parameters['maxNoInputs'])
### other options can be added
if input_group_parameters[
'targetingModel'] == "segment groups and segments":
target_points=get_unique_target_points(segment_target_array,"segment groups and segments",\
[input_group_parameters['segmentGroupList'],input_group_parameters['segmentGroupProbabilities']],no_of_inputs)
if input_group_parameters[
'targetingModel'] == "segments and subsegments":
target_points=get_unique_target_points(segment_target_array,"segments and subsegments",\
[input_group_parameters['segmentList'],input_group_parameters['segmentProbabilities'],\
input_group_parameters['fractionAlongANDsubsegProbabilities']],no_of_inputs)
target_point_counter = 0
for target_point in range(0, len(target_points)):
train_libID = cell_counter + target_point_counter
if libID == 'newlyGenerated':
file_string = currDir + "/simulations/%s/sim%d/%s_%s_syn0_PoissonTrain_%d.dat" % (
expID, simID, label, popID, train_libID)
else:
file_string = currDir + "/simulations/%s/sim%d/%s_PoissonTrain_%d.dat" % (
libID, simID, input_group_parameters['inputIdLibrary'],
train_libID)
if os.path.getsize(file_string) > 0:
target_point_counter += 1
spike_times = np.loadtxt(file_string)
spike_times = np.transpose(spike_times)
spike_times = spike_times[1]
spike_array = neuroml.SpikeArray(
id="%s_%s_cell%d_%d" %
(label, popID, target_cell, target_point))
if 'units' in input_group_parameters:
units = input_group_parameters['units']
else:
units = "ms"
for spike in range(0, len(spike_times)):
spike_object = neuroml.Spike(
id="%d" % spike,
time="%f%s" % (spike_times[spike], units))
spike_array.spikes.append(spike_object)
spike_arrays.append(spike_array)
Input_pop = neuroml.Population(
id="InputPop_%s_%s_cell%d_%d" %
(label, popID, target_cell, target_point),
size=1,
component=spike_array.id)
input_pop_array.append(Input_pop)
for synapse_index in range(0, len(synapse_list)):
synapse_array = synapse_list[synapse_index]
synapse_name = synapse_array['synapseType']
synapse_name_array.append(synapse_name)
proj = neuroml.Projection(id="InputProj_%s_%s_cell%d_syn%d_%d"%(label,popID,target_cell,synapse_index,target_point),presynaptic_population=Input_pop.id,\
postsynaptic_population=popID,synapse=synapse_name)
conn = neuroml.Connection(id="0", \
pre_cell_id="../%s[0]"%(Input_pop.id), \
pre_segment_id=0, \
pre_fraction_along=0.5,\
post_cell_id="../%s/%i/%s"%(popID,target_cell,cellType), \
post_segment_id="%d"%target_points[target_point,0],
post_fraction_along="%f"%target_points[target_point,1])
proj.connections.append(conn)
proj_arrays.append(proj)
cell_counter += 1
else:
for synapse_index in range(0, len(synapse_list)):
synapse_array = synapse_list[synapse_index]
synapse_name = synapse_array['synapseType']
synapse_name_array.append(synapse_name)
if synapse_array['targetingModel'] == "segments and subsegments":
segment_target_array = extract_morphology_information(
[cellTypeFile], {cellTypeFile: cellNML2Type},
["segments", synapse_array['segmentList']])
if synapse_array[
'targetingModel'] == "segment groups and segments":
segment_target_array = extract_morphology_information(
[cellTypeFile], {cellTypeFile: cellNML2Type},
["segment groups", synapse_array['segmentGroupList']])
cell_counter = 0
for target_cell in target_cells:
if saveCellID:
input_receiving_cells.append(target_cell)
if synapse_array[
'numberModel'] == "constant number of inputs per cell":
no_of_inputs = synapse_array['noInputs']
if synapse_array[
'numberModel'] == "variable number of inputs per cell":
if synapse_array['distribution'] == "binomial":
no_of_inputs=np.random.binomial(synapse_array['maxNoInputs'],\
synapse_array['averageNoInputs']/synapse_array['maxNoInputs'])
### other options can be added
if synapse_array[
'targetingModel'] == "segment groups and segments":
target_points=get_unique_target_points(segment_target_array,"segment groups and segments",\
[synapse_array['segmentGroupList'],synapse_array['segmentGroupProbabilities']],no_of_inputs)
if synapse_array[
'targetingModel'] == "segments and subsegments":
target_points=get_unique_target_points(segment_target_array,"segments and subsegments",\
[synapse_array['segmentList'],synapse_array['segmentProbabilities'],\
synapse_array['fractionAlongANDsubsegProbabilities']],no_of_inputs)
target_point_counter = 0
for target_point in range(0, len(target_points)):
train_libID = cell_counter + target_point_counter
if libID == 'newlyGenerated':
file_string = currDir + "/simulations/%s/sim%d/%s_%s_syn%d_PoissonTrain_%d.dat" % (
expID, simID, label, popID, synapse_index,
train_libID)
else:
file_string = currDir + "/simulations/%s/sim%d/%s_PoissonTrain_%d.dat" % (
libID, simID, synapse_array['inputIdLibrary'],
train_libID)
if os.path.getsize(file_string) > 0:
target_point_counter += 1
spike_times = np.loadtxt(file_string)
spike_times = np.transpose(spike_times)
spike_times = spike_times[1]
spike_array = neuroml.SpikeArray(
id="%s_%s_cell%d_syn%d_%d" %
(label, popID, target_cell, synapse_index,
target_point))
if 'units' in input_group_parameters:
units = synapse_array['units']
else:
units = "ms"
for spike in range(0, len(spike_times)):
spike_object = neuroml.Spike(
id="%d" % spike,
time="%f%s" % (spike_times[spike], units))
spike_array.spikes.append(spike_object)
spike_arrays.append(spike_array)
Input_pop = neuroml.Population(
id="InputPop_%s_%s_syn%d_%d" %
(label, popID, synapse_index, target_point),
size=1,
component=spike_array.id)
input_pop_array.append(Input_pop)
proj = neuroml.Projection(id="InputProj_%s_%s_syn%d_%d"%(label,popID,synapse_index,target_point),presynaptic_population=Input_pop.id,\
postsynaptic_population=popID,synapse=synapse_name)
conn = neuroml.Connection(id="0", \
pre_cell_id="../%s[0]"%(Input_pop.id), \
pre_segment_id=0, \
pre_fraction_along=0.5,\
post_cell_id="../%s/%i/%s"%(popID,target_cell,cellType), \
post_segment_id="%d"%target_points[target_point,0],
post_fraction_along="%f"%target_points[target_point,1])
proj.connections.append(conn)
proj_arrays.append(proj)
cell_counter += 1
return input_pop_array, spike_arrays, proj_arrays, synapse_name_array, input_receiving_cells
def chemical_connection_model(pair_id,projection_id,prePop,prePop_listIndex,prePopSize,preCellType,preNML2Type,pre_cell_positions,\
postPop,postPop_listIndex,postPopSize,postCellType,postNML2Type,post_cell_positions,\
connectivity_parameters,seed_number,parentDir=None):
random.seed(seed_number)
if parentDir != None:
preCellTypeFile=parentDir+"/NeuroML2"+"/"+preCellType
postCellTypeFile=parentDir+"/NeuroML2"+"/"+postCellType
else:
preCellTypeFile=preCellType
postCellTypeFile=postCellType
nonempty_projection=False
gapJ_object_array=[]
gap_counter=0
#######
one_population=False
if prePop==postPop:
one_population=True
if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments":
pre_pop_target_segment_array=extract_morphology_information([preCellTypeFile],{preCellTypeFile:preNML2Type},\
["segment groups", \
connectivity_parameters['targetingModelprePop']['segmentGroupList']])
if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments":
pre_pop_target_segment_array=extract_morphology_information([preCellTypeFile],{preCellTypeFile:preNML2Type},\
["segments",connectivity_parameters['targetingModelprePop']['segmentList']])
if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments":
post_pop_target_segment_array=extract_morphology_information([postCellTypeFile],{postCellTypeFile:postNML2Type},\
["segment groups",connectivity_parameters['targetingModelpostPop']['segmentGroupList'] ] )
if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments":
post_pop_target_segment_array=extract_morphology_information([postCellTypeFile],{postCellTypeFile:postNML2Type},\
["segments",connectivity_parameters['targetingModelpostPop']['segmentGroupList']])
proj = neuroml.Projection(id="proj%d"%projection_id,presynaptic_population=prePop,postsynaptic_population=postPop,synapse=connectivity_parameters['synapse'])
synapse_name=connectivity_parameters['synapse']
conn_count = 0
#### for now, no_of_Synapses_Onto_TargetCell is fixed for each presynaptic cell of a given population
no_of_Synapses_Onto_TargetCell=connectivity_parameters['number_of_PostCellSynapses_per_PreCell']
######## connect pre and post populations according to a given probability and a number of synapses made by a single presynaptic cell onto a single postsynaptic cell
if connectivity_parameters['chemicalConnModel']=="explicit_connection_probabilities":
connection_probability=connectivity_parameters['connProb_from_PreCell_to_PostCell']
for Pre_cell in range(0,prePopSize):
if one_population:
post_index_array=range(0,postPopSize)
post_index_array.remove(Pre_cell)
else:
post_index_array=range(0,postPopSize)
if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments":
pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segment groups and segments",\
[connectivity_parameters['targetingModelprePop']['segmentGroupList'],\
connectivity_parameters['targetingModelprePop']['segmentGroupProbabilities']],no_of_Synapses_Onto_TargetCell)
if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments":
pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segments and subsegments",\
[connectivity_parameters['targetingModelprePop']['segmentList'],\
connectivity_parameters['targetingModelprePop']['segmentProbabilities'],connectivity_parameters['targetingModelprePop']['fractionAlongANDsubsegProbabilities']],\
no_of_Synapses_Onto_TargetCell)
for Post_cell in post_index_array:
if random.random() < connection_probability:
if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments":
post_targeting_mode="segment groups and segments"
post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentGroupList'],\
connectivity_parameters['targetingModelpostPop']['segmentGroupProbabilities']]
if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments":
post_targeting_mode="segments and subsegments"
post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentList'],\
connectivity_parameters['targetingModelpostPop']['segmentProbabilities'],connectivity_parameters['targetingModelpostPop']['fractionAlongANDsubsegProbabilities']]
for pre_target_point in range(0,no_of_Synapses_Onto_TargetCell):
if 'maximalConnDistance' in connectivity_parameters:
x=0
while x==0:
post_target_points=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,post_targeting_parameters,1)
if get_3D_connection_length(preCellTypeFile,postCellTypeFile,preNML2Type,postNML2Type,pre_cell_positions,post_cell_positions,Pre_cell,\
Post_cell,pre_target_points[pre_target_point,0],post_target_point[0,0],\
pre_target_points[pre_target_point,1],post_target_point[0,1]) <=connectivity_parameters['maximalConnDistance']:
x=1
else:
post_target_point=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,\
post_targeting_parameters,1)
Pre_segment_id=pre_target_points[pre_target_point,0]
Post_segment_id=post_target_point[0,0]
Pre_fraction=pre_target_points[pre_target_point,1]
Post_fraction=post_target_point[0,1]
conn =neuroml.Connection(id=conn_count,pre_cell="../%s/%d/%s"%(prePop,Pre_cell,preCellType),\
post_cell="../%s/%d/%s"%(postPop,Post_cell,postCellType),\
pre_segment="%d"%Pre_segment_id,post_segment="%d"%Post_segment_id,\
pre_fraction_along="%f"%Pre_fraction,post_fraction_along="%f"%Post_fraction)
nonempty_projection=True
proj.connections.append(conn)
conn_count+=1
##### projection in which each presynaptic cell contacts a fixed number of postsynaptic cells
if connectivity_parameters['chemicalConnModel']=="fixedNo_of_PostTargetCells":
for Pre_cell in range(0,prePopSize):
if one_population:
post_index_array=range(0,postPopSize)
post_index_array.remove(Pre_cell)
else:
post_index_array=range(0,postPopSize)
if connectivity_parameters['chooseTargetMode']=='random':
randomly_selected_target_cells=random.sample(range(post_index_array),int(round(connectivity_parameters['number_of_PostTargetCells_per_PreCell'])))
###### other chooseTargetModes can be added in the future
if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments":
pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segment groups and segments",\
[connectivity_parameters['targetingModelprePop']['segmentGroupList'],\
connectivity_parameters['targetingModelprePop']['segmentGroupProbabilities']],no_of_Synapses_Onto_TargetCell)
if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments":
pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segments and subsegments",\
[connectivity_parameters['targetingModelprePop']['segmentList'],\
connectivity_parameters['targetingModelprePop']['segmentProbabilities'],connectivity_parameters['targetingModelprePop']['fractionAlongANDsubsegProbabilities']],\
no_of_Synapses_Onto_TargetCell)
for Post_cell in randomly_selected_target_cells:
if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments":
post_targeting_mode="segment groups and segments"
post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentGroupList'],\
connectivity_parameters['targetingModelpostPop']['segmentGroupProbabilities']]
if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments":
post_targeting_mode="segments and subsegments"
post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentList'],\
connectivity_parameters['targetingModelpostPop']['segmentProbabilities'],connectivity_parameters['targetingModelpostPop']['fractionAlongANDsubsegProbabilities']]
for pre_target_point in range(0,no_of_Synapses_Onto_TargetCell):
if 'maximalConnDistance' in connectivity_parameters:
x=0
while x==0:
post_target_points=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,post_targeting_parameters,1)
if get_3D_connection_length(preCellTypeFile,postCellTypeFile,preNML2Type,postNML2Type,pre_cell_positions,post_cell_positions,Pre_cell,\
Post_cell,pre_target_points[pre_target_point,0],post_target_point[0,0],\
pre_target_points[pre_target_point,1],post_target_point[0,1]) <=connectivity_parameters['maximalConnDistance']:
x=1
else:
post_target_point=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,\
post_targeting_parameters,1)
Pre_segment_id=pre_target_points[pre_target_point,0]
Post_segment_id=post_target_point[0,0]
Pre_fraction=pre_target_points[pre_target_point,1]
Post_fraction=post_target_point[0,1]
conn =neuroml.Connection(id=conn_count,pre_cell="../%s/%d/%s"%(prePop,Pre_cell,preCellType),\
post_cell="../%s/%d/%s"%(postPop,Post_cell,postCellType),\
pre_segment="%d"%Pre_segment_id,post_segment="%d"%Post_segment_id,\
pre_fraction_along="%f"%Pre_fraction,post_fraction_along="%f"%Post_fraction)
nonempty_projection=True
proj.connections.append(conn)
conn_count+=1
############ projection in which each presynaptic cell of a given presynaptic population has a variable number of postsynaptic targets according to a given statistical distribution
if connectivity_parameters['chemicalConnModel']=="variableNo_of_PostTargetCells":
for Pre_cell in range(0,prePopSize):
if one_population:
post_index_array=range(0,postPopSize)
post_index_array.remove(Pre_cell)
else:
post_index_array=range(0,postPopSize)
if connectivity_parameters['targetNoModel']['modelType']=='binomial':
no_of_targets=np.random.binomial(connectivity_parameters['targetNoModel']['maxTargetNo'],\
connectivity_parameters['targetNoModel']['average']/connectivity_parameters['targetNoModel']['maxTargetNo'])
####### other distributions can be added in the future
if connectivity_parameters['chooseTargetMode']=='random':
randomly_selected_target_cells=random.sample(post_index_array,int(round(no_of_targets)))
###### other chooseTargetModes can be added in the future
if connectivity_parameters['targetingModelprePop']['model']=="segment groups and segments":
pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segment groups and segments",\
[connectivity_parameters['targetingModelprePop']['segmentGroupList'],\
connectivity_parameters['targetingModelprePop']['segmentGroupProbabilities']],no_of_Synapses_Onto_TargetCell)
if connectivity_parameters['targetingModelprePop']['model']=="segments and subsegments":
pre_target_points=get_unique_target_points(pre_pop_target_segment_array,"segments and subsegments",\
[connectivity_parameters['targetingModelprePop']['segmentList'],\
connectivity_parameters['targetingModelprePop']['segmentProbabilities'],connectivity_parameters['targetingModelprePop']['fractionAlongANDsubsegProbabilities']],\
no_of_Synapses_Onto_TargetCell)
for Post_cell in randomly_selected_target_cells:
if connectivity_parameters['targetingModelpostPop']['model']=="segment groups and segments":
post_targeting_mode="segment groups and segments"
post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentGroupList'],\
connectivity_parameters['targetingModelpostPop']['segmentGroupProbabilities']]
if connectivity_parameters['targetingModelpostPop']['model']=="segments and subsegments":
post_targeting_mode="segments and subsegments"
post_targeting_parameters=[connectivity_parameters['targetingModelpostPop']['segmentList'],\
connectivity_parameters['targetingModelpostPop']['segmentProbabilities'],connectivity_parameters['targetingModelpostPop']['fractionAlongANDsubsegProbabilities']]
for pre_target_point in range(0,no_of_Synapses_Onto_TargetCell):
if 'maximalConnDistance' in connectivity_parameters:
x=0
while x==0:
post_target_points=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,post_targeting_parameters,1)
if get_3D_connection_length(preCellTypeFile,postCellTypeFile,preNML2Type,postNML2Type,pre_cell_positions,post_cell_positions,Pre_cell,\
Post_cell,pre_target_points[pre_target_point,0],post_target_point[0,0],\
pre_target_points[pre_target_point,1],post_target_point[0,1]) <=connectivity_parameters['maximalConnDistance']:
x=1
else:
post_target_point=get_unique_target_points(post_pop_target_segment_array,post_targeting_mode,\
post_targeting_parameters,1)
Pre_segment_id=pre_target_points[pre_target_point,0]
Post_segment_id=post_target_point[0,0]
Pre_fraction=pre_target_points[pre_target_point,1]
Post_fraction=post_target_point[0,1]
conn =neuroml.Connection(id=conn_count,pre_cell="../%s/%d/%s"%(prePop,Pre_cell,preCellType),\
post_cell="../%s/%d/%s"%(postPop,Post_cell,postCellType),\
pre_segment="%d"%Pre_segment_id,post_segment="%d"%Post_segment_id,\
pre_fraction_along="%f"%Pre_fraction,post_fraction_along="%f"%Post_fraction)
nonempty_projection=True
proj.connections.append(conn)
conn_count+=1
return proj, nonempty_projection,gapJ_object_array,synapse_name
def create_GoC_network( duration, dt, seed, N_goc=0, run=False, prob_type='Boltzmann', GJw_type='Vervaeke2010' ):
goc_filename = 'GoC.cell.nml'
goc_file = pynml.read_neuroml2_file( goc_filename )
goc_type = goc_file.cells[0]
GJ_filename = 'GapJuncCML.nml'
GJ_file = pynml.read_neuroml2_file( GJ_filename )
GJ_type = GJ_file.gap_junctions[0]
MFSyn_filename = 'MF_GoC_Syn.nml'
mfsyn_file = pynml.read_neuroml2_file( MFSyn_filename )
MFSyn_type = mfsyn_file.exp_three_synapses[0]
MF20Syn_filename = 'MF_GoC_SynMult.nml'
mf20syn_file = pynml.read_neuroml2_file( MF20Syn_filename )
MF20Syn_type = mf20syn_file.exp_three_synapses[0]
# Distribute cells in 3D
if N_goc>0:
GoC_pos = nu.GoC_locate(N_goc)
else:
GoC_pos = nu.GoC_density_locate()
N_goc = GoC_pos.shape[0]
# get GJ connectivity
GJ_pairs, GJWt = nu.GJ_conn( GoC_pos, prob_type, GJw_type )
tmp1, tmp2 = valnet.gapJuncAnalysis( GJ_pairs, GJWt )
print("Number of gap junctions per cell: ", tmp1)
print("Net GJ conductance per cell:", tmp2)
# Create pop List
goc_pop = nml.Population( id=goc_type.id+"Pop", component = goc_type.id, type="populationList", size=N_goc )
# Create NML document for network specification
net = nml.Network( id="gocNetwork", type="networkWithTemperature" , temperature="23 degC" )
net_doc = nml.NeuroMLDocument( id=net.id )
net_doc.networks.append( net )
net_doc.includes.append( goc_type )
net.populations.append( goc_pop )
#Add locations for GoC instances in the population:
for goc in range(N_goc):
inst = nml.Instance( id=goc )
goc_pop.instances.append( inst )
inst.location = nml.Location( x=GoC_pos[goc,0], y=GoC_pos[goc,1], z=GoC_pos[goc,2] )
# Define input spiketrains
input_type = 'spikeGenerator'#'spikeGeneratorPoisson'
lems_inst_doc = lems.Model()
mf_inputs = lems.Component( "MF_Input", input_type)
mf_inputs.set_parameter("period", "2000 ms" )
#mf_inputs.set_parameter("averageRate", "50 Hz")
lems_inst_doc.add( mf_inputs )
#synapse_type = 'alphaCurrentSynapse'
#alpha_syn = lems.Component( "AlphaSyn", synapse_type)
#alpha_syn.set_parameter("tau", "30 ms" )
#alpha_syn.set_parameter("ibase", "200 pA")
#lems_inst_doc.add( alpha_syn )
# Define MF input population
N_mf = 15
#MF_pop = nml.Population(id=mf_inputs.id+"_pop", component=mf_inputs.id, type="populationList", size=N_mf)
#net.populations.append( MF_pop )
mf_type2 = 'spikeGeneratorPoisson'
#mf_poisson = lems.Component( "MF_Poisson", mf_type2)
#mf_poisson.set_parameter("averageRate", "5 Hz")
#lems_inst_doc.add( mf_poisson )
# adding in neuroml document instead of mf_poisson
mf_poisson = nml.SpikeGeneratorPoisson( id = "MF_Poisson", average_rate="5 Hz" )
net_doc.spike_generator_poissons.append( mf_poisson )
net_doc.includes.append( goc_type )
MF_Poisson_pop = nml.Population(id=mf_poisson.id+"_pop", component=mf_poisson.id, type="populationList", size=N_mf)
net.populations.append( MF_Poisson_pop )
MF_pos = nu.GoC_locate( N_mf )
for mf in range( N_mf ):
inst = nml.Instance(id=mf)
MF_Poisson_pop.instances.append( inst )
inst.location = nml.Location( x=MF_pos[mf,0], y=MF_pos[mf,1], z=MF_pos[mf,2] )
# Setup Mf->GoC synapses
#MFprojection = nml.Projection(id="MFtoGoC", presynaptic_population=MF_pop.id, postsynaptic_population=goc_pop.id, synapse=alpha_syn.id)
#net.projections.append(MFprojection)
MF2projection = nml.Projection(id="MF2toGoC", presynaptic_population=MF_Poisson_pop.id, postsynaptic_population=goc_pop.id, synapse=MFSyn_type.id)#alpha_syn.id
net.projections.append(MF2projection)
#Get list of MF->GoC synapse
mf_synlist = nu.randdist_MF_syn( N_mf, N_goc, pConn=0.3)
nMFSyn = mf_synlist.shape[1]
for syn in range( nMFSyn ):
mf, goc = mf_synlist[:, syn]
conn2 = nml.Connection(id=syn, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, mf, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5")
MF2projection.connections.append(conn2)
# Burst of MF input (as explicit input)
mf_bursttype = 'transientPoissonFiringSynapse'
mf_burst = lems.Component( "MF_Burst", mf_bursttype)
mf_burst.set_parameter( "averageRate", "100 Hz" )
mf_burst.set_parameter( "delay", "2000 ms" )
mf_burst.set_parameter( "duration", "500 ms" )
mf_burst.set_parameter( "synapse", MF20Syn_type.id )
mf_burst.set_parameter( "spikeTarget", './{}'.format(MF20Syn_type.id) )
lems_inst_doc.add( mf_burst )
# Add few burst inputs
n_bursts = 4
gocPerm = np.random.permutation( N_goc )
ctr = 0
for gg in range(4):
goc = gocPerm[gg]
for jj in range( n_bursts ):
inst = nml.ExplicitInput( id=ctr, target='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), input=mf_burst.id, synapse=MF20Syn_type.id, spikeTarget='./{}'.format(MF20Syn_type.id))
net.explicit_inputs.append( inst )
ctr += 1
'''
one-to-one pairing of MF and GoC -> no shared inputs
for goc in range(N_mf):
#inst = nml.Instance(id=goc)
#MF_pop.instances.append( inst )
#inst.location = nml.Location( x=GoC_pos[goc,0], y=GoC_pos[goc,1], z=GoC_pos[goc,2]+100 )
#conn = nml.Connection(id=goc, pre_cell_id='../{}/{}/{}'.format(MF_pop.id, goc, mf_inputs.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc, goc_type.id), post_segment_id='0', post_fraction_along="0.5")
#MFprojection.connections.append(conn)
goc2 = N_goc-goc-1
inst2 = nml.Instance(id=goc)
MF_Poisson_pop.instances.append( inst2 )
inst2.location = nml.Location( x=GoC_pos[goc2,0], y=GoC_pos[goc2,1], z=GoC_pos[goc2,2]+100 )
conn2 = nml.Connection(id=goc, pre_cell_id='../{}/{}/{}'.format(MF_Poisson_pop.id, goc, mf_poisson.id), post_cell_id='../{}/{}/{}'.format(goc_pop.id, goc2, goc_type.id), post_segment_id='0', post_fraction_along="0.5")
MF2projection.connections.append(conn2)
'''
# Add electrical synapses
GoCCoupling = nml.ElectricalProjection( id="gocGJ", presynaptic_population=goc_pop.id, postsynaptic_population=goc_pop.id )
#print(GJ_pairs)
gj = nml.GapJunction( id="GJ_0", conductance="426pS" )
net_doc.gap_junctions.append(gj)
nGJ = GJ_pairs.shape[0]
for jj in range( nGJ ):
#gj.append( lems.Component( "GJ_%d"%jj, 'gapJunction') )
#gj[jj].set_parameter( "conductance", "%fnS"%(GJWt[jj]) )
#gj = nml.GapJunction(id="GJ_%d"%jj, conductance="%fnS"%(GJWt[jj]))
#net_doc.gap_junctions.append(gj)
#lems_inst_doc.add( gj[jj] )
#print("%fnS"%(GJWt[jj]*0.426))
conn = nml.ElectricalConnectionInstanceW( id=jj, pre_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj,0], goc_type.id), pre_segment='1', pre_fraction_along='0.5', post_cell='../{}/{}/{}'.format(goc_pop.id, GJ_pairs[jj,1], goc_type.id), post_segment='1', post_fraction_along='0.5', synapse=gj.id, weight=GJWt[jj] )#synapse="GapJuncCML" synapse=gj.id , conductance="100E-9mS"
# ------------ need to create GJ component
GoCCoupling.electrical_connection_instance_ws.append( conn )
net.electrical_projections.append( GoCCoupling )
net_filename = 'gocNetwork.nml'
pynml.write_neuroml2_file( net_doc, net_filename )
lems_filename = 'instances.xml'
pynml.write_lems_file( lems_inst_doc, lems_filename, validate=False )
simid = 'sim_gocnet'+goc_type.id
ls = LEMSSimulation( simid, duration=duration, dt=dt, simulation_seed=seed )
ls.assign_simulation_target( net.id )
#ls.include_lems_file( 'Synapses.xml', include_included=False)
#ls.include_lems_file( 'Inputs.xml', include_included=False)
ls.include_neuroml2_file( net_filename)
ls.include_neuroml2_file( goc_filename)
ls.include_neuroml2_file( GJ_filename)
ls.include_neuroml2_file( MFSyn_filename)
ls.include_neuroml2_file( MF20Syn_filename)
ls.include_lems_file( lems_filename, include_included=False)
# Specify outputs
eof0 = 'Events_file'
ls.create_event_output_file(eof0, "%s.v.spikes"%simid,format='ID_TIME')
for jj in range( goc_pop.size):
ls.add_selection_to_event_output_file( eof0, jj, '{}/{}/{}'.format( goc_pop.id, jj, goc_type.id), 'spike' )
of0 = 'Volts_file'
ls.create_output_file(of0, "%s.v.dat"%simid)
for jj in range( goc_pop.size ):
ls.add_column_to_output_file(of0, jj, '{}/{}/{}/v'.format( goc_pop.id, jj, goc_type.id))
#Create Lems file to run
lems_simfile = ls.save_to_file()
#res = pynml.run_lems_with_jneuroml( lems_simfile, max_memory="1G",nogui=True, plot=False)
#res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", only_generate_scripts = True, compile_mods = False, nogui=True, plot=False)
res = pynml.run_lems_with_jneuroml_neuron( lems_simfile, max_memory="2G", compile_mods = False,nogui=True, plot=False)
#res=True
return res
target='../%s/2/%s' % (pyr_cells_pop3.id, cell_id),
segment_id="4",
destination="synapses"))
net.input_lists.append(tsi_input_list)
# Create a projection
proj_sa = neuroml.Projection(id="Proj_sa",
synapse=syn1.id,
presynaptic_population=sa_pop.id,
postsynaptic_population=pyr_cells_pop1.id)
net.projections.append(proj_sa)
proj_sa.connections.append(neuroml.Connection(id=0, \
pre_cell_id="../%s[0]"%(sa_pop.id),
post_cell_id="../%s/%i/%s"%(pyr_cells_pop1.id,0,cell_id)))
proj_sa.connections.append(neuroml.Connection(id=1, \
pre_cell_id="../%s[0]"%(sa_pop.id),
post_cell_id="../%s/%i/%s"%(pyr_cells_pop1.id,1,cell_id),
post_segment_id = "2",))
proj_sa.connections.append(neuroml.Connection(id=2, \
pre_cell_id="../%s[0]"%(sa_pop.id),
post_cell_id="../%s/%i/%s"%(pyr_cells_pop1.id,2,cell_id),
post_segment_id = "4",))
proj_sgp = neuroml.Projection(id="Proj_sgp",
synapse=syn0.id,
presynaptic_population=sgp_pop.id,
def generate_grc_layer_network(
p_mf_ON,
duration,
dt,
minimumISI, # ms
ONRate, # Hz
OFFRate, # Hz
run=False):
# Load connectivity matrix
file = open('GCLconnectivity.pkl')
p = pkl.load(file)
conn_mat = p['conn_mat']
N_mf, N_grc = conn_mat.shape
assert (np.all(conn_mat.sum(
axis=0) == 4)), 'Connectivity matrix is incorrect.'
# Load GrC and MF rosette positions
grc_pos = p['grc_pos']
glom_pos = p['glom_pos']
# Choose which mossy fibers are on, which are off
N_mf_ON = int(N_mf * p_mf_ON)
mf_indices_ON = random.sample(range(N_mf), N_mf_ON)
mf_indices_ON.sort()
N_mf_OFF = N_mf - N_mf_ON
mf_indices_OFF = [x for x in range(N_mf) if x not in mf_indices_ON]
mf_indices_OFF.sort()
# load NeuroML components, LEMS components and LEMS componentTypes from external files
##spikeGeneratorRefPoisson is now a standard nml type...
##spike_generator_doc = pynml.read_lems_file(spike_generator_file_name)
iaF_GrC = nml.IafRefCell(id="iaF_GrC",
refract="2ms",
C="3.22pF",
thresh="-40mV",
reset="-63mV",
leak_conductance="1.498nS",
leak_reversal="-79.67mV")
ampa_syn_filename = "RothmanMFToGrCAMPA.xml"
nmda_syn_filename = "RothmanMFToGrCNMDA.xml"
rothmanMFToGrCAMPA_doc = pynml.read_lems_file(ampa_syn_filename)
rothmanMFToGrCNMDA_doc = pynml.read_lems_file(nmda_syn_filename)
# define some components from the componentTypes we just loaded
##spike_generator_ref_poisson_type = spike_generator_doc.component_types['spikeGeneratorRefPoisson']
lems_instances_doc = lems.Model()
spike_generator_ref_poisson_type_name = 'spikeGeneratorRefPoisson'
spike_generator_on = lems.Component("mossySpikerON",
spike_generator_ref_poisson_type_name)
spike_generator_on.set_parameter("minimumISI", "%s ms" % minimumISI)
spike_generator_on.set_parameter("averageRate", "%s Hz" % ONRate)
lems_instances_doc.add(spike_generator_on)
spike_generator_off = lems.Component(
"mossySpikerOFF", spike_generator_ref_poisson_type_name)
spike_generator_off.set_parameter("minimumISI", "%s ms" % minimumISI)
spike_generator_off.set_parameter("averageRate", "%s Hz" % OFFRate)
lems_instances_doc.add(spike_generator_off)
rothmanMFToGrCAMPA = rothmanMFToGrCAMPA_doc.components[
'RothmanMFToGrCAMPA'].id
rothmanMFToGrCNMDA = rothmanMFToGrCNMDA_doc.components[
'RothmanMFToGrCNMDA'].id
# create populations
GrCPop = nml.Population(id=iaF_GrC.id + "Pop",
component=iaF_GrC.id,
type="populationList",
size=N_grc)
GrCPop.properties.append(nml.Property(tag='color', value='0 0 0.8'))
GrCPop.properties.append(nml.Property(tag='radius', value=2))
mossySpikersPopON = nml.Population(id=spike_generator_on.id + "Pop",
component=spike_generator_on.id,
type="populationList",
size=N_mf_ON)
mossySpikersPopON.properties.append(
nml.Property(tag='color', value='0.8 0 0'))
mossySpikersPopON.properties.append(nml.Property(tag='radius', value=2))
mossySpikersPopOFF = nml.Population(id=spike_generator_off.id + "Pop",
component=spike_generator_off.id,
size=N_mf_OFF)
mossySpikersPopOFF.properties.append(
nml.Property(tag='color', value='0 0.8 0'))
mossySpikersPopOFF.properties.append(nml.Property(tag='radius', value=2))
# create network and add populations
net = nml.Network(id="network")
net_doc = nml.NeuroMLDocument(id=net.id)
net_doc.networks.append(net)
net_doc.iaf_ref_cells.append(iaF_GrC)
net.populations.append(GrCPop)
net.populations.append(mossySpikersPopON)
net.populations.append(mossySpikersPopOFF)
#net_doc.includes.append(nml.IncludeType(href=iaf_nml2_file_name))
# Add locations for GCs
for grc in range(N_grc):
inst = nml.Instance(id=grc)
GrCPop.instances.append(inst)
inst.location = nml.Location(x=grc_pos[grc, 0],
y=grc_pos[grc, 1],
z=grc_pos[grc, 2])
# ON MFs: locations and connectivity
ONprojectionAMPA = nml.Projection(
id="ONProjAMPA",
presynaptic_population=mossySpikersPopON.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCAMPA)
ONprojectionNMDA = nml.Projection(
id="ONProjNMDA",
presynaptic_population=mossySpikersPopON.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCNMDA)
net.projections.append(ONprojectionAMPA)
net.projections.append(ONprojectionNMDA)
ix = 0
for mf_ix_ON in range(N_mf_ON):
mf_ix = mf_indices_ON[mf_ix_ON]
inst = nml.Instance(id=mf_ix_ON)
mossySpikersPopON.instances.append(inst)
inst.location = nml.Location(x=glom_pos[mf_ix, 0],
y=glom_pos[mf_ix, 1],
z=glom_pos[mf_ix, 2])
# find which granule cells are neighbors
innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0]
for grc_ix in innervated_grcs:
for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]:
connection = nml.Connection(
id=ix,
pre_cell_id='../{}/{}/{}'.format(mossySpikersPopON.id,
mf_ix_ON,
spike_generator_on.id),
post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix,
iaF_GrC.id))
ONprojectionAMPA.connections.append(connection)
ONprojectionNMDA.connections.append(connection)
ix = ix + 1
# OFF MFs: locations and connectivity
OFFprojectionAMPA = nml.Projection(
id="OFFProjAMPA",
presynaptic_population=mossySpikersPopOFF.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCAMPA)
OFFprojectionNMDA = nml.Projection(
id="OFFProjNMDA",
presynaptic_population=mossySpikersPopOFF.id,
postsynaptic_population=GrCPop.id,
synapse=rothmanMFToGrCNMDA)
net.projections.append(OFFprojectionAMPA)
net.projections.append(OFFprojectionNMDA)
ix = 0
for mf_ix_OFF in range(N_mf_OFF):
mf_ix = mf_indices_OFF[mf_ix_OFF]
inst = nml.Instance(id=mf_ix_OFF)
mossySpikersPopOFF.instances.append(inst)
inst.location = nml.Location(x=glom_pos[mf_ix, 0],
y=glom_pos[mf_ix, 1],
z=glom_pos[mf_ix, 2])
# find which granule cells are neighbors
innervated_grcs = np.where(conn_mat[mf_ix, :] == 1)[0]
for grc_ix in innervated_grcs:
for synapse in [rothmanMFToGrCAMPA, rothmanMFToGrCNMDA]:
connection = nml.Connection(
id=ix,
pre_cell_id='../{}/{}/{}'.format(mossySpikersPopOFF.id,
mf_ix_OFF,
spike_generator_on.id),
post_cell_id='../{}/{}/{}'.format(GrCPop.id, grc_ix,
iaF_GrC.id))
OFFprojectionAMPA.connections.append(connection)
OFFprojectionNMDA.connections.append(connection)
ix = ix + 1
# Write network to file
net_file_name = 'OSBnet.nml'
pynml.write_neuroml2_file(net_doc, net_file_name)
# Write LEMS instances to file
lems_instances_file_name = 'instances.xml'
pynml.write_lems_file(lems_instances_doc,
lems_instances_file_name,
validate=False)
# Create a LEMSSimulation to manage creation of LEMS file
ls = LEMSSimulation(
'sim', duration, dt,
simulation_seed=123) # int(np.round(1000*random.random())))
# Point to network as target of simulation
ls.assign_simulation_target(net.id)
# Include generated/existing NeuroML2 files
###ls.include_lems_file(spike_generator_file_name, include_included=False)
ls.include_lems_file(lems_instances_file_name)
ls.include_lems_file(ampa_syn_filename, include_included=False)
ls.include_lems_file(nmda_syn_filename, include_included=False)
ls.include_neuroml2_file(net_file_name)
# Specify Displays and Output Files
basedir = ''
eof0 = 'Volts_file'
ls.create_event_output_file(eof0, basedir + "MF_spikes.dat")
for i in range(mossySpikersPopON.size):
ls.add_selection_to_event_output_file(
eof0, mf_indices_ON[i], '{}/{}/{}'.format(mossySpikersPopON.id, i,
spike_generator_on.id),
'spike')
for i in range(mossySpikersPopOFF.size):
ls.add_selection_to_event_output_file(
eof0, mf_indices_OFF[i],
'{}/{}/{}'.format(mossySpikersPopOFF.id, i,
spike_generator_on.id), 'spike')
eof1 = 'GrCspike_file'
ls.create_event_output_file(eof1, basedir + "GrC_spikes.dat")
for i in range(GrCPop.size):
ls.add_selection_to_event_output_file(
eof1, i, '{}/{}/{}'.format(GrCPop.id, i, iaF_GrC.id), 'spike')
lems_file_name = ls.save_to_file()
if run:
print('Running the generated LEMS file: %s for simulation of %sms' %
(lems_file_name, duration))
results = pynml.run_lems_with_jneuroml(lems_file_name,
max_memory="8G",
nogui=True,
load_saved_data=False,
plot=False)
return results
nc.populations.append(pc)
instance = neuroml.Instance(0)
instance.location = neuroml.Location(100, 100, 33.333)
pc.instances.append(instance)
instance = neuroml.Instance(1)
instance.location = neuroml.Location(200, 200, 66.66)
pc.instances.append(instance)
prc = ProjectionContainer(id="proj",
presynaptic_population=pc0.id,
postsynaptic_population=pc.id,
synapse="ampa")
conn = neuroml.Connection(id=0,
pre_cell_id="../%s/%i/%s"%(pc0.id,0,pc0.component), \
pre_segment_id=2, \
pre_fraction_along=0.1,
post_cell_id="../%s/%i/%s"%(pc.id,2,pc.id))
prc.connections.append(conn)
nc.projections.append(prc)
ilc = InputListContainer(id="iii", component="CCC", populations=pc.id)
nc.input_lists.append(ilc)
ilc.input.append(
neuroml.Input(id=0,
target="../pyramidals_48/37/pyr_4_sym",
destination="synapses",
segment_id="2",
fraction_along="0.3"))
nc2 = NetworkContainer(id="testnet2")