emulatorDefaults.RdemulatorControl (a module parameter) overrides any of these by name.
emulatorDefaults()a named list:
designPerParam (20): the space-filling design (maximin Latin hypercube, lhs::maximinLHS()) has this many
points per parameter, each evaluated once;
designRepPoints (4), designReps (6): that many of the design points are evaluated designReps times
more, so the GP sees the noise away from the optimum;
globalMaxEvals (1000), maxEvals (1600): the budget of real evaluations of the global phase, and of both
phases together;
minEvals (600): the global phase does not stop for lack of improvement before this many evaluations;
globalWindow (6), relTol (0.002): the global phase stops when the GP's best mean (at an evaluated point)
improved by less than relTol times itself over its last globalWindow batches (the prototype: 2 objective
units at ~938);
batchSize (NULL): evaluations per batch; NULL is the cluster's number of workers, or 48 without one;
floorFrac (0.8), globalCapRatio (10), localCapRatio (1.18): the GP models
log(min(y, cap) - floorFrac * min(y)), with cap globalCapRatio times the best value seen in the global
phase and localCapRatio times the GP's best mean in the local phase, so failures (the objective's fail
value, and runaway sets scored in the millions) sit on a plateau instead of dominating the fit;
nCandidates (4000), nPerturb (3000), perturbSD (c(0.005, 0.015, 0.04, 0.1)), nTop (20): each batch
is chosen from nCandidates Latin-hypercube points (in the trust region in the local phase) and nPerturb
Gaussian perturbations, at each perturbSD (unit-cube scale), of the nTop best points by GP mean;
exclusion (0.25): batch members are at least this far apart in lengthscale units;
lcbSD (2): the exploration picks minimise the GP mean minus this many standard deviations;
logSpanMin (20): the search space (emulatorSpace()) puts a parameter on a signed log1p scale when one of
its bounds is 0 and the other is at least this far from 0; the others are linear;
the local phase, trust-region rounds of trustRoundBatches (2) batches each: the region is the box around
the best localTopFrac (0.1) of all distinct evaluated points by GP mean, widened by localWiden (0.5) of
its width each side, times the round's scale (emulatorTrustBox()). After each round (emulatorTrustStep()),
an improvement of the GP's best mean by more than trustTolSD (1) times the objective's noise SD
(emulatorNoiseSD()), and by more than relTol times the best mean (the floor while there are few or no
replicates near it), is a success, else
a failure; trustSuccessTol (1) successes in a row multiply the scale by trustShrink (0.5), unless the
GP's best point after the round lies in the box's widened margin (emulatorAtBoxEdge()): the region then
held the search back, so it keeps its scale. A failure multiplies it by trustExpand (1.25, at most 1), and
trustFailureTol (2) failures in a row stop
the search. It also stops when the region's widest side is narrower than trustMinWidth (0.01 of the unit
cube; not relative to the GP's lengthscales, which reach their upper bound when the local cap flattens the
response), or at maxEvals;
popPoolFrac (0.2), popMinDist (1): the starting population is picked from the best popPoolFrac of the
distinct evaluated points (by their mean value; at least NP of them), best first, skipping a point closer
than popMinDist GP lengthscales to one already picked, the distance halved until NP are picked
(emulatorSpreadPopulation()), so separate good regions are all in it;
thetaBounds (c(0.01, 5)), gpMaxit (200), gpThreads (6): the GP's lengthscale bounds (unit cube),
optimiser iterations (hetGP::mleHetGP()) and BLAS threads (the rest of the search runs on one);
gpMaxPoints (400), gpBestFrac (0.5): the GP is fitted to at most gpMaxPoints evaluations, because
a fit costs seconds at 200 points and over a minute at 1,000, with the workers idle. The best distinct points
by mean value (all their replicates) fill gpBestFrac of them, the rest are the evaluated points farthest
from those already kept (emulatorTrainRows()). Inf fits every evaluation (the behaviour before this
setting); batch choice and the starting population still look at all of them.