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_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_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 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_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_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 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_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_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_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_compareAll(self):
'''
Compare the solution of a coupled ode using 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::])
###
### very short version
###
n = 2
beta = []
lambdaStr = []
lambdaName = []
stateName = ['N','S','E','I','R']
for s in stateName:
exec('%s = %s' % (s, [s+'_'+str(i) for i in range(n)]))
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)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01,float),t[0])
solution4 = ode.integrate(t[1::])
###
### confused version
###
n = 2
stateName = ['N','S','E','I','R']
for s in stateName:
exec('%s = %s' % (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)
ode.setParameters(paramEval).setInitialValue(numpy.array(x01,float),t[0])
solution5 = ode.integrate(t[1::])
if numpy.any((solution1-solution2) >= 0.001):
raise Exception("Solution not match")
if numpy.any((solution3-solution2) >= 0.001):
raise Exception("Solution not match")
if numpy.any((solution4-solution3) >= 0.001):
raise Exception("Solution not match")
if numpy.any((solution5-solution4) >= 0.001):
raise Exception("Solution not match")
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)
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")
