Changes between Version 2 and Version 3 of ImplementAnalysisLocal


Ignore:
Timestamp:
Nov 16, 2020, 3:22:39 PM (9 days ago)
Author:
lnerger
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • ImplementAnalysisLocal

    v2 v3  
    2929With Version 1.16 of PDAF we introduced PDAF-OMI (observation module infrastructure). With OMI we provide generic routines for the analysis step, which only distinguish global and local filters. This page describes the implementation of the analysis step for domain-local filters (LESTKF, LETKF, LNETF, LSEIK).
    3030
    31 For the analysis step of the local filters, several operations related to the observations are needed. These operations are requested by PDAF by calls to routines supplied by the user and provided in the OMI structure.  The names of the required routines are specified in the call to the routine `PDAF_assimilate_local` in the fully-parallel implementation (or `PDAF_put_state_local` for the 'flexible' implementation) described below. With regard to the parallelization, all these routines (except `U_collect_state`, `U_distribute_state`, and `U_next_observation`) are executed by the filter processes (`filterpe=.true.`) only.
    32 
    33 For completeness we discuss here all user-supplied routines that are specified in the interface to `PDAF_assimilate_local`. Many of the routines are identical to those used for the global filters. Hence, when the user-supplied routines for the global filters have been already implemented, one can base on these routines to speed up the implementation. Due to this, it can also be reasonable to first fully implement a global filter version and subsequently implement the corresponding localized filter by modifying and extending the global routines.
    34 
    35 
    36 == `PDAF_assimilate_local` ==
     31For the analysis step of the local filters, several operations related to the observations are needed. These operations are requested by PDAF by call-back routines supplied by the user and provided in the OMI structure.  The names of the required routines are specified in the call to the routine `PDAF_assimilate_local_omi` in the fully-parallel implementation (or `PDAF_put_state_local_omi` for the 'flexible' implementation) described below. With regard to the parallelization, all these routines (except `U_collect_state`, `U_distribute_state`, and `U_next_observation`) are executed by the filter processes (`filterpe=.true.`) only.
     32
     33For completeness we discuss here all user-supplied routines that are specified in the interface to `PDAF_assimilate_local_omi`. Many of the routines are identical to those used for the global filters. Hence, when the user-supplied routines for the global filters have been already implemented, one can base on these routines to speed up the implementation. Due to this, it can also be reasonable to first fully implement a global filter version and subsequently implement the corresponding localized filter by modifying and extending the global routines.
     34
     35
     36== `PDAF_assimilate_local_omi` ==
    3737
    3838The general aspects of the filter-specific routines `PDAF_assimilate_*` have been described on the page [ModifyModelforEnsembleIntegration Modification of the model code for the ensemble integration] and its sub-page on [InsertAnalysisStep inserting the analysis step].  The routine is used in the fully-parallel implementation variant of the data assimilation system. When the 'flexible' implementation variant is used, the routines `PDAF_put_state_*' is used as described further below.
    39 The interface for the routine `PDAF_assimilate_local` contains several routine names for routines that operate on the local analysis domains (marked by `_l` at the end of the routine name). In addition, there are names for routines that consider all available observations required to perform local analyses with LESTKF within some sub-domain of a domain-decomposed model (marked by `_f` at the end of the routine name). In case of a serial execution of the assimilation program, these will be all globally available observations. However, if the program is executed with parallelization, this might be a smaller set of observations.
    40 
    41 To explain the  difference, it is assumed, for simplicity, that a local analysis domain consists of a single vertical column of the model grid. In addition, we assume that the domain decomposition splits the global model domain by vertical boundaries as is typical for ocean models and that the observations are spatially distributed observations of model fields that are part of the state vector.  Under these assumptions, the situation is the following: When a model uses domain decomposition, the LESTKF is executed such that for each model sub-domain a loop over all local analysis domains (e.g. vertical columns) that belong to the model sub-domain is performed. As each model sub-domain is treated by a different process, all loops are executed parallel to each other.
    42 
    43 For the update of each single vertical column, observations from some larger domain surrounding the vertical column are required. If the influence radius for the observations is sufficiently small there will be vertical columns for which the relevant observations reside completely inside the model sub-domain of the process. However, if a vertical column is considered that is located close to the boundary of the model sub-domain, there will be some observations that don't belong spatially to the local model sub-domain, but to a neighboring model sub-domain. Nonetheless, these observations are required on the local model sub-domain. A simple way to handle this situation is to initialize for each process all globally available observations, together with their coordinates. While this method is simple, it can also become inefficient if the assimilation program is executed using a large number of processes. As for an initial implementation it is usually not the concern to obtain the highest parallel efficiency, the description below assumes that 'full' refers to the global model domain.
     39
     40The interface for the routine `PDAF_assimilate_local_omi` contains two routine names for routines that operate on the local analysis domains (marked by `_l` at the end of the routine name). Further there are routines that convert between a local and a global model state vector (`U_g2l_state` and `U_l2g_state`).
     41Here, we list the full interface of the routine. Subsequently, the user-supplied routines specified in the call is explained.
    4442
    4543The interface when using one of the local filters is the following:
    4644{{{
    47   SUBROUTINE PDAF_assimilate_lestkf(U_collect_state, U_distribute_state, &
    48                                   U_init_dim_obs_f, U_obs_op_f, &
     45  SUBROUTINE PDAF_assimilate_local_omi(U_collect_state, U_distribute_state, &
     46                                  U_init_dim_obs, U_obs_op, &
    4947                                  U_prepoststep, U_init_n_domains, U_init_dim_l, &
    5048                                  U_init_dim_obs_l, U_g2l_state, U_l2g_state, &
     
    5452 * [#U_collect_statecollect_state_pdaf.F90 U_collect_state]: The name of the user-supplied routine that initializes a state vector from the array holding the ensemble of model states from the model fields. This is basically the inverse operation to `U_distribute_state` used in [ModifyModelforEnsembleIntegration#PDAF_get_state PDAF_get_state] and also here.
    5553 * [#U_distribute_statedistribute_state_pdaf.F90 U_distribute_state]:  The name of a user supplied routine that initializes the model fields from the array holding the ensemble of model state vectors.
    56  * [#U_init_dim_obs_finit_dim_obs_f_pdaf.F90 U_init_dim_obs_f]: The name of the user-supplied routine that provides the size of the full observation vector
    57  * [#U_obs_op_fobs_op_f_pdaf.F90 U_obs_op_f]: The name of the user-supplied routine that acts as the full observation operator on some state vector
     54 * [#U_init_dim_obscallback_obs_pdafomi.F90 U_init_dim_obs]: The name of the user-supplied routine that initializes the observation information and provides the size of observation vector
     55 * [#U_obs_opcallback_obs_pdafomi.F90 U_obs_op]: The name of the user-supplied routine that acts as the observation operator on some state vector
    5856 * [#U_prepoststepprepoststep_ens_pdaf.F90 U_prepoststep]: The name of the pre/poststep routine as in `PDAF_get_state`
    5957 * [#U_init_n_domainsinit_n_domains_pdaf.F90 U_init_n_domains]: The name of the routine that provides the number of local analysis domains
     
    6159 * [#U_init_dim_obs_linit_dim_obs_l_pdaf.F90 U_init_dim_obs_l]: The name of the routine that initializes the size of the observation vector for a local analysis domain
    6260 * [#U_g2l_stateg2l_state_pdaf.F90 U_g2l_state]: The name of the routine that initializes a local state vector from the global state vector
    63  * [#U_l2g_statel2g_state_pdaf.F90 U_l2g_state]: The name of the routine that initializes the corresponding part of the global state vector from the the provided local state vector
     61 * [#U_l2g_statel2g_state_pdaf.F90 U_l2g_state]: The name of the routine that initializes the corresponding part of the global state vector from the provided local state vector
    6462 * [#U_next_observationnext_observation.F90 U_next_observation]: The name of a user supplied routine that initializes the variables `nsteps`, `timenow`, and `doexit`. The same routine is also used in `PDAF_get_state`.
    65  * `status`: The integer status flag. It is zero, if `PDAF_assimilate_lestkf` is exited without errors.
     63 * `status`: The integer status flag. It is zero, if `PDAF_assimilate_local_omi` is exited without errors.
    6664
    6765Note:
     
    7068
    7169
    72 == `PDAF_put_state_local` ==
    73 
    74 When the 'flexible' implementation variant is chosen for the assimilation system, the routine `PDAF_put_state_local` has to be used instead of `PDAF_assimilate_local`. The general aspects of the filter specific routines `PDAF_put_state_*` have been described on the page [ModifyModelforEnsembleIntegration Modification of the model code for the ensemble integration]. The interface of the routine is identical with that of `PDAF_assimilate_local` with the exception the specification of the user-supplied routines `U_distribute_state` and `U_next_observation` are missing.
     70== `PDAF_put_state_local_omi` ==
     71
     72When the 'flexible' implementation variant is chosen for the assimilation system, the routine `PDAF_put_state_local_omi` has to be used instead of `PDAF_assimilate_local_omi`. The general aspects of the filter specific routines `PDAF_put_state_*` have been described on the page [ModifyModelforEnsembleIntegration Modification of the model code for the ensemble integration]. The interface of the routine is identical with that of `PDAF_assimilate_local_omi` with the exception the specification of the user-supplied routines `U_distribute_state` and `U_next_observation` are missing.
    7573
    7674The interface when using one of the local filters is the following:
    7775{{{
    78   SUBROUTINE PDAF_put_state_lestkf(U_collect_state, &
    79                                   U_init_dim_obs_f, U_obs_op_f, &
     76  SUBROUTINE PDAF_put_state_local_omi(U_collect_state, &
     77                                  U_init_dim_obs, U_obs_op, &
    8078                                  U_prepoststep, U_init_n_domains, U_init_dim_l, &
    8179                                  U_init_dim_obs_l, U_g2l_state, U_l2g_state, &
     
    8583== User-supplied routines ==
    8684
    87 Here, all user-supplied routines are described that are required in the call to `PDAF_assimilate_local` or `PDAF_put_state_local`. For some of the generic routines, we link to the page on [ModifyModelforEnsembleIntegration modifying the model code for the ensemble integration].
     85Here, all user-supplied routines are described that are required in the call to `PDAF_assimilate_local_omi` or `PDAF_put_state_local_omi`. For some of the generic routines, we link to the page on [ModifyModelforEnsembleIntegration modifying the model code for the ensemble integration].
    8886
    8987To indicate user-supplied routines we use the prefix `U_`. In the template directory `templates/` as well as in the example implementation in `testsuite/src/dummymodel_1D` these routines exist without the prefix, but with the extension `_pdaf.F90`. In the section titles below we provide the name of the template file in parentheses.
     
    9391=== `U_collect_state` (collect_state_pdaf.F90) ===
    9492
    95 This routine is independent from the filter algorithm used.
    96 See the mape on [InsertAnalysisStep#U_collect_statecollect_state_pdaf.F90 inserting the analysis step] for the description of this routine.
     93This routine is independent of the filter algorithm used.
     94See the page on [InsertAnalysisStep#U_collect_statecollect_state_pdaf.F90 inserting the analysis step] for the description of this routine.
    9795
    9896=== `U_distribute_state` (distribute_state_pdaf.F90) ===
     
    102100
    103101
    104 === `U_init_dim_obs_f` (init_dim_obs_f_pdaf.F90) ===
    105 
    106 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    107 
    108 The interface for this routine is:
    109 {{{
    110 SUBROUTINE init_dim_obs_f(step, dim_obs_f)
     102=== `U_init_dim_obs` (callback_obs_pdafomi.F90) ===
     103
     104The interface for this routine is:
     105{{{
     106SUBROUTINE init_dim_obs(step, dim_obs_f)
    111107
    112108  INTEGER, INTENT(in)  :: step       ! Current time step
     
    114110}}}
    115111
    116 The routine is called at the beginning of each analysis step, before the loop over all local analysis domains is entered.  It has to initialize the size `dim_obs_f` of the full observation vector according to the current time step. For simplicity, `dim_obs_f` can be the size for the global model domain.
    117 
    118 Some hints:
    119  * It can be useful to not only determine the size of the observation vector at this point. One can also already gather information about the location of the observations, which can be used later, e.g. to implement the observation operator. In addition, one can already prepare an array that holds the full observation vector. This can be used later by `U_init_obs_l` to initialize a local vector of observations by selecting the relevant parts of the full observation vector. The required arrays can be defined in a module like `mod_assimilation`.
    120  * The routine is similar to `init_dim_obs` used in the global filters. However, if the global filter is used with a domain-decomposed model, it only initializes the size of the observation vector for the local model sub-domain. This is different for the local filters, as the local analysis also requires observational data from neighboring model sub-domains. Nonetheless, one can base on an implemented routine `init_dim_obs` to implement `init_dim_obs_f`.
    121 
    122 === `U_obs_op_f` (obs_op_f_pdaf.F90) ===
    123 
    124 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    125 
    126 The interface for this routine is:
    127 {{{
    128 SUBROUTINE obs_op_f(step, dim_p, dim_obs_f, state_p, m_state_f)
     112The routine is called at the beginning of each analysis step.  For PDAF, it has to initialize the size `dim_obs_f` of the observation vector according to the current time step. `dim_obs_f` is usually be the size for the full model domain. When a domain-decomposed model is used, `dim_obs_f` can be reduced to those observations relevant for the local analysis loop in a process domain.
     113
     114With PDAF-OMI, the routine just calls a routine from the observation module for each observation type.
     115
     116
     117=== `U_obs_op` (callback_obs_pdafomi.F90) ===
     118
     119The interface for this routine is:
     120{{{
     121SUBROUTINE obs_op(step, dim_p, dim_obs_p, state_p, m_state_f)
    129122
    130123  INTEGER, INTENT(in) :: step               ! Currrent time step
    131124  INTEGER, INTENT(in) :: dim_p              ! PE-local dimension of state
    132   INTEGER, INTENT(in) :: dim_obs_f          ! Dimension of the full observed state
     125  INTEGER, INTENT(in) :: dim_obs_f          ! Dimension of observed state
    133126  REAL, INTENT(in)    :: state_p(dim_p)     ! PE-local model state
    134127  REAL, INTENT(out) :: m_state_f(dim_obs_f) ! Full observed state
    135128}}}
    136129
    137 The routine is called during the analysis step, before the loop over the local analysis domain is entered. It has to perform the operation of the observation operator acting on a state vector, which is provided as `state_p`. The observed state has to be returned in `m_state_f`. It is the observed state corresponding to the 'full' observation vector.
    138 
    139 Hint:
    140  * The routine is similar to `init_dim_obs` used for the global filters. However, with a domain-decomposed model `m_state_f` will contain parts of the state vector from neighboring model sub-domains. To make these parts accessible, some parallel communication will be necessary (The state information for a neighboring model sub-domain, will be in the memory of the process that handles that sub-domain). The example implementation in `testsuite/dummymodel_1d` uses the function `MPI_AllGatherV` for this communication.
     130The routine is called during the analysis step. It has to perform the operation of the observation operator acting on a state vector that is provided as `state_p`. The observed state has to be returned in `m_state_f`.
     131
     132With PDAF-OMI, the routine just calls a routine from the observation module for each observation type.
    141133
    142134
     
    179171=== `U_init_n_domains` (init_n_domains_pdaf.F90) ===
    180172
    181 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    182 
    183173The interface for this routine is:
    184174{{{
     
    197187
    198188=== `U_init_dim_l` (init_dim_l_pdaf.F90) ===
    199 
    200 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    201189
    202190The interface for this routine is:
     
    217205
    218206=== `U_init_dim_obs_l` (init_dim_obs_l_pdaf.F90) ===
    219 
    220 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    221207
    222208The interface for this routine is:
     
    233219It has to initialize in `dim_obs_l` the size of the observation vector used for the local analysis domain with index `domain_p`.
    234220
    235 Some hints:
    236  * Usually, the observations to be considered for a local analysis are those which reside within some distance from the local analysis domain. Thus, if the local analysis domain is a single vertical column of the model grid and if the model grid is a regular ij-grid, then one could use some range of i/j indices to select the observations and determine the local number of them. More generally, one can compute the physical distance of an observation from the local analysis domain and decide on this basis, if the observation has to be considered.
    237  * In the loop over the local analysis domains, the routine is always called before `U_init_obs_l` is executed. Thus, as `U_init_dim_obs_l` has to check which observations should be used for the local analysis domain, one can already initialize an integer array that stores the index of observations to be considered. This index should be the position of the observation in the array `observation_f`. With this, the initialization of the local observation vector in `U_init_obs_l` can be sped up.
    238  * For PDAF, we could not join the routines `U_init_dim_obs_l` and `U_init_obs_l`, because the array for the local observations is allocated internally to PDAF after its size has been determined in `U_init_dim_obs_l`.
     221With PDAF-OMI, the routine just calls a routine from the observation module for each observation type. PDAF-OMI will perform the necessary intializations based on the coordinates of the observations.
    239222
    240223
    241224=== `U_g2l_state` (g2l_state_pdaf.F90) ===
    242 
    243 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    244225
    245226The interface for this routine is:
     
    259240Hints:
    260241 * In the simple case that a local analysis domain is a single vertical column of the model grid, the operation in this routine would be to take out of `state_p` the data for the vertical column indexed by `domain_p`.
     242 * Usually, one can initialize the indices of the local state vector elements in the global state vector in `U_init_dim_l` and just use these here.
    261243
    262244
    263245=== `U_l2g_state` (l2g_state_pdaf.F90) ===
    264 
    265 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF) and is independent of the particular algorithm.
    266246
    267247The interface for this routine is:
     
    281261Hints:
    282262 * In the simple case that a local analysis domain is a single vertical column of the model grid, the operation in this routine would be to write into `state_p` the data for the vertical column indexed by `domain_p`.
     263 * Usually, one can initialize the indices of the local state vector elements in the global state vector in `U_init_dim_l` and just use these here.
    283264
    284265
     
    291272== Execution order of user-supplied routines ==
    292273
    293 The user-supplied routines are executed in the order listed below. The order can be important as some routines can perform preparatory work for routines executed later on during the analysis. For example, `U_init_dim_obs_local` can prepare an index array that provides the information how to localize a 'full' vector of observations. Some hints one the efficient implementation strategy are given with the descriptions of the routine interfaces above.
     274The user-supplied routines are executed in the order listed below. The order can be important as some routines can perform preparatory work for routines executed later on during the analysis. For example, `U_init_dim_l` can prepare an index array that provides the information how to localize a global state vector. Some hints one the efficient implementation strategy are given with the descriptions of the routine interfaces above.
    294275
    295276Before the analysis step is called the following is executed:
     
    299280 1. [#U_prepoststepprepoststep_ens_pdaf.F90 U_prepoststep] (Call to act on the forecast ensemble, called with negative value of the time step)
    300281 1. [#U_init_n_domainsinit_n_domains_pdaf.F90 U_init_n_domains]
    301  1. [#U_init_dim_obs_finit_dim_obs_f_pdaf.F90 U_init_dim_obs_f]
    302  1. [#U_obs_op_fobs_op_f_pdaf.F90 U_obs_op_f] (Called `dim_ens` times; once for each ensemble member)
     282 1. [#U_init_dim_obsback_obs_pdafomi.F90 U_init_dim_obs]
     283 1. [#U_obs_opcallback_obs_pdafomi.F90 U_obs_op] (Called `dim_ens` times; once for each ensemble member)
    303284
    304285In the loop over all local analysis domains, it is executed for each local analysis domain:
     
    306287 1. [#U_init_dim_obs_linit_dim_obs_l_pdaf.F90 U_init_dim_obs_l]
    307288 1. [#U_g2l_stateg2l_state_pdaf.F90 U_g2l_state] (Called `dim_ens+1` times: Once for each ensemble member and once for the mean state estimate)
    308  1. [#U_prodRinvA_lprodrinva_l_pdaf.F90 U_prodRinvA_l]
    309289 1. [#U_l2g_statel2g_state_pdaf.F90 U_l2g_state] (Called `dim_ens+1` times: Once for each ensemble member and once for the mean state estimate)
    310290
     
    312292 1. [#U_prepoststepprepoststep_ens_pdaf.F90 U_prepoststep] (Call to act on the analysis ensemble, called with (positive) value of the time step)
    313293
    314 In case of the routine `PDAF_assimilate_local`, the following routines are executed after the analysis step:
     294In case of the routine `PDAF_assimilate_local_omi`, the following routines are executed after the analysis step:
    315295 1. [#U_distribute_statedistribute_state_pdaf.F90 U_distribute_state]
    316296 1. [#U_next_observationnext_observation_pdaf.F90 U_next_observation]