emulator_learn() and emulator_predict() results change, and
predictions no longer draw from the session's random numbers. AR(2)
emulators no longer need three time steps.calibration_prepare()) now uses a Matern 5/2 kernel with separate
hyperparameters for each time step, instead of one squared-exponential
kernel for all times. With 40 training and 50 held-out SIR runs on
10 x 10, 20 x 20 and 50 x 50 grids, the RMSE of PDE-free predictions fell
by 4.0%, 9.5% and 5.2% in the first E2 benchmark profile (unit grid cells,
one design; benchmarks/results/e2/paper) and by 27%, 13% and 9% on a
second, independent simulation; in that profile, 95% intervals covered
95-96% of held-out values (93-95% before). Fitting one GP per time step adds about 8 s to
calibration_prepare() for 26 time steps. New arguments design_kernel and
design_groups select the design GP; design_kernel = "sqexp", design_groups = "shared" restores the previous one. Both Stan programs
evaluate the chosen kernel, with one design variance factor per time step.calibration_fit() starts the chains at the posterior mode by default
(init = "mode"): in each conditional fit it runs L-BFGS from mode_starts
(20) random starts and starts every chain, slightly jittered, at the optimum
with the highest log posterior density. In the E3 calibration benchmark,
chains started at random settled in local modes 35 to 586 log-density units
below the main mode, which carry negligible posterior mass but made the
pooled draws unreliable. init = "random" and init = "midpoint" (the
previous default; in the bundled dt_calibration example the midpoint equals
the true parameter value) remain available. The recorded vignette example
and the installed reproduction script pass init = "midpoint" and are
unchanged.calibration_fit() (diagnostics[[j]]$summary,
max_rhat, min_n_eff, and summary()) are now the rank-normalised split
Rhat and bulk effective sample size of Vehtari et al. (2021), from
rstan::Rhat() and rstan::ess_bulk(), instead of the classic diagnostics
of rstan::summary(); the tail effective sample size is added
(min_ess_tail). They flag poorly mixed chains more reliably, so some
fits that passed before now warn.calibration_fit() requires iter. For inference use several chains and
enough iterations (for example chains = 4, iter = 2000); iter = 1 is a
quick execution check.emulator_learn() no longer builds the dense S x S R_field unless it is
supplied, so setup$R_field is NULL by default. Calibration builds the
same kernel at the observed sites when it needs it, and results are
unchanged. This removes an O(S^3) step and O(S^2) memory from every fit.update_y_eta(),
update_y_eta_one(), update_muSigma_eta_one(), sample_y_eta_one(),
cal_Bt_bt(), scale_uniform(), scale_back_uniform(), expit(),
cal_jacobian_logit_uniform()) are deprecated. They still work and warn
once per session; options(spDBL.warn_deprecated = FALSE) silences them.gen_ran_matrix() now scales by the largest absolute entry, so its entries
stay in [-1, 1] as documented.calibration_prepare() now propagates it
by default (design_uncertainty = TRUE): at each time the field covariance
gains the design GP's error through each coefficient draw, including the
correlation between design columns and between spatial blocks. Both Stan
programs, the R reference densities, calibration_fit() and
calibration_predict() use it. Predicting held-out runs of a 20 x 20 SIR
model, pointwise 95% intervals covered 54% of outputs before and 94% after.
design_uncertainty = FALSE restores the 1.1.1 behaviour, and objects
prepared by 1.1.1 keep it. The recorded result in vignette("calibration")
was regenerated. Design-row errors are still treated as independent across
times (see vignette("calibration-details")).predict() for fitted emulators and prepared calibration objects gains
interval = "prediction" and level. It returns pointwise predictive
means, standard deviations and central intervals: Student-t given known
autoregressive rows, and, for prediction without simulator runs, the
equal-weight mixture over emulator draws (with the design-GP variance)
summarised by its moments. Tests compare it with Monte Carlo from the
package's samplers. The benchmarks now use it.BS_bigdata_R() runs the backward
pass over the files written by FF_bigdata_R(), and
FFBS_predict_bigdata_R() predicts at new inputs block by block. Both
match the in-memory BS() and FFBS_predict_exact(). FF_bigdata_R()
now checks the design file's width to find lag-2 columns instead of
silently ignoring read errors.print(), summary() and predict() methods for fitted emulators. The
summary reports the in-sample fit of the smoothed coefficients and the
posterior mean residual variance. Prepared calibration objects gain
print() and predict().calibration_fit(checkpoint_dir = ) now resumes: a conditional fit already
saved there with the same data, settings, seed and Stan program is reused
instead of refitted, so an interrupted calibration continues where it
stopped. Fits saved with other settings are refitted.emulator_learn(keep_draws = FALSE) (and the same argument of
FFBS_sampling() and FFBS_sampling_sigma2R()) stores, instead of every
episode's coefficient draws, where each episode's draws start in the
random-number stream, and regenerates identical draws when prediction or
calibration needs them. On a 20 x 20 grid with 20 draws the emulator
shrinks from 197 to 71 MB, the prepared calibration input from 152 to 45 MB,
and the peak memory of fitting halves; simulator-free prediction takes
3.1 s instead of 1.9 s for 50 inputs. All results are identical to stored
draws. Marginal sampling only; joint draws are always stored.calibration_fit(parallel_draws = ) runs that many conditional fits (one
per emulator draw) at the same time in forked processes (Linux and macOS),
so wall time falls roughly in proportion on machines with spare cores.
Each forked fit runs its chains one after another, so parallel_draws
processes run at once. With a multithreaded BLAS (oneMKL, OpenBLAS), start R
with OMP_NUM_THREADS=1: forked processes can otherwise hang on the BLAS
thread pool, and calibration_fit() warns when it detects this setup. Results are identical to running the fits one
after another: each fit draws all its random numbers from its own seeds,
and rstan's draws do not depend on the number of cores. Convergence
warnings are raised after all fits finish.calibration_fit(init = ) sets the chains' starting values: "mode" (the
new default, see above), "random" (uniform within the bounds, reproducible
from seed), "midpoint", or a vector of parameter values.setup$seed, setup$spDBL_version), prepared
calibration objects (seed, spDBL_version) and calibration fits
(settings$spDBL_version, with settings$seed) record the seed and the
spDBL version that produced them.prepare_data() keeps a one-row matrix when only one run goes to the
training or test set, and stops with a clear message if prop_train
leaves either set empty.delta was accepted but ignored by the filters,
smoothers and predictors. Values other than 1 now give a warning; results
are unchanged. (The samplers already required delta = 1.)generate.grid.rowsnake() and generate.grid.lr() returned overlapping
blocks when the grid had a single block, and left rows uncovered when the
blocks spanned the full width. They now compute each block directly; the
output is unchanged wherever it was a valid partition, including the calls
made by emulator_learn() and emulator_predict().verbose = TRUE no longer fails on short series: FF() with one time
step, FF_sigma2R() and FF_I() with fewer than five, and
FFBS_sampling_I() with fewer than three.FFBS_sampling_I() no longer reads past the end of a time-varying G_ls
list. It never used G_ls, F_ls or delta; they are kept for
compatibility. It also handles a single coefficient row or column.gen_pde() sizes the ODE solver's work array by grid size instead of
requesting a fixed 1.6 GB. Results are identical.gen_Jt() no longer adds the nugget to the cross-covariance when a new
input equals a training input.update_y_eta(), update_y_eta_one() and update_muSigma_eta_one() use
the input-GP prior variance gp_sigma2 + gp_tau2, not 1, so the predictive
variance cannot go negative near a training input.
update_muSigma_eta_one() uses the selected variance draw, like
update_y_eta_one().cal_jacobian_logit_uniform() skips fixed coordinates (equal bounds)
rather than coordinates equal to zero.quick_heat(),
quick_save(), plot_panel_heatmap_9() and its variants), which now say
which package to install. deSolve and ReacTran also move to Suggests: only
the demonstration SIR simulator (SIR(), gen_pde()) uses them.
magrittr, invgamma, LaplacesDemon and matrixcalc
are no longer used; their inverse-gamma draws, traces, log determinants and
positive-definiteness check are computed in base R with the same
definitions, so results are unchanged.crossprod() (symmetric by
construction, so the explicit re-symmetrising copy is gone) and adds the
noise with add_diag(), and the programs are compiled with stanc's O1
optimisations. Log densities and gradients agree with the previous program
to 1e-12. Cached models from earlier versions are recompiled once.predict(cal, newdata, interval = "prediction")) are about 40 times faster: the design-GP rows and input-GP
terms are computed once per new input and the coefficient terms once per
emulator draw, instead of once per input and draw. On a 20 x 20 grid with
20 emulator draws, 50 new inputs take 1.9 s instead of 74 s. Results are
unchanged (to 1e-14). recover_from_EP_exact() with block_cols binds
episode blocks directly instead of through a data frame, which also speeds
up predict_calibration() and calibration_validate().emulator_predict() on a prepared calibration object and
calibration_validate() loop over coefficient draws first, which reuses
each draw's cached residual weights. Results are identical.covr). New
tests check the filters, smoothers, samplers, log predictive densities,
out-of-core filtering, grid utilities, plotting, legacy helpers, and the
calibration back end against independent calculations. The RStan back-end
logic is also tested with a fake rstan, so it runs without compiling Stan.
Suggests now requires testthat >= 3.3.2.SPDX-License-Identifier: MIT), checked in CI.citation("spDBL") also cites the software itself.R CMD check on macOS, Windows, and Ubuntu (R devel,
release, previous release); test coverage including the RStan integration
tests; license-header check; pkgdown website.Calibration accepts a positive-definite discrepancy covariance scale U
with non-unit diagonal, preserving the original research experiment's
discrepancy-to-observation variance ratio.
Default emulator coefficient sampling to smoothed marginals conditional on a shared covariance draw. Add sampling = "joint" for coherent backward paths under both scalar-variance and inverse-Wishart covariance models.
Let calibration preparation inherit or explicitly change the fitted sampling method, with sampling metadata retained in saved objects and fit summaries.
Default calibration to one chain, one iteration, zero warmup, and one retained sample per emulator draw. Longer iterations and other controls remain options; warmup, retained-sample counts, and default controls adapt to the settings.
Default the installed reproduction script to the marginal oneiter500 profile; update the vignettes and recorded example to these defaults.