wiki:AvailableOptionsforInitPDAFuntilPDAF231

Available options for the different filter algorithms

This page documents the options for PDAF 2.3.1.
See the page on available options in PDAF3 for the revised options in PDAF V3.

There are different operations for each of the filter algorithms that need to be specified in the call to PDAF_init. To display the available options in a compiled assimilation program, one can use run with the specification subtype=-1. In this case PDAF_init wil display the available options for the selected filter algorithm and exit with an error status of -1.

Below we list the options as they are displayed using subtype=-1.

SEIK (filtertype=1)

PDAF     Available options for SEIK:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: full ensemble integration; left-sided application of T
PDAF       1: full ensemble integration; right-sided application of T
PDAF       2: Fixed error space basis
PDAF       3: Fixed state covariance matrix
PDAF       4: Implementation with explicit ensemble transformation
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): not used
PDAF       param_int(4): Apply incremental updating; optional
PDAF           0: no incremental updating (default)
PDAF           1: apply incremental updating
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: fixed forgetting factor (default)
PDAF           1: adaptive forgetting factor (experimental)
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: deterministic omega (default)
PDAF           1: random orthonormal omega orthogonal to (1,...,1)^T
PDAF           2: use product of 0 with random orthonomal matrix with eigenvector (1,...,1)^T
PDAF              (experimental; for random transformations, 1 is recommended)
PDAF       param_int(7): Type of transformation matrix square root; optional
PDAF           (Only relevant for subtype/=3)
PDAF           0: symmetric square root (default)
PDAF           1: Cholesky decomposition
PDAF       param_int(8): Application of observation operator H, optional
PDAF           0: Apply H to ensemble mean to compute residual (default)
PDAF           1: Apply H to all ensemble states and then compute residual from mean of these
PDAF              param_int(8)=1 is the recomended choice for nonlinear H
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     --- Internal parameter (defined inside PDAF) ---
PDAF       Nm1vsN: Normalization of covariance matrix; default: 1
PDAF           0: normalization with 1/(Ensemble size)
PDAF              (original SEIK, mainly for compatibility with older studies)
PDAF           1: normalization with 1/(Ensemble size - 1)
PDAF           (sample covariance matrix consistent with other EnKFs)
PDAF     +++++++++ End of option overview for the SEIK filter ++++++++++

EnKF (filtertype=2)

PDAF     Available options for EnKF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Full ensemble integration; analysis for 2*dim_obs>dim_ens
PDAF       1: Full ensemble integration; analysis for 2*dim_obs<=dim_ens
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): maximum rank for inversion of HPH^T, optional, default=0
PDAF           (for =0, HPH is inverted by solving the representer equation)
PDAF           (if set to >=ensemble size, it is reset to ensemble size - 1)
PDAF       param_int(4): not used
PDAF       param_int(5): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           (>=1; not larger than total number of processors)
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the EnKF ++++++++++

LSEIK (filtertype=3)

PDAF     Available options for LSEIK:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: full ensemble integration; left-sided application of T
PDAF       2: Fixed error space basis
PDAF       3: Fixed state covariance matrix
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): not used
PDAF       param_int(4): Apply incremental updating; optional
PDAF           0: no incremental updating (default)
PDAF           1: apply incremental updating
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: fixed forgetting factor (default)
PDAF           1: adaptive forgetting factor for full domain (experimental)
PDAF           2: locally adaptive forgetting factor (experimental)
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: deterministic omega (default)
PDAF           1: random orthonormal omega orthogonal to (1,...,1)^T
PDAF           2: use product of 0 with random orthonomal matrix with eigenvector (1,...,1)^T
PDAF              (experimental; for random transformations, 1 is recommended)
PDAF       param_int(7): Type of transformation matrix square root; optional
PDAF           (Only relevant for subtype/=3)
PDAF           0: symmetric square root (default)
PDAF           1: Cholesky decomposition
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     --- Internal parameter (defined inside PDAF) ---
PDAF       Nm1vsN: Normalization of covariance matrix; default: 1
PDAF           0: normalization with 1/(Ensemble size)
PDAF              (original SEIK, mainly for compatibility with older studies)
PDAF           1: normalization with 1/(Ensemble size - 1)
PDAF              (sample covariance matrix consistent with other EnKFs)
PDAF     +++++++++ End of option overview for the LSEIK filter ++++++++++

