SpaceTimeBSS (version 0.3-0)

lacov: Local Autocovariance Matrices

Description

Computation of local autocovariance matrices for a multivariate space-time dataset based on a given set of spatio-temporal kernel functions.

Usage

lacov(x, coords, time, kernel_type, kernel_parameters, 
      lags, kernel_list = NULL, center = TRUE)

Value

lacov returns a list of length K where each entry is a numeric matrix of dimension c(p, p) corresponding to a local autocovariance matrix.

Arguments

x

either a numeric matrix of dimension c(n, p) where the p columns correspond to the entries of the space-time random field and the n rows are the observations.

coords

a numeric matrix of dimension c(n,2) where each row represents the spatial coordinates of the corresponding observation over a 2D spatial domain.

time

a numeric vector of length n where each entry represents the temporal coordinate of the corresponding observation.

kernel_type

either a string or a string vector of length K (or 1) indicating which spatio-temporal kernel function to use. Implemented choices are 'ring', 'ball' or 'gauss'.

kernel_parameters

a numeric vector of length K (or 1) for the 'ball' and 'gauss' kernel function or a list of length K (or 1) for the 'ring' kernel, see details.

lags

an integer vector of length K (or 1) that provides the temporal lags for the spatio-temporal kernel functions, see details.

kernel_list

a list of spatio-temporal kernel matrices with dimension c(n,n), see details. Usually computed by the function stkmat.

center

logical. If TRUE the data x is centered prior computing the local covariance matrices. Default is TRUE.

Details

Local autocovariance matrices are defined by $$ LACov(f) = 1/(n F_{f,n}) \sum_{i,j} f(s_i-s_j,t_i-t_j) (x(s_i,t_i)-\bar{x}) (x(s_j,t_j)-\bar{x})',$$ with $$ F^2_{f,n} = 1 / n \sum_{i,j} f^2(s_i-s_j,t_i-t_j).$$ Here, \(x(s_i,t_i)\) are the p random field values at location \(s_i,t_i\), \(\bar{x}\) is the sample mean vector, and the space-time kernel function \(f\) determines the locality. The following kernel functions are implemented and chosen with the argument kernel_type:

• 'ring': the spatial parameters are inner radius \(r_i\) and outer radius \(r_o\), with \(r_i < r_o\), and \(r_i, r_o \ge 0\), the temporal parameter is the temporal lag \(u\): $$f(d_s,d_t) = I(r_i < d_s \le r_o)I(d_t = u)$$

• 'ball': the spatial parameter is the radius \(r\), with \(r \ge 0\), the temporal parameter is the temporal lag \(u\): $$f(d_s,d_t) = I(d_s \le r)I(d_t = u)$$

• 'gauss': Gaussian function where 95% of the mass is inside the spatial parameter \(r\), with \(r \ge 0\), the temporal parameter is the temporal lag \(u\): $$f(d_s,d_t) = exp(-0.5 (\Phi^{-1}(0.95) d_s/r)^2)I(d_t = u)$$

Above, \(I()\) represents the indicator function. The argument kernel_type determines the used kernel function as presented above, the argument lags provides the used temporal lags for the kernel functions (\(u\) in the above formulas) and the argument kernel_parameters gives the spatial parameters for the kernel function. Each of the arguments kernel_type, lags and kernel_parameters can be of length K or 1. Specifically, kernel_type can be either one kernel, then each local autocovariance matrix use the same kernel type, or of length K which leads to different kernel functions for the provided kernel parameters. lags can be either one integer, then for each kernel the same temporal lag is used, or an integer vector of length K which leads to different temporal lags. In the same fashion kernel_parameters is a vector of length K or 1. If kernel_type equals 'ball' or 'gauss' then the corresponding entry of kernel_parameters gives the single spatial radius parameter. In contrast, if (at least one entry of) kernel_type equals 'ring', then kernel_parameters must be a list of length K (or 1) where each entry is a numeric vector of length 2 defining the inner and outer spatial radius. See examples below.

Alternatively, a list of kernel matrices can be given directly to the function lacov through the kernel_list argument. A list with kernel matrices can be computed with the function stkmat.

References

Muehlmann, C., De Iaco, S. and Nordhausen, K. (2023), Blind Recovery of Sources for Multivariate Space-Time Environmental Data. Stochastic and Environmental Research and Risk Assessment, 37, 1593--1613, <doi:10.1007/s00477-022-02348-2>.

See Also

stkmat, stbss

Examples

# space and time coordinates
n_t <- 50
n_sp <- 10
st_coords <- as.matrix(expand.grid(1:n_sp, 1:n_sp, 1:n_t))

# simulate three latent white noise fields
field_1 <- rnorm(nrow(st_coords))
field_2 <- rnorm(nrow(st_coords))
field_3 <- rnorm(nrow(st_coords))

# compute the observed field
latent_field <- cbind(field_1, field_2, field_3)
mixing_matrix <- matrix(rnorm(9), 3, 3)
observed_field <- latent_field 

# lacov with different ring kernels and same lags
lacov_r <- lacov(observed_field, coords = st_coords[, 1:2], time = st_coords[, 3], 
                 kernel_type = 'ring', 
                 kernel_parameters = list(c(0, 1), c(1, 2)), lags = 1)

# lacov with same ball kernels and different lags
lacov_b <- lacov(observed_field, coords = st_coords[, 1:2], time = st_coords[, 3], 
                 kernel_type = 'ball', kernel_parameters = 1, lags = c(1, 2, 3))

# lacov with different gauss kernels and different lags
lacov_g <- lacov(observed_field, coords = st_coords[, 1:2], time = st_coords[, 3], 
                 kernel_type = 'gauss', kernel_parameters = 1, lags = 1:3)

# lacov mixed kernels
lacov_m <- lacov(observed_field, coords = st_coords[, 1:2], time = st_coords[, 3], 
                 kernel_type = c('ball', 'ring', 'gauss'), 
                 kernel_parameters = list(1, c(1:2), 3), lags = 1:3)

# lacov with a kernel list
kernel_list <- stkmat(coords = st_coords[, 1:2], time = st_coords[, 3], 
                      kernel_type = 'ring', 
                      kernel_parameters = list(c(0, 1)), lags = 1)
lacov_k <- lacov(observed_field, kernel_list = kernel_list)