def makeModel():
moose.Neutral('/library')
makeCellProto('cellProto')
makeChemProto()
#moose.SBML.readSBML('/home/vinu/Documents/Biophysics/new_mod/detailed_models/oct01_volScale/mv1.xml','/model')
rdes = rd.rdesigneur(
useGssa=False,
turnOffElec=True,
chemDt=0.01,
diffDt=0.01,
chemPlotDt=0.1,
combineSegments=False,
stealCellFromLibrary=True,
diffusionLength=50e-9,
cellProto=[['cellProto', 'elec']],
chemProto=[['hydra', 'chem']],
chemDistrib=[["chem", "#", "install", "1"]]
#plotList = [
#['psd/z', '1', '.', 'n', 'z n' ]
#['psd/z', '1', '.', 'n', 'z n' ]
#],
)
moose.seed(100)
rdes.buildModel('/model')
moose.element('/model/chem/dend/Rad').nInit = 30e-9
## moose.element('/model/chem/dend/stoich').allowNegative=1
print 'built model'
def main():
global params
fig = plt.figure(figsize=(6, 10), facecolor='white')
library = moose.Neutral('/library')
for ii in range(len(sys.argv)):
if sys.argv[ii][:2] == '--':
argName = sys.argv[ii][2:]
if argName in params:
params[argName] = float(sys.argv[ii + 1])
if argName == 'sequence':
params[argName] = sys.argv[ii + 1] # Leave it as a str.
moose.seed(int(params['seed']))
'''
'''
makePassiveSoma('cell', params['dendLength'], params['dendDiameter'])
moose.le('/library')
panelBCsingleCompt(fig)
moose.le('/library')
moose.delete('/library/soma')
params['dendLength'] = 60e-6
makePassiveSoma('cell', params['dendLength'], params['dendDiameter'])
panelEFspatialSeq(fig)
plt.tight_layout()
plt.show()
def makeModel():
moose.Neutral('/library')
makeCellProto('cellProto')
makeChemProto('cProto')
rdes = rd.rdesigneur(
useGssa=False,
turnOffElec=True,
chemDt=0.1,
diffDt=0.1,
combineSegments=False,
stealCellFromLibrary=True,
diffusionLength=1e-6,
cellProto=[['cellProto', 'elec']],
spineProto=[['makePassiveSpine()', 'spine']],
chemProto=[['cProto', 'chem']],
spineDistrib=[[
'spine', '#',
str(spineSpacing),
str(spineSpacingDistrib),
str(spineSize),
str(spineSizeDistrib),
str(spineAngle),
str(spineAngleDistrib)
]],
chemDistrib=[["chem", "#dend#,#psd#", "install", "1"]],
adaptorList=[
['psd/z', 'n', 'spine', 'psdArea', 50.0e-15, 500e-15],
])
moose.seed(1234)
rdes.buildModel('/model')
print('built model')
x = moose.vec('/model/chem/dend/x')
x.concInit = 0.0
for i in range(0, 20):
x[i].concInit = concInit
def test():
"""Test
"""
rdes = rd.rdesigneur(
elecDt=50e-6,
chemDt=0.002,
diffDt=0.002,
chemPlotDt=0.02,
useGssa=False,
# cellProto syntax: ['ballAndStick', 'name', somaDia, somaLength, dendDia, dendLength, numDendSegments ]
cellProto=[['ballAndStick', 'soma', 12e-6, 12e-6, 4e-6, 100e-6, 2]],
chemProto=[[
os.path.join(sdir_, '../py_rdesigneur/chem/chanPhosph3compt.g'),
'chem'
]],
spineProto=[['makeActiveSpine()', 'spine']],
chanProto=[['make_Na()', 'Na'], ['make_K_DR()', 'K_DR'],
['make_K_A()', 'K_A'], ['make_Ca()', 'Ca'],
['make_Ca_conc()', 'Ca_conc']],
passiveDistrib=[['soma', 'CM', '0.01', 'Em', '-0.06']],
spineDistrib=[['spine', '#dend#', '50e-6', '1e-6']],
chemDistrib=[['chem', '#', 'install', '1']],
chanDistrib=[['Na', 'soma', 'Gbar', '300'],
['K_DR', 'soma', 'Gbar', '250'],
['K_A', 'soma', 'Gbar', '200'],
['Ca_conc', 'soma', 'tau', '0.0333'],
['Ca', 'soma', 'Gbar', '40']],
adaptorList=[['psd/chan_p', 'n', 'glu', 'modulation', 0.1, 1.0],
['Ca_conc', 'Ca', 'spine/Ca', 'conc', 0.00008, 8]],
# Syn input basline 1 Hz, and 40Hz burst for 1 sec at t=20. Syn weight
# is 0.5, specified in 2nd argument as a special case stimLists.
stimList=[[
'head#', '0.5', 'glu', 'periodicsyn', '1 + 40*(t>10 && t<11)'
]],
plotList=[
['soma', '1', '.', 'Vm', 'Membrane potential'],
['#', '1', 'spine/Ca', 'conc', 'Ca in Spine'],
['#', '1', 'dend/DEND/Ca', 'conc', 'Ca in Dend'],
['#', '1', 'spine/Ca_CaM', 'conc', 'Ca_CaM'],
['head#', '1', 'psd/chan_p', 'conc', 'Phosph gluR'],
['head#', '1', 'psd/Ca_CaM_CaMKII', 'conc', 'Active CaMKII'],
])
moose.seed(123)
rdes.buildModel()
moose.reinit()
moose.start(25)
data = []
v = moose.wildcardFind('/##[TYPE=Table]')[0].vector
assert np.allclose(
(v.mean(), v.std()),
(-0.06777396715033643, 0.008550767915889)), (v.mean(), v.std())
for t in moose.wildcardFind('/##[TYPE=Table2]'):
data.append(t.vector)
m = np.mean(data, axis=1)
u = np.std(data, axis=1)
assert m.shape[0] == 67
assert np.allclose(m, A, atol=1e-5), m - A
assert np.allclose(u, B, atol=1e-5), u - B
def test_rand():
moose.seed(10)
f, t = create_func('random', 'rnd()')
moose.reinit()
moose.start(1000)
print(np.mean(t.vector), np.std(t.vector), 'xxx')
assert abs(np.mean(t.vector) - 0.5) < 0.01
assert np.std(t.vector) < 0.3
def test():
"""
Test CICR.
>>> test() # doctest: +NORMALIZE_WHITESPACE
Rdesigneur: Elec model has 5 compartments and 2 spines on 4 compartments.
Chem part of model has the following compartments:
| In dend, 40 voxels X 19 pools
| In spine, 2 voxels X 1 pools
| In psd, 2 voxels X 1 pools
| In dend_endo, 40 voxels X 2 pools
True
"""
rdes = rd.rdesigneur(
turnOffElec=False,
chemDt=0.002,
chemPlotDt=0.02,
diffusionLength=1e-6,
numWaveFrames=50,
useGssa=False,
addSomaChemCompt=False,
addEndoChemCompt=True,
# cellProto syntax: ['ballAndStick', 'name', somaDia, somaLength, dendDia, dendLength, numDendSeg]
cellProto=[['ballAndStick', 'soma', 10e-6, 10e-6, 2e-6, 40e-6, 4]],
spineProto=[['makeActiveSpine()', 'spine']],
chemProto=[[
os.path.join(sdir_, '../py_rdesigneur/chem/CICRspineDend.g'),
'chem'
]],
spineDistrib=[['spine', '#dend#', '10e-6', '0.1e-6']],
chemDistrib=[['chem', 'dend#,spine#,head#', 'install', '1']],
adaptorList=[['Ca_conc', 'Ca', 'spine/Ca', 'conc', 0.00008, 8]],
stimList=[
['head0', '0.5', 'glu', 'periodicsyn', '1 + 40*(t>5 && t<6)'],
['head0', '0.5', 'NMDA', 'periodicsyn', '1 + 40*(t>5 && t<6)'],
['dend#', 'g>10e-6 && g<=31e-6', 'dend/IP3', 'conc', '0.0006'],
],
plotList=[
['head#', '1', 'spine/Ca', 'conc', 'Spine Ca conc'],
['dend#', '1', 'dend/Ca', 'conc', 'Dend Ca conc'],
['dend#', '1', 'dend/Ca', 'conc', 'Dend Ca conc', 'wave'],
['dend#', '1', 'dend_endo/CaER', 'conc', 'ER Ca conc', 'wave'],
['soma', '1', '.', 'Vm', 'Memb potl'],
],
)
moose.seed(1234)
rdes.buildModel()
moose.reinit()
moose.start(2)
data = []
for t in moose.wildcardFind('/##[TYPE=Table2]'):
data.append(t.vector[::20])
res = np.mean(data, axis=1)
assert np.allclose(res, expected, rtol=1e-4, atol=1e-4), \
"Total error %s" % np.sum(res - expected)
return True
def test_rand( ):
moose.seed( 10 )
f, t = create_func( 'random', 'rnd()')
moose.reinit()
moose.start(1)
expected = [0.49458993, 0.44301495, 0.58332174, 0.70920801, 0.26360285,
0.68381843, 0.33607158, 0.19812181, 0.87761494, 0.54088093,
0.41366738]
assert np.isclose(t.vector, expected ).all(), t.vector
print( 'Passed test random' )
def init():
global _inited
if _inited:
return
_inited = True
if reseed:
if moose_rngseed:
moose.seed(int(moose_rngseed))
else:
moose.seed(0)
if numpy_rngseed:
numpy.random.seed(int(numpy_rngseed))
def test_rand():
moose.seed(10)
f, t = create_func('random', 'rnd()')
moose.reinit()
moose.start(1)
expected = [
0.29876116, 0.49458993, 0.83191136, 0.02517173, 0.26556613, 0.15037787,
0.81660184, 0.89081653, 0.03061665, 0.72743551, 0.13145815
]
assert np.isclose(
t.vector, expected).all(), "Expected %s, got %s" % (expected, t.vector)
print('Passed test random')
def init():
global _inited
if _inited:
return
_inited = True
if reseed:
if moose_rngseed:
moose.seed(int(moose_rngseed))
else:
moose.seed(0)
if numpy_rngseed:
numpy.random.seed(int(numpy_rngseed))
def load():
rdes = rd.rdesigneur(
elecDt = 50e-6,
chemDt = 0.002,
diffDt = 0.002,
chemPlotDt = 0.02,
turnOffElec = True, #FindSim needs to create Vclamp and then solver.
useGssa = False,
# cellProto syntax: ['ballAndStick', 'name', somaDia, somaLength, dendDia, dendLength, numDendSegments ]
cellProto = [['ballAndStick', 'soma', 12e-6, 12e-6, 4e-6, 100e-6, 1 ]],
chemProto = [['models/CaMKII_MAPK_7.g', 'chem']],
spineProto = [['makeActiveSpine()', 'spine']],
chanProto = [
['make_Na()', 'Na'],
['make_K_DR()', 'K_DR'],
['make_K_A()', 'K_A' ],
['make_glu()', 'glu' ],
['make_Ca()', 'Ca' ],
['make_Ca_conc()', 'Ca_conc' ]
],
passiveDistrib = [['soma', 'CM', '0.01', 'Em', '-0.06']],
spineDistrib = [['spine', '#dend#', '100e-6', '1e-6']],
chemDistrib = [['chem', '#', 'install', '1' ]],
chanDistrib = [
['Na', 'soma', 'Gbar', '300' ],
['K_DR', 'soma', 'Gbar', '250' ],
['K_A', 'soma', 'Gbar', '200' ],
['glu', 'dend#', 'Gbar', '20' ],
['Ca_conc', 'soma', 'tau', '0.0333' ],
['Ca', 'soma', 'Gbar', '40' ]
],
adaptorList = [
[ 'psd/tot_phospho_R', 'n', 'glu', 'modulation', 1.0, 0.3 ],
[ 'Ca_conc', 'Ca', 'psd/Ca', 'conc', 0.00008, 3 ]
],
# Syn wt is 0.2, specified in 2nd argument
stimList = [['head#', '0.2','glu', 'periodicsyn', '0']],
)
moose.seed(1234567)
rdes.buildModel()
#moose.element( '/model/chem/dend/ksolve' ).numThreads = 4
#moose.showfield( '/model/chem/dend/ksolve' )
#moose.element( '/model/chem/dend/ksolve' ).method = "rk4"
moose.delete( '/model/stims/stim0')
inputElm = moose.element( '/model/elec/head0/glu/sh/synapse/synInput_rs' )
inputElm.name = 'synInput'
moose.connect( inputElm, 'spikeOut', '/model/elec/head0/glu/sh/synapse', 'addSpike' )
#moose.showmsg( '/model/elec/head0/glu/sh/synapse/synInput_rs' )
#import presettle_CaMKII_MAPK7_init
moose.reinit()
return rdes.model
def equal():
rand1, rand2 = [], []
N = 10
moose.seed( 10 )
for i in range( N ):
x = moose.rand()
rand1.append( x )
reload( moose )
moose.seed( 10 )
for i in range( N ):
x = moose.rand()
rand2.append( x )
assert np.equal( rand1, rand2 ).all()
def test_equal():
rand1, rand2 = [], []
N = 10
moose.seed(10)
for i in range(N):
x = moose.rand()
rand1.append(x)
reload(moose)
moose.seed(10)
for i in range(N):
x = moose.rand()
rand2.append(x)
assert np.equal(rand1, rand2).all()
def main():
compartment = makeModel()
ksolve = moose.Ksolve( '/model/compartment/ksolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState( '/model/compartment/state' )
moose.reinit()
state.stoich = stoich
state.convergenceCriterion = 1e-6
moose.seed( 111 ) # Used when generating the samples in state space
moose.reinit()
moose.start(10)
plot( 10)
def main():
compartment = makeModel()
ksolve = moose.Ksolve('/model/compartment/ksolve')
stoich = moose.Stoich('/model/compartment/stoich')
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState('/model/compartment/state')
moose.reinit()
state.stoich = stoich
state.convergenceCriterion = 1e-6
moose.seed(111) # Used when generating the samples in state space
moose.reinit()
moose.start(10)
plot(10)
def main():
makeModel()
moose.seed( 11111 )
gsolve = moose.Gsolve( '/model/compartment/gsolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
#gsolve.numAllVoxels = 1
compt = moose.element( '/model/compartment' );
stoich.compartment = compt
stoich.ksolve = gsolve
stoich.path = "/model/compartment/##"
#solver.method = "rk5"
#mesh = moose.element( "/model/compartment/mesh" )
#moose.connect( mesh, "remesh", solver, "remesh" )
moose.setClock( 5, 1.0 ) # clock for the solver
moose.useClock( 5, '/model/compartment/gsolve', 'process' )
a = moose.element( '/model/compartment/a' )
for vol in ( 1e-19, 1e-20, 1e-21, 3e-22, 1e-22, 3e-23, 1e-23 ):
# Set the volume
#print 'vol = ', vol, ', a.concInit = ', a.concInit, ', a.nInit = ', a.nInit
compt.volume = vol
print 'vol = ', vol, ', a.concInit = ', a.concInit, ', a.nInit = ', a.nInit
moose.reinit()
moose.start( 100.0 ) # Run the model for 100 seconds.
a = moose.element( '/model/compartment/a' )
b = moose.element( '/model/compartment/b' )
# move most molecules over to b
b.conc = b.conc + a.conc * 0.9
a.conc = a.conc * 0.1
moose.start( 100.0 ) # Run the model for 100 seconds.
# move most molecules back to a
a.conc = a.conc + b.conc * 0.99
b.conc = b.conc * 0.01
moose.start( 100.0 ) # Run the model for 100 seconds.
# Iterate through all plots, dump their contents to data.plot.
displayPlots()
#pylab.legend()
pylab.show( block=False )
print 'vol = ', vol, 'hit enter to go to next plot'
raw_input()
quit()
def panelEFspatialSeq(fig):
print "Starting Panel EF"
moose.seed(int(params['seed']))
diffusionLength = params['diffusionLength']
#makeChemProto( 'spread', stimAmpl = 1,diffLength = diffusionLength )
fhn = ame.makeFHN([])
rdes = rd.rdesigneur(
useGssa=False,
turnOffElec=True,
chemPlotDt=0.02,
# spineProto = [['makePassiveSpine()', 'spine']],
# spineDistrib = [['spine', '#', str(params['spineSpacing']),'1e-7','1.4','0']],
cellProto=[['./taper.p', 'elec']],
chemProto=[['fhn', 'chem']],
chemDistrib=[['chem', '#', 'install', '1']],
plotList=[['#', '1', 'dend/A', 'n', '# of A'],
['#', '1', 'dend/B', 'n', '# of B'],
['#', '1', 'dend/phase', 'n', '# of Phase'],
['#', '1', 'dend/Ca', 'n', '# of Ca']],
moogList=[['#', 'x>5e-6 && x<100e-6', '.', 'Vm', 'Vm']]
#plotList = [
# ['#', '1', 'dend/P_MAPK', 'conc', '[dend P_MAPK]'],
# ['#head#', '1', 'psd/Ca', 'conc', '[PSD Ca]'],
# ['#head#', '1', 'spine/Ca', 'conc', '[spine Ca]'],
#['soma', '1', 'dend/DEND/Ca', 'conc', '[dend Ca]'],
#],
)
# Assign parameters to the prototype model.
#setDiffConst( 'Ca', 'diffConstCa' )
#setDiffConst( '../../spine/Ca', 'diffConstCa' )
#setDiffConst( '../../psd/Ca', 'diffConstCa' )
#setDiffConst( 'P_MAPK', 'diffConstMAPK' )
#setDiffConst( 'MAPK', 'diffConstMAPK' )
#setDiffConst( 'reg_phosphatase', 'diffConstPP' )
#setDiffConst( 'inact_phosphatase', 'diffConstPP' )
#moose.element( '/library/chem/dend/DEND/Ca_activate_Raf' ).Kf = params['CaActivateRafKf']
print "Set up rdesigneur"
rdes.buildModel()
print "MODEL BUILT"
################################################################
# Run and display the stimulus
runAndDisplay('01234', 'E', 1, rdes.chemPlotDt, 1.5)
runAndDisplay('40312', 'F', 2, rdes.chemPlotDt, 1.5)
def main():
global params
fig = plt.figure(figsize=(10, 6), facecolor='white')
library = moose.Neutral('/library')
for ii in range(len(sys.argv)):
if sys.argv[ii][:2] == '--':
argName = sys.argv[ii][2:]
if argName in params:
params[argName] = float(sys.argv[ii + 1])
if argName == 'sequence':
params[argName] = sys.argv[ii + 1] # Leave it as a str.
moose.seed(int(params['seed']))
panelEFspatialSeq(fig)
plt.tight_layout()
plt.show()
def panelEFspatialSeq(fig):
print "Starting Panel EF"
moose.seed(int(params['seed']))
rdes = rd.rdesigneur(
useGssa=False,
turnOffElec=True,
chemPlotDt=0.02,
diffusionLength=params['diffusionLength'],
spineProto=[['makePassiveSpine()', 'spine']],
spineDistrib=[[
'spine', '#',
str(params['spineSpacing']), '1e-7', '1.4', '0'
]],
cellProto=[['cell', 'soma']],
chemProto=[[params['chemModel'], 'chem']],
chemDistrib=[['chem', 'soma', 'install', '1']],
plotList=[
['soma', '1', 'dend/DEND/P_MAPK', 'conc', '[dend P_MAPK]'],
['#head#', '1', 'psd/Ca', 'conc', '[PSD Ca]'],
['#head#', '1', 'spine/Ca', 'conc', '[spine Ca]'],
['soma', '1', 'dend/DEND/Ca', 'conc', '[dend Ca]'],
],
)
# Assign parameters to the prototype model.
setDiffConst('Ca', 'diffConstCa')
setDiffConst('../../compartment_1/Ca', 'diffConstCa')
setDiffConst('../../compartment_2/Ca', 'diffConstCa')
setDiffConst('P_MAPK', 'diffConstMAPK')
setDiffConst('MAPK', 'diffConstMAPK')
setDiffConst('reg_phosphatase', 'diffConstPP')
setDiffConst('inact_phosphatase', 'diffConstPP')
moose.element('/library/chem/kinetics/DEND/Ca_activate_Raf'
).Kf = params['CaActivateRafKf']
print "Set up rdesigneur"
rdes.buildModel()
print "MODEL BUILT"
################################################################
# Run and display the stimulus
runAndDisplay('01234', 'E', (4, 0), rdes.chemPlotDt, 0.6)
runAndDisplay('40312', 'F', (4, 1), rdes.chemPlotDt, 0.6)
moose.delete('/model')
def main():
"""
This example describes the special (and discouraged) use case where
functions provide input to a reaction system. Here we have two functions of
time which control the pool # and pool rate of change, respectively::
number of molecules of a = 1 + sin(t)
rate of change of number of molecules of b = 10 * cos(t)
In the stochastic case one must set a special flag *useClockedUpdate*
in order to achieve clock-triggered updates from the functions. This is
needed because the functions do not have reaction events to trigger them,
and even if there were reaction events they might not be frequent enough to
track the periodic updates. The use of this flag slows down the calculations,
so try to use a table to control a pool instead.
To run in stochastic mode::
''python funcInputToPools''
To run in deterministic mode::
''python funcInputToPools false''
"""
makeModel()
moose.seed()
moose.reinit()
moose.start( 50.0 ) # Run the model for 50 seconds.
a = moose.element( '/model/compartment/a' )
b = moose.element( '/model/compartment/b' )
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind( '/model/graphs/n#' ):
#x.xplot( 'scriptKineticModel.plot', x.name )
t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
quit()
def main():
"""
This example describes the special (and discouraged) use case where
functions provide input to a reaction system. Here we have two functions of
time which control the pool # and pool rate of change, respectively::
number of molecules of a = 1 + sin(t)
rate of change of number of molecules of b = 10 * cos(t)
In the stochastic case one must set a special flag *useClockedUpdate*
in order to achieve clock-triggered updates from the functions. This is
needed because the functions do not have reaction events to trigger them,
and even if there were reaction events they might not be frequent enough to
track the periodic updates. The use of this flag slows down the calculations,
so try to use a table to control a pool instead.
To run in stochastic mode::
>>> python funcInputToPools.py
To run in deterministic mode::
>>> python funcInputToPools.py false
"""
makeModel()
moose.seed()
moose.reinit()
moose.start(50.0) # Run the model for 100 seconds.
a = moose.element('/model/compartment/a')
b = moose.element('/model/compartment/b')
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind('/model/graphs/n#'):
#x.xplot( 'scriptKineticModel.plot', x.name )
t = numpy.arange(0, x.vector.size, 1) * x.dt # sec
pylab.plot(t, x.vector, label=x.name)
pylab.legend()
pylab.show()
quit()
def main():
makeModel()
moose.seed()
moose.reinit()
moose.start( 50.0 ) # Run the model for 100 seconds.
a = moose.element( '/model/compartment/a' )
b = moose.element( '/model/compartment/b' )
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind( '/model/graphs/n#' ):
#x.xplot( 'scriptKineticModel.plot', x.name )
t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec
pylab.plot( t, x.vector, label=x.name )
pylab.legend()
pylab.show()
quit()
def paneDlayout():
print "Starting Panel D"
moose.reinit()
moose.seed(int(params['seed']))
print "MODEL PREBUILT"
rdes = rd.rdesigneur(useGssa=False,
turnOffElec=True,
chemPlotDt=0.02,
diffusionLength=params['diffusionLength'],
spineProto=[['makePassiveSpine()', 'spine']],
spineDistrib=[[
'spine', '#',
str(params['spineSpacing']), '1e-7', '1.4', '0'
]],
cellProto=[['cell', 'soma']],
chemProto=[[params['chemModel'], 'chem']],
chemDistrib=[['chem', 'soma', 'install', '1']],
moogList=[
['#', '1', '.', 'Vm', 'Vm', -0.1, 0.05],
])
rdes.buildModel()
print "MODEL BUILT"
sequence = [int(i) for i in params['sequence']]
blanks = params['blankVoxelsAtEnd']
step = int(round(params['seqDx'] / params['spineSpacing']))
for i in moose.wildcardFind('/model/elec/head#,/model/elec/shaft#'):
i.initVm = 0.0
for i in sequence:
e = moose.element('/model/elec/head' + str(blanks + i * step))
e.initVm = 0.1
e = moose.element('/model/elec/shaft' + str(blanks + i * step))
e.initVm = 0.1
################################################################
# Run and display the stimulus
moose.reinit()
rdes.displayMoogli(0.0001, 0.001, 0.0)
def main():
compartment = makeModel()
ksolve = moose.Ksolve('/model/compartment/ksolve')
stoich = moose.Stoich('/model/compartment/stoich')
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState('/model/compartment/state')
moose.reinit()
state.stoich = stoich
state.showMatrices()
state.convergenceCriterion = 1e-6
moose.seed(111) # Used when generating the samples in state space
for i in range(0, 50):
getState(ksolve, state)
# Now display the states of the system at more length to compare.
moose.start(100.0) # Run the model for 100 seconds.
a = moose.element('/model/compartment/a')
b = moose.element('/model/compartment/b')
# move most molecules over to b
b.conc = b.conc + a.conc * 0.9
a.conc = a.conc * 0.1
moose.start(100.0) # Run the model for 100 seconds.
# move most molecules back to a
a.conc = a.conc + b.conc * 0.99
b.conc = b.conc * 0.01
moose.start(400.0) # Run the model for 200 seconds.
# Iterate through all plots, dump their contents to data.plot.
displayPlots()
quit()
def makeModel():
moose.Neutral('/library')
makeCellProto('cellProto')
makeChemProto()
rdes = rd.rdesigneur(
useGssa=False,
turnOffElec=False,
chemDt=0.0025,
diffDt=0.0025,
chemPlotDt=0.1,
combineSegments=False,
stealCellFromLibrary=True,
diffusionLength=50e-9,
cellProto=[['cellProto', 'elec']],
chanProto=[
['make_NMDA()', 'NMDA'],
['make_Ca_conc()', 'Ca_conc'],
],
chemProto=[['hydra', 'chem']],
chemDistrib=[["chem", "#", "install", "1"]],
chanDistrib=[
['NMDA', 'dend#', 'Gbar', '1'],
['Ca_conc', 'dend#', 'tau', '0.033'],
],
stimList=[
[
'dend#', '1.', 'NMDA', 'periodicsyn',
str(args_[13]) + '*(t>0 && t<60)+' + str(args_[13]) + '*(t>' +
str(args_[15]) + ' && t<(' + str(args_[15]) + '+60))'
],
],
adaptorList=[['Ca_conc', 'Ca', 'dend/conv', 'conc', 0.00008, 20]],
benchmark=True)
moose.seed(100)
print("[INFO ] rdes is building model ...")
rdes.buildModel('/model')
print("[INFO ] Model is built...")
moose.element('/model/chem/dend/IRSpGr/Rad').nInit = 30e-9
def dummy():
print "Starting Dummy"
makePassiveSoma('cell', 0.5e-6, params['dendDiameter'])
moose.reinit()
moose.seed(int(params['seed']))
rdes = rd.rdesigneur(
useGssa=False,
turnOffElec=True,
chemPlotDt=0.02,
diffusionLength=params['diffusionLength'],
spineProto=[['makePassiveSpine()', 'spine']],
spineDistrib=[['spine', '#', '0.4e-6', '1e-7', '1.4', '0']],
cellProto=[['cell', 'soma']],
chemProto=[[params['chemModel'], 'chem']],
chemDistrib=[['chem', 'soma', 'install', '1']],
#moogList = [ ['soma', '1', '.', 'Vm', 'Vm', -0.1, 0.05], ]
)
rdes.buildModel()
moose.le('/library')
moose.delete('/library/soma')
moose.delete('/library/chem')
moose.le('/')
moose.delete('/model')
print "Finsihed dummy "
def main():
"""
Simulate pre and post Poisson firing for a synapse with
Ca plasticity of Graupner and Brunel 2012.
See the trace over time (lifetime) for the synaptic efficacy,
similar to figure 2A of Higgins, Graupner, Brunel, 2014.
Author: Aditya Gilra, NCBS, Bangalore, October, 2014.
"""
numrepeats = 10 # repeat runtime for numrepeats
frate = 1.0 # pre- and post-synaptic firing rate
# 1 Hz gives ~300s lifetime, ~0.2 efficacy (weight)
# 10 Hz gives ~10s lifetime, ~0.5 efficacy (weight)
# high firing rates make synaptic efficacy go to 0.5.
runtime = 600.0 / frate # s
#############################################
# Ca Plasticity parameters: synapses (not for ExcInhNetBase)
#############################################
## Cortical slice values -- Table Suppl 2 in Graupner & Brunel 2012
## Also used in Higgins et al 2014
tauCa = 22.6936e-3 # s # Ca decay time scale
tauSyn = 346.3615 # s # synaptic plasticity time scale
## in vitro values in Higgins et al 2014, faster plasticity
CaPre = 0.56175 # mM
CaPost = 1.2964 # mM
## in vivo values in Higgins et al 2014, slower plasticity
#CaPre = 0.33705 # mM
#CaPost = 0.74378 # mM
delayD = 4.6098e-3 # s # CaPre is added to Ca after this delay
# proxy for rise-time of NMDA
thetaD = 1.0 # mM # depression threshold for Ca
thetaP = 1.3 # mM # potentiation threshold for Ca
gammaD = 331.909 # factor for depression term
gammaP = 725.085 # factor for potentiation term
J = 5e-3 # V # delta function synapse, adds to Vm
weight = 0.43 # initial synaptic weight
# gammaP/(gammaP+gammaD) = eq weight w/o noise
# see eqn (22), noiseSD also appears
# but doesn't work here,
# weights away from 0.4 - 0.5 screw up the STDP rule!!
bistable = True # if bistable is True, use bistable potential for weights
noisy = True # use noisy weight updates given by noiseSD
noiseSD = 3.3501 # if noisy, use noiseSD (3.3501 from Higgins et al 2014)
##########################################
prePoisson = moose.RandSpike('/pre')
prePoisson.rate = frate
postPoisson = moose.RandSpike('/post')
postPoisson.rate = frate
syn = moose.GraupnerBrunel2012CaPlasticitySynHandler('/syn')
syn.numSynapses = 1 # 1 synapse
# many pre-synaptic inputs can connect to a synapse
# spikes from presynaptic Poisson generator
moose.connect(prePoisson, 'spikeOut', syn.synapse[0], 'addSpike')
# post-synaptic spikes from postsynaptic Poisson generator
moose.connect(postPoisson, 'spikeOut', syn, 'addPostSpike')
syn.synapse[0].delay = 0.0
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.CaInit = 0.0
syn.tauCa = tauCa
syn.tauSyn = tauSyn
syn.CaPre = CaPre
syn.CaPost = CaPost
syn.delayD = delayD
syn.thetaD = thetaD
syn.thetaP = thetaP
syn.gammaD = gammaD
syn.gammaP = gammaP
syn.weightMax = 1.0 # bounds on the weight
syn.weightMin = 0.
syn.noisy = noisy
syn.noiseSD = noiseSD
syn.bistable = bistable
# ###########################################
# Setting up tables
# ###########################################
CaTable = moose.Table('/plotCa', 1)
moose.connect(CaTable, 'requestOut', syn, 'getCa')
WtTable = moose.Table('/plotWeight', 1)
moose.connect(WtTable, 'requestOut', syn.synapse[0], 'getWeight')
# ###########################################
# Simulate
# ###########################################
dt = 1e-3 # s
# moose simulation
#moose.useClock( 0, '/syn', 'process' )
#moose.useClock( 1, '/pre', 'process' )
#moose.useClock( 1, '/post', 'process' )
# I think MOOSE uses a different clock than 3 for Tables
# anyway, we use the default one and set all clocks to dt below
#moose.useClock( 3, '/plotCa', 'process' )
#moose.useClock( 3, '/plotWeight', 'process' )
## use setClock to set the dt different from default dt
for i in range(10):
moose.setClock(i, dt)
moose.seed(100)
moose.reinit()
# function to make the aPlus and aMinus settle to equilibrium values
print(("Rates of pre- and post-syanptic neurons =", frate))
WtSeries = []
numsteps = int(runtime / dt)
for i in range(numrepeats):
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.Ca = 0.0
print(("Repeat number", i, "running..."))
moose.start(runtime)
WtSeries.append(WtTable.vector[i * numsteps:(i + 1) * numsteps])
WtSeries = array(WtSeries)
WtMean = mean(WtSeries, axis=0)
print("plotting...")
# ###########################################
# Plot the simulated weights and Ca vs time
# ###########################################
timeseries = linspace(0.0, runtime, numsteps)
# Ca plots for the synapse
# only the first repeat
figure(facecolor='w')
plot(timeseries, CaTable.vector[:numsteps], color='r')
plot((timeseries[0],timeseries[-1]),(thetaP,thetaP),color='k',\
linestyle='dashed',label='pot thresh')
plot((timeseries[0],timeseries[-1]),(thetaD,thetaD),color='b',\
linestyle='dashed',label='dep thresh')
legend()
xlabel('time (s)')
ylabel('Ca (arb)')
title("Ca conc in the synapse @ " + str(frate) + " Hz firing")
# Weight plots for the synapse
figure(facecolor='w')
for i in range(numrepeats):
plot(timeseries, WtSeries[i], alpha=0.5)
plot(timeseries, WtMean, color='k', linewidth=2)
xlabel('time (s)')
ylabel('Efficacy')
title("Efficacy of the synapse @ " + str(frate) + " Hz firing")
show()
Graupner, Michael, and Nicolas Brunel. 2012.
Calcium-Based Plasticity Model Explains Sensitivity of Synaptic Changes to Spike Pattern, Rate, and Dendritic Location.
Proceedings of the National Academy of Sciences, February, 201109359.
The Ca-based bistable synapse has been implemented as the GraupnerBrunel2012CaPlasticitySynHandler class.
"""
## import modules and functions to be used
import numpy as np
import matplotlib.pyplot as plt
import random
import time
import moose
np.random.seed(100) # set seed for reproducibility of simulations
random.seed(100) # set seed for reproducibility of simulations
moose.seed(100) # set seed for reproducibility of simulations
#############################################
# All parameters as per:
# David Higgins, Michael Graupner, Nicolas Brunel
# Memory Maintenance in Synapses with Calcium-Based
# Plasticity in the Presence of Background Activity
# PLOS Computational Biology, 2014.
#############################################
#############################################
# Neuron model
#############################################
# equation: dv/dt = (1/taum)*(-(v-el)) + inp
# with spike when v>vt, reset to vr
import random import time import moose from PyQt4 import Qt, QtCore, QtGui from numpy import random as nprand from moose.neuroml.NeuroML import NeuroML import sys import rdesigneur as rd import moogli cellname = "./cells_channels/CA1_nochans.morph.xml" fname = "fig6bcde" ############################################# np.random.seed(100) # set seed for reproducibility of simulations random.seed(100) # set seed for reproducibility of simulations moose.seed(100) # set seed for reproducibility of simulations ############################################# # All parameters as per: # David Higgins, Michael Graupner, Nicolas Brunel # Memory Maintenance in Synapses with Calcium-Based # Plasticity in the Presence of Background Activity # PLOS Computational Biology, 2014. ############################################# ############################################# # Neuron model ############################################# # equation: dv/dt = (1/taum)*(-(v-el)) + inp # with spike when v>vt, reset to vr
chemDistrib = [['chem', '#', 'install', '1' ]],
chanDistrib = [
['Na', 'soma', 'Gbar', '300' ],
['K_DR', 'soma', 'Gbar', '250' ],
['K_A', 'soma', 'Gbar', '200' ],
['Ca_conc', 'soma', 'tau', '0.0333' ],
['Ca', 'soma', 'Gbar', '40' ]
],
adaptorList = [
[ 'psd/chan_p', 'n', 'glu', 'modulation', 0.1, 1.0 ],
[ 'Ca_conc', 'Ca', 'spine/Ca', 'conc', 0.00008, 8 ]
],
# Syn input basline 1 Hz, and 40Hz burst for 1 sec at t=20. Syn weight
# is 0.5, specified in 2nd argument as a special case stimLists.
stimList = [['head#', '0.5','glu', 'periodicsyn', '1 + 40*(t>10 && t<11)']],
plotList = [
['soma', '1', '.', 'Vm', 'Membrane potential'],
['#', '1', 'spine/Ca', 'conc', 'Ca in Spine'],
['#', '1', 'dend/DEND/Ca', 'conc', 'Ca in Dend'],
['#', '1', 'spine/Ca_CaM', 'conc', 'Ca_CaM'],
['head#', '1', 'psd/chan_p', 'conc', 'Phosph gluR'],
['head#', '1', 'psd/Ca_CaM_CaMKII', 'conc', 'Active CaMKII'],
]
)
moose.seed(123)
rdes.buildModel()
moose.reinit()
moose.start( 25 )
rdes.display()
def main():
"""
Simulate pre and post Poisson firing for a synapse with
Ca plasticity of Graupner and Brunel 2012.
See the trace over time (lifetime) for the synaptic efficacy,
similar to figure 2A of Higgins, Graupner, Brunel, 2014.
Author: Aditya Gilra, NCBS, Bangalore, October, 2014.
"""
numrepeats = 10 # repeat runtime for numrepeats
frate = 1.0 # pre- and post-synaptic firing rate
# 1 Hz gives ~300s lifetime, ~0.2 efficacy (weight)
# 10 Hz gives ~10s lifetime, ~0.5 efficacy (weight)
# high firing rates make synaptic efficacy go to 0.5.
runtime = 600.0/frate # s
#############################################
# Ca Plasticity parameters: synapses (not for ExcInhNetBase)
#############################################
## Cortical slice values -- Table Suppl 2 in Graupner & Brunel 2012
## Also used in Higgins et al 2014
tauCa = 22.6936e-3 # s # Ca decay time scale
tauSyn = 346.3615 # s # synaptic plasticity time scale
## in vitro values in Higgins et al 2014, faster plasticity
CaPre = 0.56175 # mM
CaPost = 1.2964 # mM
## in vivo values in Higgins et al 2014, slower plasticity
#CaPre = 0.33705 # mM
#CaPost = 0.74378 # mM
delayD = 4.6098e-3 # s # CaPre is added to Ca after this delay
# proxy for rise-time of NMDA
thetaD = 1.0 # mM # depression threshold for Ca
thetaP = 1.3 # mM # potentiation threshold for Ca
gammaD = 331.909 # factor for depression term
gammaP = 725.085 # factor for potentiation term
J = 5e-3 # V # delta function synapse, adds to Vm
weight = 0.43 # initial synaptic weight
# gammaP/(gammaP+gammaD) = eq weight w/o noise
# see eqn (22), noiseSD also appears
# but doesn't work here,
# weights away from 0.4 - 0.5 screw up the STDP rule!!
bistable = True # if bistable is True, use bistable potential for weights
noisy = True # use noisy weight updates given by noiseSD
noiseSD = 3.3501 # if noisy, use noiseSD (3.3501 from Higgins et al 2014)
##########################################
prePoisson = moose.RandSpike('/pre')
prePoisson.rate = frate
postPoisson = moose.RandSpike('/post')
postPoisson.rate = frate
syn = moose.GraupnerBrunel2012CaPlasticitySynHandler( '/syn' )
syn.numSynapses = 1 # 1 synapse
# many pre-synaptic inputs can connect to a synapse
# spikes from presynaptic Poisson generator
moose.connect( prePoisson,'spikeOut', syn.synapse[0], 'addSpike')
# post-synaptic spikes from postsynaptic Poisson generator
moose.connect( postPoisson, 'spikeOut', syn, 'addPostSpike')
syn.synapse[0].delay = 0.0
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.CaInit = 0.0
syn.tauCa = tauCa
syn.tauSyn = tauSyn
syn.CaPre = CaPre
syn.CaPost = CaPost
syn.delayD = delayD
syn.thetaD = thetaD
syn.thetaP = thetaP
syn.gammaD = gammaD
syn.gammaP = gammaP
syn.weightMax = 1.0 # bounds on the weight
syn.weightMin = 0.
syn.noisy = noisy
syn.noiseSD = noiseSD
syn.bistable = bistable
# ###########################################
# Setting up tables
# ###########################################
CaTable = moose.Table( '/plotCa', 1 )
moose.connect( CaTable, 'requestOut', syn, 'getCa')
WtTable = moose.Table( '/plotWeight', 1 )
moose.connect( WtTable, 'requestOut', syn.synapse[0], 'getWeight')
# ###########################################
# Simulate
# ###########################################
dt = 1e-3 # s
# moose simulation
#moose.useClock( 0, '/syn', 'process' )
#moose.useClock( 1, '/pre', 'process' )
#moose.useClock( 1, '/post', 'process' )
# I think MOOSE uses a different clock than 3 for Tables
# anyway, we use the default one and set all clocks to dt below
#moose.useClock( 3, '/plotCa', 'process' )
#moose.useClock( 3, '/plotWeight', 'process' )
## use setClock to set the dt different from default dt
for i in range(10):
moose.setClock( i, dt )
moose.seed(100)
moose.reinit()
# function to make the aPlus and aMinus settle to equilibrium values
print(("Rates of pre- and post-syanptic neurons =",frate))
WtSeries = []
numsteps = int(runtime/dt)
for i in range(numrepeats):
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.Ca = 0.0
print(("Repeat number",i,"running..."))
moose.start(runtime)
WtSeries.append(WtTable.vector[i*numsteps:(i+1)*numsteps])
WtSeries = array(WtSeries)
WtMean = mean(WtSeries,axis=0)
print("plotting...")
# ###########################################
# Plot the simulated weights and Ca vs time
# ###########################################
timeseries = linspace(0.0,runtime,numsteps)
# Ca plots for the synapse
# only the first repeat
figure(facecolor='w')
plot(timeseries,CaTable.vector[:numsteps],color='r')
plot((timeseries[0],timeseries[-1]),(thetaP,thetaP),color='k',\
linestyle='dashed',label='pot thresh')
plot((timeseries[0],timeseries[-1]),(thetaD,thetaD),color='b',\
linestyle='dashed',label='dep thresh')
legend()
xlabel('time (s)')
ylabel('Ca (arb)')
title("Ca conc in the synapse @ "+str(frate)+" Hz firing")
# Weight plots for the synapse
figure(facecolor='w')
for i in range(numrepeats):
plot(timeseries,WtSeries[i],alpha=0.5)
plot(timeseries,WtMean,color='k',linewidth=2)
xlabel('time (s)')
ylabel('Efficacy')
title("Efficacy of the synapse @ "+str(frate)+" Hz firing")
show()
def main():
"""
Simulate pre and post Poisson firing for a synapse with
Ca plasticity of Graupner and Brunel 2012.
See the trace over time (lifetime) for the synaptic efficacy,
similar to figure 2A of Higgins, Graupner, Brunel, 2014.
Author: Aditya Gilra, NCBS, Bangalore, October, 2014.
"""
prePoisson = moose.RandSpike('/pre')
prePoisson.rate = frate
postPoisson = moose.RandSpike('/post')
postPoisson.rate = frate
syn = moose.GraupnerBrunel2012CaPlasticitySynHandler( '/syn' )
syn.numSynapses = 1 # 1 synapse
# many pre-synaptic inputs can connect to a synapse
# spikes from presynaptic Poisson generator
moose.connect( prePoisson,'spikeOut', syn.synapse[0], 'addSpike')
# post-synaptic spikes from postsynaptic Poisson generator
moose.connect( postPoisson, 'spikeOut', syn, 'addPostSpike')
syn.synapse[0].delay = 0.0
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.CaInit = 0.0
syn.tauCa = tauCa
syn.tauSyn = tauSyn
syn.CaPre = CaPre
syn.CaPost = CaPost
syn.delayD = delayD
syn.thetaD = thetaD
syn.thetaP = thetaP
syn.gammaD = gammaD
syn.gammaP = gammaP
syn.weightMax = 1.0 # bounds on the weight
syn.weightMin = 0.
syn.noisy = noisy
syn.noiseSD = noiseSD
syn.bistable = bistable
# ###########################################
# Setting up tables
# ###########################################
CaTable = moose.Table( '/plotCa', 1 )
moose.connect( CaTable, 'requestOut', syn, 'getCa')
WtTable = moose.Table( '/plotWeight', 1 )
moose.connect( WtTable, 'requestOut', syn.synapse[0], 'getWeight')
# ###########################################
# Simulate
# ###########################################
dt = 1e-3 # s
# moose simulation
#moose.useClock( 0, '/syn', 'process' )
#moose.useClock( 1, '/pre', 'process' )
#moose.useClock( 1, '/post', 'process' )
# I think MOOSE uses a different clock than 3 for Tables
# anyway, we use the default one and set all clocks to dt below
#moose.useClock( 3, '/plotCa', 'process' )
#moose.useClock( 3, '/plotWeight', 'process' )
## use setClock to set the dt different from default dt
for i in range(10):
moose.setClock( i, dt )
moose.seed(100)
moose.reinit()
# function to make the aPlus and aMinus settle to equilibrium values
print(("Rates of pre- and post-syanptic neurons =",frate))
WtSeries = []
numsteps = int(runtime/dt)
for i in range(numrepeats):
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.Ca = 0.0
print(("Repeat number",i,"running..."))
moose.start(runtime)
WtSeries.append(WtTable.vector[i*numsteps:(i+1)*numsteps])
WtSeries = array(WtSeries)
WtMean = mean(WtSeries,axis=0)
print("plotting...")
# ###########################################
# Plot the simulated weights and Ca vs time
# ###########################################
timeseries = linspace(0.0,runtime,numsteps)
# Ca plots for the synapse
# only the first repeat
figure(facecolor='w')
plot(timeseries,CaTable.vector[:numsteps],color='r')
plot((timeseries[0],timeseries[-1]),(thetaP,thetaP),color='k',\
linestyle='dashed',label='pot thresh')
plot((timeseries[0],timeseries[-1]),(thetaD,thetaD),color='b',\
linestyle='dashed',label='dep thresh')
legend()
xlabel('time (s)')
ylabel('Ca (arb)')
title("Ca conc in the synapse @ "+str(frate)+" Hz firing")
# Weight plots for the synapse
figure(facecolor='w')
for i in range(numrepeats):
plot(timeseries,WtSeries[i],alpha=0.5)
plot(timeseries,WtMean,color='k',linewidth=2)
xlabel('time (s)')
ylabel('Efficacy')
title("Efficacy of the synapse @ "+str(frate)+" Hz firing")
show()
def main():
"""
The stochasticLotkaVolterra example is almost identical to the
funcReacLotkaVolterra. It shows how to use function objects
as part of differential equation systems in the framework of the MOOSE
kinetic solvers. Here the difference is that we use a a stochastic
solver. The system is interesting because it illustrates the
instability of Lotka-Volterra systems in stochastic conditions. Here we
see exctinction of one of the species and runaway buildup of the other.
The simulation has to be halted at this point.
Here the system is set up explicitly using the
scripting, in normal use one would expect to use SBML.
In this example we set up a Lotka-Volterra system. The equations
are readily expressed as a pair of reactions each of whose rate is
governed by a function::
x' = x( alpha - beta.y )
y' = -y( gamma - delta.x )
This translates into two reactions::
x ---> z Kf = beta.y - alpha
y ---> z Kf = gamma - delta.x
Here z is a dummy molecule whose concentration is buffered to zero.
The model first runs using default Exponential Euler integration.
This is not particularly accurate even with a small timestep.
The model is then converted to use the deterministic Kinetic solver
Ksolve. This is accurate and faster.\n
Note that we cannot use the stochastic GSSA solver for this system, it
cannot handle a reaction term whose rate keeps changing.
"""
makeModel()
moose.seed( 1 )
# A seed of 3 will give an extinction at 79 seconds.
for i in range( 11, 18 ):
moose.setClock( i, 0.001 )
moose.setClock( 18, 0.1 )
moose.reinit()
moose.start( runtime ) # Run the model
# Iterate through all plots, dump their contents to data.plot.
for x in moose.wildcardFind( '/model/graphs/#' ):
#x.xplot( 'scriptKineticModel.plot', x.name )
t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec
pylab.plot( t, x.vector, label=x.name )
#pylab.ylim( 0, 2.5 )
pylab.title( "Exponential Euler solution. Note slight error buildup" )
pylab.legend()
pylab.figure()
compt = moose.element( '/model/lotka' )
ksolve = moose.Gsolve( '/model/lotka/ksolve' )
stoich = moose.Stoich( '/model/lotka/stoich' )
stoich.compartment = compt
stoich.ksolve = ksolve
stoich.path = '/model/lotka/##'
moose.reinit()
moose.start( runtime ) # Run the model
for i in range( 11, 18 ):
moose.setClock( i, 0.1 )
for x in moose.wildcardFind( '/model/graphs/#' ):
t = numpy.arange( 0, x.vector.size, 1 ) * x.dt # sec
pylab.plot( t, x.vector, label=x.name )
#pylab.ylim( 0, 2.5 )
pylab.title( "GSSA solution." )
pylab.legend()
pylab.show()
quit()
def main():
"""
This example sets up the kinetic solver and steady-state finder, on
a bistable model of a chemical system. The model is set up within the
script.
The algorithm calls the steady-state finder 50 times with different
(randomized) initial conditions, as follows:
* Set up the random initial condition that fits the conservation laws
* Run for 2 seconds. This should not be mathematically necessary, but
for obscure numerical reasons it makes it much more likely that the
steady state solver will succeed in finding a state.
* Find the fixed point
* Print out the fixed point vector and various diagnostics.
* Run for 10 seconds. This is completely unnecessary, and is done here
just so that the resultant graph will show what kind of state has
been found.
After it does all this, the program runs for 100 more seconds on the
last found fixed point (which turns out to be a saddle node), then
is hard-switched in the script to the first attractor basin from which
it runs for another 100 seconds till it settles there, and then
is hard-switched yet again to the second attractor and runs for 400
seconds.
Looking at the output you will see many features of note:
* the first attractor (stable point) and the saddle point (unstable
fixed point) are both found quite often. But the second
attractor is found just once.
It has a very small basin of attraction.
* The values found for each of the fixed points match well with the
values found by running the system to steady-state at the end.
* There are a large number of failures to find a fixed point. These are
found and reported in the diagnostics. They show up on the plot
as cases where the 10-second runs are not flat.
If you wanted to find fixed points in a production model, you would
not need to do the 10-second runs, and you would need to eliminate the
cases where the state-finder failed. Then you could identify the good
points and keep track of how many of each were found.
There is no way to guarantee that all fixed points have been found
using this algorithm! If there are points in an obscure corner of state
space (as for the singleton second attractor convergence in this
example) you may have to iterate very many times to find them.
You may wish to sample concentration space logarithmically rather than
linearly.
"""
compartment = makeModel()
ksolve = moose.Ksolve( '/model/compartment/ksolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState( '/model/compartment/state' )
moose.reinit()
state.stoich = stoich
state.showMatrices()
state.convergenceCriterion = 1e-6
moose.seed( 111 ) # Used when generating the samples in state space
for i in range( 0, 50 ):
getState( ksolve, state )
# Now display the states of the system at more length to compare.
moose.start( 100.0 ) # Run the model for 100 seconds.
a = moose.element( '/model/compartment/a' )
b = moose.element( '/model/compartment/b' )
# move most molecules over to b
b.conc = b.conc + a.conc * 0.9
a.conc = a.conc * 0.1
moose.start( 100.0 ) # Run the model for 100 seconds.
# move most molecules back to a
a.conc = a.conc + b.conc * 0.99
b.conc = b.conc * 0.01
moose.start( 400.0 ) # Run the model for 200 seconds.
# Iterate through all plots, dump their contents to data.plot.
displayPlots()
quit()
def main():
"""
This example builds a dose-response of a bistable model of a chemical
system. It uses the kinetic solver *Ksolve* and the steady-state finder
*SteadyState*.
The model is set up within the script.
The basic approach is to increment the control variable, **a** in this
case, while monitoring **b**.
The algorithm marches through a series of values of the buffered pool
**a** and measures resultant values of pool **b**. At each cycle
the algorithm calls the steady-state finder. Since **a** is incremented
only a small amount on each step, each new steady state is
(usually) quite close to the previous one. The exception is when there
is a state transition.
Here we plot three dose-response curves to illustrate the bistable
nature of the system.
On the upward going curve in blue, **a** starts low. Here,
**b** follows the low arm of the curve
and then jumps up to the high value at roughly *log( [a] ) = -0.55*.
On the downward going curve in green, **b** follows the high arm
of the curve forming a nice hysteretic loop.
Eventually **b** has to fall to the low state at about
*log( [a] ) = -0.83*
Through nasty concentration manipulations, we find the third arm
of the curve, which tracks the unstable fixed point. This is in red.
We find this arm by
setting an initial point close to the unstable fixed point, which
the steady-state finder duly locates. We then follow a dose-response
curve as with the other arms of the curve.
Note that the steady-state solver doesn't always succeed in finding a
good solution, despite moving only in small steps. Nevertheless the
resultant curves are smooth because it gives up pretty close to the
correct value, simply because the successive points are close together.
Overall, the system is pretty robust despite the core root-finder
computations in GSL being temperamental.
In doing a production dose-response series
you may wish to sample concentration space logarithmically rather than
linearly.
"""
compartment = makeModel()
ksolve = moose.Ksolve( '/model/compartment/ksolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState( '/model/compartment/state' )
moose.reinit()
state.stoich = stoich
state.convergenceCriterion = 1e-6
moose.seed( 111 ) # Used when generating the samples in state space
b = moose.element( '/model/compartment/b' )
a = moose.element( '/model/compartment/a' )
a.concInit = 0.1
deltaA = 0.002
num = 150
avec = []
bvec = []
moose.reinit()
# Now go up.
for i in range( 0, num ):
moose.start( 1.0 ) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append( a.conc )
bvec.append( b.conc )
a.concInit += deltaA
print i, a.conc, b.conc
pylab.plot( numpy.log10( avec ), numpy.log10( bvec ), label='b vs a up' )
# Now go down.
avec = []
bvec = []
for i in range( 0, num ):
moose.start( 1.0 ) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append( a.conc )
bvec.append( b.conc )
a.concInit -= deltaA
print i, a.conc, b.conc
pylab.plot( numpy.log10( avec ), numpy.log10( bvec ), label='b vs a down' )
# Now aim for the middle. We do this by judiciously choosing a
# start point that should be closer to the unstable fixed point.
avec = []
bvec = []
a.concInit = 0.28
b.conc = 0.15
for i in range( 0, 65 ):
moose.start( 1.0 ) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append( a.conc )
bvec.append( b.conc )
a.concInit -= deltaA
print i, a.conc, b.conc
pylab.plot( numpy.log10( avec ), numpy.log10( bvec ), label='b vs a mid' )
pylab.ylim( [-1.7, 1.2] )
pylab.legend()
pylab.show()
quit()
def main():
"""
This example illustrates how to run a model at different volumes.
The key line is just to set the volume of the compartment::
compt.volume = vol
If everything
else is set up correctly, then this change propagates through to all
reactions molecules.
For a deterministic reaction one would not see any change in output
concentrations.
For a stochastic reaction illustrated here, one sees the level of
'noise'
changing, even though the concentrations are similar up to a point.
This example creates a bistable model having two enzymes and a reaction.
One of the enzymes is autocatalytic.
This model is set up within the script rather than using an external
file.
The model is set up to run using the GSSA (Gillespie Stocahstic systems
algorithim) method in MOOSE.
To run the example, run the script
``python scaleVolumes.py``
and hit ``enter`` every cycle to see the outcome of stochastic
calculations at ever smaller volumes, keeping concentrations the same.
"""
makeModel()
moose.seed(11111)
gsolve = moose.Gsolve('/model/compartment/gsolve')
stoich = moose.Stoich('/model/compartment/stoich')
compt = moose.element('/model/compartment')
stoich.compartment = compt
stoich.ksolve = gsolve
stoich.path = "/model/compartment/##"
moose.setClock(5, 1.0) # clock for the solver
moose.useClock(5, '/model/compartment/gsolve', 'process')
a = moose.element('/model/compartment/a')
for vol in (1e-19, 1e-20, 1e-21, 3e-22, 1e-22, 3e-23, 1e-23):
# Set the volume
compt.volume = vol
print(('vol = ', vol, ', a.concInit = ', a.concInit, ', a.nInit = ',
a.nInit))
moose.reinit()
moose.start(100.0) # Run the model for 100 seconds.
a = moose.element('/model/compartment/a')
b = moose.element('/model/compartment/b')
# move most molecules over to b
b.conc = b.conc + a.conc * 0.9
a.conc = a.conc * 0.1
moose.start(100.0) # Run the model for 100 seconds.
# move most molecules back to a
a.conc = a.conc + b.conc * 0.99
b.conc = b.conc * 0.01
moose.start(100.0) # Run the model for 100 seconds.
# Iterate through all plots, dump their contents to data.plot.
displayPlots()
pylab.show(block=False)
print(('vol = ', vol, 'hit enter to go to next plot'))
input()
quit()
addSomaChemCompt = False,
addEndoChemCompt = True,
# cellProto syntax: ['ballAndStick', 'name', somaDia, somaLength, dendDia, dendLength, numDendSeg]
cellProto = [['ballAndStick', 'soma', 10e-6, 10e-6, 2e-6, 40e-6, 4]],
spineProto = [['makeActiveSpine()', 'spine']],
chemProto = [['./chem/CICRspineDend.g', 'chem']],
spineDistrib = [['spine', '#dend#', '10e-6', '0.1e-6']],
chemDistrib = [['chem', 'dend#,spine#,head#', 'install', '1' ]],
adaptorList = [
[ 'Ca_conc', 'Ca', 'spine/Ca', 'conc', 0.00008, 8 ]
],
stimList = [
['head0', '0.5', 'glu', 'periodicsyn', '1 + 40*(t>5 && t<6)'],
['head0', '0.5', 'NMDA', 'periodicsyn', '1 + 40*(t>5 && t<6)'],
['dend#', 'g>10e-6 && g<=31e-6', 'dend/IP3', 'conc', '0.0006' ],
],
plotList = [
['head#', '1', 'spine/Ca', 'conc', 'Spine Ca conc'],
['dend#', '1', 'dend/Ca', 'conc', 'Dend Ca conc'],
['dend#', '1', 'dend/Ca', 'conc', 'Dend Ca conc', 'wave'],
['dend#', '1', 'dend_endo/CaER', 'conc', 'ER Ca conc', 'wave'],
['soma', '1', '.', 'Vm', 'Memb potl'],
],
)
moose.seed( 1234 )
rdes.buildModel()
moose.reinit()
moose.start( 16 )
rdes.display()
cellProto=[['ballAndStick', 'soma', 12e-6, 12e-6, 4e-6, 100e-6, 1]],
chemProto=[['../chem/CaMKII_MAPK_7.g', 'chem']],
spineProto=[['makeActiveSpine()', 'spine']],
chanProto=[['make_Na()', 'Na'], ['make_K_DR()', 'K_DR'],
['make_K_A()', 'K_A'], ['make_glu()', 'glu'],
['make_Ca()', 'Ca'], ['make_Ca_conc()', 'Ca_conc']],
passiveDistrib=[['soma', 'CM', '0.01', 'Em', '-0.06']],
spineDistrib=[['spine', '#dend#', '100e-6', '1e-6']],
chemDistrib=[['chem', '#', 'install', '1']],
chanDistrib=[['Na', 'soma', 'Gbar',
'300'], ['K_DR', 'soma', 'Gbar', '250'],
['K_A', 'soma', 'Gbar', '200'],
['glu', 'dend#', 'Gbar', '20'],
['Ca_conc', 'soma', 'tau', '0.0333'],
['Ca', 'soma', 'Gbar', '40']],
adaptorList=[['psd/tot_phospho_R', 'n', 'glu', 'modulation', 1.0, 0.3],
['Ca_conc', 'Ca', 'psd/Ca', 'conc', 0.00008, 3]],
# Syn wt is 0.2, specified in 2nd argument
stimList=[['head#', '0.2', 'glu', 'periodicsyn', '0']],
)
moose.seed(1234567)
rdes.buildModel()
moose.delete('/model/stims/stim0')
inputElm = moose.element('/model/elec/head0/glu/sh/synapse/synInput_rs')
inputElm.name = 'synInput'
moose.connect(inputElm, 'spikeOut', '/model/elec/head0/glu/sh/synapse',
'addSpike')
#moose.showmsg( '/model/elec/head0/glu/sh/synapse/synInput_rs' )
import presettle_CaMKII_MAPK7_init
moose.reinit()
def main():
"""
This example illustrates how to run a model at different volumes.
The key line is just to set the volume of the compartment::
compt.volume = vol
If everything
else is set up correctly, then this change propagates through to all
reactions molecules.
For a deterministic reaction one would not see any change in output
concentrations.
For a stochastic reaction illustrated here, one sees the level of
'noise'
changing, even though the concentrations are similar up to a point.
This example creates a bistable model having two enzymes and a reaction.
One of the enzymes is autocatalytic.
This model is set up within the script rather than using an external
file.
The model is set up to run using the GSSA (Gillespie Stocahstic systems
algorithim) method in MOOSE.
To run the example, run the script
``python scaleVolumes.py``
and hit ``enter`` every cycle to see the outcome of stochastic
calculations at ever smaller volumes, keeping concentrations the same.
"""
makeModel()
moose.seed( 11111 )
gsolve = moose.Gsolve( '/model/compartment/gsolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
compt = moose.element( '/model/compartment' );
stoich.compartment = compt
stoich.ksolve = gsolve
stoich.path = "/model/compartment/##"
#moose.setClock( 5, 1.0 ) # clock for the solver
#moose.useClock( 5, '/model/compartment/gsolve', 'process' )
a = moose.element( '/model/compartment/a' )
for vol in ( 1e-19, 1e-20, 1e-21, 3e-22, 1e-22, 3e-23, 1e-23 ):
# Set the volume
compt.volume = vol
print(('vol = ', vol, ', a.concInit = ', a.concInit, ', a.nInit = ', a.nInit))
moose.reinit()
moose.start( 100.0 ) # Run the model for 100 seconds.
a = moose.element( '/model/compartment/a' )
b = moose.element( '/model/compartment/b' )
# move most molecules over to b
b.conc = b.conc + a.conc * 0.9
a.conc = a.conc * 0.1
moose.start( 100.0 ) # Run the model for 100 seconds.
# move most molecules back to a
a.conc = a.conc + b.conc * 0.99
b.conc = b.conc * 0.01
moose.start( 100.0 ) # Run the model for 100 seconds.
# Iterate through all plots, dump their contents to data.plot.
displayPlots()
pylab.show( block=False )
print(('vol = ', vol, 'hit 0 to go to next plot'))
eval(str(input()))
quit()
chanProto=[['make_Na()', 'Na'], ['make_K_DR()', 'K_DR'],
['make_K_A()', 'K_A'], ['make_Ca()', 'Ca'],
['make_Ca_conc()', 'Ca_conc']],
passiveDistrib=[['soma', 'CM', '0.01', 'Em', '-0.06']],
spineDistrib=[['spine', '#dend#', '50e-6', '1e-6']],
chemDistrib=[['chem', '#', 'install', '1']],
chanDistrib=[['Na', 'soma', 'Gbar',
'300'], ['K_DR', 'soma', 'Gbar', '250'],
['K_A', 'soma', 'Gbar', '200'],
['Ca_conc', 'soma', 'tau', '0.0333'],
['Ca', 'soma', 'Gbar', '40']],
adaptorList=[['psd/chan_p', 'n', 'glu', 'modulation', 0.1, 1.0],
['Ca_conc', 'Ca', 'spine/Ca', 'conc', 0.00008, 8]],
# Syn input basline 1 Hz, and 40Hz burst for 1 sec at t=20. Syn weight
# is 0.5, specified in 2nd argument as a special case stimLists.
stimList=[['head#', '0.5', 'glu', 'periodicsyn', '1 + 40*(t>10 && t<11)']],
plotList=[
['soma', '1', '.', 'Vm', 'Membrane potential'],
['#', '1', 'spine/Ca', 'conc', 'Ca in Spine'],
['#', '1', 'dend/DEND/Ca', 'conc', 'Ca in Dend'],
['#', '1', 'spine/Ca_CaM', 'conc', 'Ca_CaM'],
['head#', '1', 'psd/chan_p', 'conc', 'Phosph gluR'],
['head#', '1', 'psd/Ca_CaM_CaMKII', 'conc', 'Active CaMKII'],
])
moose.seed(123)
rdes.buildModel()
moose.reinit()
moose.start(25)
rdes.display()
def main():
"""
This example builds a dose-response of a bistable model of a chemical
system. It uses the kinetic solver *Ksolve* and the steady-state finder
*SteadyState*.
The model is set up within the script.
The basic approach is to increment the control variable, **a** in this
case, while monitoring **b**.
The algorithm marches through a series of values of the buffered pool
**a** and measures resultant values of pool **b**. At each cycle
the algorithm calls the steady-state finder. Since **a** is incremented
only a small amount on each step, each new steady state is
(usually) quite close to the previous one. The exception is when there
is a state transition.
Here we plot three dose-response curves to illustrate the bistable
nature of the system.
On the upward going curve in blue, **a** starts low. Here,
**b** follows the low arm of the curve
and then jumps up to the high value at roughly *log( [a] ) = -0.55*.
On the downward going curve in green, **b** follows the high arm
of the curve forming a nice hysteretic loop.
Eventually **b** has to fall to the low state at about
*log( [a] ) = -0.83*
Through nasty concentration manipulations, we find the third arm
of the curve, which tracks the unstable fixed point. This is in red.
We find this arm by
setting an initial point close to the unstable fixed point, which
the steady-state finder duly locates. We then follow a dose-response
curve as with the other arms of the curve.
Note that the steady-state solver doesn't always succeed in finding a
good solution, despite moving only in small steps. Nevertheless the
resultant curves are smooth because it gives up pretty close to the
correct value, simply because the successive points are close together.
Overall, the system is pretty robust despite the core root-finder
computations in GSL being temperamental.
In doing a production dose-response series
you may wish to sample concentration space logarithmically rather than
linearly.
"""
compartment = makeModel()
ksolve = moose.Ksolve( '/model/compartment/ksolve' )
stoich = moose.Stoich( '/model/compartment/stoich' )
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState( '/model/compartment/state' )
moose.reinit()
state.stoich = stoich
state.convergenceCriterion = 1e-6
moose.seed( 111 ) # Used when generating the samples in state space
b = moose.element( '/model/compartment/b' )
a = moose.element( '/model/compartment/a' )
c = moose.element( '/model/compartment/c' )
a.concInit = 0.1
deltaA = 0.002
num = 150
avec = []
bvec = []
moose.reinit()
# Now go up.
for i in range( 0, num ):
moose.start( 1.0 ) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append( a.conc )
bvec.append( b.conc )
a.concInit += deltaA
#print i, a.conc, b.conc
pylab.plot( numpy.log10( avec ), numpy.log10( bvec ), label='b vs a up' )
# Now go down.
avec = []
bvec = []
for i in range( 0, num ):
moose.start( 1.0 ) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append( a.conc )
bvec.append( b.conc )
a.concInit -= deltaA
#print i, a.conc, b.conc
pylab.plot( numpy.log10( avec ), numpy.log10( bvec ), label='b vs a down' )
# Now aim for the middle. We do this by judiciously choosing a
# start point that should be closer to the unstable fixed point.
avec = []
bvec = []
a.concInit = 0.28
b.conc = 0.15
for i in range( 0, 65 ):
moose.start( 1.0 ) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append( a.conc )
bvec.append( b.conc )
a.concInit -= deltaA
#print i, a.conc, b.conc
pylab.plot( numpy.log10( avec ), numpy.log10( bvec ), label='b vs a mid' )
pylab.ylim( [-1.7, 1.2] )
pylab.legend()
pylab.show()
def main():
compartment = makeModel()
ksolve = moose.Ksolve('/model/compartment/ksolve')
stoich = moose.Stoich('/model/compartment/stoich')
stoich.compartment = compartment
stoich.ksolve = ksolve
stoich.path = "/model/compartment/##"
state = moose.SteadyState('/model/compartment/state')
moose.reinit()
state.stoich = stoich
state.convergenceCriterion = 1e-6
moose.seed(111) # Used when generating the samples in state space
b = moose.element('/model/compartment/b')
a = moose.element('/model/compartment/a')
c = moose.element('/model/compartment/c')
a.concInit = 0.1
deltaA = 0.002
num = 150
avec = []
bvec = []
moose.reinit()
# Now go up.
for i in range(0, num):
moose.start(1.0) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append(a.conc)
bvec.append(b.conc)
a.concInit += deltaA
aa, bb = avec, bvec
got = np.mean(aa), np.std(aa)
expected = 0.24899, 0.08660
assert np.isclose(got, expected,
atol=1e-4).all(), "Got %s, expected %s" % (got, expected)
print("[INFO ] Test 1 PASSED")
# Now go down.
avec = []
bvec = []
for i in range(0, num):
moose.start(1.0) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append(a.conc)
bvec.append(b.conc)
a.concInit -= deltaA
aa, bb = avec, bvec
got = np.mean(aa), np.std(aa)
expected = 0.251, 0.0866
assert np.isclose(got, expected,
atol=1e-4).all(), "Got %s, expected %s" % (got, expected)
print("[INFO ] Test 2 PASSED")
# Now aim for the middle. We do this by judiciously choosing a
# start point that should be closer to the unstable fixed point.
avec = []
bvec = []
a.concInit = 0.28
b.conc = 0.15
for i in range(0, 65):
moose.start(1.0) # Run the model for 1 seconds.
state.settle() # This function finds the steady states.
avec.append(a.conc)
bvec.append(b.conc)
a.concInit -= deltaA
aa, bb = avec, bvec
got = np.mean(aa), np.std(aa)
expected = 0.216, 0.03752
assert np.isclose(got, expected,
atol=1e-4).all(), "Got %s, expected %s" % (got, expected)
print("[INFO ] Test 3 PASSED")
quit()
# ###########################################
dt = 1e-3 # s
# moose simulation
moose.useClock(0, '/syn', 'process')
moose.useClock(1, '/pre', 'process')
moose.useClock(1, '/post', 'process')
moose.useClock(3, '/plotCa', 'process')
moose.useClock(3, '/plotWeight', 'process')
moose.setClock(0, dt)
moose.setClock(1, dt)
moose.setClock(2, dt)
moose.setClock(3, dt)
moose.setClock(9, dt)
moose.seed(100)
moose.reinit()
# function to make the aPlus and aMinus settle to equilibrium values
print "Rates of pre- and post-syanptic neurons =", frate
WtSeries = []
numsteps = int(runtime / dt)
for i in range(numrepeats):
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.Ca = 0.0
print "Repeat number", i, "running..."
moose.start(runtime)
WtSeries.append(WtTable.vector[i * numsteps:(i + 1) * numsteps])
WtSeries = array(WtSeries)
WtMean = mean(WtSeries, axis=0)
print "plotting..."
# ###########################################
dt = 1e-3 # s
# moose simulation
#moose.useClock( 0, '/syn', 'process' )
#moose.useClock( 1, '/pre', 'process' )
#moose.useClock( 1, '/post', 'process' )
# I think MOOSE uses a different clock than 3 for Tables
# anyway, we use the default one and set all clocks to dt below
#moose.useClock( 3, '/plotCa', 'process' )
#moose.useClock( 3, '/plotWeight', 'process' )
## use setClock to set the dt different from default dt
for i in range(10):
moose.setClock( i, dt )
moose.seed(100)
moose.reinit()
# function to make the aPlus and aMinus settle to equilibrium values
print(("Rates of pre- and post-syanptic neurons =",frate))
WtSeries = []
numsteps = int(runtime/dt)
for i in range(numrepeats):
syn.synapse[0].weight = 1.0 # starting weight to decay from
syn.Ca = 0.0
print(("Repeat number",i,"running..."))
moose.start(runtime)
WtSeries.append(WtTable.vector[i*numsteps:(i+1)*numsteps])
WtSeries = array(WtSeries)
WtMean = mean(WtSeries,axis=0)
print("plotting...")