ETKF (filtertype=4)

PDAF     Available options for ETKF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: full ensemble integration; apply T-matrix analogously to SEIK
PDAF       1: full ensemble integration; formulation without T matrix
PDAF       2: Fixed error space basis; analysis with T-matrix
PDAF       3: Fixed state covariance matrix; analysis with T-matrix
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF       param_int(4): not used
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: fixed forgetting factor (default)
PDAF           1: adaptive forgetting factor (experimental)
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: deterministic transformation (default)
PDAF           2: use product of 0 with random orthonomal matrix with eigenvector (1,...,1)^T
PDAF       param_int(7): not used
PDAF       param_int(8): Application of observation operator H
PDAF           0: Apply H to ensemble mean to compute residual (default)
PDAF           1: Apply H to all ensemble states; then compute residual from mean of these
PDAF              param_int(8)=1 is the recomended choice for nonlinear H
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the ETKF ++++++++++

LETKF (filtertype=5)

PDAF     Available options for LETKF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: full ensemble integration;  apply T-matrix analogously to SEIK
PDAF       2: Fixed error space basis; analysis with T-matrix
PDAF       3: Fixed state covariance matrix; analysis with T-matrix
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF       param_int(4): not used
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: fixed forgetting factor (default)
PDAF           1: adaptive forgetting factor for full domain (experimental)
PDAF           2: locally adaptive forgetting factor (experimental)
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: deterministic transformation (default)
PDAF           2: use product of 0 with random orthonomal matrix with eigenvector (1,...,1)^T
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the LETKF ++++++++++

ESTKF (filtertype=6)

PDAF     Available options for ESTKF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Standard implementation with ensemble integration
PDAF       2: Fixed error space basis
PDAF       3: Fixed state covariance matrix
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF       param_int(4): not used
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: fixed forgetting factor (default)
PDAF           1: adaptive forgetting factor (experimental)
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: deterministic omega (default)
PDAF           1: random orthonormal omega orthogonal to (1,...,1)^T
PDAF           2: use product of 0 with random orthonomal matrix with eigenvector (1,...,1)^T
PDAF              (experimental; for random transformations, 0 or 1 are recommended)
PDAF       param_int(7): Type of transformation matrix square root; optional
PDAF           0: symmetric square root (default)
PDAF           1: Cholesky decomposition
PDAF       param_int(8): Application of observation operator H
PDAF           0: Apply H to ensemble mean to compute residual (default)
PDAF           1: Apply H to all ensemble states; then compute residual from mean of these
PDAF              param_int(8)=1 is the recomended choice for nonlinear H
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the ESTKF  ++++++++++

LESTKF (filtertype=7)

PDAF     Available options for LESTKF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Standard implementation with ensemble integration
PDAF       2: Fixed error space basis
PDAF       3: Fixed state covariance matrix
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF       param_int(4): not used
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: fixed forgetting factor (default)
PDAF           1: adaptive forgetting factor for full domain (experimental)
PDAF           2: locally adaptive forgetting factor (experimental)
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: deterministic omega (default)
PDAF           1: random orthonormal omega orthogonal to (1,...,1)^T
PDAF           2: use product of 0 with random orthonomal matrix with eigenvector (1,...,1)^T
PDAF              (experimental; for random transformations, 1 is recommended)
PDAF       param_int(7): Type of transformation matrix square root; optional
PDAF           0: symmetric square root (default)
PDAF           1: Cholesky decomposition
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the LESTKF ++++++++++

LEnKF (filtertype=8)

PDAF     Available options for LEnKF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Full ensemble integration; analysis with covariance localization
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): maximum rank for inversion of HPH^T, optional, default=0
PDAF           (for =0, HPH is inverted by solving the representer equation)
PDAF           (if set to >=ensemble size, it is reset to ensemble size - 1)
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           (>=1; not larger than total number of processors)
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the LEnKF ++++++++++

NETF (filtertype=9)

