SpaDES logo

This package allows implementation a variety of simulation-type models, with a focus on spatially explicit models. The core simulation components are built upon a discrete event simulation framework that facilitates modularity, and easily enables the user to include additional functionality by running user-built simulation modules. Included are numerous tools to visualize various spatial data formats, as well as non-spatial data. Much work has been done to speed up the core of the DES, with current benchmarking as low as 700 microseconds overhead for each event (including queuing, sorting, spawning event etc.).

Bug reports: https://github.com/PredictiveEcology/SpaDES.core/issues

Module repository: https://github.com/PredictiveEcology/SpaDES-modules

Wiki: https://github.com/PredictiveEcology/SpaDES/wiki

------------------------------------------------------------------------------------------

1 Spatial discrete event simulation (SpaDES)

A collection of top-level functions for doing spatial discrete event simulation.

1.1 Simulations

There are two workhorse functions that initialize and run a simulation, and third function for doing multiple spades runs:
simInitInitialize a new simulation
spadesRun a discrete event simulation
experimentRun multiple spades calls
simInit

1.2 Events

Within a module, important simulation functions include:
scheduleEventSchedule a simulation event
removeEventRemove an event from the simulation queue (not yet implemented)
scheduleEvent

2 The simList object class

The principle exported object class is the simList. All SpaDES simulations operate on this object class.

simListThe 'simList' class
simList

------------------------------------------------------------------------------------------

3 simList methods

Collections of commonly used functions to retrieve or set slots (and their elements) of a simList object are summarized further below.

3.1 Simulation parameters

globalsList of global simulation parameters.
paramsNested list of all simulation parameter.
PNamespaced version of params (i.e., do not have to specify module name).
globals

3.2 loading from disk, saving to disk

inputsList of loaded objects used in simulation. (advanced)
outputsList of objects to save during simulation. (advanced)
inputs

3.3 objects in the simList

ls, objectsNames of objects referenced by the simulation environment.
ls.strList the structure of the simList objects.
objsList of objects referenced by the simulation environment.
ls, objects

3.4 Simulation paths

Accessor functions for the paths slot and its elements.
cachePathGlobal simulation cache path.
modulePathGlobal simulation module path.
inputPathGlobal simulation input path.
outputPathGlobal simulation output path.
pathsGlobal simulation paths (cache, modules, inputs, outputs).
cachePath

3.5 Simulation times

Accessor functions for the simtimes slot and its elements.
timeCurrent simulation time, in units of longest module.
startSimulation start time, in units of longest module.
endSimulation end time, in units of longest module.
timesList of all simulation times (current, start, end), in units of longest module..
time

3.6 Simulation event queues

Accessor functions for the events and completed slots. By default, the event lists are shown when the simList object is printed, thus most users will not require direct use of these methods.
eventsScheduled simulation events (the event queue). (advanced)
currentCurrently executing event. (advanced)
completedCompleted simulation events. (advanced)
events

3.7 Modules, dependencies, packages

Accessor functions for the depends, modules, and .loadOrder slots. These are included for advanced users.
dependsList of simulation module dependencies. (advanced)
modulesList of simulation modules to be loaded. (advanced)
packagesVector of required R libraries of all modules. (advanced)
depends

3.8 simList environment

The simList has a slot called .envir which is an environment. All objects in the simList are actually in this environment, i.e., the simList is not a list. In R, environments use pass-by-reference semantics, which means that copying a simList object using normal R assignment operation (e.g., sim2 <- sim1), will not copy the objects contained within the .envir slot. The two objects (sim1 and sim2) will share identical objects within that slot. Sometimes, this not desired, and a true copy is required.
envirAccess the environment of the simList directly (advanced)
copyDeep copy of a simList. (advanced)
envir

3.9 Checkpointing

Accessor methodModuleDescription
checkpointFile.checkpointName of the checkpoint file. (advanced)
checkpointInterval.checkpointThe simulation checkpoint interval. (advanced)
Accessor methodModule

3.10 Progress Bar

progressType.progressType of graphical progress bar used. (advanced)
progressInterval.progressInterval for the progress bar. (advanced)
progressType.progress

------------------------------------------------------------------------------------------

4 Module operations

4.1 Creating, distributing, and downloading modules

