This notebook demonstrates some functionality of MuMoT when working with one-dimensional systems.¶

import mumot

mumot.__version__
mumot.about()

model1 = mumot.parseModel(r"""
\emptyset + \alpha_\beta -> \alpha_\beta + \alpha_\beta : r
\alpha_\beta + \alpha_\beta + \alpha_\beta -> \emptyset + \emptyset + \emptyset : b
""")

model1.showODEs()

model1.showMasterEquation()

model1.showVanKampenExpansion()

model1.showFokkerPlanckEquation()

model1.showODEs(method='vanKampen')

model1.showODEs()

model1.showNoiseEquations()

model1.showNoiseSolutions()

mint1 = model1.integrate(initWidgets={'maxTime': [10,1,50,1]})

mint1.showLogs()

model1.noiseCorrelations(initWidgets={'maxTime': [10,1,50,1]})

bif1 = model1.bifurcation('r', r'\alpha_\beta')

bif1.showLogs()

mc1 = mumot.MuMoTmultiController([model1.integrate(params=[('b',2)], choose_yrange=[0,1], silent=True),
                          model1.integrate(params=[('b',1)], choose_yrange=[0,1], silent=True)],
                         shareAxes = False, silent=False);

mc1.showLogs()

mumot.MuMoTmultiController([model1.integrate(initWidgets={'maxTime':[10,5,50,1], 
                                               'initialState':{'\\alpha_\\beta': [0.3,0,1,0.01]}},
                                           conserved=False, silent=True),
                          model1.noiseCorrelations(initWidgets={'maxTime':[10,5,50,1], 
                                               'initialState':{'\\alpha_\\beta': [0.5,0,1,0.01]}},
                                           conserved=False, silent=True)], shareAxes = False)

model2 = mumot.parseModel(r"""
(A) -> X : k
X + X -> \emptyset + \emptyset : h
""")

model2.show()

model2.showODEs()

model2.showODEs(method='vanKampen')

model2.showMasterEquation()

model3 = model2.substitute('h = v, k = m')

model3.showODEs()

model3.showODEs(method='vanKampen')

model3.showNoiseEquations()

model3.showNoiseSolutions()

model2.integrate()

model3.integrate()

model3.showStoichiometry()

model2.showStoichiometry()

model2.noiseCorrelations()

model3.bifurcation('A','X')