NCL Home > Documentation > Functions > Empirical orthogonal functions

eofunc_ts_n

Calculates the time series of the amplitudes associated with each eigenvalue in an EOF, given an index that specifies the time dimension.

Available in version 6.4.0 and later.

Prototype

	function eofunc_ts_n (
		data    : numeric,  
		evec    : numeric,  
		optETS  : logical,  
		dim [1] : integer   
	)

	return_val  :  numeric

Arguments

data

A multi-dimensional array in which the dim index specifies the dimension that contains the number of observations. Generally, this is the time dimension.

evec

A multi-dimensional array containing the EOFs calculated using eofunc_n.

optETS

A logical variable to which various optional arguments may be assigned as attributes. These optional arguments alter the default behavior of the function. Must be set to True prior to setting the attributes which are assigned using the @ operator:

jopt - integer (default is 0)
```
optETS      = True
optETS@jopt = 1
```
optETS@jopt = 1: Use the standardized data matrix to compute the time series. The default is to use data and evec

dim

The dimension index of data that represents the dimension containing the number of observations. Generally, this is the time dimension.

Return value

A two-dimensional array dimensioned by the number of eigenvalues selected in eofunc_n by the size of the time dimension of data. Will contain the following attribute:

ts_mean: an array of the same size and type as evec containing the means removed from data as part of the calculation.

This attribute can be accessed using the @ operator:

print(return_val@ts_mean)

Description

This function is identical to eofunc_ts, except it has an extra dim argument that allows you to specify which dimension index is the "time" dimension. This keeps you from having to unnecessarily reorder the data to force "time" to be the rightmost dimension.

This function calculates the time series of the amplitudes associated with each eigenvalue in an EOF. These amplitudes are also called principal components, expansion coefficients, scores, etc. They are derived via the dot product of the data and the EOF spatial patterns. The mean is subtracted from the value of each component time series.

Use the eofunc_ts_n_Wrap function if metadata retention is desired. The interface is identical.

To test the EOF time series for orthogonality, compute correlations. If neval=3 then

  r01 = escorc(eof_ts(0,:), eof_ts(1,:))
  r12 = escorc(eof_ts(1,:), eof_ts(2,:))
  r02 = escorc(eof_ts(0,:), eof_ts(2,:))
  print("r01="+r01+"  r12="+r12+"  r02="+r02)   ; numbers may be +/- 1e-8

Examples

Example 1

Let x be two-dimensional with dimensions "variables" (size = nvar) and "time". Commonly, 'x' contains anomalies.

  neval  = 3                         ; calculate 3 EOFs out of 7 
  ev     = eofunc_n(x,neval,False,1)   ; ev(neval,nvar)
  
  option      = True
  option@jopt = 1                    ; use correlation matrix
  ev_cor = eofunc_n(x,neval,option,1)  ; ev_cor(neval,nvar)

  ev_ts = eofunc_ts_n(x,ev_cor,False,1)

  ; Use eofunc_ts_n_Wrap if metadata retention is desired
  ; ev_ts = eofunc_ts_n_Wrap(x,ev_cor,False,1)

Example 2

Let x be three-dimensional with dimensions of time, lat, lon:

  neval  = nvar                                  ; calculate all EOFs 
  ev     = eofunc_n(y,neval,False,0)    ; 0=index of time dimension
  ; ev(neval,nlat,nlon)
  ev_ts = eofunc_ts_n(y,ev,False,0)

  ; Use eofunc_ts_n_Wrap if metadata retention is desired
  ; ev_ts = eofunc_ts_n_Wrap(y,ev,False,0)

Example 3

Let z be four-dimensional with dimensions time, lev, lat, lon:

  neval  = 3                       ; calculate 3 EOFs out of klev*nlat*mlon 
  ev     = eofunc_n(z,neval,False,0)
; ev will be dimensioned neval, level, lat, lon
  ev_ts = eofunc_ts_n(z,ev,False,0)

  ; Use eofunc_ts_n_Wrap if metadata retention is desired
  ; ev_ts = eofunc_ts_n_Wrap(z,ev,False,0)

Example 4

Calculate the EOFs at every other lat/lon point:

  neval  = 5                          ; calculate 5 EOFs out of nlat*mlon 
  ev     = eofunc_n(z(:,::2,::2),neval,False,0)   ; ev(neval,nlat/2,mlon/2)
  ev_ts  = eofunc_ts_n(z,ev,False,0)

  ; Use eofunc_ts_n_Wrap if metadata retention is desired
  ; ev_ts  = eofunc_ts_n_Wrap(z,ev,False,0)

Example 5

Let z be four-dimensional with dimensions level, lat, lon, time. Calculate the EOFs at one specified level:

  kl     = 3                               ; specify level
  neval  = 8                               ; calculate 8 EOFs out of nlat*mlon 
  ev     = eofunc_n(z(kl,:,:,:),neval,False,3)  
; ev will be dimensioned neval, lat, lon 

  optETS      = True
  optETS@jopt = 1
  ev_rot = eofunc_ts_n(z,ev,optETS,3)

  ; Use eofunc_ts_n_Wrap if metadata retention is desired
  ; ev_rot = eofunc_ts_n_Wrap(z,ev,optETS,3)

Example 6

Let z be four-dimensional with dimensions time, lev, lat, lon. Calculate on one specified level:

  kl     = 3                             ; specify level
  neval  = 8                             ; calculate 8 EOFs out of nlat*mlon 
  ev     = eofunc_n(z(:,kl,:,:),neval,False,0)  
  ev_ts  = eofunc_ts_n(z,ev,False,0)

  ; Use eofunc_ts_n_Wrap if metadata retention is desired
  ; ev_ts  = eofunc_ts_n_Wrap(z,ev,False,0)

Example 7

Area-weight the data prior to calculation. Let p be three-dimensional with dimensions time x lat x lon. The array lat contains the latitudes.