These provide top-level, powerful settings for a comprehensive SpaDES workflow. To see defaults, run `spadesOptions()`. See Details below.
spadesOptions()Below are options that can be set with `options("spades.xxx" = newValue)`, where `xxx` is one of the values below, and `newValue` is a new value to give the option. Sometimes these options can be placed in the user's `.Rprofile` file so they persist between sessions.
The following options are likely of interest to most users
| *OPTION* | *DEFAULT VALUE* | *DESCRIPTION* |
| `spades.browserOnError` | `FALSE` | If `TRUE`, the default, then any error rerun the same event with `debugonce` called on it to allow editing to be done. When that browser is continued (e.g., with 'c'), then it will save it reparse it into the `simList` and rerun the edited version. This may allow a `spades()` call to be recovered on error, though in many cases that may not be the correct behaviour. For example, if the `simList` gets updated inside that event in an iterative manner, then each run through the event will cause that iteration to occur. When this option is `TRUE`, then the event will be run at least 3 times: the first time makes the error, the second time has `debugonce` and the third time is after the error is addressed. `TRUE` is likely somewhat slower. |
| `reproducible.cachePath` | `getOption('reproducible.cachePath')` | The default local directory in which to cache simulation outputs. Default is a temporary directory (typically `/tmp/RtmpXXX/SpaDES/cache`). |
| `spades.debug` | `TRUE` | The default debugging value `debug` argument in `spades()` |
| `spades.DTthreads` | `1L` | The default number of data.table threads to use. See also `?data.table::setDTthreads`. |
| `spades.futureEvents` | `FALSE` | If set to `TRUE`, the event simulator will attempt to spawn events whose outputs are not needed (by other events in the sim) into a future. In some cases, this will speed up simulations, by running some events in parallel. Still VERY experimental. Use cautiously. |
| `spades.inputPath` | Default is a temporary directory (typically `/tmp/RtmpXXX/SpaDES/inputs`) | The default local directory in which to look for simulation inputs. |
| `spades.lowMemory` | `FALSE` | If true, some functions will use more memory efficient (but slower) algorithms. |
| `spades.memoryUseInterval` | `FALSE` | A numeric in seconds indicating how often sample the memory use. This will be run in a separate "future" process so it can monitor the main process. To access the resulting memory use table, use `memoryUse(sim)` after the simulation has terminated. |
| `spades.messagingNumCharsModule` | `21` | The number of characters to use for the messaging preamble on each line of the messaging during spades calls. |
| `spades.moduleCodeChecks` | `list(suppressParamUnused = FALSE, suppressUndefined = TRUE, suppressPartialMatchArgs = FALSE, suppressNoLocalFun = TRUE, skipWith = TRUE)` | Should the various code checks be run during `simInit`. These are passed to codetools::checkUsage. Default is given by the function, plus these: |
| `moduleDocument` | `NULL` | When a module is an R package e.g., via `convertToPackage`, it will not, by default, rebuild documentation during `simInit`. If the user would like this to happen on every call to `simInit`, set this option to `TRUE` |
| `spades.modulePath` | `file.path(tempdir(), "SpaDES", "modules")`) | The default local directory where modules and data will be downloaded and stored. Default is a temporary directory |
| `spades.moduleRepo` | `"PredictiveEcology/SpaDES-modules"` | The default GitHub repository to use when downloading modules via `downloadModule` |
| `spades.nCompleted` | `1000L` | The maximum number of completed events to retain in the `completed` event queue. |
| `spades.outputPath` | `file.path(tempdir(), "SpaDES", "outputs")` | The default local directory in which to save simulation outputs. |
| `spades.recoveryMode` | `1L` | If this a numeric > 0 or TRUE, then the discrete event simulator will take a snapshot of the objects in the simList that might change (based on metadata `outputObjects` for that module), prior to initiating every event. This will allow the user to be able to recover in case of an error or manual interruption (e.g., `Esc`). If this is numeric, a copy of that number of "most recent events" will be maintained so that the user can recover and restart > 1 event in the past, i.e., redo some of the "completed" events. Default is `TRUE`, i.e., it will keep the state of the `simList` at the start of the current event. This can be recovered with `restartSpades` and the differences can be seen in a hidden object in the stashed simList. There is a message which describes how to find that. |
| `spades.scratchPath` | `file.path(tempdir(), "SpaDES", "scratch")`) | The default local directory where transient files from modules and data will written. This includes temporary `raster` and `terra` files, as well as SpaDES recovery mode files. Default is a temporary directory. |
| `spades.switchPkgNamespaces` | `FALSE` to keep computational overhead down. | Should the search path be modified to ensure a module's required packages are listed first? If `TRUE`, there should be no name conflicts among package objects, but it is much slower, especially if the events are themselves fast. |
| `spades.testMemoryLeaks` | `TRUE`. | There is a very easy way to create a memory leak with R and SpaDES, by adding formulas or functions to `sim$` when the enclosing environment of the formula or function contained a large object, most relevant here is the `sim` object. SpaDES.core now tests for likely culprits for this and suggests alternatives with a warning |
| `spades.tolerance` | `.Machine$double.eps^0.5`. | The default tolerance value used for floating point number comparisons. |
| `spades.useragent` | `"https://github.com/PredictiveEcology/SpaDES"`. | : The default user agent to use for downloading modules from GitHub. |