def makeSpine(model, parentComp, compName, index, frac, SpineParams): #frac is where along the compartment the spine is attached #unfortunately, these values specified in the .p file are not accessible neck_path = '{}/{}{}{}'.format(parentComp.path, compName, index, NAME_NECK) neck = moose.Compartment(neck_path) log.debug('{} at {} x,y,z={},{},{}', neck.path, frac, parentComp.x, parentComp.y, parentComp.z) moose.connect(parentComp, 'raxial', neck, 'axial', 'Single') #evenly distribute the spines along the parent compartment x = parentComp.x0 + frac * (parentComp.x - parentComp.x0) y = parentComp.y0 + frac * (parentComp.y - parentComp.y0) z = parentComp.z0 + frac * (parentComp.z - parentComp.z0) neck.x0, neck.y0, neck.z0 = x, y, z #could pass in an angle and use cos and sin to set y and z neck.x, neck.y, neck.z = x, y + SpineParams.necklen, z setSpineCompParams(model, neck, SpineParams.neckdia, SpineParams.necklen, SpineParams.neckRA, SpineParams.spineRM, SpineParams.spineCM) head_path = '{}/{}{}{}'.format(parentComp.path, compName, index, NAME_HEAD) head = moose.Compartment(head_path) moose.connect(neck, 'raxial', head, 'axial', 'Single') head.x0, head.y0, head.z0 = neck.x, neck.y, neck.z head.x, head.y, head.z = head.x0, head.y0 + SpineParams.headlen, head.z0 setSpineCompParams(model, head, SpineParams.headdia, SpineParams.headlen, SpineParams.headRA, SpineParams.spineRM, SpineParams.spineCM) return head, neck
def makePassiveSoma( name, length, diameter): print("length: ", length) print("diameter: ", diameter) numComp = 10 x = length/float(numComp) # x = length elecid = moose.Neuron( '/library/' + name ) soma = moose.Compartment( elecid.path + '/soma' ) soma.diameter = diameter soma.length = length soma.x0 = 0 soma.x = x ls = x n = 2.0 dendList = [] for i in range(numComp -1): dendList.append(moose.Compartment( elecid.path + '/dend' + str(i) )) dend = dendList[-1] dend.diameter = diameter/n # dl = ls + x dend.x0 = ls dend.x = ls + x dend.length = x ls += x n += 1.0 if i == 0: moose.connect( soma, 'axial', dendList[i], 'raxial') else: moose.connect( dendList[i-1], 'axial', dendList[i], 'raxial') return elecid
def loadGran98NeuroML_L123(filename, params): neuromlR = NeuroML() populationDict, projectionDict = \ neuromlR.readNeuroMLFromFile(filename,params=params) print "Number of compartments =",\ len(moose.Neuron(populationDict['CA1group'][1][0].path).children) soma_path = populationDict['CA1group'][1][0].path + '/Seg0_soma_0_0' somaVm = setupTable('somaVm', moose.Compartment(soma_path), 'Vm') #somaCa = setupTable('somaCa',moose.CaConc(soma_path+'/Gran_CaPool_98'),'Ca') #somaIKCa = setupTable('somaIKCa',moose.HHChannel(soma_path+'/Gran_KCa_98'),'Gk') #KDrX = setupTable('ChanX',moose.HHChannel(soma_path+'/Gran_KDr_98'),'X') soma = moose.Compartment(soma_path) print "Reinit MOOSE ... " resetSim(['/elec', '/cells'], simdt, plotdt, simmethod='hsolve') # from moose.utils print "Running ... " moose.start(runtime) tvec = arange(0.0, runtime, simdt) plot(tvec, somaVm.vector[1:]) title('Soma Vm') xlabel('time (s)') ylabel('Voltage (V)') print "Showing plots ..." show()
def loadGran98NeuroML_L123(filename): neuromlR = NeuroML() populationDict, projectionDict = \ neuromlR.readNeuroMLFromFile(filename) soma_path = populationDict['Gran'][1][0].path + '/Soma_0' somaVm = setupTable('somaVm', moose.Compartment(soma_path), 'Vm') somaCa = setupTable('somaCa', moose.CaConc(soma_path + '/Gran_CaPool_98'), 'Ca') somaIKCa = setupTable('somaIKCa', moose.HHChannel(soma_path + '/Gran_KCa_98'), 'Gk') #KDrX = setupTable('ChanX',moose.HHChannel(soma_path+'/Gran_KDr_98'),'X') soma = moose.Compartment(soma_path) print("Reinit MOOSE ... ") resetSim(['/elec', '/cells'], simdt, plotdt, simmethod='ee') # from moose.utils print("Running ... ") moose.start(runtime) tvec = arange(0.0, runtime, plotdt) plot(tvec, somaVm.vector[1:]) title('Soma Vm') xlabel('time (s)') ylabel('Voltage (V)') figure() plot(tvec, somaCa.vector[1:]) title('Soma Ca') xlabel('time (s)') ylabel('Ca conc (mol/m^3)') figure() plot(tvec, somaIKCa.vector[1:]) title('KCa current (A)') xlabel('time (s)') ylabel('') print("Showing plots ...") show()
def makeSpine(model, parentComp, compName, index, frac, SpineParams, randomAngles=True): # frac is where along the compartment the spine is attached # unfortunately, these values specified in the .p file are not accessible neck_path = '{}/{}{}{}'.format(parentComp.path, compName, index, NAME_NECK) neck = moose.Compartment(neck_path) log.debug('{} at {} x,y,z={},{},{}', neck.path, frac, parentComp.x, parentComp.y, parentComp.z) moose.connect(parentComp, 'raxial', neck, 'axial', 'Single') # evenly distribute the spines along the parent compartment x = parentComp.x0 + frac * (parentComp.x - parentComp.x0) y = parentComp.y0 + frac * (parentComp.y - parentComp.y0) z = parentComp.z0 + frac * (parentComp.z - parentComp.z0) neck.x0, neck.y0, neck.z0 = x, y, z from scipy.linalg import norm if randomAngles: # random angles for visualization dendvect = np.array([ parentComp.x, parentComp.y, parentComp.z ]) - np.array([parentComp.x0, parentComp.y0, parentComp.z0]) dendvmag = norm(dendvect) dendunitvec = dendvect / dendvmag not_v = np.random.random(3) not_v /= norm(not_v) while (dendunitvec == not_v).all(): not_v = np.random.random(3) not_v /= norm(not_v) # make vector perpendicular to v n1 = np.cross(dendunitvec, not_v) # normalize n1 n1 /= norm(n1) neck.x, neck.y, neck.z = SpineParams.necklen * n1 # print(neck.x, neck.y, neck.z) else: # could pass in an angle and use cos and sin to set y and z neck.x, neck.y, neck.z = x, y + SpineParams.necklen, z setSpineCompParams(model, neck, SpineParams.neckdia, SpineParams.necklen, SpineParams.neckRA, SpineParams.spineRM, SpineParams.spineCM) head_path = '{}/{}{}{}'.format(parentComp.path, compName, index, NAME_HEAD) head = moose.Compartment(head_path) moose.connect(neck, 'raxial', head, 'axial', 'Single') head.x0, head.y0, head.z0 = neck.x, neck.y, neck.z head.x, head.y, head.z = SpineParams.headlen * np.array([ head.x0, head.y0, head.z0 ]) / norm(np.array([head.x0, head.y0, head.z0])) # head.x0, head.y0 + SpineParams.headlen, head.z0 setSpineCompParams(model, head, SpineParams.headdia, SpineParams.headlen, SpineParams.headRA, SpineParams.spineRM, SpineParams.spineCM) return head, neck
def loadCell(self): self.context.readCell('gran_aditya_migliore.p',self.path) self._gran = moose.Cell(self.path) self._granSoma = moose.Compartment(self.path+'/soma') self._granSomaKA = moose.Compartment(self.path+'/soma/KA_ms') self._granPeri = moose.Compartment(self.path+'/periphery') self._granPeriNa = moose.HHChannel(self.path+'/periphery/Na_rat_ms') self._granPeriKA = moose.HHChannel(self.path+'/periphery/KA_ms')
def setUp(self): cell = moose.Neutral('/n') comp1 = moose.Compartment('/n/c1') chan = moose.HHChannel('/n/c1/ch') moose.connect(comp1, 'channel', chan, 'channel') comp2 = moose.Compartment('/n/c2') comp2.connect('raxial', comp1, 'axial') self.graph = moosegraph('/n')
def loadGran98NeuroML_L123(filename): neuromlR = NeuroML() populationDict, projectionDict = \ neuromlR.readNeuroMLFromFile(filename) soma_path = populationDict['CA1group'][1][0].path + '/Seg0_soma_0_0' somaVm = setupTable('somaVm', moose.Compartment(soma_path), 'Vm') soma = moose.Compartment(soma_path) moose.reinit() moose.start(runtime) tvec = np.arange(0.0, runtime, simdt) res = count.spike_train_simple_stat(somaVm.vector) return res['number of spikes']
def create_spine(parentCompt, parentObj, index, frac, length, dia, theta): """Create spine of specified dimensions and index""" RA = 1.0 RM = 1.0 CM = 0.01 sname = 'shaft' + str(index) hname = 'head' + str(index) shaft = moose.Compartment(parentObj.path + '/' + sname) moose.connect(parentCompt, 'raxial', shaft, 'axial', 'single') x = parentCompt.x0 + frac * (parentCompt.x - parentCompt.x0) y = parentCompt.y0 + frac * (parentCompt.y - parentCompt.y0) z = parentCompt.z0 + frac * (parentCompt.z - parentCompt.z0) shaft.x0 = x shaft.y0 = y shaft.z0 = z sy = y + length * math.cos(theta * math.pi / 180.0) sz = z + length * math.sin(theta * math.pi / 180.0) shaft.x = x shaft.y = sy shaft.z = sz shaft.diameter = dia / 10.0 shaft.length = length xa = math.pi * dia * dia / 400.0 circumference = math.pi * dia / 10.0 shaft.Ra = RA * length / xa shaft.Rm = RM / (length * circumference) shaft.Cm = CM * length * circumference shaft.Em = EREST_ACT shaft.initVm = EREST_ACT head = moose.Compartment(parentObj.path + '/' + hname) moose.connect(shaft, 'raxial', head, 'axial', 'single') head.x0 = x head.y0 = sy head.z0 = sz hy = sy + length * math.cos(theta * math.pi / 180.0) hz = sz + length * math.sin(theta * math.pi / 180.0) head.x = x head.y = hy head.z = hz head.diameter = dia head.length = length xa = math.pi * dia * dia / 4.0 circumference = math.pi * dia head.Ra = RA * length / xa head.Rm = RM / (length * circumference) head.Cm = CM * length * circumference head.Em = EREST_ACT head.initVm = EREST_ACT return head
def add_synchans(model, container): #synchans is 2D array, where each row has a single channel type #at the end they are concatenated into a dictionary synchans = [] comp_list = moose.wildcardFind(container + '/#[TYPE=Compartment]') SynPerCompList = np.zeros((len(comp_list), len(model.NumSyn)), dtype=int) #Create 2D array to store all the synapses. Rows=num synapse types, columns=num comps for key in model.SYNAPSE_TYPES: synchans.append([]) allkeys = sorted(model.SYNAPSE_TYPES) # i indexes compartment for array that stores number of synapses for i, comp in enumerate(comp_list): #create each type of synchan in each compartment. Add to 2D array for key in DendSynChans(model): keynum = allkeys.index(key) Gbar = model.SYNAPSE_TYPES[key].Gbar Gbarvar = model.SYNAPSE_TYPES[key].var synchans[keynum].append( addoneSynChan(key, comp, Gbar, model.calYN, Gbarvar)) for key in SpineSynChans(model): keynum = allkeys.index(key) Gbar = model.SYNAPSE_TYPES[key].Gbar Gbarvar = model.SYNAPSE_TYPES[key].var for spcomp in moose.wildcardFind(comp.path + '/#[ISA=Compartment]'): if NAME_HEAD in spcomp.path: synchans[keynum].append( addoneSynChan(key, spcomp, Gbar, model.calYN, Gbarvar)) ########### delete from here to allsynchans= once pop_funcs debugged ################ #calculate distance from soma xloc = moose.Compartment(comp).x yloc = moose.Compartment(comp).y dist = np.sqrt(xloc * xloc + yloc * yloc) #create array of number of synapses per compartment based on distance #possibly replace NumGlu[] with number of spines, or eliminate this if using real morph #Check in ExtConn - how is SynPerComp used #end of iterating over compartments #now, transform the synchans into a dictionary allsynchans = { key: synchans[keynum] for keynum, key in enumerate(sorted(model.SYNAPSE_TYPES)) } return allsynchans
def setUp(self): self.test_id = uuid.uuid4() self.model_container = moose.Neutral('test%s' % (self.test_id)) self.neuron = moose.Neuron('%s/cell' % (self.model_container.path)) self.soma = moose.Compartment('%s/soma' % (self.neuron.path)) self.soma.diameter = 20e-6 self.soma.length = 0.0 parent = self.soma comps = [] for ii in range(100): comp = moose.Compartment('%s/comp_%d' % (self.neuron.path, ii)) comp.diameter = 10e-6 comp.length = 100e-6 moose.connect(parent, 'raxial', comp, 'axial') comps.append(comp) parent = comp
def loadCell(self): self.context.readCell('mit_aditya_davison_reduced.p', self.path) self._mitral = moose.Cell(self.path) self._mitralSoma = moose.Compartment(self.path + '/soma') self._mitralGlom = moose.Compartment(self.path + '/glom') self._mitralDend = moose.Compartment(self.path + '/dend') self._mitralDendNa = moose.HHChannel(self.path + '/dend/Na_mit_usb') self._mitralSomaNa = moose.HHChannel(self.path + '/soma/Na_mit_usb') self._mitralSomaCaPool = moose.CaConc(self.path + '/soma/Ca_mit_conc') self._mitralSomaLCa = moose.HHChannel(self.path + '/soma/LCa3_mit_usb') self._mitralSomaKCa = moose.HHChannel(self.path + '/soma/Kca_mit_usb') # Connect the LCa current to the Ca Pool self._mitralSomaLCa.connect('IkSrc', self._mitralSomaCaPool, 'current') # Connect the KCa channel to the Ca concentration of Ca Pool self._mitralSomaCaPool.connect('concSrc', self._mitralSomaKCa, 'concen')
def makePassiveSoma(name, length, diameter): elecid = moose.Neuron('/library/' + name) dend = moose.Compartment(elecid.path + '/soma') dend.diameter = diameter dend.length = length dend.x = length return elecid
def makeCompt(name, parent, dx, dy, dia): RM = 1.0 RA = 1.0 CM = 0.01 EM = -0.065 pax = 0 pay = 0 if (parent.className == "Compartment"): pax = parent.x pay = parent.y compt = moose.Compartment(name) compt.x0 = pax compt.y0 = pay compt.z0 = 0 compt.x = pax + dx compt.y = pay + dy compt.z = 0 compt.diameter = dia clen = numpy.sqrt(dx * dx + dy * dy) compt.length = clen compt.Rm = RM / (numpy.pi * dia * clen) compt.Ra = RA * 4.0 * numpy.pi * clen / (dia * dia) compt.Cm = CM * numpy.pi * dia * clen if (parent.className == "Compartment"): moose.connect(parent, 'raxial', compt, 'axial') return compt
def makePassiveSoma(name, length, diamater): elecid = moose.Neuron('/library/' + name) dend = moose.Compartment(elecid.path + '/soma') dend.diameter = params['dendDia'] dend.length = params['dendL'] dend.x = params['dendL'] return elecid
def loadGran98NeuroML_L123(filename): neuromlR = NeuroML() populationDict, projectionDict = \ neuromlR.readNeuroMLFromFile(filename) soma_path = populationDict['Gran'][1][0].path+'/Soma_0' somaVm = setupTable('somaVm',moose.Compartment(soma_path),'Vm') somaCa = setupTable('somaCa',moose.CaConc(soma_path+'/Gran_CaPool_98'),'Ca') somaIKCa = setupTable('somaIKCa',moose.HHChannel(soma_path+'/Gran_KCa_98'),'Gk') ## Am not able to plot KDr gating variable X when running under hsolve #KDrX = setupTable('ChanX',moose.HHChannel(soma_path+'/Gran_KDr_98'),'X') print "Reinit MOOSE ... " resetSim(['/elec',cells_path], simdt, plotdt, simmethod='hsolve') print "Running ... " moose.start(runtime) tvec = arange(0.0,runtime*2.0,plotdt) tvec = tvec[ : somaVm.vector.size ] plot(tvec,somaVm.vector) title('Soma Vm') xlabel('time (s)') ylabel('Voltage (V)') figure() plot(tvec,somaCa.vector) title('Soma Ca') xlabel('time (s)') ylabel('Ca conc (mol/m^3)') figure() plot(tvec,somaIKCa.vector) title('soma KCa current') xlabel('time (s)') ylabel('KCa current (A)') print "Showing plots ..." show()
def buildCompt(pa, name, RM=1.0, RA=1.0, CM=0.01, dia=1.0e-6, x=0.0, y=0.0, z=0.0, dx=10e-6, dy=0.0, dz=0.0, Em=-0.065, initVm=-0.065): length = np.sqrt(dx * dx + dy * dy + dz * dz) compt = moose.Compartment(pa.path + '/' + name) compt.x0 = x compt.y0 = y compt.z0 = z compt.x = dx + x compt.y = dy + y compt.z = dz + z compt.diameter = dia compt.length = length xa = dia * dia * PI / 4.0 sa = length * dia * PI compt.Ra = length * RA / xa compt.Rm = RM / sa compt.Cm = CM * sa compt.Em = Em compt.initVm = initVm return compt
def __init__(self, path, length, diameter, args): """ Initialize moose-compartment """ self.mc_ = None self.path = path # Following values are taken from Upi's chapter on Rallpacks self.RM = args.get('RM', 4.0) self.RA = args.get('RA', 1.0) self.CM = args.get('CM', 0.01) self.Em = args.get('Em', -0.065) self.diameter = diameter self.compLength = length self.computeParams() try: self.mc_ = moose.Compartment(self.path) self.mc_.length = self.compLength self.mc_.diameter = self.diameter self.mc_.Ra = self.Ra self.mc_.Rm = self.Rm self.mc_.Cm = self.Cm self.mc_.Em = self.Em self.mc_.initVm = self.Em except Exception as e: utils.dump("ERROR", [ "Can't create compartment with path %s " % path, "Failed with error %s " % e ]) sys.exit(0)
def testNMDAChan(simtime=1.0, simdt=1e-5, plotdt=1e-5): context = moose.PyMooseBase.getContext() container = moose.Neutral('test_NMDA') soma_b = moose.Compartment('B', container) soma_b.Rm = 5.3e9 # GM = 2e-5 S/cm^2 soma_b.Cm = 8.4823001646924426e-12 # CM = 0.9 uF/cm^2 soma_b.Em = -65e-3 soma_b.initVm = -65e-3 soma_b.Ra = 282942.12 # RA = 250 Ohm-cm nmda = moose.NMDAChan('nmda', container) nmda.tau2 = 5e-3 nmda.tau1 = 130e-3 nmda.Gbar = 1e-9 nmda.saturation = 1e10 nmda.connect('channel', soma_b, 'channel') spikegen = moose.SpikeGen('spike', container) spikegen.threshold = 0.5 spikegen.connect('event', nmda, 'synapse') spikegen.refractT = 0.0 nmda.delay[0] = 1e-3 nmda.weight[0] = 1.0 pulsegen = moose.PulseGen('pulse', container) pulsegen.setCount(3) pulsegen.level[0] = 1.0 pulsegen.delay[0] = 10e-3 pulsegen.width[0] = 1e-3 pulsegen.level[1] = 1.0 pulsegen.delay[1] = 2e-3 pulsegen.width[1] = 1e-3 pulsegen.delay[2] = 1e9 pulsegen.connect('outputSrc', spikegen, 'Vm') data = moose.Neutral('data') vmB = moose.Table('Vm_B', data) vmB.stepMode = 3 vmB.connect('inputRequest', soma_b, 'Vm') pulse = moose.Table('pulse', data) pulse.stepMode = 3 pulse.connect('inputRequest', pulsegen, 'output') gNMDA = moose.Table('G', data) gNMDA.stepMode = 3 gNMDA.connect('inputRequest', nmda, 'Gk') context.setClock(0, simdt) context.setClock(1, simdt) context.setClock(2, simdt) context.setClock(3, plotdt) context.reset() context.step(simtime) # gNMDA.dumpFile('gNMDA.dat', False) # vmA.dumpFile('Va.dat', False) # vmB.dumpFile('Vb.dat', False) ts = np.linspace(0, simtime, len(gNMDA)) pylab.plot(ts, pulse) pylab.plot(ts, np.asarray(gNMDA) * 1e9, label='gNMDA') pylab.show() np.savetxt('../data/two_comp_nmda.plot', np.transpose(np.vstack((ts, vmB, gNMDA))))
def create_compartment(path): comp = moose.Compartment(path) comp.diameter = soma_dia comp.Em = EREST_ACT + 10.613e-3 comp.initVm = EREST_ACT sarea = np.pi * soma_dia * soma_dia comp.Rm = 1/(0.3e-3 * 1e4 * sarea) comp.Cm = 1e-6 * 1e4 * sarea if moose.exists('/library/na'): nachan = moose.element(moose.copy('/library/na', comp, 'na')) else: nachan = create_na_chan(comp.path) nachan.Gbar = 120e-3 * sarea * 1e4 moose.showfield(nachan) moose.connect(nachan, 'channel', comp, 'channel') if moose.exists('/library/k'): kchan = moose.element(moose.copy('/library/k', comp, 'k')) else: kchan = create_k_chan(comp.path) kchan.Gbar = 36e-3 * sarea * 1e4 moose.connect(kchan, 'channel', comp, 'channel') synchan = moose.SynChan(comp.path + '/synchan') synchan.Gbar = 1e-8 synchan.tau1 = 2e-3 synchan.tau2 = 2e-3 synchan.Ek = 0.0 m = moose.connect(comp, 'channel', synchan, 'channel') spikegen = moose.SpikeGen(comp.path + '/spikegen') spikegen.threshold = 0.0 m = moose.connect(comp, 'VmOut', spikegen, 'Vm') return comp
def translate_rotate( self, obj, x, y, z, ztheta): # recursively translate all compartments under obj for childId in obj.children: try: childobj = moose.element(childId) if childobj.className in ['Compartment', 'SymCompartment']: ## SymCompartment inherits from Compartment, ## so below wrapping by Compartment() is fine for both Compartment and SymCompartment child = moose.Compartment(childId) x0 = child.x0 y0 = child.y0 x0new = x0 * cos(ztheta) - y0 * sin(ztheta) y0new = x0 * sin(ztheta) + y0 * cos(ztheta) child.x0 = x0new + x child.y0 = y0new + y child.z0 += z x1 = child.x y1 = child.y x1new = x1 * cos(ztheta) - y1 * sin(ztheta) y1new = x1 * sin(ztheta) + y1 * cos(ztheta) child.x = x1new + x child.y = y1new + y child.z += z if len(childobj.children) > 0: self.translate_rotate( childobj, x, y, z, ztheta) # recursive translation+rotation except TypeError: # in async13, gates which have not been created still 'exist' # i.e. show up as a child, but cannot be wrapped. pass
def translate_rotate( self, obj, x, y, z, ztheta): # recursively translate all compartments under obj for childId in obj.children(): childobj = moose.Neutral(childId) if childobj.className in [ 'Compartment', 'SymCompartment' ]: # if childobj is a compartment or symcompartment translate, else skip it child = moose.Compartment( childId ) # SymCompartment inherits from Compartment, so this is fine for both Compartment and SymCompartment x0 = child.x0 y0 = child.y0 x0new = x0 * cos(ztheta) - y0 * sin(ztheta) y0new = x0 * sin(ztheta) + y0 * cos(ztheta) child.x0 = x0new + x child.y0 = y0new + y child.z0 += z x1 = child.x y1 = child.y x1new = x1 * cos(ztheta) - y1 * sin(ztheta) y1new = x1 * sin(ztheta) + y1 * cos(ztheta) child.x = x1new + x child.y = y1new + y child.z += z if len(childobj.children()) > 0: self.translate_rotate(childobj, x, y, z, ztheta) # recursive translation+rotation
def translate_rotate(self, obj, x, y, z, ztheta): for childId in obj.children: childobj = moose.Neutral(childId) # if childobj is a compartment or symcompartment translate, else # skip it if childobj.className in ['Compartment', 'SymCompartment']: # SymCompartment inherits from Compartment, so below wrapping by # Compartment() is fine for both Compartment and SymCompartment child = moose.Compartment(childId) x0 = child.x0 y0 = child.y0 x0new = x0 * cos(ztheta) - y0 * sin(ztheta) y0new = x0 * sin(ztheta) + y0 * cos(ztheta) child.x0 = x0new + x child.y0 = y0new + y child.z0 += z x1 = child.x y1 = child.y x1new = x1 * cos(ztheta) - y1 * sin(ztheta) y1new = x1 * sin(ztheta) + y1 * cos(ztheta) child.x = x1new + x child.y = y1new + y child.z += z if len(childobj.children) > 0: # recursive translation+rotation self.translate_rotate(childobj, x, y, z, ztheta)
def make_compartment(path): comp = moose.Compartment(path) comp.Em = -70e-3 comp.initVm = -70e-3 comp.Cm = 1e-12 comp.Rm = 1e9 return comp
def create_squid(): """Create a single compartment squid model.""" parent = moose.Neutral('/n') compt = moose.Compartment('/n/compt') Em = EREST_ACT + 10.613e-3 compt.Em = Em compt.initVm = EREST_ACT compt.Cm = 7.85e-9 compt.Rm = 4.2e5 compt.Ra = 7639.44e3 nachan = moose.HHChannel('/n/compt/Na') nachan.Xpower = 3 xGate = moose.HHGate(nachan.path + '/gateX') xGate.setupAlpha(Na_m_params + [VDIVS, VMIN, VMAX]) nachan.Ypower = 1 yGate = moose.HHGate(nachan.path + '/gateY') yGate.setupAlpha(Na_h_params + [VDIVS, VMIN, VMAX]) nachan.Gbar = 0.942e-3 nachan.Ek = 115e-3 + EREST_ACT moose.connect(nachan, 'channel', compt, 'channel', 'OneToOne') kchan = moose.HHChannel('/n/compt/K') kchan.Xpower = 4.0 xGate = moose.HHGate(kchan.path + '/gateX') xGate.setupAlpha(K_n_params + [VDIVS, VMIN, VMAX]) kchan.Gbar = 0.2836e-3 kchan.Ek = -12e-3 + EREST_ACT moose.connect(kchan, 'channel', compt, 'channel', 'OneToOne') return compt
def run_model(): model = moose.Neutral('/model') data = moose.Neutral('/data') cell = TuftedIB('/model/TuftedIB') stim = alpha_stimulus('/model/stim', 1.0e-9, 15e-3, 20e-3, simtime, simdt) stim.startTime = 1e9 p1 = cell.path + '/' + d1 p2 = cell.path + '/' + d2 comp_d1 = moose.element(p1) if moose.exists(p1) else moose.Compartment(p1) comp_d2 = moose.element(p2) if moose.exists(p2) else moose.Compartment(p2) s = '%s/%s' % (cell.path, 'comp_1') comp_soma = moose.element(s) if moose.exists(s) else moose.Compartment(s) comp_soma.inject = -0.2e-9 moose.connect(stim, 'output', comp_d1, 'injectMsg') tab_d1 = moose.Table('%s/d1_Vm' % (data.path)) tab_d2 = moose.Table('%s/d2_Vm' % (data.path)) tab_soma = moose.Table('%s/soma_Vm' % (data.path)) tab_stim = moose.Table('%s/stim' % (data.path)) moose.connect(tab_d1, 'requestOut', comp_d1, 'getVm') moose.connect(tab_d2, 'requestOut', comp_d2, 'getVm') moose.connect(tab_soma, 'requestOut', comp_soma, 'getVm') moose.connect(stim, 'output', tab_stim, 'input') solver = moose.HSolve('%s/solver' % (cell.path)) solver.dt = simdt solver.target = cell.path utils.setDefaultDt(elecdt=simdt, plotdt2=plotdt) utils.assignDefaultTicks() moose.reinit() utils.stepRun(simtime, 1e5 * simdt, logger=config.logger) pylab.subplot(211) pylab.plot(np.linspace(0, simtime, len(tab_d1.vector)), tab_d1.vector * 1e3, label='D1 Vm (mV)') pylab.plot(np.linspace(0, simtime, len(tab_d2.vector)), tab_d2.vector * 1e3, label='D2 Vm (mV)') pylab.plot(np.linspace(0, simtime, len(tab_soma.vector)), tab_soma.vector * 1e3, label='SOMA Vm (mV)') pylab.legend() pylab.subplot(212) pylab.plot(np.linspace(0, simtime, len(tab_stim.vector)), tab_stim.vector * 1e9, label='Stimulus (nA)') pylab.legend() pylab.savefig('fig_a4c.png') pylab.show()
def make_testcomp(containerpath): comp = moose.Compartment('%s/testcomp' % (containerpath)) comp.Em = -65e-3 comp.initVm = -65e-3 comp.Cm = 1e-12 comp.Rm = 1e9 comp.Ra = 1e5 return comp
def timetable_demo(): tt_array, sp_array = timetable_nparray() tt_file, sp_file = timetable_file() # Create a synchan inside a compartment to demonstrate how to use # TimeTable to send artificial spike events to a synapse. comp = moose.Compartment('/model/comp') comp.Em = -60e-3 comp.Rm = 1e9 comp.Cm = 1e-12 synchan = moose.SynChan('/model/comp/synchan') synchan.Gbar = 1e-6 synchan.Ek = 0.0 moose.connect(synchan, 'channel', comp, 'channel') synh = moose.SimpleSynHandler('/model/comp/synchan/synh') moose.connect(synh, 'activationOut', synchan, 'activation') synh.synapse.num = 1 moose.connect(tt_file, 'eventOut', moose.element(synh.path + '/synapse'), 'addSpike') # Data recording: record the `state` of the time table filled # using array. data = moose.Neutral('/data') tab_array = moose.Table('/data/tab_array') moose.connect(tab_array, 'requestOut', tt_array, 'getState') # Record the synaptic conductance for the other time table, which # is filled from a text file and sends spike events to a synchan. tab_file = moose.Table('/data/tab_file') moose.connect(tab_file, 'requestOut', synchan, 'getGk') # Scheduling moose.setClock(0, simdt) moose.setClock(1, simdt) moose.useClock(1, '/model/##[ISA=Compartment]', 'init') moose.useClock(1, '/model/##,/data/##', 'process') moose.reinit() moose.start(simtime) # Plotting pylab.subplot(2, 1, 1) pylab.plot(sp_array, np.ones(len(sp_array)), 'rx', label='spike times from numpy array') pylab.plot(np.linspace(0, simtime, len(tab_array.vector)), tab_array.vector, 'b-', label='TimeTable state') pylab.legend() pylab.subplot(2, 1, 2) pylab.plot(sp_file, np.ones(len(sp_file)), 'rx', label='spike times from file') pylab.plot(np.linspace(0, simtime, len(tab_file.vector)), tab_file.vector * 1e6, 'b-', label='Syn Gk (uS)') pylab.legend() pylab.show()
def buildModel(): global model global soma model = moose.Neutral('/model') soma = moose.Compartment('/model/soma') soma.Em = -60e-3 soma.Rm = 1e10 soma.Cm = 1e-10 return model
def loadGran98NeuroML_L123(filename): neuromlR = NeuroML() populationDict, projectionDict = \ neuromlR.readNeuroMLFromFile(filename) soma_path = populationDict['Gran'][1][0].path + '/Soma_0' somaVm = setupTable('somaVm', moose.Compartment(soma_path), 'Vm') somaCa = setupTable('somaCa', moose.CaConc(soma_path + '/Gran_CaPool_98'), 'Ca') somaIKCa = setupTable('somaIKCa', moose.HHChannel(soma_path + '/Gran_KCa_98'), 'Gk') #KDrX = setupTable('ChanX',moose.HHChannel(soma_path+'/Gran_KDr_98'),'X') soma = moose.Compartment(soma_path) print "Reinit MOOSE ... " resetSim(['/elec', '/cells'], simdt, plotdt, simmethod='ee') # from moose.utils print "Running ... " moose.start(runtime) print 'Finished simulation for', runtime, 'seconds'