def setUp(self):
# Tests the following system, solving the deterministic version
# A + A -> C
# A + B -> D
# \emptyset -> A
# \emptyset -> B
self.param_eval = {'k1': 0.001, 'k2': 0.01, 'k3': 1.2, 'k4': 1.0}
self.x0 = [0, 0, 0, 0]
self.t = np.linspace(0, 100, 100)
self.states = ['A', 'B', 'C', 'D']
self.params = ['k1', 'k2', 'k3', 'k4']
self.transitions = [
Transition(origin=('A', 'A'),
destination='C',
equation='A * (A - 1) * k1',
transition_type=TransitionType.T),
Transition(origin=('A', 'B'),
destination='D',
equation='A * B * k2',
transition_type=TransitionType.T)
]
# our birth and deaths
self.birth_deaths = [
Transition(origin='A',
equation='k3',
transition_type=TransitionType.B),
Transition(origin='B',
equation='k4',
transition_type=TransitionType.B)
]
def test_Vector_State1(self):
# state is a vector
stateList = ['y1:4']
paramList = []
# transitions call from the vector
transitionList = [
Transition(origState='y[0]',
destState='y[1]',
equation='0.04*y[0] + 1e4 * y[1] * y[2]',
transitionType=TransitionType.T),
Transition(origState='y[1]',
destState='y[0]',
equation='1e4 * y[1] * y[2]',
transitionType=TransitionType.T),
Transition(origState='y[1]',
destState='y[2]',
equation='3e7 * y[1] * y[1]',
transitionType=TransitionType.T)
]
# initialize the model
ode = OperateOdeModel(stateList,
paramList,
transitionList=transitionList)
ode.getOde()
t = numpy.append(0, 4 * numpy.logspace(-6, 6, 1000))
ode = ode.setInitialValue([1.0, 0.0, 0.0], t[0])
# try to integrate to see if there is any problem
solution, output = ode.integrate(t[1::], full_output=True)
def test_adding_parameters(self):
'''
Test adding parameters to a model
'''
expected_result = [
ODEVariable('beta', 'beta', None, True),
ODEVariable('gamma', 'gamma', None, True),
ODEVariable('mu', 'mu', None, True),
ODEVariable('B', 'B', None, True)
]
# Model parts
stateList = ['S', 'I', 'R']
paramList = ['beta', 'gamma']
# build the basic model
t1 = Transition(origin='S',
destination='I',
equation='beta*S*I',
transition_type=TransitionType.T)
t2 = Transition(origin='I',
destination='R',
equation='gamma*I',
transition_type=TransitionType.T)
modelTrans = SimulateOde(stateList, paramList, transition=[t1, t2])
# add to the parameters
modelTrans.param_list = paramList + ['mu', 'B']
self.assertListEqual(
modelTrans.param_list, expected_result,
'Adding parameters does not give expected '
'parameter list')
def setUp(self):
n_size = 50
self.n_sim = 3
# x0 = [1,1.27e-6,0] # original
self.x0 = [2362206.0, 3.0, 0.0]
self.t = np.linspace(0, 250, n_size)
# use a shorter version if we just want to test
# whether setting the seed is applicable
self.t_seed = np.linspace(0, 10, 10)
self.index = np.random.randint(n_size)
state_list = ['S', 'I', 'R']
param_list = ['beta', 'gamma', 'N']
transition_list = [
Transition(origin='S',
destination='I',
equation='beta*S*I/N',
transition_type=TransitionType.T),
Transition(origin='I',
destination='R',
equation='gamma*I',
transition_type=TransitionType.T)
]
# initialize the model
self.odeS = SimulateOde(state_list,
param_list,
transition=transition_list)
self.odeS.parameters = [0.5, 1.0 / 3.0, self.x0[0]]
self.odeS.initial_values = (self.x0, self.t[0])
def setUp(self):
self.n_sim = 1000
# initial time
self.t0 = 0
# the initial state, normalized to zero one
self.x0 = [1, 1.27e-6, 0]
# set the time sequence that we would like to observe
self.t = np.linspace(0, 150, 100)
# Standard. Find the solution.
ode = common_models.SIR()
ode.parameters = [0.5, 1.0 / 3.0]
ode.initial_values = (self.x0, self.t0)
self.solution = ode.integrate(self.t[1::], full_output=False)
# now we need to define our ode explicitly
state_list = ['S', 'I', 'R']
param_list = ['beta', 'gamma']
transition_list = [
Transition(origin='S',
destination='I',
equation='beta*S*I',
transition_type=TransitionType.T),
Transition(origin='I',
destination='R',
equation='gamma*I',
transition_type=TransitionType.T)
]
# our stochastic version
self.odeS = SimulateOde(state_list,
param_list,
transition=transition_list)
def test_Vector_State3(self):
# state is a vector
state_list = [ODEVariable('y1', 'y1'),
ODEVariable('y2', 's'),
ODEVariable('y3', 'x')]
param_list = []
# transitions are explicit names
transition_list = [
Transition(origin='y1',
destination='y2',
equation='0.04*y1',
transition_type=TransitionType.T),
Transition(origin='y2',
destination='y1',
equation='1e4*y2*y3',
transition_type=TransitionType.T),
Transition(origin='y2',
destination='y3',
equation='3e7*y2*y2',
transition_type=TransitionType.T)
]
ode = DeterministicOde(state_list, param_list,
transition=transition_list)
ode.get_ode_eqn()
t = numpy.append(0, 4*numpy.logspace(-6, 6, 1000))
ode.initial_values = ([1.0, 0.0, 0.0], t[0])
# try to integrate to see if there is any problem
solution, output = ode.integrate(t[1::], full_output=True)
def test_Vector_State1(self):
# state is a vector
state_list = ['y1:4']
param_list = []
# transitions call from the vector
transition_list = [
Transition(origin='y[0]',
destination='y[1]',
equation='0.04*y[0]',
transition_type=TransitionType.T),
Transition(origin='y[1]',
destination='y[0]',
equation='1e4*y[1]*y[2]',
transition_type=TransitionType.T),
Transition(origin='y[1]',
destination='y[2]',
equation='3e7*y[1]*y[1]',
transition_type=TransitionType.T)
]
# initialize the model
ode = DeterministicOde(state_list, param_list,
transition=transition_list)
ode.get_ode_eqn()
t = numpy.append(0, 4*numpy.logspace(-6, 6, 1000))
ode.initial_values = ([1.0, 0.0, 0.0], t[0])
# try to integrate to see if there is any problem
_solution, _output = ode.integrate(t[1::], full_output=True)
def test_Vector_State2(self):
# state is a vector
stateList = ['y1:4']
paramList = []
# transitions are explicit names
transitionList = [
Transition(origState='y1',
destState='y2',
equation='0.04*y1 + 1e4 * y2 * y3',
transitionType=TransitionType.T),
Transition(origState='y2',
destState='y1',
equation='1e4 * y2 * y3',
transitionType=TransitionType.T),
Transition(origState='y2',
destState='y3',
equation='3e7 * y2 * y2',
transitionType=TransitionType.T)
]
ode = OperateOdeModel(stateList,
paramList,
transitionList=transitionList)
ode.getOde()
t = numpy.append(0, 4 * numpy.logspace(-6, 6, 1000))
ode = ode.setInitialValue([1.0, 0.0, 0.0], t[0])
# try to integrate to see if there is any problem
solution, output = ode.integrate(t[1::], full_output=True)
def test_SimulateCTMC(self):
'''
Stochastic ode under the interpretation that we have a continuous
time Markov chain as the underlying process
'''
#x0 = [1,1.27e-6,0] # original
x0 = [2362206.0, 3.0, 0.0]
t = numpy.linspace(0, 250, 50)
stateList = ['S', 'I', 'R']
paramList = ['beta', 'gamma', 'N']
transitionList = [
Transition(origState='S',
destState='I',
equation='beta*S*I/N',
transitionType=TransitionType.T),
Transition(origState='I',
destState='R',
equation='gamma*I',
transitionType=TransitionType.T)
]
# initialize the model
odeS = SimulateOdeModel(stateList,
paramList,
transitionList=transitionList)
odeS.setParameters([0.5, 1.0 / 3.0, x0[0]]).setInitialValue(x0, t[0])
solution = odeS.integrate(t[1::])
odeS.transitionMean(x0, t[0])
odeS.transitionVar(x0, t[0])
odeS.transitionMean(solution[10, :], t[10])
odeS.transitionVar(solution[10, :], t[10])
simX, simT = odeS.simulateJump(250, 3, full_output=True)
def test_SIR_Estimate_PoissonLoss_2TargetState(self):
# initial values
N = 2362205.0
x0 = [N, 3.0, 0.0]
t = numpy.linspace(0, 150, 100).astype('float64')
# params
paramEval = [('beta', 0.5), ('gamma', 1.0 / 3.0), ('N', N)]
stateList = ['S', 'I', 'R']
paramList = ['beta', 'gamma', 'N']
transitionList = [
Transition(origState='S',
destState='I',
equation='beta * S * I/N',
transitionType=TransitionType.T),
Transition(origState='I',
destState='R',
equation='gamma * I',
transitionType=TransitionType.T)
]
# initialize the model
ode = OperateOdeModel(stateList,
paramList,
transitionList=transitionList)
ode = ode.setParameters(paramEval).setInitialValue(x0, t[0])
# Standard. Find the solution.
solution = ode.integrate(t[1::])
# initial value
theta = [0.4, 0.3]
# note that we need to round the observations to integer for it to make sense
objSIR = PoissonLoss(theta,
ode,
x0,
t[0],
t[1::],
numpy.round(solution[1::, 1:3]), ['I', 'R'],
targetParam=['beta', 'gamma'])
# constraints
EPSILON = numpy.sqrt(numpy.finfo(numpy.float).eps)
boxBounds = [(EPSILON, 2), (EPSILON, 2)]
res = scipy.optimize.minimize(fun=objSIR.cost,
jac=objSIR.sensitivity,
x0=theta,
method='L-BFGS-B',
bounds=boxBounds)
target = numpy.array([0.5, 1.0 / 3.0])
if numpy.any(abs(res['x'] - target) >= 1e-2):
raise Exception("Failed!")
def test_simple(self):
ode1 = Transition('S', '-beta*S*I', 'ode')
ode2 = Transition('I', 'beta*S*I - gamma * I', 'ode')
ode3 = Transition('R', 'gamma*I', 'ode')
state_list = ['S', 'I', 'R']
param_list = ['beta', 'gamma']
ode = SimulateOde(state_list, param_list, ode=[ode1, ode2, ode3])
ode2 = ode.get_unrolled_obj()
diffEqZero = map(lambda x: x==0, sympy.simplify(ode.get_ode_eqn() - ode2.get_ode_eqn()))
self.assertTrue(numpy.all(numpy.array(list(diffEqZero))))
def test_simple(self):
ode1 = Transition('S','-beta*S*I', 'ode')
ode2 = Transition('I','beta*S*I - gamma * I', 'ode')
ode3 = Transition('R','gamma*I', 'ode')
stateList = ['S','I','R']
paramList = ['beta','gamma']
ode = SimulateOdeModel(stateList, paramList, odeList=[ode1,ode2,ode3])
ode2 = ode.returnObjWithTransitionsAndBD()
diffEqZero = map(lambda x: x==0, sympy.simplify(ode.getOde() - ode2.getOde()))
if numpy.any(numpy.array(diffEqZero) == False):
raise Exception("Simple: SIR Decomposition failed")
def test_simple(self):
ode1 = Transition('S', '-beta*S*I', 'ode')
ode2 = Transition('I', 'beta*S*I - gamma * I', 'ode')
ode3 = Transition('R', 'gamma*I', 'ode')
state_list = ['S', 'I', 'R']
param_list = ['beta', 'gamma']
ode = SimulateOde(state_list, param_list, ode=[ode1, ode2, ode3])
ode2 = ode.get_unrolled_obj()
diffEqZero = map(
lambda x: x == 0,
sympy.simplify(ode.get_ode_eqn() - ode2.get_ode_eqn()))
self.assertTrue(numpy.all(numpy.array(list(diffEqZero))))
def test_simulateParam2(self):
'''
Stochastic ode under the interpretation that the parameters follow
some sort of distribution. In this case, a function handle which
has the same name as R
'''
t0 = 0
# the initial state, normalized to zero one
x0 = [1, 1.27e-6, 0]
# set the time sequence that we would like to observe
t = numpy.linspace(0, 150, 100)
# Standard. Find the solution.
ode = common_models.SIR()
ode.setParameters([0.5, 1.0 / 3.0])
ode.setInitialValue(x0, t0)
solutionReference = ode.integrate(t[1::], full_output=False)
# now we need to define our ode explicitly
stateList = ['S', 'I', 'R']
paramList = ['beta', 'gamma']
transitionList = [
Transition(origState='S',
destState='I',
equation='beta*S*I',
transitionType=TransitionType.T),
Transition(origState='I',
destState='R',
equation='gamma*I',
transitionType=TransitionType.T)
]
# our stochastic version
odeS = SimulateOdeModel(stateList,
paramList,
transitionList=transitionList)
# define our parameters in terms of two gamma distributions
# where the expected values are the same as before [0.5,1.0/3.0]
d = dict()
d['beta'] = (rgamma, {'shape': 100.0, 'rate': 200.0})
d['gamma'] = (rgamma, (100.0, 300.0))
odeS.setParameters(d).setInitialValue(x0, t0)
# now we generate the solutions
solutionDiff = odeS.simulateParam(t[1::], 1000) - solutionReference
# test :)
if numpy.any(abs(solutionDiff) >= 0.2):
raise Exception("Possible problem with simulating the parameters")
def test_simple(self):
ode1 = Transition('S', '-beta*S*I', 'ode')
ode2 = Transition('I', 'beta*S*I - gamma * I', 'ode')
ode3 = Transition('R', 'gamma*I', 'ode')
stateList = ['S', 'I', 'R']
paramList = ['beta', 'gamma']
ode = SimulateOdeModel(stateList,
paramList,
odeList=[ode1, ode2, ode3])
ode2 = ode.returnObjWithTransitionsAndBD()
diffEqZero = map(lambda x: x == 0,
sympy.simplify(ode.getOde() - ode2.getOde()))
if numpy.any(numpy.array(list(diffEqZero)) == False):
raise Exception("Simple: SIR Decomposition failed")
def test_hard(self):
# the SLIARD model is considered to be hard because a state can
# go to multiple state. This is not as hard as the SEIHFR model
# below.
stateList = ['S', 'L', 'I', 'A', 'R', 'D']
paramList = [
'beta', 'p', 'kappa', 'alpha', 'f', 'delta', 'epsilon', 'N'
]
odeList = [
Transition('S', '- beta * S/N * ( I + delta * A)', 'ODE'),
Transition('L', 'beta * S/N * (I + delta * A) - kappa * L', 'ODE'),
Transition('I', 'p * kappa * L - alpha * I', 'ODE'),
Transition('A', '(1-p) * kappa * L - epsilon * A', 'ODE'),
Transition('R', 'f * alpha * I + epsilon * A', 'ODE'),
Transition('D', '(1-f) * alpha * I', 'ODE')
]
ode = SimulateOdeModel(stateList, paramList, odeList=odeList)
ode2 = ode.returnObjWithTransitionsAndBD()
diffEqZero = map(lambda x: x == 0,
sympy.simplify(ode.getOde() - ode2.getOde()))
if numpy.any(numpy.array(list(diffEqZero)) == False):
raise Exception("Hard: SLIARD Decomposition failed")
def test_hard(self):
# the SLIARD model is considered to be hard because a state can
# go to multiple state. This is not as hard as the SEIHFR model
# below.
state_list = ['S', 'L', 'I', 'A', 'R', 'D']
param_list = [
'beta', 'p', 'kappa', 'alpha', 'f', 'delta', 'epsilon', 'N'
]
ode_list = [
Transition('S', '- beta * S/N * ( I + delta * A)', 'ODE'),
Transition('L', 'beta * S/N * (I + delta * A) - kappa * L', 'ODE'),
Transition('I', 'p * kappa * L - alpha * I', 'ODE'),
Transition('A', '(1-p) * kappa * L - epsilon * A', 'ODE'),
Transition('R', 'f * alpha * I + epsilon * A', 'ODE'),
Transition('D', '(1-f) * alpha * I', 'ODE')
]
ode = SimulateOde(state_list, param_list, ode=ode_list)
ode2 = ode.get_unrolled_obj()
diffEqZero = map(
lambda x: x == 0,
sympy.simplify(ode.get_ode_eqn() - ode2.get_ode_eqn()))
self.assertTrue(numpy.all(numpy.array(list(diffEqZero))))
def test_deterministic(self):
# Tests the following system, solving the deterministic version
# A + A -> C
# A + B -> D
# \emptyset -> A
# \emptyset -> B
stateList = ['A', 'B', 'C', 'D']
paramList = ['k1', 'k2', 'k3', 'k4']
transitionList = [
Transition(origState=('A', 'A'),
destState='C',
equation='A * (A - 1) * k1',
transitionType=TransitionType.T),
Transition(origState=('A', 'B'),
destState='D',
equation='A * B * k2',
transitionType=TransitionType.T)
]
# our birth and deaths
birthDeathList = [
Transition(origState='A',
equation='k3',
transitionType=TransitionType.B),
Transition(origState='B',
equation='k4',
transitionType=TransitionType.B)
]
ode = OperateOdeModel(stateList,
paramList,
birthDeathList=birthDeathList,
transitionList=transitionList)
x0 = [0, 0, 0, 0]
t = numpy.linspace(0, 100, 100)
ode.setParameters(paramEval).setInitialValue(x0, t[0])
solution = ode.integrate(t[1::])
def test_stochastic(self):
# Tests the following system simulating jumps
# A + A -> C
# A + B -> D
# \emptyset -> A
# \emptyset -> B
stateList = ['A', 'B', 'C', 'D']
paramList = ['k1', 'k2', 'k3', 'k4']
transitionList = [
Transition(origState=('A', 'A'),
destState='C',
equation='A * (A - 1) * k1',
transitionType=TransitionType.T),
Transition(origState=('A', 'B'),
destState='D',
equation='A * B * k2',
transitionType=TransitionType.T)
]
# our birth and deaths
birthDeathList = [
Transition(origState='A',
equation='k3',
transitionType=TransitionType.B),
Transition(origState='B',
equation='k4',
transitionType=TransitionType.B)
]
ode = SimulateOdeModel(stateList,
paramList,
birthDeathList=birthDeathList,
transitionList=transitionList)
x0 = [0, 0, 0, 0]
t = numpy.linspace(0, 100, 100)
ode.setParameters(paramEval).setInitialValue(x0, t[0])
simX, simT = ode.simulateJump(t, 5, full_output=True)
def setUp(self):
# initial values
N = 2362205.0
self.x0 = [N, 3.0, 0.0]
self.t = np.linspace(0, 150, 100).astype('float64')
# params
param_eval = [('beta', 0.5), ('gamma', 1.0 / 3.0), ('N', N)]
state_list = ['S', 'I', 'R']
param_list = ['beta', 'gamma', 'N']
transition_list = [
Transition(origin='S',
destination='I',
equation='beta * S * I/N',
transition_type=TransitionType.T),
Transition(origin='I',
destination='R',
equation='gamma * I',
transition_type=TransitionType.T)
]
# initialize the model
self.ode = DeterministicOde(state_list,
param_list,
transition=transition_list)
self.ode.parameters = param_eval
self.ode.initial_values = (self.x0, self.t[0])
# Standard. Find the solution.
self.solution = self.ode.integrate(self.t[1::])
# initial value
self.theta = np.array([0.4, 0.3])
# constraints
EPSILON = np.sqrt(np.finfo(np.float).eps)
self.box_bounds = [(EPSILON, 2), (EPSILON, 2)]
self.target = np.array([0.5, 1.0 / 3.0])
def test_bd(self):
state_list = ['S', 'I', 'R']
param_list = ['beta', 'gamma', 'B', 'mu']
ode_list = [
Transition(origin='S',
equation='-beta * S * I + B - mu * S',
transition_type=TransitionType.ODE),
Transition(origin='I',
equation='beta * S * I - gamma * I - mu * I',
transition_type=TransitionType.ODE),
Transition(origin='R',
destination='R',
equation='gamma * I',
transition_type=TransitionType.ODE)
]
ode = SimulateOde(state_list, param_list, ode=ode_list)
ode2 = ode.get_unrolled_obj()
diffEqZero = map(
lambda x: x == 0,
sympy.simplify(ode.get_ode_eqn() - ode2.get_ode_eqn()))
self.assertTrue(numpy.all(numpy.array(list(diffEqZero))))
def test_bd(self):
stateList = ['S', 'I', 'R']
paramList = ['beta', 'gamma', 'B', 'mu']
odeList = [
Transition(origState='S',
equation='-beta * S * I + B - mu * S',
transitionType=TransitionType.ODE),
Transition(origState='I',
equation='beta * S * I - gamma * I - mu * I',
transitionType=TransitionType.ODE),
Transition(origState='R',
destState='R',
equation='gamma * I',
transitionType=TransitionType.ODE)
]
ode = SimulateOdeModel(stateList, paramList, odeList=odeList)
ode2 = ode.returnObjWithTransitionsAndBD()
diffEqZero = map(lambda x: x == 0,
sympy.simplify(ode.getOde() - ode2.getOde()))
if numpy.any(numpy.array(list(diffEqZero)) == False):
raise Exception("Birth Death: SIR+BD Decomposition failed")
def getOdeObject(model):
a = getModelComponents(model)
#paramList = map(lambda x: x['id'], getCompartmentsInfo(a['comps']))
paramEval = map(lambda x: (x['id'], x['size']),
getCompartmentsInfo(a['comps']))
stateList = map(lambda x: x['id'], getSpeciesInfo(a['species']))
x0 = map(lambda x: x['x0'], getSpeciesInfo(a['species']))
# origList = list()
# destList = list()
# eqnList = list()
transitionList = list()
for r in getReactionsInfo(a['reacts']):
orig = [reactant['specie'] for reactant in r['reactant']]
dest = [product['specie'] for product in r['product']]
eqn = r['kineticlaw']['eqn']
# eqnList.append(eqn)
# paramList += map(lambda x: x['id'], r['kineticlaw']['parameters'])
paramLocal = map(lambda x: (x['id'], x['value']),
r['kineticlaw']['parameters'])
# newTerm = map(lambda x: r['id'] + '_' + x[0], paramLocal)
# term = map(lambda x: r'\b%s\b' % x[0], paramLocal)
# this the first line below essentially create the two variables
# above on the fly
for term in map(lambda x: x[0], paramLocal):
eqn = re.sub(r'\b%s\b' % term, ' %s_%s ' % (r['id'], term), eqn)
transitionList.append(Transition(orig, eqn, 'T', dest, r['id']))
paramEval += map(lambda x: (r['id'] + '_' + x[0], x[1]), paramLocal)
# print "\n"
# print eqn
# print paramLocal
paramList = map(lambda x: x[0], paramEval)
# print "\nfinal paramEval"+str(paramEval)
# print paramList
# print transitionList
ode = OperateOdeModel(stateList, paramList, transitionList=transitionList)
ode = ode.setInitialState(x0).setParameters(paramEval)
return (ode)
def test_derived_param(self):
# the derived parameters are treated separately when compared to the
# normal parameters and the odes
ode = common_models.Legrand_Ebola_SEIHFR()
odeList = [
Transition(
'S',
'-(beta_I * S * I + beta_H_Time * S * H + beta_F_Time * S * F)'
),
Transition(
'E',
'(beta_I * S * I + beta_H_Time * S * H + beta_F_Time * S * F)-alpha * E'
),
Transition(
'I',
'-gamma_I * (1 - theta_1) * (1 - delta_1) * I - gamma_D * (1 - theta_1) * delta_1 * I - gamma_H * theta_1 * I + alpha * E'
),
Transition(
'H',
'gamma_H * theta_1 * I - gamma_DH * delta_2 * H - gamma_IH * (1 - delta_2) * H'
),
Transition(
'F',
'- gamma_F * F + gamma_DH * delta_2 * H + gamma_D * (1 - theta_1) * delta_1 * I'
),
Transition(
'R',
'gamma_I * (1 - theta_1) * (1 - delta_1) * I + gamma_F * F + gamma_IH * (1 - delta_2) * H'
),
Transition('tau', '1')
]
ode1 = SimulateOdeModel(ode._stateList,
ode._paramList,
ode._derivedParamEqn,
odeList=odeList)
ode2 = ode1.returnObjWithTransitionsAndBD()
diffEqZero = map(lambda x: x == 0,
sympy.simplify(ode.getOde() - ode2.getOde()))
if numpy.any(numpy.array(list(diffEqZero)) == False):
raise Exception("FAILED!")
def test_derived_param(self):
# the derived parameters are treated separately when compared to the
# normal parameters and the odes
ode = common_models.Legrand_Ebola_SEIHFR()
ode_list = [
Transition('S',
'-(beta_I*S*I + beta_H_Time*S*H + beta_F_Time*S*F)'),
Transition(
'E',
'(beta_I*S*I + beta_H_Time*S*H + beta_F_Time*S*F) - alpha*E'),
Transition(
'I',
'-gamma_I*(1 - theta_1)*(1 - delta_1)*I - gamma_D*(1 - theta_1)*delta_1*I - gamma_H*theta_1*I + alpha*E'
),
Transition(
'H',
'gamma_H*theta_1*I - gamma_DH*delta_2*H - gamma_IH*(1 - delta_2)*H'
),
Transition(
'F',
'- gamma_F*F + gamma_DH*delta_2*H + gamma_D*(1 - theta_1)*delta_1*I'
),
Transition(
'R',
'gamma_I*(1 - theta_1)*(1 - delta_1)*I + gamma_F*F + gamma_IH*(1 - delta_2)*H'
),
Transition('tau', '1')
]
ode1 = SimulateOde(ode.state_list,
ode.param_list,
ode._derivedParamEqn,
ode=ode_list)
ode2 = ode1.get_unrolled_obj()
diffEqZero = map(
lambda x: x == 0,
sympy.simplify(ode.get_ode_eqn() - ode2.get_ode_eqn()))
self.assertTrue(numpy.all(numpy.array(list(diffEqZero))))
df = pd.read_excel("Italy Variable Data.xlsx",header = 0)
S = list(df['S'])
E = list(df['E'])
I = list(df['I'])
Q = list(df['Q'])
C = list(df['C'])
R = list(df['R'])
y = []
t = []
for i in range(1, len(S)):
y.append([S[i], E[i], I[i], Q[i], R[i]])
t.append(i)
states = ['S', 'E', 'I', 'Q', 'C', 'R']
params = ['A', 'q', 'mu1', 'mu2', 'mu3', 'd1', 'd2','d3', 'delta', 'delta1', 'delta2', 'p1', 'alpha', 'beta']
odeList = [ Transition(origin='S',equation='A - (delta*S) - (beta*S*I) - (alpha*C*S) - q*S',transition_type=TransitionType.ODE),
Transition(origin='E',equation='(beta*I*S) - (delta*E) - (delta1*E) + (alpha*C*S)',transition_type=TransitionType.ODE),
Transition(origin='I',equation='delta1*E - (delta*I) - (delta2*I) - (mu1*I) - (d1*I)',transition_type=TransitionType.ODE),
Transition(origin='Q',equation='(p1*delta2*I) - (delta*Q) - (mu2*Q) - (d2*Q)',transition_type=TransitionType.ODE),
Transition(origin='C',equation='(delta2*I*(1-p1)) - (delta*C) - (mu3*C) - (d3*C)',transition_type=TransitionType.ODE),
Transition(origin='R',equation='mu1*I + mu2*Q + mu3*C - delta*R',transition_type=TransitionType.ODE)]
model = DeterministicOde (states, params, ode =odeList)
init_state = [60461803,2703,94, 127, 2948,1]
param_eval = [('A', 0.007896),('q',0.01), ('mu1', 0.4554), ('mu2', 1.21382), ('mu3', 0.1325), ('d1',0.24203), ('d2', 0.55586),('d3', 0.07849), ('delta', 0.000213), ('delta1',0.196), ('delta2',0.996), ('alpha',0.000000196), ('beta', 0.000034196), ('p1',0.96)]
model.intial_values = (init_state, [0])
model.parameters = param_eval
# sol = odeint(model.ode, init_state, t[1:])
# print(sol)
# print(sol.size)
theta = [0.5, 0.9, 0.05, 0.05]
bounds = [(0,1),(0,1),(0,1),(0,1)]
def naive(self, n):
# n = 2
s = [str(i) for i in range(n)]
beta = []
lambdaStr = []
lambdaName = []
N, S, E, I, R = [], [], [], [], []
for i in s:
N += ['N_' + i]
S += ['S_' + i]
E += ['E_' + i]
I += ['I_' + i]
R += ['R_' + i]
lambdaTemp = '0 '
for j in s:
beta += ['beta_' + i + j]
if i == j:
lambdaTemp += '+ I_' + j + '* beta_' + i + j
else:
lambdaTemp += '+ I_' + j + ' * beta_' + i + j + ' * p'
lambdaStr += [lambdaTemp]
lambdaName += ['lambda_' + i]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
stateList = S + E + I + R
transitionList = []
bdList = []
derivedParamList = []
for i in range(n):
derivedParamList += [(lambdaName[i], lambdaStr[i])]
transitionList += [
Transition(origState=S[i],
destState=E[i],
equation=lambdaName[i] + '*' + S[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=E[i],
destState=I[i],
equation=' epsilon * ' + E[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=I[i],
destState=R[i],
equation=' gamma * ' + I[i],
transitionType=TransitionType.T)
]
bdList += [
Transition(origState=S[i],
equation='d * ' + S[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=E[i],
equation='d * ' + E[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=I[i],
equation='d * ' + I[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=R[i],
equation='d * ' + R[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=S[i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
t = numpy.linspace(0, 40, 100)
x01 = self.getInitialValue(paramList, n)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution1 = ode.integrate(t[1::])
return (solution1)
def confused(self, n):
# stateName = ['N', 'S', 'E', 'I', 'R']
# for s in stateName:
# six.exec_('%s = %s' % (s, [s+'_'+str(i) for i in range(n)]))
var_dict = globals()
stateName = ['N', 'S', 'E', 'I', 'R']
for s in stateName:
# six.exec_('%s = %s' % (s, [s+'_'+str(i) for i in range(n)]))
# glb[s] = [s+'_'+str(i) for i in range(n)]
var_dict[s] = [s + '_' + str(i) for i in range(n)]
beta = []
bdList = list()
transitionList = list()
derivedParamList = list()
for i in range(n):
lambdaStr = '0 '
for j in range(n):
beta.append('beta_%s%s' % (i, j))
lambdaStr += '+ I_%s * beta_%s%s ' % (j, i, j)
if i != j:
lambdaStr += ' * p'
derivedParamList += [('lambda_' + str(i), lambdaStr)]
transitionList += [
Transition(origState=S[i],
destState=E[i],
equation='lambda_' + str(i) + '*' + S[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=E[i],
destState=I[i],
equation=' epsilon * ' + E[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=I[i],
destState=R[i],
equation=' gamma * ' + I[i],
transitionType=TransitionType.T)
]
bdList += [
Transition(origState=S[i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
stateList = S + E + I + R
for s in stateList:
bdList += [
Transition(origState=s,
equation='d * ' + s,
transitionType=TransitionType.D)
]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
t = numpy.linspace(0, 40, 100)
x01 = self.getInitialValue(paramList, n)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution5 = ode.integrate(t[1::])
return (solution5)
def very_short(self, n):
beta = []
lambdaStr = []
lambdaName = []
var_dict = globals()
stateName = ['N', 'S', 'E', 'I', 'R']
for s in stateName:
# six.exec_('%s = %s' % (s, [s+'_'+str(i) for i in range(n)]))
# glb[s] = [s+'_'+str(i) for i in range(n)]
var_dict[s] = [s + '_' + str(i) for i in range(n)]
# print(glb.keys())
# print(lcl.keys())
for i in range(n):
lambdaTemp = '0 '
for j in range(n):
beta.append('beta_%s%s' % (i, j))
lambdaTemp += '+ I_%s * beta_%s%s ' % (j, i, j)
if i != j:
lambdaTemp += ' * p'
lambdaStr += [lambdaTemp]
lambdaName += ['lambda_' + str(i)]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
stateList = S + E + I + R
transitionList = []
bdList = []
derivedParamList = []
for i in range(n):
derivedParamList += [(lambdaName[i], lambdaStr[i])]
transitionList += [
Transition(origState=S[i],
destState=E[i],
equation=lambdaName[i] + '*' + S[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=E[i],
destState=I[i],
equation=' epsilon * ' + E[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=I[i],
destState=R[i],
equation=' gamma * ' + I[i],
transitionType=TransitionType.T)
]
bdList += [
Transition(origState=S[i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
for s in stateList:
bdList += [
Transition(origState=s,
equation='d * ' + s,
transitionType=TransitionType.D)
]
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
t = numpy.linspace(0, 40, 100)
x01 = self.getInitialValue(paramList, n)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution4 = ode.integrate(t[1::])
return (solution4)
def even_shorter(self, n):
s = [str(i) for i in range(n)]
beta = []
lambdaStr = []
lambdaName = []
stateName = ["S", "E", "I", "R"]
states = OrderedDict.fromkeys(stateName, [])
N = []
for i in s:
for v in states:
states[v] = states[v] + [str(v) + "_" + i]
N += ['N_' + i]
lambdaTemp = '0'
for j in s:
beta += ['beta_' + i + j]
if i == j:
lambdaTemp += '+ I_' + j + '*beta_' + i + j
else:
lambdaTemp += '+ I_' + j + '*beta_' + i + j + ' * p'
lambdaStr += [lambdaTemp]
lambdaName += ['lambda_' + i]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
stateList = []
for v in states:
stateList += states[v]
transitionList = []
bdList = []
derivedParamList = []
for i in range(n):
derivedParamList += [(lambdaName[i], lambdaStr[i])]
transitionList += [
Transition(origState=states['S'][i],
destState=states['E'][i],
equation=lambdaName[i] + '*' + states['S'][i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=states['E'][i],
destState=states['I'][i],
equation=' epsilon * ' + states['E'][i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=states['I'][i],
destState=states['R'][i],
equation=' gamma * ' + states['I'][i],
transitionType=TransitionType.T)
]
for v in states:
bdList += [
Transition(origState=states[v][i],
equation='d * ' + states[v][i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=states['S'][i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
t = numpy.linspace(0, 40, 100)
x01 = self.getInitialValue(paramList, n)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution3 = ode.integrate(t[1::])
return (solution3)
# |p| Fraction of the individuals at high-risk | 0.2|
# |$\beta$| Transmission rate of disease | Estimated|
# |$1/\mu$| Average life of human | 63 years|
# Now set up the parameters
parameters = [
'phi_H', 'sigma_I', 'sigma_H', 'theta_I', 'theta_H', 'alpha', 'tau',
'Rec_rate', 'p', 'beta', 'mu', 'lda', 'eta', 'N'
]
# Set this up as birth, death and transitions
# This could have been done as lifts of the ODE system from the paper but
# being more verbose like this makes us concentrate on the model
transitions = [
Transition(origin='Susceptible_lr',
destination='Exposed',
equation='lda*Susceptible_lr',
transition_type=TransitionType.T),
Transition(origin='Susceptible_hr',
destination='Exposed',
equation='phi_H * lda * Susceptible_hr',
transition_type=TransitionType.T),
Transition(origin='Exposed',
destination='Infected',
equation='alpha * Exposed',
transition_type=TransitionType.T),
Transition(origin='Infected',
destination='Hospitalized',
equation='tau * Infected',
transition_type=TransitionType.T),
Transition(origin='Infected',
destination='Recovered',
def test_compareAll(self):
'''
Compare the solution of a coupled ode using three different
ways of defining it
'''
## naive version
n = 2
s = [str(i) for i in range(n)]
beta = []
lambdaStr = []
lambdaName = []
N, S, E, I, R = [], [], [], [], []
for i in s:
N += ['N_' + i]
S += ['S_' + i]
E += ['E_' + i]
I += ['I_' + i]
R += ['R_' + i]
lambdaTemp = '0 '
for j in s:
beta += ['beta_' + i + j]
if i == j:
lambdaTemp += '+ I_' + j + '* beta_' + i + j
else:
lambdaTemp += '+ I_' + j + ' * beta_' + i + j + ' * p'
lambdaStr += [lambdaTemp]
lambdaName += ['lambda_' + i]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
stateList = S + E + I + R
transitionList = []
bdList = []
derivedParamList = []
for i in range(n):
derivedParamList += [(lambdaName[i], lambdaStr[i])]
transitionList += [
Transition(origState=S[i],
destState=E[i],
equation=lambdaName[i] + '*' + S[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=E[i],
destState=I[i],
equation=' epsilon * ' + E[i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=I[i],
destState=R[i],
equation=' gamma * ' + I[i],
transitionType=TransitionType.T)
]
bdList += [
Transition(origState=S[i],
equation='d * ' + S[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=E[i],
equation='d * ' + E[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=I[i],
equation='d * ' + I[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=R[i],
equation='d * ' + R[i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=S[i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
## to find the stationary starting conditions
for param in paramList:
strAdd = param + ' = sympy.symbols("' + param + '")'
exec(strAdd)
N = sympy.symbols("N")
R0 = (epsilon * N) / ((d + epsilon) *
(d + gamma)) * (beta_00 + beta_01)
S = N / R0
E = (d * N) / (d + epsilon) * (1 - 1 / R0)
I = (d * epsilon) / ((d + gamma) * (d + epsilon)) * N * (1 - 1 / R0)
R = N - S - E - I
paramEval1 = {
'beta_00': 0.0010107,
'beta_01': 0.0010107,
'beta_10': 0.0010107,
'beta_11': 0.0010107,
'd': 0.02,
'epsilon': 45.6,
'gamma': 73.0,
'N_0': 10**6,
'N_1': 10**6,
'N': 10**6
}
x0 = [
S.subs(paramEval1),
E.subs(paramEval1),
I.subs(paramEval1),
R.subs(paramEval1)
]
t = numpy.linspace(0, 40, 100)
x01 = []
for s in x0:
x01 += [s]
x01 += [s]
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution1 = ode.integrate(t[1::])
## shorter version
n = 2
s = [str(i) for i in range(n)]
beta = []
lambdaStr = []
lambdaName = []
stateName = ["S", "E", "I", "R"]
states = OrderedDict.fromkeys(stateName, [])
N = []
for i in s:
for v in states:
states[v] = states[v] + [str(v) + "_" + i]
N += ['N_' + i]
lambdaTemp = '0'
for j in s:
beta += ['beta_' + i + j]
if i == j:
lambdaTemp += '+ I_' + j + '*beta_' + i + j
else:
lambdaTemp += '+ I_' + j + '*beta_' + i + j + ' * p'
lambdaStr += [lambdaTemp]
lambdaName += ['lambda_' + i]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
stateList = []
for v in states:
stateList += states[v]
transitionList = []
bdList = []
derivedParamList = []
for i in range(n):
derivedParamList += [(lambdaName[i], lambdaStr[i])]
transitionList += [
Transition(origState=states['S'][i],
destState=states['E'][i],
equation=lambdaName[i] + '*' + states['S'][i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=states['E'][i],
destState=states['I'][i],
equation=' epsilon * ' + states['E'][i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=states['I'][i],
destState=states['R'][i],
equation=' gamma * ' + states['I'][i],
transitionType=TransitionType.T)
]
bdList += [
Transition(origState=states['S'][i],
equation='d * ' + states['S'][i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=states['E'][i],
equation='d * ' + states['E'][i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=states['I'][i],
equation='d * ' + states['I'][i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=states['R'][i],
equation='d * ' + states['R'][i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=states['S'][i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution2 = ode.integrate(t[1::])
## even shorter version
n = 2
s = [str(i) for i in range(n)]
beta = []
lambdaStr = []
lambdaName = []
stateName = ["S", "E", "I", "R"]
states = OrderedDict.fromkeys(stateName, [])
N = []
for i in s:
for v in states:
states[v] = states[v] + [str(v) + "_" + i]
N += ['N_' + i]
lambdaTemp = '0'
for j in s:
beta += ['beta_' + i + j]
if i == j:
lambdaTemp += '+ I_' + j + '*beta_' + i + j
else:
lambdaTemp += '+ I_' + j + '*beta_' + i + j + ' * p'
lambdaStr += [lambdaTemp]
lambdaName += ['lambda_' + i]
paramList = beta + ['d', 'epsilon', 'gamma', 'p'] + N
stateList = []
for v in states:
stateList += states[v]
transitionList = []
bdList = []
derivedParamList = []
for i in range(n):
derivedParamList += [(lambdaName[i], lambdaStr[i])]
transitionList += [
Transition(origState=states['S'][i],
destState=states['E'][i],
equation=lambdaName[i] + '*' + states['S'][i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=states['E'][i],
destState=states['I'][i],
equation=' epsilon * ' + states['E'][i],
transitionType=TransitionType.T)
]
transitionList += [
Transition(origState=states['I'][i],
destState=states['R'][i],
equation=' gamma * ' + states['I'][i],
transitionType=TransitionType.T)
]
for v in states:
bdList += [
Transition(origState=states[v][i],
equation='d * ' + states[v][i],
transitionType=TransitionType.D)
]
bdList += [
Transition(origState=states['S'][i],
equation='d * ' + N[i],
transitionType=TransitionType.B)
]
ode = OperateOdeModel(stateList,
paramList,
derivedParamList=derivedParamList,
transitionList=transitionList,
birthDeathList=bdList)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01, float),
t[0])
solution3 = ode.integrate(t[1::])
if numpy.any((solution1 - solution2) >= 0.1):
raise Exception("Solution not match")
else:
print("happy")
if numpy.any((solution3 - solution2) >= 0.1):
raise Exception("Solution not match")
else:
print("happy")
