def func2map(i):
cell = h.Import3d_SWC_read()
print(len(nfs))
print(i)
morphology_filename = nfs[i]
cell = h.Import3d_SWC_read()
cell.input(morphology_filename)
i3d = h.Import3d_GUI(cell, 0)
i3d.instantiate(None)
file_name = str(nfs[i]) + str('.wrl')
print(file_name)
ctng(show=False, magnification=200, file_name=file_name)
mlab.savefig(str(nfs[i]) + '.wrl')
def initialize_neuron(swc_path, file_paths):
h.load_file("stdgui.hoc")
h.load_file("import3d.hoc")
swc = h.Import3d_SWC_read()
swc.input(swc_path)
imprt = h.Import3d_GUI(swc, 0)
h("objref this")
imprt.instantiate(h.this)
print file_paths
for sec in h.allsec():
if sec.name().startswith("axon"):
h.delete_section(sec=sec)
axon = h.Section()
axon.L = 60
axon.diam = 1
axon.connect(h.soma[0], 0.5, 0)
h.define_shape()
for sec in h.allsec():
sec.insert('pas')
for seg in sec:
seg.pas.e = 0
for file_path in file_paths:
h.load_file(file_path.encode("ascii", "ignore"))
def build_morphology(self):
"""
Loads a 3D morphology of the neuron
"""
# Load hoc routines to import 3D morphologies
h.load_file('stdlib.hoc')
h.load_file("import3d.hoc")
cell = h.Import3d_SWC_read() # We have a .swc morphology file
#cell = h.Import3d_Neurolucida3() # We have an .asc morphology file
# Read the file and creates automatically section.connect(parent) statements
cell.input('Pyr_01.swc')
# Instantiate morphology for simulation and
# execute the connect statements and loads the cell into h scope
self.importedcell = h.Import3d_GUI(cell, 0)
self.importedcell.instantiate(None)
# Create python lists from the morphology with the different sections: soma, dend, apic and axon
self.soma = []
self.dend = []
self.apic = []
self.axon = [] # for the moment we will forget about the axon
self.all = []
for sec in h.allsec():
if 'soma' in sec.name():
self.soma.append(sec)
if 'dend' in sec.name():
self.dend.append(sec)
if 'apic' in sec.name():
self.apic.append(sec)
if 'axon' in sec.name():
self.axon.append(sec)
def load_morpho(self, filepath):
"""
:param filepath:
swc file path
"""
if not path.exists(filepath):
raise FileNotFoundError(filepath)
# SWC
fileformat = filepath.split('.')[-1]
if fileformat == 'swc':
morpho = h.Import3d_SWC_read()
# Neurolucida
elif fileformat == 'asc':
morpho = h.Import3d_Neurolucida3()
else:
raise Exception('file format `%s` not recognized' % filepath)
self.all = []
morpho.input(filepath)
i3d = h.Import3d_GUI(morpho, 0)
i3d.instantiate(self)
for hoc_sec in self.all:
name = hoc_sec.name().split('.')[-1] # eg. name="dend[19]"
if len(self.filter_secs(name)) > 0:
raise LookupError(
"The name '%s' is already taken by another section of the cell: '%s' of type: '%s'."
% (name, self.name, self.__class__.__name__))
sec = Sec(hoc_sec, cell=self, name=name)
self.secs.append(sec)
del self.all
def load_morphology(filename):
h = get_h()
swc = h.Import3d_SWC_read()
swc.input(str(filename))
imprt = h.Import3d_GUI(swc, 0)
h("objref this")
imprt.instantiate(h.this)
def import_swc_cell(path):
morph = h.Import3d_SWC_read()
morph.input(path)
i3d = h.Import3d_GUI(morph, 0)
i3d.instantiate(h.nil)
return i3d
def set_morphology(hobj, morph_file):
"""Set morphology for the cell from a swc
:param hobj: NEURON's cell object
:param morph_file: name of swc file containing 3d coordinates of morphology
"""
swc = h.Import3d_SWC_read()
swc.quiet = True
swc.input(str(morph_file))
imprt = h.Import3d_GUI(swc, 0)
imprt.quiet = True
imprt.instantiate(hobj)
def create_morph(swc_file, template):
h.load_file("import3d.hoc")
h.load_file("nrngui.hoc")
h("objref cell, tobj")
h.load_file(template + ".hoc")
h.execute("cell = new " + template + "()") #replace
nl = h.Import3d_SWC_read()
nl.quiet = 1
nl.input(swc_file)
imprt = h.Import3d_GUI(nl, 0)
imprt.instantiate(h.cell)
return h.cell
def _load_geometry(self):
'''Load the morphology-file in NEURON'''
try:
h.sec_counted = 0
except LookupError:
h('sec_counted = 0')
#import the morphology, try and determine format
fileEnding = self.morphology.split('.')[-1]
if fileEnding == 'hoc' or fileEnding == 'HOC':
h.load_file(1, self.morphology)
elif fileEnding == 'py':
geom_func = imp.load_source('shape_3D', self.morphology)
geom_func.shape_3D(self)
else:
neuron.h('objref this')
if fileEnding == 'asc' or fileEnding == 'ASC':
Import = h.Import3d_Neurolucida3()
if not self.verbose:
Import.quiet = 1
elif fileEnding == 'swc' or fileEnding == 'SWC':
Import = h.Import3d_SWC_read()
elif fileEnding == 'xml' or fileEnding == 'XML':
Import = h.Import3d_MorphML()
else:
raise ValueError(
'%s is not a recognised morphology file format!'
).with_traceback('Should be either .hoc, .asc, .swc, .xml!' %
self.morphology)
#assuming now that morphologies file is the correct format
try:
Import.input(self.morphology)
except:
if not hasattr(neuron, 'neuroml'):
raise Exception('Can not import, try and copy the ' + \
'nrn/share/lib/python/neuron/neuroml ' + \
'folder into %s' % neuron.__path__[0])
else:
raise Exception('something wrong with file, see output')
try:
imprt = neuron.h.Import3d_GUI(Import, 0)
except:
raise Exception('See output, try to correct the file')
imprt.instantiate(neuron.h.this)
h.define_shape()
self._create_sectionlists()
def swc2morph(swc_file: str):
"""
Generate morph sectioning data from .swc file.
"""
if HAS_NEURON:
h.load_file('stdlib.hoc')
h.load_file('import3d.hoc')
cell = h.Import3d_SWC_read()
cell.input(swc_file)
i3d = h.Import3d_GUI(cell, 0)
i3d.instantiate(None)
return neuron2morph(h)
else:
print("NEURON module is not available.")
def mkswc(swc_contents):
f = open("temp.tmp", "w")
f.write(swc_contents)
f.close()
swc = h.Import3d_SWC_read()
swc.input("temp.tmp")
ig = h.Import3d_GUI(swc)
ig.box.unmap()
h.doNotify()
ig.box.map("Import3d", 650, 200, -1, -1)
h.doNotify()
ig.instantiate(None)
print (swc_contents)
h.topology()
print (secinfo())
print ("\n\n\n")
return ig
def swc2morph(swc_file):
"""
Generate morph sectioning data from swc file.
"""
from neuron import h
h.load_file('stdlib.hoc')
h.load_file('import3d.hoc')
cell = h.Import3d_SWC_read()
cell.input(swc_file)
i3d = h.Import3d_GUI(cell, 0)
i3d.instantiate(None)
sections = {}
for sec in h.allsec():
sections[sec.name()] = {}
sections[sec.name()]["name"] = sec.name()
sr = h.SectionRef(sec=sec)
if sr.has_parent():
parent = sr.parent.name()
else:
parent = None
sections[sec.name()]["parent"] = parent
children = []
for child in sr.child:
children.append(child.name())
sections[sec.name()]["children"] = children
x = []
y = []
z = []
d = []
n3d = int(h.n3d())
sections[sec.name()]["points"] = []
for i in range(n3d):
sections[sec.name()]["points"].append(
[h.x3d(i), h.y3d(i), h.z3d(i),
h.diam3d(i)])
return sections
def _load_morphology(self, Jonas_cell):
''' internal function: loads morphology and creates section lists'''
fileEnding = self.morphology.split('.')[-1]
if fileEnding == 'hoc':
h.load_file(1, self.morphology)
else:
h('objref this') # why do i need this?
if fileEnding == 'swc':
Import = h.Import3d_SWC_read()
Import.input(self.morphology)
imprt = h.Import3d_GUI(Import, 0)
imprt.instantiate(h.this)
h.define_shape() # not sure what this does either
# set up section names: You need to clarify differences between h.allsec(), h.SectionList() - just makes a new #sectionlist - to do with if have multple cells?
self.all_section_names = []
self.sec_list = h.SectionList()
self.nsec = 0
self.dendrites = h.SectionList(
) # maybe these should be h.SectionList()? rather than python lists
self.axon = h.SectionList()
self.soma = h.SectionList()
self.root = 'none'
for sec in h.allsec():
self.all_section_names.append(sec.name())
self.sec_list.append(sec=sec)
self.nsec += 1
# Set up categories for different cell regions
if sec.name().find('soma') >= 0:
self.soma.append(sec=sec)
if sec.name().find('0') >= 0:
self.root = sec
if self.verbose:
print(sec.name(), 'is root')
elif Jonas_cell:
self.root = sec
if sec.name().find('dend') >= 0:
self.dendrites.append(sec=sec)
if sec.name().find('axon') >= 0:
self.dendrites.append(sec=sec)
def load_morpho(self, filepath, seg_per_L_um=1.0, add_const_segs=11):
"""
:param filepath:
swc file path
:param seg_per_L_um:
how many segments per single um of L, Length. Can be < 1. None is 0.
:param add_const_segs:
how many segments have each section by default.
With each um of L this number will be increased by seg_per_L_um
"""
if not path.exists(filepath):
raise FileNotFoundError()
# SWC
fileformat = filepath.split('.')[-1]
if fileformat == 'swc':
morpho = h.Import3d_SWC_read()
# Neurolucida
elif fileformat == 'asc':
morpho = h.Import3d_Neurolucida3()
else:
raise Exception('file format `%s` not recognized' % filepath)
morpho.input(filepath)
h.Import3d_GUI(morpho, 0)
i3d = h.Import3d_GUI(morpho, 0)
i3d.instantiate(self)
# add all SWC sections to self.secs; self.all is defined by SWC import
new_secs = {}
for sec in self.all:
name = sec.name().split('.')[-1] # eg. name="dend[19]"
new_secs[name] = sec
# change segment number based on seg_per_L_um and add_const_segs
for sec in new_secs.values():
add = int(sec.L * seg_per_L_um) if seg_per_L_um is not None else 0
sec.nseg = add_const_segs + add
self.secs.update(new_secs)
del self.all
def initialize_neuron(swc_path, file_paths):
""" Initialize neuron with morphology and load hoc files
Parameters
----------
swc_path : str
Path to SWC file
file_paths : list
List of str file paths of files for NEURON to load
"""
h.load_file("stdgui.hoc")
h.load_file("import3d.hoc")
swc = h.Import3d_SWC_read()
swc.input(swc_path)
imprt = h.Import3d_GUI(swc, 0)
h("objref this")
imprt.instantiate(h.this)
for sec in h.allsec():
if sec.name().startswith("axon"):
h.delete_section(sec=sec)
axon = h.Section()
axon.L = 60
axon.diam = 1
axon.connect(h.soma[0], 0.5, 0)
h.define_shape()
for sec in h.allsec():
sec.insert('pas')
for seg in sec:
seg.pas.e = 0
for file_path in file_paths:
h.load_file(file_path.encode("ascii", "ignore"))
def instantiate_swc(filename):
"""load an swc file and instantiate it"""
### I have done this already: ###########################################
## load the NEURON library (just in case h is defined otherwise elsewhere)
#from neuron import h, gui
## a helper library, included with NEURON
#h.load_file('import3d.hoc')
#########################################################################
# load the data. Use Import3d_SWC_read for swc, Import3d_Neurolucida3 for
# Neurolucida V3, Import3d_MorphML for MorphML (level 1 of NeuroML), or
# Import3d_Eutectic_read for Eutectic. (There is also an
# Import3d_Neurolucida_read for old Neurolucida files, but I've never seen one
# in practice; try Import3d_Neurolucida3 first.)
cell = h.Import3d_SWC_read()
cell.input(filename)
# easiest to instantiate by passing the loaded morphology to the Import3d_GUI
# tool; with a second argument of 0, it won't display the GUI, but it will allow
# use of the GUI's features
i3d = h.Import3d_GUI(cell, 0)
i3d.instantiate(None)
dx = 0.25
has_dx = False
if len(sys.argv) > 3 or (not has_dx and len(sys.argv) == 3):
filename_out = sys.argv[2]
from neuron import h
from mayavi import mlab
import geometry3d
import time
h.load_file('stdlib.hoc')
h.load_file('import3d.hoc')
if filename.lower()[-4:] == '.swc':
cell = h.Import3d_SWC_read()
else:
cell = h.Import3d_Neurolucida3()
cell.input(filename)
start = time.time()
tri_mesh = geometry3d.surface(cell, dx, n_soma_step=100, nouniform=nouniform)
mlab.triangular_mesh(tri_mesh.x, tri_mesh.y, tri_mesh.z, tri_mesh.faces, color=(1, 0, 0))
print 'time to construct mesh:', time.time() - start
start = time.time()
area = tri_mesh.area
print 'area: ', area
print 'time to compute area:', time.time() - start
start = time.time()
def load(filename,
fileformat=None,
cell=None,
use_axon=True,
xshift=0,
yshift=0,
zshift=0):
"""
Load an SWC from filename and instantiate inside cell. Code kindly provided
by @ramcdougal.
Args:
filename = .swc file containing morphology
cell = Cell() object. (Default: None, creates new object)
filename = the filename of the SWC file
use_axon = include the axon? Default: True (yes)
xshift, yshift, zshift = use to position the cell
Returns:
Cell() object with populated soma, axon, dend, & apic fields
Minimal example:
# pull the morphology for the demo from NeuroMorpho.Org
from PyNeuronToolbox import neuromorphoorg
with open('c91662.swc', 'w') as f:
f.write(neuromorphoorg.morphology('c91662'))
cell = load_swc(filename)
"""
if cell is None:
cell = Cell(name=string.join(filename.split('.')[:-1]))
if fileformat is None:
fileformat = filename.split('.')[-1]
name_form = {1: 'soma[%d]', 2: 'axon[%d]', 3: 'dend[%d]', 4: 'apic[%d]'}
# load the data. Use Import3d_SWC_read for swc, Import3d_Neurolucida3 for
# Neurolucida V3, Import3d_MorphML for MorphML (level 1 of NeuroML), or
# Import3d_Eutectic_read for Eutectic.
if fileformat == 'swc':
morph = h.Import3d_SWC_read()
elif fileformat == 'asc':
morph = h.Import3d_Neurolucida3()
else:
raise Exception('file format `%s` not recognized' % (fileformat))
morph.input(filename)
# easiest to instantiate by passing the loaded morphology to the Import3d_GUI
# tool; with a second argument of 0, it won't display the GUI, but it will allow
# use of the GUI's features
i3d = h.Import3d_GUI(morph, 0)
# get a list of the swc section objects
swc_secs = i3d.swc.sections
swc_secs = [swc_secs.object(i) for i in xrange(int(swc_secs.count()))]
# initialize the lists of sections
sec_list = {1: cell.soma, 2: cell.axon, 3: cell.dend, 4: cell.apic}
# name and create the sections
real_secs = {}
for swc_sec in swc_secs:
cell_part = int(swc_sec.type)
# skip everything else if it's an axon and we're not supposed to
# use it... or if is_subsidiary
if (not (use_axon) and cell_part == 2) or swc_sec.is_subsidiary:
continue
# figure out the name of the new section
if cell_part not in name_form:
raise Exception('unsupported point type')
name = name_form[cell_part] % len(sec_list[cell_part])
# create the section
sec = h.Section(name=name)
# connect to parent, if any
if swc_sec.parentsec is not None:
sec.connect(real_secs[swc_sec.parentsec.hname()](swc_sec.parentx))
# define shape
if swc_sec.first == 1:
h.pt3dstyle(1,
swc_sec.raw.getval(0, 0),
swc_sec.raw.getval(1, 0),
swc_sec.raw.getval(2, 0),
sec=sec)
j = swc_sec.first
xx, yy, zz = [swc_sec.raw.getrow(i).c(j) for i in xrange(3)]
dd = swc_sec.d.c(j)
if swc_sec.iscontour_:
# never happens in SWC files, but can happen in other formats supported
# by NEURON's Import3D GUI
raise Exception('Unsupported section style: contour')
if dd.size() == 1:
# single point soma; treat as sphere
x, y, z, d = [dim.x[0] for dim in [xx, yy, zz, dd]]
for xprime in [x - d / 2., x, x + d / 2.]:
h.pt3dadd(xprime + xshift, y + yshift, z + zshift, d, sec=sec)
else:
for x, y, z, d in zip(xx, yy, zz, dd):
h.pt3dadd(x + xshift, y + yshift, z + zshift, d, sec=sec)
# store the section in the appropriate list in the cell and lookup table
sec_list[cell_part].append(sec)
real_secs[swc_sec.hname()] = sec
cell.all = cell.soma + cell.apic + cell.dend + cell.axon
return cell
lng = []
GRs = []
mean_lng = []
max_lng = []
Total_lng = []
max_BO = []
mean_BO = []
max_PL = []
min_PL = []
mean_PL = []
symm = []
for i in range(len(qual_files_list)):
print qual_files_list[i]
h.load_file('import3d.hoc')
Import3d = h.Import3d_SWC_read()
Import3d.input(qual_files_list[i])
imprt = h.Import3d_GUI(Import3d, 0)
imprt.instantiate(None)
print qual_files_list[i]
num_axon_sec = 0
for sec in h.allsec():
if (str(sec)[0:2] == "ax"):
num_axon_sec = num_axon_sec + 1
tbl = []
for sec in range(num_axon_sec - 1):
tbl.append([
sec, h.axon[sec].L, h.axon[sec].diam,
def __init__(self, params=defparams, factors=None):
Import = h.Import3d_SWC_read()
Import.input(morphology + 'latest_WT-P270-20-14ak.swc')
imprt = h.Import3d_GUI(Import, 0)
imprt.instantiate(None)
h.define_shape()
# h.cao0_ca_ion = 2 # default in nrn
h.celsius = 35
self._create_sectionlists()
self._set_nsegs()
self.v_init = -80
for sec in self.allseclist:
sec.Ra = 150
sec.cm = 1.0
sec.insert('pas')
#sec.g_pas = 1e-5 # set using json file
sec.e_pas = -70 # -73
for sec in self.somalist:
sec.insert('naf')
sec.insert('kaf')
sec.insert('kas')
sec.insert('kdr')
sec.insert('kir')
sec.ena = 50
sec.ek = -85 # -90
sec.insert('cal12')
sec.insert('cal13')
sec.insert('car')
sec.insert('cadyn')
sec.insert('caldyn')
sec.insert('sk')
sec.insert('bk')
sec.insert('can')
#sec.kb_cadyn = 200.
for sec in self.axonlist:
sec.insert('naf')
#sec.insert('kaf')
sec.insert('kas')
#sec.insert('kdr')
#sec.insert('kir')
sec.ena = 50
sec.ek = -85 # -90
for sec in self.dendlist:
sec.insert('naf')
sec.insert('kaf')
sec.insert('kas')
sec.insert('kdr')
sec.insert('kir')
sec.ena = 50
sec.ek = -85 # -90
sec.insert('cal12')
sec.insert('cal13')
sec.insert('car')
sec.insert('cadyn')
sec.insert('caldyn')
sec.insert('sk')
sec.insert('bk')
sec.insert('cat32')
sec.insert('cat33')
with open(params) as file:
par = json.load(file)
self.distribute_channels("soma", "g_pas", 0, 1, 0, 0, 0, float(par['g_pas_all']['Value']))
self.distribute_channels("axon", "g_pas", 0, 1, 0, 0, 0, float(par['g_pas_all']['Value']))
self.distribute_channels("dend", "g_pas", 0, 1, 0, 0, 0, float(par['g_pas_all']['Value']))
self.distribute_channels("soma", "gbar_naf", 0, 1, 0, 0, 0, float(par['gbar_naf_somatic']['Value']),factors=factors)
self.distribute_channels("soma", "gbar_kaf", 0, 1, 0, 0, 0, float(par['gbar_kaf_somatic']['Value']))
self.distribute_channels("soma", "gbar_kas", 0, 1, 0, 0, 0, float(par['gbar_kas_somatic']['Value']))
self.distribute_channels("soma", "gbar_kdr", 0, 1, 0, 0, 0, float(par['gbar_kdr_somatic']['Value']))
self.distribute_channels("soma", "gbar_kir", 0, 1, 0, 0, 0, float(par['gbar_kir_somatic']['Value']))
self.distribute_channels("soma", "gbar_sk", 0, 1, 0, 0, 0, float(par['gbar_sk_somatic']['Value']))
self.distribute_channels("soma", "gbar_bk", 0, 1, 0, 0, 0, float(par['gbar_bk_somatic']['Value']))
#self.distribute_channels("axon", "gbar_naf", 0, 1, 0, 0, 0, float(par['gbar_naf_somatic']['Value']),factors=factors)
self.distribute_channels("axon", "gbar_naf", 3, 1, 1.1, 30, 500, float(par['gbar_naf_axonal']['Value']),factors=factors)
#self.distribute_channels("axon", "gbar_naf", 3, 1, 1.1, 20, 500, float(par['gbar_naf_axonal']['Value']))
#self.distribute_channels("dend", "gbar_naf", 1, 1, 1.2, 30, -5, float(par['gbar_naf_axonal']['Value']))
self.distribute_channels("axon", "gbar_kas", 0, 1, 0, 0, 0, float(par['gbar_kas_axonal']['Value']))
self.distribute_channels("dend", "gbar_naf", 1, 0.1, 0.9, 60.0, 10.0, float(par['gbar_naf_basal']['Value']),factors=factors)
self.distribute_channels("dend", "gbar_kaf", 1, 1, 0.5, 120, -30, float(par['gbar_kaf_basal']['Value']))
#self.distribute_channels("dend", "gbar_naf", 0, 1, -0.0072, 0, 0, float(par['gbar_naf_basal']['Value']))
#self.distribute_channels("dend", "gbar_kaf", 0, 1, 0.0167, 0, 0, float(par['gbar_kaf_basal']['Value']))
self.distribute_channels("dend", "gbar_kas", 2, 1, 9.0, 0.0, -5.0, float(par['gbar_kas_basal']['Value']))
self.distribute_channels("dend", "gbar_kdr", 0, 1, 0, 0, 0, float(par['gbar_kdr_basal']['Value']))
self.distribute_channels("dend", "gbar_kir", 0, 1, 0, 0, 0, float(par['gbar_kir_basal']['Value']))
self.distribute_channels("dend", "gbar_sk", 0, 1, 0, 0, 0, float(par['gbar_sk_basal']['Value']))
self.distribute_channels("dend", "gbar_bk", 0, 1, 0, 0, 0, float(par['gbar_bk_basal']['Value']))
self.distribute_channels("soma", "pbar_cal12", 0, 1, 0, 0, 0, 1e-5)
self.distribute_channels("soma", "pbar_cal13", 0, 1, 0, 0, 0, 1e-6)
self.distribute_channels("soma", "pbar_car", 0, 1, 0, 0, 0, 1e-4)
self.distribute_channels("soma", "pbar_can", 0, 1, 0, 0, 0, 3e-5)
#self.distribute_channels("soma", "kb_cadyn", 0, 1, 0, 0, 0, 200.0)
self.distribute_channels("dend", "pbar_cal12", 0, 1, 0, 0, 0, 1e-5)
self.distribute_channels("dend", "pbar_cal13", 0, 1, 0, 0, 0, 1e-6)
self.distribute_channels("dend", "pbar_car", 0, 1, 0, 0, 0, 1e-4)
self.distribute_channels("dend", "pbar_cat32", 1, 0, 1.0, 70.0, -4.5, 1e-7)
self.distribute_channels("dend", "pbar_cat33", 1, 0, 1.0, 70.0, -4.5, 1e-8)
def createPops(self):
# Get info from nodes files
for n in self.network_config['networks']['nodes']:
nodes_file = self.subs(n['nodes_file'])
node_types_file = self.subs(n['node_types_file'])
print("\nLoading nodes from %s and %s" %
(nodes_file, node_types_file))
h5file = tables.open_file(nodes_file, mode='r')
self.parse_group(h5file.root.nodes)
h5file.close()
self.nodes_info[self.current_node] = load_csv_props(
node_types_file)
self.current_node = None
pp.pprint(self.nodes_info)
# Use extracted node/cell info to create populations
for sonata_pop in self.cell_info:
# iterate over cell types -- will make one netpyne population per cell type
for type in self.cell_info[sonata_pop]['type_numbers']:
info = self.nodes_info[sonata_pop][type]
pop_name = info['pop_name'] if 'pop_name' in info else None
ref = info['model_name'] if 'model_name' in info else info[
'model_type']
model_type = info['model_type']
model_template = info[
'model_template'] if 'model_template' in info else '- None -'
if pop_name:
pop_id = '%s_%s' % (sonata_pop, pop_name)
else:
pop_id = '%s_%s_%s' % (sonata_pop, ref, type)
self.pop_id_from_type[(sonata_pop, type)] = pop_id
print(" - Adding population: %s which has model info: %s" %
(pop_id, info))
size = self.cell_info[sonata_pop]['type_numbers'][type]
# create netpyne pop
# Note: alternatively could create sim.net.params.popParams and then call sim.createPops()
popTags = {}
popTags['cellModel'] = model_type
popTags['cellType'] = info[
'model_name'] if 'model_name' in info else pop_id
popTags['numCells'] = size
popTags['pop'] = pop_id
popTags['ei'] = info['ei'] if 'ei' in info else ''
sim.net.pops[pop_id] = sim.Pop(pop_id, popTags)
# create population cell template (sections) from morphology and dynamics params files
if model_type == 'biophysical':
sim.net.pops[pop_id].cellModelClass = sim.CompartCell
# morphology
morphology_file = self.subs(
self.network_config['components']['morphologies_dir']
) + '/' + info['morphology'] + '.swc'
cellMorph = EmptyCell()
swcData = h.Import3d_SWC_read()
swcData.input(morphology_file)
swcSecs = h.Import3d_GUI(swcData, 0)
swcSecs.instantiate(cellMorph)
# replace axon with AIS stub
if self.replaceAxon:
fix_axon_peri_v2(cellMorph)
# extract netpyne parameters
secs, secLists, synMechs, globs = neuronPyHoc.getCellParams(
cellMorph)
if self.setdLNseg:
fix_sec_nseg(secs, sim.cfg.dL)
# create mapping of sec ids
secLists['SONATA_sec_id'] = [
sim.conversion.getSecName(sec) for sec in cellMorph.all
]
cellRule = {
'conds': {
'pop': pop_id
},
'secs': secs,
'secLists': secLists,
'globals': globs
}
# dynamics params
dynamics_params_file = self.subs(
self.network_config['components']
['biophysical_neuron_models_dir'] + '/' +
info['model_template'])
if info['model_template'].startswith('nml'):
dynamics_params_file = dynamics_params_file.replace(
'nml:', '')
nml_doc = read_neuroml2_file(dynamics_params_file)
cell_dynamic_params = nml_doc.cells[0]
cellRule = self.setCellRuleDynamicParamsFromNeuroml(
cell_dynamic_params, cellRule)
elif info['dynamics_params'].startswith('json'):
dynamics_params = load_json(dynamics_params_file)
pass
# set extracted cell params in cellParams rule
sim.net.params.cellParams[pop_id] = cellRule
# clean up before next import
del swcSecs, cellMorph
h.initnrn()
# create population of virtual cells (VecStims so can add spike times)
elif model_type == 'virtual':
popTags['cellModel'] = 'VecStim'
sim.net.pops[pop_id].cellModelClass = sim.PointCell
def __init__(self, params=None, \
morphology='latest_WT-P270-20-14ak.swc' ):
Import = h.Import3d_SWC_read()
Import.input(morphology)
imprt = h.Import3d_GUI(Import, 0)
imprt.instantiate(None)
h.define_shape()
# h.cao0_ca_ion = 2 # default in nrn
h.celsius = 35
self._create_sectionlists()
self._set_nsegs()
self.v_init = -80
for sec in self.somalist:
for mech in [
"naf", "kaf", "kas", "kdr", "kir", "cal12", "cal13", "can",
"car", "cadyn", "caldyn", "sk", "bk"
]:
sec.insert(mech)
for sec in self.axonlist:
for mech in ["naf", "kas"]:
sec.insert(mech)
for sec in self.dendlist:
for mech in [
"naf", "kaf", "kas", "kdr", "kir", "cal12", "cal13", "car",
"cat32", "cat33", "cadyn", "caldyn", "sk", "bk"
]:
sec.insert(mech)
for sec in self.allseclist:
sec.Ra = 150
sec.cm = 1.0
sec.insert('pas')
#sec.g_pas = 1e-5 # set using json file
sec.e_pas = -70 # -73
sec.ena = 50
sec.ek = -85 # -90
with open(params) as file:
par = json.load(file)
self.distribute_channels("soma", "g_pas", 0, 1, 0, 0, 0,
float(par['g_pas_all']['Value']))
self.distribute_channels("axon", "g_pas", 0, 1, 0, 0, 0,
float(par['g_pas_all']['Value']))
self.distribute_channels("dend", "g_pas", 0, 1, 0, 0, 0,
float(par['g_pas_all']['Value']))
self.distribute_channels("soma", "gbar_naf", 0, 1, 0, 0, 0,
float(par['gbar_naf_somatic']['Value']))
self.distribute_channels("soma", "gbar_kaf", 0, 1, 0, 0, 0,
float(par['gbar_kaf_somatic']['Value']))
self.distribute_channels("soma", "gbar_kas", 0, 1, 0, 0, 0,
float(par['gbar_kas_somatic']['Value']))
self.distribute_channels("soma", "gbar_kdr", 0, 1, 0, 0, 0,
float(par['gbar_kdr_somatic']['Value']))
self.distribute_channels("soma", "gbar_kir", 0, 1, 0, 0, 0,
float(par['gbar_kir_somatic']['Value']))
self.distribute_channels("soma", "gbar_sk", 0, 1, 0, 0, 0,
float(par['gbar_sk_somatic']['Value']))
self.distribute_channels("soma", "gbar_bk", 0, 1, 0, 0, 0,
float(par['gbar_bk_somatic']['Value']))
self.distribute_channels("axon", "gbar_naf", 3, 1, 1.1, 30, 500,
float(par['gbar_naf_axonal']['Value']))
self.distribute_channels("axon", "gbar_kas", 0, 1, 0, 0, 0,
float(par['gbar_kas_axonal']['Value']))
self.distribute_channels("dend", "gbar_naf", 1, 0.1, 0.9, 60.0, 10.0,
float(par['gbar_naf_basal']['Value']))
self.distribute_channels("dend", "gbar_kaf", 1, 1, 0.5, 120.0, -30.0,
float(par['gbar_kaf_basal']['Value']))
self.distribute_channels("dend", "gbar_kas", 2, 1, 9.0, 0.0, -5.0,
float(par['gbar_kas_basal']['Value']))
self.distribute_channels("dend", "gbar_kdr", 0, 1, 0, 0, 0,
float(par['gbar_kdr_basal']['Value']))
self.distribute_channels("dend", "gbar_kir", 0, 1, 0, 0, 0,
float(par['gbar_kir_basal']['Value']))
self.distribute_channels("dend", "gbar_sk", 0, 1, 0, 0, 0,
float(par['gbar_sk_basal']['Value']))
self.distribute_channels("dend", "gbar_bk", 0, 1, 0, 0, 0,
float(par['gbar_bk_basal']['Value']))
self.distribute_channels("soma", "pbar_cal12", 0, 1, 0, 0, 0, 1e-5)
self.distribute_channels("soma", "pbar_cal13", 0, 1, 0, 0, 0, 1e-6)
self.distribute_channels("soma", "pbar_car", 0, 1, 0, 0, 0, 1e-4)
self.distribute_channels("soma", "pbar_can", 0, 1, 0, 0, 0, 3e-5)
self.distribute_channels("dend", "pbar_cal12", 0, 1, 0, 0, 0, 1e-5)
self.distribute_channels("dend", "pbar_cal13", 0, 1, 0, 0, 0, 1e-6)
self.distribute_channels("dend", "pbar_car", 0, 1, 0, 0, 0, 1e-4)
self.distribute_channels("dend", "pbar_cat32", 1, 0, 1.0, 120.0, -30.0,
1e-7)
self.distribute_channels("dend", "pbar_cat33", 1, 0, 1.0, 120.0, -30.0,
1e-8)
def createPops(self):
# Get info from nodes files
for n in self.network_config['networks']['nodes']:
nodes_file = self.subs(n['nodes_file'])
node_types_file = self.subs(n['node_types_file'])
print("\nLoading nodes from %s and %s"%(nodes_file, node_types_file))
h5file = tables.open_file(nodes_file,mode='r')
self.parse_group(h5file.root.nodes)
h5file.close()
self.nodes_info[self.current_node] = load_csv_props(node_types_file)
self.current_node = None
pp.pprint(self.nodes_info)
# Use extracted node/cell info to create populations
for sonata_pop in self.cell_info:
# iterate over cell types -- will make one netpyne population per cell type
for type in self.cell_info[sonata_pop]['type_numbers']:
info = self.nodes_info[sonata_pop][type]
pop_name = info['pop_name'] if 'pop_name' in info else None
ref = info['model_name'] if 'model_name' in info else info['model_type']
model_type = info['model_type']
model_template = info['model_template'] if 'model_template' in info else '- None -'
if pop_name:
pop_id = '%s_%s'%(sonata_pop, pop_name)
else:
pop_id = '%s_%s_%s'%(sonata_pop,ref,type)
self.pop_id_from_type[(sonata_pop, type)] = pop_id
print(" - Adding population: %s which has model info: %s"%(pop_id, info))
size = self.cell_info[sonata_pop]['type_numbers'][type]
# create netpyne pop
# Note: alternatively could create sim.net.params.popParams and then call sim.createPops()
popTags = {}
popTags['cellModel'] = model_type
popTags['cellType'] = info['model_name'] if 'model_name' in info else pop_id
popTags['numCells'] = size
popTags['pop'] = pop_id
popTags['ei'] = info['ei'] if 'ei' in info else ''
sim.net.pops[pop_id] = sim.Pop(pop_id, popTags)
sim.net.params.popParams[pop_id] = popTags
# create population cell template (sections) from morphology and dynamics params files
if model_type == 'biophysical':
sim.net.pops[pop_id].cellModelClass = sim.CompartCell
# morphology
morphology_file = self.subs(self.network_config['components']['morphologies_dir']) +'/'+info['morphology'] + '.swc'
cellMorph = EmptyCell()
swcData = h.Import3d_SWC_read()
swcData.input(morphology_file)
swcSecs = h.Import3d_GUI(swcData, 0)
swcSecs.instantiate(cellMorph)
# replace axon with AIS stub
if self.replaceAxon:
fix_axon_peri(cellMorph)
# extract netpyne parameters
secs, secLists, synMechs, globs = neuronPyHoc.getCellParams(cellMorph)
# remove sec vinits since imported temporary cell with morph
for secName in secs:
del secs[secName]['vinit']
# fix nseg based on dL
if self.setdLNseg:
fix_sec_nseg(secs, sim.cfg.dL)
# invert y coordinates
# if self.swapSomaXY:
# swap_soma_xy(secs)
# make soma mid segment (x,y,z) = (0,0,0)
# somaLabel = next((s for s in secs.keys() if 'soma' in s), None)
# somaPtFirst = secs[somaLabel]['geom']['pt3d'][0]
# somaPtLast = secs[somaLabel]['geom']['pt3d'][-1]
# somaPt = [(p1+p2)/2.0 for p1,p2 in zip(somaPtFirst, somaPtLast)]
# for secLabel in secs:
# for ipt3d in range(len(secs[secLabel]['geom']['pt3d'])):
# origPt = secs[secLabel]['geom']['pt3d'][ipt3d]
# offsetX = 0.0
# if 'apic' in secLabel:
# offsetX = 0.0
# newpt = (origPt[0] - somaPt[0] + offsetX, origPt[1] - somaPt[1], origPt[2] - somaPt[2], origPt[3])
# secs[secLabel]['geom']['pt3d'][ipt3d] = newpt
# create mapping of sec ids
secLists['SONATA_sec_id'] = [sim.conversion.getSecName(sec) for sec in cellMorph.all]
cellRule = {'conds': {'pop': pop_id}, 'secs': secs, 'secLists': secLists, 'globals': globs}
# dynamics params
if info['model_template'].startswith('nml'):
dynamics_params_file = self.subs(self.network_config['components']['biophysical_neuron_models_dir']+'/'+info['model_template'])
dynamics_params_file = dynamics_params_file.replace('nml:', '')
#nml_doc = read_neuroml2_file(dynamics_params_file)
#cell_dynamic_params = nml_doc.cells[0]
cell_dynamic_params = NMLTree(dynamics_params_file)
cellRule = self.setCellRuleDynamicParamsFromNeuroml(cell_dynamic_params, cellRule)
elif info['dynamics_params'].endswith('json'):
dynamics_params_file = self.subs(self.network_config['components']['biophysical_neuron_models_dir']+'/'+info['dynamics_params'])
cell_dynamic_params = load_json(dynamics_params_file)
cellRule = self.setCellRuleDynamicParamsFromJson(cell_dynamic_params, cellRule)
# set extracted cell params in cellParams rule
sim.net.params.cellParams[pop_id] = cellRule
# clean up before next import
del swcSecs, cellMorph
h.initnrn()
# create population of virtual cells (VecStims so can add spike times)
elif model_type == 'virtual':
popTags['cellModel'] = 'VecStim'
sim.net.pops[pop_id].cellModelClass = sim.PointCell
def __init__(self, params=None,
morphology=None,
mechanisms=None,
variables=None,
replace_axon=True,
section=None
):
Import = h.Import3d_SWC_read()
Import.input(morphology)
imprt = h.Import3d_GUI(Import, 0)
imprt.instantiate(None)
h.define_shape()
self._set_nsegs()
self._create_sectionlists(replace_axon=replace_axon)
self._read_param_file(params)
# initialize soma as start point of distance function
#h.distance(sec=self.soma)
# Define origin of distance function
h.distance(0, 0.5, sec=self.soma)
# global params---hard coded for now. TODO find better solution
h.celsius = self.par['global']['celsius']['value']
self.v_init = self.par['global']['v_init']['value']
if mechanisms:
with open(mechanisms) as file:
mechLists = json.load(file)
# set channels and parameters
for region, seclist in zip(['somatic', 'axonal', 'basal'],[self.somalist, self.axonlist, self.dendlist]):
# if no mechanism file is passed assumes cadyn objects for spn.
if mechanisms: cl = mechLists[region]
elif region == 'axonal': cl = self.channel_lists[region]
else: cl = self.channel_lists[region]+["cadyn_ms", "caldyn_ms"]
for sec in seclist:
for mech in cl:
sec.insert(mech)
if not mechanisms or ('all' in mechLists and 'pas' in mechLists['all']):
sec.insert('pas')
sec.e_pas = self.par['section'][region]['e_pas']['value']
sec.g_pas = self.par['section'][region]['g_pas']['value']
# passive params (section params)---hard coded for now. TODO find better solution
sec.Ra = self.par['section'][region]['Ra']['value']
sec.cm = self.par['section'][region]['cm']['value']
sec.ena = self.par['section'][region]['ena']['value']
sec.ek = self.par['section'][region]['ek']['value']
# channels (range params)
for rp in self.par['range'][region].keys():
value = self.par['range'][region][rp]['value']
if self.par['range'][region][rp]['dist_type'] in ['exp','distance']:
function = self.par['range'][region][rp]['dist']
# get dist
for seg in sec:
distance = h.distance(1, seg.x, sec=sec)
val = eval( function.format(distance=distance, value=value) )
cmd = 'seg.{} = {}'.format(rp, val)
exec(cmd)
else:
val = value
for seg in sec:
cmd = 'seg.{} = {}'.format(rp, val)
exec(cmd)
def __init__(self, params=None, \
morphology=None, \
variables=None, \
section=None ):
Import = h.Import3d_SWC_read()
Import.input(morphology)
imprt = h.Import3d_GUI(Import, 0)
imprt.instantiate(None)
h.define_shape()
# h.cao0_ca_ion = 2 # default in nrn
h.celsius = 35
self._create_sectionlists()
self._set_nsegs(section=section)
self.v_init = -85
self.dendritic_channels = [
"naf",
"kaf",
"kas",
"kdr",
"kir",
"cal12",
"cal13",
"can",
"car",
"cav32",
"cav33",
"sk",
"bk" ]
self.somatic_channels = [
"naf",
"kaf",
"kas",
"kdr",
"kir",
"cal12",
"cal13",
"can",
"car",
"sk",
"bk" ]
self.axonal_channels = [
"naf",
"kas" ,
"Im" ]
# insert active mechanisms (related to channels) -------------
for sec in self.somalist:
for mech in self.somatic_channels+["cadyn", "caldyn"]:
sec.insert(mech)
for sec in self.axonlist:
for mech in self.axonal_channels:
sec.insert(mech)
for sec in self.dendlist:
for mech in self.dendritic_channels+["cadyn", "caldyn"]:
sec.insert(mech)
with open(params) as file:
par = json.load(file)
# set passive parameters --------------------------------------------
for sec in self.allseclist:
sec.Ra = 150
sec.cm = 1.0
sec.insert('pas')
#sec.g_pas = 1e-5 # set using json file
sec.e_pas = -70 # -73
sec.g_pas = float(par['g_pas_all']['Value'])
sec.ena = 50
sec.ek = -85 # -90
self.distribute_channels("soma", "gbar_naf", 0, 1, 0, 0, 0, float(par['gbar_naf_somatic']['Value']))
self.distribute_channels("soma", "gbar_kaf", 0, 1, 0, 0, 0, float(par['gbar_kaf_somatic']['Value']))
self.distribute_channels("soma", "gbar_kas", 0, 1, 0, 0, 0, float(par['gbar_kas_somatic']['Value']))
self.distribute_channels("soma", "gbar_kdr", 0, 1, 0, 0, 0, float(par['gbar_kdr_somatic']['Value']))
self.distribute_channels("soma", "gbar_bk", 0, 1, 0, 0, 0, float(par['gbar_bk_somatic' ]['Value']))
self.distribute_channels("soma", "pbar_cal12", 0, 1, 0, 0, 0, 1.34e-5)
self.distribute_channels("soma", "pbar_cal13", 0, 1, 0, 0, 0, 1.34e-6)
self.distribute_channels("soma", "pbar_car", 0, 1, 0, 0, 0, 1.34e-4)
self.distribute_channels("soma", "pbar_can", 0, 1, 0, 0, 0, 4e-5)
self.distribute_channels("dend", "gbar_kdr", 0, 1, 0, 0, 0, float(par['gbar_kdr_basal']['Value']))
self.distribute_channels("dend", "gbar_bk", 0, 1, 0, 0, 0, float(par['gbar_bk_basal' ]['Value']))
self.distribute_channels("dend", "pbar_cal12", 0, 1, 0, 0, 0, 1e-5)
self.distribute_channels("dend", "pbar_cal13", 0, 1, 0, 0, 0, 1e-6)
self.distribute_channels("dend", "pbar_car", 0, 1, 0, 0, 0, 1e-4)
self.distribute_channels("axon", "gbar_kas", 0, 1, 0, 0, 0, float(par['gbar_kas_axonal']['Value']))
self.distribute_channels("axon", "gbar_naf", 3, 1, 1.1, 30, 500, float(par['gbar_naf_axonal']['Value']))
self.distribute_channels("axon", "gbar_Im", 0, 1, 0, 0, 0, 1.0e-3)
# in ephys step functions are not supported so something like below formula will be used instead.
#self.distribute_channels("axon", "gbar_naf", 1, 1, 0.1, 30, -1, float(par['gbar_naf_axonal']['Value']))
#(1 + 0.9/(1 + math.exp(({distance}-30.0)/-1.0) ))
if variables:
self.distribute_channels("dend", "gbar_naf", 1, 1.0-variables['naf'][1], \
variables['naf'][1], \
variables['naf'][2], \
variables['naf'][3], \
np.power(10,variables['naf'][0])*float(par['gbar_naf_basal']['Value']))
self.distribute_channels("dend", "gbar_kaf", 1, 1.0, \
variables['kaf'][1], \
variables['kaf'][2], \
variables['kaf'][3], \
np.power(10,variables['kaf'][0])*float(par['gbar_kaf_basal']['Value']))
self.distribute_channels("dend", "gbar_kas", 1, 0.1, \
0.9, \
variables['kas'][1], \
variables['kas'][2], \
np.power(10,variables['kas'][0])*float(par['gbar_kas_basal']['Value']))
self.distribute_channels("dend", "gbar_kir", 0, np.power(10,variables['kir'][0]), 0, 0, 0, float(par['gbar_kir_basal' ]['Value']))
self.distribute_channels("soma", "gbar_kir", 0, np.power(10,variables['kir'][0]), 0, 0, 0, float(par['gbar_kir_somatic']['Value']))
self.distribute_channels("dend", "gbar_sk", 0, np.power(10,variables['sk' ][0]), 0, 0, 0, float(par['gbar_sk_basal' ]['Value']))
self.distribute_channels("soma", "gbar_sk", 0, np.power(10,variables['sk' ][0]), 0, 0, 0, float(par['gbar_sk_somatic' ]['Value']))
self.distribute_channels("dend", "pbar_can", 1, 1.0-variables['can'][1], \
variables['can'][1], \
variables['can'][2], \
variables['can'][3], \
np.power(10,variables['can'][0]))
self.distribute_channels("dend", "pbar_cav32", 1, 0, \
1, \
variables['c32'][1], \
variables['c32'][2], \
np.power(10,variables['c32'][0]))
self.distribute_channels("dend", "pbar_cav33", 1, 0, \
1, \
variables['c33'][1], \
variables['c33'][2], \
np.power(10,variables['c33'][0]))
else:
self.distribute_channels("dend", "gbar_naf", 1, 0.1, 0.9, 60.0, 10.0, float(par['gbar_naf_basal']['Value']))
self.distribute_channels("dend", "gbar_kaf", 1, 1, 0.5, 120.0, -30.0, float(par['gbar_kaf_basal']['Value']))
self.distribute_channels("dend", "gbar_kas", 2, 1, 9.0, 0.0, -5.0, float(par['gbar_kas_basal']['Value']))
self.distribute_channels("dend", "gbar_kir", 0, 1, 0, 0, 0, float(par['gbar_kir_basal']['Value']))
self.distribute_channels("soma", "gbar_kir", 0, 1, 0, 0, 0, float(par['gbar_kir_somatic']['Value']))
self.distribute_channels("dend", "gbar_sk", 0, 1, 0, 0, 0, float(par['gbar_sk_basal']['Value']))
self.distribute_channels("soma", "gbar_sk", 0, 1, 0, 0, 0, float(par['gbar_sk_basal']['Value']))
self.distribute_channels("dend", "pbar_can", 0, 1, 0, 0, 0, 1e-7)
self.distribute_channels("dend", "pbar_cav32", 1, 0, 1.0, 120.0, -30.0, 1e-7)
self.distribute_channels("dend", "pbar_cav33", 1, 0, 1.0, 120.0, -30.0, 1e-8)
