def __init__(self):
h.xopen("purkinje_reduced_PPR model.hoc")
# There are thirtyeight compartments and the following are chosen as
# attributes to this python class for potential recording
self.soma = h.Soma
#
dend_root = h.MainDendrite # len(h.MainDendrite) -> 1
dend_sm_distalshort = h.SmoothDistalDendriteshort # len() -> 3
dend_sm_distallong = h.SmoothDistalDendritelong # len() -> 3
dend_sp_distal = h.SpinyDistalDendrite # len() -> 3
dend_adj = h.AdjacentDendrite # len() -> 15
spine_neck = h.SpineNeck # len() -> 1
spine = h.Spine # len() -> 1
#
self.dend_root = dend_root[0]
self.dend_sm = [
dend_sm_distalshort[randint(0,
len(dend_sm_distalshort) - 1)],
dend_sm_distallong[randint(0,
len(dend_sm_distallong) - 1)]
][randint(0, 1)]
self.dend_sp = [
dend_sp_distal[randint(0,
len(dend_sp_distal) - 1)],
dend_adj[randint(0,
len(dend_adj) - 1)]
][randint(0, 1)]
self.spine_head = spine[0]
self.spine_neck = spine_neck[0]
def main(template_path, forest_path, synapses_path, config_path):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
env = Env(comm=comm, config_file=config_path, template_paths=template_path)
h('objref nil, pc, tlog, Vlog, spikelog')
h.load_file("nrngui.hoc")
h.xopen("./tests/rn.hoc")
h.xopen(template_path + '/BasketCell.hoc')
pop_name = "BC"
gid = 1039000
(trees_dict, _) = read_tree_selection(forest_path,
pop_name, [gid],
comm=env.comm)
synapses_dict = read_cell_attribute_selection(synapses_path,
pop_name, [gid],
"Synapse Attributes",
comm=env.comm)
(_, tree) = next(trees_dict)
(_, synapses) = next(synapses_dict)
v_init = -60
template_class = getattr(h, "BasketCell")
ap_test(template_class, tree, v_init)
passive_test(template_class, tree, v_init)
ap_rate_test(template_class, tree, v_init)
fi_test(template_class, tree, v_init)
gap_junction_test(env, template_class, tree, v_init)
synapse_test(template_class, gid, tree, synapses, v_init, env)
def main(template_path, forest_path, synapses_path, connections_path, config_path):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
env = Env(comm=comm, config_file=config_path, template_paths=template_path)
h('objref nil, pc, tlog, Vlog, spikelog')
h.load_file("nrngui.hoc")
h.xopen ("./tests/rn.hoc")
h.xopen(template_path+'/HICAPCell.hoc')
pop_name = "HCC"
gid = 1043250
(trees_dict,_) = read_tree_selection (forest_path, pop_name, [gid], comm=env.comm)
(_, tree) = next(trees_dict)
v_init = -67
template_class = getattr(h, "HICAPCell")
passive_test(template_class, tree, v_init)
ap_test(template_class, tree, v_init)
ap_rate_test(template_class, tree, v_init)
fi_test(template_class, tree, v_init)
if synapses_path and connections_path:
synapses_iter = read_cell_attribute_selection (synapses_path, pop_name, [gid],
"Synapse Attributes", comm=env.comm)
(_, synapses_dict) = next(synapses_iter)
connections = read_graph_selection(file_name=connections_path, selection=[gid],
namespaces=['Synapses', 'Connections'], comm=env.comm)
synapse_test(template_class, gid, tree, synapses_dict, connections, v_init, env)
def __init__(self):
############################# MORPHOLOGY ##############################
h.xopen("Golgi_template.hoc") # Within it is the function Goc() which
# creates a soma (1 section, 1 segment = 1 compartment) and
# three dendrites (3 section, each with 10 compartments = 10 segments)
# notice the absence of axon
h("objref GoC") # this will make available: h.GoC.soma
h("GoC = new Goc(0,0,0)") # h.GoC.axon and h.GoC.dend
# Notice three arguments vs GoC2007Solinas, this is because here the
# the template by Souza & Schutter are meant for the network.
# The arguments are basically the x,y,z-coordinates.
# below are the regions set as attribute to this python class
self.soma = h.GoC.soma
self.dend = h.GoC.dend # len(h.GoC.dend) -> 3
############################# PARAMETERS ##############################
# using the parameters given in network.hoc (under Golgi cell layer)
#self.soma.el_Golgi_lkg = -55. # already by default
self.soma.ko = 5
#self.soma.ki = 140 # already by default
self.soma.nao = 145
#self.soma.nai = 5 # already by default
#
# Based on the paper http://dx.doi.org/10.1186/2042-1001-1-7
# under Methods section, Model GoC's sub-section
# "We adopted a resting membrane potential of -60 mV and a
# passive leakage current with reversal porential at -44.5 mV."
h("v_init = -60.")
self.soma.el_Golgi_lkg = -44.5
[ setattr(d, "el_Golgi_lkg", -44.5) for d in self.dend ]
def __init__(self):
h.xopen("granule2.proto") # Within it parameters are defined and
# its geometry is set by loading granuel.nrn
# There are thirteen compartments and the following are chosen as
# attributes to this python class for potential recording
self.soma = h.soma
self.dend = h.dendrite # len(h.dendrite) -> 4
self.bulb = h.bulb # len(h.bulb) -> 4
def __init__(self):
h.xopen("resurgesim.hoc")
# Since it has only one compartment the attribute for this
# python class for recording is just soma
self.soma = h.soma
# based on the readme.txt
h.dt = 0.025
h.steps_per_ms = 1 / h.dt
def __init__(self):
############################# MORPHOLOGY ##############################
h("GJ = 1") # 0 for no gap-junctions between GoCs
# 0 or 1, GJ must be set prior to loading network.hoc
h.xopen("network.hoc") # Within it is the function Goc() which
# below are the components set as attribute to this python class
self.GrC = h.GrC # len(h.GrC) -> 8100
self.GoC = h.GoC # len(h.GoC) -> 225
self.MF = h.fiber # len(h.fiber) -> 900
def __init__(self):
h.xopen("purkinje.hoc")
# There are thirteen compartments and the following are chosen as
# attributes to this python class for potential recording
self.soma = h.soma
#
dend_sm = h.SmoothDendrite # len(h.SmoothDendrite) -> 85
dend_sp = h.SpinyDendrite # len(h.SpinyDendrite) -> 1002
#
self.dend_sm = dend_sm[randint(0, len(dend_sm) - 1)]
self.dend_sp = dend_sp[randint(0, len(dend_sp) - 1)]
def __init__(self):
h("load_file(\"nrngui.hoc\")") #h("proc set_ra() {}")
# this step is needed otherwise there is RuntimeError
# for the undefined function when loading 2_compartment.hoc where this
# function is called at line 34. The above step defines the function set_ra()
h.xopen("2_compartment.hoc")
# The 1087 out of 1088 compartments are the compartment of dendites,
# smooth and spiny. These 1087 are reduced to a compartment. Thus,
# attributes to this python class for potential recording are
self.soma = h.soma
self.dend = h.Couple # h.Couple.nseg -> 1
def __init__(self):
h("objref cvode") # initialize multiple order variable time step
h("cvode = new CVode()"
) # integration method as it is called in hoc file
h.xopen("start.hoc")
# nsyn1 = 4 at line 11
# ncells = 1 at line 79
# nmossy = 4 at line 80
# Notice that one should try to have nmossy = nsyn1 =/= NumSyn (synapse/MF)
self.cell = h.GrCell[0] # len(h.GrCell) -> 1
self.mossy = h.Mossy # len(h.Mossy) -> 4
def __init__(self):
############################# MORPHOLOGY ##############################
h.xopen(
"granule_template.hoc") # Within it is the function grc() which
# creates a soma (1 section, 1 segment = 1 compartment)
h("objref GrC") # this will make available: h.GrC.soma
h("GrC = new grc(0,0,0)")
# Notice three arguments, this is because here the
# the template by Souza & Schutter are meant for the network.
# The arguments are basically the x,y,z-coordinates.
# below are the regions set as attribute to this python class
self.soma = h.GrC.soma
def __init__(self):
h.xopen(
"DCN_simulation.hoc") # Within it, after defining the parameters
# it loads: DCN_morph.hoc, DCN_mechs.hoc and DCN_run.hoc
# (inside DCN_run.hoc, DCN_recording.hoc is loaded)
# NOTE: for our application none of the functions within DCN_run.hoc and
# DCN_recording.hoc will be invoked and hence are of direct interest.
# since there are 517 compartments with the following reference groups:
# h.soma, h.axHillock, h.axIniSeg, h.axNode,
# h.proxDend, h.distDend, h.excSynapseComps, h.inhSynapseComps
# only those used in DCN_recording.hoc have its attribute to this python class
self.soma = h.soma
self.gaba = h.gaba # len(h.gaba) -> 450
def __init__(self):
h.xopen("model2.hoc")
# The following compartments of the Deep Cerebellar Neuron if available
# as attributes
self.soma = h.soma # 1 compartment
# there is also only 1 compartment for axon hillock but it is a SectionList
self.axon_hillock = [sec for sec in h.axHillock][0]
# there are 10 compartments of axon initial segment
self.axon_initial = [sec for sec in h.axIniSeg]
# there are 20 compartments for axon node
self.axon_node = [sec for sec in h.axNode]
# there are 83 compartments for the proximal dendrite
self.dend_proximal = [sec for sec in h.proxDend]
# there are 402 compartments for the distal dendrite
self.dend_distal = [sec for sec in h.distDend]
def __init__(self):
############################# MORPHOLOGY ##############################
h.xopen("Golgi_template.hoc") # Within it is the function Goc() which
# creates a soma (1 section, 1 segment = 1 compartment),
# an axon (1 section, 100 segment = 100 compartments) and
# three dendrites (3 section, each with 10 compartments = 10 segments)
h("objref Golgi[1]") # this will make available: h.Golgi[0].soma
h("Golgi[0] = new Goc()") # h.Golgi[0].axon and h.Golgi[0].dend
############################# PARAMETERS ##############################
h.xopen("Synapses.hoc") # synapse parameters are set on h.Golgi[0]
# below are the regions set as attribute to this python class
self.soma = h.Golgi[0].soma
self.axon = h.Golgi[0].axon
self.dend = h.Golgi[0].dend # len(h.Golgi[0].dend -> 3
def __init__(self):
h.xopen("full_CP.hoc")
# There are 1088 compartments and the following are chosen as
# attributes to this python class for potential recording
self.soma = h.soma
#
dend_sm = h.sm # len(h.sm) -> 85
#self.dend_sp1 = h.spn1 # len() -> 1
#but there are 86 such spiny dendrites and unlike h.sm they are separate
dend_sp = []
for i in range(1, 86 + 1):
dend_sp.append(getattr(h, "spn" + str(i))[0]) # since nseg = 1
#
self.dend_sm = dend_sm[randint(0, len(dend_sm) - 1)]
self.dend_sp = dend_sp[randint(0, len(dend_sp) - 1)]
def __init__(self, hoc_model, path_mods, setting):
"""
Parameters
----------
hoc_model : str
the path to model in .hoc
path_mods : str
the path to the directory containing the .mod files
setting : dict
the dictionary containing setting
"""
self.setting = setting
h.nrn_load_dll(path_mods + 'nrnmech.dll')
h.xopen(hoc_model)
self.CA1 = h.CA1_PC_Tomko()
self.soma = self.CA1.soma[0]
self.all = list(self.CA1.all)
self.apical = list(self.CA1.apical)
self.basal = list(self.CA1.basal)
self.v_vec = h.Vector().record(self.soma(0.5)._ref_v)
self.t_vec = h.Vector().record(h._ref_t)
self.t_rs_vec = h.Vector().record(
h._ref_t, self.setting['simulation']['RECORDING_STEP'])
self.cai_vecs = {}
self.cal2_ica_vecs = {}
self.dend_vecs = {}
self.ina_vecs = {}
self.nmda_ica_vecs = {}
self.apc = None
self.apc_vec = h.Vector()
self.bcm = None
self.alpha_scout_vec = h.Vector()
self.d_vec = h.Vector()
self.p_vec = h.Vector()
self.syn_AMPA_count = 0
self.syn_NMDA_count = 0
self.synapses = {}
self.net_cons = []
self.net_stims = []
self.vBoxShape = None
self.shplot = None
def create_cell(name,
mechparams=None,
Ra=None,
calc_nseg=False,
filename=None):
"""Make a copy of the GGN and insert mechanisms based on mechparams.
mechparams: dict of dicts containing parameters for
mechanisms. Each entry should be
name: { param: value, param: value, ...}
Other than name, the param keys depend on the mechanism
definition. For example, the predefined passive mechanism has name
`pas` and it defines g and e as parameters. The corresponding dict entry
will be `'pas': {'g': 2.5e-4, 'e'=-65.0}` for inserting
passive conductance with density 2.5e-4 S/cm2 on each compartment
and the reversal potential -65 mV.
"""
if not hasattr(h, name):
if filename is None:
raise Exception('Cell not preloaded. Specify template filename')
h.xopen(filename)
cell = eval('h.{}()'.format(name))
if mechparams is None:
mechparams = {}
print(mechparams)
mech_dict = ephys.create_mechs(mechparams)
insert_mechanisms(cell, mech_dict.values())
if (Ra is not None) or calc_nseg:
cell.soma.push()
ordered_tree = h.SectionList()
ordered_tree.wholetree()
h.pop_section()
if not isinstance(Ra, float): # Assume pint.UnitRegistry().Quantity
Ra = ephys.Q_(Ra).to('ohm*cm').m
for sec in ordered_tree:
sec.push()
if Ra is not None:
sec.Ra = Ra
# lambda_f = np.sqrt(sec.diam/(4 * sec.Ra * sec.g_pas))
# nseg = int(10 * sec.L / lambda_dc + 0.5)
nseg = int((sec.L / (0.1 * h.lambda_f(100)) + 0.999) / 2) * 2 + 1
sec.nseg = nseg
h.pop_section()
return cell
def __init__(self):
h.xopen("purkinje.hoc")
# There are 1088 compartments and the following are chosen as
# attributes to this python class for potential recording
self.soma = h.somaA
self.ais = h.AIS
# Based on last 50 or so lines of Purkinje19b972-1.nrn
self.dend_root = h.dendA1_0 # see Fig.2A of paper
# Reverse eng. from Purkinje19b972-1.nrn and dendv_arnd21.ses
self.dend_sm = [sec for sec in h.maindend] # len(dend_sm) -> 30
self.dend_sp = [sec for sec in h.spinydend] # len(dend_sp) -> 1105
# note that for either self.dend_sm or self.dend_sp
# the first element of its list is a dendrite section closest to soma
# and last element is the dendrite section farthest away.
# also potentially
self.cf = [sec for sec in h.cf] # for climbing fibre
self.pf = [sec for sec in h.pf] # for parallel fibre
self.bs_cf = [sec
for sec in h.bs] # for branch-specific climbing fibre
def load_3dcell(filename, max_compartment_size=20):
dendritic = h.SectionList()
for sec in h.allsec():
del sec #is this correct?
h.xopen(filename)
h('access soma')
#make sure no compartments exceed 50 uM length
for sec in h.allsec():
diam_save = sec.diam #sec.diam makes no sense does it since diam is a segment property
n = sec.L / max_compartment_size
n_truncated = int(n)#use a truncating division to avoid error
sec.nseg = n_truncated + 1
if h.n3d() == 0:
sec.diam = diam_save
dendritic.append()
return dendritic
def main(template_path,forest_path):
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
h('objref nil, pc, tlog, Vlog, spikelog')
h.load_file("nrngui.hoc")
h.xopen("./lib.hoc")
h.xopen ("./tests/rn.hoc")
h.xopen(template_path+'/MOPPCell.hoc')
h.pc = h.ParallelContext()
popName = "MOPP"
(trees,_) = read_tree_selection (comm, forest_path, popName, [1052650])
tree = next(iter(viewvalues(trees)))
passive_test(tree,-60)
ap_rate_test(tree,-60)
# Email:[email protected] # Model published as [Diwakar et al., 2011, PLoS ONE] #Shyam Diwakar, Paola Lombardo, Sergio Solinas, Giovanni Naldi, Egidio D'Angelo. "Local field potential modeling predicts dense activation in cerebellar granule cells clusters under LTP and LTD control", PLoS ONE, 2011. from neuron import h import os import subprocess from tkinter import * h.load_file("nrngui.hoc") h.load_file("Start.hoc") h.xopen("Record_vext.hoc") print("For run the Invitro LFP simulation click on the Invitro button in the panel\n") print("For run the Invivo LFP simulation click on the Invivo button in the panel\n") def invitroplot(): h.Invitro() print('\n\n\n') print('Plotting invitro......') print('Please wait few minutes......... :)') os.chdir("data/Invitro/") return_value = subprocess.check_output('python3 testconv.py', shell=True) print(return_value.decode('utf-8')) print("Quit and restart before running for in vivo traces... ")
# "Encoding and retrieval in a model of the hippocampal CA1 microcircuit",
# Hippocampus, in press, DOI 10.1002/hipo.20661, 2009.
from neuron import h, gui
import numpy as np
import random
import math
import sys
h("strdef simname")
h("batchflag = 0")
h("plotflag = 0")
h("scaleDown = 1")
h("scaleEScon = 1") # Scaling argument for calcium channel conductances
h.simname = "test"
if len(sys.argv) > 1:
h.simname = sys.argv[1]
if len(sys.argv) > 2:
h.batchflag = int(sys.argv[2])
if len(sys.argv) > 3:
h.plotflag = int(sys.argv[3])
if len(sys.argv) > 4:
h.scaleDown = float(sys.argv[4])
if len(sys.argv) > 5:
h.scaleEScon = float(sys.argv[5])
print("h.simname = ", h.simname)
h.xopen("HAM_StoRec_ser_new.hoc")
# CA1 heteroassociative memory network: Storage and recall
# CA1 PCs, BCs, AACs, BSCs and OLMs (using moderate cell models)
# EC, CA3 (excitatory) and Septal (inhibitory) inputs
# Cycle is: Recall-Storage-Recall etc
# Serial code adapted from Hines' ran3ser.hoc
# VCU & BPG 8-1-09
# Results reported in V. Cutsuridis, S. Cobb and B.P. Graham,
# "Encoding and retrieval in a model of the hippocampal CA1 microcircuit",
# Hippocampus, in press, DOI 10.1002/hipo.20661, 2009.
from neuron import h, gui
import numpy as np
import random
import math
h.xopen("HAM_StoRec_ser.hoc")
def init_cell(cell_path, spines=True):
"""
cell: path to cell definiton
"""
h("forall delete_section()")
# ---- conditions ----
h.celsius = temp
# ---- soma & dendrite ----
h.xopen(cell_path)
soma = h.soma
dendritic = []
# segment lengths should be not longer than 50um
# contains soma!
for sec in h.allsec():
diam = sec.diam
n = sec.L / 50.0 + 1
sec.nseg = int(n) # needed in Python, automatic in hoc
if h.n3d() == 0:
sec.diam = diam
dendritic.append(sec)
dendritic_only = []
for sec in dendritic:
if sec != h.soma:
dendritic_only.append(sec)
assert len(dendritic) - 1 == len(dendritic_only)
# ---- spines ---
if spines:
for sec in dendritic_only:
a = 0.0
for seg in sec.allseg():
a += seg.area()
F = (sec.L * spine_area * spine_dens + a) / a
sec.L = sec.L * F ** (2 / 3.0)
for seg in sec.allseg():
seg.diam = seg.diam * F ** (1 / 3.0)
# ---- axon ----
# initial segment between hillock + myelin
iseg = h.Section(name="iseg")
iseg.L = iseg_L
iseg.nseg = iseg_nseg
soma_compl_area = 0
for seg in soma:
soma_compl_area += seg.area()
print soma_compl_area
iseg.diam = (soma_compl_area / (4.0 * np.pi)) ** (0.5) / 10.0
# axon hillock
hill = h.Section(name="hill")
hill.L = hill_L
hill.nseg = hill_nseg
taper_diam(hill, 4 * iseg.diam, iseg.diam)
myelin = [h.Section(name="myelin %d" % i) for i in range(n_axon_seg)]
for myelin_sec in myelin:
myelin_sec.nseg = myelin_nseg # each of the 5 sections has 5 segments
myelin_sec.L = myelin_L
myelin_sec.diam = iseg.diam
node = [h.Section(name="node %d" % i) for i in range(n_axon_seg)]
for node_sec in node:
node_sec.nseg = node_nseg
node_sec.L = node_L
node_sec.diam = iseg.diam * 0.75
# syntax: childsec.connect(parentsec, parentx, childx)
hill.connect(soma, 0.5, 0)
iseg.connect(hill, 1, 0)
myelin[0].connect(iseg, 1, 0)
node[0].connect(myelin[0], 1, 0)
for i in range(n_axon_seg - 1):
myelin[i + 1].connect(node[i], 1, 0)
node[i + 1].connect(myelin[i + 1], 1, 0)
# ---- mechanisms ----
for sec in h.allsec():
sec.insert("pas")
sec.Ra = ra
sec.cm = c_m
sec.g_pas = 1.0 / rm
sec.e_pas = v_init
sec.insert("na")
# dendrite
for sec in dendritic_only:
sec.gbar_na = gna_dend
sec.insert("km")
sec.gbar_km = gkm
sec.insert("kca")
sec.gbar_kca = gkca
sec.insert("ca")
sec.gbar_ca = gca
sec.insert("cad")
# na+ channels
soma.gbar_na = gna_soma
soma.insert("kv")
soma.gbar_kv = gkv_soma
soma.insert("km")
soma.gbar_km = gkm_soma
soma.insert("kca")
soma.gbar_kca = gkca_soma
soma.insert("ca")
soma.gbar_ca = gca_soma
soma.insert("cad")
for myelin_sec in myelin:
myelin_sec.cm = cm_myelin
myelin_sec.gbar_na = gna_dend
hill.gbar_na = gna_node
iseg.gbar_na = gna_node
for node_sec in node:
node_sec.g_pas = g_pas_node
node_sec.gbar_na = gna_node
iseg.insert("kv")
iseg.gbar_kv = gkv_axon
hill.insert("kv")
hill.gbar_kv = gkv_axon
for sec in h.allsec():
if h.ismembrane("k_ion"):
sec.ek = Ek
if h.ismembrane("na_ion"):
sec.ena = Ena
h.vshift_na = -5
if h.ismembrane("ca_ion"):
sec.eca = 140
h.ion_style("ca_ion", 0, 1, 0, 0, 0)
h.vshift_ca = 0
axon = [iseg, hill, myelin, node]
return soma, dendritic_only, axon
''' Test file for MC single cell stimulation as in MC_Stim.hoc
of the Cleland model'''
from neuron import h, gui
import tabchannels
import matplotlib.pyplot as plt
import numpy as np
# import cell
h.xopen('MC_def.hoc')
# Parameters
tstop = 6000
celsius = 35
# Instantiate a cell
mitral = h.Mitral()
# Current injection
T1 = 1500
Dur = 4000
Ic1 = 0.36
'''
stim1 = h.IClamp(mitral.soma(0.5))
stim1.delay = T1
stim1.dur = Dur
stim1.amp = Ic1
def _display_NEURON_fired(self):
nrn.xopen("ses.ses")
def __init__(self):
h.xopen("purkinje.hoc")
# Since there is only the denrite compartment with CF being inserted
self.dend = h.dend
import sys
from neuron import h, hoc
from math import sqrt, pi, log, exp
Ra = 100
ek = -94
ena = 50
with open('wtd2_params.txt') as f:
for line in f:
exec(line)
h.xopen("msn_wolf_all_tau_vecs.hoc")
dgnaf_proxF = G_NAFD / G_NAF
dgnap_proxF = G_NAPD / G_NAP
dgnaf_midF = G_NAFD / G_NAF
dgnap_midF = G_NAPD / G_NAP
dgkas_midF = G_KASD / G_KAS
dgkaf_midF = G_KAFD / G_KAF
dgnaf_distF = G_NAFD / G_NAF
dgnap_distF = G_NAPD / G_NAP
dgkas_distF = G_KASD / G_KAS
dgkaf_distF = G_KAFD / G_KAF
class WTD2:
def __init__(self):
self.create_cell()
self.optimize_nseg()
self.settopo()
self.add_all()
self.geom_nseg()
netfcns.spikerecord(cells)
results = netfcns.vrecord(cells,dictpop, iPPC, iNPPC)
#%%
#################
# RUN SIMULATION AND WRITE RESULTS
#################
h('StepBy=100') # ms
h('walltime = startsw()')
h.xopen("midbalfcn.hoc")
h('objref fihw')
h('fihw = new FInitializeHandler(2, "midbal()")')
#if (batchflag==1):
print("Now running simulation at scale = ", scaleDown, " for time = ", h.SIMDUR, " with scaleEScon = ", scaleEScon)
h.run()
netfcns.spikeout(cells,fstem)
netfcns.vout(cells,results,fstem,dictpop)
print( "** Finished running sim and printing results **")
#%%
#################
def pythonsim(simid, rundir, inputdir, modeldir, outputdir, currentstr, vinitstr, delaystr, stimdurationstr, timestepstr, simstopstr, recordintervalstr):
import neuron
from neuron import h
Section = h.Section
# All the mods are in the simulator directory
# Apparently this is already done by the import, if we use the "-dll"
# option in the call to nrniv. Since the import behavior seems to be
# inconsistent without the "-dll" option, we do it this way.
#neuron.load_mechanisms(".") # NOT USING LOAD_MECHANISMS HERE
# local auto-modified version for no gui and control over certain ion
# channels is in the run dir
h.xopen(rundir + '/' + simid + '.hoc')
timefilepath = outputdir + '/' + 'timedata.txt'
timefile = h.File()
timefile.wopen(timefilepath, 'w')
voltagefilepath = outputdir + '/' + 'voltagedata.txt'
voltagefile = h.File()
voltagefile.wopen(voltagefilepath, 'w')
current = float(currentstr)
vinit = float(vinitstr)
delay = float(delaystr)
stimduration = float(stimdurationstr)
timestep = float(timestepstr)
simstop = float(simstopstr)
recordinterval = float(recordintervalstr)
# ----- Current Injection
stim = h.IClamp(0.5, sec=h.soma)
stim.amp = current # nA
stim.delay = delay # msec
stim.dur = stimduration # msec
# ----- Simulation Control (now mostly done through input arguments)
h.dt = timestep
# Preallocate record vectors for speed
# Requires recordinterval to be an exact multiple of tstep.
recordlength = simstop/recordinterval + 1
testt = h.Vector(recordlength)
testv = h.Vector(recordlength)
# Recording at the soma
testt.record(h._ref_t, recordinterval)
testv.record(h.soma(0.5)._ref_v, recordinterval)
# Initialize
h.finitialize(vinit)
h.fcurrent()
# Integrate
while h.t <= simstop:
v = h.soma.v
h.fadvance()
# Shutdown
testt.printf(timefile, '%f\n')
testv.printf(voltagefile, '%f\n')
timefile.close()
voltagefile.close()
return(0)
def __init__(self):
h.xopen("P20.hoc")
# The following are chosen as attributes for potential recording
self.soma = h.soma
self.dend_root = h.dendA1_0 # see Fig.2A Zang et al. 2018 10.1016/j.celrep.2018.07.011
#
# Script code (run always)
#
# Load the sys and os packages.
import sys, os
# Load the interpreter object.
from neuron import h
# Load the NEURON GUI.
if use_NEURON_GUI:
from neuron import gui
# Load default parameters and initialize the network.
h.xopen("main.hoc")
# Load functions for interfacing with hoc data structures.
from hocinterface import *
# Load the neuroplot namespace.
from neuroplot import *
# Load the numpy namespace.
from numpy import *
# Load analysis
from analysis import *
# Set up cellsnq and connsnq for display functions.
h('objref cellsnq')
stim.amp=amp
return stim
def recvolt(seg):
rec_v=neuron.h.Vector()
rec_v.record(seg._ref_v)
return rec_v
def rectime(seg):
rec_t=neuron.h.Vector()
rec_t.record(seg._ref_t)
return rec_t
load_mechanisms('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/')
h.xopen('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/basket_cell17S.hoc')
h.xopen('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/pyramidal_cell_14Vb.hoc')
h.xopen('/home/ben/Desktop/5ht3a_project/neuron_model/downloaded_neuron_models/Hipp_paper_code/olm_cell2.hoc')
pyrstren=np.arange(.005,.01,.001)
pvstren=np.arange(0,0.3,.05)
olmexcstren=np.arange(.05,.055,.001)
olmstren=np.arange(.04,.05,.002)
olmcombs=itertools.product(olmexcstren,olmstren)
pvpyrcombs=itertools.product(pyrstren,pvstren)
numiter=100
ppp=1
#
# Script code (run always)
#
# Load the sys and os packages.
import sys, os
# Load the interpreter object.
from neuron import h
# Load the NEURON GUI.
if use_NEURON_GUI:
from neuron import gui
# Load default parameters and initialize the network.
h.xopen("main_demo.hoc")
# Load functions for interfacing with hoc data structures.
from hocinterface import *
# Load the neuroplot namespace.
from neuroplot import *
# Load the numpy namespace.
from numpy import *
# Load analysis
from analysis import *
# Set up cellsnq and connsnq for display functions.
def main(config, template_path, output_path, forest_path, populations, io_size,
chunk_size, value_chunk_size, cache_size, verbose):
"""
:param config:
:param template_path:
:param forest_path:
:param populations:
:param io_size:
:param chunk_size:
:param value_chunk_size:
:param cache_size:
"""
utils.config_logging(verbose)
logger = utils.get_script_logger(script_name)
comm = MPI.COMM_WORLD
rank = comm.rank
env = Env(comm=MPI.COMM_WORLD,
config_file=config,
template_paths=template_path)
h('objref nil, pc, templatePaths')
h.load_file("nrngui.hoc")
h.load_file("./templates/Value.hoc")
h.xopen("./lib.hoc")
h.pc = h.ParallelContext()
if io_size == -1:
io_size = comm.size
if rank == 0:
logger.info('%i ranks have been allocated' % comm.size)
h.templatePaths = h.List()
for path in env.templatePaths:
h.templatePaths.append(h.Value(1, path))
if output_path is None:
output_path = forest_path
if rank == 0:
if not os.path.isfile(output_path):
input_file = h5py.File(forest_path, 'r')
output_file = h5py.File(output_path, 'w')
input_file.copy('/H5Types', output_file)
input_file.close()
output_file.close()
comm.barrier()
(pop_ranges, _) = read_population_ranges(forest_path, comm=comm)
start_time = time.time()
for population in populations:
logger.info('Rank %i population: %s' % (rank, population))
count = 0
(population_start, _) = pop_ranges[population]
template_name = env.celltypes[population]['template']
h.find_template(h.pc, h.templatePaths, template_name)
template_class = eval('h.%s' % template_name)
measures_dict = {}
for gid, morph_dict in NeuroH5TreeGen(forest_path,
population,
io_size=io_size,
comm=comm,
topology=True):
if gid is not None:
logger.info('Rank %i gid: %i' % (rank, gid))
cell = cells.make_neurotree_cell(template_class,
neurotree_dict=morph_dict,
gid=gid)
secnodes_dict = morph_dict['section_topology']['nodes']
apicalidx = set(cell.apicalidx)
basalidx = set(cell.basalidx)
dendrite_area_dict = {k + 1: 0.0 for k in range(0, 4)}
dendrite_length_dict = {k + 1: 0.0 for k in range(0, 4)}
for (i, sec) in enumerate(cell.sections):
if (i in apicalidx) or (i in basalidx):
secnodes = secnodes_dict[i]
prev_layer = None
for seg in sec.allseg():
L = seg.sec.L
nseg = seg.sec.nseg
seg_l = old_div(L, nseg)
seg_area = h.area(seg.x)
layer = cells.get_node_attribute(
'layer', morph_dict, seg.sec, secnodes, seg.x)
layer = layer if layer > 0 else (
prev_layer if prev_layer is not None else 1)
prev_layer = layer
dendrite_length_dict[layer] += seg_l
dendrite_area_dict[layer] += seg_area
measures_dict[gid] = { 'dendrite_area': np.asarray([ dendrite_area_dict[k] for k in sorted(dendrite_area_dict.keys()) ], dtype=np.float32), \
'dendrite_length': np.asarray([ dendrite_length_dict[k] for k in sorted(dendrite_length_dict.keys()) ], dtype=np.float32) }
del cell
count += 1
else:
logger.info('Rank %i gid is None' % rank)
append_cell_attributes(output_path,
population,
measures_dict,
namespace='Tree Measurements',
comm=comm,
io_size=io_size,
chunk_size=chunk_size,
value_chunk_size=value_chunk_size,
cache_size=cache_size)
MPI.Finalize()
#!/usr/bin/env python
# run using command line: 'python -i cable.py'
from neuron import gui, h # h stands for hoc
# create the cable
cable = h.Section() # the name here is used for graphics but doesn't produce a hoc pointer
cable.L, cable.diam, cable.nseg = 10000, 1, 1001 # microns, microns, num
cable.insert('hh') # this is a SECTION level call that puts 'pas' into all of the 1001 SEGMENTs
# cable.g_pas, cable.e_pas = 1/20000.0, -65 # 1/(Ohm cm^2) = Siemens/cm^2, mV; this access will set all of the segments
cabref = h.SectionRef(sec=cable) # a workaround to end up with a hoc object that points to the python object
h('objref cable') # creates the object reference in hoc
h.cable=cabref # aligns the pointers; if had a hoc file that defined the cell would go other direction
h.xopen("cable.ses")
# here's a more pythonic way to set pas params that accesses segments via dot notation
# def setpas (sec, gpas=1/20000, epas=-65): # provide defaults
# for seg in sec: # iterate over all of the segments in a section
# seg.pas.g, seg.pas.e = gpas, epas # this is the more pythonic segmentwise way to do this
#
# setpas(cable)
