In [1]:

    

import scotch


    

In [1]:

    




    

In [2]:

    

A = scotch.model('ruthie.json')


    

    




scotch.scotch.model with 9 states, 13 parameters, and 25 reactions.

States :
T, initial condition = 99990
E1, initial condition = 0
E1X, initial condition = 0
E2, initial condition = 0
E2X, initial condition = 0
I1, initial condition = 10
I2, initial condition = 0
DT, initial condition = 0
DI, initial condition = 0

Parameters :
kappa = 0
phi_T = 0.14
beta_V = 0.000000005
nu_I = 1/7
phi_I = 0.14 * 0.8
mu = 0.00001
khi = 8.18 * 100000000000 / 10000* 4.1825 / (22.3*1500)
s = 1.01
eta = 0.01
nu_T = 0.014
beta_I = 4.1825 * 0.00001 / (60*24)
alpha = 1
alpha_X = 0.013

Reactions :
T -> E1,	rate (1 - eta) * beta_I * I1 * T * (1 - mu)
T -> E1,	rate (1 - eta) * beta_V * khi * I1 * T * (1 - mu)
T -> E1X,	rate eta * beta_I * I1 * T * (1 - mu)
T -> E1X,	rate eta * beta_V * I1 * khi * T * (1 - mu)
T -> E2,	rate mu * (1 - eta) * beta_I * I1 * T
T -> E2,	rate mu * (1 - eta) * beta_V * khi * I1 * T
T -> E2,	rate (1 - eta) * s * beta_I * I2 * T
T -> E2,	rate (1 - eta) * s * beta_V * khi * I2 * T
T -> E2X,	rate mu * eta * beta_I * I1 * T
T -> E2X,	rate mu * eta * beta_V * khi * I1 * T
T -> E2X,	rate eta * s * beta_I * I2 * T
T -> E2X,	rate eta * s * beta_V * khi * I2 * T
T -> DT,	rate nu_T * T
E1 -> I1,	rate alpha * E1
E1X -> I1,	rate alpha_X * E1X
E2 -> I2,	rate alpha * E2
E2X -> I2,	rate alpha_X * E2
I1 -> DI,	rate nu_I * I1
I2 -> DI,	rate nu_I * I2
E1 -> DT,	rate nu_T * E1
E2 -> DT,	rate nu_T * E2
E1X -> DT,	rate nu_T * E1X
E2X -> DT,	rate nu_T * E2X
DT -> T,	rate phi_T * DT
DI -> T,	rate phi_I * DI

In [16]:

    

A.build


    

    
Out[16]:





<bound method model.build of T -> E1, rate (1 - eta) * beta_I * I1 * T * (1 - mu)
T -> E1, rate (1 - eta) * beta_V * khi * I1 * T * (1 - mu)
T -> E1X, rate eta * beta_I * I1 * T * (1 - mu)
T -> E1X, rate eta * beta_V * I1 * khi * T * (1 - mu)
T -> E2, rate mu * (1 - eta) * beta_I * I1 * T
T -> E2, rate mu * (1 - eta) * beta_V * khi * I1 * T
T -> E2, rate (1 - eta) * s * beta_I * I2 * T
T -> E2, rate (1 - eta) * s * beta_V * khi * I2 * T
T -> E2X, rate mu * eta * beta_I * I1 * T
T -> E2X, rate mu * eta * beta_V * khi * I1 * T
T -> E2X, rate eta * s * beta_I * I2 * T
T -> E2X, rate eta * s * beta_V * khi * I2 * T
T -> DT, rate nu_T * T
E1 -> I1, rate alpha * E1
E1X -> I1, rate alpha_X * E1X
E2 -> I2, rate alpha * E2
E2X -> I2, rate alpha_X * E2
I1 -> DI, rate nu_I * I1
I2 -> DI, rate nu_I * I2
E1 -> DT, rate nu_T * E1
E2 -> DT, rate nu_T * E2
E1X -> DT, rate nu_T * E1X
E2X -> DT, rate nu_T * E2X
DT -> T, rate phi_T * DT
DI -> T, rate phi_I * DI
>

In [17]:

    

[t,trace] = scotch.simulate.tauLeap(A,1000,.01)


    

    




[                         ]-------------------------

In [13]:

    

A.initconds['T'] = '9990'


    

In [4]:

    

import matplotlib.pyplot as plt
import seaborn


    

In [18]:

    

plt.plot(t,trace[:,[0,5,6]])
plt.legend([A.states[i] for i in [0,5,6]])


    

    
Out[18]:





<matplotlib.legend.Legend at 0x10daa2790>






    

In [7]:

    

%matplotlib inline


    

In [70]:

    

A.states[0,7]


    

    




---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-70-7422952f2b06> in <module>()
----> 1 A.states[0,7]

TypeError: list indices must be integers, not tuple

In [73]:

    

[A.states[i] for i in [0,5,6]]


    

    
Out[73]:





[u'T', u'I1', u'I2']

In [ ]: