# Lorenz95 model¶

## Introduction¶

The Lorenz95 model is an application of the Lorenz (1996) chaotic dynamics. This model is governed by \(I\) equations:

where \(i = 1, 2, \ldots, I\), with cyclic boundary conditions, and the constant \(F\) is independent of \(i\). The variables of this model may be thought of as values of some atmospheric quantity in \(I\) locations of a latitude circle. The so-called 40-variable version of this model assumes \(I=40\), with \(i = 1, 2, \ldots, 40\), which implies to the cyclic boundary conditions being defined as: \(x_{0} = x_{40}\); \(x_{-1} = x_{39}\); and, \(x_{41} = x_{1}\).

Note

This model was first presented at a Seminar on Predictability at ECMWF in 1995, with the seminar paper published in 1996. The model is also often referred to as the Lorenz96 model (for the year of publication).

## Lorenz95 model-related classes and their configuration¶

### Geometry¶

The L95 model geometry is configured with a parameter `resol`

which defines the number of variables \(I\) in (11).

For example, the geometry for the 40-variable version of the model can be configured as:

```
geometry:
resol: 40
```

### Model¶

The L95 model can be configured to specify the constant \(F\) and the time resolution of the model (for L95 this is both the model time step and the time resolution that data assimilation algorithms will observe model states with).

For example, the L95 model with \(F=8.0\) can be configured as:

```
model:
name: L95 # required to identify that Lorenz95 model will be run
f: 8.0
tstep: PT1H30M
```

Note

The equivalence between real time and the time considered for Lorenz95 is defined as a combination of the number of variables \(I\) and the constant \(F\). For the parameters listed above (\(I=40\) and \(F=8.0\)), the scaling applied makes the model time unit equal to 5 days. See details in Lorenz (1996) and Lorenz and Emanuel (1998).

It is also possible to use a *PseudoModel* with L95 (as well as with any other model interfaced with JEDI). *PseudoModel* propagates model states forward in time by reading precomputed states from files instead of running a forecast model.

For example, a PseudoModel for L95 can be configured as:

```
model:
name: PseudoModel # required to identify that PseudoModel will be used
state variables: ['x'] # required to specify which variables need to be read from files (always ['x'] for L95)
tstep: PT12H # time resolution between the states read from files
states: # list of the states to read
- date: 2010-01-01T12:00:00Z
filename: Data/test.fc.2010-01-01T00:00:00Z.PT12H
- date: 2010-01-02T00:00:00Z
filename: Data/test.fc.2010-01-01T00:00:00Z.P1D
```

### State¶

#### Reading and initializing L95 States¶

To read an L95 model state from an existing file, one needs to specify an input file to read the state from, and the valid date of the state.

For example:

```
state: # or "initial condition", or "background", depending on the application
date: 2010-01-01T00:00:00Z # valid date
filename: Data/truth.an.2010-01-01T00:00:00Z.l95 # input file name
```

To initialize an L95 state with artificially generated values, the `analytic init`

option can be used. In this case the state is generated as \(x_{i} = a + b \times sin(2 \pi (i-1) / I)\).

```
state: # or "initial condition", or "background", depending on the application
date: 2010-01-01T00:00:00Z # valid date
analytic init:
mean: 2.0 # constant "a" in the formula above; if omitted, 0.0
sinus: 1.0 # constant "b" in the formula above; if omitted, 0.0
```

#### Writing L95 States¶

To configure writing out L95 model state output (for example, forecast output or analysis output), several configuration options need to be specified: `datadir`

(output directory), `exp`

(name of the experiment), and `type`

(type of the output, valid types are: `fc`

(forecast), `an`

(analysis), `ens`

(ensemble output)). The output file names are generated using those options.

For the `fc`

type, filenames for output files are `${datadir}/${exp}.${type}.${initial condition date}.${forecast duration}`

. For the `ens`

type, filenames include ensemble member index: `${datadir}/${exp}.${type}.${ensemble member}.${initial condition date}.${forecast duration}`

. For the `an`

type, filenames for output files are: `${datadir}/${exp}.${type}.${analysis time}`

.

For example, for the following configuration of the forecast output:

```
output:
datadir: Data
exp: truth
type: fc
date: 2010-01-01T00:00:00Z # option used for all models: initial condition date
frequency: PT3H # option used for all models: frequency of output
```

states will be saved in the following files:

`Data/truth.fc.2010-01-01T00:00:00Z.PT0S`

(“forecast” at initial time),`Data/truth.fc.2010-01-01T00:00:00Z.PT3H`

,`Data/truth.fc.2010-01-01T00:00:00Z.PT6H`

,etc up to the end of the forecast length.

For the following configuration of the ensemble output:

```
output:
datadir: Data
exp: test
type: ens
date: 2010-01-01T00:00:00Z
frequency: PT1H30M
```

states will be saved in the following files:

`Data/test.ens.1.2010-01-01T00:00:00Z.PT0S`

(“forecast” at initial time for member 1),`Data/test.ens.2.2010-01-01T00:00:00Z.PT0S`

(“forecast” at initial time for member 2),`Data/test.ens.1.2010-01-01T00:00:00Z.PT1H30M`

,`Data/test.ens.2.2010-01-01T00:00:00Z.PT1H30M`

, etc.

For the following configuration of the analysis output:

```
output:
datadir: Data
exp: test
type: an
frequency: PT6H
```

the analysis will be saved in `Data/test.an.2010-01-01T06:00:00Z`

if the analysis is computed for `2010-01-01T06:00:00Z`

.

### Background error covariance¶