Modules are the basic unit of SpaDES. These are generally created and stored locally, or are downloaded from remote repositories, including our SpaDES-modules repository on GitHub.
checksumsVerify (and optionally write) checksums for a module's data files.
downloadModuleOpen all modules nested within a base directory.
getModuleVersionGet the latest module version # from module repository.
newModuleCreate new module from template.
newModuleDocumentationCreate empty documentation for a new module.
openModulesOpen all modules nested within a base directory.
moduleMetadataShows the module metadata.
zipModuleZip a module and its associated files.
checksums

4.2 Module metadata

Each module requires several items to be defined. These comprise the metadata for that module (including default parameter specifications, inputs and outputs), and are currently written at the top of the module's .R file.
defineModuleDefine the module metadata
defineParameterSpecify a parameter's name, value and set a default
expectsInputSpecify an input object's name, class, description, sourceURL and other specifications
createsOutputSpecify an output object's name, class, description and other specifications
defineModule

4.3 Module dependencies

Once a set of modules have been chosen, the dependency information is automatically calculated once simInit is run. There are several functions to assist with dependency information:
depsEdgeListBuild edge list for module dependency graph
depsGraphBuild a module dependency graph using igraph
depsEdgeList

------------------------------------------------------------------------------------------

5 Module functions

A collection of functions that help with making modules can be found in the suggested SpaDES.tools package, and are summarized below.

5.1 Spatial spreading/distances methods

Spatial contagion is a key phenomenon for spatially explicit simulation models. Contagion can be modelled using discrete approaches or continuous approaches. Several SpaDES.tools functions assist with these:
adjAn optimized (i.e., faster) version of adjacent
cirIdentify pixels in a circle around a SpatialPoints* object
directionFromEachPointFast calculation of direction and distance surfaces
distanceFromEachPointFast calculation of distance surfaces
ringsIdentify rings around focal cells (e.g., buffers and donuts)
spokesIdentify outward radiating spokes from initial points
spreadContagious cellular automata
wrapCreate a torus from a grid
adj

5.2 Spatial agent methods

Agents have several methods and functions specific to them:
crwSimple correlated random walk function
headingDetermines the heading between SpatialPoints*
makeLinesMakes SpatialLines object for, e.g., drawing arrows
moveA meta function that can currently only take "crw"
specificNumPerPatchInitiate a specific number of agents per patch
crw

5.3 GIS operations

In addition to the vast amount of GIS operations available in R (mostly from contributed packages such as sp, raster, maps, maptools and many others), we provide the following GIS-related functions:
equalExtentAssess whether a list of extents are all equal
equalExtent

5.4 'Map-reduce'--type operations

These functions convert between reduced and mapped representations of the same data. This allows compact representation of, e.g., rasters that have many individual pixels that share identical information.
rasterizeReducedConvert reduced representation to full raster.
rasterizeReduced

5.5 Colors in Raster* objects

We likely will not want the default colours for every map. Here are several helper functions to add to, set and get colors of Raster* objects:
setColorsSet colours for plotting Raster* objects
getColorsGet colours in a Raster* objects
divergentColorsCreate a color palette with diverging colors around a middle
setColors

5.6 Random Map Generation

It is often useful to build dummy maps with which to build simulation models before all data are available. These dummy maps can later be replaced with actual data maps.
gaussMapCreates a random map using Gaussian random fields
randomPolygonsCreates a random polygon with specified number of classes
gaussMap

5.7 Checking for the existence of objects

SpaDES modules will often require the existence of objects in the simList. These are helpers for assessing this:
checkObjectCheck for a existence of an object within a simList
checkPathChecks the specified filepath for formatting consistencies
checkObject

5.8 SELES-type approach to simulation

These functions are essentially skeletons and are not fully implemented. They are intended to make translations from SELES. You must know how to use SELES for these to be useful:
agentLocationAgent location
initiateAgentsInitiate agents into a SpatialPointsDataFrame
numAgentsNumber of agents
probInitProbability of initiating an agent or event
transitionsTransition probability
agentLocation

5.9 Miscellaneous

Functions that may be useful within a SpaDES context:
inRangeTest whether a number lies within range [a,b]
layerNamesGet layer names for numerous object classes
loadPackagesSimple wrapper for loading packages
numLayersReturn number of layers
paddedFloatToCharWrapper for padding (e.g., zeros) floating numbers to character
updateListUpdate values in a named list
inRange

------------------------------------------------------------------------------------------

6 Caching simulations and simulation components