PDAF     Available options for NETF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Standard implementation with ensemble integration
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF       param_int(4): Type of ensemble perturbations, optional
PDAF           0: no perturbations (default)
PDAF           1: constant standard deviation
PDAF           2: relative to ensemble standard deviation
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: forgetting factor on forecast ensemble (default)
PDAF           2: forgetting factor on analysis ensemble
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: random orthonormal matrix orthogonal to (1,...,1)^T (default)
PDAF           1: deterministic transformation
PDAF       param_int(7): Type of weights inflation; optional
PDAF           0: no weights inflation (default)
PDAF           1: inflate so that N_eff/N > param_real(2)
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF       param_real(2): Limit for weigts inflation N_eff/N > param_real(2), optional, default=0.0
PDAF       param_real(3): Ensemble perturbation level (>0), required, only used if param_int(4)>0
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the NETF  ++++++++++

LNETF (filtertype=10)

PDAF     Available options for LNETF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Standard implementation with ensemble integration
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Size of smoothing lag (>=0), optional
PDAF           0: no smoothing (default)
PDAF           >0: apply smoother up to specified lag
PDAF       param_int(4): Type of ensemble perturbations, optional
PDAF           0: no perturbations (default)
PDAF           1: constant standard deviation
PDAF           2: relative to ensemble standard deviation
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: forgetting factor on forecast ensemble (default)
PDAF           1: forgetting factor on forecast ensemble only observed domains
PDAF           2: forgetting factor on analysis ensemble
PDAF           3: forgetting factor on analysis ensemble only observed domains
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: random orthonormal matrix orthogonal to (1,...,1)^T (default)
PDAF           1: deterministic transformation
PDAF       param_int(7): Type of weights inflation; optional
PDAF           0: no weights inflation (default)
PDAF           1: inflate so that N_eff/N > param_real(2)
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF       param_real(2): Limit for weigts inflation N_eff/N > param_real(2), optional, default=0.0
PDAF       param_real(3): Ensemble perturbation level (>0), required, only used if param_int(4)>0
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the LNETF  ++++++++++

LKNETF (filtertype=11)

Note: The LKNETF (hybrid local Kalman-nonlinear ensemble transform filter) was added in PDAF V2.1.

PDAF     Available options for LKNETF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: HNK: 2-step LKNETF with NETF before LETKF
PDAF       1: HKN: 2-step LKNETF with LETKF before NETF
PDAF       4: HSync: LKNETF synchronous
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): not used
PDAF       param_int(4): not used
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: inflate forecast ensemble by 1/forget (default)
PDAF           1: inflate forecast ensemble by 1/forget only observed domains
PDAF           2: inflate analysis ensemble by 1/forget
PDAF           3: inflate analysis ensemble by 1/forget only observed domains
PDAF       param_int(6): Type of ensemble transformation matrix; optional
PDAF           0: random orthonormal matrix orthogonal to (1,...,1)^T (default)
PDAF           1: deterministic transformation
PDAF       param_int(7): Type of hybrid weight; optional
PDAF           0: fixed value
PDAF           1: gamma_lin: (1 - N_eff/N_e)*param_real(2) (default)
PDAF           2: gamma_alpha: hybrid weight from N_eff/N>=param_real(2)
PDAF           3: gamma_ska: 1 - min(s,k)/sqrt(param_real(3)) with N_eff/N>=param_real(2)
PDAF           4: gamma_sklin: 1 - min(s,k)/sqrt(param_real(3)) >= 1-N_eff/N>=param_real(2)
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF       param_real(2): prescribed hybrid weight gamma (usually >0 and <=1), optional, default=1.0
PDAF       param_real(3): hybrid norm kappa (>0), optional, default=dim_ens
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the LKNETF  ++++++++++

PF (filtertype=12)

PDAF     Available options for PF:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Standard implementation with ensemble integration
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Resampling type, optional
PDAF           1: probabilistic resamping (default)
PDAF           2: stochastic universal resampling
PDAF           3: residual resampling
PDAF       param_int(4): Type of ensemble perturbations, optional
PDAF           0: no perturbations (default)
PDAF           1: constant standard deviation
PDAF           2: relative to ensemble standard deviation
PDAF       param_int(5): Type of forgetting factor; optional
PDAF           0: forgetting factor on forecast ensemble (default)
PDAF           2: forgetting factor on analysis ensemble
PDAF       param_int(6): Type of weights inflation; optional
PDAF           0: no weights inflation (default)
PDAF           1: inflate so that N_eff/N > param_real(2)
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Ensemble pert. level (>0), required, only used if param_int(4)>0
PDAF       param_real(2): Forgetting factor (usually >0 and <=1), optional, default=1.0
PDAF       param_real(3): Limit for weigts inflation N_eff/N > param_real(2), optional, default=0.0
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the PF  ++++++++++

