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' )
#####################################################################
# Put in endo compartment. Add molecule s
endo = moose.EndoMesh( '/model/endo' )
endo.isMembraneBound = True
endo.surround = compartment
es = moose.Pool( '/model/endo/s' )
rXfer = moose.Reac( '/model/endo/rXfer' )
#####################################################################
moose.connect( rXfer, 'sub', s, 'reac' )
moose.connect( rXfer, 'prd', es, 'reac' )
volRatio = compartment.volume / endo.volume
rXfer.Kf = 0.04 # 0.04/sec
rXfer.Kb = 0.02 # 0.02/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 == 1 )
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 == 2 )
edsolve.buildMeshJunctions( dsolve )
plot1 = moose.Table2( '/model/plot1' )
plot2 = moose.Table2( '/model/plot2' )
moose.connect( '/model/plot1', 'requestOut', s, 'getN' )
moose.connect( '/model/plot2', 'requestOut', es, 'getN' )
plot3 = moose.Table2( '/model/plot3' )
plot4 = moose.Table2( '/model/plot4' )
moose.connect( '/model/plot3', 'requestOut', s, 'getConc' )
moose.connect( '/model/plot4', 'requestOut', es, 'getConc' )
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' )
#####################################################################
# Put in endo compartment. Add molecule s
endo = moose.EndoMesh( '/model/endo' )
endo.isMembraneBound = True
endo.surround = compartment
es = moose.Pool( '/model/endo/s' )
rXfer = moose.Reac( '/model/endo/rXfer' )
#####################################################################
moose.connect( rXfer, 'sub', s, 'reac' )
moose.connect( rXfer, 'prd', es, 'reac' )
volRatio = compartment.volume / endo.volume
rXfer.Kf = 0.04 # 0.04/sec
rXfer.Kb = 0.02 # 0.02/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 == 1 )
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 == 2 )
edsolve.buildMeshJunctions( dsolve )
plot1 = moose.Table2( '/model/plot1' )
plot2 = moose.Table2( '/model/plot2' )
moose.connect( '/model/plot1', 'requestOut', s, 'getN' )
moose.connect( '/model/plot2', 'requestOut', es, 'getN' )
plot3 = moose.Table2( '/model/plot3' )
plot4 = moose.Table2( '/model/plot4' )
moose.connect( '/model/plot3', 'requestOut', s, 'getConc' )
moose.connect( '/model/plot4', 'requestOut', es, 'getConc' )
def main(standalone=False):
mfile = os.path.join(os.path.dirname(__file__), 'OSC_diff_vols.g')
runtime = 4000.0
modelId = moose.loadModel(mfile, 'model', 'ee')
kin = moose.element('/model/kinetics')
compt1 = moose.element('/model/compartment_1')
compt1.x1 += kin.x1
compt1.x0 += kin.x1
fixXreacs.fixXreacs('/model')
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
ks1 = moose.Ksolve('/model/kinetics/ksolve')
ds1 = moose.Dsolve('/model/kinetics/dsolve')
s1 = moose.Stoich('/model/kinetics/stoich')
s1.compartment = moose.element('/model/kinetics')
s1.ksolve = ks1
s1.dsolve = ds1
s1.path = '/model/kinetics/##'
ks2 = moose.Ksolve('/model/compartment_1/ksolve')
ds2 = moose.Dsolve('/model/compartment_1/dsolve')
s2 = moose.Stoich('/model/compartment_1/stoich')
s2.compartment = moose.element('/model/compartment_1')
s2.ksolve = ks2
s2.dsolve = ds2
s2.path = '/model/compartment_1/##'
ds2.buildMeshJunctions(ds1)
moose.reinit()
moose.start(runtime)
# I don't have an analytic way to assess oscillations
assert (countCrossings('/model/graphs/conc2/M.Co', 0.001) == 4)
moose.delete('/model')
def setCompartmentSolver(modelRoot, solver):
"""
If Solver type is 'gsl' or 'gssa' do add Solver
if 'ee' nothing
"""
if solver != 'ee':
comptlist = dict(
(c.volume, c)
for c in moose.wildcardFind(modelRoot + '/##[ISA=ChemCompt]'))
vollist = sorted(comptlist.keys())
compts = [comptlist[key] for key in vollist]
#compts = [key for key, value in sorted(comptlist.items(), key=lambda (k,v): (v,k))]
if (len(compts) > 1):
positionCompt(compts)
fixXreacs(modelRoot)
vollist = sorted(comptlist.keys())
compts = [comptlist[key] for key in vollist]
#compts = [key for key, value in sorted(comptlist.items(), key=lambda (k,v): (v,k))]
for compt in compts:
if solver != 'ee':
if solver.lower() in ['gsl', 'runge kutta', 'lsoda']:
ksolve = moose.Ksolve(compt.path + '/ksolve')
elif solver.lower() in ['gssa', 'gillespie']:
ksolve = moose.Gsolve(compt.path + '/gsolve')
if (len(compts) > 1):
dsolve = moose.Dsolve(compt.path + '/dsolve')
stoich = moose.Stoich(compt.path + '/stoich')
stoich.ksolve = ksolve
if (len(compts) > 1):
stoich.dsolve = dsolve
stoich.compartment = compt
stoich.path = compt.path + "/##"
dsolveList = moose.wildcardFind(modelRoot + '/##[ISA=Dsolve]')
i = 0
while (i < len(dsolveList) - 1):
dsolveList[i + 1].buildMeshJunctions(dsolveList[i])
i += 1
if not modelRoot[:1].startswith('/'):
modelRoot = '/' + modelRoot
print(" Solver is added to model path `%s` with `%s` solver" %
(modelRoot, solver))
def test_xreac2():
mfile = os.path.join(os.path.dirname(__file__), 'OSC_diff_vols.g')
runtime = 4000.0
modelId = moose.loadModel(mfile, 'model', 'ee')
kin = moose.element('/model/kinetics')
compt1 = moose.element('/model/compartment_1')
compt1.x1 += kin.x1
compt1.x0 += kin.x1
# for r in moose.wildcardFind('/##[TYPE=Reac]'):
# print("---", r)
# print(r.neighbors['sub'])
# print(r.neighbors['prd'])
fixXreacs.fixXreacs('/model')
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
print('After fixing...')
for r in moose.wildcardFind('/##[TYPE=Reac]'):
print("---", r)
print(r.neighbors['sub'])
print(r.neighbors['prd'])
ks1 = moose.Ksolve('/model/kinetics/ksolve')
ds1 = moose.Dsolve('/model/kinetics/dsolve')
s1 = moose.Stoich('/model/kinetics/stoich')
s1.compartment = moose.element('/model/kinetics')
s1.ksolve = ks1
s1.dsolve = ds1
s1.path = '/model/kinetics/##'
ks2 = moose.Ksolve('/model/compartment_1/ksolve')
ds2 = moose.Dsolve('/model/compartment_1/dsolve')
s2 = moose.Stoich('/model/compartment_1/stoich')
s2.compartment = moose.element('/model/compartment_1')
s2.ksolve = ks2
s2.dsolve = ds2
s2.path = '/model/compartment_1/##'
print(ds1)
ds2.buildMeshJunctions(ds1)
moose.reinit()
moose.start(runtime)
# I don't have an analytic way to assess oscillations
nCrossings = countCrossings('/model/graphs/conc2/M.Co', 0.001)
assert (nCrossings == 4), "Expected 4, got %d" % nCrossings
moose.delete('/model')
def setCompartmentSolver(modelRoot, solver):
"""
If Solver type is 'gsl' or 'gssa' do add Solver
if 'ee' nothing
"""
if solver != 'ee':
comptlist = dict((c.volume, c) for c in moose.wildcardFind(modelRoot + '/##[ISA=ChemCompt]'))
vollist = sorted(comptlist.keys())
compts = [comptlist[key] for key in vollist]
#compts = [key for key, value in sorted(comptlist.items(), key=lambda (k,v): (v,k))]
if (len(compts) >1 ):
positionCompt(compts)
fixXreacs( modelRoot )
vollist = sorted(comptlist.keys())
compts = [comptlist[key] for key in vollist]
#compts = [key for key, value in sorted(comptlist.items(), key=lambda (k,v): (v,k))]
for compt in compts:
if solver != 'ee':
if (solver == 'gsl'):
ksolve = moose.Ksolve(compt.path + '/ksolve')
if (solver == 'gssa') :
ksolve = moose.Gsolve(compt.path + '/gsolve')
if (len(compts) > 1):
dsolve = moose.Dsolve(compt.path+'/dsolve')
stoich = moose.Stoich(compt.path + '/stoich')
stoich.ksolve = ksolve
if (len(compts) > 1):
stoich.dsolve = dsolve
stoich.compartment = compt
stoich.path = compt.path + "/##"
dsolveList = moose.wildcardFind(modelRoot+'/##[ISA=Dsolve]')
i = 0
while(i < len(dsolveList)-1):
dsolveList[i+1].buildMeshJunctions(dsolveList[i])
i += 1
if not modelRoot[:1].startswith('/'):
modelRoot ='/'+modelRoot
print( " Solver is added to model path `%s` with `%s` solver" % (modelRoot,solver) )
def main( standalone = False ):
mfile = os.path.join( os.path.dirname( __file__), 'OSC_diff_vols.g' )
runtime = 4000.0
modelId = moose.loadModel( mfile, 'model', 'ee' )
kin = moose.element( '/model/kinetics' )
compt1 = moose.element( '/model/compartment_1' )
compt1.x1 += kin.x1
compt1.x0 += kin.x1
fixXreacs.fixXreacs( '/model' )
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
ks1 = moose.Ksolve( '/model/kinetics/ksolve' )
ds1 = moose.Dsolve( '/model/kinetics/dsolve' )
s1 = moose.Stoich( '/model/kinetics/stoich' )
s1.compartment = moose.element( '/model/kinetics' )
s1.ksolve = ks1
s1.dsolve = ds1
s1.path = '/model/kinetics/##'
ks2 = moose.Ksolve( '/model/compartment_1/ksolve' )
ds2 = moose.Dsolve( '/model/compartment_1/dsolve' )
s2 = moose.Stoich( '/model/compartment_1/stoich' )
s2.compartment = moose.element( '/model/compartment_1' )
s2.ksolve = ks2
s2.dsolve = ds2
s2.path = '/model/compartment_1/##'
ds2.buildMeshJunctions( ds1 )
moose.reinit()
moose.start( runtime )
# I don't have an analytic way to assess oscillations
assert( countCrossings( '/model/graphs/conc2/M.Co', 0.001 ) == 4 )
if standalone:
# Display all plots.
for x in moose.wildcardFind( '/model/#graphs/conc#/#' ):
t = np.arange( 0, x.vector.size, 1 ) * x.dt
plt.plot( t, x.vector, label=x.name )
plt.legend()
plt.show()
moose.delete( '/model' )
def main(standalone=False):
mfile = os.path.join(os.path.dirname(__file__), 'OSC_diff_vols.g')
runtime = 4000.0
modelId = moose.loadModel(mfile, 'model', 'ee')
kin = moose.element('/model/kinetics')
compt1 = moose.element('/model/compartment_1')
compt1.x1 += kin.x1
compt1.x0 += kin.x1
fixXreacs.fixXreacs('/model')
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
ks1 = moose.Ksolve('/model/kinetics/ksolve')
ds1 = moose.Dsolve('/model/kinetics/dsolve')
s1 = moose.Stoich('/model/kinetics/stoich')
s1.compartment = moose.element('/model/kinetics')
s1.ksolve = ks1
s1.dsolve = ds1
s1.path = '/model/kinetics/##'
ks2 = moose.Ksolve('/model/compartment_1/ksolve')
ds2 = moose.Dsolve('/model/compartment_1/dsolve')
s2 = moose.Stoich('/model/compartment_1/stoich')
s2.compartment = moose.element('/model/compartment_1')
s2.ksolve = ks2
s2.dsolve = ds2
s2.path = '/model/compartment_1/##'
ds2.buildMeshJunctions(ds1)
moose.reinit()
moose.start(runtime)
# I don't have an analytic way to assess oscillations
assert (countCrossings('/model/graphs/conc2/M.Co', 0.001) == 4)
if standalone:
# Display all plots.
for x in moose.wildcardFind('/model/#graphs/conc#/#'):
t = np.arange(0, x.vector.size, 1) * x.dt
plt.plot(t, x.vector, label=x.name)
plt.legend()
plt.show()
moose.delete('/model')
def main( standalone = False ):
mfile = os.path.join( os.path.dirname( __file__), 'OSC_diff_vols.g' )
runtime = 4000.0
modelId = moose.loadModel( mfile, 'model', 'ee' )
kin = moose.element( '/model/kinetics' )
compt1 = moose.element( '/model/compartment_1' )
compt1.x1 += kin.x1
compt1.x0 += kin.x1
fixXreacs.fixXreacs( '/model' )
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
ks1 = moose.Ksolve( '/model/kinetics/ksolve' )
ds1 = moose.Dsolve( '/model/kinetics/dsolve' )
s1 = moose.Stoich( '/model/kinetics/stoich' )
s1.compartment = moose.element( '/model/kinetics' )
s1.ksolve = ks1
s1.dsolve = ds1
s1.path = '/model/kinetics/##'
ks2 = moose.Ksolve( '/model/compartment_1/ksolve' )
ds2 = moose.Dsolve( '/model/compartment_1/dsolve' )
s2 = moose.Stoich( '/model/compartment_1/stoich' )
s2.compartment = moose.element( '/model/compartment_1' )
s2.ksolve = ks2
s2.dsolve = ds2
s2.path = '/model/compartment_1/##'
ds2.buildMeshJunctions( ds1 )
moose.reinit()
moose.start( runtime )
# I don't have an analytic way to assess oscillations
nCrossings = countCrossings( '/model/graphs/conc2/M.Co', 0.001 )
assert( nCrossings == 4 ), "Expected 4, got %d" % nCrossings
moose.delete( '/model' )
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
prd = moose.Pool( '/model/compartment/prd' )
rXfer = moose.Reac( '/model/compartment/rXfer' )
#####################################################################
# Put in endo compartment. Add molecule s
endo = moose.EndoMesh( '/model/endo' )
endo.isMembraneBound = True
endo.surround = compartment
sub = moose.Pool( '/model/endo/sub' )
enzPool = moose.Pool( '/model/endo/enzPool' )
enzPool.concInit = eInit
enz = moose.MMenz( '/model/endo/enzPool/enz' )
#####################################################################
moose.connect( enz, 'sub', sub, 'reac' )
moose.connect( enz, 'prd', prd, 'reac' )
moose.connect( enzPool, 'nOut', enz, 'enzDest' )
moose.connect( rXfer, 'sub', prd, 'reac' )
moose.connect( rXfer, 'prd', sub, 'reac' )
rXfer.Kf = Kf # 0.04/sec
rXfer.Kb = 0.0 # 0.02/sec
enz.Km = Km
enz.kcat = kcat
# v = es.kcat/(s+Km)
# v = Kf * conc.
#####################################################################
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 )
sub.vec.concInit = subInit
enzPool.vec.concInit = eInit
estoich = moose.Stoich( '/model/endo/stoich' )
estoich.compartment = endo
estoich.ksolve = eksolve
estoich.dsolve = edsolve
estoich.path = "/model/endo/##"
assert( edsolve.numPools == 3 )
edsolve.buildMeshJunctions( dsolve )
plot1 = moose.Table2( '/model/plot1' )
plot2 = moose.Table2( '/model/plot2' )
moose.connect( '/model/plot1', 'requestOut', sub, 'getN' )
moose.connect( '/model/plot2', 'requestOut', prd, 'getN' )
plot3 = moose.Table2( '/model/plot3' )
plot4 = moose.Table2( '/model/plot4' )
moose.connect( '/model/plot3', 'requestOut', sub, 'getConc' )
moose.connect( '/model/plot4', 'requestOut', prd, 'getConc' )
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')
# Note that the chanPool must be on the 'In' compartment.
#chanPool = moose.Pool( '/model/compartment/chanPool' )
#chan = moose.ConcChan( '/model/compartment/chanPool/chan' )
chanPool = moose.Pool('/model/endo/chanPool')
chan = moose.ConcChan('/model/endo/chanPool/chan')
endo.isMembraneBound = True
endo.surround = compartment
es = moose.Pool('/model/endo/s')
#####################################################################
moose.connect(rXfer, 'sub', s, 'reac')
moose.connect(rXfer, 'prd', es, 'reac')
moose.connect(chanPool, 'nOut', chan, 'setNumChan')
moose.connect(chan, 'out', s, 'reac')
moose.connect(chan, 'in', es, 'reac')
volRatio = compartment.volume / endo.volume
rXfer.Kf = 0.0 # 0.02/sec
rXfer.Kb = 0.0 #
s.concInit = 0.001
chanPool.nInit = 1000.0
# Flux (mM/s) = permeability * N * (conc_out - conc_in )
chan.permeability = 0.1 * chanPool.volume * 6.022e23 / chanPool.nInit
#####################################################################
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)
estoich = moose.Stoich('/model/endo/stoich')
estoich.compartment = endo
estoich.ksolve = eksolve
estoich.dsolve = edsolve
estoich.path = "/model/endo/##"
assert (edsolve.numPools == 2)
edsolve.buildMeshJunctions(dsolve)
plot1 = moose.Table2('/model/plot1')
plot2 = moose.Table2('/model/plot2')
plot3 = moose.Table2('/model/plot3')
moose.connect('/model/plot1', 'requestOut', s, 'getN')
moose.connect('/model/plot2', 'requestOut', es, 'getN')
moose.connect('/model/plot3', 'requestOut',
'/model/compartment/s_xfer_endo', 'getN')
plot4 = moose.Table2('/model/plot4')
plot5 = moose.Table2('/model/plot5')
plot6 = moose.Table2('/model/plot6')
moose.connect('/model/plot4', 'requestOut', s, 'getConc')
moose.connect('/model/plot5', 'requestOut', es, 'getConc')
moose.connect('/model/plot6', 'requestOut',
'/model/compartment/s_xfer_endo', 'getConc')
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
u = moose.Pool( '/model/compartment/u' )
#####################################################################
# Put in endo compartment. Add molecule s
endo = moose.EndoMesh( '/model/endo' )
endo.isMembraneBound = True
endo.surround = compartment
rXfer = moose.Reac( '/model/endo/rXfer' )
et = moose.Pool( '/model/endo/t' )
es = moose.Pool( '/model/endo/s' )
#####################################################################
moose.connect( rXfer, 'sub', u, 'reac' )
moose.connect( rXfer, 'sub', et, 'reac' )
moose.connect( rXfer, 'prd', es, 'reac' )
u.concInit = 1.0
et.concInit = 1.0
#####################################################################
# [u0] = 1 in compt, [t0] = 1 in endo, [s0] = 0
# [u] + [s]/8 = [u0] ; [t] + [s] = [t0]; nu + ns = nu0, nt + ns = nt0
# At equil, numKf*nu*nt = numKb*ns
# Express all # in terms of ns.
# nu = nu0-ns; nt = nt0-ns Also, nu0 = 8*nt0
# So numKf*(nu0-ns)*(nt0-ns) = numKb*ns
# Target level is nt = ns = nt0/2
# So numKf*( 8nt0 - nt0/2)*nt0/2 = numKb*nt0/2
# So 7.5*nt0 = numKb/numKf
rXfer.numKb = 0.1
rXfer.numKf = 0.1/(7.5 * et.nInit)
#print( "Rates = {}, {}".format( rXfer.Kf, rXfer.Kb ))
#####################################################################
fixXreacs.fixXreacs( '/model' )
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
#####################################################################
# Make solvers
ksolve = moose.Ksolve( '/model/compartment/ksolve' )
dsolve = moose.Dsolve( '/model/compartment/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 == 1 )
estoich = moose.Stoich( '/model/endo/stoich' )
estoich.compartment = endo
estoich.ksolve = eksolve
estoich.dsolve = edsolve
estoich.path = "/model/endo/##"
assert( edsolve.numPools == 3 )
edsolve.buildMeshJunctions( dsolve )
plot1 = moose.Table2( '/model/plot1' )
plot2 = moose.Table2( '/model/plot2' )
plot3 = moose.Table2( '/model/plot3' )
moose.connect( '/model/plot1', 'requestOut', u, 'getN' )
moose.connect( '/model/plot2', 'requestOut', et, 'getN' )
moose.connect( '/model/plot3', 'requestOut', es, 'getN' )
plot4 = moose.Table2( '/model/plot4' )
plot5 = moose.Table2( '/model/plot5' )
plot6 = moose.Table2( '/model/plot6' )
moose.connect( '/model/plot4', 'requestOut', u, 'getConc' )
moose.connect( '/model/plot5', 'requestOut', et, 'getConc' )
moose.connect( '/model/plot6', 'requestOut', es, 'getConc' )
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
prd = moose.Pool('/model/compartment/prd')
rXfer = moose.Reac('/model/compartment/rXfer')
#####################################################################
# Put in endo compartment. Add molecule s
endo = moose.EndoMesh('/model/endo')
endo.isMembraneBound = True
endo.surround = compartment
sub = moose.Pool('/model/endo/sub')
enzPool = moose.Pool('/model/endo/enzPool')
enzPool.concInit = eInit
enz = moose.MMenz('/model/endo/enzPool/enz')
#####################################################################
moose.connect(enz, 'sub', sub, 'reac')
moose.connect(enz, 'prd', prd, 'reac')
moose.connect(enzPool, 'nOut', enz, 'enzDest')
moose.connect(rXfer, 'sub', prd, 'reac')
moose.connect(rXfer, 'prd', sub, 'reac')
rXfer.Kf = Kf # 0.04/sec
rXfer.Kb = 0.0 # 0.02/sec
enz.Km = Km
enz.kcat = kcat
# v = es.kcat/(s+Km)
# v = Kf * conc.
#####################################################################
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)
sub.vec.concInit = subInit
enzPool.vec.concInit = eInit
estoich = moose.Stoich('/model/endo/stoich')
estoich.compartment = endo
estoich.ksolve = eksolve
estoich.dsolve = edsolve
estoich.path = "/model/endo/##"
assert (edsolve.numPools == 3)
edsolve.buildMeshJunctions(dsolve)
plot1 = moose.Table2('/model/plot1')
plot2 = moose.Table2('/model/plot2')
moose.connect('/model/plot1', 'requestOut', sub, 'getN')
moose.connect('/model/plot2', 'requestOut', prd, 'getN')
plot3 = moose.Table2('/model/plot3')
plot4 = moose.Table2('/model/plot4')
moose.connect('/model/plot3', 'requestOut', sub, 'getConc')
moose.connect('/model/plot4', 'requestOut', prd, 'getConc')
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' )
# Note that the chanPool must be on the 'In' compartment.
#chanPool = moose.Pool( '/model/compartment/chanPool' )
#chan = moose.ConcChan( '/model/compartment/chanPool/chan' )
chanPool = moose.Pool( '/model/endo/chanPool' )
chan = moose.ConcChan( '/model/endo/chanPool/chan' )
endo.isMembraneBound = True
endo.surround = compartment
es = moose.Pool( '/model/endo/s' )
#####################################################################
moose.connect( rXfer, 'sub', s, 'reac' )
moose.connect( rXfer, 'prd', es, 'reac' )
moose.connect( chanPool, 'nOut', chan, 'setNumChan' )
moose.connect( chan, 'out', s, 'reac' )
moose.connect( chan, 'in', es, 'reac' )
volRatio = compartment.volume / endo.volume
rXfer.Kf = 0.0 # 0.02/sec
rXfer.Kb = 0.0 #
s.concInit = 0.001
chanPool.nInit = 1000.0
# Flux (#/s) = permeability * N * (#out/vol_out - #in/vol_in)
chan.permeability = 0.1 * chanPool.volume / chanPool.nInit
#####################################################################
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' )
eksolve.method = 'gsl'
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 )
estoich = moose.Stoich( '/model/endo/stoich' )
estoich.compartment = endo
estoich.ksolve = eksolve
estoich.dsolve = edsolve
estoich.path = "/model/endo/##"
assert( edsolve.numPools == 2 )
edsolve.buildMeshJunctions( dsolve )
plot1 = moose.Table2( '/model/plot1' )
plot2 = moose.Table2( '/model/plot2' )
plot3 = moose.Table2( '/model/plot3' )
moose.connect( '/model/plot1', 'requestOut', s, 'getN' )
moose.connect( '/model/plot2', 'requestOut', es, 'getN' )
moose.connect( '/model/plot3', 'requestOut', '/model/compartment/s_xfer_endo', 'getN' )
plot4 = moose.Table2( '/model/plot4' )
plot5 = moose.Table2( '/model/plot5' )
plot6 = moose.Table2( '/model/plot6' )
moose.connect( '/model/plot4', 'requestOut', s, 'getConc' )
moose.connect( '/model/plot5', 'requestOut', es, 'getConc' )
moose.connect( '/model/plot6', 'requestOut', '/model/compartment/s_xfer_endo', 'getConc' )
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
u = moose.Pool( '/model/compartment/u' )
#####################################################################
# Put in endo compartment. Add molecule s
endo = moose.EndoMesh( '/model/endo' )
endo.isMembraneBound = True
endo.surround = compartment
rXfer = moose.Reac( '/model/endo/rXfer' )
et = moose.Pool( '/model/endo/t' )
es = moose.Pool( '/model/endo/s' )
#####################################################################
moose.connect( rXfer, 'sub', u, 'reac' )
moose.connect( rXfer, 'sub', et, 'reac' )
moose.connect( rXfer, 'prd', es, 'reac' )
u.concInit = 1.0
et.concInit = 1.0
#####################################################################
# [u0] = 1 in compt, [t0] = 1 in endo, [s0] = 0
# [u] + [s]/8 = [u0] ; [t] + [s] = [t0]; nu + ns = nu0, nt + ns = nt0
# At equil, numKf*nu*nt = numKb*ns
# Express all # in terms of ns.
# nu = nu0-ns; nt = nt0-ns Also, nu0 = 8*nt0
# So numKf*(nu0-ns)*(nt0-ns) = numKb*ns
# Target level is nt = ns = nt0/2
# So numKf*( 8nt0 - nt0/2)*nt0/2 = numKb*nt0/2
# So 7.5*nt0 = numKb/numKf
rXfer.numKb = 0.1
rXfer.numKf = 0.1/(7.5 * et.nInit)
#print( "Rates = {}, {}".format( rXfer.Kf, rXfer.Kb ))
#####################################################################
fixXreacs.fixXreacs( '/model' )
#fixXreacs.restoreXreacs( '/model' )
#fixXreacs.fixXreacs( '/model' )
#####################################################################
# Make solvers
ksolve = moose.Ksolve( '/model/compartment/ksolve' )
dsolve = moose.Dsolve( '/model/compartment/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 == 1 )
estoich = moose.Stoich( '/model/endo/stoich' )
estoich.compartment = endo
estoich.ksolve = eksolve
estoich.dsolve = edsolve
estoich.path = "/model/endo/##"
assert( edsolve.numPools == 3 )
edsolve.buildMeshJunctions( dsolve )
plot1 = moose.Table2( '/model/plot1' )
plot2 = moose.Table2( '/model/plot2' )
plot3 = moose.Table2( '/model/plot3' )
moose.connect( '/model/plot1', 'requestOut', u, 'getN' )
moose.connect( '/model/plot2', 'requestOut', et, 'getN' )
moose.connect( '/model/plot3', 'requestOut', es, 'getN' )
plot4 = moose.Table2( '/model/plot4' )
plot5 = moose.Table2( '/model/plot5' )
plot6 = moose.Table2( '/model/plot6' )
moose.connect( '/model/plot4', 'requestOut', u, 'getConc' )
moose.connect( '/model/plot5', 'requestOut', et, 'getConc' )
moose.connect( '/model/plot6', 'requestOut', es, 'getConc' )
