def _createGreensTrees(self): """ _1 -> decrease in s2d attenuation in control compared to zd _2 -> increase in s2d attenuation in control compared to zd """ sim_tree_zd = self.model_evaluator.getTreeWithParams() sim_tree_wh_1 = self.att_evaluator_1.getTreeWithParams() sim_tree_wh_2 = self.att_evaluator_2.getTreeWithParams() self.greens_tree_zd = sim_tree_zd.__copy__(new_tree=GreensTree()) self.greens_tree_wh_1 = sim_tree_wh_1.__copy__(new_tree=GreensTree()) self.greens_tree_wh_2 = sim_tree_wh_2.__copy__(new_tree=GreensTree()) # for n1, n2, n3 in zip(self.greens_tree_zd, self.greens_tree_wh_1, self.greens_tree_wh_2): print(n1.e_eq, n2.e_eq, n3.e_eq) # self.greens_tree_zd.setEEq(-60.) # self.greens_tree_wh_1.setEEq(-60.) # self.greens_tree_wh_2.setEEq(-60.) self.greens_tree_zd.setCompTree() self.greens_tree_wh_1.setCompTree() self.greens_tree_wh_2.setCompTree() self.greens_tree_zd.setImpedance(np.array([0.])) self.greens_tree_wh_1.setImpedance(np.array([0.])) self.greens_tree_wh_2.setImpedance(np.array([0.]))
def createPointNeurons(self, v_eq=-75.): self.v_eq = v_eq self.dt = .025 gh, eh = 50., -43. h_chan = channelcollection.h() self.greens_tree = GreensTree( file_n=os.path.join(MORPHOLOGIES_PATH_PREFIX, 'ball.swc')) self.greens_tree.setPhysiology(1., 100. / 1e6) self.greens_tree.addCurrent(h_chan, gh, eh) self.greens_tree.fitLeakCurrent(v_eq, 10.) self.greens_tree.setEEq(v_eq) self.greens_tree_pas = self.greens_tree.__copy__(new_tree=GreensTree()) self.greens_tree_pas.asPassiveMembrane() self.sim_tree = self.greens_tree.__copy__(new_tree=NeuronSimTree()) # set the impedances self.greens_tree_pas.setCompTree() self.freqs = np.array([0.]) self.greens_tree_pas.setImpedance(self.freqs) # create sov tree self.sov_tree = self.greens_tree_pas.__copy__(new_tree=SOVTree()) self.sov_tree.calcSOVEquations(maxspace_freq=50.) z_inp = self.greens_tree_pas.calcZF((1, .5), (1, .5))[0] alphas, gammas = self.sov_tree.getSOVMatrices(locarg=[(1., .5)]) # create NET node_0 = NETNode(0, [0], [0], z_kernel=(alphas, gammas[:, 0]**2)) net_py = NET() net_py.setRoot(node_0) # check if correct assert np.abs(gammas[0, 0]**2 / np.abs(alphas[0]) - z_inp) < 1e-10 assert np.abs(node_0.z_bar - z_inp) < 1e-10 # to initialize neuron tree self.sim_tree.initModel(dt=self.dt) # add ion channel to NET simulator a_soma = 4. * np.pi * (self.sim_tree[1].R * 1e-4)**2 self.cnet = netsim.NETSim(net_py, v_eq=self.v_eq) hchan = channelcollection.h() self.cnet.addChannel(hchan, 0, gh * a_soma, eh) # add the synapse # to neuron tree self.sim_tree.addDoubleExpSynapse((1, .5), .2, 3., 0.) self.sim_tree.setSpikeTrain(0, 0.001, [5.]) # to net sim self.cnet.addSynapse(0, { 'tau_r': .2, 'tau_d': 3., 'e_r': 0. }, g_max=0.001) self.cnet.setSpikeTimes(0, [5. + self.dt])
def loadTTreeTestChannel(self): """ Load the T-tree morphology in memory with h-current 6--5--4--7--8 | | 1 """ v_eq = -75. self.dt = 0.025 self.tmax = 100. # for frequency derivation self.ft = ke.FourrierTools(np.arange(0., self.tmax, self.dt)) # load the morphology test_chan = channelcollection.TestChannel2() fname = os.path.join(MORPHOLOGIES_PATH_PREFIX, 'Tsovtree.swc') self.greenstree = GreensTree(fname, types=[1, 3, 4]) self.greenstree.addCurrent(test_chan, 50., -23.) self.greenstree.fitLeakCurrent(v_eq, 10.) self.greenstree.setCompTree() self.greenstree.setImpedance(self.ft.s) # copy greenstree parameters into NEURON simulation tree self.neurontree = NeuronSimTree(dt=self.dt, t_calibrate=100., v_init=v_eq, factor_lambda=25.) self.greenstree.__copy__(self.neurontree) self.neurontree.treetype = 'computational'
def testPickling(self): self.loadBall() # of PhysTree ss = pickle.dumps(self.tree) pt_ = pickle.loads(ss) self._checkPhysTrees(self.tree, pt_) # of GreensTree greens_tree = self.tree.__copy__(new_tree=GreensTree()) greens_tree.setCompTree() freqs = np.array([0.]) greens_tree.setImpedance(freqs) ss = pickle.dumps(greens_tree) gt_ = pickle.loads(ss) self._checkPhysTrees(greens_tree, gt_) # of SOVTree sov_tree = self.tree.__copy__(new_tree=SOVTree()) sov_tree.calcSOVEquations() # works with pickle ss = pickle.dumps(sov_tree) st_ = pickle.loads(ss) self._checkPhysTrees(sov_tree, st_)
def loadTTreeActive(self): ''' Load the T-tree morphology in memory with h-current 6--5--4--7--8 | | 1 ''' v_eq = -75. self.dt = 0.025 self.tmax = 100. # for frequency derivation self.ft = ke.FourrierTools(np.arange(0., self.tmax, self.dt)) # load the morphology print '>>> loading T-tree <<<' fname = 'test_morphologies/Tsovtree.swc' self.greenstree = GreensTree(fname, types=[1,3,4]) self.greenstree.addCurrent('h', 50., -43.) self.greenstree.fitLeakCurrent(e_eq_target=v_eq, tau_m_target=10.) # for node in self.greenstree: # print node.getGTot(channel_storage=self.greenstree.channel_storage) # print node.currents self.greenstree.setCompTree() self.greenstree.setImpedance(self.ft.s) # copy greenstree parameters into NEURON simulation tree self.neurontree = neurm.NeuronSimTree(dt=self.dt, t_calibrate=10., v_eq=v_eq, factor_lambda=25.) self.greenstree.__copy__(self.neurontree) self.neurontree.treetype = 'computational'
def loadTTreeActive(self): """ Load the T-tree morphology in memory with h-current 6--5--4--7--8 | | 1 """ v_eq = -75. self.dt = 0.1 self.tmax = 100. # for frequency derivation self.ft = ke.FourrierTools(np.arange(0., self.tmax, self.dt)) # load the morphology print('>>> loading T-tree <<<') h_chan = channelcollection.h() fname = 'test_morphologies/Tsovtree.swc' self.greenstree = GreensTree(fname, types=[1, 3, 4]) self.greenstree.addCurrent(h_chan, 50., -43.) self.greenstree.fitLeakCurrent(v_eq, 10.) self.greenstree.setCompTree() self.greenstree.setImpedance(self.ft.s) # copy greenstree parameters into NEURON simulation tree self.neurontree = NeuronSimTree(dt=self.dt, t_calibrate=10., v_init=v_eq, factor_lambda=25.) self.greenstree.__copy__(self.neurontree) self.neurontree.treetype = 'computational'
def testFitModel(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] 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 compartmentfitter cm = CompartmentFitter(self.tree) ctree_cm = cm.fitModel(fit_locs) # compare the two trees self._checkPasCondProps(ctree_cm, ctree) self._checkPasCaProps(ctree_cm, ctree) self._checkEL(ctree_cm, -75.) # check active channel self.fitBall() locs = [(1, 0.5)] cm = CompartmentFitter(self.tree) ctree_cm_1 = cm.fitModel(locs, parallel=False, use_all_chans_for_passive=False) ctree_cm_2 = cm.fitModel(locs, parallel=False, use_all_chans_for_passive=True) self._checkAllCurrProps(self.ctree, ctree_cm_1) self._checkAllCurrProps(self.ctree, ctree_cm_2)
def testPickling(self): self.loadBall() # of PhysTree ss = pickle.dumps(self.tree) pt_ = pickle.loads(ss) self._checkPhysTrees(self.tree, pt_) # of GreensTree greens_tree = self.tree.__copy__(new_tree=GreensTree()) greens_tree.setCompTree() freqs = np.array([0.]) greens_tree.setImpedance(freqs) ss = dill.dumps(greens_tree) gt_ = dill.loads(ss) self._checkPhysTrees(greens_tree, gt_) # of SOVTree sov_tree = self.tree.__copy__(new_tree=SOVTree()) sov_tree.calcSOVEquations() # fails with pickle (lambda functions) with pytest.raises(AttributeError): ss = pickle.dumps(sov_tree) # works with dill ss = dill.dumps(sov_tree) st_ = dill.loads(ss) self._checkPhysTrees(sov_tree, st_)
def loadValidationTree(self): """ Load the T-tree morphology in memory 5---1---4 """ fname = os.path.join(MORPHOLOGIES_PATH_PREFIX, 'sovvalidationtree.swc') self.tree = GreensTree(fname, types=[1,3,4]) self.tree.fitLeakCurrent(-75., 10.) self.tree.setCompTree()
def loadValidationTree(self): ''' Load the T-tree morphology in memory 5---1---4 ''' print '>>> loading validation tree <<<' fname = 'test_morphologies/sovvalidationtree.swc' self.tree = GreensTree(fname, types=[1,3,4]) self.tree.fitLeakCurrent(e_eq_target=-75., tau_m_target=10.) self.tree.setCompTree()
def loadValidationTree(self): """ Load the T-tree morphology in memory 5---1---4 """ print('>>> loading validation tree <<<') fname = 'test_morphologies/sovvalidationtree.swc' self.tree = GreensTree(fname, types=[1,3,4]) self.tree.fitLeakCurrent(-75., 10.) self.tree.setCompTree()
def loadBallAndStick(self): self.greens_tree = GreensTree(file_n=os.path.join( MORPHOLOGIES_PATH_PREFIX, 'ball_and_stick.swc')) self.greens_tree.setPhysiology(0.8, 100. / 1e6) self.greens_tree.setLeakCurrent(100., -75.) self.greens_tree.setCompTree() # set the impedances self.freqs = np.array([0.]) * 1j self.greens_tree.setImpedance(self.freqs) # create sov tree self.sov_tree = self.greens_tree.__copy__(new_tree=SOVTree()) self.sov_tree.calcSOVEquations(maxspace_freq=50.)
def loadTTree(self): """ Load the T-tree morphology in memory 6--5--4--7--8 | | 1 """ fname = os.path.join(MORPHOLOGIES_PATH_PREFIX, 'Tsovtree.swc') self.tree = GreensTree(fname, types=[1,3,4]) self.tree.fitLeakCurrent(-75., 10.) self.tree.setCompTree()
def loadTTree(self): """ Load the T-tree morphology in memory 6--5--4--7--8 | | 1 """ print('>>> loading T-tree <<<') fname = 'test_morphologies/Tsovtree.swc' self.tree = GreensTree(fname, types=[1,3,4]) self.tree.fitLeakCurrent(-75., 10.) self.tree.setCompTree()
def loadTTree(self): ''' Load the T-tree morphology in memory 6--5--4--7--8 | | 1 ''' print '>>> loading T-tree <<<' fname = 'test_morphologies/Tsovtree.swc' self.tree = GreensTree(fname, types=[1,3,4]) self.tree.fitLeakCurrent(e_eq_target=-75., tau_m_target=10.) self.tree.setCompTree()
def loadBallAndStick(self): self.greens_tree = GreensTree( file_n='test_morphologies/ball_and_stick.swc') for node in self.greens_tree: node.setPhysiology( 0.8, # Cm [uF/cm^2] 100. / 1e6, # Ra [MOhm*cm] ) node.addCurrent( 'L', # leak current 100., # g_max [uS/cm^2] -75., # e_rev [mV] ) self.greens_tree.setCompTree() # set the impedances self.freqs = np.array([0., 1., 10., 100., 1000]) * 1j self.greens_tree.setImpedance(self.freqs)
def getGreensTree(morph_name, physiology_type='Pas', recompute=False, freqs=None): if freqs is None: freqs = np.array([0.]) if morph_name[-4:] == '.swc': morph_name = morph_name[:-4] # load a greenstree greens_tree = GreensTree(file_n='morph/' + morph_name + '.swc') # set the physiological parameters eval('setPhysiology' + physiology_type + '(greens_tree)') # set the computational tree greens_tree.setCompTree(eps=1.) # set the impedance greens_tree.setImpedance(freqs) return greens_tree
def loadBall(self): self.greens_tree = GreensTree( file_n=os.path.join(MORPHOLOGIES_PATH_PREFIX, 'ball.swc')) # capacitance and axial resistance self.greens_tree.setPhysiology(0.8, 100. / 1e6) # ion channels k_chan = channelcollection.Kv3_1() self.greens_tree.addCurrent(k_chan, 0.766 * 1e6, -85.) na_chan = channelcollection.Na_Ta() self.greens_tree.addCurrent(na_chan, 1.71 * 1e6, 50.) # fit leak current self.greens_tree.fitLeakCurrent(-75., 10.) # set computational tree self.greens_tree.setCompTree() # set the impedances self.freqs = np.array([0.]) self.greens_tree.setImpedance(self.freqs) # create sov tree self.sov_tree = self.greens_tree.__copy__(new_tree=SOVTree()) self.sov_tree.calcSOVEquations(maxspace_freq=100.)
def testSingleCompartment(self): self.loadBall() # for validation greenstree = self.btree.__copy__(new_tree=GreensTree()) greenstree.setCompTree() greenstree.setImpedance(np.array([0.])) z_inp = greenstree.calcImpedanceMatrix([(1., 0.5)]) self.btree.calcSOVEquations(maxspace_freq=500) alphas, gammas = self.btree.getSOVMatrices(locarg=[(1., .5)]) z_inp_sov = self.btree.calcImpedanceMatrix(locarg=[(1., .5)]) assert alphas.shape[0] == 1 assert gammas.shape == (1, 1) assert np.abs(1. / np.abs(alphas[0]) - 10.) < 1e-10 g_m = self.btree[1].getGTot(self.btree.channel_storage) g_s = g_m * 4. * np.pi * (self.btree[1].R * 1e-4)**2 assert np.abs(gammas[0, 0]**2 / np.abs(alphas[0]) - 1. / g_s) < 1e-10 assert np.abs(z_inp_sov - 1. / g_s) < 1e-10
def loadTTreeTestChannelSoma(self): """ Load the T-tree morphology in memory with h-current 6--5--4--7--8 | | 1 """ v_eq = -75. self.dt = 0.025 self.tmax = 100. # for frequency derivation self.ft = ke.FourrierTools(np.arange(0., self.tmax, self.dt)) # load the morphology print('>>> loading T-tree <<<') test_chan = channelcollection.TestChannel2() fname = 'test_morphologies/Tsovtree.swc' self.greenstree = GreensTree(fname, types=[1, 3, 4]) self.greenstree.addCurrent(test_chan, 50., 23., node_arg=[self.greenstree[1]]) self.greenstree.fitLeakCurrent(v_eq, 10.) # for node in self.greenstree: # print node.getGTot(channel_storage=self.greenstree.channel_storage) # print node.currents self.greenstree.setCompTree() self.greenstree.setImpedance(self.ft.s) # copy greenstree parameters into NEURON simulation tree self.neurontree = NeuronSimTree(dt=self.dt, t_calibrate=100., v_init=v_eq, factor_lambda=25.) self.greenstree.__copy__(self.neurontree) self.neurontree.treetype = 'computational'
def reduceExplicit(self): self.loadBall() freqs = np.array([0.]) locs = [(1, 0.5)] e_eqs = [-75., -55., -35., -15.] # create compartment tree ctree = self.tree.createCompartmentTree(locs) ctree.addCurrent(channelcollection.Na_Ta(), 50.) ctree.addCurrent(channelcollection.Kv3_1(), -85.) # create tree with only leak greens_tree_pas = self.tree.__copy__(new_tree=GreensTree()) greens_tree_pas[1].currents = {'L': greens_tree_pas[1].currents['L']} greens_tree_pas.setCompTree() greens_tree_pas.setImpedance(freqs) # compute the passive impedance matrix z_mat_pas = greens_tree_pas.calcImpedanceMatrix(locs)[0] # create tree with only potassium greens_tree_k = self.tree.__copy__(new_tree=GreensTree()) greens_tree_k[1].currents = {key: val for key, val in greens_tree_k[1].currents.items() \ if key != 'Na_Ta'} # compute potassium impedance matrices z_mats_k = [] for e_eq in e_eqs: greens_tree_k.setEEq(e_eq) greens_tree_k.setCompTree() greens_tree_k.setImpedance(freqs) z_mats_k.append(greens_tree_k.calcImpedanceMatrix(locs)) # create tree with only sodium greens_tree_na = self.tree.__copy__(new_tree=GreensTree()) greens_tree_na[1].currents = {key: val for key, val in greens_tree_na[1].currents.items() \ if key != 'Kv3_1'} # create state variable expansion points svs = [] e_eqs_ = [] na_chan = greens_tree_na.channel_storage['Na_Ta'] for e_eq1 in e_eqs: sv1 = na_chan.computeVarinf(e_eq1) for e_eq2 in e_eqs: e_eqs_.append(e_eq2) sv2 = na_chan.computeVarinf(e_eq2) svs.append({'m': sv2['m'], 'h': sv1['h']}) # compute sodium impedance matrices z_mats_na = [] for sv, eh in zip(svs, e_eqs_): greens_tree_na.setEEq(eh) greens_tree_na[1].setExpansionPoint('Na_Ta', sv) greens_tree_na.setCompTree() greens_tree_na.setImpedance(freqs) z_mats_na.append(greens_tree_na.calcImpedanceMatrix(locs)) # passive fit ctree.computeGMC(z_mat_pas) # potassium channel fit matrices fit_mats_k = [] for z_mat_k, e_eq in zip(z_mats_k, e_eqs): mf, vt = ctree.computeGSingleChanFromImpedance( 'Kv3_1', z_mat_k, e_eq, freqs, other_channel_names=['L'], action='return') fit_mats_k.append([mf, vt]) # sodium channel fit matrices fit_mats_na = [] for z_mat_na, e_eq, sv in zip(z_mats_na, e_eqs_, svs): mf, vt = ctree.computeGSingleChanFromImpedance( 'Na_Ta', z_mat_na, e_eq, freqs, sv=sv, other_channel_names=['L'], action='return') fit_mats_na.append([mf, vt]) return fit_mats_na, fit_mats_k
def fitBall(self): self.loadBall() freqs = np.array([0.]) locs = [(1, 0.5)] e_eqs = [-75., -55., -35., -15.] # create compartment tree ctree = self.tree.createCompartmentTree(locs) ctree.addCurrent(channelcollection.Na_Ta(), 50.) ctree.addCurrent(channelcollection.Kv3_1(), -85.) # create tree with only leak greens_tree_pas = self.tree.__copy__(new_tree=GreensTree()) greens_tree_pas[1].currents = {'L': greens_tree_pas[1].currents['L']} greens_tree_pas.setCompTree() greens_tree_pas.setImpedance(freqs) # compute the passive impedance matrix z_mat_pas = greens_tree_pas.calcImpedanceMatrix(locs)[0] # create tree with only potassium greens_tree_k = self.tree.__copy__(new_tree=GreensTree()) greens_tree_k[1].currents = {key: val for key, val in greens_tree_k[1].currents.items() \ if key != 'Na_Ta'} # compute potassium impedance matrices z_mats_k = [] for e_eq in e_eqs: greens_tree_k.setEEq(e_eq) greens_tree_k.setCompTree() greens_tree_k.setImpedance(freqs) z_mats_k.append(greens_tree_k.calcImpedanceMatrix(locs)) # create tree with only sodium greens_tree_na = self.tree.__copy__(new_tree=GreensTree()) greens_tree_na[1].currents = {key: val for key, val in greens_tree_na[1].currents.items() \ if key != 'Kv3_1'} # create state variable expansion points svs = [] e_eqs_ = [] na_chan = greens_tree_na.channel_storage['Na_Ta'] for e_eq1 in e_eqs: sv1 = na_chan.computeVarinf(e_eq1) for e_eq2 in e_eqs: e_eqs_.append(e_eq2) sv2 = na_chan.computeVarinf(e_eq2) svs.append({'m': sv2['m'], 'h': sv1['h']}) # compute sodium impedance matrices z_mats_na = [] for ii, sv in enumerate(svs): greens_tree_na.setEEq(e_eqs[ii % len(e_eqs)]) greens_tree_na[1].setExpansionPoint('Na_Ta', sv) greens_tree_na.setCompTree() greens_tree_na.setImpedance(freqs) z_mats_na.append(greens_tree_na.calcImpedanceMatrix(locs)) # passive fit ctree.computeGMC(z_mat_pas) # get SOV constants for capacitance fit sov_tree = greens_tree_pas.__copy__(new_tree=SOVTree()) sov_tree.setCompTree() sov_tree.calcSOVEquations() alphas, phimat, importance = sov_tree.getImportantModes( locarg=locs, sort_type='importance', eps=1e-12, return_importance=True) # fit the capacitances from SOV time-scales ctree.computeC(-alphas[0:1].real * 1e3, phimat[0:1, :].real, weights=importance[0:1]) # potassium channel fit for z_mat_k, e_eq in zip(z_mats_k, e_eqs): ctree.computeGSingleChanFromImpedance('Kv3_1', z_mat_k, e_eq, freqs, other_channel_names=['L']) ctree.runFit() # sodium channel fit for z_mat_na, e_eq, sv in zip(z_mats_na, e_eqs_, svs): ctree.computeGSingleChanFromImpedance('Na_Ta', z_mat_na, e_eq, freqs, sv=sv, other_channel_names=['L']) ctree.runFit() ctree.setEEq(-75.) ctree.removeExpansionPoints() ctree.fitEL() self.ctree = ctree
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)