GENOBS (filtertype=100)

Note: GENOBS used filtertype=11 before PDAF V2.0.

PDAF     Available options for GENOBS:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Standard implementation with ensemble integration
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required, but not used
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           =1 for GENOBS; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for GENOBS  ++++++++++

3DVAR (filtertype=200)

Note: 3D-Var methods were added in PDAF V2.0.

PDAF     Available options for 3D-Var:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: incremental 3D-Var with parameterized covariance matrix
PDAF       1: 3D ensemble Var using LESTKF for ensemble transformation
PDAF       4: 3D ensemble Var using ESTKF for ensemble transformation
PDAF       6: hybrid 3D-Var using LESTKF for ensemble transformation
PDAF       7: hybrid 3D-Var using ESTKF for ensemble transformation
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Select optimization method (solver), required
PDAF           0: LBFGS (default)
PDAF           1: CG+
PDAF           2: direct implementation of CG
PDAF           3: direct implementation of CG with decomposed control vector
PDAF       param_int(4): size of parameterized control vector (for parameterized and hybrid 3D-Var), required
PDAF       param_int(5): size of ensemble control vector (required for ensemble and hybrid 3D-Var), 
PDAF       param_int(6): Solver-specific parameter, optional
PDAF           LBFGS: parameter m (default=5)
PDAF                Number of corrections used in limited memory matrix; 3<=m<=20
PDAF           CG+: parameter method (default=2)
PDAF                (1) Fletcher-Reeves, (2) Polak-Ribiere, (3) positive Polak-Ribiere
PDAF           CG: maximum number of iterations (default=200)
PDAF       param_int(7): Solver-specific parameter, optional
PDAF           CG+: parameter irest (default=1)
PDAF                (0) no restarts; (n>0) restart every n steps
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required;
PDAF           (only used for ensemble and hybrid 3D-Var)
PDAF       param_real(2): hybrid weight beta, optional (only for hybrid 3D-Var)
PDAF           range >=0.0 and <=1.0, =1.0 for pure ensemble 3D-var  (default=0.5)
PDAF       param_real(3): Solver-specific parameter, optional
PDAF           LBFGS: Limit for stopping iterations (pgtol, default=1.0e-5)
PDAF           CG+: convergence parameter eps (default=1.0e-5)
PDAF           CG: convergence parameter eps (default=1.0e-6)
PDAF       param_real(4): Solver-specific parameter, optional
PDAF           LBFGS: Tolerance in termination test (factr, default=1.0e+7)
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for 3DVAR ++++++++++

SEEK (filtertype=0)

Note: The SEEK filter is deprecated and will be removed in a future release of PDAF.

PDAF     Available options for SEEK:
PDAF     --- Sub-types (Parameter subtype) ---
PDAF       0: Evolve unit modes with finite difference approx. of TLM
PDAF       1: like 0 with modes scaled by eigenvalues, unit U
PDAF       2: Fixed basis vectors; variable U matrix
PDAF       3: Fixed covariance matrix (V and U kept constant)
PDAF     --- Integer parameters (Array param_int) ---
PDAF       param_int(1): Dimension of state vector (>0), required
PDAF       param_int(2): Ensemble size (>0), required
PDAF       param_int(3): Interval for re-diagonalization of P (>0); optional: default 1
PDAF       param_int(4): 1 for incremental updating, 0 else; optional: default 0
PDAF     --- Floating point parameters (Array param_real) ---
PDAF       param_real(1): Forgetting factor (usually >0 and <=1), required
PDAF       param_real(2): epsilon for finite-difference approx. of TLM, required
PDAF     --- Further parameters ---
PDAF       n_modeltasks: Number of parallel model integration tasks
PDAF           >=1 for subtypes 0 and 1; not larger than total number of processors
PDAF           =1 required for subtypes 2 and 3
PDAF       screen: Control verbosity of PDAF
PDAF           0: no outputs
PDAF           1: basic output (default)
PDAF           2: 1 plus timing output
PDAF           3: 2 plus debug output
PDAF     +++++++++ End of option overview for the SEEK filter ++++++++++
Last modified 6 days ago Last modified on Mar 24, 2025, 9:58:16 AM
Note: See TracWiki for help on using the wiki.