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