Softcore              package:spatstat              R Documentation

_T_h_e _S_o_f_t _C_o_r_e _P_o_i_n_t _P_r_o_c_e_s_s _M_o_d_e_l

_D_e_s_c_r_i_p_t_i_o_n:

     Creates an instance of the Soft Core point process model which can
     then be fitted to point pattern data.

_U_s_a_g_e:

       Softcore(kappa)

_A_r_g_u_m_e_n_t_s:

   kappa: The exponent kappa of the Soft Core interaction

_D_e_t_a_i_l_s:

     The (stationary) Soft Core point process with parameters beta and
     sigma and exponent kappa is the pairwise interaction point process
     in which  each point contributes a factor beta to the  probability
     density of the point pattern, and each pair of points contributes
     a factor

                     exp( - (sigma/d)^(2/kappa) )

     to the density, where d is the distance between the two points.

     Thus the process has probability density

 f(x_1,...,x_n) = alpha . beta^n(x) exp( - sum (sigma/||x[i]-x[j]||)^(2/kappa))

     where x[1],...,x[n] represent the  points of the pattern, n(x) is
     the number of points in the pattern, alpha is the normalising
     constant, and the sum on the right hand side is over all unordered
     pairs of points of the pattern. 

     This model describes an ``ordered'' or ``inhibitive'' process,
     with the interpoint interaction decreasing smoothly with distance.
     The strength of interaction is controlled by the parameter sigma,
     a positive real number, with larger values corresponding to
     stronger interaction; and by the exponent kappa in the range
     (0,1), with larger values corresponding to weaker interaction. If
     sigma = 0 the model reduces to the Poisson point process. If sigma
     > 0, the process is well-defined only for kappa in (0,1). The
     limit of the model as kappa -> 0 is the hard core process with
     hard core distance h=sigma.

     The nonstationary Soft Core process is similar except that  the
     contribution of each individual point x[i] is a function
     beta(x[i]) of location, rather than a constant beta. 

     The function `mpl()', which fits point process models to  point
     pattern data, requires an argument  of class `"interact"'
     describing the interpoint interaction structure of the model to be
     fitted.  The appropriate description of the Soft Core process
     pairwise interaction is yielded by the function `Softcore()'. See
     the examples below.

     Note the only argument is the exponent  `kappa'. When `kappa' is
     fixed, the model becomes an exponential family with canonical
     parameters log(beta) and 

                  log(gamma) = (2/kappa) log(sigma)

     The canonical parameters are estimated by `mpl()', not fixed in
     `Softcore()'.

_V_a_l_u_e:

     An object of class `"interact"' describing the interpoint
     interaction structure of the Soft Core process with exponent
     kappa.

_A_u_t_h_o_r(_s):

     Adrian Baddeley adrian@maths.uwa.edu.au <URL:
     http://www.maths.uwa.edu.au/~adrian/> and Rolf Turner
     rolf@math.unb.ca <URL: http://www.math.unb.ca/~rolf>

_R_e_f_e_r_e_n_c_e_s:

     Ogata, Y, and Tanemura, M. (1981). Estimation of interaction
     potentials of spatial point patterns through the maximum
     likelihood procedure. Annals of the Institute of Statistical
     Mathematics, B 33, 315-338.

     Ogata, Y, and Tanemura, M. (1984). Likelihood analysis of spatial
     point patterns. Journal of the Royal Statistical Society, series B
     46, 496-518.

_S_e_e _A_l_s_o:

     `mpl', `pairwise.family', `ppm.object'

_E_x_a_m_p_l_e_s:


        library(spatstat)

        data(cells) 
        mpl(cells, ~1, Softcore(kappa=0.5), rbord=0)
        # fit the stationary Soft Core process to `cells'

