RFMethods            package:RandomFields            R Documentation

_S_i_m_u_l_a_t_i_o_n _T_e_c_h_n_i_q_u_e_s

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

     'PrintMethodList' prints the list of currently implemented methods
     for simulating random fields

     'GetMethodNames' returns a list of currently implemented methods

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

     PrintMethodList()

     GetMethodNames()

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

        *  Boolean functions.
            See marked point processes.

        *  'circulant embedding'. 
            Introduced by Dietrich & Newsam (1993) and Wood and Chan
           (1994). 

        *  'local circulant embedding (Stein, 2000)'. 
            Here multiplicative models are not allowed (yet).

           If anisotropy then the given variance is attained as 
           variogram value at max_{u =unit vector} gamma(M u), M the
           anisotropy matrix

        *  'direct matrix decomposition'.
            This method is based on the well-known method for
           simulating any multivariate Gaussian distribution, using the
           square root of the covariance matrix.  The method is pretty
           slow and limited to about 1000 points, i.e. a 10x10x10 grid
           in three dimensions.  This implementation can use the
           Cholesky decomposition and the singular value decomposition.
            It allows for arbitrary points and arbitrary grids.

        *  Marked point processes.
            Some methods are based on marked point process P =
           ([x_1,m_1], [x_2,m_2], ...) where the marks m_i are
           deterministic or i.i.d. random functions on R^d.

           *  'add.MPP' (Random coins).
               Here the functions are elements of the intersection (L1
              cap L2) of the Hilbert spaces L1 and L2. A random field Z
              is obtained by adding the marks:

                     Z(.) = sum_i  m_i( . - x_i)

              In this package, only stationary Poisson point fields are
              allowed as underlying unmarked point processes. Thus, if
              the marks m_i are all indicator functions, we obtain a
              Poisson random field. If the intensity of the Poisson
              process is high we obtain an approximate Gaussian random
              field by the central limit theorem - this is the
              'add.mpp' method.

           *  'max.MPP' (Boolean functions).
               If the random functions are multiplied by suitable,
              independent random values, and then the maximum is taken,
              a max-stable random field with unit Frechet margins is
              obtained - this is the 'max.mpp' method.


        *  'nugget'.
            One may specify this method (and "nugget" as covariance
           function) to generate a random field of independent Gaussian
           random variables.  However, any other method and any
           covariance function, called with zero variance, generates
           also such a random field (without loss of speed).  This
           method exists mainly for reasons of internal implementation.

        *  Random coins.
            See marked point processes.

        *  'spectral TBM' (Spectral turning bands).
            The principle of 'spectral TBM' does not differ from the
           other turning bands methods.  However, line simulations are
           performed by a spectral technique (Mantoglou and Wilson,
           1982); a realisation is given as the cosine with random
           amplitude and random phase.    The implementation allows the
           simulation of 2-dimensional random fields defined on
           arbitrary points or arbitrary grids.

        *  'TBM2', 'TBM3' (Turning bands methods; turning layers).
            It is generally difficult to use the turning bands method
           ('TBM2') directly in the 2-dimensional space. Instead,
           2-dimensional random fields are frequently obtained by
           simulating a 3-dimensional random field (using 'TBM3') and
           taking a 2-dimensional cross-section. TBM3 allows for
           multiplicative models; in case of anisotropy the anisotropy
           matrices must be multiples of the first matrix or the
           anisotropy matrix consists of a time component only (i.e.
           all components are zero except the very last one).
            'TBM2' and 'TBM3' allow for arbitrary points, and arbitrary
           grids (arbitrary number of points in each direction,
           arbitrary grid length for each direction).    

           The turning layers are used for the simulations with time
           component. Here,  if the model is a multiplicative
           covariance function then the product may contain matrices
           with pure time component.  All the other matrices must be
           equal up to a factor and the temporal part of the anisotropy
           matrix (right column) may contain only zeros, except the
           very last entry.

_N_o_t_e:

     Most methods possess additional parameters, see 'RFparameters()'
     that control the precision of the result.  The default parameters
     are chosen such that the simulations are fine for many models and
     their parameters.  The example in 'EmpiricalVariogram()' shows a
     way of checking the precision.

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

     Martin Schlather, martin.schlather@cu.lu <URL:
     http://www.cu.lu/~schlathe>

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

     Gneiting, T. and Schlather, M. (2004) Statistical modeling with
     covariance functions. _In preparation._

     Lantuejoul, Ch. (2002) _Geostatistical simulation._ *New York:*
     Springer.

     Schlather, M. (1999) _An introduction to positive definite
     functions and to unconditional simulation of random fields._
     Technical report ST 99-10, Dept. of Maths and Statistics,
     Lancaster University. 

     Original work:

        *  Circulant embedding:

           Chan, G. and Wood, A.T.A. (1997) An algorithm for simulating
           stationary Gaussian random fields. _J. R. Stat. Soc., Ser.
           C_ *46*, 171-181.

           Dietrich, C.R. and Newsam, G.N. (1993) A fast and exact
           method for multidimensional Gaussian stochastic simulations.
           _Water Resour. Res._ *29*, 2861-2869.    

           Wood, A.T.A. and Chan, G. (1994) Simulation of stationary
           Gaussian processes in [0,1]^d _J. Comput. Graph. Stat._ *3*,
           409-432.

        *  Local Circulant embedding:

           Stein, M.L. (2002) Fast and exact simulation of fractional
           Brownian surfaces. {\emph J. Comput. Graph. Statist.} *11*,
           587-599.

        *  Turning bands method (TBM), turning layers:

           Dietrich, C.R. (1995) A simple and efficient space domain
           implementation of the turning bands method. _Water Resour.
           Res._ *31*, 147-156.

           Mantoglou, A. and Wilson, J.L. (1982) The turning bands
           method for simulation of random fields using line generation
           by a spectral method. _Water. Resour. Res._ *18*, 1379-1394.

           Matheron, G. (1973) The intrinsic random functions and their
           applications. _Adv. Appl. Probab._ *5*, 439-468.

           Schlather, M. (2004) Turning layers: A space-time extension
           of turning bands. _Submitted_

        *  Random coins:

           Matheron, G. (1967) _Elements pour une Theorie des Milieux
           Poreux_. Paris: Masson.

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

     'GaussRF', 'MaxStableRF', 'PrintModelList', 'RandomFields'.

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

      PrintMethodList()

