def all(substring, start=0, end=-1):
results = []
mt = h.MechanismType(1)
cnt = int(mt.count())
end = cnt if end == -1 or end > cnt else end
for i in range(start, end):
if mt.is_netcon_target(i) and not mt.is_artificial(i):
mt.select(i)
n = h.ref("")
mt.selected(n)
mechname = n[0]
if substring not in mechname:
continue
if uses_pointer(mechname):
print("\n%d> %s has a POINTER" % (i, mechname))
if 'ProbAMPANMDA_EMS' not in mechname:
continue
print("\n%d of %d" % (i, cnt))
print(mechname)
for h.secondorder in [0, 2]:
m, result = one(mechname)
if cnt > 30:
m.g = None
if result:
results.append((i, result, m.g))
del m
h.secondorder = 0
return results
def get_mech_names():
_mech_names = []
mt = h.MechanismType(0)
mname = h.ref("")
for i in range(int(mt.count())):
mt.select(i)
mt.selected(mname)
_mech_names.append(mname[0])
return _mech_names
def remove_mechanisms(remove_list):
""" Removes all active mechanisms in remove_list from cell model
"""
mt = h.MechanismType(0)
for sec in h.allsec():
for seg in sec:
for mech in remove_list:
mt.select(mech)
mt.remove()
def _is_loaded_mechanisms():
# copied from:
# https://www.neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/mechtype.html
mt = h.MechanismType(0)
mname = h.ref('')
mnames = list()
for i in range(mt.count()):
mt.select(i)
mt.selected(mname)
mnames.append(mname[0])
if 'hh2' not in mnames:
return False
else:
return True
def mechVarList ():
msname = h.ref('')
varList = {}
for i, mechtype in enumerate(['mechs','pointps']):
mt = h.MechanismType(i) # either distributed mechs (0) or point process (1)
varList[mechtype] = {}
for j in xrange(int(mt.count())):
mt.select(j)
mt.selected(msname)
ms = h.MechanismStandard(msname[0], 1) # PARAMETER (modifiable)
varList[mechtype][msname[0]] = []
propName = h.ref('')
for var in xrange(int(ms.count())):
k = ms.name(propName, var)
varList[mechtype][msname[0]].append(propName[0])
return varList
def is_loaded_mechanisms():
# copied from:
# https://www.neuron.yale.edu/neuron/static/py_doc/modelspec/programmatic/mechtype.html
mt = h.MechanismType(0)
mname = h.ref('')
mnames = list()
for i in range(mt.count()):
mt.select(i)
mt.selected(mname)
mnames.append(mname[0])
# note this check only works for the original hnn model
# need to generalize for any model
if 'hh2' not in mnames:
return False
else:
return True
def ptype():
msname = h.ref('')
propList = {}
for i, mechtype in enumerate(['mechs', 'pointps']):
mt = h.MechanismType(
i) # either distributed mechs (0) or point process (1)
propList[mechtype] = {}
for j in range(int(mt.count())):
mt.select(j)
mt.selected(msname)
print('\n\n', msname[0], ' mechanismtype=%d' % j)
pname(msname[0])
ms = h.MechanismStandard(msname[0], 1) # PARAMETER (modifiable)
propList[mechtype][msname[0]] = []
propName = h.ref('')
for prop in range(int(ms.count())):
k = ms.name(propName, prop)
propList[mechtype][msname[0]].append(propName[0])
print(propList)
def find_point_process(self, sec):
"""Find a point_process in a section if any.
Params:
sec - Section to search
Return:
point_process or None if not present.
"""
mt = h.MechanismType(1)
total_mech = int(mt.count())
sec.push()
pp = None
for i in range(total_mech):
pp_type = mt.select(i)
pp = mt.pp_begin()
if pp is not None:
break
h.pop_section()
return pp
def mechVarList():
"""
Function for/to <short description of `netpyne.conversion.neuronPyHoc.mechVarList`>
"""
msname = h.ref('')
varList = {}
for i, mechtype in enumerate(['mechs', 'pointps']):
mt = h.MechanismType(
i) # either distributed mechs (0) or point process (1)
varList[mechtype] = {}
for j in range(int(mt.count())):
mt.select(j)
mt.selected(msname)
ms = h.MechanismStandard(msname[0], 1) # PARAMETER (modifiable)
varList[mechtype][msname[0]] = []
propName = h.ref('')
for var in range(int(ms.count())):
k = ms.name(propName, var)
varList[mechtype][msname[0]].append(propName[0])
return varList
def get_root(sec):
return h.SectionRef(sec=sec).root().sec
root_sections = []
for sec in h.allsec():
if not h.SectionRef(sec).has_parent():
root_sections.append(sec)
# get all mech names
mech_names = []
h("""
objref mt
json_var = 0
strdef mname
""")
h.mt = h.MechanismType(0)
for i in xrange(int(h.mt.count())):
h.mt.select(i)
h('mt.selected(mname)')
mech_names.append(h.mname)
# get all point process names
pointprocess_names = []
h.mt = h.MechanismType(1)
for i in xrange(int(h.mt.count())):
h.mt.select(i)
h('mt.selected(mname)')
pointprocess_names.append(h.mname)
def pt_from_seg(seg):
sec = seg.sec
from neuron import h
for j in range(2):
mt = h.MechanismType(j)
name = h.ref("")
for i in range(mt.count()):
mt.select(i)
mt.selected(name)
a = mt.code().split(sep='\n')
print(("%s : %s" % (name[0], a[0])))
def psection(sec):
from neuron import h, _has_rxd
try:
if _has_rxd['crxd']:
from neuron import crxd as rxd
from neuron.crxd import region, species
from neuron.crxd import rxd as rxd_module
else:
from neuron import rxd
from neuron.rxd import region, species
from neuron.rxd import rxd as rxd_module
have_rxd = True
except:
have_rxd = False
results = {}
mname = h.ref('')
# point processes
pps = {}
mt = h.MechanismType(1)
for i in range(int(mt.count())):
mt.select(i)
mypps = set()
pp = mt.pp_begin(sec=sec)
while pp is not None:
mypps.add(pp)
pp = mt.pp_next()
if mypps:
mt.selected(mname)
pps[mname[0]] = mypps
results['point_processes'] = pps
center_seg_dir = dir(sec(0.5))
mechs_present = []
# membrane mechanisms
mt = h.MechanismType(0)
for i in range(int(mt.count())):
mt.select(i)
mt.selected(mname)
name = mname[0]
if name in center_seg_dir:
mechs_present.append(name)
results['density_mechs'] = {}
results['ions'] = {}
for mech in mechs_present:
my_results = {}
ms = h.MechanismStandard(mech, 0)
for j in range(int(ms.count())):
n = int(ms.name(mname, j))
name = mname[0]
pvals = []
# TODO: technically this is assuming everything that ends with _ion
# is an ion. Check this.
if mech.endswith('_ion'):
pvals = [getattr(seg, name) for seg in sec]
else:
mechname = name #+ '_' + mech
for seg in sec:
if n > 1:
pvals.append(
[getattr(seg, mechname)[i] for i in range(n)])
else:
pvals.append(getattr(seg, mechname))
my_results[name[:-(len(mech) +
1)] if name.endswith('_' +
mech) else name] = pvals
# TODO: should be a better way of testing if an ion
if mech.endswith('_ion'):
results['ions'][mech[:-4]] = my_results
else:
results['density_mechs'][mech] = my_results
morphology = {
'L':
sec.L,
'diam': [seg.diam for seg in sec],
'pts3d': [(sec.x3d(i), sec.y3d(i), sec.z3d(i), sec.diam3d(i))
for i in range(sec.n3d())],
'parent':
sec.parentseg(),
'trueparent':
sec.trueparentseg()
}
results['morphology'] = morphology
results['nseg'] = sec.nseg
results['Ra'] = sec.Ra
results['cm'] = [seg.cm for seg in sec]
if have_rxd:
regions = {
r()
for r in region._all_regions if r() is not None and sec in r().secs
}
results['regions'] = regions
my_species = []
for sp in species._all_species:
sp = sp()
if sp is not None:
sp_regions = sp._regions
if not hasattr(sp_regions, '__len__'):
sp_regions = [sp_regions]
if any(r in sp_regions for r in regions):
my_species.append(sp)
results['species'] = set(my_species)
results['name'] = sec.hname()
results['hoc_internal_name'] = sec.hoc_internal_name()
results['cell'] = sec.cell()
#all_active_reactions = [r() for r in rxd_module._all_reactions if r() is not None]
return results
def run_simulation(params):
"""
Function get parameters and run the model
"""
pc = h.ParallelContext()
pc.timeout(3600)
h.load_file("stdgui.hoc")
h.load_file("stdrun.hoc")
h.load_file("import3d.hoc")
RNG = np.random.default_rng()
load_mechanisms("./mods/")
# h.dt = 0.1 * ms
h.cvode.use_fast_imem(1)
# h.CVode().fixed_step(1)
# h.cvode.use_local_dt(1)
sys.path.append("../LFPsimpy/") # path to LFPsimpy
from LFPsimpy import LfpElectrode
# load all cells
cell_path = "./cells/"
for file in os.listdir(cell_path):
if file.find(".hoc") != -1:
h.load_file(cell_path + file)
gid_vect = np.asarray(
[neuron_param["gid"] for neuron_param in params["neurons"]])
all_cells = h.List()
hh_cells = h.List()
pyramidal_sec_list = h.SectionList()
is_pyrs_thread = False
radius_for_pyramids = params["common_params"]["radius4piramids"]
spike_count_obj = []
spike_times_vecs = []
soma_v_vecs = []
# create objects for neurons simulation
for neuron_param in params["neurons"]:
celltypename = neuron_param["celltype"]
cellclass_name = neuron_param["cellclass"]
gid = neuron_param["gid"]
cellclass = getattr(h, cellclass_name)
cell = cellclass(gid, 0)
pc.set_gid2node(gid, pc.id())
if celltypename == "pyr":
# x and y position of pyramidal cells
angle = 2 * np.pi * (RNG.random() - 0.5)
radius = radius_for_pyramids * 2 * (RNG.random() - 0.5)
pyr_coord_in_layer_x = radius * np.cos(angle)
pyr_coord_in_layer_y = radius * np.sin(angle)
cell.position(pyr_coord_in_layer_x, 0, pyr_coord_in_layer_y)
for sec in cell.all:
pyramidal_sec_list.append(sec)
is_pyrs_thread = True
# set counters for spike generation
if cell.is_art() == 0:
for sec in cell.all:
sec.insert("IextNoise")
sec.myseed_IextNoise = RNG.integers(0, 1000000000000000, 1)
sec.sigma_IextNoise = 0.005
sec.mean_IextNoise = neuron_param["cellparams"]["iext"]
if hasattr(cell, "axon_list"):
mt = h.MechanismType(0)
mt.select('IextNoise')
for sec in cell.axon_list:
mt.remove(sec=sec)
firing = h.NetCon(cell.soma[0](0.5)._ref_v, None, sec=cell.soma[0])
firing.threshold = -30 * mV
else:
cell.celltype = celltypename
for p_name, p_val in neuron_param["cellparams"].items():
if hasattr(cell.acell, p_name):
setattr(cell.acell, p_name, p_val)
setattr(cell.acell, "delta_t", h.dt)
setattr(cell.acell, "myseed", RNG.integers(0, 1000000000000000, 1))
firing = h.NetCon(cell.acell, None)
pc.cell(gid, firing)
fring_vector = h.Vector()
firing.record(fring_vector)
spike_count_obj.append(firing)
spike_times_vecs.append(fring_vector)
# check is need to save Vm of soma
if np.sum(params["save_soma_v"] == gid) == 1:
soma_v = h.Vector()
soma_v.record(cell.soma[0](0.5)._ref_v)
soma_v_vecs.append(soma_v)
else:
soma_v_vecs.append(np.empty(shape=0))
if cell.is_art() == 0:
hh_cells.append(cell)
all_cells.append(cell)
pc.barrier()
if pc.id() == 0:
print("End of neurons settings")
# set connection
connections = h.List()
synapses = h.List()
for syn_params in params["synapses_params"]:
post_idx = np.argwhere(gid_vect == syn_params["post_gid"]).ravel()
post_idx = post_idx[0]
postsynaptic_cell = all_cells[post_idx]
post_list = getattr(postsynaptic_cell,
syn_params["target_compartment"])
len_postlist = sum([1 for _ in post_list])
if len_postlist == 1:
post_idx = 0
else:
post_idx = RNG.integers(0, len_postlist - 1)
for idx_tmp, post_comp_tmp in enumerate(post_list):
if idx_tmp == post_idx: post_comp = post_comp_tmp
syn = h.Exp2Syn(post_comp(0.5))
syn.e = syn_params["Erev"]
syn.tau1 = syn_params["tau_rise"]
syn.tau2 = syn_params["tau_decay"]
conn = pc.gid_connect(syn_params["pre_gid"], syn)
conn.delay = syn_params["delay"]
conn.weight[0] = syn_params["gmax"]
conn.threshold = -30 * mV
connections.append(conn)
synapses.append(syn)
try:
# check NMDA in synapse
gmax_nmda = syn_params["NMDA"]["gNMDAmax"]
syn_nmda = h.NMDA(post_comp(0.5), sec=post_comp)
syn_nmda.tcon = syn_params["NMDA"]["tcon"]
syn_nmda.tcoff = syn_params["NMDA"]["tcoff"]
syn_nmda.gNMDAmax = gmax_nmda
conn2 = pc.gid_connect(syn_params["pre_gid"], syn_nmda)
conn2.delay = syn_params["delay"]
conn2.weight[0] = syn_params["NMDA"]["gNMDAmax"]
conn2.threshold = -30 * mV
connections.append(conn2)
synapses.append(syn_nmda)
except KeyError:
pass
pc.barrier()
# create gap junction objects
gap_junctions = h.List()
for gap_params in params["gap_junctions"]:
idx1 = np.argwhere(gid_vect == gap_params["gid1"]).ravel()
idx2 = np.argwhere(gid_vect == gap_params["gid2"]).ravel()
if idx1.size != 0 and idx2.size != 0:
idx1 = idx1[0]
idx2 = idx2[0]
cell1 = all_cells[idx1]
cell2 = all_cells[idx2]
comp1_list = getattr(cell1, gap_params["compartment1"])
len_list = sum([1 for _ in comp1_list])
if len_list == 1:
idx1 = 0
else:
idx1 = RNG.integers(0, len_list - 1)
for idx_tmp, comp_tmp in enumerate(comp1_list):
if idx_tmp == idx1: comp1 = comp_tmp
comp2_list = getattr(cell2, gap_params["compartment2"])
len_list = sum([1 for _ in comp2_list])
if len_list == 1:
idx2 = 0
else:
idx2 = RNG.integers(0, len_list - 1)
for idx_tmp, comp_tmp in enumerate(comp2_list):
if idx_tmp == idx2: comp2 = comp_tmp
pc.source_var(comp1(0.5)._ref_v, gap_params["sgid_gap"],
sec=comp1) # gap_params["gid1"]
gap = h.GAP(comp1(0.5), sec=comp1)
gap.r = gap_params["r"]
pc.target_var(gap._ref_vgap,
gap_params["sgid_gap"] + 1) # gap_params["gid2"]
gap_junctions.append(gap)
pc.source_var(comp2(0.5)._ref_v,
gap_params["sgid_gap"] + 1,
sec=comp2) # gap_params["gid2"]
gap = h.GAP(comp2(0.5), sec=comp2)
gap.r = gap_params["r"]
pc.target_var(gap._ref_vgap,
gap_params["sgid_gap"]) # gap_params["gid1"]
gap_junctions.append(gap)
elif idx1.size != 0 or idx2.size != 0:
if idx1.size != 0 and idx2.size != 0: continue
if idx1.size != 0:
this_idx = idx1[0]
this_gid = gap_params["gid1"]
out_gid = gap_params["gid2"]
comp_name = gap_params["compartment1"]
sgid_gap_src = gap_params["sgid_gap"]
sgid_gap_trg = gap_params["sgid_gap"] + 1
else:
this_idx = idx2[0]
this_gid = gap_params["gid2"]
out_gid = gap_params["gid1"]
comp_name = gap_params["compartment2"]
sgid_gap_src = gap_params["sgid_gap"] + 1
sgid_gap_trg = gap_params["sgid_gap"]
cell = all_cells[this_idx]
comp_list = getattr(cell, comp_name)
for idx_tmp, comp_tmp in enumerate(comp_list):
if idx_tmp == 0: comp = comp_tmp
pc.source_var(comp(0.5)._ref_v, sgid_gap_src, sec=comp)
gap = h.GAP(0.5, sec=comp)
gap.r = gap_params["r"]
pc.target_var(gap._ref_vgap, sgid_gap_trg)
pc.setup_transfer()
pc.barrier()
if pc.id() == 0:
print("End of connection settings")
# create electrodes objects for LFP simulation
el_x = params["elecs"]["el_x"]
el_y = params["elecs"]["el_y"]
el_z = params["elecs"]["el_z"]
electrodes = []
for idx_el in range(el_x.size):
if is_pyrs_thread:
le = LfpElectrode(x=el_x[idx_el], y=el_y[idx_el], z=el_z[idx_el], sampling_period=h.dt, \
method='Line', sec_list=pyramidal_sec_list)
electrodes.append(le)
else:
electrodes.append(None)
if pc.id() == 0:
t_sim = h.Vector()
t_sim.record(h._ref_t)
else:
t_sim = None
h.tstop = params["duration"] * ms
pc.set_maxstep(5 * ms)
h.finitialize()
pc.barrier()
if pc.id() == 0:
print("Start simulation")
timer = time()
pc.psolve(params["duration"] * ms)
pc.barrier()
if pc.id() == 0:
print("End of the simulation!")
print("Time of simulation in sec ", time() - timer)
# unite data from all threads to 0 thread
comm = MPI.COMM_WORLD
lfp_data = join_lfp(comm, electrodes)
spike_trains = join_vect_lists(comm, spike_times_vecs, gid_vect)
soma_v_list = join_vect_lists(comm, soma_v_vecs, gid_vect)
if (pc.id() == 0) and (params["file_results"] != None):
t_sim = np.asarray(t_sim)
rem_time = params["del_start_time"]
if rem_time > t_sim[-1]:
rem_time = 0
rem_idx = int(rem_time / h.dt)
# save results to file
with h5py.File(params["file_results"], 'w') as h5file:
celltypes = params["cell_types_in_model"]
t_sim = t_sim[rem_idx:] - rem_time
h5file.create_dataset("time", data=t_sim)
# save LFP data
extracellular_group = h5file.create_group("extracellular")
ele_group = extracellular_group.create_group('electrode_1')
lfp_group = ele_group.create_group('lfp')
lfp_group_origin = lfp_group.create_group('origin_data')
lfp_group_origin.attrs['SamplingRate'] = 1000 / h.dt # dt in ms
for idx_el, lfp in enumerate(lfp_data):
lfp_group_origin.create_dataset("channel_" + str(idx_el + 1),
data=lfp[rem_idx:])
# save firing data
firing_group = h5file.create_group(
"extracellular/electrode_1/firing/origin_data")
for celltype in set(celltypes):
cell_friring_group = firing_group.create_group(celltype)
for cell_idx, sp_times in enumerate(spike_trains):
if celltype != celltypes[cell_idx]:
continue
sp_times = sp_times[sp_times >= rem_time] - rem_time
cell_friring_group.create_dataset(
"neuron_" + str(cell_idx + 1),
data=sp_times) # cell_spikes_dataset
# save intracellular membrane potential
intracellular_group = h5file.create_group("intracellular")
intracellular_group_origin = intracellular_group.create_group(
"origin_data")
for soma_v_idx in params["save_soma_v"]:
soma_v = soma_v_list[soma_v_idx]
if soma_v.size == 0: continue
soma_v_dataset = intracellular_group_origin.create_dataset(
"neuron_" + str(soma_v_idx + 1), data=soma_v[rem_idx:])
cell_type = celltypes[soma_v_idx]
soma_v_dataset.attrs["celltype"] = cell_type
pc.done()
h.quit()
return
