Version 46 (modified by 2 weeks ago) (diff) | ,
---|
PDAF-OMI, the Observation Module Infrastructure
PDAF-OMI Guide
- Overview
- callback_obs_pdafomi.F90
- Observation Modules
- Observation operators
- Checking error status
- Debugging functionality
- Implementing the analysis step with OMI
- General overview for ensemble filters
- Implementation for Global Filters
- Implementation for Local Filters
- Implementation for LEnKF
- General overview for 3D-Var methods
- Using nondiagonal R-matrices
- Porting an existing implemention to OMI
- Additional OMI Functionality
Contents of this page
PDAF-OMI (Observation Module Infrastructure) is an extension to PDAF for a better modular implementation of the observation handling for PDAF. It was introduced with PDAF V1.16.
Compared to the classical variant to implement observations with PDAF, OMI is designed with two main aims
- reduce the coding effort for implementing the support for an observation type, its corresponding observation operator, and localization.
- simplify the implementation of complex cases in which several different observation types are assimilated by clearly separating each observation type
To guarantee that each observation type (like sea surface temperature data from some satellite sensor, or altimetry data) is handled independently from the others one implements with OMI one Fortran module for each observation type. Thus, different developers can implement observation types without interfering with the implementations by others.
To reduce the coding effort only two routines (in the case of global ensemble filters) or three routines (in the case of localized ensemble filter) need to be implemented for an observation type. Always required are:
- init_dim_obs
Reads observations from a file and initialize the information describing the observations - obs_op
Calls an observation operator routine
For the domain localized filters LETKF/LESTKF/LNETF the following routine is required:
- init_dim_obs_l
Calls a generic routine to initialize local observations
For the localized EnKF, instead of init_dim_obs_l
the following routine is used:
- localize_covar
Calls a generic routine to apply covariance localization
Only in the case of 3D-Var, two more routines are required:
- obs_op_lin
Calls a routine for the linearized observation operator (equal toobs_op
if this is linear) - obs_op_adj
Calls a routine for the adjoint observation operator
The only 'real' coding effort will be in init_dim_obs because the other routines merely call a routine provided by PDAF-OMI. All functionality needed during the analyis step bases on variables that are initialized by these routines and is provided by PDAF-OMI.
Main Components of OMI
The main components of OMI are
- Observation Modules
One observation-specific Fortran module for each observation type - callback_obs_pdafomi.F90
The observation-specific call-back routines are merely pass-through routines without own functionality. They are collected into this single file for compactness. - PDAF-OMI core routines
These routines are part of the PDAF library and provide functionality for observation handling, localization, and observation operators
Figure 1 shows the call structure for the analysis step with PDAF-OMI. For the analysis step, the core routines of PDAF (green) call different user-provided call-back functions. Some of these routines, like those performing state localization, that are not related to observations (blue). PDAF-OMI is concerned with the routines related to observations (red and purple).
Figure 1: Call-structure of PDAF with OMI: (green) PDAF library with core and omi; (blue) call-back routines; (red) OMI call-back routines; (purple) observation-specific modules. If PDAFlocal is not used, there will be two additional routines g2l_state
and l2g_state
relating to localization.
With OMI, the functionality to handle observations is included in generic routines and observation-specific modules (obs_*_pdafomi in the third column in Fig. 1, denoted obs-module below). Most routines for the observation handling are generic with OMI and included in PDAF so that only three to four routines with observation specific operations need to be implemented. There is one obs-module per observation type with collects these routines. For example, one can have one obs-module for the satellite sea surface temperature from one data provider and another one for sea level anomaly data. Important is that each of these obs-modules, which are further described below, is independent from the others. This allows us to switch between different combinations of observations ensuring that their implementations don’t interfere.
Since the actual operations are performed in the obs-modules obs_*_pdafomi, the remaining call-back routines (init_dim_obs, obs_op, init_dim_obs_l, localize_covar) are reduced to pass-through routines. Thus, each of these routines contains only calls to one observation-specific routine from each obs-module. There is, in addition, one routine for deallocating the observation-related arrays which calls a generic PDAF-OMI routine for each observation type.
Because the call-back routines become very compact by this change, they are collected into the file callback_obs_pdafomi.F90
. This is mainly for convenience, because all these routines are now ‘in one place’. Thus, when adding a new observation type only a new subroutine call has to be added to each of the routines in this file. (Note, that callback_obs_pdafomi.F90 does not define a Fortran module. This is because the call-back routines of PDAF are not contained in a module as this would require to compile the module together with the PDAF core so that the PDAF core would no longer be generic.)
Each obs-module contains four routines:
init_dim_obs
initializes all variables holding the information about one observation type.obs_op
applies the observation operator to a state vector. One can call an observation operator routine provided by PDAF, or one can to implement a new operator.init_dim_obs_l
calls a PDAF-OMI routine to initialize the observation information corresponding to a local analysis domain. One can set localization parameters, like the localization radius, for each observation type.localize_covar
calls a PDAF-OMI routine to apply covariance localization. One can set localization parameters, liek the localization radius, for each observation type.
For each observation type, PDAF-OMI uses a data structure (Fortran 'type') that is initialized in init_dim_obs
in the obs-module. The set of routines in callback_obs_pdafomi.F90
provide the observation handling for all filters and smoothers provided by PDAF. Thus, once the routines in an obs-module are implemented for a particular observation and the subroutine calls in callback_obs_pdafomi.F90
for this observation type are inserted, one can use each of the provided assimilation methods.
Note that init_dim_obs_l
is only required if one plans to use domain-localized filters like LESTKF, LETKF or LNETF. Likewise, localize_covar
is only required if on likes to use the loalized EnKF (LEnKF).
Further documentation of PDAF-OMI
The documentation for implementing is provided on the following pages:
- The file callback_obs_pdafomi.F90
- The Observation Modules
- Observation Operators
- Debugging Functionality
- Implementing the analysis step with OMI
- Porting an existing implementation to OMI
- Additional functionality of OMI
Implementation examples
From PDAF V1.16, the PDAF package provides several implementation examples:
- /tutorial/online_2D_serialmodel
This implementation includes three obs-modules. The two modulesobs_A_pdafomi.F90
andobs_B_pdafomi.F90
are for observation at grid points, whileobs_C_pdafomi.F90
uses an observation operator with bi-linear interpolation. In this case we have only implemented support for the global and the domain-localized filters, but not the LEnKF (see /models/lorenz96_omi for the example supporting all filters) - /tutorial/online_2D_parallelmodel
This implementation includes two obs-modules (obs_A_pdafomi.F90
,obs_B_pdafomi.F90
) for observations at grid points. One can compare these modules with those in online_2D_serialmodel_omi to see differences in the case of a serial model to those in a parallel model - /models/lorenz96
This implementation uses one obs-module for observations at grid points. The implementation supports all filters that are available in PDAF. This variant uses the flexible parallelization variant (PDAFomi_put_state_X).
Some Known Limitations
The current version of PDAF-OMI has a few limitations
- OMI currently only supports diagonal observation error covariance matrices (though, the observation variances can vary).
- OMI currently only includes observation operators with linear interpolation.
- We have not tested interoperability with other programming languages. Generally Fortran derived data types and C structs should be compatible. Obviously, taking the Fortran routines and calling C functions to perform the actual initializations will work.