# simulate.ppm

##### Simulate a Fitted Gibbs Point Process Model

Generates simulated realisations from a fitted Gibbs or Poisson point process model.

##### Usage

```
## S3 method for class 'ppm':
simulate(object, nsim=1, ...,
singlerun = FALSE,
start = NULL,
control = default.rmhcontrol(object),
project=TRUE, new.coef=NULL,
verbose=FALSE, progress=(nsim > 1))
```

##### Arguments

- object
- Fitted point process model.
An object of class
`"ppm"`

. - nsim
- Number of simulated realisations.
- singlerun
- Logical. Whether to generate the simulated realisations
from a single long run of the Metropolis-Hastings algorithm
(
`singlerun=TRUE`

) or from separate, independent runs of the algorithm (`singlerun=FALSE`

, the default). - start
- Data determining the initial state
of the Metropolis-Hastings algorithm. See
`rmhstart`

for description of these arguments. Defaults to`list(n.start=npoints(data.ppm(model)))`

me - control
- Data controlling the running of
the Metropolis-Hastings algorithm. See
`rmhcontrol`

for description of these arguments. - ...
- Further arguments passed to
`rmhcontrol`

, or to`rmh.default`

, or to covariate functions in the model. - project
- Logical flag indicating what to do if the fitted model is
invalid (in the sense that the values of the fitted coefficients do not
specify a valid point process).
If
`project=TRUE`

the closest valid model will be simulated; if - verbose
- Logical flag indicating whether to print progress reports
from
`rmh.ppm`

during the simulation of each point pattern. - progress
- Logical flag indicating whether to print progress reports for the sequence of simulations.
- new.coef
- New values for the canonical parameters of the model.
A numeric vector of the same length as
`coef(model)`

.

##### Details

This function is a method for the generic function
`simulate`

for the class `"ppm"`

of fitted
point process models.
Simulations are performed by `rmh.ppm`

.

If `singlerun=FALSE`

(the default), the simulated patterns are
the results of independent runs of the Metropolis-Hastings
algorithm. If `singlerun=TRUE`

, a single long run of the
algorithm is performed, and the state of the simulation is saved
every `nsave`

iterations to yield the simulated patterns.

In the case of a single run, the behaviour is controlled
by the parameters `nsave,nburn,nrep`

. These
are described in `rmhcontrol`

. They may be passed
in the `...`

arguments or included in `control`

.
It is sufficient to specify two
of the three parameters `nsave,nburn,nrep`

.

##### Value

- A list of length
`nsim`

containing simulated point patterns (objects of class`"ppp"`

). It also belongs to the class`"listof"`

, so that it can be plotted, and the class`"timed"`

, so that the total computation time is recorded.

##### See Also

##### Examples

```
<testonly>op <- spatstat.options(rmh.nrep=10)</testonly>
fit <- ppm(japanesepines, ~1, Strauss(0.1))
simulate(fit, 2)
simulate(fit, 2, singlerun=TRUE, nsave=1e4, nburn=1e4)
<testonly>spatstat.options(op)</testonly>
```

*Documentation reproduced from package spatstat, version 1.36-0, License: GPL (>= 2)*