def _get_neuron(self, key): try: params = IzhikevichDemo.parameters[key] except KeyError as e: print((' %s : Invalid neuron type. The valid types are:' % (key))) for key in IzhikevichDemo.parameters: print(key) raise e try: neuron = self.neurons[key] return neuron except KeyError as e: neuron = moose.IzhikevichNrn(self.model_container.path + '/' + key) if key == 'integrator' or key == 'Class_1': # Integrator has different constants neuron.beta = 4.1e3 neuron.gamma = 108.0 if key == 'accommodation': neuron.accommodating = True neuron.u0 = -0.065 self.neuron = neuron neuron.a = params[1] * 1e3 # ms^-1 -> s^-1 neuron.b = params[2] * 1e3 # ms^-1 -> s^-1 neuron.c = params[3] * 1e-3 # mV -> V neuron.d = params[4] # d is in mV/ms = V/s neuron.initVm = params[6] * 1e-3 # mV -> V neuron.Vmax = 0.03 # mV -> V if key != 'accommodation': neuron.initU = neuron.initVm * neuron.b else: neuron.initU = -16.0 # u is in mV/ms = V/s moose.showfield(neuron) self.neurons[key] = neuron return neuron
def library1(): import moose.genesis import moose.SBML import moose.chemMerge import moose.utils import moose.network_utils print('done') p1 = moose.le() a = moose.Pool('/a') for i in range(10): moose.Pool('/a/p%d' % i) p2 = moose.le() assert set(p2) - set(p1) == set(['/a']) aa = moose.le(a) assert len(aa) == 10 try: moose.syncDataHandler('/a') except NotImplementedError: pass try: moose.showfield('/x') except ValueError: pass moose.showfield('/a') moose.showfields('/a')
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 test_showfield_func(): """Show field of a function. >>> test_showfield_func() #doctest: +NORMALIZE_WHITESPACE [/dadada[0]] allowUnknownVariable =True className =Function derivative =nan doEvalAtReinit =False dt =0.1 expr =0 fieldIndex =0 idValue =448 independent =t index =0 mode =1 name =dadada numData =1 numField =1 numVars =0 path =/dadada[0] rate =0.0 tick =12 useTrigger =False value =0.0 """ f = moose.Function('/dadada') moose.showfield(f)
def main(): library = moose.Neutral('/library') makePassiveSoma('cell', params['dendL'], params['dendDia']) makeChemProto() rdes = rd.rdesigneur( turnOffElec=True, chemPlotDt=0.1, diffusionLength=params['diffusionL'], cellProto=[['cell', 'soma']], chemProto=[['hydra', 'hydra']], chemDistrib=[['hydra', 'soma', 'install', '1']], plotList=[['soma', '1', 'dend/A', 'n', '# of A'], ['soma', '1', 'dend/B', 'n', '# of B']], # moogList = [['soma', '1', 'dend/A', 'n', 'num of A (number)']] ) moose.le('/library') moose.le('/library/hydra') moose.showfield('/library/soma/soma') rdes.buildModel() #moose.element('/model/chem/dend/B').vec[50].nInit=15.5 A = moose.vec('/model/chem/dend/A') #B = moose.vec('/model/chem/dend/B') # A.concInit=1 # B.concInit=10 moose.element('/model/chem/dend/B').vec[50].nInit = 100 #moose.element('/model/chem/dend/B').vec[25].nInit=0 #A.nInit=1 #B.nInit=15 #Adot = moose.element('/model/chem/dend/A/Adot') #Bdot = moose.element('/model/chem/dend/B/Bdot') #print "\n\n\t\t Before Run", Adot, Bdot, A.nInit, B.nInit, A.n, B.n, A.concInit, B.concInit moose.reinit() moose.start(500) #print "\n\n\t\t After Run", A.nInit, B.nInit, A.n, B.n, A.concInit, B.concInit # rdes.display() # rdes.displayMoogli( 1, 400, 0.001 ) avec = moose.vec('/model/chem/dend/A').n bvec = moose.vec('/model/chem/dend/B').n #tab = moose.element( '/model/graphs/plot0') #dt = tab.dt #tvec=[] #tvec.append( tab.vector ) # xplot = [] # xplot.append( avec ) ## t = np.arange( 0, len( tvec[0] ), 1.0 ) * dt plt.plot(avec) #print bvec, len(bvec), bvec return bvec, avec
def insert_ca(compartment, phi, tau): ca = moose.copy(CaPool.prototype, compartment)[0] ca.B = phi / (np.pi * compartment.length * compartment.diameter) ca.tau = tau print ca.path, ca.B, ca.tau for chan in moose.wildcardFind('%s/#[TYPE=HHChannel]' % (compartment.path)): if chan.name.startswith('KC') or chan.name.startswith('KAHP'): moose.connect(ca, 'concOut', chan, 'concen') elif chan.name.startswith('CaL'): moose.connect(chan, 'IkOut', ca, 'current') else: continue moose.showfield(chan) return ca
def create_1comp_neuron(path, number=1): """Create single-compartmental neuron with Na+ and K+ channels. Parameters ---------- path : str path of the compartment to be created number : int number of compartments to be created. If n is greater than 1, we create a vec with that size, each having the same property. Returns ------- comp : moose.Compartment a compartment vec with `number` elements. """ comps = moose.vec(path=path, n=number, dtype='Compartment') diameter = 30e-6 length = 50e-6 sarea = np.pi * diameter * length xarea = np.pi * diameter * diameter / 4.0 Em = EREST_ACT + 10.613e-3 comps.Em = Em comps.initVm = EREST_ACT #: CM = 1 uF/cm^2 comps.Cm = 1e-6 * sarea * 1e4 #: RM = 0.3 mS/cm^2 comps.Rm = 1 / (0.3e-3 * sarea * 1e4) container = comps[0].parent.path #: Here we create copies of the prototype channels nachan = moose.copy(create_na_proto(), container, 'na', number) #: Gbar_Na = 120 mS/cm^2 nachan.Gbar = 120e-3 * sarea * 1e4 nachan.Ek = 115e-3 + EREST_ACT moose.showfield(nachan.path) moose.connect(nachan, 'channel', comps, 'channel', 'OneToOne') kchan = moose.copy(create_k_proto(), container, 'k', number) #: Gbar_K = 36 mS/cm^2 kchan.Gbar = 36e-3 * sarea * 1e4 kchan.Ek = -12e-3 + EREST_ACT moose.showfield(kchan.path) moose.connect(kchan, 'channel', comps, 'channel', 'OneToOne') return comps
def test_simple(): """First test. >>> test_simple() # doctest: +NORMALIZE_WHITESPACE Rdesigneur: Elec model has 1 compartments and 0 spines on 0 compartments. <BLANKLINE> [/model[0]/elec[0]/soma[0]] Cm =7.853981633975e-09 Em =-0.0544 Im =1.3194689277024895e-08 Ra =7639437.268410473 Rm =424413.1773342278 Vm =-0.06 className =ZombieCompartment diameter =0.0005 dt =0.0 fieldIndex =0 idValue =455 index =0 initVm =-0.065 inject =0.0 length =0.0005 name =soma numData =1 numField =1 path =/model[0]/elec[0]/soma[0] tick =-2 x =0.0005 x0 =0.0 y =0.0 y0 =0.0 z =0.0 z0 =0.0 <BLANKLINE> INCOMING: /model[0]/elec[0]/soma ('parentMsg',) <--- /model[0]/elec ('childOut',) OUTGOING: """ rdes = rd.rdesigneur() rdes.buildModel() moose.showfield(rdes.soma) moose.showmsg(rdes.soma)
def addChannelToComps(channelSpecs, comps, number=1): container = comps[0].parent.path protoChannel = create_channel_proto(channelSpecs["settings"]) print(container) print(protoChannel) channel = moose.copy(protoChannel, container, channelSpecs["settings"].name+'_{}'.format(comps.name), number) channel.Gbar = channelSpecs["gbar"] * np.pi*comps.length*comps.diameter # is the list unnecessary? channel.Ek = channelSpecs["Ek"] print(moose.showfield(moose.element(channel))) moose.connect(channel, "channel", comps, "channel", "OneToOne") if(channelSpecs["settings"].chan_type!=""): print(channelSpecs["settings"].chan_type) add_calcium(channel.name, Ca_pool_settings, channel.name, channelSpecs["settings"].chan_type, 'CaPool') return channel
moose.reinit() # start simulation at 0 nA injection current. moose.start(0.3) moose.showfields(soma) # check Vm soma.inject = -1E-12 # reset simulation moose.reint() # start simulation at -1pA injection current. moose.start(0.3) moose.showfields(soma) # Creation of pulse generator. pulse = moose.PulseGen('pulse') moose.showfield('pulse') pulse.delay[0] = 50E-3 # First delay. pulse.width[0] = 100E03 # Pulse width. pulse.level[0] = 1E-9 # Pulse amplitude. pulse.delat[1] = 1E9 moose.getFieldNames( 'PulseGen', 'srcFinfo') # returns list of message outlets for a moose element class. moose.getFieldNames( 'Compartment', 'destFinfo') # returns list of message inlets for a moose element class. soma.getFieldNames('destFinfo') moose.showmsg( 'soma') # shows message connetions statistics of the moose element.
moose.reinit() moose.start(900e-3) neuron = moose.Neutral("/neuron") inputs = moose.Neutral("/inputs") outputs = moose.Neutral("/outputs") swcNeuron = load_neuron_file("538ser3sl5-cell1-2-a.CNG.swc", "/swcNeuron", 0.8, 0.9, 0.01, 0.072) moose.le("/swcNeuron") pulse = create_pulse("/inputs/somaPulse", 10e-3, 10e-3, 0.1e-9, moose.element("/swcNeuron/soma")) table = create_table('outputs/somaVmTable', moose.element("/swcNeuron/soma"), "getVm") dtable = create_table('outputs/dendVmTable', moose.element("/swcNeuron/dend_3_0"), "getVm") run_sim() plot_tables([table, dtable]) pyplot.show() ch = moose.HHChannel("ch") moose.showfield(ch) ch.Xpower = 3 ch.Ypower = 1 ch.Ek = 0.05 ch.Gbar = 1
def main(): """ This illustrates the use of rdesigneur to build a simple dendrite with spines, and then to resize them using spine fields. These are the fields that would be changed dynamically in a simulation with reactions that affect spine geometry. In this simulation there is a propagating reaction wave using a highly abstracted equation, whose product diffuses into the spines and makes them bigger. """ radCalc() moose.delete('/model') makeModel() for i in range(11, 18): moose.setClock(i, 0.01) moose.setClock(18, 0.01) elec = moose.element('/model/elec') graphs = moose.Neutral('/graphs') Epsinit = moose.vec('/model/chem/dend/Eps8') Cdcinit = moose.vec('/model/chem/dend/Cdc42') IRSpinit = moose.vec('/model/chem/dend/IRSp53') PIPinit = moose.vec('/model/chem/dend/PIP2') Cdcinit.concInit = 0.0 ## Cdcinit[100].concInit=0.01 ##Epsinit.concInit=0.0 ##Epsinit[50].concInit=0.010 ### IRSpinit.nInit=0.0 for ci in range(90, 110): Cdcinit[ci].concInit = np.exp(-( (ci - 100)**2) / 10.**2) * 0.005 + 0.005 ## Cdcinit[ci].concInit=0.010 PIPinit.nInit = 565 print moose.vec('/model/chem/dend/Cdc42').nInit print moose.vec('/model/chem/dend/IRSp53').nInit makePlot('IRSp53', moose.vec('/model/chem/dend/IRSp53'), 'getN') makePlot('height', moose.vec('/model/chem/dend/height'), 'getN') makePlot('IM', moose.vec('/model/chem/dend/IRSp53_m'), 'getN') makePlot('Rad', moose.vec('/model/chem/dend/Rad'), 'getN') makePlot('curv_IRSp53', moose.vec('/model/chem/dend/curv_IRSp53'), 'getN') makePlot('Ipool', moose.vec('/model/chem/dend/Ipool'), 'getN') makePlot('sort', moose.vec('/model/chem/dend/sort'), 'getN') rad = moose.element('/model/chem/dend/Rad') ##curv[gri]=(radv[gri+1]-2*radv[gri]+radv[gri-1])/(200*200*1e-9) ## curv[gric]=1e-9*(heightvec[gric+1]-2*heightvec[gric]+heightvec[gric-1])/(0.2*0.2*1e-12) mypyrun = moose.PyRun('/model/mypyrun') ## curv[gri]=np.exp(6*curv_IRSp53vec[gri]+6*cip2vec[gri]+6*cip3vec[gri]+2*IRSp53_mvec[gri]) ##cPIP2.diffConst=abs(0.33e-12-(1.0/np.exp(abs(max(radv)*1e9-20.)))*0.33e-12) ##curv_IRSp53.diffConst=cPIP2.diffConst ##curv[gric]=1e-9*(-heightvec[gric+2]+16*heightvec[gric+1]-30*heightvec[gric]+16*heightvec[gric-1]-heightvec[gric-2])/(12*20.0*20.0*1e-18) ###curv[gric]=1e-9*(-radv[gric+2]+16*radv[gric+1]-30*radv[gric]+16*radv[gric-1]-radv[gric-2])/(12*50.0*50.0*1e-18) ##curv[gric]=1e-9*(radv[gric+1]-2*radv[gric]+radv[gric-1])/(0.05*0.05*1e-12) ##for gric in range(0,len(curv)): ## curv[gric]=1.0/(100.0-2*1e9*radv[gric]) ## curv[gric]=curv[gric] ## curv[gri].conc=(3*27000*IRSp53_mvec[gri].conc**2)/(1+3*27000*IRSp53_mvec[gri].conc**2) ## curv[gri]=1030*((3*0.027*(3*curv_IRSp53vec[gri]+3*cip2vec[gri]+3*cip3vec[gri]+IRSp53_mvec[gri])**2)/(1.0+3.0*0.027*(3.0*curv_IRSp53vec[gri]+3.0*cip2vec[gri]+3.0*cip3vec[gri]+IRSp53_mvec[gri])**2)) print moose.showfield('/model/chem/dend/curv/Enz'), 'number of substrates' mypyrun.initString = """count=0""" mypyrun.runString = """count=count+1 radv=moose.vec('/model/chem/dend/Rad').n radm=radv[10] output=radm IRvec=moose.vec( '/model/chem/dend/IRSp53' ).n curv_IRSp53=moose.element( '/model/chem/dend/curv_IRSp53') Cdcvec=moose.vec( '/model/chem/dend/Cdc42' ).n if count==1: Cdcinit=moose.vec( '/model/chem/dend/Cdc42' ).nInit pos=np.unravel_index(np.argmax(Cdcinit), Cdcinit.shape) pos=pos[0] heightvec=moose.vec( '/model/chem/dend/height' ).n curv_IRSp53vec=moose.vec('/model/chem/dend/curv_IRSp53').n IRSp53_mvec=moose.vec('/model/chem/dend/IRSp53_m').n cip2vec=moose.vec('/model/chem/dend/cip2').n cip3vec=moose.vec('/model/chem/dend/cip3').n Ipoolvec=moose.vec('/model/chem/dend/Ipool').n curv_ir_vec=moose.vec('/model/chem/dend/curv/Enz/Enz2_cplx').n curv=moose.vec('/model/chem/dend/curv').n cPIP2=moose.element('/model/chem/dend/cPIP2') ##moose.vec('/model/chem/dend/sort').n=(-Ipoolvec+max(Ipoolvec)) moose.vec('/model/chem/dend/sort').n=(Ipoolvec-min(Ipoolvec)) moose.vec('/model/chem/dend/detach').n=-moose.vec('/model/chem/dend/sort').n+max(moose.vec('/model/chem/dend/sort').n) ##if max(Ipoolvec)>min(Ipoolvec): ## plt.plot(Ipoolvec) ## plt.plot(moose.vec('/model/chem/dend/sort').n) ## plt.figure(2) ## plt.plot(moose.vec('/model/chem/dend/Rad').n) for gri in range(0,len(Cdcvec)): curv[gri]=1.0*((3*0.027*(curv_IRSp53vec[gri]+IRSp53_mvec[gri])**2)/(1.0+3.0*0.027*(curv_IRSp53vec[gri]+curv_ir_vec[gri]+IRSp53_mvec[gri])**2))*0.055*np.exp(-(moose.vec('/model/chem/dend/mesh')[gri].Coordinates[0]-moose.vec('/model/chem/dend/mesh')[pos].Coordinates[0])**2/(2*0.1e-6**2)) if count==1: maxCIR=[] maxIR=[] max_curv=[] moose.vec('/model/chem/dend/curv').n=curv moose.vec('/model/chem/dend/curv_pip').n=curv if count%500==0: maxCIR.append(max(moose.vec('/model/chem/dend/curv_IRSp53').n)) maxIR.append(max(moose.vec('/model/chem/dend/IRSp53_m').n)) max_curv.append(max(moose.vec('/model/chem/dend/curv').n)) pref_curv=0.055 PIP2vec=moose.vec('/model/chem/dend/PIP2').n plt.xlabel('Number of IRSp53 dimers') plt.ylabel('Deformation strength') if count%500==0: print 'Dimer n', moose.vec('/model/chem/dend/IRSp53_dimer').n print 'PIP2', moose.vec('/model/chem/dend/PIP2').n print 'Radius', radv print 'Curvature', moose.vec('/model/chem/dend/curv').n print 'CurvIRSp53', curv_IRSp53vec plt.plot(maxCIR,max_curv) radmax=max(radv) if count%100==0: print " Mass conservation check " print "Sum of all forms of IRSp53 now", sum(moose.vec('/model/chem/dend/IRSp53_dimer').n)+sum(moose.vec('/model/chem/dend/IRSp53_a').n)+sum(moose.vec('/model/chem/dend/IRSp53_m').n)+sum(moose.vec('/model/chem/dend/curv_IRSp53').n)+sum(moose.vec('/model/chem/dend/cip2').n)+sum(moose.vec('/model/chem/dend/detach/Enz/Enz_cplx').n)+sum(moose.vec('/model/chem/dend/curv/Enz/Enz2_cplx').n)+sum(moose.vec('/model/chem/dend/sort/Enz/Enz_cplx').n) print "Initial sum", sum(moose.vec('/model/chem/dend/IRSp53_dimer').nInit) Rn=moose.element( '/model/chem/dend/Rad' ).n """ ''' debug = moose.PyRun( '/pyrun' ) debug.tick = 10 debug.runString = """print "RUNNING: ", moose.element( '/model/chem/psd/z' ).n, moose.element( '/model/elec/head0' ).diameter""" ''' ###moose.connect(rad,'nOut',mypyrun,'trigger') outputTab = moose.Table('/model/output') moose.connect(mypyrun, 'output', outputTab, 'input') moose.setClock(30, 0.01) moose.setClock(10, 0.01) moose.setClock(15, 0.01) moose.setClock(16, 0.01) mypyrun.mode = 1 ###radCalc() moose.reinit() ###moose.start( runtime ) test = 'False' step = 0 if test == 'True': while step < int(runtime / 0.001): I_M = moose.element('/model/chem/dend/IRSp53_m').n I_C = moose.element('/model/chem/dend/IRSp53').n Rad = moose.element('/model/chem/dend/Rad').n height = moose.element('/model/chem/dend/height').n gradBAR = moose.element('/model/chem/dend/gradBAR').expr Radfun = moose.element('/model/chem/dend/Radfun').expr recBAR = moose.element('/model/chem/dend/recBAR').expr gradBAReval = 2.1 * 1e-28 * (I_M - I_C) * ( 1 / (0.2 * 0.2 * 1e-12)) * I_C + 0 * Rad print 'gradBAR', gradBAReval print I_C, I_M, I_P, Rad print moose.element('/model/chem/dend/IPreac').numKf if I_P > 0: Radfuneval = np.sqrt( (55 * 4 * 1e-18) / (2 * (0.02 - 0.08 * (np.log(1 / (I_P * 50 * 100 + 1)))))) print np.log(1 / (I_P * 50 * 100 + 1)) print(2 * (0.02 - 0.08 * (np.log(1 / (I_P * 50 * 100 + 1))))) print(55 * 4 * 1e-18) / (2 * (0.02 - 0.08 * (np.log(1 / (I_P * 50 * 100 + 1))))) print 'Radfun', Radfuneval raw_input() moose.start(0.001) step = step + 1 print step else: moose.start(0.001) print 'IMTab', moose.element('/graphs/IMTab').vector print 'IRSp53Tab', moose.element('/graphs/IRSp53Tab').vector print 'Radius', moose.element('/graphs/RadTab').vector print 'height', moose.element('/graphs/heightTab').vector print 'curv_IRSp53', moose.element('/graphs/curv_IRSp53Tab').vector print 'Ipool', moose.element('/graphs/IpoolTab').vector print 'sort', moose.element('/graphs/sortTab').vector ##print 'recruited IP', moose.vec('/model/chem/dend/IP_clx').n ##plt.plot(moose.vec('/model/chem/dend/IP_clx').n,label='IP at time 150') ##moose.start(250) ##if height=='True': ## plt.plot(moose.vec('/model/chem/dend/height').n,label='At time 300') ##else: ## plt.plot(moose.vec('/model/chem/dend/Rad').n,label='At time 300') plt.legend() plt.show()
chan.tau2 = params['tau2'] chan.Ek = params['Erev'] # Test to check NMDA creation. moose.le('/cell2/dend') for key, params in synparams.items(): if key == 'nmda': chan = moose.NMDAChan('/cell2/dend/' + key) chan.KMg_A = params['mgparams']['A'] chan.KMg_B = params['mgparams']['B'] chan.CMg = params['mgparams']['conc'] chan.temperature = params['temperature'] chan.extCa = params['extCa'] chan.condFraction = params['condFraction'] else: chan = moose.SynChan('/cell2/dend/' + key) chan.Gbar = params['Gbar'] chan.tau1 = params['tau1'] chan.tau2 = params['tau2'] chan.Ek = params['Erev'] m = moose.connect(nmdachan, 'ICaOut', capool, 'current') capool = moose.CaConc('/cell2/dend/capool') moose.showfield(capool) m = moose.connect(capool, 'concOut', nmdachan, 'setIntCa') moose.showmsg('/cell2')
def test_rdes1(): rdes = rd.rdesigneur() rdes.buildModel() moose.showfield(rdes.soma)
rdes = rd.rdesigneur( elecDt=50e-6, chemDt=0.002, # cellProto syntax: ['ballAndStick', 'name', somaDia, somaLength, dendDia, dendLength, numDendSegments ] cellProto=[['ballAndStick', 'soma', 12e-6, 12e-6, 4e-6, 100e-6, 2]], spineProto=[['makeActiveSpine()', 'spine']], spineDistrib=[['spine', '#dend#', '50e-6', '1e-6']], ) moose.seed(123) rdes.buildModel() moose.reinit() pre1 = moose.PresynMesh('pre1') spineHeads = moose.wildcardFind("/model/elec/#head#") print(spineHeads) pre1.buildOnSpineHeads(spineHeads) moose.showfield(pre1) print("pre1 voxelVolume = ", pre1.voxelVolume) print("pre1 voxelMidpoint = ", pre1.voxelMidpoint) pre2 = moose.PresynMesh('pre2') dends = moose.wildcardFind("/model/elec/#dend#") print(dends) pre2.buildOnDendrites(dends, 20e-6) moose.showfield(pre2) print("pre2 voxelVolume = ", pre2.voxelVolume) print("pre2 voxelMidpoint = ", pre2.voxelMidpoint)
pass import sys pfile = "layer2.p" swcfile = "538ser3sl5-cell1-2-a.CNG.swc" container1 = "cell1" container2 = "cell2" cell1 = moose.loadModel(pfile, container1) cell2 = moose.loadModel(swcfile, container2) print("P file:") moose.le("/cell1") print("SWC file:") moose.le("/cell2") moose.showfield("/cell2/soma") moose.showfield("/cell2/soma_1_0") moose.showfield("/cell2/soma_2_0") moose.showmsg("cell1/soma") moose.showmsg("cell2/soma") #import neuron from neuron import h, gui print("\n\n\n DOING NEURON NOW! \n\n\n") soma = h.Section(name="soma") dir(soma) soma.insert("pas") soma.nseg = 3
import moose import numpy as np from matplotlib import pyplot as plt from pprint import pprint # allows for one to see nested dictionaries clearer plt.ion() nmdachan = moose.NMDAChan('/nmda') moose.showfield(nmdachan) nmdachan.KMg_A = 0.17 nmdachan.KMg_B = 0.012 nmdachan.CMg = 1.4 # Function to plot and see magnesium effect on NMDA channel def magnesium_term(A, B, C): eta = 1.0 / A gamma = 1.0 / B v = np.linspace(-100e-3, 60e-3, 1000) # voltage vector mg_term = 1 / (1 + eta * C * np.exp(-gamma * v)) plt.plot(v, mg_term) synparams = {} mgparams = {'A': (1 / 6.0), 'B': (1 / 80.0), 'conc': 1.4} synparams['ampa'] = {'Erev': 5e-3, 'tau1': 1.0e-3, 'tau2': 5e-3, 'Gbar': 1e-9} synparams['nmda'] = { 'Erev': 5e-3, 'tau1': 1.1e-3, 'tau2': 37.5e-3, 'Gbar': 2e-9, 'mgparams': mgparams,
neuron.gamma = 108.0 if key == "accommodation": neuron.accommodating = True neuron.u0 = -0.065 self.neuron = neuron neuron.a = params[1] * 1e3 # ms^-1 -> s^-1 neuron.b = params[2] * 1e3 # ms^-1 -> s^-1 neuron.c = params[3] * 1e-3 # mV -> V neuron.d = params[4] # d is in mV/ms = V/s neuron.initVm = params[6] * 1e-3 # mV -> V neuron.Vmax = 0.03 # mV -> V if key != "accommodation": neuron.initU = neuron.initVm * neuron.b else: neuron.initU = -16.0 # u is in mV/ms = V/s moose.showfield(neuron) self.neurons[key] = neuron return neuron def _make_pulse_input(self, key): """This is for creating a pulse generator for use as a current source for all cases except Class_1, Class_2, resonator, integrator, thresh_var and accommodation.""" try: return self.inputs[key] except KeyError: pass # continue to the reset of the function baseLevel = 0.0 firstWidth = 1e6 firstDelay = 0.0 firstLevel = IzhikevichDemo.parameters[key][5] * 1e-6
def main(): # Simulation information. simtime = 0.1 simdt = 0.25e-5 plotdt = 0.25e-3 # Cell Compartment infromation diameter = 30e-6 length = 50e-6 Em = EREST_ACT + 10.613e-3 CM = 1e-6 * 1e4 RM = 1 / (0.3E-3 * 1e4) # Channel information. sa, x_sa = compute_comp_area(diameter, length) na_g = 120E-3 * sa * 1E4 na_ek = 115E-3 + EREST_ACT k_g = 36e-3 * sa * 1E4 k_ek = -12E-3 + EREST_ACT # Stimulus information inj_delay = 20E-3 inj_amp = 1E-9 inj_width = 40E-3 # Create cell soma = create_compartment('soma', length, diameter, RM, CM, initVM=EREST_ACT, ELEAK=Em) # Create channels K_chan = create_channel(chan_name='K', vdivs=VDIVS, vmin=VMIN, vmax=VMAX, x_params=K_n_params, xpow=4) Na_chan = create_channel(chan_name='Na', vdivs=VDIVS, vmin=VMIN, vmax=VMAX, x_params=Na_m_params, xpow=3, y_params=Na_h_params, ypow=1) # Set conductances nachan = moose.copy(Na_chan, soma.path, 'Na', 1) kchan = moose.copy(K_chan, soma.path, 'K', 1) nachan = set_channel_conductance(nachan, na_g, na_ek) moose.showfield(nachan.path) kchan = set_channel_conductance(kchan, k_g, k_ek) moose.showfield(kchan.path) # Add channels to soma moose.connect(nachan, 'channel', soma, 'channel', 'OneToOne') moose.connect(kchan, 'channel', soma, 'channel', 'OneToOne') # connect pulse gen pulse_inject = create_pulse_generator(soma, inj_width, inj_amp, delay=inj_delay) # Output table soma_v_table = create_output_table(table_element='/output', table_name='somaVm') soma_i_table = create_output_table(table_element='/output', table_name='somaIm') # Connect output tables moose.connect(soma_v_table, 'requestOut', soma, 'getVm') moose.connect(soma_i_table, 'requestOut', pulse_inject, 'getOutputValue') # Set moose simulation clocks for lable in range(7): moose.setClock(lable, simdt) moose.setClock(8, plotdt) # Run simulation moose.reinit() moose.start(simtime) # Plot output tables. v_plot = plot_vm_table(simtime, soma_v_table, soma_i_table, title="soma voltage") plt.grid(True) plt.legend(['v', 'i']) plt.show()
soma_Vm, soma_Iex = u.createDataTables(soma, data, soma_pulse) dend_Vm, dend_Iex = u.createDataTables(dend, data, soma_pulse) synchan = moose.SynChan('/neuron/swagginDend/glu') synchan.Gbar = 1e-8 synchan.tau1 = 2e-3 synchan.tau2 = 2e-3 synchan.Ek = -0.010 msg = moose.connect(dend, 'channel', synchan, 'channel') sh = moose.SimpleSynHandler('/neuron/swagginDend/glu/synhandler') moose.connect(sh, 'activationOut', synchan, 'activation') sh.synapse.num = 1 sh.synapse[0].delay = 1e-3 moose.showmsg(sh) moose.showmsg(synchan) moose.showfield(sh.synapse[0]) # the commands above specify and connect the randSpike to a synapse on the # dendrite pre_syn = moose.RandSpike('presyn_input') pre_syn.rate = 10 pre_syn.refractT = 1e-3 sh.synapse.num = 1 sh.synapse[0].delay = 5e-3 moose.connect(pre_syn, 'spikeOut', sh.synapse[0], 'addSpike') # commands above connect another spike from a pre-synaptic neuron to the # synapse pre_syn2 = moose.RandSpike('pre_syn2') pre_syn2.rate = 0 pre_syn2.refractT = 1e-3
neuron.gamma = 108.0 if key == 'accommodation': neuron.accommodating = True neuron.u0 = -0.065 self.neuron = neuron neuron.a = params[1] * 1e3 # ms^-1 -> s^-1 neuron.b = params[2] * 1e3 # ms^-1 -> s^-1 neuron.c = params[3] * 1e-3 # mV -> V neuron.d = params[4] # d is in mV/ms = V/s neuron.initVm = params[6] * 1e-3 # mV -> V neuron.Vmax = 0.03 # mV -> V if key != 'accommodation': neuron.initU = neuron.initVm * neuron.b else: neuron.initU = -16.0 # u is in mV/ms = V/s moose.showfield(neuron) self.neurons[key] = neuron return neuron def _make_pulse_input(self, key): """This is for creating a pulse generator for use as a current source for all cases except Class_1, Class_2, resonator, integrator, thresh_var and accommodation.""" try: return self.inputs[key] except KeyError: pass # continue to the reset of the function baseLevel = 0.0 firstWidth = 1e6 firstDelay = 0.0 firstLevel = IzhikevichDemo.parameters[key][5] * 1e-6
initVm = EREST_ACT cond_set = {'Na': 10000, 'K': 2500} pulse_dur = 100e-3 pulse_amp = 0.75e-9 pulse_delay1 = 20e-3 pulse_delay2 = 1e9 # Load a multi-compartment model into MOOSE and give it channels swcfile = '33-RVT162-1-4e.CNG.swc' container = 'gran_cell' libraryName = '/library' compType = 'Compartment' gran_cell = u.createMultiCompCell(swcfile, container, libraryName, compType, chan_set, cond_set, rateParams, RM, CM, RA, initVm, Em) moose.showfield('/gran_cell/soma') # Re-create the python variable pointing to the gran_cell to limit results just to # type compartment (excludes the spines and allows for createDataTables function to # work properly) gran_cell = moose.wildcardFind('/gran_cell/#[TYPE=Compartment]') # Create the pulse and apply it to the granule cell's soma g_soma_pulse = u.createPulse(gran_cell[0], 'rollingWave', pulse_dur, pulse_amp, pulse_delay1, pulse_delay2) # Create a neutral object to store the data in gran_data = moose.Neutral('/gran_data') gran_tables = [] for comp in gran_cell: gran_tables.append(u.createDataTables(comp, gran_data, g_soma_pulse))
soma.initVm = -65E-3 inj_duration = 100E-3 inj_amplitude = 0.954E-9 #0.188E-9 pulse_1 = create_pulse_generator(soma, inj_duration, inj_amplitude) moose.reinit() moose.start(0.3) print(soma.Vm) # Main call. main() ##### Class Work -3 output = moose.Neutral('/output') Vmtab = moose.Table('/output/somaVm') moose.showfield(vmtab) # To plot tables. import pylab t = pylab.linspace(0, 200E-3, len(vmtab.vector)) pylab.plot(t, vmtab.vector) pylab.show() # soma data descriptor soma_l = 20E-6 soma_d = 20E-6 soma_RM = 2 #20000 soma_CM = 0.01 #1E-6 soma_RA = 4.0
def main(): """ This example builds a simple multiscale model involving electrical and chemical signaling, but without spatial dimensions. The electrical cell model is in a single compartment and has voltage-gated channels, including a voltage-gated Ca channel for Ca influx, and a K_A channel which is regulated by the chemical pathways. The chemical model has calcium activating Calmodulin which activates CaM-Kinase II. The kinase phosphorylates the K_A channel to inactivate it. The net effect of the multiscale activity is a positive feedback loop where activity increases Ca, which activates the kinase, which reduces K_A, leading to increased excitability of the cell. In this example this results in a bistable neuron. In the resting state the cell does not fire, but if it is activated by a current pulse the cell will continue to fire even after the current is turned off. Application of an inhibitory current restores the cell to its silent state. Both the electrical and chemical models are loaded in from model description files, and these files could be replaced if one wished to define different models. However, there are model-specific Adaptor objects needed to map activity between the models of the two kinds. The Adaptors connect specific model entities between the two models. Here one Adaptor connects the electrical Ca_conc object to the chemical Ca pool. The other Adaptor connects the chemical pool representing the K_A channel to its conductance term in the electrical model. """ runtime = 4 elecDt = 50e-6 chemDt = 0.005 ePlotDt = 0.5e-3 cPlotDt = 0.0025 makeModel() moose.setClock( 8, ePlotDt ) moose.setClock( 18, cPlotDt ) for i in range( 0, 10 ): moose.setClock( i, elecDt ) for i in range( 10, 18 ): moose.setClock( i, chemDt ) graphs = moose.Neutral( '/graphs' ) caplot = addPlot( '/model/elec/soma/Ca_conc', 'getCa', 'somaCa', 8 ) vmplot = addPlot( '/model/elec/soma', 'getVm', 'somaVm', 8 ) ikplot = addPlot( '/model/elec/soma/K_A', 'getIk', 'KAIk', 8 ) addPlot( '/model/chem/kinetics/chan', 'getConc', 'chan', 18 ) addPlot( '/model/chem/kinetics/Ca', 'getConc', 'Ca', 18 ) addPlot( '/model/chem/kinetics/CaM', 'getConc', 'CaM', 18 ) addPlot( '/model/chem/kinetics/Ca_CaM_CaMKII', 'getConc', 'enz', 18 ) hsolve = moose.HSolve( '/model/elec/hsolve' ) hsolve.dt = elecDt hsolve.target = '/model/elec/soma' moose.reinit() moose.showfield( '/model/elec/soma' ) moose.element( '/model/elec/soma' ).inject = 0e-12 moose.start( runtime ) for i in moose.wildcardFind( '/model/elec/soma/#[ISA=ChanBase]' ): print( "{} {} {}".format( i.name, i.Gbar, i.modulation )) moose.element( '/model/elec/soma' ).inject = 1e-12 moose.start( runtime ) moose.element( '/model/elec/soma' ).inject = 0e-12 moose.start( runtime ) moose.element( '/model/elec/soma' ).inject = -1e-12 moose.start( runtime ) moose.element( '/model/elec/soma' ).inject = 0e-12 moose.start( runtime ) fig = plt.figure( figsize = (12,10) ) t = numpy.arange( 0, caplot.vector.size, 1 ) * caplot.dt p1 = fig.add_subplot( 411 ) p1.plot( t, caplot.vector, label="Ca elec" ) p1.legend() p2 = fig.add_subplot( 412 ) p2.plot( t, vmplot.vector, label="Vm" ) p2.legend() p3 = fig.add_subplot( 413 ) p3.plot( t, ikplot.vector, label="Ik for K_A" ) p3.legend() p4 = fig.add_subplot( 414 ) for x in moose.wildcardFind( '/graphs/#[FIELD(tick)=18]' ): t = numpy.arange( 0, x.vector.size, 1 ) * x.dt p4.plot( t, x.vector, label=x.name ) p4.legend() plt.show() quit()
def main(): """ This example builds a simple multiscale model involving electrical and chemical signaling, but without spatial dimensions. The electrical cell model is in a single compartment and has voltage-gated channels, including a voltage-gated Ca channel for Ca influx, and a K_A channel which is regulated by the chemical pathways. The chemical model has calcium activating Calmodulin which activates CaM-Kinase II. The kinase phosphorylates the K_A channel to inactivate it. The net effect of the multiscale activity is a positive feedback loop where activity increases Ca, which activates the kinase, which reduces K_A, leading to increased excitability of the cell. In this example this results in a bistable neuron. In the resting state the cell does not fire, but if it is activated by a current pulse the cell will continue to fire even after the current is turned off. Application of an inhibitory current restores the cell to its silent state. Both the electrical and chemical models are loaded in from model description files, and these files could be replaced if one wished to define different models. However, there are model-specific Adaptor objects needed to map activity between the models of the two kinds. The Adaptors connect specific model entities between the two models. Here one Adaptor connects the electrical Ca_conc object to the chemical Ca pool. The other Adaptor connects the chemical pool representing the K_A channel to its conductance term in the electrical model. """ runtime = 4 elecDt = 50e-6 chemDt = 0.005 ePlotDt = 0.5e-3 cPlotDt = 0.0025 makeModel() moose.setClock(8, ePlotDt) moose.setClock(18, cPlotDt) for i in range(0, 10): moose.setClock(i, elecDt) for i in range(10, 18): moose.setClock(i, chemDt) graphs = moose.Neutral('/graphs') caplot = addPlot('/model/elec/soma/Ca_conc', 'getCa', 'somaCa', 8) vmplot = addPlot('/model/elec/soma', 'getVm', 'somaVm', 8) ikplot = addPlot('/model/elec/soma/K_A', 'getIk', 'KAIk', 8) addPlot('/model/chem/kinetics/chan', 'getConc', 'chan', 18) addPlot('/model/chem/kinetics/Ca', 'getConc', 'Ca', 18) addPlot('/model/chem/kinetics/CaM', 'getConc', 'CaM', 18) addPlot('/model/chem/kinetics/Ca_CaM_CaMKII', 'getConc', 'enz', 18) hsolve = moose.HSolve('/model/elec/hsolve') hsolve.dt = elecDt hsolve.target = '/model/elec/soma' moose.reinit() moose.showfield('/model/elec/soma') moose.element('/model/elec/soma').inject = 0e-12 moose.start(runtime) for i in moose.wildcardFind('/model/elec/soma/#[ISA=ChanBase]'): print("{} {} {}".format(i.name, i.Gbar, i.modulation)) moose.element('/model/elec/soma').inject = 1e-12 moose.start(runtime) moose.element('/model/elec/soma').inject = 0e-12 moose.start(runtime) moose.element('/model/elec/soma').inject = -1e-12 moose.start(runtime) moose.element('/model/elec/soma').inject = 0e-12 moose.start(runtime) fig = plt.figure(figsize=(12, 10)) t = numpy.arange(0, caplot.vector.size, 1) * caplot.dt p1 = fig.add_subplot(411) p1.plot(t, caplot.vector, label="Ca elec") p1.legend() p2 = fig.add_subplot(412) p2.plot(t, vmplot.vector, label="Vm") p2.legend() p3 = fig.add_subplot(413) p3.plot(t, ikplot.vector, label="Ik for K_A") p3.legend() p4 = fig.add_subplot(414) for x in moose.wildcardFind('/graphs/#[FIELD(tick)=18]'): t = numpy.arange(0, x.vector.size, 1) * x.dt p4.plot(t, x.vector, label=x.name) p4.legend() plt.show() quit()
soma = moose.Compartment('soma') soma = moose.element('soma') # Returns a refence to an existant moose element. # Doesn't create new moose element.!!! neuron = moose.Neutral('/neuron') soma = moose.Compartment('/neuron/soma') dend = moose.Compartment('/neuron/dend') data = moose.Neutral('/data') print soma.path print soma.name # List elements under a moose element. moose.le('/neuron') # List all the attributes of a moose element. moose.showfield('/neuron') # Print individual attributes of moose elements to examine. print soma.Rm, soma.Vm, soma.Cm, soma.Ra # Allows moose to traverse into moose element to short showfield command. moose.ce('/neuron') # Change head node element for traversal. moose.ce(neuron) moose.ce() # Change the head node to root node. soma.Cm = 1e-9 soma.Rm = 10e6 soma.initVm = -75E-3
rm = 2 / 10E-4 cm = 1E-6 / 10E-4 Em = -0.065 # length is 100 microns, radius is 10 microns. Rm = rm * (2 * math.pi * 10E-6 * 100E-6) Cm = cm / (2 * math.pi * 10E-6 * 100E-6 ) # not understand calc using equation. :( soma = moose.Compartment('/soma') soma.setRm(Rm) soma.setCm(Cm) soma.setEm(Em) print(soma.Rm, soma.Cm, soma.Em) moose.showfield(soma) #Part 2 Create a pulse gen pulse = moose.PulseGen('pulse') duration = 200E-3 Vm = 30E-3 I_inj = (Vm - Em) / Rm + Vm / duration pulse.setFirstDelay(50E-3) pulse.setFirstWidth(duration) pulse.setFirstLevel(I_inj) pulse.setCount(1) moose.showfield(pulse) # I didnot understand what is difference between tick and count :( #Part 3 Connect pulse generator with soma.
def main(): library = moose.Neutral('/library') makePassiveSoma('cell', params['dendL'], params['dendDia']) makeChemProto() rdes = rd.rdesigneur( turnOffElec=True, chemPlotDt=0.1, diffusionLength=params['diffusionL'], cellProto=[['cell', 'soma']], chemProto=[['hydra', 'hydra']], chemDistrib=[['hydra', 'soma', 'install', '1']], plotList=[['soma', '1', 'dend/A', 'n', '# of A'], ['soma', '1', 'dend/B', 'n', '# of B']], # moogList = [['soma', '1', 'dend/A', 'n', 'num of A (number)']] ) moose.le('/library') moose.le('/library/hydra') moose.showfield('/library/soma/soma') rdes.buildModel() #moose.element('/model/chem/dend/B').vec[50].nInit=15.5 A = moose.vec('/model/chem/dend/A') B = moose.vec('/model/chem/dend/B') # A.concInit=1 # B.concInit=10 moose.element('/model/chem/dend/A').vec[500].nInit = 110 #moose.element('/model/chem/dend/A').vec[490].nInit=101 #moose.element('/model/chem/dend/B').vec[25].nInit=0 #A.nInit=1 #B.nInit=15 for i in range(0, 499): #moose.element('/model/chem/dend/A').vec[i].diffConst=9.45e-12 moose.element('/model/chem/dend/A').vec[i].diffConst = 1e-14 moose.element('/model/chem/dend/B').vec[i].diffConst = 1e-14 #moose.element('/model/chem/dend/B').vec[i].diffConst=0.27e-09 for i in range(500, 999): #moose.element('/model/chem/dend/A').vec[i].diffConst=9.45e-12 moose.element('/model/chem/dend/A').vec[i].diffConst = 1e-14 moose.element('/model/chem/dend/B').vec[i].diffConst = 1e-14 #moose.element('/model/chem/dend/B').vec[i].diffConst=0.27e-09 for i in range(0, 200): moose.element('/model/chem/dend/A').vec[i].diffConst = 1e-14 for i in range(700, 999): moose.element('/model/chem/dend/A').vec[i].diffConst = 1e-14 #avec = moose.vec( '/model/chem/dend/A' ).n #bvec = moose.vec( '/model/chem/dend/B' ).n print "diffconst is ", moose.element( '/model/chem/dend/A').vec[50].diffConst #plt.ion() #fig=plt.figure(figsize=(12,10)) #ax=fig.add_subplot(111) #ax.set_ylim( 0, 5) #ax1=fig.add_subplot(212) #plt.xlabel('position') #plt.ylabel('# of A') #timeLabel = plt.text(1, 1, 'time=0.0') #pos=np.arange(0,A.n.size,1) #line1,=ax.plot(pos,A.n,label='A') #line2,=ax.plot(pos,B.n,label='B') #fig.canvas.draw() #displayInterval=2 #runTime=1000 moose.reinit() moose.start(2000) avec = moose.vec('/model/chem/dend/A').n bvec = moose.vec('/model/chem/dend/B').n plt.plot(avec) #moose.start(10) #plt.plot(avec) #plt.show() #print "Before for loop" #for t in range(displayInterval,runTime,displayInterval): #print t, "entering loop" #moose.start(displayInterval) #timeLabel.set_text( "Time = %f" % t) #line1.set_ydata(A.n) #line2.set_ydata(B.n) #plt.plot(avec) #plt.show() #fig.canvas.draw() #plt.plot(avec) #plt.ioff()''' #for i in range(98,99): #moose.element('/model/chem/dend/A').vec[i].diffConst=1e-06 #moose.element('/model/chem/dend/B').vec[i].diffConst=0 #Adot = moose.element('/model/chem/dend/A/Adot') #Bdot = moose.element('/model/chem/dend/B/Bdot') #print "\n\n\t\t Before Run", Adot, Bdot, A.nInit, B.nInit, A.n, B.n, A.concInit, B.concInit #moose.reinit() #moose.start(2000) #print "\n\n\t\t After Run", A.nInit, B.nInit, A.n, B.n, A.concInit, B.concInit # rdes.display() # rdes.displayMoogli( 1, 400, 0.001 ) #avec = moose.vec( '/model/chem/dend/A' ).n #bvec = moose.vec( '/model/chem/dend/B' ).n #tab = moose.element( '/model/graphs/plot0') #dt = tab.dt #tvec=[] #tvec.append( tab.vector ) # xplot = [] # xplot.append( avec ) ## t = np.arange( 0, len( tvec[0] ), 1.0 ) * dt #plt.plot(bvec) #print bvec, len(bvec), bvec return bvec, avec