def testChannelFitMats(self):
self.loadBall()
cm = CompartmentFitter(self.tree)
cm.setCTree([(1, .5)])
# check if reversals are correct
for key in set(cm.ctree[0].currents) - {'L'}:
assert np.abs(cm.ctree[0].currents[key][1] - \
self.tree[1].currents[key][1]) < 1e-10
# fit the passive model
cm.fitPassive(use_all_channels=False)
fit_mats_cm_na = cm.evalChannel('Na_Ta', parallel=False)
fit_mats_cm_k = cm.evalChannel('Kv3_1', parallel=False)
fit_mats_control_na, fit_mats_control_k = self.reduceExplicit()
# test whether potassium fit matrices agree
for fm_cm, fm_control in zip(fit_mats_cm_k, fit_mats_control_k):
assert np.allclose(np.sum(fm_cm[0]),
fm_control[0][0, 0]) # feature matrices
assert np.allclose(fm_cm[1], fm_control[1]) # target vectors
# test whether sodium fit matrices agree
for fm_cm, fm_control in zip(fit_mats_cm_na[4:], fit_mats_control_na):
assert np.allclose(np.sum(fm_cm[0]),
fm_control[0][0, 0]) # feature matrices
assert np.allclose(fm_cm[1], fm_control[1]) # target vectors
def testTreeStructure(self):
self.loadTTree()
cm = CompartmentFitter(self.tree)
# set of locations
fit_locs1 = [(1,.5), (4,.5), (5,.5)] # no bifurcations
fit_locs2 = [(1,.5), (4,.5), (5,.5), (8,.5)] # w bifurcation, should be added
fit_locs3 = [(1,.5), (4,1.), (5,.5), (8,.5)] # w bifurcation, already added
# test fit_locs1, no bifurcation are added
# input paradigm 1
cm.setCTree(fit_locs1, extend_w_bifurc=True)
def testRecalcImpedanceMatrix(self, g_inp=np.linspace(0., 0.01, 20)):
self.loadBall()
fit_locs = [(1, .5)]
cm = CompartmentFitter(self.tree)
cm.setCTree(fit_locs)
# test only leak
# compute impedances explicitly
greens_tree = cm.createTreeGF(channel_names=[])
greens_tree.setEEq(-75.)
greens_tree.setImpedancesInTree()
z_mat = greens_tree.calcImpedanceMatrix(fit_locs,
explicit_method=False)[0]
z_test = z_mat[:, :,
None] / (1. + z_mat[:, :, None] * g_inp[None, None, :])
# compute impedances with compartmentfitter function
z_calc = np.array([ \
cm.recalcImpedanceMatrix('fit locs', [g_i], \
channel_names=[]
) \
for g_i in g_inp \
])
z_calc = np.swapaxes(z_calc, 0, 2)
assert np.allclose(z_calc, z_test)
# test with z based on all channels (passive)
# compute impedances explicitly
greens_tree = cm.createTreeGF(
channel_names=list(cm.tree.channel_storage.keys()))
greens_tree.setEEq(-75.)
greens_tree.setImpedancesInTree()
z_mat = greens_tree.calcImpedanceMatrix(fit_locs,
explicit_method=False)[0]
z_test = z_mat[:, :,
None] / (1. + z_mat[:, :, None] * g_inp[None, None, :])
# compute impedances with compartmentfitter function
z_calc = np.array([ \
cm.recalcImpedanceMatrix('fit locs', [g_i], \
channel_names=list(cm.tree.channel_storage.keys())) \
for g_i in g_inp \
])
z_calc = np.swapaxes(z_calc, 0, 2)
assert np.allclose(z_calc, z_test)
def testSynRescale(self, g_inp=np.linspace(0., 0.01, 20)):
e_rev, v_eq = 0., -75.
self.loadBallAndStick()
fit_locs = [(4, .7)]
syn_locs = [(4, 1.)]
cm = CompartmentFitter(self.tree)
cm.setCTree(fit_locs)
# compute impedance matrix
greens_tree = cm.createTreeGF(channel_names=[])
greens_tree.setEEq(-75.)
greens_tree.setImpedancesInTree()
z_mat = greens_tree.calcImpedanceMatrix(fit_locs + syn_locs)[0]
# analytical synapse scale factors
beta_calc = 1. / (1. + (z_mat[1, 1] - z_mat[0, 0]) * g_inp)
beta_full = z_mat[0,1] / z_mat[0,0] * (e_rev - v_eq) / \
((1. + (z_mat[1,1] - z_mat[0,0]) * g_inp ) * (e_rev - v_eq))
# synapse scale factors from compartment fitter
beta_cm = np.array([cm.fitSynRescale(fit_locs, syn_locs, [0], [g_i], e_revs=[0.])[0] \
for g_i in g_inp])
assert np.allclose(beta_calc, beta_cm, atol=.020)
assert np.allclose(beta_full, beta_cm, atol=.015)
def basalAPBackProp(recompute_ctree=False, recompute_biophys=False, axes=None, pshow=True):
global STIM_PARAMS, D2S_BASAL, SLOCS
global CMAP_MORPH
rc, rb = recompute_ctree, recompute_biophys
if axes is None:
pl.figure(figsize=(7,5))
ax1, ax2, ax4, ax5 = pl.subplot(221), pl.subplot(223), pl.subplot(222), pl.subplot(224)
divider = make_axes_locatable(ax1)
ax3 = divider.append_axes("top", "30%", pad="10%")
ax4, ax5 = myAx(ax4), myAx(ax5)
pl.figure(figsize=(5,5))
gs = GridSpec(2,2)
ax_morph, ax_red1, ax_red2 = pl.subplot(gs[:,0]), pl.subplot(gs[1,0]), pl.subplot(gs[1,1])
else:
ax1, ax2, ax3 = axes['trace']
ax4, ax5 = axes['amp-delay']
ax_morph, ax_red1, ax_red2 = axes['morph']
pshow = False
# create the full model
phys_tree = getL23PyramidNaK()
sim_tree = phys_tree.__copy__(new_tree=NeuronSimTree())
# distribute locations to measure backAPs on branches
leafs_basal = [node for node in sim_tree.leafs if node.swc_type == 3]
branches = [sim_tree.pathToRoot(leaf)[::-1] for leaf in leafs_basal]
locslist = [sim_tree.distributeLocsOnNodes(D2S_BASAL, node_arg=branch) for branch in branches]
branchlist = [b for ii, b in enumerate(branches) if len(locslist[ii]) == 3]
locs = [locs for locs in locslist if len(locs) == 3][1]
# do back prop sims
amp_diffs_3loc, delay_diffs_3loc = np.zeros(3), np.zeros(3)
amp_diffs_1loc, delay_diffs_1loc = np.zeros(3), np.zeros(3)
amp_diffs_biop, delay_diffs_biop = np.zeros(3), np.zeros(3)
# compartmentfitter object
cfit = CompartmentFitter(phys_tree, name='basal_bAP', path='data/')
# create reduced tree
ctree, clocs = getCTree(cfit, [SLOCS[0]] + locs, 'data/ctree_basal_bAP_3loc',
recompute_ctree=rc, recompute_biophys=rb)
csimtree = createReducedNeuronModel(ctree)
print(ctree)
# run the simulation of he full tree
res = runSim(sim_tree, locs, SLOCS[0], stim_params=STIM_PARAMS)
calcAmpDelayWidth(res)
amp_diffs_biop[:] = res['amp'][1:]
delay_diffs_biop[:] = res['delay'][1:]
# run the simulation of the reduced tree
cres = runSim(csimtree, clocs[1:], clocs[0], stim_params=STIM_PARAMS)
calcAmpDelayWidth(cres)
amp_diffs_3loc[:] = cres['amp'][1:]
delay_diffs_3loc[:] = cres['delay'][1:]
# reduced models with one single dendritic site
creslist = []
for jj, loc in enumerate(locs):
# create reduced tree with all 1 single dendritic site locs
ctree, clocs = getCTree(cfit, [SLOCS[0]] + [loc], 'data/ctree_basal_bAP_1loc%d'%jj,
recompute_ctree=rc, recompute_biophys=False)
csimtree = createReducedNeuronModel(ctree)
print(ctree)
# run the simulation of the reduced tree
cres_ss = runSim(csimtree, [clocs[1]], clocs[0], stim_params=STIM_PARAMS)
calcAmpDelayWidth(cres_ss)
creslist.append(cres_ss)
amp_diffs_1loc[jj] = cres_ss['amp'][1]
delay_diffs_1loc[jj] = cres_ss['delay'][1]
ylim = (-90., 60.)
x_range = np.array([-3.,14])
xlim = (0., 12.)
tp_full = res['t'][np.argmax(res['v_m'][0])]
tp_3comp = cres['t'][np.argmax(cres['v_m'][0])]
tp_1comp = creslist[2]['t'][np.argmax(creslist[2]['v_m'][0])]
tlim_full = tp_full + x_range
tlim_3comp = tp_3comp + x_range
tlim_1comp = tp_1comp + x_range
i0_full, i1_full = np.round(tlim_full / DT).astype(int)
i0_3comp, i1_3comp = np.round(tlim_3comp / DT).astype(int)
i0_1comp, i1_1comp = np.round(tlim_1comp / DT).astype(int)
ax1.set_ylabel(r'soma')
ax1.plot(res['t'][i0_full:i1_full] - tlim_full[0], res['v_m'][0][i0_full:i1_full],
lw=lwidth, c='DarkGrey', label=r'full')
ax1.plot(cres['t'][i0_3comp:i1_3comp] - tlim_3comp[0], cres['v_m'][0][i0_3comp:i1_3comp],
ls='--', lw=1.6*lwidth, c=colours[0], label=r'3 comp')
ax1.plot(creslist[2]['t'][i0_1comp:i1_1comp] - tlim_1comp[0], creslist[2]['v_m'][0][i0_1comp:i1_1comp],
ls='-.', lw=1.6*lwidth, c=colours[1], label=r'1 comp')
ax1.set_ylim(ylim)
# ax1.set_xlim(xlim)
drawScaleBars(ax1, b_offset=15)
myLegend(ax1, add_frame=False, loc='center left', bbox_to_anchor=[0.35, 0.55], fontsize=ticksize,
labelspacing=.8, handlelength=2., handletextpad=.2)
ax2.set_ylabel(r'dend' + '\n($d_{soma} = 150$ $\mu$m)')
ax2.plot(res['t'][i0_full:i1_full] - tlim_full[0], res['v_m'][3][i0_full:i1_full],
lw=lwidth, c='DarkGrey', label=r'full')
ax2.plot(cres['t'][i0_3comp:i1_3comp] - tlim_3comp[0], cres['v_m'][3][i0_3comp:i1_3comp],
ls='--', lw=1.6*lwidth, c=colours[0], label=r'3 comp')
ax2.plot(creslist[2]['t'][i0_1comp:i1_1comp] - tlim_1comp[0], creslist[2]['v_m'][1][i0_1comp:i1_1comp],
ls='-.', lw=1.6*lwidth, c=colours[1], label=r'1 comp')
imax = np.argmax(res['v_m'][3])
xp = res['t'][imax]
ax2.annotate(r'$v_{amp}$',
xy=(xlim[0], np.mean(ylim)), xytext=(xlim[0], np.mean(ylim)),
fontsize=ticksize, ha='center', va='center', rotation=90.)
ax2.annotate(r'$t_{delay}$',
xy=(xp, ylim[1]), xytext=(xp, ylim[1]),
fontsize=ticksize, ha='center', va='center', rotation=0.)
ax2.set_ylim(ylim)
ax2.set_xlim(xlim)
drawScaleBars(ax2, xlabel=' ms', ylabel=' mV', b_offset=15)
# myLegend(ax2, add_frame=False, ncol=2, fontsize=ticksize,
# loc='upper center', bbox_to_anchor=[.5, -.1],
# labelspacing=.6, handlelength=2., handletextpad=.2, columnspacing=.5)
ax3.plot(res['t'][i0_full:i1_full] - tlim_full[0], -res['i_clamp'][0][i0_full:i1_full],
lw=lwidth, c='r')
ax3.set_yticks([0.,3.])
drawScaleBars(ax3, ylabel=' nA', b_offset=0)
# ax3.set_xlim(xlim)
# color the branches
cnodes = [b for branch in branches for b in branch]
if cnodes is None:
plotargs = {'lw': lwidth/1.3, 'c': 'DarkGrey'}
cs = {node.index: 0 for node in sim_tree}
else:
plotargs = {'lw': lwidth/1.3}
cinds = [n.index for n in cnodes]
cs = {node.index: 1 if node.index in cinds else 0 for node in sim_tree}
# mark example locations
plocs = [SLOCS[0]] + locs
markers = [{'marker': 's', 'c': cfl[0], 'mec': 'k', 'ms': markersize}] + \
[{'marker': 's', 'c': cfl[1], 'mec': 'k', 'ms': markersize} for _ in plocs[1:]]
# plot morphology
sim_tree.plot2DMorphology(ax_morph, use_radius=False, plotargs=plotargs,
cs=cs, cmap=CMAP_MORPH,
marklocs=plocs, locargs=markers, lims_margin=0.01)
# plot compartment tree schematic
ctree_3l = cfit.setCTree([SLOCS[0]] + locs)
ctree_3l = cfit.ctree
ctree_1l = cfit.setCTree([SLOCS[0]] + locs[0:1])
ctree_1l = cfit.ctree
labelargs = {0: {'marker': 's', 'mfc': cfl[0], 'mec': 'k', 'ms': markersize*1.2}}
labelargs.update({ii: {'marker': 's', 'mfc': cfl[1], 'mec': 'k', 'ms': markersize*1.2} for ii in range(1,len(plocs))})
ctree_3l.plotDendrogram(ax_red1, plotargs={'c':'k', 'lw': lwidth}, labelargs=labelargs)
labelargs = {0: {'marker': 's', 'mfc': cfl[0], 'mec': 'k', 'ms': markersize*1.2},
1: {'marker': 's', 'mfc': cfl[1], 'mec': 'k', 'ms': markersize*1.2}}
ctree_1l.plotDendrogram(ax_red2, plotargs={'c':'k', 'lw': lwidth}, labelargs=labelargs)
ax_red1.set_xticks([]); ax_red1.set_yticks([])
ax_red1.set_xlabel(r'$\Delta x = 50$ $\mu$m', fontsize=ticksize,rotation=60)
ax_red2.set_xticks([]); ax_red2.set_yticks([])
ax_red2.set_xlabel(r'$\Delta x = 150$ $\mu$m', fontsize=ticksize,rotation=60)
xb = np.arange(3)
bwidth = 1./4.
xtls = [r'50', r'100', r'150']
ax4, ax5 = myAx(ax4), myAx(ax5)
ax4.bar(xb-bwidth, amp_diffs_biop, width=bwidth, align='center', color='DarkGrey', edgecolor='k', label=r'full')
ax4.bar(xb, amp_diffs_3loc, width=bwidth, align='center', color=colours[0], edgecolor='k', label=r'4 comp')
ax4.bar((xb+bwidth)[-1:], amp_diffs_1loc[-1:], width=bwidth, align='center', color=colours[1], edgecolor='k', label=r'2 comp')
ax4.set_ylabel(r'$v_{amp}$ (mV)')
ax4.set_xticks(xb)
ax4.set_xticklabels([])
ax4.set_ylim(50.,110.)
ax4.set_yticks([50., 80.])
myLegend(ax4, add_frame=False, loc='lower center', bbox_to_anchor=[.5, 1.05], fontsize=ticksize,
labelspacing=.1, handlelength=1., handletextpad=.2, columnspacing=.5)
ax5.bar(xb-bwidth, delay_diffs_biop, width=bwidth, align='center', color='DarkGrey', edgecolor='k', label=r'full')
ax5.bar(xb, delay_diffs_3loc, width=bwidth, align='center', color=colours[0], edgecolor='k', label=r'4 comp')
ax5.bar((xb+bwidth)[-1:], delay_diffs_1loc[-1:], width=bwidth, align='center', color=colours[1], edgecolor='k', label=r'2 comp')
ax5.set_ylabel(r'$t_{delay}$ (ms)')
ax5.set_xticks(xb)
ax5.set_xticklabels(xtls)
ax5.set_xlabel(r'$d_{soma}$ ($\mu$m)')
ax5.set_yticks([0., 0.5])
if pshow:
pl.show()
def testPassiveFit(self):
self.loadTTree()
fit_locs = [(1, .5), (4, 1.), (5, .5), (8, .5)]
# fit a tree directly from CompartmentTree
greens_tree = self.tree.__copy__(new_tree=GreensTree())
greens_tree.setCompTree()
freqs = np.array([0.])
greens_tree.setImpedance(freqs)
z_mat = greens_tree.calcImpedanceMatrix(fit_locs)[0].real
ctree = greens_tree.createCompartmentTree(fit_locs)
ctree.computeGMC(z_mat)
sov_tree = self.tree.__copy__(new_tree=SOVTree())
sov_tree.calcSOVEquations()
alphas, phimat = sov_tree.getImportantModes(locarg=fit_locs)
ctree.computeC(-alphas[0:1].real * 1e3, phimat[0:1, :].real)
# fit a tree with compartment fitter
cm = CompartmentFitter(self.tree)
cm.setCTree(fit_locs)
cm.fitPassive()
cm.fitCapacitance()
cm.fitEEq()
# check whether both trees are the same
self._checkPasCondProps(ctree, cm.ctree)
self._checkPasCaProps(ctree, cm.ctree)
self._checkEL(cm.ctree, -75.)
# test whether all channels are used correctly for passive fit
self.loadBall()
fit_locs = [(1, .5)]
# fit ball model with only leak
greens_tree = self.tree.__copy__(new_tree=GreensTree())
greens_tree.channel_storage = {}
for n in greens_tree:
n.currents = {'L': n.currents['L']}
greens_tree.setCompTree()
freqs = np.array([0.])
greens_tree.setImpedance(freqs)
z_mat = greens_tree.calcImpedanceMatrix(fit_locs)[0].real
ctree_leak = greens_tree.createCompartmentTree(fit_locs)
ctree_leak.computeGMC(z_mat)
sov_tree = greens_tree.__copy__(new_tree=SOVTree())
sov_tree.calcSOVEquations()
alphas, phimat = sov_tree.getImportantModes(locarg=fit_locs)
ctree_leak.computeC(-alphas[0:1].real * 1e3, phimat[0:1, :].real)
# make ball model with leak based on all channels
tree = self.tree.__copy__()
tree.asPassiveMembrane()
greens_tree = tree.__copy__(new_tree=GreensTree())
greens_tree.setCompTree()
freqs = np.array([0.])
greens_tree.setImpedance(freqs)
z_mat = greens_tree.calcImpedanceMatrix(fit_locs)[0].real
ctree_all = greens_tree.createCompartmentTree(fit_locs)
ctree_all.computeGMC(z_mat)
sov_tree = tree.__copy__(new_tree=SOVTree())
sov_tree.calcSOVEquations()
alphas, phimat = sov_tree.getImportantModes(locarg=fit_locs)
ctree_all.computeC(-alphas[0:1].real * 1e3, phimat[0:1, :].real)
# new compartment fitter
cm = CompartmentFitter(self.tree)
cm.setCTree(fit_locs)
# test fitting
cm.fitPassive(use_all_channels=False)
cm.fitCapacitance()
cm.fitEEq()
self._checkPasCondProps(ctree_leak, cm.ctree)
self._checkPasCaProps(ctree_leak, cm.ctree)
with pytest.raises(AssertionError):
self._checkEL(cm.ctree, self.tree[1].currents['L'][1])
cm.fitPassive(use_all_channels=True)
cm.fitCapacitance()
cm.fitEEq()
self._checkPasCondProps(ctree_all, cm.ctree)
self._checkPasCaProps(ctree_all, cm.ctree)
self._checkEL(cm.ctree, greens_tree[1].currents['L'][1])
with pytest.raises(AssertionError):
self._checkEL(cm.ctree, self.tree[1].currents['L'][1])
with pytest.raises(AssertionError):
self._checkPasCondProps(ctree_leak, ctree_all)
def testTreeStructure(self):
self.loadTTree()
cm = CompartmentFitter(self.tree)
# set of locations
fit_locs1 = [(1, .5), (4, .5), (5, .5)] # no bifurcations
fit_locs2 = [(1, .5), (4, .5), (5, .5),
(8, .5)] # w bifurcation, should be added
fit_locs3 = [(1, .5), (4, 1.), (5, .5),
(8, .5)] # w bifurcation, already added
# test fit_locs1, no bifurcation are added
# input paradigm 1
cm.setCTree(fit_locs1, extend_w_bifurc=True)
fl1_a = cm.tree.getLocs('fit locs')
cm.setCTree(fit_locs1, extend_w_bifurc=False)
fl1_b = cm.tree.getLocs('fit locs')
assert len(fl1_a) == len(fl1_b)
for fla, flb in zip(fl1_a, fl1_b):
assert fla == flb
# input paradigm 2
cm.tree.storeLocs(fit_locs1, 'fl1')
cm.setCTree('fl1', extend_w_bifurc=True)
fl1_a = cm.tree.getLocs('fit locs')
assert len(fl1_a) == len(fl1_b)
for fla, flb in zip(fl1_a, fl1_b):
assert fla == flb
# test tree structure
assert len(cm.ctree) == 3
for cn in cm.ctree:
assert len(cn.child_nodes) <= 1
# test fit_locs2, a bifurcation should be added
with pytest.warns(UserWarning):
cm.setCTree(fit_locs2, extend_w_bifurc=False)
fl2_b = cm.tree.getLocs('fit locs')
cm.setCTree(fit_locs2, extend_w_bifurc=True)
fl2_a = cm.tree.getLocs('fit locs')
assert len(fl2_a) == len(fl2_b) + 1
for fla, flb in zip(fl2_a, fl2_b):
assert fla == flb
assert fl2_a[-1] == (4, 1.)
# test tree structure
assert len(cm.ctree) == 5
for cn in cm.ctree:
assert len(cn.child_nodes) <= 1 if cn.loc_ind != 4 else \
len(cn.child_nodes) == 2
# test fit_locs2, no bifurcation should be added as it is already present
cm.setCTree(fit_locs3, extend_w_bifurc=True)
fl3 = cm.tree.getLocs('fit locs')
for fl_, fl3 in zip(fit_locs3, fl3):
assert fl_ == fl3
# test tree structure
assert len(cm.ctree) == 4
for cn in cm.ctree:
assert len(cn.child_nodes) <= 1 if cn.loc_ind != 1 else \
len(cn.child_nodes) == 2
