def splitmitral(mgid, cell, piecelist):
''' split a mitral cell into secondary dendrites and the soma/priden/axon
and destroy pieces not on this cpu and connect pieces with multisplit.
Note that -1 is the piece that includes the soma.
Also note that secondary dendrites have branches and the piecelist is
for the indices of secondary dentrites that connect to the soma.
The {mgid:cell} is added to mgid2piece so the assumption is that
piecelist is not empty.
'''
isecden = secden_indices_connected_to_soma(cell)
#disconnect all secden and destroy what is not supposed to exist
for i in isecden:
s = cell.secden[i]
h.disconnect(sec = s)
if i not in piecelist:
subtree = h.SectionList()
subtree.wholetree(sec = s)
for ss in subtree:
h.delete_section(sec = ss)
rest = h.SectionList()
rest.wholetree(sec = cell.soma)
if -1 not in piecelist:
for s in rest:
h.delete_section(sec = s)
#multisplit connect using mgid
for i in piecelist:
if i == -1:
pc.multisplit(0.5, mgid, sec = cell.soma)
else:
pc.multisplit(0.0, mgid, sec=cell.secden[i])
# add to piece dictionary
model.mgid2piece.update({mgid:cell})
def find_and_disconnect_axon(soma_ref):
'''Searching for an axon, it can be a child of the soma or a parent of the soma.'''
axon_section, axon_parent, soma_axon_x = [], False, None
for sec in soma_ref.child:
name = sec.hname().lower()
if 'axon' in name or 'hill' in name:
axon_section.append(sec)
# disconnect axon
soma_axon_x = sec.parentseg().x
sec.push()
h.disconnect()
h.define_shape()
if soma_ref.has_parent():
name = soma_ref.parent().sec.hname().lower()
if 'axon' in name or 'hill' in name:
axon_section.append(soma_ref.parent())
axon_parent = True
soma_axon_x = None
soma_ref.push()
h.disconnect()
else:
raise Exception('Soma has a parent which is not an axon')
if len(axon_section) > 1:
raise Exception('Soma has a two axons')
return axon_section, axon_parent, soma_axon_x
def splitmitral(mgid, cell, piecelist):
''' split a mitral cell into secondary dendrites and the soma/priden/axon
and destroy pieces not on this cpu and connect pieces with multisplit.
Note that -1 is the piece that includes the soma.
Also note that secondary dendrites have branches and the piecelist is
for the indices of secondary dentrites that connect to the soma.
The {mgid:cell} is added to mgid2piece so the assumption is that
piecelist is not empty.
'''
isecden = secden_indices_connected_to_soma(cell)
#disconnect all secden and destroy what is not supposed to exist
for i in isecden:
s = cell.secden[i]
h.disconnect(sec=s)
if i not in piecelist:
subtree = h.SectionList()
subtree.wholetree(sec=s)
for ss in subtree:
h.delete_section(sec=ss)
rest = h.SectionList()
rest.wholetree(sec=cell.soma)
if -1 not in piecelist:
for s in rest:
h.delete_section(sec=s)
#multisplit connect using mgid
for i in piecelist:
if i == -1:
pc.multisplit(0.5, mgid, sec=cell.soma)
else:
pc.multisplit(0.0, mgid, sec=cell.secden[i])
# add to piece dictionary
model.mgid2piece.update({mgid: cell})
def disconnect_dendrites_from_soma(self):
#
# ============Implement disconnect_all_dendrites capability============
#
cca(capability_name="disconnect_dendrites_from_soma",
CerebUnitCapability=CanDisconnectDendrites) # check capab.
#
#for d in self.cell.dend:
# if h.SectionRef(sec = d).has_parent != 0:
# h.disconnect(sec = d)
h.disconnect(sec=self.cell.dend[0])
def move_spine(self, new_parent):
''' move spine from one section to another (using default orientation)
'''
h.disconnect(sec=self.neck)
self.neck.connect(new_parent(1),0)
self.parent = new_parent
def test():
sec = h.Section(name='dend')
for sec in h.allsec():
h.disconnect(sec=sec)
sref = h.SectionRef(sec=sec)
#defeated the guards against deleting the Section pointed to by
# a PythonSection
sref.rename('delete')
h.disconnect(sec=sec)
#used to be allowed only for hoc sections (create ...)
h.delete_section(sec=sec)
def neuron_instance(neuron_import):
"""Sets/Resets the rxd test environment.
Provides 'data', a dictionary used to store voltages and rxd node
values for comparisons with the 'correct_data'.
"""
h, rxd = neuron_import
data = {'record_count': 0, 'data': []}
h.load_file('stdrun.hoc')
cvode = h.CVode()
cvode.active(False)
cvode.atol(1e-3)
h.dt = 0.025
h.stoprun = False
def gather():
return collect_data(h, rxd, data)
cvode.extra_scatter_gather(0, gather)
yield (h, rxd, data)
rxd.region._all_regions = []
rxd.region._region_count = 0
rxd.region._c_region_lookup = None
for r in rxd.rxd._all_reactions[:]:
if r():
rxd.rxd._unregister_reaction(r)
for s in rxd.species._all_species:
if s():
s().__del__()
rxd.species._species_counts = 0
rxd.section1d._rxd_sec_lookup = {}
rxd.section1d._purge_cptrs()
rxd.initializer.has_initialized = False
rxd.rxd.free_conc_ptrs()
rxd.rxd.free_curr_ptrs()
rxd.rxd.rxd_include_node_flux1D(0, None, None, None)
for sec in h.allsec():
h.disconnect(sec=sec)
sref = h.SectionRef(sec=sec)
sref.rename('delete')
h.delete_section(sec=sec)
rxd.species._has_1d = False
rxd.species._has_3d = False
rxd.rxd._memb_cur_ptrs = []
rxd.rxd._rxd_induced_currents = None
rxd.rxd._curr_indices = None
rxd.rxd._zero_volume_indices = numpy.ndarray(0, dtype=numpy.int_)
rxd.set_solve_type(dimension=1)
cvode.extra_scatter_gather_remove(gather)
def AddSoma_callback():
s = ttk.Style()
s.configure('Gray.TEntry', background='gray')
if GUI.Buttons['AddSoma']['text'] == 'Add Soma':
soma_size = float(GUI.Entries['soma']['soma.diam']['Var'].get())
soma_cm = float(GUI.Entries['soma']['soma.cm']['Var'].get())
Simulator.CreateCompartment('soma',
L=soma_size,
diam=soma_size,
Ra=110,
e_pas=h.v_init,
g_pas=1.0 / 1500.0,
nseg=int(soma_size) * 5,
cm=soma_cm)
h.disconnect(sec=Simulator.soma)
Simulator.dend.connect(
Simulator.soma, 1, 0
) # Disconnect from parents if exist (following weird bug in which soma was created as child of last created section (spine head))
h.define_shape() # !Explain this
GUI.Buttons['AddSoma'][
'text'] = 'Remove Soma' #!Toggle soma function inside GUI
GUI.RadioButtons['volt_loc']['Buttons'][2].config(state='normal')
elif GUI.Buttons['AddSoma']['text'] == 'Remove Soma':
h.delete_section(sec=Simulator.soma)
Simulator.soma = None
GUI.Buttons['AddSoma']['text'] = 'Add Soma'
GUI.RadioButtons['volt_loc']['Var'].set(2)
GUI.RadioButtons['volt_loc']['Buttons'][2].config(state='disabled')
GUI.DrawSections(colors)
UpdatePresentedValues(GUI.ChangingLabels)
def test_disconnect():
print("test_disconnect")
for sec in h.allsec():
h.delete_section(sec=sec)
h.topology()
n = 5
def setup(n):
sections = [h.Section(name="s%d" % i) for i in range(n)]
for i, sec in enumerate(sections[1:]):
sec.connect(sections[i])
return sections
sl = setup(n)
def chk(sections, i):
print(sections, i)
h.topology()
x = len(sections[0].wholetree())
assert x == i
chk(sl, n)
h.disconnect(sec=sl[2])
chk(sl, 2)
sl = setup(n)
sl[2].disconnect()
chk(sl, 2)
sl = setup(n)
expect_err("h.disconnect(sl[2])")
expect_err("h.delete_section(sl[2])")
del sl
locals()
def subtree_reductor(original_cell,
synapses_list,
netcons_list,
reduction_frequency,
model_filename='model.hoc',
total_segments_manual=-1,
PP_params_dict=None,
mapping_type='impedance',
return_seg_to_seg=False
):
'''
Receives an instance of a cell with a loaded full morphology, a list of
synapse objects, a list of NetCon objects (the i'th netcon in the list
should correspond to the i'th synapse), the filename (string) of the model
template hoc file that the cell was instantiated from, the desired
reduction frequency as a float, optional parameter for the approximate
desired number of segments in the new model (if this parameter is empty,
the number of segments will be such that there is a segment for every 0.1
lambda), and an optional param for the point process to be compared before
deciding on whether to merge a synapse or not and reduces the cell (using
the given reduction_frequency). Creates a reduced instance using the model
template in the file whose filename is given as a parameter, and merges
synapses of the same type that get mapped to the same segment
(same "reduced" synapse object for them all, but different NetCon objects).
model_filename : model.hoc will use a default template
total_segments_manual: sets the number of segments in the reduced model
can be either -1, a float between 0 to 1, or an int
if total_segments_manual = -1 will do automatic segmentation
if total_segments_manual>1 will set the number of segments
in the reduced model to total_segments_manual
if 0>total_segments_manual>1 will automatically segment the model
but if the automatic segmentation will produce a segment number that
is lower than original_number_of_segments*total_segments_manual it
will set the number of segments in the reduced model to:
original_number_of_segments*total_segments_manual
return_seg_to_seg: if True the function will also return a textify version of the mapping
between the original segments to the reduced segments
Returns the new reduced cell, a list of the new synapses, and the list of
the inputted netcons which now have connections with the new synapses.
Notes:
1) The original cell instance, synapses and Netcons given as arguments are altered
by the function and cannot be used outside of it in their original context.
2) Synapses are determined to be of the same type and mergeable if their reverse
potential, tau1 and tau2 values are identical.
3) Merged synapses are assigned a single new synapse object that represents them
all, but keep their original NetCon objects. Each such NetCon now connects the
original synapse's NetStim with
the reduced synapse.
'''
if PP_params_dict is None:
PP_params_dict = {}
h.init()
model_obj_name = load_model(model_filename)
# finds soma properties
soma = original_cell.soma[0] if original_cell.soma.hname()[-1] == ']' else original_cell.soma
soma_cable = CableParams(length=soma.L, diam=soma.diam, space_const=None,
cm=soma.cm, rm=1.0 / soma.g_pas, ra=soma.Ra, e_pas=soma.e_pas,
electrotonic_length=None)
has_apical = len(list(original_cell.apical)) != 0
soma_ref = h.SectionRef(sec=soma)
axon_section, axon_is_parent, soma_axon_x = find_and_disconnect_axon(soma_ref)
roots_of_subtrees, num_of_subtrees = gather_subtrees(soma_ref)
sections_to_delete, section_per_subtree_index, mapping_sections_to_subtree_index = \
gather_cell_subtrees(roots_of_subtrees)
# preparing for reduction
# remove active conductances and get seg_to_mech dictionary
segment_to_mech_vals = create_segments_to_mech_vals(sections_to_delete)
# disconnects all the subtrees from the soma
subtrees_xs = []
for subtree_root in roots_of_subtrees:
subtrees_xs.append(subtree_root.parentseg().x)
h.disconnect(sec=subtree_root)
# reducing the subtrees
new_cable_properties = [reduce_subtree(roots_of_subtrees[i], reduction_frequency)
for i in num_of_subtrees]
if total_segments_manual > 1:
new_cables_nsegs = calculate_nsegs_from_manual_arg(new_cable_properties,
total_segments_manual)
else:
new_cables_nsegs = calculate_nsegs_from_lambda(new_cable_properties)
if total_segments_manual > 0:
original_cell_seg_n = (sum(i.nseg for i in list(original_cell.basal)) +
sum(i.nseg for i in list(original_cell.apical))
)
min_reduced_seg_n = int(round((total_segments_manual * original_cell_seg_n)))
if sum(new_cables_nsegs) < min_reduced_seg_n:
logger.debug("number of segments calculated using lambda is {}, "
"the original cell had {} segments. "
"The min reduced segments is set to {}% of reduced cell segments".format(
sum(new_cables_nsegs),
original_cell_seg_n,
total_segments_manual * 100))
logger.debug("the reduced cell nseg is set to %s" % min_reduced_seg_n)
new_cables_nsegs = calculate_nsegs_from_manual_arg(new_cable_properties,
min_reduced_seg_n)
cell, basals = create_reduced_cell(soma_cable,
has_apical,
original_cell,
model_obj_name,
new_cable_properties,
new_cables_nsegs,
subtrees_xs)
new_synapses_list, subtree_ind_to_q = merge_and_add_synapses(
num_of_subtrees,
new_cable_properties,
PP_params_dict,
synapses_list,
mapping_sections_to_subtree_index,
netcons_list,
has_apical,
roots_of_subtrees,
original_cell,
basals,
cell,
reduction_frequency)
# create segment to segment mapping
original_seg_to_reduced_seg, reduced_seg_to_original_seg = create_seg_to_seg(
original_cell,
section_per_subtree_index,
roots_of_subtrees,
mapping_sections_to_subtree_index,
new_cable_properties,
has_apical,
cell.apic,
basals,
subtree_ind_to_q,
mapping_type,
reduction_frequency)
# copy active mechanisms
copy_dendritic_mech(original_seg_to_reduced_seg,
reduced_seg_to_original_seg,
cell.apic,
basals,
segment_to_mech_vals,
mapping_type)
if return_seg_to_seg:
original_seg_to_reduced_seg_text = textify_seg_to_seg(original_seg_to_reduced_seg)
# Connect axon back to the soma
if len(axon_section) > 0:
if axon_is_parent:
soma.connect(axon_section[0])
else:
axon_section[0].connect(soma, soma_axon_x)
# Now we delete the original model
for section in sections_to_delete:
with push_section(section):
h.delete_section()
cell.axon = axon_section
cell.dend = cell.hoc_model.dend
with push_section(cell.hoc_model.soma[0]):
h.delete_section()
if return_seg_to_seg:
return cell, new_synapses_list, netcons_list, original_seg_to_reduced_seg_text
else:
return cell, new_synapses_list, netcons_list
def subtree_reductor(original_cell,
synapses_list,
netcons_list,
reduction_frequency,
model_filename='model.hoc',
total_segments_manual=-1,
PP_params_dict=None,
mapping_type='impedance'):
'''
Receives an instance of a cell with a loaded full morphology, a list of
synapse objects, a list of NetCon objects (the i'th netcon in the list
should correspond to the i'th synapse), the filename (string) of the model
template hoc file that the cell was instantiated from, the desired
reduction frequency as a float, optional parameter for the approximate
desired number of segments in the new model (if this parameter is empty,
the number of segments will be such that there is a segment for every 0.1
lambda), and an optional param for the point process to be compared before
deciding on whethet to merge a synapse or not and reduces the cell (using
the given reduction_frequency). Creates a reduced instance using the model
template in the file whose filename is given as a parameter, and merges
synapses of the same type that get mapped to the same segment
(same "reduced" synapse object for them all, but different NetCon objects).
Returns the new reduced cell, a list of the new synapses, and the list of
the inputted netcons which now have connections with the new synapses.
note #0: a default template is available, one can use:
model_filename=model.hoc note #1: The original cell instance, synapses and
Netcons given as arguments are altered by the function and cannot be used
outside of it in their original context. note #2: Synapses are determined
to be of the same type and mergeable if their reverse potential, tau1 and
tau2 values are identical. note #3: Merged synapses are assigned a single
new synapse object that represents them all, but keep their original NetCon
objects. Each such NetCon now connects the original synapse's NetStim with
the reduced synapse.
'''
if PP_params_dict is None:
PP_params_dict = {}
h.init()
model_obj_name = load_model(model_filename)
# finds soma properties
soma = original_cell.soma[0] if original_cell.soma.hname(
)[-1] == ']' else original_cell.soma
soma_cable = CableParams(length=soma.L,
diam=soma.diam,
space_const=None,
cm=soma.cm,
rm=1.0 / soma.g_pas,
ra=soma.Ra,
e_pas=soma.e_pas,
electrotonic_length=None)
has_apical = len(list(original_cell.apical)) != 0
soma_ref = h.SectionRef(sec=soma)
axon_section, axon_is_parent = find_and_disconnect_axon(soma_ref)
roots_of_subtrees, num_of_subtrees = gather_subtrees(soma_ref)
sections_to_delete, section_per_subtree_index, mapping_sections_to_subtree_index = \
gather_cell_subtrees(roots_of_subtrees)
# preparing for reduction
# remove active conductances and get seg_to_mech dictionary
segment_to_mech_vals = create_segments_to_mech_vals(sections_to_delete)
# disconnects all the subtrees from the soma
for subtree_root in roots_of_subtrees:
h.disconnect(sec=subtree_root)
# reducing the subtrees
new_cable_properties = [
reduce_subtree(roots_of_subtrees[i], reduction_frequency)
for i in num_of_subtrees
]
if total_segments_manual != -1:
new_cables_nsegs = calculate_nsegs_from_manual_arg(
new_cable_properties, total_segments_manual)
else:
new_cables_nsegs = calculate_nsegs_from_lambda(new_cable_properties)
cell, basals = create_reduced_cell(soma_cable, has_apical, original_cell,
model_obj_name, new_cable_properties,
new_cables_nsegs)
new_synapses_list, subtree_ind_to_q = merge_and_add_synapses(
num_of_subtrees, new_cable_properties, PP_params_dict, synapses_list,
mapping_sections_to_subtree_index, netcons_list, has_apical,
roots_of_subtrees, original_cell, basals, cell, reduction_frequency)
# create segment to segment mapping
original_seg_to_reduced_seg, reduced_seg_to_original_seg = create_seg_to_seg(
original_cell, section_per_subtree_index, roots_of_subtrees,
mapping_sections_to_subtree_index, new_cable_properties, has_apical,
cell.apic, basals, subtree_ind_to_q, mapping_type, reduction_frequency)
# copy active mechanisms
copy_dendritic_mech(original_seg_to_reduced_seg,
reduced_seg_to_original_seg, cell.apic, basals,
segment_to_mech_vals, mapping_type)
# Connect axon back to the soma
if len(axon_section) > 0:
if axon_is_parent:
soma.connect(axon_section[0])
else:
axon_section[0].connect(soma)
# Now we delete the original model
for section in sections_to_delete:
with push_section(section):
h.delete_section()
cell.axon = axon_section
cell.dend = cell.hoc_model.dend
with push_section(cell.hoc_model.soma[0]):
h.delete_section()
return cell, new_synapses_list, netcons_list
proc init() {
connect dend(0), soma(1)
soma { L=10 diam= 10 insert hh }
dend { L=20 diam=1 insert pas g_pas = .001 e_pas = -65 }
}
endtemplate Cell
""")
# 1 cell for each rank
cell = h.Cell()
# rank 0 cell uses multisplit. Works if rank = 1
if rank == 0:
h.disconnect(sec=cell.dend)
pc.multisplit(0.0, rank, sec=cell.dend)
pc.multisplit(1.0, rank, sec=cell.soma)
# gap junction between soma of rank i and rank (i+1)%nhost
# use sids of 2*i and 2*i + 1 for the source voltages
halfgaps = []
def mkgap(i):
if rank == i:
gap = h.HalfGap(cell.soma(0.5))
halfgaps.append(gap)
pc.source_var(cell.soma(0.5)._ref_v, i, sec=cell.soma)
gap = pc.target_var(gap, gap._ref_vgap, i + 1)
if rank == (i + 1) % nhost:
