def make_ggn_kc_conn(ggn, kc, ggn_kc_syn_params):
"""Create a network with single KC receiving inhibition from an
isolated GGN.
"""
ggn_graph = nu.nrngraph(ggn)
ca_sec_pos = nu.select_random_terminal_segments_by_sid(
ggn_graph, ng.custom_types['LCA'], 1)
ca_sec, ca_pos = list(zip(*ca_sec_pos))
ggn_kc_syn_info = nu.make_gradedsyn_one_one(ca_sec, ca_pos, [kc.soma],
[0.5], ggn_kc_syn_params)
return {
'ggn_kc_syn_info': ggn_kc_syn_info,
'ggn_pre': ca_sec_pos,
}
def setup_recording(kcs, ggn, n_kc_vm=100, n_ggn_vm=100, t=None):
"""Create vectors for recording data from KCs and GGN sections"""
global model_dict
ret = {}
kc_st = {}
for kc in kcs:
nc, stvec = nu.record_spiketimes(kc.soma)
kc_st[kc.soma.name()] = (nc, stvec)
ret['kc_spikes'] = kc_st
if t is None:
tvec = h.Vector()
tvec.record(h._ref_t)
elif isinstance(t, float):
tvec = h.Vector()
tvec.record(h._ref_t, t)
elif isinstance(t, np.ndarray): # Assume h.Vector
tvec = h.Vector(t)
else:
tvec = t
ret['time'] = tvec
if n_kc_vm > kcs:
n_kc_vm = len(kcs)
vm_kcs = np.random.choice(kcs, size=n_kc_vm, replace=False)
if 'test_kc' in model_dict:
vm_kcs = np.append(vm_kcs, [model_dict['test_kc']])
ret['kc_vm'] = {kc.soma.name(): nu.setup_recording(kc.soma, 0.5, 'v', t) \
for kc in vm_kcs}
g = nu.nrngraph(ggn)
ggn_out_nodes = nu.select_good_nodes_by_sid(g, [ng.name_sid['LCA'], ng.name_sid['MCA']],
[n_ggn_vm, n_ggn_vm])
ggn_out = [g.node[n]['orig'] for n in ggn_out_nodes]
ret['ggn_output_vm'] = {sec.name(): nu.setup_recording(sec, 0.5, 'v', t) \
for sec in ggn_out}
ggn_alphaL_input_nodes = nu.select_good_nodes_by_sid(g, [ng.name_sid['alphaL']], [n_ggn_vm])
ggn_alphaL_input = [g.node[n]['orig'] for n in ggn_alphaL_input_nodes]
ret['ggn_alphaL_input_vm'] = {sec.name(): nu.setup_recording(sec, 0.5, 'v', t) \
for sec in ggn_alphaL_input}
ggn_basal_nodes = nu.select_good_nodes_by_sid(g, [ng.name_sid['dend_b']], [n_ggn_vm])
ggn_basal = [g.node[n]['orig'] for n in ggn_basal_nodes]
ret['ggn_basal_vm'] = {sec.name(): nu.setup_recording(sec, 0.5, 'v', t) \
for sec in ggn_basal}
if 'ig' in model_dict:
ret['ig_vm'] = h.Vector()
ret['ig_vm'].record(model_dict['ig'].izhi._ref_V, t)
model_dict.update(ret)
return ret
def make_kc_ggn_alpha_loop(ggn,
kc,
ggn_kc_syn_params,
kc_ggn_syn_params,
jitter=None):
"""Create a network with single KC connected via a single strong
synapse (equivalent to many synapses from many synchronous KCs)
jitter, if specified, should be (time_range, nsyn) where nsyn is
the number of KC->GGN synapses to be created and each will have a
delay increased by a uniform random time between 0 and time_range
(the base delay is specified in kc_ggn_syn_params).
"""
ggn_graph = nu.nrngraph(ggn)
if jitter is not None:
print('Jitter:', jitter, type(jitter[0]), type(jitter[1]))
trange = float(jitter[0])
nsyn = int(jitter[1])
else:
nsyn = 1
trange = 0.0
alpha_sec_pos = nu.select_random_terminal_segments_by_sid(
ggn_graph, ng.custom_types['alphaL'], nsyn)
alpha_sec, alpha_pos = list(zip(*alpha_sec_pos))
kc_ggn_syn_info = nu.make_exp2syn_one_one([kc.soma] * nsyn, [0.5] * nsyn,
alpha_sec, alpha_pos,
kc_ggn_syn_params)
if nsyn > 1:
delays = np.random.uniform(low=0.0, high=trange, size=nsyn)
for netcon, delay in zip(kc_ggn_syn_info['netcons'], delays):
netcon.delay += delay
ca_sec_pos = nu.select_random_terminal_segments_by_sid(
ggn_graph, ng.custom_types['LCA'], 1)
ca_sec, ca_pos = list(zip(*ca_sec_pos))
ggn_kc_syn_info = nu.make_gradedsyn_one_one(ca_sec, ca_pos, [kc.soma],
[0.5], ggn_kc_syn_params)
return {
'kc_ggn_syn_info': kc_ggn_syn_info,
'ggn_kc_syn_info': ggn_kc_syn_info,
'ggn_pre': ca_sec_pos,
'ggn_post': alpha_sec_pos,
}
cellname = [line for line in ggn_model.split('\n')
if 'begintemplate' in line]
rest = cellname[0].partition('begintemplate')[-1]
cellname = rest.split()[0]
if not hasattr(h, cellname):
h(ggn_model)
return eval('h.{}()'.format(cellname))
outfilename = '../simulated/Fig_2ef/Vm_inhpoisson_stim_series_20180907_171406.h5'
colormap = '15cb'
plots_per_region = 1
if __name__ == '__main__':
ggn = get_ggn(outfilename)
with h5.File(outfilename, 'r') as fd:
graph = nu.nrngraph(ggn)
leaves = [graph.node[n]['p'] for n in graph.nodes if graph.nodes[n]['orig'] is None]
sid_leaf_map = defaultdict(list)
for leaf in leaves:
sid_leaf_map[graph.node[leaf]['s']].append(leaf)
fig = plt.figure()
gs = gridspec.GridSpec(2, 1, height_ratios=[3,1])
ax_vm = fig.add_subplot(gs[0]) # Plot the Vm
syninfo = [s for s in fd['syninfo']]
sid_data_dict = defaultdict(list)
for nodename in fd:
if nodename.startswith('v_'):
sid = fd[nodename].attrs['sid']
# Take only leaf nodes
if fd[nodename].attrs['section'] in sid_leaf_map[sid]:
sid_data_dict[sid].append(nodename)
count = 0
ggn.soma.push()
ordered_tree = h.SectionList()
ordered_tree.wholetree()
h.pop_section()
for sec in ordered_tree:
sec.push()
for ii, seg in enumerate(sec):
if seg.diam < dialim:
seg.diam = seg.diam * diascale
# print('Changed diameter of segment', ii, seg.x, 'of section', sec.name(), 'to', seg.diam)
count += 1
h.pop_section()
print('Scaled diameters of', count, 'sections whose diameters were <',
dialim, 'by', diascale)
g0 = nu.nrngraph(ggn)
g, nmap = ng.renumber_nodes(g0, ggn.soma.name())
type_node_map = defaultdict(list)
# Reverse lookup table for node by stype
for n, d in g.nodes_iter(data=True):
stype = d['s']
if g.node[n]['orig'] is not None: # Skip the dummy nodes at terminal
type_node_map[stype].append(n)
synnodes = []
if args.synfile is None:
for branch_id in inputs:
nodes = type_node_map[branch_id]
size = syncount
if len(nodes) < syncount:
size = len(nodes)
for n in np.random.choice(nodes, size=size, replace=False):
action='store_true',
dest='stick',
help=
'Ball and stick model. If false, the 3D locations using pt3d are used')
parser.add_argument(
'-o',
'--origlabel',
action='store_true',
dest='origlabel',
help='If the original neuron section names should be used.')
args = parser.parse_args()
h.xopen(args.filename)
cellclass = getattr(h, args.cellname)
cell = cellclass()
if args.stick:
graph = nu.nrngraph(cell)
for n in graph.nodes:
print(n)
root = '{}.soma'.format(list(graph.nodes)[0].partition('.')[0])
else:
graph, root = cell_to_morph3d(cell)
numeric, nmap = ng.renumber_nodes(graph, start=root)
print(len(graph.nodes))
print(max(numeric.nodes))
print(len(numeric.nodes))
if args.origlabel:
reverse = {node: name.split('.')[-1] for name, node in nmap.items()}
label_nodes = reverse.keys()
labels = reverse.values()
else:
def setup_model(args):
"""Setup the model with synapses and recording tables."""
cell_template = args['celltemplate']
input_regions = args['inputs']
syn_counts = args['syncounts']
onset = args['onset']
tau = args['tau']
gsyn = args['gsyn']
mechs = {
'pas': {
'g': Q_(args['gpas'], 'S/cm**2'),
'e': Q_(args['Em'], 'mV')
}
}
if args['gk'] > 0:
mechs['ka'] = {'gbar': Q_(args['gk'], 'S/cm**2')}
if args['gca'] > 0:
mechs['cam'] = {'gbar': Q_(args['gca'], 'S/cm**2')}
h.xopen(cell_template)
ggn = nu.create_cell(args['cellname'],
filename=args['celltemplate'],
mechparams=mechs)
for sec in ggn.allsec():
sec.Ra = args['RA']
g0 = nu.nrngraph(ggn)
g, nmap = ng.renumber_nodes(g0, ggn.soma.name())
# Pick out nodes with sections associated with them (not terminal dummy nodes)
sec_nodes = [n for n in g.nodes() if g.node[n]['orig'] is not None]
# Select the nodes for synapse insertion
if args['synfile'] is not None: # This option is to allow replication
syn_nodes = []
sec_node_map = get_section_node_map(g)
with open(args['synfile']) as fd:
for line in fd:
try:
secname = line.strip()
syn_nodes.append(sec_node_map[secname])
except KeyError:
print('Could not fidn section "{}"'.format(secname))
raise
else:
syn_nodes_by_sid = ng.select_random_nodes_by_sid(
g.subgraph(sec_nodes), args['inputs'], args['syncounts'])
syn_nodes = list(
np.concatenate(
[v for v in syn_nodes_by_sid.values() if len(v) > 0]))
# If np.concatenate arg contains empty list, the result gets converted to float
syn_secs = []
synapses = []
for syn_node in syn_nodes:
sec = g.node[syn_node]['orig']
syn_secs.append(sec)
syn = insert_alphasynapse(sec(1.0),
onset=args['onset'],
gmax=args['gsyn'],
tau=args['tau'])
synapses.append(syn)
if args['recfile'] is not None:
rec_nodes = []
sec_node_map = get_section_node_map(g)
with open(args['recfile']) as fd:
for line in fd:
try:
secname = line.strip()
rec_nodes.append(sec_node_map[secname])
except KeyError:
print('Could not fidn section "{}"'.format(secname))
raise
else:
if args['recbyreg']:
rec_regions = [1, 3, 4, 5, 6, 7, 8]
rec_nodes_by_sid = ng.select_random_nodes_by_sid(
g.subgraph(sec_nodes), rec_regions,
[args['reccount']] * len(rec_regions))
rec_nodes = np.concatenate(
[v for v in rec_nodes_by_sid.values() if len(v) > 0])
rec_nodes = list(rec_nodes)
else:
rec_nodes = list(
np.random.choice(sec_nodes,
size=args['reccount'],
replace=False))
rec_nodes = list(set(rec_nodes + syn_nodes))
rec_secs = [g.node[n]['orig'] for n in rec_nodes]
t_vec = h.Vector()
t_vec.record(h._ref_t)
v_vecs = setup_recording(rec_secs)
syn_vecs = []
for syn in synapses:
vec = h.Vector()
vec.record(syn._ref_i)
syn_vecs.append(vec)
return {
'cell': ggn,
'cellgraph': g,
'synapses': synapses,
'synsecs': syn_secs,
'synnodes': syn_nodes,
'recsecs': rec_secs,
'recnodes': rec_nodes,
'tvec': t_vec,
'vvecs': v_vecs,
'synvecs': syn_vecs
}
def show_peak_vm_ggn(fname,
rot=None,
drot=None,
pos=None,
frames=0,
framerate=24,
moviefile=None,
bg=(0, 0, 0),
radius=10,
lw=10,
width=320,
height=240):
"""Display the GGN morphology with color coded Vm"""
sec_delv = {}
with h5.File(fname, 'r') as fd:
for node in fd:
if node.startswith('v_'):
v = fd[node].value
delv = max(v) - v[0]
sec = str(fd[node].attrs['section'])
sec_delv[sec] = delv
print('Computed delV')
ggn = get_ggn(fname)
graph = nu.nrngraph(ggn)
soma = [graph.node[node] for node in graph if node.endswith('soma')]
soma = soma[0]
name_sec_map = {}
for secname in sec_delv:
name_sec_map[secname] = graph.nodes[secname]['orig']
secpos = get_sec_pos(sec_delv.keys(), name_sec_map)
if pos is None:
pos = [(secpos[:, 0].min() + secpos[:, 0].max()) / 2.0,
(secpos[:, 1].min() + secpos[:, 1].max()) / 2.0,
(secpos[:, 2].min() + secpos[:, 2].max()) / 2.0]
# This helps to prevent the neuron from rotating outside camera view
soma = {'x': pos[0], 'y': pos[1], 'z': pos[2]}
print('Origin moved to', pos)
nodecolor = {ii: [(255 - bc) for bc in bg] for ii in range(10)}
polydata = morph3d.nrngraph2polydata(
graph,
nodecolor=nodecolor, #ng.nodecolor_7q,
lines=1.0)
ggn3d = polydata # morph3d.get_cylinder_view(polydata) <- with get_cylinder_view SetLineWidth does not have any effect
# Rotation is always with soma as origin
transfilter, transform = morph3d.get_transformed(ggn3d,
soma,
pos,
rot,
relative=True)
mapper = vtk.vtkPolyDataMapper()
mapper.SetInputConnection(transfilter.GetOutputPort())
mapper.ScalarVisibilityOn()
mapper.SetScalarModeToUseCellFieldData()
mapper.SelectColorArray('Colors')
# This helps to prevent the neuron from rotating outside camera view
actor = vtk.vtkActor()
actor.SetMapper(mapper)
actor.GetProperty().SetOpacity(0.2)
actor.GetProperty().SetLineWidth(lw)
actor.SetOrigin(pos)
vm_deflection = sec_delv.values()
print(min(vm_deflection), max(vm_deflection))
# vm_ctf = make_viridis_ctf(10.0, 30.0)
vm_ctf = make_ctf_from_linear_segmented_cm(
int(min(vm_deflection)), int(0.5 + max(vm_deflection)),
cc.m_isolum) # min and max give not-so-round numbers
vm_disp = make_vm_spheres(secpos, vm_deflection, vm_ctf, radius=radius)
vmxfilt, vmx = morph3d.get_transformed(vm_disp['glyph'],
soma,
pos,
rot,
relative=True)
vmxfilt.Update()
vm_mapper = vtk.vtkPolyDataMapper()
vm_mapper.SelectColorArray('VmColors')
vm_mapper.SetScalarModeToUsePointFieldData()
vm_mapper.SetInputConnection(vmxfilt.GetOutputPort())
# vm_mapper.ScalarVisibilityOn()
vm_mapper.SetLookupTable(vm_ctf)
vm_actor = vtk.vtkActor()
vm_actor.SetMapper(vm_mapper)
# This helps to prevent the neuron from rotating outside camera view
vm_actor.SetOrigin(pos)
colorbar = vtk.vtkScalarBarActor()
colorbar.SetLookupTable(vm_ctf)
colorbar.SetTitle('dVm (mV)')
colorbar.SetNumberOfLabels(5)
colorbar.SetWidth(0.1)
colorbar.SetHeight(0.7)
colorbar.SetPosition(0.9, 0.1)
colorbar.SetAnnotationTextScaling(True)
textcolor = [1 - bg[0], 1 - bg[1], 1 - bg[2]]
colorbar.GetTitleTextProperty().SetFontFamilyToArial()
colorbar.GetTitleTextProperty().SetFontSize(12)
colorbar.GetTitleTextProperty().SetColor(*textcolor)
colorbar.GetTitleTextProperty().SetShadow(False)
colorbar.GetTitleTextProperty().ItalicOff()
colorbar.GetLabelTextProperty().SetFontFamilyToArial()
colorbar.GetLabelTextProperty().SetFontSize(10)
colorbar.GetLabelTextProperty().SetJustificationToCentered()
colorbar.GetLabelTextProperty().SetColor(*textcolor)
colorbar.GetLabelTextProperty().SetShadow(False)
colorbar.GetLabelTextProperty().ItalicOff()
renderer = vtk.vtkRenderer()
renderer.AddActor(actor)
renderer.AddActor(vm_actor)
renderer.AddActor2D(colorbar)
renderer.SetBackground(*bg)
# camera = vtk.vtkCamera()
# # This was found experimentally
# camera.SetPosition((-323.62152099609375, +398.5799446105957, 1000.250453948881))
# camera.SetFocalPoint(pos)
# renderer.SetActiveCamera(camera)
# renderer.GetActiveCamera().SetViewAngle(30)
win = vtk.vtkRenderWindow()
win.AddRenderer(renderer)
win.SetSize(width, height)
win.Render()
# Strangely, increasing view angle makes the object distance. What is this view angle?
renderer.GetActiveCamera().SetViewAngle(23)
# print(renderer.GetActiveCamera().GetPosition())
# print(renderer.GetActiveCamera().GetFocalPoint())
interactor = vtk.vtkRenderWindowInteractor()
interactor.SetRenderWindow(win)
interactor.Initialize()
if moviefile is not None:
dump_movie([vm_actor, actor], win, drot[0], drot[1], drot[2], frames,
framerate, moviefile)
interactor.Start()
