def __init__(self, pre_index, post_index, presynaptic_population,
postsynaptic_population, projection_nml, conn_id,
pre_pop_comp, post_pop_comp, **attributes):
#logger.info("Creating Connection: %s -> %s (%s)" % (pre_index, post_index, projection_nml))
self.presynaptic_index = pre_index
self.postsynaptic_index = post_index
nml_pre_index = pre_index
nml_post_index = post_index
pre_pop = presynaptic_population
if isinstance(presynaptic_population, common.PopulationView):
pre_pop = presynaptic_population.parent
nml_pre_index = presynaptic_population.index_in_grandparent(
[pre_index])[0]
post_pop = postsynaptic_population
if isinstance(postsynaptic_population, common.PopulationView):
post_pop = postsynaptic_population.parent
nml_post_index = postsynaptic_population.index_in_grandparent(
[post_index])[0]
projection_nml.connection_wds.append(
neuroml.ConnectionWD(
id=conn_id,
pre_cell_id="../%s/%i/%s" %
(pre_pop.label, nml_pre_index, pre_pop_comp),
post_cell_id="../%s/%i/%s" %
(post_pop.label, nml_post_index, post_pop_comp),
weight=attributes['WEIGHT'],
delay='%sms' % attributes['DELAY']))
for name, value in attributes.items():
setattr(self, name, value)
def __init__(self, pre, post, projection, conn_id, pre_pop_comp, post_pop_comp, **attributes):
#logger.debug("Creating Connection: %s -> %s" % (pre, post))
self.presynaptic_index = pre
self.postsynaptic_index = post
projection.connection_wds.append(neuroml.ConnectionWD(id=conn_id,pre_cell_id="../%s/%i/%s"%(projection.presynaptic_population,pre,pre_pop_comp),
post_cell_id="../%s/%i/%s"%(projection.postsynaptic_population,post,post_pop_comp), weight=attributes['WEIGHT'], delay='%sms'%attributes['DELAY']))
for name, value in attributes.items():
setattr(self, name, value)
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 add_synapses(net,
conndata,
nrn_runname,
dCellIDs,
dNumCells,
write_synapse_file=False):
'''
Reads original data files: conndata_x.dat, connections.dat and synlist.dat (created by launch_synapse_printer.hoc)
create synapse files (only .txt files TODO: automate to make .nml-files)
calculates the place of synapses and connects the cells
:param net: neuroml.Network() - to which the projections will be added
:param conndata: string(int) - original connection data file (only for setting the weights of the synapses, other parameters are loaded from other files)
:param nrn_runname: string - name of the directory where the saved data files are stored (synlist.dat, connections.dat) ! nrn_runname depends on conndata !
:param dCellIDs - dictionary created by create_populations, which stroes the gid's
:param dNumCells - dictionary created by create_populations, quick and dirty way to handle pyramidalcell -> [poolosyncell, cutsuridiscell] in conndata_x.dat and synlist.dat
'''
# read in synaptic weight (if weight is 0 don't create synapses)
fConndata = "../../datasets/conndata_%s.dat" % conndata
dSWeights = {}
with open(fConndata) as file:
next(file) # skip header/first row: "99"
for line in file:
# handle pyramidalcell
preCell = helper_pyramidalcell(line.split()[0], dNumCells)
postCell = helper_pyramidalcell(line.split()[1], dNumCells)
weight = float(line.split()[2]) * 1000 # nS
if weight != 0.:
id = "%s_to_%s" % (preCell, postCell)
dSWeights[id] = weight
file.close()
# read in synapse types and IDs
fSynapses = "../../results/%s/synlist.dat" % nrn_runname
dSynapseIDs = {}
# for automated synapse file generation ...
# there will be a unique synapse for every poosible connection where the weight is not 0 (not all of them will be used in the network)
exp2Synapses = ''
customGABASynapses = ''
synapse_types = []
with open(fSynapses) as file:
for line in file:
# handle pyramidalcell
preCell = helper_pyramidalcell(line.split()[1], dNumCells)
postCell = helper_pyramidalcell(line.split()[0], dNumCells)
tmp = "%s_to_%s" % (preCell, postCell)
if tmp in dSWeights: # only handle synapse if weight is != 0
id = "syn_%s_to_%s" % (preCell, postCell)
synapseID = "%s_%s" % (id, int(line.split()[2]))
weight = dSWeights[tmp]
tmp = line.split()[3] # is like: cell_type[0].foo[x]
postSegID = tmp[tmp.rfind('.') + 1:tmp.rfind('[')] + '_' + tmp[
tmp.rfind('[') + 1:tmp.rfind(']')] # converts it to: foo_x
if synapseID not in dSynapseIDs:
dSynapseIDs[synapseID] = postSegID
# write out synapses
tauRise = float(line.split()[5])
tauDecay = float(line.split()[6])
erev = float(line.split()[7])
syn = '\t<expTwoSynapse id="%s" gbase="%gnS" erev="%gmV" tauDecay="%gms" tauRise="%gms"/>\n\n' % (
id, weight, erev, tauDecay, tauRise)
if id not in synapse_types and line.split(
)[4] != "ExpGABAab":
exp2Synapses += syn
synapse_types.append(id)
else:
tauRiseB = float(line.split()[5])
tauDecayB = float(line.split()[6])
erevB = float(line.split()[7])
synA = '\t<expTwoSynapse id="%s_A" gbase="%gnS" erev="%gmV" tauDecay="%gms" tauRise="%gms"/>\n' % (
id, weight, erev, tauDecay, tauRise)
synB = '\t<expTwoSynapse id="%s_B" gbase="%gnS" erev="%gmV" tauDecay="%gms" tauRise="%gms"/>\n\n' % (
id, weight / 3.37, erevB, tauDecayB, tauRiseB)
if id not in synapse_types:
customGABASynapses += (synA + synB)
synapse_types.append(id)
if write_synapse_file:
fExp2Synapses = open("../synapses/exp2Synapses.txt", 'w')
fExp2Synapses.write(exp2Synapses)
fExp2Synapses.close()
fCustomGABASynapses = open("../synapses/customGABASynapses.txt",
'w')
fCustomGABASynapses.write(customGABASynapses)
fCustomGABASynapses.close()
file.close()
# read in connections
"""
Note: if you run the model (the NEURON one) on multiple processors with CatFlag==0,
then the connections will be dispersed in one file per processor, named subconns_[processorID].dat.
SimTracker can then merge the files together, but if you don't use SimTracker and are using multiple processors,
try setting CatFlag==1 to have NEURON concatenate all the data into one connections.dat file)
This code was based on test runs wth a single processor, so we are using subconns_0.dat
"""
fConnections = "../../results/%s/subconns_0.dat" % nrn_runname # TODO: fix this...(see above in docstring)
dProjections = {}
with open(fConnections) as file:
# next(file) # skip header: "source, target, synapse" <- only if useing connections.dat, created by SimTracker
for line in file:
preCellID = int(line.split()[0])
preCell_type = dCellIDs[preCellID][0]
preCellIDPop = dCellIDs[preCellID][1]
postCellID = int(line.split()[1])
postCell_type = dCellIDs[postCellID][0]
postCellIDPop = dCellIDs[postCellID][1]
synapseID = int(line.split()[2])
postSegID = dSynapseIDs["syn_%s_to_%s_%g" %
(preCell_type, postCell_type, synapseID)]
connection = [preCellIDPop, postCellIDPop, postSegID]
projID = "proj_%spop_to_%spop" % (preCell_type, postCell_type)
if projID not in dProjections:
dProjections[projID] = []
dProjections[projID].append(connection)
else:
dProjections[projID].append(connection)
file.close()
# load cell morphologies (for segment and fractionAlong calculation for neuroml.Connections) - see morphology_helper.py
cell_types = dNumCells.keys()
dMorphs = {}
for cell in cell_types:
dMorphs[cell] = helper_morphology(
"../cells/%s.cell.nml" % cell
) # will be a dictionary of dictionaries d[cell][segGroupID] = [[segIDs], [lSegs]]
##### add projections and connections to nml file #####
for projID, connection_list in dProjections.iteritems():
presynaptic = projID.split('_')[1][:-3]
postsynaptic = projID.split('_')[-1][:-3]
if presynaptic != "ngf": # ngf cells are useing the boundled GABA_A, GABA_B syapse (ExpGABAab.mod)...
proj = neuroml.Projection(
id=projID,
presynaptic_population="pop_%s" % presynaptic,
postsynaptic_population="pop_%s" % postsynaptic,
synapse="syn_%s_to_%s" % (presynaptic, postsynaptic))
for i, sublist in enumerate(connection_list):
preCellID = sublist[0]
postCellID = sublist[1]
postSegmentGroupID = sublist[2]
if presynaptic not in ["ca3", "ec"]:
presynapticComp = "%scell" % presynaptic
preSegID, preFracAlong = calc_seg_fracalong(
dMorphs[presynaptic], "soma_0",
0.5) # see morphology_helper.
else:
presynapticComp = "spikeGenPoisson" # TODO: implement other stimulations ...
preSegID = 0
preFracAlong = 0.5
postSegID, postFracAlong = calc_seg_fracalong(
dMorphs[postsynaptic], postSegmentGroupID,
0.5) # see morphology_helper.py
conn = neuroml.ConnectionWD(
id=i,
pre_cell_id="../pop_%s/%g/%s" %
(presynaptic, preCellID, presynapticComp),
pre_segment_id=preSegID,
pre_fraction_along=preFracAlong,
post_cell_id="../pop_%s/%g/%scell" %
(postsynaptic, postCellID, postsynaptic),
post_segment_id=postSegID,
post_fraction_along=postFracAlong,
weight=
1, # synaptic weights are specified at the synapse component level and are not scaled in the network
delay="3ms")
proj.connection_wds.append(conn)
net.projections.append(proj)
else: # TODO: check if only ngf is using ExpGABAab (with other ConnDat, SynData spec.)
for sType in ['A', 'B']:
proj = neuroml.Projection(
id="%s_%s" % (projID, sType),
presynaptic_population="pop_%s" % presynaptic,
postsynaptic_population="pop_%s" % postsynaptic,
synapse="syn_%s_to_%s_%s" %
(presynaptic, postsynaptic, sType))
for i, sublist in enumerate(connection_list):
preCellID = sublist[0]
postCellID = sublist[1]
postSegmentGroupID = sublist[2]
presynapticComp = "ngfcell"
preSegID, preFracAlong = calc_seg_fracalong(
dMorphs["ngf"], "soma_0",
0.5) # see morphology_helper.
postSegID, postFracAlong = calc_seg_fracalong(
dMorphs[postsynaptic], postSegmentGroupID,
0.5) # see morphology_helper.py
conn = neuroml.ConnectionWD(
id=i,
pre_cell_id="../pop_ngf/%g/%s" %
(preCellID, presynapticComp),
pre_segment_id=preSegID,
pre_fraction_along=preFracAlong,
post_cell_id="../pop_%s/%g/%scell" %
(postsynaptic, postCellID, postsynaptic),
post_segment_id=postSegID,
post_fraction_along=postFracAlong,
weight=
1, # synaptic weights are specified at the synapse component level and are not scaled in the network
delay="3ms")
proj.connection_wds.append(conn)
net.projections.append(proj)
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)