Applying a set of ordinary differential equations to each grid cell - r

Question

I am developing an agent-based model to simulate the spread of infectious diseases in heterogeneous landscapes composed of habitat polygons (or clumps of connected cells). To simplify the model, I consider a habitat grid (or raster) containing the polygon ID of each cell. In addition, I have epidemiological parameters associated with each polygon ID. At each time step, the parameter values change in the polygon. Thus, the data frame landscape (see below) is updated at each time step. Here is an example at t = 0:
landscape <- data.frame(polygon_ID = seq(1, 10, by = 1),
beta = sample(c(100, 200, 400, 600), 10, replace = TRUE),
gamma = sample(c(25, 26, 27, 28), 10, replace = TRUE))
To study the disease dynamics, I also am developing a compartmental model based on a system of ordinary differential equations (ODEs). Here is an example to represent the system of ODEs:
solve_sir_model <- function (times, parameters) {
sir_model <- function (times, states, parameters) {
with(as.list(c(states, parameters)), {
dSdt <- -beta*S*I
dIdt <- beta*S*I-gamma*I
dRdt <- gamma*I
dNdt <- dSdt + dIdt + dRdt
return(list(c(dSdt, dIdt, dRdt, dNdt)))
})
}
states <- c(S = 99, I = 1, R = 0, N = 100)
return(ode(y = states, times = times, func = sir_model, parms = parameters))
}
require(deSolve)
output <- as.data.frame(solve_sir_model(times = seq(0, 5, by = 1), parameters = c(beta = 400, gamma = 28)))
At each time step, is it possible to apply the system of ODEs to each habitat polygon (thus each row) in the data frame landscape? I am using lsoda as an ODE solver. Do I need to use another solver to apply the ODEs at each time step?
EDIT
It seems that the method iteration in the function ode can be useful in my case:
Method "iteration" is special in that here the function func should
return the new value of the state variables rather than the rate of
change. This can be used for individual based models, for difference
equations, or in those cases where the integration is performed within
func).
I have tested the method but I don't understand why it doesn't work with a single time step:
solve_sir_model <- function (times, parameters) {
sir_model <- function (times, states, parameters) {
with(as.list(c(states, parameters)), {
dSdt <- -beta*S*I
dIdt <- beta*S*I-gamma*I
dRdt <- gamma*I
dNdt <- dSdt + dIdt + dRdt
return(list(c(dSdt, dIdt, dRdt, dNdt)))
})
}
states <- c(S = 99, I = 1, R = 0, N = 100)
return(ode(y = states, times = times, func = sir_model, parms = parameters, method = "iteration"))
}
require(deSolve)
output <- as.data.frame(solve_sir_model(times = 1, parameters = c(beta = 400, gamma = 28)))
Error in iteration(y, times, func, parms, ...) :
times should be equally spaced In addition: Warning messages:
1: In min(x) : no non-missing arguments to min; returning Inf
2: In max(x) : no non-missing arguments to max; returning -Inf

Answer 1

Something like this.
# Library *not* require
library(deSolve)
# Parameters: number of polygons, beta, & gamma
n.polys <- 10
beta <- sample(c(100, 200, 400, 600), n.polys, replace = TRUE)
gamma <- sample(c(25, 26, 27, 28), n.polys, replace = TRUE)
# Model defintion
sir_model <- function (t, Y, pars) {
# Break up state variable into parts
S <- Y[1:n.polys]
I <- Y[(n.polys+1):(2 * n.polys)]
R <- Y[(2 * n.polys+1):(3 * n.polys)]
# Calculate rate of change
dSdt <- -beta * S * I
dIdt <- beta * S * I - gamma * I
dRdt <- gamma * I
# Return rates of change after concatenating them
return(list(c(dSdt, dIdt, dRdt)))
}
# Initial conditions
Y.ini <- c(S = rep(99, n.polys), I = rep(1, n.polys), R = rep(0, n.polys))
# Solve the model
ode(y = Y.ini, times = 0:5, func = sir_model, parms = NULL)