# rThomas

##### Simulate Thomas Process

Generate a random point pattern, a realisation of the Thomas cluster process.

##### Usage

```
rThomas(kappa, scale, mu, win = owin(c(0,1),c(0,1)),
nsim=1, drop=TRUE,
saveLambda=FALSE, expand = 4*scale, ...,
poisthresh=1e-6, saveparents=TRUE)
```

##### Arguments

- kappa
Intensity of the Poisson process of cluster centres. A single positive number, a function, or a pixel image.

- scale
Standard deviation of random displacement (along each coordinate axis) of a point from its cluster centre.

- mu
Mean number of points per cluster (a single positive number) or reference intensity for the cluster points (a function or a pixel image).

- win
Window in which to simulate the pattern. An object of class

`"owin"`

or something acceptable to`as.owin`

.- nsim
Number of simulated realisations to be generated.

- drop
Logical. If

`nsim=1`

and`drop=TRUE`

(the default), the result will be a point pattern, rather than a list containing a point pattern.- saveLambda
Logical. If

`TRUE`

then the random intensity corresponding to the simulated parent points will also be calculated and saved, and returns as an attribute of the point pattern.- expand
Numeric. Size of window expansion for generation of parent points. Has a sensible default.

- …
Passed to

`clusterfield`

to control the image resolution when`saveLambda=TRUE`

and to`clusterradius`

when`expand`

is missing.- poisthresh
Numerical threshold below which the model will be treated as a Poisson process. See Details.

- saveparents
Logical value indicating whether to save the locations of the parent points as an attribute.

##### Details

This algorithm generates a realisation of the (`modified')
Thomas process, a special case of the Neyman-Scott process,
inside the window `win`

.

In the simplest case, where `kappa`

and `mu`

are single numbers, the algorithm
generates a uniform Poisson point process of “parent” points
with intensity `kappa`

. Then each parent point is
replaced by a random cluster of “offspring” points,
the number of points per cluster being Poisson (`mu`

)
distributed, and their
positions being isotropic Gaussian displacements from the
cluster parent location. The resulting point pattern
is a realisation of the classical
“stationary Thomas process” generated inside the window `win`

.
This point process has intensity `kappa * mu`

.

The algorithm can also generate spatially inhomogeneous versions of the Thomas process:

The parent points can be spatially inhomogeneous. If the argument

`kappa`

is a`function(x,y)`

or a pixel image (object of class`"im"`

), then it is taken as specifying the intensity function of an inhomogeneous Poisson process that generates the parent points.The offspring points can be inhomogeneous. If the argument

`mu`

is a`function(x,y)`

or a pixel image (object of class`"im"`

), then it is interpreted as the reference density for offspring points, in the sense of Waagepetersen (2007). For a given parent point, the offspring constitute a Poisson process with intensity function equal to`mu * f`

, where`f`

is the Gaussian probability density centred at the parent point. Equivalently we first generate, for each parent point, a Poisson (`mumax`

) random number of offspring (where \(M\) is the maximum value of`mu`

) with independent Gaussian displacements from the parent location, and then randomly thin the offspring points, with retention probability`mu/M`

.Both the parent points and the offspring points can be spatially inhomogeneous, as described above.

Note that if `kappa`

is a pixel image, its domain must be larger
than the window `win`

. This is because an offspring point inside
`win`

could have its parent point lying outside `win`

.
In order to allow this, the simulation algorithm
first expands the original window `win`

by a distance `expand`

and generates the Poisson process of
parent points on this larger window. If `kappa`

is a pixel image,
its domain must contain this larger window.

The intensity of the Thomas process is `kappa * mu`

if either `kappa`

or `mu`

is a single number. In the general
case the intensity is an integral involving `kappa`

, `mu`

and `f`

.

The Thomas process with homogeneous parents
(i.e. where `kappa`

is a single number)
can be fitted to data using `kppm`

.
Currently it is not possible to fit the Thomas model
with inhomogeneous parents.

If the pair correlation function of the model is very close
to that of a Poisson process, deviating by less than
`poisthresh`

, then the model is approximately a Poisson process,
and will be simulated as a Poisson process with intensity
`kappa * mu`

, using `rpoispp`

.
This avoids computations that would otherwise require huge amounts
of memory.

##### Value

A point pattern (an object of class `"ppp"`

) if `nsim=1`

,
or a list of point patterns if `nsim > 1`

.

Additionally, some intermediate results of the simulation are returned
as attributes of this point pattern (see
`rNeymanScott`

). Furthermore, the simulated intensity
function is returned as an attribute `"Lambda"`

, if
`saveLambda=TRUE`

.

##### References

Diggle, P. J., Besag, J. and Gleaves, J. T. (1976)
Statistical analysis of spatial point patterns by
means of distance methods. *Biometrics* **32** 659--667.

Thomas, M. (1949) A generalisation of Poisson's binomial limit for use
in ecology. *Biometrika* **36**, 18--25.

Waagepetersen, R. (2007)
An estimating function approach to inference for
inhomogeneous Neyman-Scott processes.
*Biometrics* **63**, 252--258.

##### See Also

`rpoispp`

,
`rMatClust`

,
`rCauchy`

,
`rVarGamma`

,
`rNeymanScott`

,
`rGaussPoisson`

,
`kppm`

,
`clusterfit`

.

##### Examples

```
# NOT RUN {
#homogeneous
X <- rThomas(10, 0.2, 5)
#inhomogeneous
Z <- as.im(function(x,y){ 5 * exp(2 * x - 1) }, owin())
Y <- rThomas(10, 0.2, Z)
# }
```

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