Solves a system of ordinary differential equations resulting from 2Dimensional partial differential equations that have been converted to ODEs by numerical differencing.
1 2 3 
y 
the initial (state) values for the ODE system, a vector. If

times 
time sequence for which output is wanted; the first
value of 
func 
either an Rfunction that computes the values of the
derivatives in the ODE system (the model definition) at time
If The return value of 
parms 
parameters passed to 
nspec 
the number of species (components) in the model. 
dimens 
2valued vector with the number of boxes in two dimensions in the model. 
cyclicBnd 
if not 
names 
the names of the components; used for plotting. 
method 
the integrator. Use If Method 
... 
additional arguments passed to 
This is the method of choice for 2dimensional models, that are only subjected to transport between adjacent layers.
Based on the dimension of the problem, and if lsodes
is used as
the integrator, the method first calculates the
sparsity pattern of the Jacobian, under the assumption that transport
is only occurring between adjacent layers. Then lsodes
is
called to solve the problem.
If the model is not stiff, then it is more efficient to use one of the explicit integration routines
In some cases, a cyclic boundary condition exists. This is when the first
boxes in xor ydirection interact with the last boxes. In this case, there
will be extra nonzero fringes in the Jacobian which need to be taken
into account. The occurrence of cyclic boundaries can be
toggled on by specifying argument cyclicBnd
. For innstance,
cyclicBnd = 1
indicates that a cyclic boundary is required only for
the xdirection, whereas cyclicBnd = c(1,2)
imposes a cyclic boundary
for both x and ydirection. The default is no cyclic boundaries.
If lsodes
is used to integrate, it will probably be necessary
to specify the length of the real work array, lrw
.
Although a reasonable guess of lrw
is made, it is likely that
this will be too low. In this case, ode.2D
will return with an
error message telling the size of the work array actually needed. In
the second try then, set lrw
equal to this number.
For instance, if you get the error:
1 2 3 4 
set lrw
equal to 27627 or a higher value.
See lsodes for the additional options.
A matrix of class deSolve
with up to as many rows as elements in times and as many
columns as elements in y
plus the number of "global" values
returned in the second element of the return from func
, plus an
additional column (the first) for the time value. There will be one
row for each element in times
unless the integrator returns
with an unrecoverable error. If y
has a names attribute, it
will be used to label the columns of the output value.
The output will have the attributes istate
, and rstate
,
two vectors with several useful elements. The first element of istate
returns the conditions under which the last call to the integrator
returned. Normal is istate = 2
. If verbose = TRUE
, the
settings of istate and rstate will be written to the screen. See the
help for the selected integrator for details.
It is advisable though not mandatory to specify both
nspec
and dimens
. In this case, the solver can check
whether the input makes sense (as nspec * dimens[1] * dimens[2]
== length(y)
).
Do not use this method for problems that are not 2D!
Karline Soetaert <karline.soetaert@nioz.nl>
ode
for a general interface to most of the ODE solvers,
ode.band
for integrating models with a banded Jacobian
ode.1D
for integrating 1D models
ode.3D
for integrating 3D models
lsodes
for the integration options.
diagnostics
to print diagnostic messages.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185  ## =======================================================================
## A LotkaVolterra predatorprey model with predator and prey
## dispersing in 2 dimensions
## =======================================================================
## ==================
## Model definitions
## ==================
lvmod2D < function (time, state, pars, N, Da, dx) {
NN < N*N
Prey < matrix(nrow = N, ncol = N,state[1:NN])
Pred < matrix(nrow = N, ncol = N,state[(NN+1):(2*NN)])
with (as.list(pars), {
## Biology
dPrey < rGrow * Prey * (1 Prey/K)  rIng * Prey * Pred
dPred < rIng * Prey * Pred*assEff  rMort * Pred
zero < rep(0, N)
## 1. Fluxes in xdirection; zero fluxes near boundaries
FluxPrey < Da * rbind(zero,(Prey[2:N,]  Prey[1:(N1),]), zero)/dx
FluxPred < Da * rbind(zero,(Pred[2:N,]  Pred[1:(N1),]), zero)/dx
## Add flux gradient to rate of change
dPrey < dPrey  (FluxPrey[2:(N+1),]  FluxPrey[1:N,])/dx
dPred < dPred  (FluxPred[2:(N+1),]  FluxPred[1:N,])/dx
## 2. Fluxes in ydirection; zero fluxes near boundaries
FluxPrey < Da * cbind(zero,(Prey[,2:N]  Prey[,1:(N1)]), zero)/dx
FluxPred < Da * cbind(zero,(Pred[,2:N]  Pred[,1:(N1)]), zero)/dx
## Add flux gradient to rate of change
dPrey < dPrey  (FluxPrey[,2:(N+1)]  FluxPrey[,1:N])/dx
dPred < dPred  (FluxPred[,2:(N+1)]  FluxPred[,1:N])/dx
return(list(c(as.vector(dPrey), as.vector(dPred))))
})
}
## ===================
## Model applications
## ===================
pars < c(rIng = 0.2, # /day, rate of ingestion
rGrow = 1.0, # /day, growth rate of prey
rMort = 0.2 , # /day, mortality rate of predator
assEff = 0.5, # , assimilation efficiency
K = 5 ) # mmol/m3, carrying capacity
R < 20 # total length of surface, m
N < 50 # number of boxes in one direction
dx < R/N # thickness of each layer
Da < 0.05 # m2/d, dispersion coefficient
NN < N*N # total number of boxes
## initial conditions
yini < rep(0, 2*N*N)
cc < c((NN/2):(NN/2+1)+N/2, (NN/2):(NN/2+1)N/2)
yini[cc] < yini[NN+cc] < 1
## solve model (5000 state variables... use CashKarp RungeKutta method
times < seq(0, 50, by = 1)
out < ode.2D(y = yini, times = times, func = lvmod2D, parms = pars,
dimens = c(N, N), names = c("Prey", "Pred"),
N = N, dx = dx, Da = Da, method = rkMethod("rk45ck"))
diagnostics(out)
summary(out)
# Mean of prey concentration at each time step
Prey < subset(out, select = "Prey", arr = TRUE)
dim(Prey)
MeanPrey < apply(Prey, MARGIN = 3, FUN = mean)
plot(times, MeanPrey)
## Not run:
## plot results
Col < colorRampPalette(c("#00007F", "blue", "#007FFF", "cyan",
"#7FFF7F", "yellow", "#FF7F00", "red", "#7F0000"))
for (i in seq(1, length(times), by = 1))
image(Prey[ , ,i],
col = Col(100), xlab = , zlim = range(out[,2:(NN+1)]))
## similar, plotting both and adding a margin text with times:
image(out, xlab = "x", ylab = "y", mtext = paste("time = ", times))
## End(Not run)
select < c(1, 40)
image(out, xlab = "x", ylab = "y", mtext = "LotkaVolterra in 2D",
subset = select, mfrow = c(2,2), legend = TRUE)
# plot prey and pred at t = 10; first use subset to select data
prey10 < matrix (nrow = N, ncol = N,
data = subset(out, select = "Prey", subset = (time == 10)))
pred10 < matrix (nrow = N, ncol = N,
data = subset(out, select = "Pred", subset = (time == 10)))
mf < par(mfrow = c(1, 2))
image(prey10)
image(pred10)
par (mfrow = mf)
# same, using deSolve's image:
image(out, subset = (time == 10))
## =======================================================================
## An example with a cyclic boundary condition.
## Diffusion in 2D; extra flux on 2 boundaries,
## cyclic boundary in y
## =======================================================================
diffusion2D < function(t, Y, par) {
y < matrix(nrow = nx, ncol = ny, data = Y) # vector to 2D matrix
dY < r * y # consumption
BNDx < rep(1, nx) # boundary concentration
BNDy < rep(1, ny) # boundary concentration
## diffusion in Xdirection; boundaries=imposed concentration
Flux < Dx * rbind(y[1,]  BNDy, (y[2:nx,]  y[1:(nx1),]), BNDy  y[nx,])/dx
dY < dY  (Flux[2:(nx+1),]  Flux[1:nx,])/dx
## diffusion in Ydirection
Flux < Dy * cbind(y[,1]  BNDx, (y[,2:ny]y[,1:(ny1)]), BNDx  y[,ny])/dy
dY < dY  (Flux[,2:(ny+1)]  Flux[,1:ny])/dy
## extra flux on two sides
dY[,1] < dY[,1] + 10
dY[1,] < dY[1,] + 10
## and exchange between sides on ydirection
dY[,ny] < dY[,ny] + (y[,1]  y[,ny]) * 10
return(list(as.vector(dY)))
}
## parameters
dy < dx < 1 # grid size
Dy < Dx < 1 # diffusion coeff, X and Ydirection
r < 0.05 # consumption rate
nx < 50
ny < 100
y < matrix(nrow = nx, ncol = ny, 1)
## model most efficiently solved with lsodes  need to specify lrw
print(system.time(
ST3 < ode.2D(y, times = 1:100, func = diffusion2D, parms = NULL,
dimens = c(nx, ny), verbose = TRUE, names = "Y",
lrw = 400000, atol = 1e10, rtol = 1e10, cyclicBnd = 2)
))
# summary of 2D variable
summary(ST3)
# plot output at t = 10
t10 < matrix (nrow = nx, ncol = ny,
data = subset(ST3, select = "Y", subset = (time == 10)))
persp(t10, theta = 30, border = NA, phi = 70,
col = "lightblue", shade = 0.5, box = FALSE)
# image plot, using deSolve's image function
image(ST3, subset = time == 10, method = "persp",
theta = 30, border = NA, phi = 70, main = "",
col = "lightblue", shade = 0.5, box = FALSE)
## Not run:
zlim < range(ST3[, 1])
for (i in 2:nrow(ST3)) {
y < matrix(nrow = nx, ncol = ny, data = ST3[i, 1])
filled.contour(y, zlim = zlim, main = i)
}
# same
image(ST3, method = "filled.contour")
## End(Not run)

Questions? Problems? Suggestions? Tweet to @rdrrHQ or email at ian@mutexlabs.com.
All documentation is copyright its authors; we didn't write any of that.