def test( ): compt = moose.CubeMesh( '/compt' ) r = moose.Reac( '/compt/r' ) a = moose.Pool( '/compt/a' ) a.concInit = 1 b = moose.Pool( '/compt/b' ) b.concInit = 2 c = moose.Pool( '/compt/c' ) c.concInit = 0.5 moose.connect( r, 'sub', a, 'reac' ) moose.connect( r, 'prd', b, 'reac' ) moose.connect( r, 'prd', c, 'reac' ) r.Kf = 0.1 r.Kb = 0.01 tabA = moose.Table2( '/compt/a/tab' ) tabB = moose.Table2( '/compt/tabB' ) tabC = moose.Table2( '/compt/tabB/tabC' ) print(tabA, tabB, tabC) moose.connect( tabA, 'requestOut', a, 'getConc' ) moose.connect( tabB, 'requestOut', b, 'getConc' ) moose.connect( tabC, 'requestOut', c, 'getConc' ) # Now create a streamer and use it to write to a stream st = moose.Streamer( '/compt/streamer' ) st.outfile = os.path.join( os.getcwd(), 'temp.npy' ) print(("outfile set to: %s " % st.outfile )) assert st.outfile == os.path.join( os.getcwd(), 'temp.npy' ), st.outfile st.addTable( tabA ) st.addTables( [ tabB, tabC ] ) assert st.numTables == 3 moose.reinit( ) print( '[INFO] Running for 57 seconds' ) moose.start( 57 ) outfile = st.outfile moose.quit() # Otherwise Streamer won't flush the rest of entries. # Now read the table and verify that we have written print( '[INFO] Reading file %s' % outfile ) if 'csv' in outfile: data = np.loadtxt(outfile, skiprows=1 ) else: data = np.load( outfile ) # Total rows should be 58 (counting zero as well). # print(data) # print( data.dtype ) time = data['time'] print( time ) assert data.shape >= (58,), data.shape print( '[INFO] Test 2 passed' ) return 0
def makeModel(): # create container for model model = moose.Neutral('model') harmonic = moose.CubeMesh('/model/harmonic') harmonic.volume = 1e-15 lotka = moose.CubeMesh('/model/lotka') lotka.volume = 1e-15 # create molecules and reactions x = moose.Pool('/model/lotka/x') y = moose.Pool('/model/lotka/y') z = moose.BufPool('/model/lotka/z') # Dummy molecule. xreac = moose.Reac('/model/lotka/xreac') yreac = moose.Reac('/model/lotka/yreac') xrate = moose.Function('/model/lotka/xreac/func') yrate = moose.Function('/model/lotka/yreac/func') # Parameters alpha = 1.0 beta = 1.0 gamma = 1.0 delta = 1.0 k = 1.0 x.nInit = 2.0 y.nInit = 1.0 z.nInit = 0.0 xrate.x.num = 1 yrate.x.num = 1 xrate.expr = "x0 * " + str(beta) + " - " + str(alpha) yrate.expr = str(gamma) + " - x0 * " + str(delta) xreac.Kf = k yreac.Kf = k xreac.Kb = 0 yreac.Kb = 0 # connect them up for reactions moose.connect(y, 'nOut', xrate.x[0], 'input') moose.connect(x, 'nOut', yrate.x[0], 'input') moose.connect(xrate, 'valueOut', xreac, 'setNumKf') moose.connect(yrate, 'valueOut', yreac, 'setNumKf') moose.connect(xreac, 'sub', x, 'reac') moose.connect(xreac, 'prd', z, 'reac') moose.connect(yreac, 'sub', y, 'reac') moose.connect(yreac, 'prd', z, 'reac') # Create the output tables graphs = moose.Neutral('/model/graphs') xplot = moose.Table2('/model/graphs/x') yplot = moose.Table2('/model/graphs/y') # connect up the tables moose.connect(xplot, 'requestOut', x, 'getN') moose.connect(yplot, 'requestOut', y, 'getN')
def makeModel(): # create container for model model = moose.Neutral('model') compartment = moose.CubeMesh('/model/compartment') compartment.volume = 1e-21 # m^3 # the mesh is created automatically by the compartment mesh = moose.element('/model/compartment/mesh') # create molecules and reactions a = moose.Pool('/model/compartment/a') b = moose.Pool('/model/compartment/b') c = moose.Pool('/model/compartment/c') enz1 = moose.Enz('/model/compartment/b/enz1') enz2 = moose.Enz('/model/compartment/c/enz2') cplx1 = moose.Pool('/model/compartment/b/enz1/cplx') cplx2 = moose.Pool('/model/compartment/c/enz2/cplx') reac = moose.Reac('/model/compartment/reac') # connect them up for reactions moose.connect(enz1, 'sub', a, 'reac') moose.connect(enz1, 'prd', b, 'reac') moose.connect(enz1, 'enz', b, 'reac') moose.connect(enz1, 'cplx', cplx1, 'reac') moose.connect(enz2, 'sub', b, 'reac') moose.connect(enz2, 'prd', a, 'reac') moose.connect(enz2, 'enz', c, 'reac') moose.connect(enz2, 'cplx', cplx2, 'reac') moose.connect(reac, 'sub', a, 'reac') moose.connect(reac, 'prd', b, 'reac') # Assign parameters a.concInit = 1 b.concInit = 0 c.concInit = 0.01 enz1.kcat = 0.4 enz1.Km = 4 enz2.kcat = 0.6 enz2.Km = 0.01 reac.Kf = 0.0001 reac.Kb = 0.001 # Create the output tables graphs = moose.Neutral('/model/graphs') outputA = moose.Table2('/model/graphs/concA') outputB = moose.Table2('/model/graphs/concB') outputC = moose.Table2('/model/graphs/concC') # connect up the tables moose.connect(outputA, 'requestOut', a, 'getConc') moose.connect(outputB, 'requestOut', b, 'getConc') moose.connect(outputC, 'requestOut', c, 'getConc')
def makeChemProto(name, Aexpr, Bexpr, params): sw = params['stimWidth'] diffLength = params['diffusionLength'] dca = params['diffConstA'] * diffLength * diffLength dcb = params['diffConstB'] * diffLength * diffLength # Objects chem = moose.Neutral('/library/' + name) compt = moose.CubeMesh('/library/' + name + '/' + name) A = moose.Pool(compt.path + '/A') B = moose.Pool(compt.path + '/B') Z = moose.BufPool(compt.path + '/Z') Ca = moose.BufPool(compt.path + '/Ca') phase = moose.BufPool(compt.path + '/phase') vel = moose.BufPool(compt.path + '/vel') ampl = moose.BufPool(compt.path + '/ampl') Adot = moose.Function(A.path + '/Adot') Bdot = moose.Function(B.path + '/Bdot') CaStim = moose.Function(Ca.path + '/CaStim') A.diffConst = dca B.diffConst = dcb # Equations Adot.expr = parseExpr(Aexpr, params, True) Bdot.expr = parseExpr(Bexpr, params, False) CaStim.expr = 'x2 * exp( -((x0 - t)^2)/(2* ' + str(sw * sw) + ') )' # Connections Adot.x.num = 4 moose.connect(Ca, 'nOut', Adot.x[0], 'input') moose.connect(A, 'nOut', Adot.x[1], 'input') moose.connect(B, 'nOut', Adot.x[2], 'input') moose.connect(Z, 'nOut', Adot.x[3], 'input') moose.connect(Adot, 'valueOut', A, 'increment') Bdot.x.num = 3 if name[:5] == 'negFF': moose.connect(Ca, 'nOut', Bdot.x[0], 'input') print('Doing special msg') else: moose.connect(A, 'nOut', Bdot.x[0], 'input') moose.connect(B, 'nOut', Bdot.x[1], 'input') moose.connect(Z, 'nOut', Bdot.x[2], 'input') moose.connect(Bdot, 'valueOut', B, 'increment') CaStim.x.num = 3 moose.connect(phase, 'nOut', CaStim.x[0], 'input') moose.connect(vel, 'nOut', CaStim.x[1], 'input') moose.connect(ampl, 'nOut', CaStim.x[2], 'input') moose.connect(CaStim, 'valueOut', Ca, 'setN') return compt
def makeModel(): # create container for model num = 1 # number of compartments model = moose.Neutral('/model') compartment = moose.CylMesh('/model/compartment') compartment.x1 = 1.0e-6 # Set it to a 1 micron single-voxel cylinder # create molecules and reactions s = moose.Pool('/model/compartment/s') rXfer = moose.Reac('/model/compartment/rXfer') ##################################################################### # Put in endo compartment. Add molecule s endo = moose.EndoMesh('/model/endo') endo.isMembraneBound = True endo.surround = compartment es = moose.Pool('/model/endo/s') ##################################################################### moose.connect(rXfer, 'sub', s, 'reac') moose.connect(rXfer, 'sub', s, 'reac') moose.connect(rXfer, 'prd', es, 'reac') moose.connect(rXfer, 'prd', es, 'reac') rXfer.Kf = 0.01 # 0.01/sec rXfer.Kb = 0.01 # 0.01/sec ##################################################################### fixXreacs.fixXreacs('/model') fixXreacs.restoreXreacs('/model') fixXreacs.fixXreacs('/model') ##################################################################### # Make solvers ksolve = moose.Ksolve('/model/compartment/ksolve') dsolve = moose.Dsolve('/model/dsolve') eksolve = moose.Ksolve('/model/endo/ksolve') edsolve = moose.Dsolve('/model/endo/dsolve') stoich = moose.Stoich('/model/compartment/stoich') stoich.compartment = compartment stoich.ksolve = ksolve stoich.dsolve = dsolve stoich.path = "/model/compartment/##" assert (dsolve.numPools == 2) s.vec.concInit = [1] * num estoich = moose.Stoich('/model/endo/stoich') estoich.compartment = endo estoich.ksolve = eksolve estoich.dsolve = edsolve estoich.path = "/model/endo/##" assert (edsolve.numPools == 1) edsolve.buildMeshJunctions(dsolve)
def buildLargeSystem(useStreamer=False): # create a huge system. if moose.exists('/comptB'): moose.delete('/comptB') moose.CubeMesh('/comptB') tables = [] for i in range(300): r = moose.Reac('/comptB/r%d' % i) a = moose.Pool('/comptB/a%d' % i) a.concInit = 10.0 b = moose.Pool('/comptB/b%d' % i) b.concInit = 2.0 c = moose.Pool('/comptB/c%d' % i) c.concInit = 0.5 moose.connect(r, 'sub', a, 'reac') moose.connect(r, 'prd', b, 'reac') moose.connect(r, 'prd', c, 'reac') r.Kf = 0.1 r.Kb = 0.01 # Make table name large enough such that the header is larger than 2^16 # . Numpy version 1 can't handle such a large header. If format 1 is # then this test will fail. t = moose.Table2('/comptB/TableO1%d' % i + 'abc' * 100) moose.connect(t, 'requestOut', a, 'getConc') tables.append(t) if useStreamer: s = moose.Streamer('/comptB/streamer') s.datafile = 'data2.npy' print("[INFO ] Total tables %d" % len(tables)) # Add tables using wilcardFind. s.addTables(moose.wildcardFind('/comptB/##[TYPE=Table2]')) print("Streamer has %d table" % s.numTables) assert s.numTables == len(tables), (s.numTables, len(tables)) moose.reinit() moose.start(10) if useStreamer: # load the data data = np.load(s.datafile) header = str(data.dtype.names) assert len(header) > 2**16 else: data = {x.columnName: x.vector for x in tables} return data
def makeChemModel(compt): # create molecules and reactions a = moose.Pool(compt.path + '/a') b = moose.Pool(compt.path + '/b') a.concInit = 0 b.concInit = 0 # Assign parameters a.diffConst = diffConst a.motorConst = motorConst b.diffConst = diffConst b.motorConst = -motorConst
def makeReacs(): # Parameters volume = 1e-15 CaInitConc = 60e-6 NA = 6.022e23 tauI = 1 tauG = 0.1 model = moose.Neutral('/cells') compartment = moose.CubeMesh('/cells/compartment') compartment.volume = volume # Make pools Ca = moose.BufPool('/cells/compartment/Ca') tgtCa = moose.BufPool('/cells/compartment/tgtCa') m = moose.Pool('/cells/compartment/m') chan = moose.Pool('/cells/compartment/chan') # Make Funcs f1 = moose.Func('/cells/compartment/f1') f2 = moose.Func('/cells/compartment/f2') # connect up moose.connect(f1, 'valueOut', m, 'increment') moose.connect(f2, 'valueOut', chan, 'increment') moose.connect(Ca, 'nOut', f1, 'xIn') moose.connect(tgtCa, 'nOut', f1, 'yIn') moose.connect(m, 'nOut', f2, 'xIn') moose.connect(chan, 'nOut', f2, 'yIn') # Set params Ca.concInit = CaInitConc tgtCa.concInit = tgtCaInitConc m.concInit = 0.0 chan.concInit = 0.0 volscale = 1.0 f1.expr = str(volscale / tauI) + " * (x-y)" f2.expr = str(volscale / tauG) + " * (x-y)" #Plotting channelPlot = makePlot('channelConc', chan, 'Conc', 18) mPlot = makePlot('mConc', m, 'Conc', 18) caPlot = makePlot('Ca', Ca, 'Conc', 18) targetPlot = makePlot('tgtCa', tgtCa, 'Conc', 18) return (channelPlot, mPlot, caPlot)
def makeChemProto(name='hydra'): maxs = 0.05 chem = moose.Neutral('/library/' + name) compt = moose.CubeMesh('/library/' + name + '/' + name) A = moose.Pool(compt.path + '/A') B = moose.Pool(compt.path + '/B') S = moose.Pool(compt.path + '/S') space = moose.Pool(compt.path + '/space') #C=moose.Pool(compt.path+'/C') #A.diffConst=params['diffA'] #B.diffConst=params['diffB'] Adot = moose.Function(A.path + '/Adot') Bdot = moose.Function(B.path + '/Bdot') Sdot = moose.Function(S.path + '/Sdot') spacedot = moose.Function(space.path + '/spacedot') #Cdot = moose.Function( C.path + '/Cdot' ) #Adot.expr="0.001*((x0^2/x1)+1)-1*x0+0.5*x0" #Bdot.expr="0*x0+0.001*x0^2-1*x1+1*x1" #Adot.expr="-x0+x1(0.067+(1*x0^2)/(1+x0^2))" #Bdot.expr="x0-x1(0.067+(1*x0^2)/(1+x0^2))" Adot.expr = "-x0+x1*(0.067+(1*x0^2)/(1+x0^2))+(t<20)*(0.05/2)*(1+cos(" + str( np.pi) + "*x3))*x1*x2+(t>20)*(t<25)*(0.05/4)*(cos(" + str( np.pi) + "*(t-20)/5))*(1+cos(" + str(np.pi) + "*x3))*x1*x2" Bdot.expr = "x0-x1*(0.067+(1*x0^2)/(1+x0^2))-(t<20)*(0.05/2)*(1+cos(" + str( np.pi) + "*x3))*x1*x2-(t>20)*(t<25)*(0.05/4)*(cos(" + str( np.pi) + "*(t-20)/5))*(1+cos(" + str(np.pi) + "*x3))*x1*x2" Sdot.expr = "0" spacedot.expr = "0" #Cdot.expr="0*x0+0.11*x1-0.11*x2+0.1*x0^2-0.1*(x1+x2)" print "$$$$> ", Adot, Bdot print Adot.expr, Bdot.expr print moose.showmsg(Adot) Adot.x.num = 4 #2 Bdot.x.num = 4 #2 moose.connect(A, 'nOut', Adot.x[0], 'input') moose.connect(B, 'nOut', Adot.x[1], 'input') moose.connect(S, 'nOut', Adot.x[2], 'input') moose.connect(space, 'nOut', Adot.x[3], 'input') moose.connect(Adot, 'valueOut', A, 'increment') moose.connect(A, 'nOut', Bdot.x[0], 'input') moose.connect(B, 'nOut', Bdot.x[1], 'input') moose.connect(S, 'nOut', Bdot.x[2], 'input') moose.connect(space, 'nOut', Bdot.x[3], 'input') moose.connect(Bdot, 'valueOut', B, 'increment') return compt
def createPool(compt, name, concInit): meshEntries = moose.element(compt.path + '/mesh') pool = moose.Pool(compt.path + '/' + name) moose.connect(pool, 'mesh', meshEntries, 'mesh', 'Single') pool.concInit = concInit pool.diffConst = 1e-11 return pool
def test_vec3(): print("test vec3") foo = moose.Pool('/foo3', 500) foo.vec.concInit = 0.123 print(foo.vec) assert foo.concInit == 0.123, foo.concInit assert np.allclose(foo.vec.concInit, [0.123]*500)
def createChemModel(neuroCompt): dendCa = createPool(neuroCompt, 'Ca', 1e-4) dendKinaseInact = createPool(neuroCompt, 'inact_kinase', 1e-4) dendKinase = createPool(neuroCompt, 'Ca.kinase', 0.0) dendTurnOnKinase = moose.Reac(neuroCompt.path + '/turnOnKinase') moose.connect(dendTurnOnKinase, 'sub', dendCa, 'reac') moose.connect(dendTurnOnKinase, 'sub', dendKinaseInact, 'reac') moose.connect(dendTurnOnKinase, 'prd', dendKinase, 'reac') dendTurnOnKinase.Kf = 50000 dendTurnOnKinase.Kb = 1 dendKinaseEnz = moose.Enz(dendKinase.path + '/enz') dendKinaseEnzCplx = moose.Pool(dendKinase.path + '/enz/cplx') kChan = createPool(neuroCompt, 'kChan', 1e-3) kChan_p = createPool(neuroCompt, 'kChan_p', 0.0) moose.connect(dendKinaseEnz, 'enz', dendKinase, 'reac', 'OneToOne') moose.connect(dendKinaseEnz, 'sub', kChan, 'reac', 'OneToOne') moose.connect(dendKinaseEnz, 'prd', kChan_p, 'reac', 'OneToOne') moose.connect(dendKinaseEnz, 'cplx', dendKinaseEnzCplx, 'reac', 'OneToOne') dendKinaseEnz.Km = 1e-4 dendKinaseEnz.kcat = 20 dendPhosphatase = moose.Reac(neuroCompt.path + '/phosphatase') moose.connect(dendPhosphatase, 'sub', kChan_p, 'reac') moose.connect(dendPhosphatase, 'prd', kChan, 'reac') dendPhosphatase.Kf = 1 dendPhosphatase.Kb = 0.0
def main(): """ This example implements a reaction-diffusion like system which is bistable and propagates losslessly. It is based on the NEURON example rxdrun.py, but incorporates more compartments and runs for a longer time. The system is implemented in a function rather than as a proper system of chemical reactions. Please see rxdReacDiffusion.py for a variant that uses a reaction plus a function object to control its rates. """ dt = 0.1 # define the geometry compt = moose.CylMesh('/cylinder') compt.r0 = compt.r1 = 1 compt.diffLength = 0.2 compt.x1 = 100 assert (compt.numDiffCompts == compt.x1 / compt.diffLength) #define the molecule. Its geometry is defined by its parent volume, cylinder c = moose.Pool('/cylinder/pool') c.diffConst = 1 # define diffusion constant # Here we set up a function calculation func = moose.Function('/cylinder/pool/func') func.expr = "-x0 * (0.3 - x0) * (1 - x0)" func.x.num = 1 #specify number of input variables. #Connect the molecules to the func moose.connect(c, 'nOut', func.x[0], 'input') #Connect the function to the pool moose.connect(func, 'valueOut', c, 'increment') #Set up solvers ksolve = moose.Ksolve('/cylinder/ksolve') dsolve = moose.Dsolve('/cylinder/dsolve') stoich = moose.Stoich('/cylinder/stoich') stoich.ksolve = ksolve stoich.dsolve = dsolve stoich.compartment = compt stoich.reacSystemPath = '/cylinder/##' #initialize x = numpy.arange(0, compt.x1, compt.diffLength) c.vec.nInit = [(q < 0.2 * compt.x1) for q in x] # Run and plot it. moose.reinit() updateDt = 50 runtime = updateDt * 4 plt = pylab.plot(x, c.vec.n, label='t = 0 ') t1 = time.time() for t in range(0, runtime - 1, updateDt): moose.start(updateDt) plt = pylab.plot(x, c.vec.n, label='t = ' + str(t + updateDt)) print(("Time = %f " % (time.time() - t1))) print(("Time = %s " % (time.time() - t1))) pylab.ylim(0, 1.05) pylab.legend() pylab.show()
def makeChemModel(compt, doInput): """ This function setus up a simple chemical system in which Ca input comes to the dend and to selected PSDs. There is diffusion between PSD and spine head, and between dend and spine head. Ca_input ------> Ca // in dend and spine head only. """ # create molecules and reactions Ca = moose.Pool(compt.path + '/Ca') Ca.concInit = 0.08 * 1e-3 Ca.diffConst = diffConst if doInput: Ca_input = moose.BufPool(compt.path + '/Ca_input') Ca_input.concInit = 0.08 * 1e-3 Ca_input.diffConst = diffConst rInput = moose.Reac(compt.path + '/rInput') moose.connect(rInput, 'sub', Ca, 'reac') moose.connect(rInput, 'prd', Ca_input, 'reac') rInput.Kf = 100 # 1/sec rInput.Kb = 100 # 1/sec else: Ca_sink = moose.BufPool(compt.path + '/Ca_sink') Ca_sink.concInit = 0.08 * 1e-3 rSink = moose.Reac(compt.path + '/rSink') moose.connect(rSink, 'sub', Ca, 'reac') moose.connect(rSink, 'prd', Ca_sink, 'reac') rSink.Kf = 10 # 1/sec rSink.Kb = 10 # 1/sec
def dephosphorylate(frmPool, toPool, michealson_mentis=False): global molecules_ global curr_subsec_ dephospho_.append(frmPool.name) if michealson_mentis: e = moose.MMenz('%s/%s.dephospho' % (frmPool.path, frmPool.name)) moose.connect(e, 'sub', frmPool, 'reac') moose.connect(e, 'prd', toPool, 'reac') moose.connect(molecules_['PP1'], 'nOut', e, 'enzDest') e.Km = _p.K_M e.kcat = 10 else: # if not Michealson-Mentis scheme and use this. inter = moose.Pool('%s/pp1_%s_cplx' % (frmPool.path, frmPool.name)) inter.name = curr_subsec_ + '.' + inter.name inter.nInit = 0 r = add_reaction('%s/%s.add_pp1' % (frmPool.path, frmPool.name)) moose.connect(r, 'sub', frmPool, 'reac') moose.connect(r, 'sub', molecules_[curr_subsec_ + '.' + 'PP1'], 'reac') moose.connect(r, 'prd', inter, 'reac') r.Kf = (_p.k_2) / _p.K_M r.Kb = 0.0 rr = add_reaction('%s/%s.dephospho' % (frmPool.path, frmPool.name)) moose.connect(rr, 'sub', inter, 'reac') moose.connect(rr, 'prd', molecules_[curr_subsec_ + '.' + 'PP1_'], 'reac') moose.connect(rr, 'prd', toPool, 'reac') rr.numKf = 10.0 rr.numKb = 0.0 _logger.debug("Reaction (dephospho): %s -> %s, enzymatic=%s" % (frmPool.name, toPool.name, michealson_mentis))
def test_vec(): foo = moose.Pool('/foo1', 500) # bar = moose.vec('/foo1') bar = moose.vec(foo) assert len(bar) == 500, len(bar) for i in range(len(bar)): print(bar[i])
def test_ksolve(): compt = moose.CubeMesh( '/compt' ) compt.volume = 1e-20 pools = [] for r in range( 10 ): a1 = moose.Pool( '/compt/a1%s' % r ) a1.concInit = 10 a2 = moose.Pool( '/compt/a2%s' % r ) a2.concInit = 5 b1 = moose.Pool( '/compt/b1%s' % r ) b1.concInit = 0.054 b2 = moose.Pool( '/compt/b2%s' % r ) b2.concInit = 3.9 r = moose.Reac( '/compt/reac%s'% r ) moose.connect( r, 'sub', a1, 'reac' ) moose.connect( r, 'sub', a2, 'reac' ) moose.connect( r, 'prd', b1, 'reac' ) moose.connect( r, 'prd', b2, 'reac' ) r.Kf = 2.9 r.Kb = 4.5 pools += [ a1, a2, b1, b2 ] ksolve = moose.Ksolve( '/compt/ksolve' ) stoich = moose.Stoich( '/compt/stoich' ) stoich.compartment = compt stoich.ksolve = ksolve ksolve.numThreads = 2 stoich.path = '/compt/##' moose.reinit() print( '[INFO] Using method = %s' % ksolve.method ) t1 = time.time() moose.start( 100 ) print('[INFO] Time taken %s' % (time.time() - t1 )) expected = [ 7.77859 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 , 7.77858 , 2.77858 , 2.27541 , 6.12141 ] concs = [ p.conc for p in pools ] if(not np.isclose( concs, expected ).all() ): print( " Expected %s" % expected ) print( " Got %s" % concs ) quit(1) print( 'Test passed' )
def test(): compt = moose.CubeMesh('/compt') r = moose.Reac('/compt/r') a = moose.Pool('/compt/a') a.concInit = 1 b = moose.Pool('/compt/b') b.concInit = 2 c = moose.Pool('/compt/c') c.concInit = 0.5 moose.connect(r, 'sub', a, 'reac') moose.connect(r, 'prd', b, 'reac') moose.connect(r, 'prd', c, 'reac') r.Kf = 0.1 r.Kb = 0.01 tabA = moose.Table2('/compt/a/tabA') tabA.format = 'npy' tabA.useStreamer = 1 # Setting format alone is not good enough tabB = moose.Table2('/compt/b/tabB') tabB.outfile = 'table2.npy' tabC = moose.Table2('/compt/c/tabC') tabC.outfile = 'tablec.csv' moose.connect(tabA, 'requestOut', a, 'getConc') moose.connect(tabB, 'requestOut', b, 'getConc') moose.connect(tabC, 'requestOut', c, 'getConc') moose.reinit() [print_table(x) for x in [tabA, tabB, tabC]] runtime = 1000 print('Starting moose for %d secs' % runtime) moose.start(runtime, 1) print(' MOOSE is done') # Now read the numpy and csv and check the results. a = np.load('_tables/compt/a/tabA.npy') b = np.load('table2.npy') c = np.loadtxt('tablec.csv', skiprows=1) print(a) print(b) print(c) print(a['time']) print(b['time']) assert len(a['time']) == len(a['/compt/a/tabA'])
def makeChemProto(name='hydra'): chem = moose.Neutral('/library/' + name) compt = moose.CubeMesh('/library/' + name + '/' + name) A = moose.Pool(compt.path + '/A') #B=moose.Pool(compt.path+'/B') C = moose.Pool(compt.path + '/C') r1 = moose.Reac(compt.path + '/r1') #e1=moose.MMenz(compt.path+'/e1') moose.connect(r1, 'sub', A, 'reac') moose.connect(r1, 'prd', C, 'reac') #moose.connect(C,'nOut',e1,'enzDest') r1.Kf = 1 r1.Kb = 0.1 A.nInit = 0 #B.nInit=0 C.nInit = 0 return compt
def create_model(compt, sec): global pools_ for s in ['A']: x = moose.Pool('%s/%s.%s' % (compt.path, sec, s)) pools_[x.name] = x t = moose.Table2('%s/tab%s.%s' % (compt.path, sec, s)) moose.connect(t, 'requestOut', x, 'getConc') tables_[x.name] = t
def analogStimTable(): """Example of using a StimulusTable as an analog signal source in a reaction system. It could be used similarly to give other analog inputs to a model, such as a current or voltage clamp signal. This demo creates a StimulusTable and assigns it half a sine wave. Then we assign the start time and period over which to emit the wave. The output of the StimTable is sent to a pool **a**, which participates in a trivial reaction:: table ----> a <===> b The output of **a** and **b** are recorded in a regular table for plotting. """ simtime = 150 simdt = 0.1 model = moose.Neutral('/model') data = moose.Neutral('/data') # This is the stimulus generator stimtable = moose.StimulusTable('/model/stim') a = moose.BufPool( '/model/a' ) b = moose.Pool( '/model/b' ) reac = moose.Reac( '/model/reac' ) reac.Kf = 0.1 reac.Kb = 0.1 moose.connect( stimtable, 'output', a, 'setConcInit' ) moose.connect( reac, 'sub', a, 'reac' ) moose.connect( reac, 'prd', b, 'reac' ) aPlot = moose.Table('/data/aPlot') moose.connect(aPlot, 'requestOut', a, 'getConc') bPlot = moose.Table('/data/bPlot') moose.connect(bPlot, 'requestOut', b, 'getConc') moose.setClock( stimtable.tick, simdt ) moose.setClock( a.tick, simdt ) moose.setClock( aPlot.tick, simdt ) #################################################### # Here we set up the stimulus table. It is half a sine-wave. stim = [ np.sin(0.01 * float(i) ) for i in range( 314 )] stimtable.vector = stim stimtable.stepSize = 0 # This forces use of current time as x value # The table will interpolate its contents over the time start to stop: # At values less than startTime, it emits the first value in table stimtable.startTime = 5 # At values more than stopTime, it emits the last value in table stimtable.stopTime = 60 stimtable.doLoop = 1 # Enable repeat playbacks. stimtable.loopTime = 10 + simtime / 2.0 # Repeat playback over this time moose.reinit() moose.start(simtime) t = [ x * simdt for x in range( len( aPlot.vector ) )] pylab.plot( t, aPlot.vector, label='Stimulus waveform' ) pylab.plot( t, bPlot.vector, label='Reaction product b' ) pylab.legend() pylab.show()
def makeChemProto(name): chem = moose.Neutral('/library/' + name) for i in (['dend', 1e-18], ['spine', 1e-19], ['psd', 1e-20]): print('making ', i) compt = moose.CubeMesh(chem.path + '/' + i[0]) compt.volume = i[1] Ca = moose.Pool(compt.path + '/Ca') Ca.concInit = 0.08 Ca.diffConst = 1e-11
def makeChemProto(name): chem = moose.Neutral('/library/' + name) for i in ('dend', 'spine', 'psd'): print(('making ', i)) compt = moose.CubeMesh(chem.path + '/' + i) compt.volume = 1e-18 ca = moose.Pool(compt.path + '/Ca') ca.concInit = 0.08e-3 ca.diffConst = 1e-12
def test_other(): a1 = moose.Pool('/ada') assert a1.className == 'Pool', a1.className finfo = moose.getFieldDict(a1.className) s = moose.Streamer('/asdada') p = moose.PulseGen('pg1') assert p.delay[0] == 0.0 p.delay[1] = 0.99 assert p.delay[1] == 0.99, p.delay[1]
def makeChemProto(name='hydra'): chem=moose.Neutral('/library/'+name) compt=moose.CubeMesh('/library/'+name + '/' + name) A=moose.Pool(compt.path+'/A') B=moose.Pool(compt.path+'/B') C=moose.Pool(compt.path+'/C') #A.diffConst=params['diffA'] #B.diffConst=params['diffB'] Adot = moose.Function( A.path + '/Adot' ) Bdot = moose.Function( B.path + '/Bdot' ) Cdot = moose.Function( C.path + '/Cdot' ) #Adot.expr="0.001*((x0^2/x1)+1)-1*x0+0.5*x0" #Bdot.expr="0*x0+0.001*x0^2-1*x1+1*x1" Adot.expr="-0.1*x0+((0.1*x0^2)/(x1+x2))" Bdot.expr="0*x0-0.11*x1+0.11*x2+0.1*x0^2-0.1*(x1+x2)" Cdot.expr="0*x0+0.11*x1-0.11*x2+0.1*x0^2-0.1*(x1+x2)" print "$$$$> ", Adot, Bdot, Cdot print Adot.expr, Bdot.expr, Cdot.expr print moose.showmsg(Adot) Adot.x.num = 3 #2 Bdot.x.num = 3 #2 Cdot.x.num = 3 #A.nInit=10 #B.nInit=5 A.nInit=1 B.nInit=1 C.nInit=1 moose.connect( A, 'nOut', Adot.x[0], 'input' ) moose.connect( B, 'nOut', Adot.x[1], 'input' ) moose.connect( C, 'nOut', Adot.x[2], 'input' ) moose.connect( Adot, 'valueOut', A, 'increment' ) moose.connect( A, 'nOut', Bdot.x[0], 'input' ) moose.connect( B, 'nOut', Bdot.x[1], 'input' ) moose.connect( C, 'nOut', Bdot.x[2], 'input' ) moose.connect( Bdot, 'valueOut', B, 'increment' ) moose.connect( A, 'nOut', Cdot.x[0], 'input' ) moose.connect( B, 'nOut', Cdot.x[1], 'input' ) moose.connect( C, 'nOut', Cdot.x[2], 'input' ) moose.connect( Cdot, 'valueOut', C, 'increment' ) return compt
def test_access(): a1 = moose.Pool('ac1') try: a2 = moose.Compartment('ac1') except Exception: pass else: raise RuntimeError("Should have failed.") a2 = moose.element(a1) a3 = moose.element(a1.path) assert a2 == a3, (a2, a3)
def add_pool( root, name ): global molecules_ pname = pool_name( root, name ) ppath = '%s/%s' % (root.path, name) if moose.exists( ppath ): _logger.warn( 'Already exists %s' % ppath ) return moose.element( ppath ) else: p = moose.Pool( ppath ) p.name = pname molecules_[pname] = p return p
def makeFuncRate(): model = moose.Neutral('/library') model = moose.Neutral('/library/chem') compt = moose.CubeMesh('/library/chem/compt') compt.volume = 1e-15 A = moose.Pool('/library/chem/compt/A') B = moose.Pool('/library/chem/compt/B') C = moose.Pool('/library/chem/compt/C') reac = moose.Reac('/library/chem/compt/reac') func = moose.Function('/library/chem/compt/reac/func') func.x.num = 1 func.expr = "(x0/1e8)^2" moose.connect(C, 'nOut', func.x[0], 'input') moose.connect(func, 'valueOut', reac, 'setNumKf') moose.connect(reac, 'sub', A, 'reac') moose.connect(reac, 'prd', B, 'reac') A.concInit = 1 B.concInit = 0 C.concInit = 0 reac.Kb = 1
def makeChemyOscillator(name='osc', parent='/library'): model = moose.Neutral(parent + '/' + name) compt = moose.CubeMesh(model.path + '/kinetics') """ This function sets up a simple oscillatory chemical system within the script. The reaction system is:: s ---a---> a // s goes to a, catalyzed by a. s ---a---> b // s goes to b, catalyzed by a. a ---b---> s // a goes to s, catalyzed by b. b -------> s // b is degraded irreversibly to s. in sum, **a** has a positive feedback onto itself and also forms **b**. **b** has a negative feedback onto **a**. Finally, the diffusion constant for **a** is 1/10 that of **b**. """ # create container for model diffConst = 1e-11 # m^2/sec motorRate = 1e-6 # m/sec concA = 1 # millimolar # create molecules and reactions a = moose.Pool(compt.path + '/a') c = moose.Pool(compt.path + '/c') d = moose.BufPool(compt.path + '/d') r2 = moose.Reac(compt.path + '/r2') moose.connect(r2, 'sub', a, 'reac') moose.connect(r2, 'sub', c, 'reac') moose.connect(r2, 'prd', d, 'reac') r2.Kf = 1 r2.Kb = 10 # Assign parameters a.diffConst = diffConst / 10 # b.diffConst = diffConst # s.diffConst = diffConst c.diffConst = diffConst d.diffConst = 0 return compt
def makeCyl(num, concInit, radius, x0, x1): compt = moose.CylMesh('/model/compt' + num) compt.x0 = x0 compt.x1 = x1 compt.y0 = 0 compt.y1 = 0 compt.z0 = 0 compt.z1 = 0 compt.r0 = radius compt.r1 = radius compt.diffLength = x1 - x0 a = moose.Pool(compt.path + '/a') b = moose.Pool(compt.path + '/b' + num) reac = moose.Reac(compt.path + '/reac') moose.connect(reac, 'sub', a, 'reac') moose.connect(reac, 'prd', b, 'reac') a.diffConst = diffConst a.concInit = concInit b.concInit = concInit reac.Kf = 0.1 reac.Kb = 0.1 return a, b, compt