def create_n_connection_synapse(prototype_syn, n, nml_doc, existing_synapses):
new_id = "%s_%sconns" % (prototype_syn.id, str(n).replace('.', '_'))
if not existing_synapses.has_key(new_id):
if isinstance(prototype_syn, ExpTwoSynapse):
magnitude, unit = bioparameters.split_neuroml_quantity(
prototype_syn.gbase)
new_syn = ExpTwoSynapse(id=new_id,
gbase="%s%s" % (magnitude * n, unit),
erev=prototype_syn.erev,
tau_decay=prototype_syn.tau_decay,
tau_rise=prototype_syn.tau_rise)
existing_synapses[new_id] = new_syn
nml_doc.exp_two_synapses.append(new_syn)
elif isinstance(prototype_syn, GapJunction):
magnitude, unit = bioparameters.split_neuroml_quantity(
prototype_syn.conductance)
new_syn = GapJunction(id=new_id,
conductance="%s%s" % (magnitude * n, unit))
existing_synapses[new_id] = new_syn
nml_doc.gap_junctions.append(new_syn)
else:
new_syn = existing_synapses[new_id]
return new_syn
def create_n_connection_synapse(prototype_syn, n, nml_doc, existing_synapses):
new_id = "%s_%sconns"%(prototype_syn.id, str(n).replace('.', '_'))
if not existing_synapses.has_key(new_id):
if isinstance(prototype_syn, ExpTwoSynapse):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.gbase)
new_syn = ExpTwoSynapse(id=new_id,
gbase = "%s%s"%(magnitude*n, unit),
erev = prototype_syn.erev,
tau_decay = prototype_syn.tau_decay,
tau_rise = prototype_syn.tau_rise)
existing_synapses[new_id] = new_syn
nml_doc.exp_two_synapses.append(new_syn)
elif isinstance(prototype_syn, GapJunction):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.conductance)
new_syn = GapJunction(id=new_id,
conductance = "%s%s"%(magnitude*n, unit))
existing_synapses[new_id] = new_syn
nml_doc.gap_junctions.append(new_syn)
else:
new_syn = existing_synapses[new_id]
return new_syn
def create_n_connection_synapse(prototype_syn, n, nml_doc, existing_synapses):
new_id = "%s_%sconns"%(prototype_syn.id, str(n).replace('.', '_'))
if type(n) is float:
new_id = "%s_%sconns" % (prototype_syn.id, get_str_from_expnotation(n).replace('.', '_'))
if isinstance(prototype_syn, ExpTwoSynapse):
new_id = "%s"%(prototype_syn.id)
if not existing_synapses.has_key(new_id):
if isinstance(prototype_syn, ExpTwoSynapse):
new_syn = ExpTwoSynapse(id=new_id,
gbase = prototype_syn.gbase,
erev = prototype_syn.erev,
tau_decay = prototype_syn.tau_decay,
tau_rise = prototype_syn.tau_rise)
existing_synapses[new_id] = new_syn
nml_doc.exp_two_synapses.append(new_syn)
elif isinstance(prototype_syn, GapJunction):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.conductance)
cond = "%s%s" % (magnitude * n, unit)
if type(n) is float:
cond = "%s%s" % (get_str_from_expnotation(magnitude * n), unit)
new_syn = GapJunction(id=new_id,
conductance = cond)
existing_synapses[new_id] = new_syn
nml_doc.gap_junctions.append(new_syn)
elif isinstance(prototype_syn, GradedSynapse):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.conductance)
cond = "%s%s" % (magnitude * n, unit)
if type(n) is float:
cond = "%s%s" % (get_str_from_expnotation(magnitude * n), unit)
new_syn = GradedSynapse(id=new_id,
conductance = cond,
delta = prototype_syn.delta,
Vth = prototype_syn.Vth,
erev = prototype_syn.erev,
k = prototype_syn.k)
existing_synapses[new_id] = new_syn
nml_doc.graded_synapses.append(new_syn)
else:
new_syn = existing_synapses[new_id]
return new_syn
def generate(net_id,
params,
cells = None,
cells_to_plot = None,
cells_to_stimulate = None,
include_muscles=False,
conn_number_override = None,
conn_number_scaling = None,
duration = 500,
dt = 0.01,
vmin = None,
vmax = None,
seed = 1234,
validate=True,
test=False,
verbose=True,
target_directory='./'):
root_dir = os.path.dirname(os.path.abspath(__file__))
params.create_models()
if vmin==None:
if params.level == 'A':
vmin=-72
elif params.level == 'B':
vmin=-52
elif params.level == 'C':
vmin=-60
else:
vmin=-52
if vmax==None:
if params.level == 'A':
vmax=-48
elif params.level == 'B':
vmax=-28
elif params.level == 'C':
vmax=25
else:
vmax=-28
random.seed(seed)
info = "\n\nParameters and setting used to generate this network:\n\n"+\
" Cells: %s\n" % (cells if cells is not None else "All cells")+\
" Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\
" Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
" Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\
" Include muscles: %s\n" % include_muscles
print_(info)
info += "\n%s\n"%(params.bioparameter_info(" "))
nml_doc = NeuroMLDocument(id=net_id, notes=info)
if params.level == "A" or params.level == "B" or params.level == "BC1":
nml_doc.iaf_cells.append(params.generic_cell)
elif params.level == "C":
nml_doc.cells.append(params.generic_cell)
net = Network(id=net_id)
nml_doc.networks.append(net)
nml_doc.pulse_generators.append(params.offset_current)
if params.level == "C" or params.level == "C1":
nml_doc.fixed_factor_concentration_models.append(params.concentration_model)
cell_names, conns = get_cell_names_and_connection()
# To hold all Cell NeuroML objects vs. names
all_cells = {}
# lems_file = ""
lems_info = {"comment": info,
"reference": net_id,
"duration": duration,
"dt": dt,
"vmin": vmin,
"vmax": vmax,
"cell_component": params.generic_cell.id}
lems_info["plots"] = []
lems_info["activity_plots"] = []
lems_info["muscle_plots"] = []
lems_info["muscle_activity_plots"] = []
lems_info["to_save"] = []
lems_info["activity_to_save"] = []
lems_info["muscles_to_save"] = []
lems_info["muscles_activity_to_save"] = []
lems_info["cells"] = []
lems_info["muscles"] = []
lems_info["includes"] = []
if params.custom_component_types_definitions:
lems_info["includes"].append(params.custom_component_types_definitions)
if target_directory != './':
def_file = "%s/%s"%(os.path.dirname(os.path.abspath(__file__)), params.custom_component_types_definitions)
shutil.copy(def_file, target_directory)
nml_doc.includes.append(IncludeType(href=params.custom_component_types_definitions))
backers_dir = root_dir+"/../../../../OpenWormBackers/" if test else root_dir+"/../../../OpenWormBackers/"
sys.path.append(backers_dir)
import backers
cells_vs_name = backers.get_adopted_cell_names(backers_dir)
populations_without_location = False # isinstance(params.elec_syn, GapJunction)
count = 0
for cell in cell_names:
if cells is None or cell in cells:
inst = Instance(id="0")
if not populations_without_location:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_cell.id,
type="populationList")
pop0.instances.append(inst)
else:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_cell.id,
size="1")
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(cell):
p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell])
pop0.properties.append(p)
# also use the cell name to grab the morphology file, as a NeuroML data structure
# into the 'all_cells' dict
cell_file_path = root_dir+"/../../../" if test else root_dir+"/../../" #if running test
cell_file = cell_file_path+'generatedNeuroML2/%s.cell.nml'%cell
doc = loaders.NeuroMLLoader.load(cell_file)
all_cells[cell] = doc.cells[0]
location = doc.cells[0].morphology.segments[0].proximal
if verbose:
print_("Loaded morphology: %s; id: %s; location: (%s, %s, %s)"%(os.path.realpath(cell_file), all_cells[cell].id, location.x, location.y, location.z))
inst.location = Location(float(location.x), float(location.y), float(location.z))
target = "../%s/0/%s"%(pop0.id, params.generic_cell.id)
if populations_without_location:
target = "../%s[0]" % (cell)
if cells_to_stimulate is None or cell in cells_to_stimulate:
input_list = InputList(id="Input_%s_%s"%(cell,params.offset_current.id),
component=params.offset_current.id,
populations='%s'%cell)
input_list.input.append(Input(id=0,
target=target,
destination="synapses"))
net.input_lists.append(input_list)
if cells_to_plot is None or cell in cells_to_plot:
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/v" % (cell)
lems_info["plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (cell, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/activity" % (cell)
lems_info["activity_plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'Cell':
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (cell, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/caConc" % (cell)
lems_info["activity_plots"].append(plot)
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/v" % (cell)
lems_info["to_save"].append(save)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/activity" % (cell, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/activity" % (cell)
lems_info["activity_to_save"].append(save)
if params.generic_cell.__class__.__name__ == 'Cell':
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/caConc" % (cell, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/caConc" % (cell)
lems_info["activity_to_save"].append(save)
lems_info["cells"].append(cell)
count+=1
if verbose:
print_("Finished loading %i cells"%count)
mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection()
muscles = get_muscle_names()
if include_muscles:
muscle_count = 0
for muscle in muscles:
inst = Instance(id="0")
if not populations_without_location:
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_cell.id,
type="populationList")
pop0.instances.append(inst)
else:
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_cell.id,
size="1")
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(muscle):
# No muscles adopted yet, but just in case they are in future...
p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle])
pop0.properties.append(p)
x = 80 * (-1 if muscle[1] == 'V' else 1)
z = 80 * (-1 if muscle[2] == 'L' else 1)
y = -300 + 30 * int(muscle[3:5])
print_('Positioning muscle: %s at (%s,%s,%s)'%(muscle,x,y,z))
inst.location = Location(x,y,z)
target = "%s/0/%s"%(pop0.id, params.generic_cell.id)
if populations_without_location:
target = "%s[0]" % (muscle)
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/v" % (muscle)
lems_info["muscle_plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/activity" % (muscle)
lems_info["muscle_activity_plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'Cell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/caConc" % (muscle)
lems_info["muscle_activity_plots"].append(plot)
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/v" % (muscle)
lems_info["muscles_to_save"].append(save)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/activity" % (muscle)
lems_info["muscles_activity_to_save"].append(save)
if params.generic_cell.__class__.__name__ == 'Cell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/caConc" % (muscle)
lems_info["muscles_activity_to_save"].append(save)
lems_info["muscles"].append(muscle)
muscle_count+=1
if verbose:
print_("Finished creating %i muscles"%muscle_count)
existing_synapses = {}
for conn in conns:
if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)
elect_conn = False
analog_conn = False
syn0 = params.exc_syn
if 'GABA' in conn.synclass:
syn0 = params.inh_syn
if '_GJ' in conn.synclass:
syn0 = params.elec_syn
elect_conn = isinstance(params.elec_syn, GapJunction)
if isinstance(syn0, GradedSynapse):
analog_conn = True
if len(nml_doc.silent_synapses)==0:
silent = SilentSynapse(id="silent")
nml_doc.silent_synapses.append(silent)
number_syns = conn.number
conn_shorthand = "%s-%s"%(conn.pre_cell, conn.post_cell)
if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number*conn_number_scaling[conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
if number_syns != conn.number:
magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase)
cond0 = "%s%s"%(magnitude*conn.number, unit)
cond1 = "%s%s"%(magnitude*number_syns, unit)
if verbose:
print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses)
if elect_conn:
if populations_without_location:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
# Add a Connection with the closest locations
conn0 = ElectricalConnection(id="0", \
pre_cell="0",
post_cell="0",
synapse=syn_new.id)
proj0.electrical_connections.append(conn0)
else:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)
#print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))
# Add a Connection with the closest locations
conn0 = ElectricalConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
synapse=syn_new.id)
proj0.electrical_connection_instances.append(conn0)
elif analog_conn:
proj0 = ContinuousProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.continuous_projections.append(proj0)
pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)
conn0 = ContinuousConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
pre_component="silent",
post_component=syn_new.id)
proj0.continuous_connection_instances.append(conn0)
else:
if not populations_without_location:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)
conn0 = ConnectionWD(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id,
weight = number_syns,
delay = '0ms')
proj0.connection_wds.append(conn0)
if populations_without_location:
raise NotImplementedError
'''
# <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
pre_cell_id="%s[0]"%(conn.pre_cell)
post_cell_id="%s[0]"%(conn.post_cell)
conn0 = SynapticConnection(from_=pre_cell_id,
to=post_cell_id,
synapse=syn_new.id,
destination="synapses")
net.synaptic_connections.append(conn0)'''
if include_muscles:
for conn in muscle_conns:
if conn.pre_cell in lems_info["cells"] and conn.post_cell in muscles:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)
elect_conn = False
analog_conn = False
syn0 = params.exc_syn
if 'GABA' in conn.synclass:
syn0 = params.inh_syn
if '_GJ' in conn.synclass:
syn0 = params.elec_syn
elect_conn = isinstance(params.elec_syn, GapJunction)
if isinstance(syn0, GradedSynapse):
analog_conn = True
if len(nml_doc.silent_synapses)==0:
silent = SilentSynapse(id="silent")
nml_doc.silent_synapses.append(silent)
number_syns = conn.number
conn_shorthand = "%s-%s"%(conn.pre_cell, conn.post_cell)
if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number*conn_number_scaling[conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
if number_syns != conn.number:
magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase)
cond0 = "%s%s"%(magnitude*conn.number, unit)
cond1 = "%s%s"%(magnitude*number_syns, unit)
if verbose:
print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses)
if elect_conn:
if populations_without_location:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
# Add a Connection with the closest locations
conn0 = ElectricalConnection(id="0", \
pre_cell="0",
post_cell="0",
synapse=syn_new.id)
proj0.electrical_connections.append(conn0)
else:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)
#print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))
# Add a Connection with the closest locations
conn0 = ElectricalConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
synapse=syn_new.id)
proj0.electrical_connection_instances.append(conn0)
elif analog_conn:
proj0 = ContinuousProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.continuous_projections.append(proj0)
pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)
conn0 = ContinuousConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
pre_component="silent",
post_component=syn_new.id)
proj0.continuous_connection_instances.append(conn0)
else:
if not populations_without_location:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
# Add a Connection with the closest locations
pre_cell_id="../%s/0/%s"%(conn.pre_cell, params.generic_cell.id)
post_cell_id="../%s/0/%s"%(conn.post_cell, params.generic_cell.id)
conn0 = Connection(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id)
proj0.connections.append(conn0)
if populations_without_location:
# <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
pre_cell_id="%s[0]"%(conn.pre_cell)
post_cell_id="%s[0]"%(conn.post_cell)
conn0 = SynapticConnection(from_=pre_cell_id,
to=post_cell_id,
synapse=syn_new.id,
destination="synapses")
net.synaptic_connections.append(conn0)
# import pprint
# pprint.pprint(lems_info)
template_path = root_dir+'/../' if test else root_dir+'/' # if running test
write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate, verbose=verbose, target_directory=target_directory)
return nml_doc
def generate(net_id,
params,
cells=None,
cells_to_plot=None,
cells_to_stimulate=None,
include_muscles=False,
conn_number_override=None,
conn_number_scaling=None,
duration=500,
dt=0.01,
vmin=None,
vmax=None,
seed=1234,
validate=True,
test=False,
verbose=True,
target_directory='./'):
root_dir = os.path.dirname(os.path.abspath(__file__))
params.create_models()
if vmin == None:
if params.level == 'A':
vmin = -72
elif params.level == 'B':
vmin = -52
elif params.level == 'C':
vmin = -60
else:
vmin = -52
if vmax == None:
if params.level == 'A':
vmax = -48
elif params.level == 'B':
vmax = -28
elif params.level == 'C':
vmax = 25
else:
vmax = -28
random.seed(seed)
info = "\n\nParameters and setting used to generate this network:\n\n"+\
" Cells: %s\n" % (cells if cells is not None else "All cells")+\
" Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\
" Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
" Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\
" Include muscles: %s\n" % include_muscles
print_(info)
info += "\n%s\n" % (params.bioparameter_info(" "))
nml_doc = NeuroMLDocument(id=net_id, notes=info)
if params.level == "A" or params.level == "B" or params.level == "BC1":
nml_doc.iaf_cells.append(params.generic_muscle_cell)
nml_doc.iaf_cells.append(params.generic_neuron_cell)
elif params.level == "C":
nml_doc.cells.append(params.generic_muscle_cell)
nml_doc.cells.append(params.generic_neuron_cell)
net = Network(id=net_id)
nml_doc.networks.append(net)
nml_doc.pulse_generators.append(params.offset_current)
if params.level == "C" or params.level == "C1":
nml_doc.fixed_factor_concentration_models.append(
params.concentration_model)
cell_names, conns = get_cell_names_and_connection()
# To hold all Cell NeuroML objects vs. names
all_cells = {}
# lems_file = ""
lems_info = {
"comment": info,
"reference": net_id,
"duration": duration,
"dt": dt,
"vmin": vmin,
"vmax": vmax,
"cell_component": params.generic_neuron_cell.id
}
lems_info["plots"] = []
lems_info["activity_plots"] = []
lems_info["muscle_plots"] = []
lems_info["muscle_activity_plots"] = []
lems_info["to_save"] = []
lems_info["activity_to_save"] = []
lems_info["muscles_to_save"] = []
lems_info["muscles_activity_to_save"] = []
lems_info["cells"] = []
lems_info["muscles"] = []
lems_info["includes"] = []
if params.custom_component_types_definitions:
lems_info["includes"].append(params.custom_component_types_definitions)
if target_directory != './':
def_file = "%s/%s" % (os.path.dirname(os.path.abspath(__file__)),
params.custom_component_types_definitions)
shutil.copy(def_file, target_directory)
nml_doc.includes.append(
IncludeType(href=params.custom_component_types_definitions))
backers_dir = root_dir + "/../../../../OpenWormBackers/" if test else root_dir + "/../../../OpenWormBackers/"
sys.path.append(backers_dir)
import backers
cells_vs_name = backers.get_adopted_cell_names(backers_dir)
populations_without_location = False # isinstance(params.elec_syn, GapJunction)
count = 0
for cell in cell_names:
if cells is None or cell in cells:
inst = Instance(id="0")
if not populations_without_location:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_neuron_cell.id,
type="populationList")
pop0.instances.append(inst)
else:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_neuron_cell.id,
size="1")
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(cell):
p = Property(tag="OpenWormBackerAssignedName",
value=cells_vs_name[cell])
pop0.properties.append(p)
# also use the cell name to grab the morphology file, as a NeuroML data structure
# into the 'all_cells' dict
cell_file_path = root_dir + "/../../../" if test else root_dir + "/../../" #if running test
cell_file = cell_file_path + 'generatedNeuroML2/%s.cell.nml' % cell
doc = loaders.NeuroMLLoader.load(cell_file)
all_cells[cell] = doc.cells[0]
location = doc.cells[0].morphology.segments[0].proximal
if verbose:
print_(
"Loaded morphology: %s; id: %s; location: (%s, %s, %s)" %
(os.path.realpath(cell_file), all_cells[cell].id,
location.x, location.y, location.z))
inst.location = Location(float(location.x), float(location.y),
float(location.z))
target = "../%s/0/%s" % (pop0.id, params.generic_neuron_cell.id)
if populations_without_location:
target = "../%s[0]" % (cell)
if cells_to_stimulate is None or cell in cells_to_stimulate:
input_list = InputList(id="Input_%s_%s" %
(cell, params.offset_current.id),
component=params.offset_current.id,
populations='%s' % cell)
input_list.input.append(
Input(id=0, target=target, destination="synapses"))
net.input_lists.append(input_list)
if cells_to_plot is None or cell in cells_to_plot:
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (
cell, params.generic_neuron_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/v" % (cell)
lems_info["plots"].append(plot)
if params.generic_neuron_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (
cell, params.generic_neuron_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/activity" % (cell)
lems_info["activity_plots"].append(plot)
if params.generic_neuron_cell.__class__.__name__ == 'Cell':
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (
cell, params.generic_neuron_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/caConc" % (cell)
lems_info["activity_plots"].append(plot)
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/v" % (cell,
params.generic_neuron_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/v" % (cell)
lems_info["to_save"].append(save)
if params.generic_neuron_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/activity" % (
cell, params.generic_neuron_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/activity" % (cell)
lems_info["activity_to_save"].append(save)
if params.generic_neuron_cell.__class__.__name__ == 'Cell':
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/caConc" % (
cell, params.generic_neuron_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/caConc" % (cell)
lems_info["activity_to_save"].append(save)
lems_info["cells"].append(cell)
count += 1
if verbose:
print_("Finished loading %i cells" % count)
mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection(
)
muscles = get_muscle_names()
if include_muscles:
muscle_count = 0
for muscle in muscles:
inst = Instance(id="0")
if not populations_without_location:
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_muscle_cell.id,
type="populationList")
pop0.instances.append(inst)
else:
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_muscle_cell.id,
size="1")
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(muscle):
# No muscles adopted yet, but just in case they are in future...
p = Property(tag="OpenWormBackerAssignedName",
value=cells_vs_name[muscle])
pop0.properties.append(p)
x = 80 * (-1 if muscle[1] == 'V' else 1)
z = 80 * (-1 if muscle[2] == 'L' else 1)
y = -300 + 30 * int(muscle[3:5])
print_('Positioning muscle: %s at (%s,%s,%s)' % (muscle, x, y, z))
inst.location = Location(x, y, z)
target = "%s/0/%s" % (pop0.id, params.generic_muscle_cell.id)
if populations_without_location:
target = "%s[0]" % (muscle)
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (muscle,
params.generic_muscle_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/v" % (muscle)
lems_info["muscle_plots"].append(plot)
if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (
muscle, params.generic_muscle_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/activity" % (muscle)
lems_info["muscle_activity_plots"].append(plot)
if params.generic_muscle_cell.__class__.__name__ == 'Cell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (
muscle, params.generic_muscle_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/caConc" % (muscle)
lems_info["muscle_activity_plots"].append(plot)
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/v" % (muscle,
params.generic_muscle_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/v" % (muscle)
lems_info["muscles_to_save"].append(save)
if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/activity" % (
muscle, params.generic_muscle_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/activity" % (muscle)
lems_info["muscles_activity_to_save"].append(save)
if params.generic_muscle_cell.__class__.__name__ == 'Cell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/caConc" % (
muscle, params.generic_muscle_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/caConc" % (muscle)
lems_info["muscles_activity_to_save"].append(save)
lems_info["muscles"].append(muscle)
muscle_count += 1
if verbose:
print_("Finished creating %i muscles" % muscle_count)
existing_synapses = {}
for conn in conns:
if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info[
"cells"]:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell,
conn.synclass, conn.syntype)
elect_conn = False
analog_conn = False
syn0 = params.neuron_to_neuron_exc_syn
if 'GABA' in conn.synclass:
syn0 = params.neuron_to_neuron_inh_syn
if '_GJ' in conn.synclass:
syn0 = params.neuron_to_neuron_elec_syn
elect_conn = isinstance(params.neuron_to_neuron_elec_syn,
GapJunction)
if isinstance(syn0, GradedSynapse):
analog_conn = True
if len(nml_doc.silent_synapses) == 0:
silent = SilentSynapse(id="silent")
nml_doc.silent_synapses.append(silent)
number_syns = conn.number
conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)
if conn_number_override is not None and (
conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (
conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number * conn_number_scaling[conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
if number_syns != conn.number:
magnitude, unit = bioparameters.split_neuroml_quantity(
syn0.gbase)
cond0 = "%s%s" % (magnitude * conn.number, unit)
cond1 = "%s%s" % (magnitude * number_syns, unit)
if verbose:
print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc,
existing_synapses)
if elect_conn:
if populations_without_location:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
# Add a Connection with the closest locations
conn0 = ElectricalConnection(id="0", \
pre_cell="0",
post_cell="0",
synapse=syn_new.id)
proj0.electrical_connections.append(conn0)
else:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
pre_cell_id = "../%s/0/%s" % (
conn.pre_cell, params.generic_neuron_cell.id)
post_cell_id = "../%s/0/%s" % (
conn.post_cell, params.generic_neuron_cell.id)
#print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))
# Add a Connection with the closest locations
conn0 = ElectricalConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
synapse=syn_new.id)
proj0.electrical_connection_instances.append(conn0)
elif analog_conn:
proj0 = ContinuousProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.continuous_projections.append(proj0)
pre_cell_id = "../%s/0/%s" % (conn.pre_cell,
params.generic_neuron_cell.id)
post_cell_id = "../%s/0/%s" % (conn.post_cell,
params.generic_neuron_cell.id)
conn0 = ContinuousConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
pre_component="silent",
post_component=syn_new.id)
proj0.continuous_connection_instances.append(conn0)
else:
if not populations_without_location:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
pre_cell_id = "../%s/0/%s" % (
conn.pre_cell, params.generic_neuron_cell.id)
post_cell_id = "../%s/0/%s" % (
conn.post_cell, params.generic_neuron_cell.id)
conn0 = ConnectionWD(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id,
weight = number_syns,
delay = '0ms')
proj0.connection_wds.append(conn0)
if populations_without_location:
raise NotImplementedError
'''
# <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
pre_cell_id="%s[0]"%(conn.pre_cell)
post_cell_id="%s[0]"%(conn.post_cell)
conn0 = SynapticConnection(from_=pre_cell_id,
to=post_cell_id,
synapse=syn_new.id,
destination="synapses")
net.synaptic_connections.append(conn0)'''
if include_muscles:
for conn in muscle_conns:
if conn.pre_cell in lems_info[
"cells"] and conn.post_cell in muscles:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell,
conn.synclass, conn.syntype)
elect_conn = False
analog_conn = False
syn0 = params.neuron_to_muscle_exc_syn
if 'GABA' in conn.synclass:
syn0 = params.neuron_to_muscle_inh_syn
if '_GJ' in conn.synclass:
syn0 = params.neuron_to_muscle_elec_syn
elect_conn = isinstance(params.neuron_to_muscle_elec_syn,
GapJunction)
if isinstance(syn0, GradedSynapse):
analog_conn = True
if len(nml_doc.silent_synapses) == 0:
silent = SilentSynapse(id="silent")
nml_doc.silent_synapses.append(silent)
number_syns = conn.number
conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)
if conn_number_override is not None and (
conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (
conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number * conn_number_scaling[
conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
if number_syns != conn.number:
magnitude, unit = bioparameters.split_neuroml_quantity(
syn0.gbase)
cond0 = "%s%s" % (magnitude * conn.number, unit)
cond1 = "%s%s" % (magnitude * number_syns, unit)
if verbose:
print_(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns,
nml_doc,
existing_synapses)
if elect_conn:
if populations_without_location:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
# Add a Connection with the closest locations
conn0 = ElectricalConnection(id="0", \
pre_cell="0",
post_cell="0",
synapse=syn_new.id)
proj0.electrical_connections.append(conn0)
else:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
pre_cell_id = "../%s/0/%s" % (
conn.pre_cell, params.generic_neuron_cell.id)
post_cell_id = "../%s/0/%s" % (
conn.post_cell, params.generic_muscle_cell.id)
#print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))
# Add a Connection with the closest locations
conn0 = ElectricalConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
synapse=syn_new.id)
proj0.electrical_connection_instances.append(conn0)
elif analog_conn:
proj0 = ContinuousProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.continuous_projections.append(proj0)
pre_cell_id = "../%s/0/%s" % (
conn.pre_cell, params.generic_neuron_cell.id)
post_cell_id = "../%s/0/%s" % (
conn.post_cell, params.generic_muscle_cell.id)
conn0 = ContinuousConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
pre_component="silent",
post_component=syn_new.id)
proj0.continuous_connection_instances.append(conn0)
else:
if not populations_without_location:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
# Add a Connection with the closest locations
pre_cell_id = "../%s/0/%s" % (
conn.pre_cell, params.generic_neuron_cell.id)
post_cell_id = "../%s/0/%s" % (
conn.post_cell, params.generic_muscle_cell.id)
conn0 = Connection(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id)
proj0.connections.append(conn0)
if populations_without_location:
# <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
pre_cell_id = "%s[0]" % (conn.pre_cell)
post_cell_id = "%s[0]" % (conn.post_cell)
conn0 = SynapticConnection(from_=pre_cell_id,
to=post_cell_id,
synapse=syn_new.id,
destination="synapses")
net.synaptic_connections.append(conn0)
# import pprint
# pprint.pprint(lems_info)
template_path = root_dir + '/../' if test else root_dir + '/' # if running test
write_to_file(nml_doc,
lems_info,
net_id,
template_path,
validate=validate,
verbose=verbose,
target_directory=target_directory)
return nml_doc
def generate(net_id,
params,
cells=None,
cells_to_plot=None,
cells_to_stimulate=None,
include_muscles=False,
conn_number_override=None,
conn_number_scaling=None,
duration=500,
dt=0.01,
vmin=None,
vmax=None,
seed=1234,
validate=True,
test=False,
verbose=True,
target_directory='./'):
params.create_models()
if vmin == None:
if params.level == 'A':
vmin = -72
elif params.level == 'B':
vmin = -52
elif params.level == 'C':
vmin = -60
if vmax == None:
if params.level == 'A':
vmax = -48
elif params.level == 'B':
vmax = -28
elif params.level == 'C':
vmax = 25
random.seed(seed)
info = "\n\nParameters and setting used to generate this network:\n\n"+\
" Cells: %s\n" % (cells if cells is not None else "All cells")+\
" Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All cells")+\
" Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
" Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+\
" Include muscles: %s\n" % include_muscles
info += "\n%s\n" % (params.bioparameter_info(" "))
nml_doc = NeuroMLDocument(id=net_id, notes=info)
if params.level == "A" or params.level == "B":
nml_doc.iaf_cells.append(params.generic_cell)
elif params.level == "C":
nml_doc.cells.append(params.generic_cell)
net = Network(id=net_id)
nml_doc.networks.append(net)
nml_doc.pulse_generators.append(params.offset_current)
# Use the spreadsheet reader to give a list of all cells and a list of all connections
# This could be replaced with a call to "DatabaseReader" or "OpenWormNeuroLexReader" in future...
# If called from unittest folder ammend path to "../../../../"
spreadsheet_location = "../../../../" if test else "../../../"
cell_names, conns = SpreadsheetDataReader.readDataFromSpreadsheet(
spreadsheet_location, include_nonconnected_cells=True)
cell_names.sort()
# To hold all Cell NeuroML objects vs. names
all_cells = {}
# lems_file = ""
lems_info = {
"comment": info,
"reference": net_id,
"duration": duration,
"dt": dt,
"vmin": vmin,
"vmax": vmax,
"cell_component": params.generic_cell.id
}
lems_info["plots"] = []
lems_info["activity_plots"] = []
lems_info["muscle_plots"] = []
lems_info["muscle_activity_plots"] = []
lems_info["to_save"] = []
lems_info["activity_to_save"] = []
lems_info["muscles_to_save"] = []
lems_info["muscles_activity_to_save"] = []
lems_info["cells"] = []
lems_info["muscles"] = []
lems_info["includes"] = []
if params.custom_component_types_definitions:
lems_info["includes"].append(params.custom_component_types_definitions)
if target_directory != './':
def_file = "%s/%s" % (os.path.dirname(__file__),
params.custom_component_types_definitions)
shutil.copy(def_file, target_directory)
backers_dir = "../../../../OpenWormBackers/" if test else "../../../OpenWormBackers/"
sys.path.append(backers_dir)
import backers
cells_vs_name = backers.get_adopted_cell_names(backers_dir)
populations_without_location = isinstance(params.elec_syn, GapJunction)
count = 0
for cell in cell_names:
if cells is None or cell in cells:
inst = Instance(id="0")
if not populations_without_location:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_cell.id,
type="populationList")
pop0.instances.append(inst)
else:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_cell.id,
size="1")
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(cell):
p = Property(tag="OpenWormBackerAssignedName",
value=cells_vs_name[cell])
pop0.properties.append(p)
# also use the cell name to grab the morphology file, as a NeuroML data structure
# into the 'all_cells' dict
cell_file_path = "../../../" if test else "../../" #if running test
cell_file = cell_file_path + 'generatedNeuroML2/%s.cell.nml' % cell
doc = loaders.NeuroMLLoader.load(cell_file)
all_cells[cell] = doc.cells[0]
location = doc.cells[0].morphology.segments[0].proximal
if verbose:
print(
"Loaded morphology file from: %s, with id: %s, location: (%s, %s, %s)"
% (cell_file, all_cells[cell].id, location.x, location.y,
location.z))
inst.location = Location(float(location.x), float(location.y),
float(location.z))
target = "%s/0/%s" % (pop0.id, params.generic_cell.id)
if populations_without_location:
target = "%s[0]" % (cell)
exp_input = ExplicitInput(target=target,
input=params.offset_current.id)
if cells_to_stimulate is None or cell in cells_to_stimulate:
net.explicit_inputs.append(exp_input)
if cells_to_plot is None or cell in cells_to_plot:
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/v" % (cell)
lems_info["plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (
cell, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/activity" % (cell)
lems_info["activity_plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'Cell':
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (
cell, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/caConc" % (cell)
lems_info["activity_plots"].append(plot)
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/v" % (cell, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/v" % (cell)
lems_info["to_save"].append(save)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/activity" % (
cell, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/activity" % (cell)
lems_info["activity_to_save"].append(save)
lems_info["cells"].append(cell)
count += 1
if verbose:
print("Finished loading %i cells" % count)
mneurons, all_muscles, muscle_conns = SpreadsheetDataReader.readMuscleDataFromSpreadsheet(
spreadsheet_location)
muscles = get_muscle_names()
if include_muscles:
muscle_count = 0
for muscle in muscles:
inst = Instance(id="0")
if not populations_without_location:
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_cell.id,
type="populationList")
pop0.instances.append(inst)
else:
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_cell.id,
size="1")
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(muscle):
# No muscles adopted yet, but just in case they are in future...
p = Property(tag="OpenWormBackerAssignedName",
value=cells_vs_name[muscle])
pop0.properties.append(p)
inst.location = Location(100, 10 * muscle_count, 100)
target = "%s/0/%s" % (pop0.id, params.generic_cell.id)
if populations_without_location:
target = "%s[0]" % (muscle)
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/v" % (muscle)
lems_info["muscle_plots"].append(plot)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (
muscle, params.generic_cell.id)
if populations_without_location:
plot["quantity"] = "%s[0]/activity" % (muscle)
lems_info["muscle_activity_plots"].append(plot)
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/v" % (muscle)
lems_info["muscles_to_save"].append(save)
if params.generic_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/activity" % (
muscle, params.generic_cell.id)
if populations_without_location:
save["quantity"] = "%s[0]/activity" % (muscle)
lems_info["muscles_activity_to_save"].append(save)
lems_info["muscles"].append(muscle)
muscle_count += 1
if verbose:
print("Finished creating %i muscles" % muscle_count)
existing_synapses = {}
for conn in conns:
if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info[
"cells"]:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell,
conn.synclass, conn.syntype)
elect_conn = False
syn0 = params.exc_syn
if 'GABA' in conn.synclass:
syn0 = params.inh_syn
if '_GJ' in conn.synclass:
syn0 = params.elec_syn
elect_conn = isinstance(params.elec_syn, GapJunction)
number_syns = conn.number
conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)
if conn_number_override is not None and (
conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (
conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number * conn_number_scaling[conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
if number_syns != conn.number:
magnitude, unit = bioparameters.split_neuroml_quantity(
syn0.gbase)
cond0 = "%s%s" % (magnitude * conn.number, unit)
cond1 = "%s%s" % (magnitude * number_syns, unit)
if verbose:
print(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc,
existing_synapses)
if not elect_conn:
if not populations_without_location:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
# Add a Connection with the closest locations
pre_cell_id = "../%s/0/%s" % (conn.pre_cell,
params.generic_cell.id)
post_cell_id = "../%s/0/%s" % (conn.post_cell,
params.generic_cell.id)
conn0 = Connection(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id)
proj0.connections.append(conn0)
if populations_without_location:
# <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
pre_cell_id = "%s[0]" % (conn.pre_cell)
post_cell_id = "%s[0]" % (conn.post_cell)
conn0 = SynapticConnection(from_=pre_cell_id,
to=post_cell_id,
synapse=syn_new.id,
destination="synapses")
net.synaptic_connections.append(conn0)
else:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
# Add a Connection with the closest locations
conn0 = ElectricalConnection(id="0", \
pre_cell="0",
post_cell="0",
synapse=syn_new.id)
proj0.electrical_connections.append(conn0)
if include_muscles:
for conn in muscle_conns:
if conn.pre_cell in lems_info[
"cells"] and conn.post_cell in muscles:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell,
conn.synclass, conn.syntype)
elect_conn = False
syn0 = params.exc_syn
if 'GABA' in conn.synclass:
syn0 = params.inh_syn
if '_GJ' in conn.synclass:
syn0 = params.elec_syn
elect_conn = isinstance(params.elec_syn, GapJunction)
number_syns = conn.number
conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)
if conn_number_override is not None and (
conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (
conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number * conn_number_scaling[
conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
if number_syns != conn.number:
magnitude, unit = bioparameters.split_neuroml_quantity(
syn0.gbase)
cond0 = "%s%s" % (magnitude * conn.number, unit)
cond1 = "%s%s" % (magnitude * number_syns, unit)
if verbose:
print(">> Changing number of effective synapses connection %s -> %s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns,
nml_doc,
existing_synapses)
if not elect_conn:
if not populations_without_location:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
# Add a Connection with the closest locations
pre_cell_id = "../%s/0/%s" % (conn.pre_cell,
params.generic_cell.id)
post_cell_id = "../%s/0/%s" % (conn.post_cell,
params.generic_cell.id)
conn0 = Connection(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id)
proj0.connections.append(conn0)
if populations_without_location:
# <synapticConnection from="hh1pop[0]" to="hh2pop[0]" synapse="syn1exp" destination="synapses"/>
pre_cell_id = "%s[0]" % (conn.pre_cell)
post_cell_id = "%s[0]" % (conn.post_cell)
conn0 = SynapticConnection(from_=pre_cell_id,
to=post_cell_id,
synapse=syn_new.id,
destination="synapses")
net.synaptic_connections.append(conn0)
else:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
# Add a Connection with the closest locations
conn0 = ElectricalConnection(id="0", \
pre_cell="0",
post_cell="0",
synapse=syn_new.id)
proj0.electrical_connections.append(conn0)
# import pprint
# pprint.pprint(lems_info)
template_path = '../' if test else '' # if running test
write_to_file(nml_doc,
lems_info,
net_id,
template_path,
validate=validate,
verbose=verbose,
target_directory=target_directory)
return nml_doc
def generate(net_id,
params,
data_reader = "SpreadsheetDataReader",
cells = None,
cells_to_plot = None,
cells_to_stimulate = None,
muscles_to_include=[],
conns_to_include=[],
conn_number_override = None,
conn_number_scaling = None,
conn_polarity_override = None,
duration = 500,
dt = 0.01,
vmin = None,
vmax = None,
seed = 1234,
test=False,
verbose=True,
param_overrides={},
target_directory='./'):
validate = not (params.is_level_B() or params.is_level_C0())
root_dir = os.path.dirname(os.path.abspath(__file__))
for k in param_overrides.keys():
v = param_overrides[k]
print_("Setting parameter %s = %s"%(k,v))
params.set_bioparameter(k, v, "Set with param_overrides", 0)
params.create_models()
if vmin==None:
if params.is_level_A():
vmin=-72
elif params.is_level_B():
vmin=-52
elif params.is_level_C():
vmin=-60
elif params.is_level_D():
vmin=-60
else:
vmin=-52
if vmax==None:
if params.is_level_A():
vmax=-48
elif params.is_level_B():
vmax=-28
elif params.is_level_C():
vmax=25
elif params.is_level_D():
vmax=25
else:
vmax=-28
random.seed(seed)
info = "\n\nParameters and setting used to generate this network:\n\n"+\
" Data reader: %s\n" % data_reader+\
" Cells: %s\n" % (cells if cells is not None else "All cells")+\
" Cell stimulated: %s\n" % (cells_to_stimulate if cells_to_stimulate is not None else "All neurons")+\
" Connection: %s\n" % (conns_to_include if conns_to_include is not None else "All connections") + \
" Connection numbers overridden: %s\n" % (conn_number_override if conn_number_override is not None else "None")+\
" Connection numbers scaled: %s\n" % (conn_number_scaling if conn_number_scaling is not None else "None")+ \
" Connection polarities override: %s\n" % conn_polarity_override + \
" Muscles: %s\n" % (muscles_to_include if muscles_to_include is not None else "All muscles")
if verbose: print_(info)
info += "\n%s\n"%(params.bioparameter_info(" "))
nml_doc = NeuroMLDocument(id=net_id, notes=info)
if params.is_level_A() or params.is_level_B() or params.level == "BC1":
nml_doc.iaf_cells.append(params.generic_muscle_cell)
nml_doc.iaf_cells.append(params.generic_neuron_cell)
elif params.is_level_C():
nml_doc.cells.append(params.generic_muscle_cell)
nml_doc.cells.append(params.generic_neuron_cell)
elif params.is_level_D():
nml_doc.cells.append(params.generic_muscle_cell)
net = Network(id=net_id)
nml_doc.networks.append(net)
nml_doc.pulse_generators.append(params.offset_current)
if is_cond_based_cell(params):
nml_doc.fixed_factor_concentration_models.append(params.concentration_model)
cell_names, conns = get_cell_names_and_connection(data_reader)
# To hold all Cell NeuroML objects vs. names
all_cells = {}
# lems_file = ""
lems_info = {"comment": info,
"reference": net_id,
"duration": duration,
"dt": dt,
"vmin": vmin,
"vmax": vmax}
lems_info["plots"] = []
lems_info["activity_plots"] = []
lems_info["muscle_plots"] = []
lems_info["muscle_activity_plots"] = []
lems_info["to_save"] = []
lems_info["activity_to_save"] = []
lems_info["muscles_to_save"] = []
lems_info["muscles_activity_to_save"] = []
lems_info["cells"] = []
lems_info["muscles"] = []
lems_info["includes"] = []
if params.custom_component_types_definitions:
if isinstance(params.custom_component_types_definitions, str):
params.custom_component_types_definitions = [params.custom_component_types_definitions]
for ctd in params.custom_component_types_definitions:
lems_info["includes"].append(ctd)
if target_directory != './':
def_file = "%s/%s"%(os.path.dirname(os.path.abspath(__file__)), ctd)
shutil.copy(def_file, target_directory)
nml_doc.includes.append(IncludeType(href=ctd))
backers_dir = root_dir+"/../../../../OpenWormBackers/" if test else root_dir+"/../../../OpenWormBackers/"
sys.path.append(backers_dir)
import backers
cells_vs_name = backers.get_adopted_cell_names(backers_dir)
count = 0
for cell in cell_names:
if cells is None or cell in cells:
inst = Instance(id="0")
if not params.is_level_D():
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_neuron_cell.id,
type="populationList")
cell_id = params.generic_neuron_cell.id
else:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=cell,
type="populationList")
cell_id = cell
pop0.instances.append(inst)
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(cell):
p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[cell])
pop0.properties.append(p)
# also use the cell name to grab the morphology file, as a NeuroML data structure
# into the 'all_cells' dict
cell_file_path = root_dir+"/../../../" if test else root_dir+"/../../" #if running test
cell_file = cell_file_path+'generatedNeuroML2/%s.cell.nml'%cell
doc = loaders.NeuroMLLoader.load(cell_file)
all_cells[cell] = doc.cells[0]
if params.is_level_D():
new_cell = params.create_neuron_cell(cell, doc.cells[0].morphology)
nml_cell_doc = NeuroMLDocument(id=cell)
nml_cell_doc.cells.append(new_cell)
new_cell_file = 'cells/'+cell+'_D.cell.nml'
nml_file = target_directory+'/'+new_cell_file
print_("Writing new cell to: %s"%os.path.realpath(nml_file))
writers.NeuroMLWriter.write(nml_cell_doc, nml_file)
nml_doc.includes.append(IncludeType(href=new_cell_file))
lems_info["includes"].append(new_cell_file)
inst.location = Location(0,0,0)
else:
location = doc.cells[0].morphology.segments[0].proximal
inst.location = Location(float(location.x), float(location.y), float(location.z))
if verbose:
print_("Loaded morphology: %s; id: %s; placing at location: (%s, %s, %s)"%(os.path.realpath(cell_file), all_cells[cell].id, inst.location.x, inst.location.y, inst.location.z))
if cells_to_stimulate is None or cell in cells_to_stimulate:
target = "../%s/0/%s"%(pop0.id, cell_id)
if params.is_level_D():
target+="/0"
input_list = InputList(id="Input_%s_%s"%(cell,params.offset_current.id),
component=params.offset_current.id,
populations='%s'%cell)
input_list.input.append(Input(id=0,
target=target,
destination="synapses"))
net.input_lists.append(input_list)
if cells_to_plot is None or cell in cells_to_plot:
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (cell, cell_id)
lems_info["plots"].append(plot)
if params.is_level_B():
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (cell, cell_id)
lems_info["activity_plots"].append(plot)
if is_cond_based_cell(params):
plot = {}
plot["cell"] = cell
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (cell, cell_id)
lems_info["activity_plots"].append(plot)
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/v" % (cell, cell_id)
lems_info["to_save"].append(save)
if params.is_level_B():
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/activity" % (cell, cell_id)
lems_info["activity_to_save"].append(save)
if is_cond_based_cell(params):
save = {}
save["cell"] = cell
save["quantity"] = "%s/0/%s/caConc" % (cell, cell_id)
lems_info["activity_to_save"].append(save)
lems_info["cells"].append(cell)
count+=1
if verbose:
print_("Finished loading %i cells"%count)
mneurons, all_muscles, muscle_conns = get_cell_muscle_names_and_connection(data_reader)
#if data_reader == "SpreadsheetDataReader":
# all_muscles = get_muscle_names()
if muscles_to_include == None or muscles_to_include == True:
muscles_to_include = all_muscles
elif muscles_to_include == False:
muscles_to_include = []
for m in muscles_to_include:
assert m in all_muscles
if len(muscles_to_include)>0:
muscle_count = 0
for muscle in muscles_to_include:
inst = Instance(id="0")
# build a Population data structure out of the cell name
pop0 = Population(id=muscle,
component=params.generic_muscle_cell.id,
type="populationList")
pop0.instances.append(inst)
# put that Population into the Network data structure from above
net.populations.append(pop0)
if cells_vs_name.has_key(muscle):
# No muscles adopted yet, but just in case they are in future...
p = Property(tag="OpenWormBackerAssignedName", value=cells_vs_name[muscle])
pop0.properties.append(p)
x, y, z = get_muscle_position(muscle, data_reader)
print_('Positioning muscle: %s at (%s,%s,%s)'%(muscle,x,y,z))
inst.location = Location(x,y,z)
#target = "%s/0/%s"%(pop0.id, params.generic_muscle_cell.id) # unused
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id)
lems_info["muscle_plots"].append(plot)
if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_muscle_cell.id)
lems_info["muscle_activity_plots"].append(plot)
if params.generic_muscle_cell.__class__.__name__ == 'Cell':
plot = {}
plot["cell"] = muscle
plot["colour"] = get_random_colour_hex()
plot["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_muscle_cell.id)
lems_info["muscle_activity_plots"].append(plot)
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/v" % (muscle, params.generic_muscle_cell.id)
lems_info["muscles_to_save"].append(save)
if params.generic_muscle_cell.__class__.__name__ == 'IafActivityCell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/activity" % (muscle, params.generic_muscle_cell.id)
lems_info["muscles_activity_to_save"].append(save)
if params.generic_muscle_cell.__class__.__name__ == 'Cell':
save = {}
save["cell"] = muscle
save["quantity"] = "%s/0/%s/caConc" % (muscle, params.generic_muscle_cell.id)
lems_info["muscles_activity_to_save"].append(save)
lems_info["muscles"].append(muscle)
muscle_count+=1
if muscle in cells_to_stimulate:
target = "../%s/0/%s"%(pop0.id, params.generic_muscle_cell.id)
if params.is_level_D():
target+="/0"
input_list = InputList(id="Input_%s_%s"%(muscle,params.offset_current.id),
component=params.offset_current.id,
populations='%s'%pop0.id)
input_list.input.append(Input(id=0,
target=target,
destination="synapses"))
net.input_lists.append(input_list)
if verbose:
print_("Finished creating %i muscles"%muscle_count)
existing_synapses = {}
for conn in conns:
if conn.pre_cell in lems_info["cells"] and conn.post_cell in lems_info["cells"]:
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)
conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)
elect_conn = False
analog_conn = False
syn0 = params.neuron_to_neuron_exc_syn
orig_pol = "exc"
if 'GABA' in conn.synclass:
syn0 = params.neuron_to_neuron_inh_syn
orig_pol = "inh"
if '_GJ' in conn.synclass:
syn0 = params.neuron_to_neuron_elec_syn
elect_conn = isinstance(params.neuron_to_neuron_elec_syn, GapJunction)
conn_shorthand = "%s-%s_GJ" % (conn.pre_cell, conn.post_cell)
if conns_to_include and conn_shorthand not in conns_to_include:
continue
print conn_shorthand + " " + str(conn.number) + " " + orig_pol + " " + conn.synclass
polarity = None
if conn_polarity_override and conn_polarity_override.has_key(conn_shorthand):
polarity = conn_polarity_override[conn_shorthand]
if polarity and not elect_conn:
if polarity == 'inh':
syn0 = params.neuron_to_neuron_inh_syn
else:
syn0 = params.neuron_to_neuron_exc_syn
if verbose and polarity != orig_pol:
print_(">> Changing polarity of connection %s -> %s: was: %s, becomes %s " % \
(conn.pre_cell, conn.post_cell, orig_pol, polarity))
if isinstance(syn0, GradedSynapse) or isinstance(syn0, GradedSynapse2):
analog_conn = True
if len(nml_doc.silent_synapses)==0:
silent = SilentSynapse(id="silent")
nml_doc.silent_synapses.append(silent)
number_syns = conn.number
if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number*conn_number_scaling[conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
"""if polarity:
print "%s %s num:%s" % (conn_shorthand, polarity, number_syns)
elif elect_conn:
print "%s num:%s" % (conn_shorthand, number_syns)
else:
print "%s %s num:%s" % (conn_shorthand, orig_pol, number_syns)"""
if number_syns != conn.number:
if analog_conn or elect_conn:
magnitude, unit = bioparameters.split_neuroml_quantity(syn0.conductance)
else:
magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase)
cond0 = "%s%s"%(magnitude*conn.number, unit)
cond1 = "%s%s" % (get_str_from_expnotation(magnitude * number_syns), unit)
gj = "" if not elect_conn else " GapJunction"
if verbose:
print_(">> Changing number of effective synapses connection %s -> %s%s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, gj, conn.number, cond0, number_syns, cond1))
#print "######## %s-%s %s %s" % (conn.pre_cell, conn.post_cell, conn.synclass, number_syns)
#known_motor_prefixes = ["VA"]
#if conn.pre_cell.startswith(tuple(known_motor_prefixes)) or conn.post_cell.startswith(tuple(known_motor_prefixes)):
# print "######### %s-%s %s %s" % (conn.pre_cell, conn.post_cell, number_syns, conn.synclass)
syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses)
if elect_conn:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
pre_cell_id=get_cell_id_string(conn.pre_cell, params)
post_cell_id= get_cell_id_string(conn.post_cell, params)
#print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))
# Add a Connection with the closest locations
conn0 = ElectricalConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
synapse=syn_new.id)
proj0.electrical_connection_instances.append(conn0)
elif analog_conn:
proj0 = ContinuousProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.continuous_projections.append(proj0)
pre_cell_id= get_cell_id_string(conn.pre_cell, params)
post_cell_id= get_cell_id_string(conn.post_cell, params)
conn0 = ContinuousConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
pre_component="silent",
post_component=syn_new.id)
proj0.continuous_connection_instances.append(conn0)
else:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
pre_cell_id= get_cell_id_string(conn.pre_cell, params)
post_cell_id= get_cell_id_string(conn.post_cell, params)
conn0 = ConnectionWD(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id,
weight = number_syns,
delay = '0ms')
proj0.connection_wds.append(conn0)
if len(muscles_to_include)>0:
for conn in muscle_conns:
if not conn.post_cell in muscles_to_include:
continue
if not conn.pre_cell in lems_info["cells"] and not conn.pre_cell in muscles_to_include:
continue
# take information about each connection and package it into a
# NeuroML Projection data structure
proj_id = get_projection_id(conn.pre_cell, conn.post_cell, conn.synclass, conn.syntype)
conn_shorthand = "%s-%s" % (conn.pre_cell, conn.post_cell)
elect_conn = False
analog_conn = False
syn0 = params.neuron_to_muscle_exc_syn
orig_pol = "exc"
if 'GABA' in conn.synclass:
syn0 = params.neuron_to_muscle_inh_syn
orig_pol = "inh"
if '_GJ' in conn.synclass :
elect_conn = isinstance(params.neuron_to_muscle_elec_syn, GapJunction)
conn_shorthand = "%s-%s_GJ" % (conn.pre_cell, conn.post_cell)
if conn.pre_cell in lems_info["cells"]:
syn0 = params.neuron_to_muscle_elec_syn
elif conn.pre_cell in muscles_to_include:
try:
syn0 = params.muscle_to_muscle_elec_syn
except:
syn0 = params.neuron_to_muscle_elec_syn
if conns_to_include and conn_shorthand not in conns_to_include:
continue
print conn_shorthand + " " + str(conn.number) + " " + orig_pol + " " + conn.synclass
polarity = None
if conn_polarity_override and conn_polarity_override.has_key(conn_shorthand):
polarity = conn_polarity_override[conn_shorthand]
if polarity and not elect_conn:
if polarity == 'inh':
syn0 = params.neuron_to_neuron_inh_syn
else:
syn0 = params.neuron_to_neuron_exc_syn
if verbose and polarity != orig_pol:
print_(">> Changing polarity of connection %s -> %s: was: %s, becomes %s " % \
(conn.pre_cell, conn.post_cell, orig_pol, polarity))
if isinstance(syn0, GradedSynapse) or isinstance(syn0, GradedSynapse2):
analog_conn = True
if len(nml_doc.silent_synapses)==0:
silent = SilentSynapse(id="silent")
nml_doc.silent_synapses.append(silent)
number_syns = conn.number
if conn_number_override is not None and (conn_number_override.has_key(conn_shorthand)):
number_syns = conn_number_override[conn_shorthand]
elif conn_number_scaling is not None and (conn_number_scaling.has_key(conn_shorthand)):
number_syns = conn.number*conn_number_scaling[conn_shorthand]
'''
else:
print conn_shorthand
print conn_number_override
print conn_number_scaling'''
"""if polarity:
print "%s %s num:%s" % (conn_shorthand, polarity, number_syns)
elif elect_conn:
print "%s num:%s" % (conn_shorthand, number_syns)
else:
print "%s %s num:%s" % (conn_shorthand, orig_pol, number_syns)"""
if number_syns != conn.number:
if analog_conn or elect_conn:
magnitude, unit = bioparameters.split_neuroml_quantity(syn0.conductance)
else:
magnitude, unit = bioparameters.split_neuroml_quantity(syn0.gbase)
cond0 = "%s%s"%(magnitude*conn.number, unit)
cond1 = "%s%s" % (get_str_from_expnotation(magnitude * number_syns), unit)
gj = "" if not elect_conn else " GapJunction"
if verbose:
print_(">> Changing number of effective synapses connection %s -> %s%s: was: %s (total cond: %s), becomes %s (total cond: %s)" % \
(conn.pre_cell, conn.post_cell, gj, conn.number, cond0, number_syns, cond1))
syn_new = create_n_connection_synapse(syn0, number_syns, nml_doc, existing_synapses)
if elect_conn:
proj0 = ElectricalProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.electrical_projections.append(proj0)
pre_cell_id= get_cell_id_string(conn.pre_cell, params)
post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True)
#print_("Conn %s -> %s"%(pre_cell_id,post_cell_id))
# Add a Connection with the closest locations
conn0 = ElectricalConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
synapse=syn_new.id)
proj0.electrical_connection_instances.append(conn0)
elif analog_conn:
proj0 = ContinuousProjection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell)
net.continuous_projections.append(proj0)
pre_cell_id= get_cell_id_string(conn.pre_cell, params)
post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True)
conn0 = ContinuousConnectionInstance(id="0", \
pre_cell=pre_cell_id,
post_cell=post_cell_id,
pre_component="silent",
post_component=syn_new.id)
proj0.continuous_connection_instances.append(conn0)
else:
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
net.projections.append(proj0)
# Add a Connection with the closest locations
pre_cell_id= get_cell_id_string(conn.pre_cell, params)
post_cell_id= get_cell_id_string(conn.post_cell, params, muscle=True)
conn0 = Connection(id="0", \
pre_cell_id=pre_cell_id,
post_cell_id=post_cell_id)
proj0.connections.append(conn0)
# import pprint
# pprint.pprint(lems_info)
template_path = root_dir+'/../' if test else root_dir+'/' # if running test
write_to_file(nml_doc, lems_info, net_id, template_path, validate=validate, verbose=verbose, target_directory=target_directory)
return nml_doc
def create_n_connection_synapse(prototype_syn, n, nml_doc, existing_synapses):
new_id = "%s_%sconns"%(prototype_syn.id, str(n).replace('.', '_'))
if type(n) is float:
new_id = "%s_%sconns" % (prototype_syn.id, get_str_from_expnotation(n).replace('.', '_'))
if isinstance(prototype_syn, ExpTwoSynapse):
new_id = "%s"%(prototype_syn.id)
if not existing_synapses.has_key(new_id):
if isinstance(prototype_syn, ExpTwoSynapse):
new_syn = ExpTwoSynapse(id=new_id,
gbase = prototype_syn.gbase,
erev = prototype_syn.erev,
tau_decay = prototype_syn.tau_decay,
tau_rise = prototype_syn.tau_rise)
existing_synapses[new_id] = new_syn
nml_doc.exp_two_synapses.append(new_syn)
elif isinstance(prototype_syn, GapJunction):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.conductance)
cond = "%s%s" % (magnitude * n, unit)
if type(n) is float:
cond = "%s%s" % (get_str_from_expnotation(magnitude * n), unit)
new_syn = GapJunction(id=new_id,
conductance = cond)
existing_synapses[new_id] = new_syn
nml_doc.gap_junctions.append(new_syn)
elif isinstance(prototype_syn, GradedSynapse):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.conductance)
cond = "%s%s" % (magnitude * n, unit)
if type(n) is float:
cond = "%s%s" % (get_str_from_expnotation(magnitude * n), unit)
new_syn = GradedSynapse(id=new_id,
conductance = cond,
delta = prototype_syn.delta,
Vth = prototype_syn.Vth,
erev = prototype_syn.erev,
k = prototype_syn.k)
existing_synapses[new_id] = new_syn
nml_doc.graded_synapses.append(new_syn)
elif isinstance(prototype_syn, GradedSynapse2):
magnitude, unit = bioparameters.split_neuroml_quantity(prototype_syn.conductance)
cond = "%s%s" % (magnitude * n, unit)
if type(n) is float:
cond = "%s%s" % (get_str_from_expnotation(magnitude * n), unit)
new_syn = GradedSynapse2(id=new_id,
conductance = cond,
ar = prototype_syn.ar,
ad = prototype_syn.ad,
beta = prototype_syn.beta,
vth = prototype_syn.vth,
erev = prototype_syn.erev)
existing_synapses[new_id] = new_syn
nml_doc.graded_synapses.append(new_syn)
else:
new_syn = existing_synapses[new_id]
return new_syn