Simulation caching uses the reproducible package.

Caching can be done in a variety of ways, most of which are up to the module developer. However, the one most common usage would be to cache a simulation run. This might be useful if a simulation is very long, has been run once, and the goal is just to retrieve final results. This would be an alternative to manually saving the outputs.

See example in spades, achieved by using cache = TRUE argument.

CacheCaches a function, but often accessed as arg in spades
cachedeprecated. Please use Cache
showCacheShows information about the objects in the cache
clearCacheRemoves objects from the cache
keepCacheKeeps only the objects described
clearStubArtifactsRemoves any erroneous items in a cache repository
Cache

A module developer can build caching into their module by creating cached versions of their functions.

------------------------------------------------------------------------------------------

7 Plotting

Much of the underlying plotting functionality is provided by the quickPlot package.

There are several user-accessible plotting functions that are optimized for modularity and speed of plotting:

Commonly used:

PlotThe workhorse plotting function
Plot

Simulation diagrams:

eventDiagramGantt chart representing the events in a completed simulation.
moduleDiagramNetwork diagram of simplified module (object) dependencies.
objectDiagramSequence diagram of detailed object dependencies.
eventDiagram

Other useful plotting functions:

clearPlotHelpful for resolving many errors
clickValuesExtract values from a raster object at the mouse click location(s)
clickExtentZoom into a raster or polygon map that was plotted with Plot
clickCoordinatesGet the coordinates, in map units, under mouse click
devSpecify which device to plot on, making a non-RStudio one as default
newPlotOpen a new default plotting device
rePlotReplots all elements of device for refreshing or moving plot
clearPlot

------------------------------------------------------------------------------------------

8 File operations

In addition to R's file operations, we have added several here to aid in bulk loading and saving of files for simulation purposes:

loadFilesLoad simulation objects according to a filelist
rasterToMemoryRead a raster from file to RAM
saveFilesSave simulation objects according to outputs and params
loadFiles

------------------------------------------------------------------------------------------

9 Sample modules included in package

Several dummy modules are included for testing of functionality. These can be found with file.path(find.package("SpaDES.core"), "sampleModules").

randomLandscapesImports, updates, and plots several raster map layers
caribouMovementA simple agent-based (a.k.a., individual-based) model
fireSpreadA simple model of a spatial spread process
randomLandscapes

------------------------------------------------------------------------------------------

10 Package options

SpaDES packages use the following options to configure behaviour:

  • spades.browserOnError: 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.

  • spades.cachePath: The default local directory in which to cache simulation outputs. Default is a temporary directory (typically /tmp/RtmpXXX/SpaDES/cache).

  • spades.inputPath: The default local directory in which to look for simulation inputs. Default is a temporary directory (typically /tmp/RtmpXXX/SpaDES/inputs).

  • spades.debug: The default debugging value debug argument in spades(). Default is TRUE.

  • spades.lowMemory: If true, some functions will use more memory efficient (but slower) algorithms. Default FALSE.

  • spades.moduleCodeChecks: Should the various code checks be run during simInit. These are passed to codetools::checkUsage. Default is given by the function, plus these :list(suppressParamUnused = FALSE, suppressUndefined = TRUE, suppressPartialMatchArgs = FALSE, suppressNoLocalFun = TRUE, skipWith = TRUE).

  • spades.modulePath: The default local directory where modules and data will be downloaded and stored. Default is a temporary directory (typically /tmp/RtmpXXX/SpaDES/modules).

  • spades.moduleRepo: The default GitHub repository to use when downloading modules via downloadModule. Default "PredictiveEcology/SpaDES-modules".

  • spades.nCompleted: The maximum number of completed events to retain in the completed event queue. Default 1000L.

  • spades.outputPath: The default local directory in which to save simulation outputs. Default is a temporary directory (typically /tmp/RtmpXXX/SpaDES/outputs).

  • spades.switchPkgNamespaces: Should the search path be modified to ensure a module's required packages are listed first? Default FALSE to keep computational overhead down. If TRUE, there should be no name conflicts among package objects, but it is much slower, especially if the events are themselves fast.

  • spades.tolerance: The default tolerance value used for floating point number comparisons. Default .Machine$double.eps^0.5.

  • spades.useragent: The default user agent to use for downloading modules from GitHub.com. Default "http://github.com/PredictiveEcology/SpaDES".

See also