def createMorphoMlFile(fileName, cell):
'''
Convert to new neuroml structures and write
'''
if not muscle_dict.has_key(cell.name):
neuroMlwriter = NeuroMlWriter(fileName, cell.name)
neuroMlwriter.addCell(cell)
neuroMlwriter.writeDocumentToFile()
return
#
# Incomplete code to use the neuroml interface to write the file,
# used for muscles, doesn't produce good enough result on neurons yet.
#
seg0 = cell.segments[0].position
soma = Segment(proximal=cvt_pt(seg0.proximal_point),
distal=cvt_pt(seg0.distal_point))
soma.name = 'Soma'
soma.id = 0
axon_segments = []
for seg1 in cell.segments[1:]:
parent = SegmentParent(segments=seg1.parent)
if seg1.position.proximal_point is None:
p = None
else:
p = cvt_pt(seg1.position.proximal_point)
axon_segment = Segment(proximal = p,
distal = cvt_pt(seg1.position.distal_point),
parent = parent)
axon_segment.id = seg1.id
axon_segment.name = seg1.name
axon_segments.append(axon_segment)
morphology = Morphology()
morphology.segments.append(soma)
morphology.segments += axon_segments
morphology.id = 'morphology_' + cell.name
nml_cell = neuroml_Cell()
nml_cell.id = cell.name
nml_cell.morphology = morphology
doc = NeuroMLDocument()
doc.cells.append(nml_cell)
#addCell(doc, cell)
doc.id = "TestNeuroMLDocument"
writers.NeuroMLWriter.write(doc, "Output/%s.nml" % fileName)
def createMorphoMlFile(fileName, cell):
'''
Convert to new neuroml structures and write
'''
seg0 = cell.segments[0].position
soma = Segment(proximal=cvt_pt(seg0.proximal_point),
distal=cvt_pt(seg0.distal_point))
soma.name = 'Soma'
soma.id = 0
axon_segments = []
for seg1 in cell.segments[1:]:
parent = SegmentParent(segments=seg1.parent)
if seg1.position.distal_point is None:
p = None
else:
p = cvt_pt(seg1.position.distal_point)
axon_segment = Segment(proximal = p,
distal = cvt_pt(seg1.position.distal_point),
parent = parent)
axon_segment.id = seg1.id
axon_segment.name = seg1.name
axon_segments.append(axon_segment)
morphology = Morphology()
morphology.segments.append(soma)
morphology.segments += axon_segments
morphology.id = 'morphology_' + cell.name
nml_cell = neuroml_Cell()
nml_cell.id = cell.name
nml_cell.morphology = morphology
doc = NeuroMLDocument()
#doc.name = "Test neuroML document"
doc.cells.append(nml_cell)
doc.id = fileName
writers.NeuroMLWriter.write(doc, "Output/%s.nml" % fileName)
def neuroml_network(cells, response):
""" Write a list of Cell instances.
cells: a list of Cell instances.
response: somewhere to write to, like an HttpResponse
Returns nothing.
"""
doc = NeuroMLDocument()
doc.cells.extend(cells)
doc.id = "NeuroMLDocument"
namespacedef = 'xmlns="http://www.neuroml.org/schema/neuroml2"' \
+ ' xmlns:xi="http://www.w3.org/2001/XInclude"' \
+ ' xmlns:xs="http://www.w3.org/2001/XMLSchema"' \
+ ' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' \
+ ' xsi:schemaLocation="http://www.w3.org/2001/XMLSchema"'
doc.export( response, 0, name_="neuroml", namespacedef_=namespacedef)
return response
from neuroml import Input
from neuroml import InputList
from neuroml import ConnectionWD
from neuroml import Projection
from neuroml import Property
from neuroml import Instance
from neuroml import Location
from neuroml import PoissonFiringSynapse
import neuroml.writers as writers
from random import random
scale = 2
nml_doc = NeuroMLDocument(id="IafNet")
nml_doc.notes = "Root notes"
IafCell0 = IafCell(id="iaf0",
C="1.0 nF",
thresh="-50mV",
reset="-65mV",
leak_conductance="10 nS",
leak_reversal="-65mV")
nml_doc.iaf_cells.append(IafCell0)
IafCell1 = IafCell(id="iaf1",
C="1.0 nF",
thresh="-50mV",
def generate_layered_network(
network_id,
numCells_exc_per_layer,
numCells_inh_per_layer,
num_layers=10,
x_size=1000,
layer_y_size=100,
z_size=1000,
exc_group_component="SimpleIaF",
inh_group_component="SimpleIaF_inh",
validate=True,
random_seed=1234,
generate_lems_simulation=False,
connections=True,
connection_probability_exc_exc=0.4,
connection_probability_inh_exc=0.4,
connection_probability_exc_inh=0.4,
connection_probability_inh_inh=0.4,
inputs=False,
input_firing_rate=50, # Hz
num_inputs_per_exc=4,
duration=500, # ms
dt=0.05,
temperature="32.0 degC"):
seed(random_seed)
nml_doc = NeuroMLDocument(id=network_id)
net = Network(id=network_id,
type="networkWithTemperature",
temperature=temperature)
net.notes = "Network generated using libNeuroML v%s" % __version__
nml_doc.networks.append(net)
for cell_comp in set([exc_group_component,
inh_group_component]): # removes duplicates
nml_doc.includes.append(IncludeType(href='%s.cell.nml' % cell_comp))
# The names of the Exc & Inh groups/populations
exc_group = "Exc"
inh_group = "Inh"
# The names of the network connections
net_conn_exc_inh = "NetConn_Exc_Inh"
net_conn_inh_exc = "NetConn_Inh_Exc"
net_conn_exc_exc = "NetConn_Exc_Exc"
net_conn_inh_inh = "NetConn_Inh_Inh"
# The names of the synapse types (should match names at Cell Mechanism/Network tabs in neuroConstruct)
exc_inh_syn = "AMPAR"
inh_exc_syn = "GABAA"
exc_exc_syn = "AMPAR"
inh_inh_syn = "GABAA"
for syn in [exc_inh_syn, inh_exc_syn]:
nml_doc.includes.append(IncludeType(href='%s.synapse.nml' % syn))
# Generate excitatory cells
for layer in range(num_layers):
y_offset = -1 * layer * layer_y_size
exc_pop = Population(id="%s_%i" % (exc_group, layer),
component=exc_group_component,
type="populationList",
size=numCells_exc_per_layer)
net.populations.append(exc_pop)
for i in range(0, numCells_exc_per_layer):
index = i
inst = Instance(id=index)
exc_pop.instances.append(inst)
inst.location = Location(x=str(x_size * random()),
y=str(y_offset - layer_y_size * random()),
z=str(z_size * random()))
if numCells_inh_per_layer > 0:
# Generate inhibitory cells
inh_pop = Population(id="%s_%i" % (inh_group, layer),
component=inh_group_component,
type="populationList",
size=numCells_inh_per_layer)
net.populations.append(inh_pop)
for i in range(0, numCells_inh_per_layer):
index = i
inst = Instance(id=index)
inh_pop.instances.append(inst)
inst.location = Location(x=str(x_size * random()),
y=str(y_offset -
layer_y_size * random()),
z=str(z_size * random()))
if connections:
W = getW('mouse somatic M1')
for pre in range(num_layers):
for post in range(num_layers):
id = "proj_%s_%s" % (pre, post)
pre_pop = "%s_%i" % (exc_group, pre)
post_pop = "%s_%i" % (exc_group, post)
proj = Projection(id=id,
presynaptic_population=pre_pop,
postsynaptic_population=post_pop,
synapse=exc_exc_syn)
net.projections.append(proj)
count = 0
prob = W[pre][post]
print("Connecting layer %s to layer %s with probability %s" %
(pre, post, prob))
for i in range(0, numCells_exc_per_layer):
for j in range(0, numCells_exc_per_layer):
if i != j:
if random() < prob:
add_connection(proj, count, pre_pop,
exc_group_component, i, 0,
post_pop, exc_group_component,
j, 0)
count += 1
if inputs:
mf_input_syn = "AMPAR"
if mf_input_syn != exc_inh_syn and mf_input_syn != inh_exc_syn:
nml_doc.includes.append(
IncludeType(href='%s.synapse.nml' % mf_input_syn))
rand_spiker_id = "input_%sHz" % input_firing_rate
pfs = PoissonFiringSynapse(id=rand_spiker_id,
average_rate="%s per_s" % input_firing_rate,
synapse=mf_input_syn,
spike_target="./%s" % mf_input_syn)
nml_doc.poisson_firing_synapses.append(pfs)
input_list = InputList(id="Input_0",
component=rand_spiker_id,
populations=exc_group)
count = 0
for i in range(0, numCells_exc_per_layer):
for j in range(num_inputs_per_exc):
input = Input(id=count,
target="../%s/%i/%s" %
(exc_group, i, exc_group_component),
destination="synapses")
input_list.input.append(input)
count += 1
net.input_lists.append(input_list)
####### Write to file ######
print("Saving to file...")
nml_file = network_id + '.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file)
print("Written network file to: " + nml_file)
if validate:
###### Validate the NeuroML ######
from neuroml.utils import validate_neuroml2
validate_neuroml2(nml_file)
if generate_lems_simulation:
# Create a LEMSSimulation to manage creation of LEMS file
ls = LEMSSimulation("Sim_%s" % network_id, duration, dt)
# Point to network as target of simulation
ls.assign_simulation_target(net.id)
# Include generated/existing NeuroML2 files
ls.include_neuroml2_file('%s.cell.nml' % exc_group_component)
ls.include_neuroml2_file('%s.cell.nml' % inh_group_component)
ls.include_neuroml2_file(nml_file)
# Specify Displays and Output Files
disp_exc = "display_exc"
ls.create_display(disp_exc, "Voltages Exc cells", "-80", "50")
of_exc = 'Volts_file_exc'
ls.create_output_file(of_exc, "v_exc.dat")
disp_inh = "display_inh"
ls.create_display(disp_inh, "Voltages Inh cells", "-80", "50")
of_inh = 'Volts_file_inh'
ls.create_output_file(of_inh, "v_inh.dat")
for i in range(numCells_exc_per_layer):
quantity = "%s_0/%i/%s/v" % (exc_group, i, exc_group_component)
ls.add_line_to_display(disp_exc, "Exc %i: Vm" % i, quantity, "1mV",
pynml.get_next_hex_color())
ls.add_column_to_output_file(of_exc, "v_%i" % i, quantity)
for i in range(numCells_inh_per_layer):
quantity = "%s_0/%i/%s/v" % (inh_group, i, inh_group_component)
ls.add_line_to_display(disp_inh, "Inh %i: Vm" % i, quantity, "1mV",
pynml.get_next_hex_color())
ls.add_column_to_output_file(of_inh, "v_%i" % i, quantity)
# Save to LEMS XML file
lems_file_name = ls.save_to_file()
print "-----------------------------------"
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)
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(__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 = 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)
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_neuron_files_from_neuroml(network,
verbose=False,
dir_for_mod_files=None):
"""
Generate NEURON hoc/mod files from the NeuroML files which are marked as
included in the NeuroMLlite description; also compiles the mod files
"""
print_v(
"------------- Generating NEURON files from NeuroML for %s (default dir: %s)..."
% (network.id, dir_for_mod_files))
nml_src_files = []
from neuroml import NeuroMLDocument
import neuroml.writers as writers
temp_nml_doc = NeuroMLDocument(id="temp")
dirs_for_mod_files = []
if dir_for_mod_files != None:
dirs_for_mod_files.append(os.path.abspath(dir_for_mod_files))
for c in network.cells:
if c.neuroml2_source_file:
nml_src_files.append(c.neuroml2_source_file)
dir_for_mod = os.path.dirname(
os.path.abspath(c.neuroml2_source_file))
if not dir_for_mod in dirs_for_mod_files:
dirs_for_mod_files.append(dir_for_mod)
for s in network.synapses:
if s.neuroml2_source_file:
nml_src_files.append(s.neuroml2_source_file)
dir_for_mod = os.path.dirname(
os.path.abspath(s.neuroml2_source_file))
if not dir_for_mod in dirs_for_mod_files:
dirs_for_mod_files.append(dir_for_mod)
for i in network.input_sources:
if i.neuroml2_source_file:
nml_src_files.append(i.neuroml2_source_file)
dir_for_mod = os.path.dirname(
os.path.abspath(i.neuroml2_source_file))
if not dir_for_mod in dirs_for_mod_files:
dirs_for_mod_files.append(dir_for_mod)
temp_nml_doc = _extract_pynn_components_to_neuroml(network)
summary = temp_nml_doc.summary()
if 'IF_' in summary:
import tempfile
temp_nml_file = tempfile.NamedTemporaryFile(delete=False,
suffix='.nml',
dir=dir_for_mod_files)
print_v("Writing temporary NML file to: %s, summary: " %
temp_nml_file.name)
print_v(summary)
writers.NeuroMLWriter.write(temp_nml_doc, temp_nml_file.name)
nml_src_files.append(temp_nml_file.name)
for f in nml_src_files:
from pyneuroml import pynml
print_v("Generating/compiling hoc/mod files for: %s" % f)
pynml.run_lems_with_jneuroml_neuron(f,
nogui=True,
only_generate_scripts=True,
compile_mods=True,
verbose=False)
for dir_for_mod_files in dirs_for_mod_files:
if not dir_for_mod_files in locations_mods_loaded_from:
print_v(
"Generated NEURON code; loading mechanisms from %s (cwd: %s; already loaded: %s)"
% (dir_for_mod_files, os.getcwd(), locations_mods_loaded_from))
try:
from neuron import load_mechanisms
if os.getcwd() == dir_for_mod_files:
print_v(
"That's current dir => importing neuron module loads mods here..."
)
else:
load_mechanisms(dir_for_mod_files)
locations_mods_loaded_from.append(dir_for_mod_files)
except:
print_v("Failed to load mod file mechanisms...")
else:
print_v("Already loaded mechanisms from %s (all loaded: %s)" %
(dir_for_mod_files, locations_mods_loaded_from))
def run_fitted_cell_simulation(sweeps_to_tune_against: List,
tuning_report: Dict,
simulation_id: str) -> None:
"""Run a simulation with the values obtained from the fitting
:param tuning_report: tuning report from the optimser
:type tuning_report: Dict
:param simulation_id: text id of simulation
:type simulation_id: str
"""
# get the fittest variables
fittest_vars = tuning_report["fittest vars"]
C = str(fittest_vars["izhikevich2007Cell:Izh2007/C/pF"]) + "pF"
k = str(
fittest_vars["izhikevich2007Cell:Izh2007/k/nS_per_mV"]) + "nS_per_mV"
vr = str(fittest_vars["izhikevich2007Cell:Izh2007/vr/mV"]) + "mV"
vt = str(fittest_vars["izhikevich2007Cell:Izh2007/vt/mV"]) + "mV"
vpeak = str(fittest_vars["izhikevich2007Cell:Izh2007/vpeak/mV"]) + "mV"
a = str(fittest_vars["izhikevich2007Cell:Izh2007/a/per_ms"]) + "per_ms"
b = str(fittest_vars["izhikevich2007Cell:Izh2007/b/nS"]) + "nS"
c = str(fittest_vars["izhikevich2007Cell:Izh2007/c/mV"]) + "mV"
d = str(fittest_vars["izhikevich2007Cell:Izh2007/d/pA"]) + "pA"
# Create a simulation using our obtained parameters.
# Note that the tuner generates a graph with the fitted values already, but
# we want to keep a copy of our fitted cell also, so we'll create a NeuroML
# Document ourselves also.
sim_time = 1500.0
simulation_doc = NeuroMLDocument(id="FittedNet")
# Add an Izhikevich cell with some parameters to the document
simulation_doc.izhikevich2007_cells.append(
Izhikevich2007Cell(
id="Izh2007",
C=C,
v0="-60mV",
k=k,
vr=vr,
vt=vt,
vpeak=vpeak,
a=a,
b=b,
c=c,
d=d,
))
simulation_doc.networks.append(Network(id="Network0"))
# Add a cell for each acquisition list
popsize = len(sweeps_to_tune_against)
simulation_doc.networks[0].populations.append(
Population(id="Pop0", component="Izh2007", size=popsize))
# Add a current source for each cell, matching the currents that
# were used in the experimental study.
counter = 0
for acq in sweeps_to_tune_against:
simulation_doc.pulse_generators.append(
PulseGenerator(
id="Stim{}".format(counter),
delay="80ms",
duration="1000ms",
amplitude="{}pA".format(currents[acq]),
))
simulation_doc.networks[0].explicit_inputs.append(
ExplicitInput(target="Pop0[{}]".format(counter),
input="Stim{}".format(counter)))
counter = counter + 1
# Print a summary
print(simulation_doc.summary())
# Write to a neuroml file and validate it.
reference = "FittedIzhFergusonPyr3"
simulation_filename = "{}.net.nml".format(reference)
write_neuroml2_file(simulation_doc, simulation_filename, validate=True)
simulation = LEMSSimulation(
sim_id=simulation_id,
duration=sim_time,
dt=0.1,
target="Network0",
simulation_seed=54321,
)
simulation.include_neuroml2_file(simulation_filename)
simulation.create_output_file("output0", "{}.v.dat".format(simulation_id))
counter = 0
for acq in sweeps_to_tune_against:
simulation.add_column_to_output_file("output0",
"Pop0[{}]".format(counter),
"Pop0[{}]/v".format(counter))
counter = counter + 1
simulation_file = simulation.save_to_file()
# simulate
run_lems_with_jneuroml(simulation_file,
max_memory="2G",
nogui=True,
plot=False)
def create_cell():
"""Create the cell.
:returns: name of the cell nml file
"""
# Create the nml file and add the ion channels
hh_cell_doc = NeuroMLDocument(id="cell", notes="HH cell")
hh_cell_fn = "HH_example_cell.nml"
hh_cell_doc.includes.append(IncludeType(href=create_na_channel()))
hh_cell_doc.includes.append(IncludeType(href=create_k_channel()))
hh_cell_doc.includes.append(IncludeType(href=create_leak_channel()))
# Define a cell
hh_cell = Cell(id="hh_cell", notes="A single compartment HH cell")
# Define its biophysical properties
bio_prop = BiophysicalProperties(id="hh_b_prop")
# notes="Biophysical properties for HH cell")
# Membrane properties are a type of biophysical properties
mem_prop = MembraneProperties()
# Add membrane properties to the biophysical properties
bio_prop.membrane_properties = mem_prop
# Append to cell
hh_cell.biophysical_properties = bio_prop
# Channel density for Na channel
na_channel_density = ChannelDensity(id="na_channels", cond_density="120.0 mS_per_cm2", erev="50.0 mV", ion="na", ion_channel="na_channel")
mem_prop.channel_densities.append(na_channel_density)
# Channel density for k channel
k_channel_density = ChannelDensity(id="k_channels", cond_density="360 S_per_m2", erev="-77mV", ion="k", ion_channel="k_channel")
mem_prop.channel_densities.append(k_channel_density)
# Leak channel
leak_channel_density = ChannelDensity(id="leak_channels", cond_density="3.0 S_per_m2", erev="-54.3mV", ion="non_specific", ion_channel="leak_channel")
mem_prop.channel_densities.append(leak_channel_density)
# Other membrane properties
mem_prop.spike_threshes.append(SpikeThresh(value="-20mV"))
mem_prop.specific_capacitances.append(SpecificCapacitance(value="1.0 uF_per_cm2"))
mem_prop.init_memb_potentials.append(InitMembPotential(value="-65mV"))
intra_prop = IntracellularProperties()
intra_prop.resistivities.append(Resistivity(value="0.03 kohm_cm"))
# Add to biological properties
bio_prop.intracellular_properties = intra_prop
# Morphology
morph = Morphology(id="hh_cell_morph")
# notes="Simple morphology for the HH cell")
seg = Segment(id="0", name="soma", notes="Soma segment")
# We want a diameter such that area is 1000 micro meter^2
# surface area of a sphere is 4pi r^2 = 4pi diam^2
diam = math.sqrt(1000 / math.pi)
proximal = distal = Point3DWithDiam(x="0", y="0", z="0", diameter=str(diam))
seg.proximal = proximal
seg.distal = distal
morph.segments.append(seg)
hh_cell.morphology = morph
hh_cell_doc.cells.append(hh_cell)
pynml.write_neuroml2_file(nml2_doc=hh_cell_doc, nml2_file_name=hh_cell_fn, validate=True)
return hh_cell_fn
from neuroml import ElectricalConnection
from neuroml import ElectricalConnectionInstance
from neuroml import ElectricalConnectionInstanceW
from neuroml import Property
from neuroml import Instance
from neuroml import Location
from neuroml import PoissonFiringSynapse
import neuroml.writers as writers
import random
random.seed(123)
scale = 2
nml_doc = NeuroMLDocument(id="Complete")
nml_doc.notes = "Lots of notes...."
IafCell0 = IafCell(id="iaf0",
C="1.0 nF",
thresh="-50mV",
reset="-65mV",
leak_conductance="10 nS",
leak_reversal="-65mV")
nml_doc.iaf_cells.append(IafCell0)
IafCell1 = IafCell(id="iaf1",
C="1.0 nF",
thresh="-50mV",
from neuroml import Input
from neuroml import InputList
from neuroml import ConnectionWD
from neuroml import Projection
from neuroml import Property
from neuroml import Instance
from neuroml import Location
from neuroml import PoissonFiringSynapse
import neuroml.writers as writers
from random import random
scale = 2
nml_doc = NeuroMLDocument(id="IafNet")
nml_doc.notes = "Root notes"
IafCell0 = IafCell(id="iaf0",
C="1.0 nF",
thresh = "-50mV",
reset="-65mV",
leak_conductance="10 nS",
leak_reversal="-65mV")
nml_doc.iaf_cells.append(IafCell0)
IafCell1 = IafCell(id="iaf1",
C="1.0 nF",
thresh = "-50mV",
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 = -75,
vmax = 20,
seed = 1234,
validate=True):
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"%(bioparameter_info(" "))
nml_doc = NeuroMLDocument(id=net_id, notes=info)
nml_doc.iaf_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...
spreadsheet_location = "../../../"
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 hasattr(params.generic_cell, 'custom_component_type_definition'):
lems_info["includes"].append(params.generic_cell.custom_component_type_definition)
backers_dir = "../../../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 = '../../generatedNeuroML2/%s.nml'%cell
doc = loaders.NeuroMLLoader.load(cell_file)
all_cells[cell] = doc.cells[0]
location = doc.cells[0].morphology.segments[0].proximal
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 hasattr(params.generic_cell, 'custom_component_type_definition'):
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)
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 hasattr(params.generic_cell, 'custom_component_type_definition'):
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
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 hasattr(params.generic_cell, 'custom_component_type_definition'):
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 hasattr(params.generic_cell, 'custom_component_type_definition'):
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
print("Finished creating %i muscles"%muscle_count)
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 = split_neuroml_quantity(syn0.gbase)
cond0 = "%s%s"%(magnitude*conn.number, unit)
cond1 = "%s%s"%(magnitude*number_syns, unit)
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)
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 = split_neuroml_quantity(syn0.gbase)
cond0 = "%s%s"%(magnitude*conn.number, unit)
cond1 = "%s%s"%(magnitude*number_syns, unit)
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)
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)
write_to_file(nml_doc, lems_info, net_id, validate=validate)
return nml_doc
def generate(net_id,
params,
cells=None,
cells_to_plot=None,
cells_to_stimulate=None,
duration=500,
dt=0.01,
vmin=-75,
vmax=20):
nml_doc = NeuroMLDocument(id=net_id)
nml_doc.iaf_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...
cell_names, conns = R().read()
cell_names.sort()
# To hold all Cell NeuroML objects vs. names
all_cells = {}
# lems_file = ""
lems_info = {
"reference": net_id,
"duration": duration,
"dt": dt,
"vmin": vmin,
"vmax": vmax,
"cell_component": params.generic_cell.id
}
lems_info["plots"] = []
lems_info["cells"] = []
for cell in cell_names:
if cells is None or cell in cells:
# build a Population data structure out of the cell name
pop0 = Population(id=cell,
component=params.generic_cell.id,
type="populationList")
inst = Instance(id="0")
pop0.instances.append(inst)
# put that Population into the Network data structure from above
net.populations.append(pop0)
# also use the cell name to grab the morphology file, as a NeuroML data structure
# into the 'all_cells' dict
cell_file = '../../generatedNeuroML2/%s.nml' % cell
doc = loaders.NeuroMLLoader.load(cell_file)
all_cells[cell] = doc.cells[0]
location = doc.cells[0].morphology.segments[0].proximal
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))
exp_input = ExplicitInput(target="%s/0/%s" %
(pop0.id, params.generic_cell.id),
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()
lems_info["plots"].append(plot)
lems_info["cells"].append(cell)
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)
syn0 = params.exc_syn
if 'GABA' in conn.synclass:
syn0 = params.inh_syn
syn_new = create_n_connection_synapse(syn0, conn.number, nml_doc)
proj0 = Projection(id=proj_id, \
presynaptic_population=conn.pre_cell,
postsynaptic_population=conn.post_cell,
synapse=syn_new.id)
# Get the corresponding Cell for each
# pre_cell = all_cells[conn.pre_cell]
# post_cell = all_cells[conn.post_cell]
net.projections.append(proj0)
# Add a Connection with the closest locations
conn0 = Connection(id="0", \
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))
proj0.connections.append(conn0)
write_to_file(nml_doc, lems_info, net_id)
def generatePopulationLEMS(pops, n_pops, amplitudes, baseline, sim_length,
delay):
def generatePopulationProjection(from_pop, to_pop, n_from_pop, n_to_pop,
w_to_from_pop, p_to_from_pop, net):
connection_count = 0
projection = ContinuousProjection(
id='%s_%s' % (from_pop, to_pop),
presynaptic_population='%sPop' % from_pop,
postsynaptic_population='%sPop' % to_pop)
for idx_from_pop in range(n_from_pop):
for idx_to_pop in range(n_to_pop):
if random.random() <= p_to_from_pop:
pre_comp = from_pop.upper()
to_comp = to_pop.upper()
connection = ContinuousConnectionInstanceW(
id=connection_count,
pre_cell='../%sPop/%i/%s' %
(from_pop, idx_from_pop, pre_comp),
post_cell='../%sPop/%i/%s' %
(to_pop, idx_to_pop, to_comp),
pre_component='silent1',
post_component='rs',
weight=w_to_from_pop / (p_to_from_pop * n_from_pop))
projection.continuous_connection_instance_ws.append(
connection)
connection_count += 1
if connection_count > 0:
net.continuous_projections.append(projection)
# Connection probabilities for each pop in the population
w_to_from_pops = np.array([[2.42, -.33, -0.80, 0], [2.97, -3.45, -2.13, 0],
[4.64, 0, 0, -2.79], [0.71, 0, -0.16, 0]])
# p_to_from_pop = np.array([[1, 1, 1, 0],
# [1, 1, 1, 0],
# [1, 0, 0, 1],
# [1, 0, 1, 0]])
p_to_from_pop = np.array([[0.02, 1, 1, 0], [0.01, 1, 0.85, 0],
[0.01, 0, 0, 0.55], [0.01, 0, 0.5, 0]])
nml_doc = NeuroMLDocument(id='RandomPopulation')
# Add silent synapsis
silent_syn = SilentSynapse(id='silent1')
nml_doc.silent_synapses.append(silent_syn)
for pop_idx, pop in enumerate(pops):
pulse = PulseGenerator(id='baseline_%s' % pop,
delay='0ms',
duration=str(sim_length) + 'ms',
amplitude=amplitudes[pop_idx])
nml_doc.pulse_generators.append(pulse)
if pop == 'vip':
# time point when additional current is induced
pulse_mod = PulseGenerator(id='modVIP',
delay=str(delay) + 'ms',
duration=str(sim_length - delay) + 'ms',
amplitude='10 pA')
nml_doc.pulse_generators.append(pulse_mod)
# Create the network and add the 4 different populations
net = Network(id='net2')
nml_doc.networks.append(net)
colours = ['0 0 1', '1 0 0', '.5 0 .5', '0 1 0']
centres = [(0, 0, 0), (-1200, 0, 0), (-800, 800, 0), (0, 1200, 0)]
radii = [800, 200, 200, 200]
# Populate the network with the 4 populations
for pop_idx, pop in enumerate(pops):
pop = Population(id='%sPop' % pop,
component=(pops[pop_idx]).upper(),
size=n_pops[pop_idx],
type='populationList')
net.populations.append(pop)
pop.properties.append(Property(tag='color', value=colours[pop_idx]))
pop.properties.append(Property(tag='radius', value=10))
for n_pop in range(n_pops[pop_idx]):
inst = Instance(id=n_pop)
pop.instances.append(inst)
x, y, z = centres[pop_idx]
r = (random.random() * radii[pop_idx]**3)**(1. / 3)
theta = random.random() * math.pi
phi = random.random() * math.pi * 2
inst.location = Location(
x=str(x + r * math.sin(theta) * math.cos(phi)),
y=str(y + r * math.sin(theta) * math.sin(phi)),
z=str(z + r * math.cos(theta)))
for from_idx, from_pop in enumerate(pops):
for to_idx, to_pop in enumerate(pops):
generatePopulationProjection(pops[from_idx], pops[to_idx],
n_pops[from_idx], n_pops[to_idx],
w_to_from_pops[to_idx, from_idx],
p_to_from_pop[to_idx, from_idx], net)
# Add inputs
for pop_idx, pop in enumerate(pops):
input_list = InputList(id='baseline_%s' % pop,
component='baseline_%s' % pops[pop_idx],
populations='%sPop' % pop)
net.input_lists.append(input_list)
if pop == 'vip':
input_list_mod = InputList(id='modulation_%s' % pop,
component='modVIP',
populations='%sPop' % pop)
net.input_lists.append(input_list_mod)
for n_idx in range(n_pops[pop_idx]):
input = Input(id=n_idx,
target='../%sPop/%i/%s' % (pop, n_idx, pop.upper()),
destination='synapses')
input_list.input.append(input)
# if vip add modulatory input
if pop == 'vip':
mod_input = Input(id=n_idx,
target='../vipPop/%i/VIP' % n_idx,
destination='synapses')
input_list_mod.input.append(mod_input)
nml_file = 'RandomPopulationRate_%s_baseline.nml' % baseline
writers.NeuroMLWriter.write(nml_doc, nml_file)
print('Written network file to: %s' % nml_file)
# Validate the NeuroML
from neuroml.utils import validate_neuroml2
validate_neuroml2(nml_file)
from neuroml import Member
from neuroml import Input
from neuroml import InputList
from neuroml import Instance
from neuroml import Location
from neuroml import Network
from neuroml import NeuroMLDocument
from neuroml import PoissonFiringSynapse
from neuroml import Population
from neuroml import Projection
from neuroml import Property
import neuroml.writers as writers
import random
import math
nml_doc = NeuroMLDocument(id="Example2")
nml_doc.notes = "Demo of cell with spines"
net = Network(id=nml_doc.id)
net.notes = nml_doc.notes
nml_doc.networks.append(net)
populations = {}
def add_instance(name, x, y, z):
pop = populations[name]
inst = Instance(id=len(pop.instances))
from neuroml import ElectricalProjection
from neuroml import ElectricalConnection
from neuroml import ElectricalConnectionInstance
from neuroml import Property
from neuroml import Instance
from neuroml import Location
from neuroml import PoissonFiringSynapse
import neuroml.writers as writers
import random
random.seed(123)
scale = 2
nml_doc = NeuroMLDocument(id="IafNet")
nml_doc.notes = "Root notes"
IafCell0 = IafCell(id="iaf0",
C="1.0 nF",
thresh="-50mV",
reset="-65mV",
leak_conductance="10 nS",
leak_reversal="-65mV")
nml_doc.iaf_cells.append(IafCell0)
IafCell1 = IafCell(id="iaf1",
C="1.0 nF",
thresh="-50mV",
def tune_izh_model(acq_list: List, metrics_from_data: Dict,
currents: Dict) -> Dict:
"""Tune networks model against the data.
Here we generate a network with the necessary number of Izhikevich cells,
one for each current stimulus, and tune them against the experimental data.
:param acq_list: list of indices of acquisitions/sweeps to tune against
:type acq_list: list
:param metrics_from_data: dictionary with the sweep number as index, and
the dictionary containing metrics generated from the analysis
:type metrics_from_data: dict
:param currents: dictionary with sweep number as index and stimulus current
value
"""
# length of simulation of the cells---should match the length of the
# experiment
sim_time = 1500.0
# Create a NeuroML template network simulation file that we will use for
# the tuning
template_doc = NeuroMLDocument(id="IzhTuneNet")
# Add an Izhikevich cell with some parameters to the document
template_doc.izhikevich2007_cells.append(
Izhikevich2007Cell(
id="Izh2007",
C="100pF",
v0="-60mV",
k="0.7nS_per_mV",
vr="-60mV",
vt="-40mV",
vpeak="35mV",
a="0.03per_ms",
b="-2nS",
c="-50.0mV",
d="100pA",
))
template_doc.networks.append(Network(id="Network0"))
# Add a cell for each acquisition list
popsize = len(acq_list)
template_doc.networks[0].populations.append(
Population(id="Pop0", component="Izh2007", size=popsize))
# Add a current source for each cell, matching the currents that
# were used in the experimental study.
counter = 0
for acq in acq_list:
template_doc.pulse_generators.append(
PulseGenerator(
id="Stim{}".format(counter),
delay="80ms",
duration="1000ms",
amplitude="{}pA".format(currents[acq]),
))
template_doc.networks[0].explicit_inputs.append(
ExplicitInput(target="Pop0[{}]".format(counter),
input="Stim{}".format(counter)))
counter = counter + 1
# Print a summary
print(template_doc.summary())
# Write to a neuroml file and validate it.
reference = "TuneIzhFergusonPyr3"
template_filename = "{}.net.nml".format(reference)
write_neuroml2_file(template_doc, template_filename, validate=True)
# Now for the tuning bits
# format is type:id/variable:id/units
# supported types: cell/channel/izhikevich2007cell
# supported variables:
# - channel: vShift
# - cell: channelDensity, vShift_channelDensity, channelDensityNernst,
# erev_id, erev_ion, specificCapacitance, resistivity
# - izhikevich2007Cell: all available attributes
# we want to tune these parameters within these ranges
# param: (min, max)
parameters = {
"izhikevich2007Cell:Izh2007/C/pF": (100, 300),
"izhikevich2007Cell:Izh2007/k/nS_per_mV": (0.01, 2),
"izhikevich2007Cell:Izh2007/vr/mV": (-70, -50),
"izhikevich2007Cell:Izh2007/vt/mV": (-60, 0),
"izhikevich2007Cell:Izh2007/vpeak/mV": (35, 70),
"izhikevich2007Cell:Izh2007/a/per_ms": (0.001, 0.4),
"izhikevich2007Cell:Izh2007/b/nS": (-10, 10),
"izhikevich2007Cell:Izh2007/c/mV": (-65, -10),
"izhikevich2007Cell:Izh2007/d/pA": (50, 500),
} # type: Dict[str, Tuple[float, float]]
# Set up our target data and so on
ctr = 0
target_data = {}
weights = {}
for acq in acq_list:
# data to fit to:
# format: path/to/variable:metric
# metric from pyelectro, for example:
# https://pyelectro.readthedocs.io/en/latest/pyelectro.html?highlight=mean_spike_frequency#pyelectro.analysis.mean_spike_frequency
mean_spike_frequency = "Pop0[{}]/v:mean_spike_frequency".format(ctr)
average_last_1percent = "Pop0[{}]/v:average_last_1percent".format(ctr)
first_spike_time = "Pop0[{}]/v:first_spike_time".format(ctr)
# each metric can have an associated weight
weights[mean_spike_frequency] = 1
weights[average_last_1percent] = 1
weights[first_spike_time] = 1
# value of the target data from our data set
target_data[mean_spike_frequency] = metrics_from_data[acq][
"{}:mean_spike_frequency".format(acq)]
target_data[average_last_1percent] = metrics_from_data[acq][
"{}:average_last_1percent".format(acq)]
target_data[first_spike_time] = metrics_from_data[acq][
"{}:first_spike_time".format(acq)]
# only add these if the experimental data includes them
# these are only generated for traces with spikes
if "{}:average_maximum".format(acq) in metrics_from_data[acq]:
average_maximum = "Pop0[{}]/v:average_maximum".format(ctr)
weights[average_maximum] = 1
target_data[average_maximum] = metrics_from_data[acq][
"{}:average_maximum".format(acq)]
if "{}:average_minimum".format(acq) in metrics_from_data[acq]:
average_minimum = "Pop0[{}]/v:average_minimum".format(ctr)
weights[average_minimum] = 1
target_data[average_minimum] = metrics_from_data[acq][
"{}:average_minimum".format(acq)]
ctr = ctr + 1
# simulator to use
simulator = "jNeuroML"
return run_optimisation(
# Prefix for new files
prefix="TuneIzh",
# Name of the NeuroML template file
neuroml_file=template_filename,
# Name of the network
target="Network0",
# Parameters to be fitted
parameters=list(parameters.keys()),
# Our max and min constraints
min_constraints=[v[0] for v in parameters.values()],
max_constraints=[v[1] for v in parameters.values()],
# Weights we set for parameters
weights=weights,
# The experimental metrics to fit to
target_data=target_data,
# Simulation time
sim_time=sim_time,
# EC parameters
population_size=100,
max_evaluations=500,
num_selected=30,
num_offspring=50,
mutation_rate=0.9,
num_elites=3,
# Seed value
seed=12345,
# Simulator
simulator=simulator,
dt=0.025,
show_plot_already='-nogui' not in sys.argv,
save_to_file="fitted_izhikevich_fitness.png",
save_to_file_scatter="fitted_izhikevich_scatter.png",
save_to_file_hist="fitted_izhikevich_hist.png",
save_to_file_output="fitted_izhikevich_output.png",
num_parallel_evaluations=4,
)
"""
Example to create a file with multiple synapse types
"""
from neuroml import NeuroMLDocument
from neuroml import *
import neuroml.writers as writers
from random import random
nml_doc = NeuroMLDocument(id="SomeSynapses")
expOneSyn0 = ExpOneSynapse(id="ampa", tau_decay="5ms", gbase="1nS", erev="0mV")
nml_doc.exp_one_synapses.append(expOneSyn0)
expTwoSyn0 = ExpTwoSynapse(id="gaba",
tau_decay="12ms",
tau_rise="3ms",
gbase="1nS",
erev="-70mV")
nml_doc.exp_two_synapses.append(expTwoSyn0)
bpSyn = BlockingPlasticSynapse(id="blockStpSynDep",
gbase="1nS",
erev="0mV",
tau_rise="0.1ms",
tau_decay="2ms")
bpSyn.notes = "This is a note"
bpSyn.plasticity_mechanism = PlasticityMechanism(
type="tsodyksMarkramDepMechanism",
"""
Example to build a PyNN based network
"""
from neuroml import NeuroMLDocument
from neuroml import *
import neuroml.writers as writers
from random import random
######################## Build the network ####################################
nml_doc = NeuroMLDocument(id="IafNet")
pynn0 = IF_curr_alpha(id="IF_curr_alpha_pop_IF_curr_alpha",
cm="1.0",
i_offset="0.9",
tau_m="20.0",
tau_refrac="10.0",
tau_syn_E="0.5",
tau_syn_I="0.5",
v_init="-65",
v_reset="-62.0",
v_rest="-65.0",
v_thresh="-52.0")
nml_doc.IF_curr_alpha.append(pynn0)
pynn1 = HH_cond_exp(id="HH_cond_exp_pop_HH_cond_exp",
cm="0.2",
e_rev_E="0.0",
if "GapJunction" in syntype:
proj_id += '_GJ'
return proj_id
if __name__ == "__main__":
# 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...
cell_names, conns = c302.SpreadsheetDataReader.readDataFromSpreadsheet()
net_id = "CElegansConnectome"
nml_network_doc = NeuroMLDocument(id=net_id)
# Create a NeuroML Network data structure to hold on to all the connection info.
net = Network(id=net_id)
nml_network_doc.networks.append(net)
# To hold all Cell NeuroML objects vs. names
all_cells = {}
for cell in cell_names:
# build a Population data structure out of the cell name
pop0 = Population(id=cell, component=cell, size=1)
inst = Instance(id="0")
# Each of these cells is at (0,0,0), i.e. segment 3D info in each cell is absolute
inst.location = Location(x="0.0", y="0.0", z="0.0")
pop0.instances.append(inst)
from neuroml import NeuroMLDocument
from neuroml import Izhikevich2007Cell
from neuroml import Population
from neuroml import Network
from neuroml import PulseGenerator
from neuroml import ExplicitInput
import neuroml.writers as writers
from neuroml.utils import validate_neuroml2
from pyneuroml import pynml
from pyneuroml.lems import LEMSSimulation
import numpy as np
# Create a new NeuroML model document
nml_doc = NeuroMLDocument(id="IzhSingleNeuron")
# Define the Izhikevich cell and add it to the model in the document
izh0 = Izhikevich2007Cell(
id="izh2007RS0", v0="-60mV", C="100pF", k="0.7nS_per_mV", vr="-60mV",
vt="-40mV", vpeak="35mV", a="0.03per_ms", b="-2nS", c="-50.0mV", d="100pA")
nml_doc.izhikevich2007_cells.append(izh0)
# Create a network and add it to the model
net = Network(id="IzhNet")
nml_doc.networks.append(net)
# Create a population of defined cells and add it to the model
size0 = 1
pop0 = Population(id="IzhPop0", component=izh0.id, size=size0)
net.populations.append(pop0)
def run():
cell_num = 10
x_size = 500
y_size = 500
z_size = 500
nml_doc = NeuroMLDocument(id="Net3DExample")
syn0 = ExpOneSynapse(id="syn0", gbase="65nS", erev="0mV", tau_decay="3ms")
nml_doc.exp_one_synapses.append(syn0)
net = Network(id="Net3D")
nml_doc.networks.append(net)
proj_count = 0
#conn_count = 0
for cell_id in range(0, cell_num):
cell = Cell(id="Cell_%i" % cell_id)
cell.morphology = generateRandomMorphology()
nml_doc.cells.append(cell)
pop = Population(id="Pop_%i" % cell_id,
component=cell.id,
type="populationList")
net.populations.append(pop)
pop.properties.append(Property(tag="color", value="1 0 0"))
inst = Instance(id="0")
pop.instances.append(inst)
inst.location = Location(x=str(x_size * random()),
y=str(y_size * random()),
z=str(z_size * random()))
prob_connection = 0.5
for post in range(0, cell_num):
if post is not cell_id and random() <= prob_connection:
from_pop = "Pop_%i" % cell_id
to_pop = "Pop_%i" % post
pre_seg_id = 0
post_seg_id = 1
projection = Projection(id="Proj_%i" % proj_count,
presynaptic_population=from_pop,
postsynaptic_population=to_pop,
synapse=syn0.id)
net.projections.append(projection)
connection = Connection(id=proj_count, \
pre_cell_id="%s[%i]"%(from_pop,0), \
pre_segment_id=pre_seg_id, \
pre_fraction_along=random(),
post_cell_id="%s[%i]"%(to_pop,0), \
post_segment_id=post_seg_id,
post_fraction_along=random())
projection.connections.append(connection)
proj_count += 1
#net.synaptic_connections.append(SynapticConnection(from_="%s[%i]"%(from_pop,0), to="%s[%i]"%(to_pop,0)))
####### Write to file ######
nml_file = 'tmp/net3d.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file)
print("Written network file to: " + nml_file)
###### Validate the NeuroML ######
from neuroml.utils import validate_neuroml2
validate_neuroml2(nml_file)
def createModel(self):
# File names of all components
pyr_file_name = "../ACnet2_NML2/Cells/pyr_4_sym.cell.nml"
bask_file_name = "../ACnet2_NML2/Cells/bask.cell.nml"
exc_exc_syn_names = '../ACnet2_NML2/Synapses/AMPA_syn.synapse.nml'
exc_inh_syn_names = '../ACnet2_NML2/Synapses/AMPA_syn_inh.synapse.nml'
inh_exc_syn_names = '../ACnet2_NML2/Synapses/GABA_syn.synapse.nml'
inh_inh_syn_names = '../ACnet2_NML2/Synapses/GABA_syn_inh.synapse.nml'
bg_exc_syn_names = '../ACnet2_NML2/Synapses/bg_AMPA_syn.synapse.nml'
nml_doc = NeuroMLDocument(id=self.filename + '_doc')
net = Network(id=self.filename + '_net')
nml_doc.networks.append(net)
nml_doc.includes.append(IncludeType(pyr_file_name))
nml_doc.includes.append(IncludeType(bask_file_name))
nml_doc.includes.append(IncludeType(exc_exc_syn_names))
nml_doc.includes.append(IncludeType(exc_inh_syn_names))
nml_doc.includes.append(IncludeType(inh_exc_syn_names))
nml_doc.includes.append(IncludeType(inh_inh_syn_names))
nml_doc.includes.append(IncludeType(bg_exc_syn_names))
# Create a LEMSSimulation to manage creation of LEMS file
ls = LEMSSimulation(self.filename, self.sim_time, self.dt)
# Point to network as target of simulation
ls.assign_simulation_target(net.id)
# The names of the cell type/component used in the Exc & Inh populations
exc_group_component = "pyr_4_sym"
inh_group_component = "bask"
# The names of the Exc & Inh groups/populations
exc_group = "pyramidals" #"pyramidals48x48"
inh_group = "baskets" #"baskets24x24"
# The names of the network connections
net_conn_exc_exc = "pyr_pyr"
net_conn_exc_inh = "pyr_bask"
net_conn_inh_exc = "bask_pyr"
net_conn_inh_inh = "bask_bask"
# The names of the synapse types
exc_exc_syn = "AMPA_syn"
exc_exc_syn_seg_id = 3 # Middle apical dendrite
exc_inh_syn = "AMPA_syn_inh"
exc_inh_syn_seg_id = 1 # Dendrite
inh_exc_syn = "GABA_syn"
inh_exc_syn_seg_id = 6 # Basal dendrite
inh_inh_syn = "GABA_syn_inh"
inh_inh_syn_seg_id = 0 # Soma
aff_exc_syn = "AMPA_aff_syn"
aff_exc_syn_seg_id = 5 # proximal apical dendrite
bg_exc_syn = "bg_AMPA_syn"
bg_exc_syn_seg_id = 7 # Basal dendrite
# Excitatory Parameters
XSCALE_ex = 24 #48
ZSCALE_ex = 24 #48
xSpacing_ex = 40 # 10^-6m
zSpacing_ex = 40 # 10^-6m
# Inhibitory Parameters
XSCALE_inh = 12 #24
ZSCALE_inh = 12 #24
xSpacing_inh = 80 # 10^-6m
zSpacing_inh = 80 # 10^-6m
numCells_ex = XSCALE_ex * ZSCALE_ex
numCells_inh = XSCALE_inh * ZSCALE_inh
# Connection probabilities (initial value)
connection_probability_ex_ex = 0.15
connection_probability_ex_inh = 0.45
connection_probability_inh_ex = 0.6
connection_probability_inh_inh = 0.6
# Generate excitatory cells
exc_pop = Population(id=exc_group,
component=exc_group_component,
type="populationList",
size=XSCALE_ex * ZSCALE_ex)
net.populations.append(exc_pop)
exc_pos = np.zeros((XSCALE_ex * ZSCALE_ex, 2))
for i in range(0, XSCALE_ex):
for j in range(0, ZSCALE_ex):
# create cells
x = i * xSpacing_ex
z = j * zSpacing_ex
index = i * ZSCALE_ex + j
inst = Instance(id=index)
exc_pop.instances.append(inst)
inst.location = Location(x=x, y=0, z=z)
exc_pos[index, 0] = x
exc_pos[index, 1] = z
# Generate inhibitory cells
inh_pop = Population(id=inh_group,
component=inh_group_component,
type="populationList",
size=XSCALE_inh * ZSCALE_inh)
net.populations.append(inh_pop)
inh_pos = np.zeros((XSCALE_inh * ZSCALE_inh, 2))
for i in range(0, XSCALE_inh):
for j in range(0, ZSCALE_inh):
# create cells
x = i * xSpacing_inh
z = j * zSpacing_inh
index = i * ZSCALE_inh + j
inst = Instance(id=index)
inh_pop.instances.append(inst)
inst.location = Location(x=x, y=0, z=z)
inh_pos[index, 0] = x
inh_pos[index, 1] = z
proj_exc_exc = Projection(id=net_conn_exc_exc,
presynaptic_population=exc_group,
postsynaptic_population=exc_group,
synapse=exc_exc_syn)
net.projections.append(proj_exc_exc)
proj_exc_inh = Projection(id=net_conn_exc_inh,
presynaptic_population=exc_group,
postsynaptic_population=inh_group,
synapse=exc_inh_syn)
net.projections.append(proj_exc_inh)
proj_inh_exc = Projection(id=net_conn_inh_exc,
presynaptic_population=inh_group,
postsynaptic_population=exc_group,
synapse=inh_exc_syn)
net.projections.append(proj_inh_exc)
proj_inh_inh = Projection(id=net_conn_inh_inh,
presynaptic_population=inh_group,
postsynaptic_population=inh_group,
synapse=inh_inh_syn)
net.projections.append(proj_inh_inh)
# Generate exc -> * connections
exc_exc_conn = np.zeros((numCells_ex, numCells_ex))
exc_inh_conn = np.zeros((numCells_ex, numCells_inh))
count_exc_exc = 0
count_exc_inh = 0
for i in range(0, XSCALE_ex):
for j in range(0, ZSCALE_ex):
x = i * xSpacing_ex
y = j * zSpacing_ex
index = i * ZSCALE_ex + j
#print("Looking at connections for exc cell at (%i, %i)"%(i,j))
# exc -> exc connections
conn_type = net_conn_exc_exc
for k in range(0, XSCALE_ex):
for l in range(0, ZSCALE_ex):
# calculate distance from pre- to post-synaptic neuron
xk = k * xSpacing_ex
yk = l * zSpacing_ex
distance = math.sqrt((x - xk)**2 + (y - yk)**2)
connection_probability = connection_probability_ex_ex * math.exp(
-(distance / (10.0 * xSpacing_ex))**2)
# create a random number between 0 and 1, if it is <= connection_probability
# accept connection otherwise refuse
a = random.random()
if 0 < a <= connection_probability:
index2 = k * ZSCALE_ex + l
count_exc_exc += 1
add_connection(proj_exc_exc, count_exc_exc,
exc_group, exc_group_component,
index, 0, exc_group,
exc_group_component, index2,
exc_exc_syn_seg_id)
exc_exc_conn[index, index2] = 1
# exc -> inh connections
conn_type = net_conn_exc_inh
for k in range(0, XSCALE_inh):
for l in range(0, ZSCALE_inh):
# calculate distance from pre- to post-synaptic neuron
xk = k * xSpacing_inh
yk = l * zSpacing_inh
distance = math.sqrt((x - xk)**2 + (y - yk)**2)
connection_probability = connection_probability_ex_inh * math.exp(
-(distance / (10.0 * xSpacing_ex))**2)
# create a random number between 0 and 1, if it is <= connection_probability
# accept connection otherwise refuse
a = random.random()
if 0 < a <= connection_probability:
index2 = k * ZSCALE_inh + l
count_exc_inh += 1
add_connection(proj_exc_inh, count_exc_inh,
exc_group, exc_group_component,
index, 0, inh_group,
inh_group_component, index2,
exc_inh_syn_seg_id)
exc_inh_conn[index, index2] = 1
inh_exc_conn = np.zeros((numCells_inh, numCells_ex))
inh_inh_conn = np.zeros((numCells_inh, numCells_inh))
count_inh_exc = 0
count_inh_inh = 0
for i in range(0, XSCALE_inh):
for j in range(0, ZSCALE_inh):
x = i * xSpacing_inh
y = j * zSpacing_inh
index = i * ZSCALE_inh + j
#print("Looking at connections for inh cell at (%i, %i)"%(i,j))
# inh -> exc connections
conn_type = net_conn_inh_exc
for k in range(0, XSCALE_ex):
for l in range(0, ZSCALE_ex):
# calculate distance from pre- to post-synaptic neuron
xk = k * xSpacing_ex
yk = l * zSpacing_ex
distance = math.sqrt((x - xk)**2 + (y - yk)**2)
connection_probability = connection_probability_inh_ex * math.exp(
-(distance / (10.0 * xSpacing_ex))**2)
# create a random number between 0 and 1, if it is <= connection_probability
# accept connection otherwise refuse
a = random.random()
if 0 < a <= connection_probability:
index2 = k * ZSCALE_ex + l
count_inh_exc += 1
add_connection(proj_inh_exc, count_inh_exc,
inh_group, inh_group_component,
index, 0, exc_group,
exc_group_component, index2,
inh_exc_syn_seg_id)
inh_exc_conn[index, index2] = 1
# inh -> inh connections
conn_type = net_conn_inh_inh
for k in range(0, XSCALE_inh):
for l in range(0, ZSCALE_inh):
# calculate distance from pre- to post-synaptic neuron
xk = k * xSpacing_inh
yk = l * zSpacing_inh
distance = math.sqrt((x - xk)**2 + (y - yk)**2)
connection_probability = connection_probability_inh_inh * math.exp(
-(distance / (10.0 * xSpacing_ex))**2)
# create a random number between 0 and 1, if it is <= connection_probability
# accept connection otherwise refuse
a = random.random()
if 0 < a <= connection_probability:
index2 = k * ZSCALE_inh + l
count_inh_inh += 1
add_connection(proj_inh_inh, count_inh_inh,
inh_group, inh_group_component,
index, 0, inh_group,
inh_group_component, index2,
inh_inh_syn_seg_id)
inh_inh_conn[index, index2] = 1
print(
"Generated network with %i exc_exc, %i exc_inh, %i inh_exc, %i inh_inh connections"
% (count_exc_exc, count_exc_inh, count_inh_exc, count_inh_inh))
####### Create Input ######
# Create a sine generator
sgE = SineGenerator(id="sineGen_0",
phase="0",
delay="0ms",
duration=str(self.sim_time) + "ms",
amplitude=str(self.Edrive_weight) + "nA",
period=str(self.Drive_period) + "ms")
sgI = SineGenerator(id="sineGen_1",
phase="0",
delay="0ms",
duration=str(self.sim_time) + "ms",
amplitude=str(self.Idrive_weight) + "nA",
period=str(self.Drive_period) + "ms")
nml_doc.sine_generators.append(sgE)
nml_doc.sine_generators.append(sgI)
# Create an input object for each excitatory cell
for i in range(0, XSCALE_ex):
exp_input = ExplicitInput(target="%s[%i]" % (exc_pop.id, i),
input=sgE.id)
net.explicit_inputs.append(exp_input)
# Create an input object for a percentage of inhibitory cells
input_probability = 0.65
for i in range(0, XSCALE_inh):
ran = random.random()
if 0 < ran <= input_probability:
inh_input = ExplicitInput(target="%s[%i]" % (inh_pop.id, i),
input=sgI.id)
net.explicit_inputs.append(inh_input)
# Define Poisson noise input
# Ex
#nml_doc.includes.append(IncludeType('Synapses/bg_AMPA_syn.synapse.nml'))
pfs1 = PoissonFiringSynapse(id="poissonFiringSyn1",
average_rate=str(self.bg_noise_frequency) +
"Hz",
synapse=bg_exc_syn,
spike_target="./%s" % bg_exc_syn)
nml_doc.poisson_firing_synapses.append(pfs1)
pfs_input_list1 = InputList(id="pfsInput1",
component=pfs1.id,
populations=exc_pop.id)
net.input_lists.append(pfs_input_list1)
for i in range(0, numCells_ex):
pfs_input_list1.input.append(
Input(id=i,
target='../%s/%i/%s' %
(exc_pop.id, i, exc_group_component),
segment_id=bg_exc_syn_seg_id,
destination="synapses"))
####### Write to file ######
print("Saving to file...")
nml_file = '../ACnet2_NML2/' + self.filename + '_doc' + '.net.nml'
writers.NeuroMLWriter.write(nml_doc, nml_file)
print("Written network file to: " + nml_file)
###### Validate the NeuroML ######
from neuroml.utils import validate_neuroml2
validate_neuroml2(nml_file)
print "-----------------------------------"
###### Output #######
# Output membrane potential
# Ex population
Ex_potentials = 'V_Ex'
ls.create_output_file(Ex_potentials,
"../ACnet2_NML2/Results/v_exc.dat")
for j in range(numCells_ex):
quantity = "%s[%i]/v" % (exc_pop.id, j)
v = 'v' + str(j)
ls.add_column_to_output_file(Ex_potentials, v, quantity)
# Inh population
#Inh_potentials = 'V_Inh'
#ls.create_output_file(Inh_potentials, "../ACnet2_NML2/Results/v_inh.dat")
#for j in range(numCells_inh):
# quantity = "%s[%i]/v"%(inh_pop.id, j)
# v = 'v'+str(j)
# ls.add_column_to_output_file(Inh_potentials,v, quantity)
# include generated network
ls.include_neuroml2_file(nml_file)
# Save to LEMS XML file
lems_file_name = ls.save_to_file(file_name='../ACnet2_NML2/LEMS_' +
self.filename + '.xml')
def _extract_pynn_components_to_neuroml(nl_model, nml_doc=None):
"""
Parse the NeuroMLlite description for cell, synapses and inputs described as
PyNN elements (e.g. IF_cond_alpha, DCSource) and parameters, and convert
these to the equivalent elements in a NeuroMLDocument
"""
if nml_doc == None:
from neuroml import NeuroMLDocument
nml_doc = NeuroMLDocument(id="temp")
for c in nl_model.cells:
if c.pynn_cell:
if nml_doc.get_by_id(c.id) == None:
import pyNN.neuroml
cell_params = c.parameters if c.parameters else {}
#print('------- %s: %s' % (c, cell_params))
for p in cell_params:
cell_params[p] = evaluate(cell_params[p],
nl_model.parameters)
#print('====== %s: %s' % (c, cell_params))
for proj in nl_model.projections:
synapse = nl_model.get_child(proj.synapse, 'synapses')
post_pop = nl_model.get_child(proj.postsynaptic,
'populations')
if post_pop.component == c.id:
#print("--------- Cell %s in post pop %s of %s uses %s"%(c.id,post_pop.id, proj.id, synapse))
if synapse.pynn_receptor_type == 'excitatory':
post = '_E'
elif synapse.pynn_receptor_type == 'inhibitory':
post = '_I'
for p in synapse.parameters:
cell_params['%s%s' %
(p, post)] = synapse.parameters[p]
temp_cell = eval('pyNN.neuroml.%s(**cell_params)' %
c.pynn_cell)
if c.pynn_cell != 'SpikeSourcePoisson':
temp_cell.default_initial_values[
'v'] = temp_cell.parameter_space['v_rest'].base_value
cell_id = temp_cell.add_to_nml_doc(nml_doc, None)
cell = nml_doc.get_by_id(cell_id)
cell.id = c.id
for s in nl_model.synapses:
if nml_doc.get_by_id(s.id) == None:
if s.pynn_synapse_type and s.pynn_receptor_type:
import neuroml
if s.pynn_synapse_type == 'cond_exp':
syn = neuroml.ExpCondSynapse(
id=s.id,
tau_syn=s.parameters['tau_syn'],
e_rev=s.parameters['e_rev'])
nml_doc.exp_cond_synapses.append(syn)
elif s.pynn_synapse_type == 'cond_alpha':
syn = neuroml.AlphaCondSynapse(
id=s.id,
tau_syn=s.parameters['tau_syn'],
e_rev=s.parameters['e_rev'])
nml_doc.alpha_cond_synapses.append(syn)
elif s.pynn_synapse_type == 'curr_exp':
syn = neuroml.ExpCurrSynapse(
id=s.id, tau_syn=s.parameters['tau_syn'])
nml_doc.exp_curr_synapses.append(syn)
elif s.pynn_synapse_type == 'curr_alpha':
syn = neuroml.AlphaCurrSynapse(
id=s.id, tau_syn=s.parameters['tau_syn'])
nml_doc.alpha_curr_synapses.append(syn)
for i in nl_model.input_sources:
#if nml_doc.get_by_id(i.id) == None:
if i.pynn_input:
import pyNN.neuroml
input_params = i.parameters if i.parameters else {}
exec('input__%s = pyNN.neuroml.%s(**input_params)' %
(i.id, i.pynn_input))
exec('temp_input = input__%s' % i.id)
pg_id = temp_input.add_to_nml_doc(nml_doc, None)
#for pp in nml_doc.pulse_generators:
# print('PG: %s: %s'%(pp,pp.id))
pg = nml_doc.get_by_id(pg_id)
pg.id = i.id
return nml_doc
cells = ['467703703', '323452245']
cells = [
'467703703', '471141261', '320207387', '471141261', '324493977',
'464326095'
]
cell_files = glob.glob('*.cell.nml')
cells = [c.split('.')[0] for c in cell_files]
problematic = [
'314642645', '469704261', '466664172', '314822529', '320654829',
'324025371', '397353539', '469704261', '469753383'
]
net_ref = "Net"
net_doc = NeuroMLDocument(id=net_ref)
net = Network(id=net_ref)
net_doc.networks.append(net)
def rotate_z(x, y, theta):
x_ = x * math.cos(theta) - y * math.sin(theta)
y_ = x * math.sin(theta) + y * math.cos(theta)
return x_, y_
count = 0
for cell in cells:
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_olm_cell():
"""Create the complete cell.
:returns: cell object
"""
nml_cell_doc = NeuroMLDocument(id="oml_cell")
cell = create_cell("olm")
nml_cell_file = cell.id + ".cell.nml"
# Add two soma segments
diam = 10.0
soma_0 = add_segment(cell,
prox=[0.0, 0.0, 0.0, diam],
dist=[0.0, 10., 0.0, diam],
name="Seg0_soma_0",
group="soma_0")
soma_1 = add_segment(cell,
prox=None,
dist=[0.0, 10. + 10., 0.0, diam],
name="Seg1_soma_0",
parent=soma_0,
group="soma_0")
# Add axon segments
diam = 1.5
axon_0 = add_segment(cell,
prox=[0.0, 0.0, 0.0, diam],
dist=[0.0, -75, 0.0, diam],
name="Seg0_axon_0",
parent=soma_0,
fraction_along=0.0,
group="axon_0")
axon_1 = add_segment(cell,
prox=None,
dist=[0.0, -150, 0.0, diam],
name="Seg1_axon_0",
parent=axon_0,
group="axon_0")
# Add 2 dendrite segments
diam = 3.0
dend_0_0 = add_segment(cell,
prox=[0.0, 20, 0.0, diam],
dist=[100, 120, 0.0, diam],
name="Seg0_dend_0",
parent=soma_1,
fraction_along=1,
group="dend_0")
dend_1_0 = add_segment(cell,
prox=None,
dist=[177, 197, 0.0, diam],
name="Seg1_dend_0",
parent=dend_0_0,
fraction_along=1,
group="dend_0")
dend_0_1 = add_segment(cell,
prox=[0.0, 20, 0.0, diam],
dist=[-100, 120, 0.0, diam],
name="Seg0_dend_1",
parent=soma_1,
fraction_along=1,
group="dend_1")
dend_1_1 = add_segment(cell,
prox=None,
dist=[-177, 197, 0.0, diam],
name="Seg1_dend_1",
parent=dend_0_1,
fraction_along=1,
group="dend_1")
# XXX: For segment groups to be correctly mapped to sections in NEURON,
# they must include the correct neurolex ID
for section_name in ["soma_0", "axon_0", "dend_0", "dend_1"]:
section_group = get_seg_group_by_id(section_name, cell)
section_group.neuro_lex_id = 'sao864921383'
den_seg_group = get_seg_group_by_id("dendrite_group", cell)
den_seg_group.includes.append(Include(segment_groups="dend_0"))
den_seg_group.includes.append(Include(segment_groups="dend_1"))
den_seg_group.properties.append(Property(tag="color", value="0.8 0 0"))
ax_seg_group = get_seg_group_by_id("axon_group", cell)
ax_seg_group.includes.append(Include(segment_groups="axon_0"))
ax_seg_group.properties.append(Property(tag="color", value="0 0.8 0"))
soma_seg_group = get_seg_group_by_id("soma_group", cell)
soma_seg_group.includes.append(Include(segment_groups="soma_0"))
soma_seg_group.properties.append(Property(tag="color", value="0 0 0.8"))
# Other cell properties
set_init_memb_potential(cell, "-67mV")
set_resistivity(cell, "0.15 kohm_cm")
set_specific_capacitance(cell, "1.3 uF_per_cm2")
# channels
# leak
add_channel_density(cell,
nml_cell_doc,
cd_id="leak_all",
cond_density="0.01 mS_per_cm2",
ion_channel="leak_chan",
ion_chan_def_file="olm-example/leak_chan.channel.nml",
erev="-67mV",
ion="non_specific")
# HCNolm_soma
add_channel_density(cell,
nml_cell_doc,
cd_id="HCNolm_soma",
cond_density="0.5 mS_per_cm2",
ion_channel="HCNolm",
ion_chan_def_file="olm-example/HCNolm.channel.nml",
erev="-32.9mV",
ion="h",
group="soma_group")
# Kdrfast_soma
add_channel_density(cell,
nml_cell_doc,
cd_id="Kdrfast_soma",
cond_density="73.37 mS_per_cm2",
ion_channel="Kdrfast",
ion_chan_def_file="olm-example/Kdrfast.channel.nml",
erev="-77mV",
ion="k",
group="soma_group")
# Kdrfast_dendrite
add_channel_density(cell,
nml_cell_doc,
cd_id="Kdrfast_dendrite",
cond_density="105.8 mS_per_cm2",
ion_channel="Kdrfast",
ion_chan_def_file="olm-example/Kdrfast.channel.nml",
erev="-77mV",
ion="k",
group="dendrite_group")
# Kdrfast_axon
add_channel_density(cell,
nml_cell_doc,
cd_id="Kdrfast_axon",
cond_density="117.392 mS_per_cm2",
ion_channel="Kdrfast",
ion_chan_def_file="olm-example/Kdrfast.channel.nml",
erev="-77mV",
ion="k",
group="axon_group")
# KvAolm_soma
add_channel_density(cell,
nml_cell_doc,
cd_id="KvAolm_soma",
cond_density="4.95 mS_per_cm2",
ion_channel="KvAolm",
ion_chan_def_file="olm-example/KvAolm.channel.nml",
erev="-77mV",
ion="k",
group="soma_group")
# KvAolm_dendrite
add_channel_density(cell,
nml_cell_doc,
cd_id="KvAolm_dendrite",
cond_density="2.8 mS_per_cm2",
ion_channel="KvAolm",
ion_chan_def_file="olm-example/KvAolm.channel.nml",
erev="-77mV",
ion="k",
group="dendrite_group")
# Nav_soma
add_channel_density(cell,
nml_cell_doc,
cd_id="Nav_soma",
cond_density="10.7 mS_per_cm2",
ion_channel="Nav",
ion_chan_def_file="olm-example/Nav.channel.nml",
erev="50mV",
ion="na",
group="soma_group")
# Nav_dendrite
add_channel_density(cell,
nml_cell_doc,
cd_id="Nav_dendrite",
cond_density="23.4 mS_per_cm2",
ion_channel="Nav",
ion_chan_def_file="olm-example/Nav.channel.nml",
erev="50mV",
ion="na",
group="dendrite_group")
# Nav_axon
add_channel_density(cell,
nml_cell_doc,
cd_id="Nav_axon",
cond_density="17.12 mS_per_cm2",
ion_channel="Nav",
ion_chan_def_file="olm-example/Nav.channel.nml",
erev="50mV",
ion="na",
group="axon_group")
nml_cell_doc.cells.append(cell)
pynml.write_neuroml2_file(nml_cell_doc, nml_cell_file, True, True)
return nml_cell_file