The background error covariance for the L95 model has a Gaussian structure: \(B(i,j) = \sigma_b^2 * exp(-\frac{1}{2} \frac{dist(i,j)}{lengthscale})\), where \(dist(i,j) = min(|i-j|, I - |i-j|)\), i.e. lengthscale is specified in units of gridpoints. The covariance lengthscale and standard deviations of background errors can be configured as:

```
background error:
covariance model: L95Error # required to identify that L95 covariance model will be used
date: 2010-01-02T00:00:00Z # required, should be the same date as the background date
length_scale: 1.0 # lengthscale in the formula above
standard_deviation: 0.6 # sigma_b in the formula above
```

### Ensemble background error covariance localization¶

The localization matrix for L95 ensemble background error covariances follows the same Gaussian structure as the background error covariances above: \(L(i,j) = exp(-\frac{1}{2} \frac{dist(i,j)}{lengthscale})\). The localization lengthscale can be configured as:

```
localization:
localization method: L95 # required to identify that L95 localization model will be used
length_scale: 1.0 # lengthscale in the formula above
```

## Lorenz95 observation-related classes and their configuration¶

The observations are always observing the state \(x\) at the specified grid locations.

### Obs space¶

Observations for L95 can be read from the file, or generated using the `make obs`

option of the HofX applications. In all applications, only observations within `(window_begin, window_begin + window_length]`

time window are used (note the `window_begin`

is not included, while `window_begin + window_length`

is).

#### Generating new obs space¶

For generating new observations with the `make obs`

option of the HofX applications, the `generate`

configuration option can be used. The following suboptions need to be specified:

`obs_frequency`

: time frequency for simulating observations,`obs_density`

: number of observations to generate in each time slot (the observations would be regularly distributed at grid point locations, e.g., for \(I = 40\) (`geometry.resol: 40`

), if`obs_density`

is set to 20, observations would be generated at every other grid point,`obs_error`

: observation error standard deviation, the same value will be assigned to all of the observations, and used in the future experiments in the observation error covariances, and for observations perturbations.

For example, to generate observations at every other gridpoint, and every 3 hours, the following configuration can be used:

```
obs space:
generate:
obs_frequency: PT3H
obs_density: 20
obs_error: 0.5
obsdataout:
engine:
obsfile: Data/test_observations.obt # optional, output file name
```

Note

Since in all of the applications only observations within `(window_begin, window_begin + window_length]`

time window are used, observations are generated for the following times: `window_begin + obs_frequency`

, `window_begin + 2 * obs_frequency`

, … up to `window_begin + window_length`

.

#### Reading observations from an existing file¶

To read observations from an existing observations file, the `obsdatain`

option needs to be specified for the input observation file name. If the `obsdataout`

option is specified, the observations, metadata, and additional diagnostics would also be output into the specified file. The output file will include everything from the input file, and everything computed and saved during the application run (e.g., `oman`

values for some data assimilation experiments).

For example, the configuration for reading observations from a file generated in the previous example may look like:

```
obs space:
obsdatain:
engine:
obsfile: Data/test_observations.obt
obsdataout:
engine:
obsfile: Data/test_observations_and_diags.obt
```

### Observation operator¶

The only kind of observations supported for the L95 model is direct observations of the state. Thus, the observation operator does not need any configuration options, and is typically configured as empty:

```
obs operator: {}
```

### Observation quality control (QC) filters¶

The background check observation QC filter can be configured to reject or give smaller weight to the observations that are too far from the background.

For rejecting observations for which \(|y - H(x)| > threshold\), the background check can be configured in the following way:

```
obs filters:
- filter: Background Check
threshold: 1.3 # threshold in the formula above
```

Alternatively, the background check can be configured to increase observation error standard deviations by a specified factor, instead of rejecting observations. An example of configuration of the QC for this case:

```
obs filters:
- filter: Background Check
threshold: 1.3
inflate obs error: 2.0 # a factor to inflate observation error standard deviations by
```

### Observation error covariance¶

Currently, only diagonal observation error covariances implemented in OOPS are supported. Observation error standard deviations for the diagonal \(R\) are read from the input observation file as the `ObsError`

field. If observations were generated using the `obs space.generate`

options described above, the value of `obs space.generate.obs_error`

will be used as observation error standard deviations.

The observation error for L95 experiments can be configured as:

```
obs error:
covariance model: diagonal # required to identify that the diagonal R is used
```

### Observation-space error covariance localization¶

LETKF applications use observation-space error covariance localization that depends on the distance between a grid point and observation location. Two types of observation-space localization are implemented for the L95 model:

boxcar localization function,

Gaspari-Cohn (1999) localization function.

The boxcar observation-space localization can be configured as:

```
obs localizations:
- localization method: Box Car
lengthscale: 0.2 # distance at which localization becomes zero.
```

The Gaspari-Cohn observation-space localization can be configured as:

```
obs localizations:
- localization method: Gaspari-Cohn
lengthscale: 0.2 # distance at which localization becomes zero.
```

## References¶

Gaspari, G. and Cohn, S.E. (1999), Construction of correlation functions in two and three dimensions. Q.J.R. Meteorol. Soc., 125: 723-757. https://doi.org/10.1002/qj.49712555417

Lorenz, E. N., 1996: Predictability: a problem partly solved. Seminar on Predictability, 4-8 September 1995, volume 1, pages 1–18, European Centre for Medium Range Weather Forecasts, Reading, England. ECMWF.

Lorenz, E. N. and Emanuel, K. A. (1998). Optimal sites for supplementary weather observations: Simulation with a small model. J. Atmos. Sci., 55(3):399–414.