Growth predictions under constant environmental conditions
Basic growth predictions
The argument environment defines the type of model that
predict_growth() will use to calculate the model
predictions. When environment="constant", calculations are
calculated based only on primary models. The model equation and the
values of the model parameters are defined through the argument
primary_model. It must be a named list with one entry
called "model" that defines the model equation. The keys
identifying the types of model can be retrieved by calling
primary_model_data().
primary_model_data()
#> [1] "modGompertz" "Baranyi" "Baranyi_noLag"
#> [4] "Baranyi_noStationary" "Trilinear" "Logistic"
#> [7] "Richards" "Loglinear" "Bilinear_lag"
#> [10] "Bilinear_stationary"In this example, we will use the modified Baranyi model.
Then, the values of the model parameters are defined using additional
entries in the list. These must be named according to keys defined
internally within the package. These (as well as other meta-information
on the model) can be retrieved passing the model key to
primary_model_data()
Here we can see that the Baranyi model requires the definition of the
logarithm of the initial population size (logN0), the
maximum population size in the stationary phase (logNmax),
the growth rate during the exponential growth phase mu and
the duration of the lag phase lambda. In this example, we
will assign logN0=1, logNmax=7,
mu=0.2 and lambda=20.
For additional details on the model equations and the interpretation of the different model parameters, the reader is referred to the specific vignette about mathematical methods.
For model predictions under constant environmental conditions, the
simulations are calculated by solving the algebraic form of the model
equation. The time points were it is calculated must be defined using
the times argument, which is a numeric vector of any
length. In this case, we will use a regular vector from 0 to 100 with
1,000 uniformly spaced points.
Once we have defined these arguments, we can call the
predict_growth() function
The function returns an instance of GrowthPrediction
with several S3 methods to ease the interpretation of the growth
prediction. The print() method shows the model selected and
the values of the model parameters used for the calculations. It also
shows the base of the logarithms used for the definition of the model
parameters and the population size. This point will be discussed
below.
my_prediction
#> Growth prediction based on primary models
#>
#> Growth model: Baranyi
#>
#> Parameters of the primary model:
#> logN0 logNmax mu lambda
#> 1.0 7.0 0.2 20.0
#>
#> Parameter mu defined in log-10 scale
#> Population size defined in log-10 scaleThe values of the model parameters can also be retrieved using the
coef() method
It also implements a plot() method to visualize the
predicted growth curve
Note that the y-axis represents the logarithm of the population size. By default, the label of the y-axis shows within parenthesis the base of the logarithm. This, as well as many other aesthetics of the plot, can be edited by passing additional arguments to plot
plot(my_prediction,
label_y1 = "log10 of the population size",
label_x = "Time (years)",
line_size = 2,
line_col = "red",
line_type = "dotted")
For a detailed description of the arguments admitted by the function,
please check its help page (e.g. with
?plot.GrowthPrediction). Note that plot()
returns an instance of ggplot, so it can be edited using
additional layers
One aspect that is often of interest when analyzing the growth of
populations is the time required to reach a value of the population
size. In biogrowth, this can be calculated using
time_to_size(). This function can take as arguments an
instance of GrowthPrediction and a population size (in log
units) and returns the time required to reach that population size.
If the population size is not reached during the simulation, the
function returns NA.
Alternative definitions of model parameters
In order to facilitate the definition of different types of model,
predict_growth() accepts alternative definitions of the
model parameters. Namely, * the initial population size can also be
described either in log-scale (logN0) or without a log
transformation (N0), * the maximum population size in the
stationary phase can also be described either in log-scale
(logNmax) or without a log transformation
(Nmax), * the growth rate during the exponential phase can
be named mu_opt instead of mu * the duration
of the lag phase can be defined in terms of Q0 instead of
lambda. In this case, the duration of the lag phase is
calculated as \(\lambda=1/\left( \exp(\mu
\cdot \lambda) - 1 \right)\), as per the Baranyi model (see
vignette about the mathematical models for the derivation). Note that
this calculation is included in biogrowth in the
function lambda_to_Q0().
Therefore, this model definition is equivalent to the one defined above:
primary_model <- list(model = my_model, logN0 = 1, logNmax = 7, mu = .2, lambda = 20)
Q0 <- lambda_to_Q0(lambda = 20, mu = .2)
equivalent_pars <- list(model = my_model, N0 = 10^1, Nmax = 10^7, mu_opt = .2,
Q0 = Q0)
equivalent_prediction <- predict_growth(environment = "constant", my_times,
equivalent_pars)
plot(equivalent_prediction)
Definition of different logarithmic bases
As already mentioned above, growth simulations often cover several
orders of magnitude, making it more convenient to express the results in
logarithmic scale. By default, all the calculations in
biogrowth are done in log10 scale. Nevertheless, this
can be modified using the arguments logbase_mu and
logbase_logN. We believe the relevance of these bases is a
common source of confusion when modeling population growth (although the
population size has no units, its logarithmic base affects the
calculations), so the reader is strongly encouraged to check the
vignette dedicated to the unit system.
The base of the logarithm of the population size is defined by
logbase_logN. By default, the calculations are done in
log10 scale, but any numeric value can be passed to this argument. One
point worth highlighting here is that the model parameters
logN0 and logNmax are defined in the same
scale as the population size. Therefore, if the primary model is defined
based on this parameters, the growth curve is exactly the same,
regardless of the base of \(\log N\).
The only difference is the label of the y-axis.
primary_model <- list(model = my_model, logN0 = 1, logNmax = 7, mu = .2, lambda = 20)
prediction_base_e <- predict_growth(environment = "constant", my_times,
primary_model,
logbase_logN = exp(1))
prediction_base_e
#> Growth prediction based on primary models
#>
#> Growth model: Baranyi
#>
#> Parameters of the primary model:
#> logN0 logNmax mu lambda
#> 1.0 7.0 0.2 20.0
#>
#> Parameter mu defined in log-e scale
#> Population size defined in log-e scale
plot(prediction_base_e)
However, if the primary model is defined in terms of \(N_0\) and/or \(N_{max}\), the growth curve will be affected.
primary_model <- list(model = my_model, N0 = 1, Nmax = 1e7, mu = .2, lambda = 20)
prediction_base_e <- predict_growth(environment = "constant", my_times,
primary_model,
logbase_logN = exp(1))
plot(prediction_base_e)
The base of the logarithm for the parameter \(\mu\) is defined by the argument
logbase_mu. By default, this parameter uses the same base
as the population size. Nonetheless, it can accept any numeric value.
Changes in this base will be reflected both in the print method and the
growth curve:
primary_model <- list(model = my_model, logN0 = 1, logNmax = 7, mu = .2, lambda = 20)
prediction_mu_e <- predict_growth(environment = "constant", my_times,
primary_model,
logbase_mu = exp(1))
prediction_mu_e
#> Growth prediction based on primary models
#>
#> Growth model: Baranyi
#>
#> Parameters of the primary model:
#> logN0 logNmax mu lambda
#> 1.0 7.0 0.2 20.0
#>
#> Parameter mu defined in log-e scale
#> Population size defined in log-10 scale
plot(prediction_mu_e)
As detailed in the vignette dedicated to the unit system, the growth rate for different log-bases of \(\mu\) can be calculated as \(\mu_b = \mu_a \cdot \log_b a\)
primary_model <- list(model = my_model, logN0 = 1, logNmax = 7,
mu = .2 * log(10),
lambda = 20)
prediction_mu_e <- predict_growth(environment = "constant", my_times,
primary_model,
logbase_mu = exp(1)
)
plot(prediction_mu_e)
Note that time_to_size() also accepts a
logbase_logN argument. By default, this argument takes
NULL, so the function uses the same logbase as the growth
prediction. For instance, if we use prediction_base_e that
used natural base for the calculation, a size=5 would mean
a size of exp(5) units.
print(prediction_base_e)
#> Growth prediction based on primary models
#>
#> Growth model: Baranyi
#>
#> Parameters of the primary model:
#> N0 Nmax mu lambda
#> 1e+00 1e+07 2e-01 2e+01
#>
#> Parameter mu defined in log-e scale
#> Population size defined in log-e scale
time_to_size(prediction_base_e, size = 5)
#> [1] 44.96689Then, if we want to define the population in log-base10, we would
need to set logbase_logN=10.
