Changes between Version 5 and Version 6 of ImplementAnalysisletkf


Ignore:
Timestamp:
Sep 15, 2011, 3:45:00 PM (8 years ago)
Author:
lnerger
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • ImplementAnalysisletkf

    v5 v6  
    3737
    3838The general espects of the filter-specific routines `PDAF_put_state_*` have been described on the page [ModifyModelforEnsembleIntegration Modification of the model code for the ensemble integration].
    39 The interface for the routine `PDAF_put_state_letkf` contains several routine names for routines that operate on the local analysis domains (marked by `_local` at then end of the routine name). In addition, there are names for routines that consider all available observations required to perform local analyses with LETKF within some sub-domain of a domain-decomposed model (marked by `_full` at then 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.
     39The interface for the routine `PDAF_put_state_letkf` 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 LETKF 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.
    4040
    4141To 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 LETKF algorithm 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.
     
    4545The interface when using the LETKF algorithm is the following:
    4646{{{
    47   SUBROUTINE PDAF_put_state_letkf(U_collect_state, U_init_dim_obs_full, U_obs_op_full, U_init_obs_full, &
    48                                   U_init_obs_local, U_prepoststep, U_prodRinvA_local, U_init_n_domains, &
    49                                   U_init_dim_local, U_init_dim_obs_local, &
    50                                   U_global2local_state, U_local2glocal_state, U_glocal2local_obs, &
    51                                   U_init_obsvar, U_init_obsvar_local, status)
     47  SUBROUTINE PDAF_put_state_letkf(U_collect_state, U_init_dim_obs_f, U_obs_op_f, U_init_obs_f, &
     48                                  U_init_obs_l, U_prepoststep, U_prodRinvA_l, U_init_n_domains, &
     49                                  U_init_dim_l, U_init_dim_obs_l, &
     50                                  U_g2l_state, U_l2g_state, U_g2l_obs, &
     51                                  U_init_obsvar, U_init_obsvar_l, status)
    5252}}}
    5353with the following arguments:
    5454 * [#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]
    55  * [#U_init_dim_obs_fullinit_dim_obs_full_pdaf.F90 U_init_dim_obs_full]: The name of the user-supplied routine that provides the size of the full observation vector
    56  * [#U_obs_op_fullobs_op_full_pdaf.F90 U_obs_op_full]: The name of the user-supplied routine that acts as the full observation operator on some state vector
    57  * [#U_init_obs_fullinit_obs_full_pdaf.F90 U_init_obs_full]: The name of the user-supplied routine that initializes the full vector of observations
    58  * [#U_init_obs_localinit_obs_local_pdaf.F90 U_init_obs_local]: The name of the user-supplied routine that initializes the vector of observations for a local analysis domain
     55 * [#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
     56 * [#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
     57 * [#U_init_obs_finit_obs_f_pdaf.F90 U_init_obs_f]: The name of the user-supplied routine that initializes the full vector of observations
     58 * [#U_init_obs_linit_obs_l_pdaf.F90 U_init_obs_l]: The name of the user-supplied routine that initializes the vector of observations for a local analysis domain
    5959 * [#U_prepoststepprepoststep_seik_pdaf.F90 U_prepoststep]: The name of the pre/poststep routine as in `PDAF_get_state`
    60  * [#U_prodRinvA_localprodrinva_local_pdaf.F90 U_prodRinvA_local]: The name of the user-supplied routine that computes the product of the inverse of the observation error covariance matrix with some matrix provided to the routine by PDAF.
     60 * [#U_prodRinvA_lprodrinva_l_pdaf.F90 U_prodRinvA_l]: The name of the user-supplied routine that computes the product of the inverse of the observation error covariance matrix with some matrix provided to the routine by PDAF.
    6161 * [#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
    62  * [#U_init_dim_localinit_dim_local_pdaf.F90 U_init_dim_local]: The name of the routine that provides the state dimension for a local analysis domain
    63  * [#U_init_dim_obs_localinit_dim_obs_local_pdaf.F90 U_init_dim_obs_local]: The name of the routine that initializes the size of the observation vector for a local analysis domain
    64  * [#U_global2local_stateglobal2local_state_pdaf.F90 U_global2local_state]: The name of the routine that initializes a local state vector from the global state vector
    65  * [#U_local2global_statelocal2global_state_pdaf.F90 U_local2global_state]: The name of the routine that initializes the corresponding part of the global state vector from the the provided local state vector
    66  * [#U_global2local_obsglobal2local_obs_pdaf.F90 U_global2local_obs]: The name of the routine that initializes a local observation vector from a full observation vector
     62 * [#U_init_dim_linit_dim_l_pdaf.F90 U_init_dim_l]: The name of the routine that provides the state dimension for a local analysis domain
     63 * [#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
     64 * [#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
     65 * [#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
     66 * [#U_g2l_obsg2l_obs_pdaf.F90 U_g2l_obs]: The name of the routine that initializes a local observation vector from a full observation vector
    6767 * [#U_init_obsvarinit_obsvar_pdaf.F90 U_init_obsvar]: The name of the user-supplied routine that provides a global mean observation error variance (This routine will only be executed, if an adaptive forgetting factor is used)
    68  * [#U_init_obsvar_localinit_obsvar_local_pdaf.F90 U_init_obsvar_local]: The name of the user-supplied routine that provides a mean observation error variance for the local analysis domain (This routine will only be executed, if a local adaptive forgetting factor is used)
     68 * [#U_init_obsvar_linit_obsvar_l_pdaf.F90 U_init_obsvar_l]: The name of the user-supplied routine that provides a mean observation error variance for the local analysis domain (This routine will only be executed, if a local adaptive forgetting factor is used)
    6969 * `status`: The integer status flag. It is zero, if `PDAF_put_state_letkf` is exited without errors.
    7070
     
    8686
    8787
    88 === `U_init_dim_obs_full` (init_dim_obs_full_pdaf.F90) ===
    89 
    90 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    91 
    92 The interface for this routine is:
    93 {{{
    94 SUBROUTINE init_dim_obs_full(step, dim_obs_f)
     88=== `U_init_dim_obs_f` (init_dim_obs_f_pdaf.F90) ===
     89
     90This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     91
     92The interface for this routine is:
     93{{{
     94SUBROUTINE init_dim_obs_f(step, dim_obs_f)
    9595
    9696  INTEGER, INTENT(in)  :: step       ! Current time step
     
    102102Some hints:
    103103 * 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`.
    104  * 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_full`.
    105 
    106 === `U_obs_op_full` (obs_op_full_pdaf.F90) ===
    107 
    108 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    109 
    110 The interface for this routine is:
    111 {{{
    112 SUBROUTINE obs_op_full(step, dim_p, dim_obs_f, state_p, m_state_f)
     104 * 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`.
     105
     106=== `U_obs_op_f` (obs_op_f_pdaf.F90) ===
     107
     108This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     109
     110The interface for this routine is:
     111{{{
     112SUBROUTINE obs_op_f(step, dim_p, dim_obs_f, state_p, m_state_f)
    113113
    114114  INTEGER, INTENT(in) :: step               ! Current time step
     
    124124 * 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.
    125125
    126 === `U_init_obs_full` (init_obs_full_pdaf.F90) ===
     126=== `U_init_obs_f` (init_obs_f_pdaf.F90) ===
    127127
    128128This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     
    131131The interface for this routine is:
    132132{{{
    133 SUBROUTINE init_obs_full(step, dim_obs_f, observation_f)
     133SUBROUTINE init_obs_f(step, dim_obs_f, observation_f)
    134134
    135135  INTEGER, INTENT(in) :: step                     ! Current time step
     
    145145
    146146
    147 === `U_init_obs_local` (init_obs_local_pdaf.F90) ===
    148 
    149 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    150 
    151 The interface for this routine is:
    152 {{{
    153 SUBROUTINE init_obs_local(domain_p, step, dim_obs_l, observation_l)
     147=== `U_init_obs_l` (init_obs_l_pdaf.F90) ===
     148
     149This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     150
     151The interface for this routine is:
     152{{{
     153SUBROUTINE init_obs_l(domain_p, step, dim_obs_l, observation_l)
    154154
    155155  INTEGER, INTENT(in) :: domain_p                 ! Current local analysis domain
     
    163163
    164164Hints:
    165  * For parallel efficiency, the LETKF algorithm is implemented in a way that first the full vectors are initialized. These are then restricted to the local analysis domain during the loop over all local analysis domains. Thus, if the full vector of observations has been initialized before `U_init_obs_local` is executed (e.g. by `U_init_dim_obs_full`), the operations performed in this routine will be to select the part of the full observation vector that is relevant for the current local analysis domain.
    166  * The routine `U_init_dim_obs_local` is executed before this routine. Thus, if that routine already prepares the information which elements of `observation_f` are needed for `observation_l`, this information can be used efficiently here.
     165 * For parallel efficiency, the LETKF algorithm is implemented in a way that first the full vectors are initialized. These are then restricted to the local analysis domain during the loop over all local analysis domains. Thus, if the full vector of observations has been initialized before `U_init_obs_l` is executed (e.g. by `U_init_dim_obs_f`), the operations performed in this routine will be to select the part of the full observation vector that is relevant for the current local analysis domain.
     166 * The routine `U_init_dim_obs_l` is executed before this routine. Thus, if that routine already prepares the information which elements of `observation_f` are needed for `observation_l`, this information can be used efficiently here.
    167167
    168168
     
    203203
    204204
    205 === `U_prodRinvA_local` (prodrinva_local_pdaf.F90) ===
     205=== `U_prodRinvA_l` (prodrinva_l_pdaf.F90) ===
    206206
    207207This routine is used by the local filters (LSEIK and LETKF). There is a slight difference between LSEIK and LETKF for this routine, which is described below.
     
    209209The interface for this routine is:
    210210{{{
    211 SUBROUTINE prodRinvA_local(domain_p, step, dim_obs_l, dim_ens, obs_l, A_l, C_l)
     211SUBROUTINE prodRinvA_l(domain_p, step, dim_obs_l, dim_ens, obs_l, A_l, C_l)
    212212
    213213  INTEGER, INTENT(in) :: domain_p             ! Current local analysis domain
     
    222222The routine is called during the loop over the local analysis domains. In the algorithm, the product of the inverse of the observation error covariance matrix with some matrix has to be computed. For the SEIK filter this matrix holds the observed part of the ensemble perturbations for the local analysis domain of index `domain_p`. The matrix is provided as `A_l`. The product has to be given as `C_l`.
    223223
    224 This routine is also the place to perform observation localization. To initialize a vector of weights, the routine `PDAF_local_weights` can be called. The procedure is used in the example implementation and also demonstrated in the template routine.
     224This routine is also the place to perform observation localization. To initialize a vector of weights, the routine `PDAF_local_weight` can be called. The procedure is used in the example implementation and also demonstrated in the template routine.
    225225
    226226Hints:
     
    250250
    251251
    252 === `U_init_dim_local` (init_dim_local_pdaf.F90) ===
    253 
    254 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    255 
    256 The interface for this routine is:
    257 {{{
    258 SUBROUTINE init_dim_local(step, domain_p, dim_l)
     252=== `U_init_dim_l` (init_dim_l_pdaf.F90) ===
     253
     254This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     255
     256The interface for this routine is:
     257{{{
     258SUBROUTINE init_dim_l(step, domain_p, dim_l)
    259259
    260260  INTEGER, INTENT(in)  :: step        ! Current time step
     
    270270
    271271
    272 === `U_init_dim_obs_local` (init_dim_obs_local_pdaf.F90) ===
    273 
    274 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    275 
    276 The interface for this routine is:
    277 {{{
    278 SUBROUTINE init_dim_obs_local(domain_p, step, dim_obs_f, dim_obs_l)
     272=== `U_init_dim_obs_l` (init_dim_obs_l_pdaf.F90) ===
     273
     274This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     275
     276The interface for this routine is:
     277{{{
     278SUBROUTINE init_dim_obs_l(domain_p, step, dim_obs_f, dim_obs_l)
    279279
    280280  INTEGER, INTENT(in)  :: domain_p   ! Current local analysis domain
     
    289289Some hints:
    290290 * 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.
    291  * In the loop over the local analysis domains, the routine is always called before `U_init_obs_local` is executed. Thus, as `U_init_dim_obs_local` 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_local` can be sped up.
    292  * For PDAF, we could not join the routines `U_init_dim_obs_local` and `U_init_obs_local`, because the array for the local observations is allocated internally to PDAF after its size has been determined in `U_init_dim_obs_local`.
     291 * 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_local` 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.
     292 * 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`.
    293293
    294294
     
    315315
    316316
    317 === `U_local2global_state` (local2global_state_pdaf.F90) ===
    318 
    319 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    320 
    321 The interface for this routine is:
    322 {{{
    323 SUBROUTINE local2global_state(step, domain_p, dim_l, state_l, dim_p, state_p)
     317=== `U_l2g_state` (l2g_state_pdaf.F90) ===
     318
     319This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     320
     321The interface for this routine is:
     322{{{
     323SUBROUTINE l2g_state(step, domain_p, dim_l, state_l, dim_p, state_p)
    324324
    325325  INTEGER, INTENT(in) :: step           ! Current time step
     
    337337
    338338
    339 === `U_global2local_obs` (global2local_obs_pdaf.F90) ===
    340 
    341 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
    342 
    343 The interface for this routine is:
    344 {{{
    345 SUBROUTINE global2local_obs(domain_p, step, dim_obs_f, dim_obs_l, mstate_f, mstate_l)
     339=== `U_g2l_obs` (g2l_obs_pdaf.F90) ===
     340
     341This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     342
     343The interface for this routine is:
     344{{{
     345SUBROUTINE g2l_obs(domain_p, step, dim_obs_f, dim_obs_l, mstate_f, mstate_l)
    346346
    347347  INTEGER, INTENT(in) :: domain_p              ! Current local analysis domain
     
    357357Hints:
    358358 * The  vector `mstate_f` that is provided to the routine is one of the observed state vectors that are produced by `U_obs_op_full`.
    359  * Some operations performed here are analogous to those required to initialize a local vector of observations in `U_init_obs_l`. If that routine reads first a full vector of observations (e.g. in `U_init_dim_obs_full`), this vector has to be restricted to the relevant observations for the current local analysis domain. For this operation, one can for example initialize an index array when `U_init_dim_obs_local` is executed. (Which happens before `U_global2local_obs`)
     359 * Some operations performed here are analogous to those required to initialize a local vector of observations in `U_init_obs_l`. If that routine reads first a full vector of observations (e.g. in `U_init_dim_obs_f`), this vector has to be restricted to the relevant observations for the current local analysis domain. For this operation, one can for example initialize an index array when `U_init_dim_obs_l` is executed. (Which happens before `U_global2local_obs`)
    360360
    361361
     
    375375
    376376The routine is called in the local filters before the loop over all local analysis domains is entered. The call is by the routine that computes an adaptive forgetting factor (`PDAF_set_forget`).
    377 The routine has to initialize an average full observation error variance, which should be consistent with the observation vector initialized in `U_init_ob_full`.
     377The routine has to initialize an average full observation error variance, which should be consistent with the observation vector initialized in `U_init_ob_f`.
    378378
    379379
     
    384384
    385385
    386 === `U_init_obsvar_local` (init_obsvar_local_pdaf.F90) ===
     386=== `U_init_obsvar_l` (init_obsvar_l_pdaf.F90) ===
    387387
    388388This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm. The routine is only called if the local adaptive forgetting factor is used (`type_forget=2` in the example implementation).
     
    390390The interface for this routine is:
    391391{{{
    392 SUBROUTINE init_obsvar_local(domain_p, step, dim_obs_l, obs_l, meanvar_l)
     392SUBROUTINE init_obsvar_l(domain_p, step, dim_obs_l, obs_l, meanvar_l)
    393393
    394394  INTEGER, INTENT(in) :: domain_p         ! Current local analysis domain
     
    406406== Execution order of user-supplied routines ==
    407407
    408 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.
     408The 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_l` 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.
    409409
    410410Before the analysis step is called the following is executed:
     
    414414 1. [#U_prepoststepprepoststep_seik_pdaf.F90 U_prepoststep] (Call to act on the forecast ensemble, called with negative value of the time step)
    415415 1. [#U_init_n_domainsinit_n_domains_pdaf.F90 U_init_n_domains]
    416  1. [#U_init_dim_obs_fullinit_dim_obs_full_pdaf.F90 U_init_dim_obs_full]
    417  1. [#U_obs_op_fullobs_op_full_pdaf.F90 U_obs_op_full] (Called `dim_ens` times; once for each ensemble member)
    418  1. [#U_init_obs_fullinit_obs_full_pdaf.F90 U_init_obs_full] (Only executed, if the global adaptive forgetting factor is used (`type_forget=1` in the example implemention))
     416 1. [#U_init_dim_obs_finit_dim_obs_f_pdaf.F90 U_init_dim_obs_f]
     417 1. [#U_obs_op_fobs_op_f_pdaf.F90 U_obs_op_f] (Called `dim_ens` times; once for each ensemble member)
     418 1. [#U_init_obs_finit_obs_f_pdaf.F90 U_init_obs_f] (Only executed, if the global adaptive forgetting factor is used (`type_forget=1` in the example implemention))
    419419 1. [#U_init_obsvarinit_obsvar_pdaf.F90 U_init_obsvar] (Only executed, if the global adaptive forgetting factor is used (`type_forget=1` in the example implemention))
    420420
    421421In the loop over all local analysis domains, it is executed for each local analysis domain:
    422  1. [#U_init_dim_localinit_dim_local_pdaf.F90 U_init_dim_local]
    423  1. [#U_init_dim_obs_localinit_dim_obs_local_pdaf.F90 U_init_dim_obs_local]
    424  1. [#U_global2local_stateglobal2local_state_pdaf.F90 U_global2local_state] (Called `dim_ens+1` times: Once for each ensemble member and once for the mean state estimate)
    425  1. [#U_global2local_obsglobal2local_obs_pdaf.F90 U_global2local_obs] (A single call to localize the mean observed state)
    426  1. [#U_init_obs_localinit_obs_local_pdaf.F90 U_init_obs_local]
    427  1. [#U_global2local_obsglobal2local_obs_pdaf.F90 U_global2local_obs] (`dim_ens` calls: one call to localize the observed part of each ensemble member)
    428  1. [#U_init_obsvar_localinit_obsvar_local_pdaf.F90 U_init_obsvar_local] (Only called, if the local adaptive forgetting factor is used (`type_forget=2` in the example implementation))
    429  1. [#U_prodRinvA_localprodrinva_local_pdaf.F90 U_prodRinvA_local]
    430  1. [#U_local2global_statelocal2global_state_pdaf.F90 U_local2global_state] (Called `dim_ens+1` times: Once for each ensemble member and once for the mean state estimate)
     422 1. [#U_init_dim_linit_dim_l_pdaf.F90 U_init_dim_l]
     423 1. [#U_init_dim_obs_linit_dim_obs_l_pdaf.F90 U_init_dim_obs_l]
     424 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)
     425 1. [#U_g2l_obsg2l_obs_pdaf.F90 U_g2l_obs] (A single call to localize the mean observed state)
     426 1. [#U_init_obs_linit_obs_l_pdaf.F90 U_init_obs_l]
     427 1. [#U_g2l_obsg2l_obs_pdaf.F90 U_g2l_obs] (`dim_ens` calls: one call to localize the observed part of each ensemble member)
     428 1. [#U_init_obsvar_linit_obsvar_l_pdaf.F90 U_init_obsvar_l] (Only called, if the local adaptive forgetting factor is used (`type_forget=2` in the example implementation))
     429 1. [#U_prodRinvA_lprodrinva_l_pdaf.F90 U_prodRinvA_l]
     430 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)
    431431
    432432After the loop over all local analysis domains, it is executed: