Changes between Version 2 and Version 3 of ImplementAnalysis_3DEnVar_classical


Ignore:
Timestamp:
Dec 9, 2021, 1:09:58 PM (12 months ago)
Author:
lnerger
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • ImplementAnalysis_3DEnVar_classical

    v2 v3  
    180180=== `U_init_dim_obs` (init_dim_obs_pdaf.F90) ===
    181181
    182 This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF).
     182This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF, NETF, PF) and the 3D-Var methods.
    183183
    184184The interface for this routine is:
     
    198198=== `U_obs_op` (obs_op_pdaf.F90) ===
    199199
    200 This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF).
     200This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF, NETF, PF) and the 3D-Var methods.
    201201
    202202The interface for this routine is:
     
    221221=== `U_init_obs` (init_obs_pdaf.F90) ===
    222222
    223 This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF).
     223This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF, NETF, PF) and the 3D-Var methods.
    224224
    225225The interface for this routine is:
     
    241241=== `U_prodRinvA` (prodrinva_pdaf.F90) ===
    242242
    243 This routine is used by all filter algorithms that use the inverse of the observation error covariance matrix (SEEK, SEIK, and ETKF).
     243This routine is used by all filter algorithms that use the inverse of the observation error covariance matrix (SEEK, SEIK, ESTKF, ETKF, and NETF).
    244244
    245245The interface for this routine is:
     
    262262 * The routine does not require that the product is implemented as a real matrix-matrix product. Rather, the product can be implemented in its most efficient form. For example, if the observation error covariance matrix is diagonal, only the multiplication of the diagonal with matrix `A_p` has to be implemented.
    263263 * The observation vector `obs_p` is provided through the interface for cases where the observation error variance is relative to the actual value of the observations.
    264  * The interface has a difference for SEIK and ETKF: For ETKF the third argument is the ensemble size (`dim_ens`), while for SEIK it is the rank of the covariance matrix (usually ensemble size minus one). In addition, the second dimension of `A_p` and `C_p` has size `dim_ens` for ETKF, while it is `rank` for the SEIK filter.  (Practically, one can usually ignore this difference as the fourth argument of the interface can be named arbitrarily in the routine.)
     264 * The interface has a difference for ESTKF/SEIK and ETKF: For ETKF the third argument is the ensemble size (`dim_ens`), while for ESTKF and SEIK it is the rank of the covariance matrix (usually ensemble size minus one). In addition, the second dimension of `A_p` and `C_p` has size `dim_ens` for ETKF, while it is `rank` for the ESTKF and SEIK filters.  (Practically, one can usually ignore this difference as the fourth argument of the interface can be named arbitrarily in the routine.)
    265265
    266266
     
    359359=== `U_init_dim_obs_f` (init_dim_obs_f_pdaf.F90) ===
    360360
    361 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     361This routine is used by all filter algorithms with domain-localization (LSEIK, LESTKF, LETKF, LNETF) and is independent of the particular algorithm.
    362362
    363363The interface for this routine is:
     
    377377=== `U_obs_op_f` (obs_op_f_pdaf.F90) ===
    378378
    379 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     379This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    380380
    381381The interface for this routine is:
     
    397397=== `U_init_obs_f` (init_obs_f_pdaf.F90) ===
    398398
    399 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     399This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    400400The routine is only called if the globally adaptive forgetting factor is used (`type_forget=1` in the example implementation). For the local filters there is also the alternative to use locally adaptive forgetting factors (`type_forget=2` in the example implementation)
    401401
     
    418418=== `U_init_obs_l` (init_obs_l_pdaf.F90) ===
    419419
    420 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     420This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    421421
    422422The interface for this routine is:
     
    442442=== `U_prodRinvA_l` (prodrinva_l_pdaf.F90) ===
    443443
    444 This 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.
     444This routine is used by the local filters (LSEIK, LETKF, LESTKF, LNETF). There is a slight difference between LESTKF/LSEIK and LETKF for this routine, which is described below.
    445445
    446446The interface for this routine is:
     
    457457}}}
    458458
    459 The 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`.
     459The 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 ESTKF and SEIK filters 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`.
    460460
    461461This 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.
     
    465465 * The routine does not require that the product is implemented as a real matrix-matrix product. Rather, the product can be implemented in its most efficient form. For example, if the observation error covariance matrix is diagonal, only the multiplication of the diagonal with matrix `A_l` has to be implemented.
    466466 * The observation vector `obs_l` is provided through the interface for cases where the observation error variance is relative to the actual value of the observations.
    467  * The interface has a difference for SEIK and ETKF: For ETKF the third argument is the ensemble size (`dim_ens`), while for SEIK it is the rank (`rank`) of the covariance matrix (usually ensemble size minus one). In addition, the second dimension of `A_l` and `C_l` has size `dim_ens` for ETKF, while it is `rank` for the SEIK filter. (Practically, one can usually ignore this difference as the fourth argument of the interface can be named arbitrarily in the routine.)
     467 * The interface has a difference for ESTKF/SEIK and ETKF: For ETKF the third argument is the ensemble size (`dim_ens`), while for ESTKF and SEIK it is the rank (`rank`) of the covariance matrix (usually ensemble size minus one). In addition, the second dimension of `A_l` and `C_l` has size `dim_ens` for ETKF, while it is `rank` for the ESTKF and SEIK filters. (Practically, one can usually ignore this difference as the fourth argument of the interface can be named arbitrarily in the routine.)
    468468
    469469
    470470=== `U_init_n_domains` (init_n_domains_pdaf.F90) ===
    471471
    472 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     472This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    473473
    474474The interface for this routine is:
     
    489489=== `U_init_dim_l` (init_dim_l_pdaf.F90) ===
    490490
    491 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     491This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    492492
    493493The interface for this routine is:
     
    509509=== `U_init_dim_obs_l` (init_dim_obs_l_pdaf.F90) ===
    510510
    511 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     511This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    512512
    513513The interface for this routine is:
     
    532532=== `U_g2l_state` (g2l_state_pdaf.F90) ===
    533533
    534 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     534This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    535535
    536536The interface for this routine is:
     
    554554=== `U_l2g_state` (l2g_state_pdaf.F90) ===
    555555
    556 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     556This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    557557
    558558The interface for this routine is:
     
    576576=== `U_g2l_obs` (g2l_obs_pdaf.F90) ===
    577577
    578 This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF) and is independent of the particular algorithm.
     578This routine is used by all filter algorithms with domain-localization LSEIK, LETKF, LESTKF, LNETF) and is independent of the particular algorithm.
    579579
    580580The interface for this routine is:
     
    599599=== `U_init_obsvar` (init_obsvar_pdaf.F90) ===
    600600
    601 This routine is used by the global filter algorithms SEIK and  ETKF as well as the local filters LSEIK and LETKF. The routine is only called if the adaptive forgetting factor is used (`type_forget=1` in the example implementation). The difference in this routine between global and local filters is that the global filters use 'global' while the local filters use 'full' quantities.
     601This routine is used by the global filter algorithms SEIK, ESTKF and ETKF as well as the local filters LESTKF, LSEIK and LETKF. The routine is only called if the adaptive forgetting factor is used (`type_forget=1` in the example implementation). The difference in this routine between global and local filters is that the global filters use 'global' while the local filters use 'full' quantities.
    602602
    603603The interface for this routine is:
     
    623623=== `U_init_obsvar_l` (init_obsvar_l_pdaf.F90) ===
    624624
    625 This 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).
     625This routine is used by all filter algorithms with domain-localization (LSEIK, LETKF, LESTKF, LNETF) 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).
    626626
    627627The interface for this routine is: