Changes between Version 28 and Version 29 of PDAF_OMI_Overview


Ignore:
Timestamp:
Nov 27, 2020, 1:33:50 PM (6 months ago)
Author:
lnerger
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • PDAF_OMI_Overview

    v28 v29  
    3838  Calls an observation operator routine
    3939 - '''init_dim_obs_l''' [[br]]
    40   Calls a generic routine to initialize local observations (only for domain-localized filters like LETKF and LESTKF)
     40  Calls a generic routine to initialize local observations (only required for domain-localized filters like LETKF and LESTKF)
    4141 - '''localize_covar'''[[br]]
    42   Calls a generic routine to apply covariance localization (only needed for the localized EnKF)
     42  Calls a generic routine to apply covariance localization (only required for the localized EnKF)
    4343
    44 All functionality needed during the analyis step bases on variables that are initialized by these routines and is provided by PDAF-OMI.
     44The 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.
    4545
    4646
     
    6363
    6464
    65 With OMI, the functionality to handle observations is shifted to 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 routines with observation specific operations need to be implemented.
    66 There is one obs-module per observation type with collects the three 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.
     65With 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.
    6766
    68 Since the actual opernations are done in the obs-modules obs_*_pdafomi, the remaining three call-back routines (init_dim_obs, obs_op, init_dim_obs_l) 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. As 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’. This simplifies the addition of a new data type by adding a subroutine call 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.) When adding a new observation type only a new subroutine call has to be added to each of the routines in callback_obs_pdafomi.F90.
     67Since 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.
     68
     69Because 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.)
    6970
    7071Each obs-module contains four routines:
    71 1. `init_dim_obs` initializes all variables holding the information about one observation type. The information about the observation type is stored in a data structure (Fortran derived type).
     721. `init_dim_obs` initializes all variables holding the information about one observation type.  
    72731. `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.
    73 1. `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, liek the localization radius, for each observation type.
     741. `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.
    74751. `localize_covar` calls a PDAF-OMI routine to apply covariance localization. One can set localization parameters, liek the localization radius, for each observation type.
    7576
    76 For each observation type, PDAF-OMI uses a data structure that was initialized 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 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. Here `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).
     77For 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.
     78
     79Note 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).
    7780
    7881== Further documentation of PDAF-OMI ==
     
    9699From PDAF V1.16, the PDAF package provides several implementation examples:
    97100
    98  - `/tutorial/online_2D_serialmodel_omi`[[BR]]
    99    This implementation includes three obs-modules. The two modules `obs_A_pdafomi.F90` and `obs_B_pdafomi.F90` are for observation at grid points, while `obs_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 (see `/models/lorenz96_omiz for the example supporting all filters)
    100  - `/tutorial/online_2D_parallelmodel_omi`[[BR]]
     101 - '''/tutorial/online_2D_serialmodel'''[[BR]]
     102   This implementation includes three obs-modules. The two modules `obs_A_pdafomi.F90` and `obs_B_pdafomi.F90` are for observation at grid points, while `obs_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)
     103 - '''/tutorial/online_2D_parallelmodel'''[[BR]]
    101104   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
    102  - `/models/lorenz96_omi`[[br]]
     105 - '''/models/lorenz96_omi'''[[br]]
    103106   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 (PDAF_put_state_X).
    104107