有没有办法强制 ode() [deSolve-R package] 在 ode 函数的每个积分步骤提供输出

Question

I would like to extract the value of the state variable at each step of the numerical scheme.

The ode() function in the deSolve R package, uses one of the implemented ODE solvers to numerically solve a system of ordinary differential equations. To do this it uses a dynamically adjusted integration step based on the value of the Local Truncation Error at the end of each integration. The user basically specifies the desired output times which define the timestep grid, that can have a step equal or smaller to the output times.

If we take the Lotka Volterra Predator-Prey model (with logistic prey) as an example:

LVmod <- function(Time, State, Pars) {
  with(as.list(c(State, Pars)), {
    Ingestion    <- rIng  * Prey * Predator
    GrowthPrey   <- rGrow * Prey * (1 - Prey/K)
    MortPredator <- rMort * Predator

    dPrey        <- GrowthPrey - Ingestion
    dPredator    <- Ingestion * assEff - MortPredator

    return(list(c(dPrey, dPredator)))
  })
}

with the parameters and state variable defined as:

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      = 10)     # mmol/m3, carrying capacity



yini  <- c(Prey = 1, Predator = 2)

and output requested at a daily timestep:

times <- seq(0, 200, by = 1)

out   <- ode(yini, times, LVmod, pars)
diagnostics(out)

Looking at the diagnostics we can see that the solver used 282 steps in total while the output is generated for 200 steps (as set in the times object).

This difference is a lot bigger for the model that I am running and to do a complete analysis of the stability of my system I need the output at each integration step together with the size of the step. Is there a way to extract this info from ode?

Answer 1

So, after a bit of research [1,2]:

There are two explicit methods that do not adapt the time step: the euler method and the rk4 method. They are implemented in two ways:

1. As a rkMethod of the general rk solver. In this case the time step used can be specified independently from the times argument, by setting argument hini. Function ode uses this general code
2. As special solver codes euler and rk4. These implementations are simplified and with less options to avoid overhead. The timestep used is determined by the time increment in the times argument.

Applied to the LV example, the next two statements both trigger the Euler method, the first using the “special” code with a time step = 1, as imposed by the times argument, the second using the generalized method with a time step set by hini.

    out.euler  <- euler(y = state, times = times, func = LVmod, parms = parameters)
    out.rk <- ode(y = state, times = times, func = LVmod, parms = parameters,
                 method = "euler", hini = 0.01)

In this very simple system using the explicit Euler scheme might make sense, however for more complex systems the rk4 would be advisable even though it is still an explicit scheme.

To conclude:

• There seems to be no way to extract the state values at each step when using the dynamic time step in the ode() function.
• You can set a constant step for two explicit schemes: Euler and rk4.

[1] Soetaert, KER, Petzoldt, T., & Setzer, RW (2010). Solving differential equations in R: package deSolve. Journal of Statistical Software, 33.

[2] Soetaert, K., Petzoldt, T., & Setzer, RW (2010). Package deSolve: solving initial value differential equations in R. J Stat Softw, 33(9), 1-25.

Answer 2

It is possible to watch how the integrator works by putting a print or cat in the model function:

library("deSolve")

LVmod <- function(Time, State, Pars) {
  with(as.list(c(State, Pars)), {
    Ingestion    <- rIng  * Prey * Predator
    GrowthPrey   <- rGrow * Prey * (1 - Prey/K)
    MortPredator <- rMort * Predator

    dPrey        <- GrowthPrey - Ingestion
    dPredator    <- Ingestion * assEff - MortPredator
    cat("Time=", Time, "dPrey"=dPrey, "dPredator=", dPredator, "\n")
    return(list(c(dPrey, dPredator)))
  })
}

This works with both, automatic and fixed step solvers. Please note however, that automatic steppers may sometimes discard steps and try it again, so time is not always monotonous. If you want to save the data for later use, save the data to a list with <<-, ideally by constructing a closure around the simulation.