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")