pyPDAF.PDAF

pyPDAF.PDAF.add_increment(state_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_add_increment or PDAF source files

Parameters:

state_p (ndarray[float]) – state vector; Dimension: dim_p

Returns:

state_p – state vector; Dimension: dim_p

Return type:

ndarray[float]

pyPDAF.PDAF.assimilate_3dvar(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_3dvar or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_en3dvar_estkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_obsvar_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_en3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_en3dvar_lestkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__init_obs_f_pdaf, py__init_obs_l_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_en3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__init_obs_f_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_enkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__add_obs_err_pdaf, py__init_obs_covar_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_enkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__add_obs_err_pdaf (func) – add obs error covariance r to hph in enkf

• py__init_obs_covar_pdaf (func) – initialize obs. error cov. matrix r in enkf

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_estkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__init_obsvar_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 hv

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_etkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__init_obsvar_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_etkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 hv

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_hyb3dvar_estkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_obsvar_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_hyb3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_hyb3dvar_lestkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__init_obs_f_pdaf, py__init_obs_l_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_hyb3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__init_obs_f_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_lenkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__localize_covar_pdaf, py__add_obs_err_pdaf, py__init_obs_covar_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_lenkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__localize_covar_pdaf (func) – apply localization to hp and hph^t

• py__add_obs_err_pdaf (func) – add obs error covariance r to hph in enkf

• py__init_obs_covar_pdaf (func) – initialize obs. error cov. matrix r in enkf

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_lestkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_letkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_letkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_lknetf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__prodrinva_hyb_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__likelihood_l_pdaf, py__likelihood_hyb_l_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_lknetf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__prodrinva_hyb_l_pdaf (func) – provide product r^-1 a on local analysis domain with hybrid weight

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__likelihood_l_pdaf (func) – compute likelihood

• py__likelihood_hyb_l_pdaf (func) – compute likelihood with hybrid weight

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_lnetf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__likelihood_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_lnetf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__likelihood_l_pdaf (func) – compute observation likelihood for an ensemble member

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_lseik(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_lseik or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_netf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__likelihood_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_netf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__likelihood_pdaf (func) – compute observation likelihood for an ensemble member

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_pf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__likelihood_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_pf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__likelihood_pdaf (func) – compute observation likelihood for an ensemble member

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_prepost(py__collect_state_pdaf, py__distribute_state_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_prepost or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_seek(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_seek or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 hv

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.assimilate_seik(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_assimilate_seik or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 hv

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.deallocate()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_deallocate or PDAF source files

pyPDAF.PDAF.diag_crps(element, oens, obs)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_diag_CRPS or PDAF source files

Parameters:

• element (int) – id of element to be used. if element=0, mean values over all elements are computed

• oens (ndarray[float]) – state ensemble; Dimension: dim,dim_ens

• obs (ndarray[float]) – state ensemble; Dimension: dim

Returns:

• crps (float) – crps

• reli (float) – reliability

• resol (float) – resolution

• uncert (float) – uncertainty

• status (int) – status flag (0=success)

pyPDAF.PDAF.diag_effsample(weights)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_diag_effsample or PDAF source files

Parameters:

weights (ndarray[float]) – weights of the samples; Dimension: dim_sample

Returns:

effsample – effecfive sample size

Return type:

float

pyPDAF.PDAF.diag_ensstats(element, state, ens)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_diag_ensstats or PDAF source files

Parameters:

• element (int) – id of element to be used. if element=0, mean values over all elements are computed

• state (ndarray[float]) – state vector; Dimension: dim

• ens (ndarray[float]) – state ensemble; Dimension: dim,dim_ens

Returns:

• skewness (float) – skewness of ensemble

• kurtosis (float) – kurtosis of ensemble

• status (int) – status flag (0=success)

pyPDAF.PDAF.diag_histogram(ncall, element, state, ens, hist)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_diag_histogram or PDAF source files

Parameters:

• ncall (int) – number of calls to routine

• element (int) – element of vector used for histogram

• state (ndarray[float]) – if element=0, all elements are usedstate vector; Dimension: dim

• ens (ndarray[float]) – state ensemble; Dimension: dim,dim_ens

• hist (ndarray[int]) – histogram about the state; Dimension: dim_ens+1

Returns:

• hist (ndarray[int]) – histogram about the state; Dimension: dim_ens+1

• delta (float) – deviation measure from flat histogram

• status (int) – status flag (0=success)

pyPDAF.PDAF.enkf_omega(seed, omega, norm, otype, screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_enkf_omega or PDAF source files

Parameters:

• seed (ndarray[int]) – seed for random number generation; Dimension: 4

• omega (ndarray[float]) – random matrix; Dimension: dim_ens,r

• norm (float) – norm for ensemble transformation

• otype (int) – type of omega

• screen (int) – verbosity flag

Returns:

• omega (ndarray[float]) – random matrix; Dimension: dim_ens,r

• norm (float) – norm for ensemble transformation

pyPDAF.PDAF.eofcovar(dim_fields, offsets, remove_mstate, do_mv, states, meanstate, verbose)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_eofcovar or PDAF source files

Parameters:

• dim_fields (ndarray[int]) – size of each field; Dimension: nfields

• offsets (ndarray[int]) – start position of each field; Dimension: nfields

• remove_mstate (int) – 1: subtract mean state from statesbefore computing eofs; 0: don’t remove

• do_mv (int) – 1: do multivariate scaling; 0: no scalingnfields, dim_fields and offsets are only used if do_mv=1

• states (ndarray[float]) – state perturbations; Dimension: dim_state,nstates

• meanstate (ndarray[float]) – mean state (only changed if remove_mstate=1); Dimension: dim_state

• verbose (int) – verbosity flag

Returns:

• states (ndarray[float]) – state perturbations; Dimension: dim_state,nstates

• stddev (ndarray[float]) – standard deviation of field variabilitywithout multivariate scaling (do_mv=0), it is stddev = 1.0; Dimension: nfields

• svals (ndarray[float]) – singular values divided by sqrt(nstates-1); Dimension: nstates

• svec (ndarray[float]) – singular vectors; Dimension: dim_state,nstates

• meanstate (ndarray[float]) – mean state (only changed if remove_mstate=1); Dimension: dim_state

• status (int) – status flag

pyPDAF.PDAF.estkf_omegaa(a)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_estkf_OmegaA or PDAF source files

Parameters:

a (ndarray[float]) – input matrix; Dimension: rank,dim_col

Returns:

b – output matrix (ta); Dimension: rank+1,dim_col

Return type:

ndarray[float]

pyPDAF.PDAF.etkf_tleft(a)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_etkf_Tleft or PDAF source files

Parameters:

a (ndarray[float]) – input/output matrix; Dimension: dim_ens,dim

Returns:

a – input/output matrix; Dimension: dim_ens,dim

Return type:

ndarray[float]

pyPDAF.PDAF.force_analysis()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_force_analysis or PDAF source files

pyPDAF.PDAF.gather_dim_obs_f(dim_obs_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_gather_dim_obs_f or PDAF source files

Parameters:

dim_obs_p (int) – pe-local observation dimension

Returns:

dim_obs_f – full observation dimension

Return type:

int

pyPDAF.PDAF.gather_obs_f(obs_p, dimobs_f)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_gather_obs_f or PDAF source files

Parameters:

• obs_p (ndarray[float]) – pe-local vector; Dimension: dimobs_p

• dimobs_f (int) – dimension of full gathered obs

Returns:

• obs_f (ndarray[float]) – full gathered vector; Dimension: dimobs_f

• status (int) – status flag:(0) no error(1) when pdaf_gather_dim_obs_f not executed before

pyPDAF.PDAF.gather_obs_f2(coords_p, dimobs_f)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_gather_obs_f2 or PDAF source files

Parameters:

• coords_p (ndarray[float]) – pe-local array; Dimension: nrows,dimobs_p

• dimobs_f (int) – dimension of full gathered obs

Returns:

• coords_f (ndarray[float]) – full gathered array; Dimension: nrows,dimobs_f

• status (int) – status flag:(0) no error(1) when pdaf_gather dim_obs_f not executed before

pyPDAF.PDAF.gather_obs_f2_flex(dim_obs_f, coords_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_gather_obs_f2_flex or PDAF source files

Parameters:

• dim_obs_f (int) – full observation dimension

• coords_p (ndarray[float]) – pe-local array; Dimension: nrows,dim_obs_p

Returns:

• coords_f (ndarray[float]) – full gathered array; Dimension: nrows,dim_obs_f

• status (int) – status flag: (0) no error

pyPDAF.PDAF.gather_obs_f_flex(dim_obs_f, obs_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_gather_obs_f_flex or PDAF source files

Parameters:

• dim_obs_f (int) – full observation dimension

• obs_p (ndarray[float]) – pe-local vector; Dimension: dim_obs_p

Returns:

• obs_f (ndarray[float]) – full gathered vector; Dimension: dim_obs_f

• status (int) – status flag: (0) no error

pyPDAF.PDAF.generate_obs(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__get_obs_f_pdaf, py__init_obserr_f_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_generate_obs or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__get_obs_f_pdaf (func) – provide observation vector to user

• py__init_obserr_f_pdaf (func) – initialize vector of observation error standard deviations

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.get_assim_flag()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_assim_flag or PDAF source files

Returns:

did_assim – flag: (1) for assimilation; (0) else

Return type:

int

pyPDAF.PDAF.get_ensstats()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_ensstats or PDAF source files

Returns:

• dims (ndarray[int]) – dimension of pointer; Dimension: 1

• c_skew_ptr (ndarray[float]) – pointer to skewness array

• c_kurt_ptr (ndarray[float]) – pointer to kurtosis array

• status (int) – status flag

pyPDAF.PDAF.get_localfilter()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_localfilter or PDAF source files

Returns:

lfilter – whether the filter is domain-localized

Return type:

int

pyPDAF.PDAF.get_memberid(memberid)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_memberid or PDAF source files

Parameters:

memberid (int) – index in the local ensemble

Returns:

memberid – index in the local ensemble

Return type:

int

pyPDAF.PDAF.get_obsmemberid(memberid)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_obsmemberid or PDAF source files

Parameters:

memberid (int) – index in the local observed ensemble

Returns:

memberid – index in the local observed ensemble

Return type:

int

pyPDAF.PDAF.get_smootherens()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_smootherens or PDAF source files

Returns:

• c_sens_point (ndarray[float]) – pointer to smoother array

• maxlag (int) – number of past timesteps processed in sens

• dims (ndarray[int]) – dimension of pointer; Dimension: 3

• status (int) – status flag

pyPDAF.PDAF.get_state(steps, doexit, py__next_observation_pdaf, py__distribute_state_pdaf, py__prepoststep_pdaf, flag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_get_state or PDAF source files

Parameters:

• steps (int) – flag and number of time steps

• doexit (int) – whether to exit from forecasts

• py__next_observation_pdaf (func) – provide time step and time of next observation

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• flag (int) – status flag

Returns:

• steps (int) – flag and number of time steps

• time (float) – current model time

• doexit (int) – whether to exit from forecasts

• flag (int) – status flag

pyPDAF.PDAF.global_except_hook(exctype, value, traceback)

pyPDAF.PDAF.incr_local_obsstats(dim_obs_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_incr_local_obsstats or PDAF source files

Parameters:

dim_obs_l (int) – number of locally assimilated observations

pyPDAF.PDAF.incremental(steps, py__dist_stateinc_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_incremental or PDAF source files

Parameters:

• steps (int) – time steps over which increment is distributed

• py__dist_stateinc_pdaf (func) – add state increment during integration

pyPDAF.PDAF.init(filtertype, subtype, stepnull, param_int, param_real, comm_model, comm_filter, comm_couple, task_id, n_modeltasks, in_filterpe, py__init_ens_pdaf, in_screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_init or PDAF source files

Parameters:

• filtertype (int) – type of filter

• subtype (int) – sub-type of filter

• stepnull (int) – initial time step of assimilation

• param_int (ndarray[int]) – integer parameter array; Dimension: dim_pint

• param_real (ndarray[float]) – real parameter array; Dimension: dim_preal

• comm_model (int) – model communicator

• comm_filter (int) – filter communicator

• comm_couple (int) – coupling communicator

• task_id (int) – id of my ensemble task

• n_modeltasks (int) – number of parallel model tasks

• in_filterpe (bool) – is my pe a filter-pe?

• py__init_ens_pdaf (func) – user-supplied routine for ensemble initialization

• in_screen (int) – control screen output:

Returns:

• param_int (ndarray[int]) – integer parameter array; Dimension: dim_pint

• param_real (ndarray[float]) – real parameter array; Dimension: dim_preal

• flag (int) – status flag, 0: no error, error codes:

pyPDAF.PDAF.init_local_obsstats()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_init_local_obsstats or PDAF source files

pyPDAF.PDAF.local_weight(wtype, rtype, cradius, sradius, distance, a, var_obs, verbose)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_local_weight or PDAF source files

Parameters:

• wtype (int) – type of weight function

• rtype (int) – type of regulated weighting

• cradius (float) – cut-off radius

• sradius (float) – support radius

• distance (float) – distance to observation

• a (ndarray[float]) – input matrix; Dimension: nrows,ncols

• var_obs (float) – observation variance

• verbose (int) – verbosity flag

Returns:

weight – weights

Return type:

float

pyPDAF.PDAF.local_weights(wtype, cradius, sradius, distance, verbose)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_local_weights or PDAF source files

Parameters:

• wtype (int) – type of weight function(0): unit weight (=1 up to distance=cradius)(1): exponential decrease (1/e at distance=sradius; 0 for distance>cradius)(2): 5th order polynomial (gaspari&cohn 1999; 0 for distance>cradius)

• cradius (float) – parameter for cut-off

• sradius (float) – support radius

• distance (ndarray[float]) – array holding distances; Dimension: dim

• verbose (int) – verbosity flag

Returns:

weight – array for weights; Dimension: dim

Return type:

ndarray[float]

pyPDAF.PDAF.omi_add_obs_error_cb(step, dim_obs_p, c_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_add_obs_error_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs_p (int) – dimension of pe-local observation vector

• c_p (ndarray[float]) – matrix to which r is added; Dimension: dim_obs_p,dim_obs_p

Returns:

c_p – matrix to which r is added; Dimension: dim_obs_p,dim_obs_p

Return type:

ndarray[float]

pyPDAF.PDAF.omi_assimilate_3dvar(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_3dvar or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step, time and dimension of next observation

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_en3dvar_estkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_en3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__cvt_ens_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step, time and dimension of next observation

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_en3dvar_lestkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_en3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of full observation vector

• py__obs_op_f_pdaf (func) – full observation operator

• py__cvt_ens_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize local dimimension of obs. vector

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from local state

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step, time and dimension of next observation

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_global(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_global or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_hyb3dvar_estkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_hyb3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__cvt_ens_pdaf (func) – apply ensemble control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint ensemble control vector transform matrix

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step, time and dimension of next observation

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_hyb3dvar_lestkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_hyb3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of full observation vector

• py__obs_op_f_pdaf (func) – full observation operator

• py__cvt_ens_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize local dimimension of obs. vector

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from local state

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step, time and dimension of next observation

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_lenkf(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__prepoststep_pdaf, py__localize_covar_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_lenkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__localize_covar_pdaf (func) – apply localization to hp and hph^t

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_assimilate_local(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__prepoststep_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_assimilate_local or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_check_error(flag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_check_error or PDAF source files

Parameters:

flag (int) – < error flag

Returns:

flag – < error flag

Return type:

int

pyPDAF.PDAF.omi_deallocate_obs(i_obs)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_deallocate_obs or PDAF source files

Parameters:

i_obs (int) – index of observations

pyPDAF.PDAF.omi_g2l_obs_cb(domain_p, step, dim_obs_f, dim_obs_l, ostate_f, ostate_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_g2l_obs_cb or PDAF source files

Parameters:

• domain_p (int) – index of current local analysis domain

• step (int) – current time step

• dim_obs_f (int) – dimension of full pe-local observation vector

• dim_obs_l (int) – dimension of local observation vector

• ostate_f (ndarray[float]) – full pe-local obs.ervation vector; Dimension: dim_obs_f

• ostate_l (ndarray[float]) – observation vector on local domain; Dimension: dim_obs_l

Returns:

ostate_l – observation vector on local domain; Dimension: dim_obs_l

Return type:

ndarray[float]

pyPDAF.PDAF.omi_gather_obs(i_obs, obs_p, ivar_obs_p, ocoord_p, cradius)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/pdafomi_gather_obs or PDAF source files

Parameters:

• i_obs (int) – index of observations

• obs_p (ndarray[float]) – pe-local observation vector; Dimension: dim_obs_p

• ivar_obs_p (ndarray[float]) – pe-local inverse observation error variance; Dimension: dim_obs_p

• ocoord_p (ndarray[float]) – pe-local observation coordinates; Dimension: thisobs(i_obs)%ncoord,dim_obs_p

• cradius (float) – localization radius

Returns:

dim_obs – full number of observations

Return type:

int

pyPDAF.PDAF.omi_gather_obsdims()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_gather_obsdims or PDAF source files

pyPDAF.PDAF.omi_gather_obsstate(i_obs, obsstate_p, obsstate_f)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_gather_obsstate or PDAF source files

Parameters:

• i_obs (int) – index of observations

• obsstate_p (ndarray[float]) – vector of process-local observed state; Dimension: thisobs(i_obs)%dim_obs_p

• obsstate_f (ndarray[float]) – full observed vector for all types; Dimension: nobs_f_all

Returns:

obsstate_f – full observed vector for all types; Dimension: nobs_f_all

Return type:

ndarray[float]

pyPDAF.PDAF.omi_generate_obs(py__collect_state_pdaf, py__distribute_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__get_obs_f_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_generate_obs or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__get_obs_f_pdaf (func) – provide observation vector to user

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – provide time step and time of next observation

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_get_interp_coeff_lin(gpc, oc, icoeff)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_get_interp_coeff_lin or PDAF source files

Parameters:

• gpc (ndarray[float]) – coordinates of grid points; Dimension: num_gp,n_dim

• oc (ndarray[float]) – coordinates of observation; Dimension: n_dim

• icoeff (ndarray[float]) – interpolation coefficients (num_gp); Dimension: num_gp

Returns:

icoeff – interpolation coefficients (num_gp); Dimension: num_gp

Return type:

ndarray[float]

pyPDAF.PDAF.omi_get_interp_coeff_lin1d(gpc, oc, icoeff)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_get_interp_coeff_lin1D or PDAF source files

Parameters:

• gpc (ndarray[float]) – coordinates of grid points (dim=2); Dimension: 2

• oc (float) – coordinates of observation

• icoeff (ndarray[float]) – interpolation coefficients (dim=2); Dimension: 2

Returns:

icoeff – interpolation coefficients (dim=2); Dimension: 2

Return type:

ndarray[float]

pyPDAF.PDAF.omi_get_interp_coeff_tri(gpc, oc, icoeff)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_get_interp_coeff_tri or PDAF source files

Parameters:

• gpc (ndarray[float]) – coordinates of grid points; dim(3,2); Dimension: 3,2

• oc (ndarray[float]) – 3 rows; each containing lon and lat coordinatescoordinates of observation; dim(2); Dimension: 2

• icoeff (ndarray[float]) – interpolation coefficients; dim(3); Dimension: 3

Returns:

icoeff – interpolation coefficients; dim(3); Dimension: 3

Return type:

ndarray[float]

pyPDAF.PDAF.omi_init(n_obs)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init or PDAF source files

Parameters:

n_obs (int) – number of observations

pyPDAF.PDAF.omi_init_dim_obs_l_iso(i_obs, coords_l, locweight, cradius, sradius, cnt_obs_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_dim_obs_l_iso or PDAF source files

Parameters:

• i_obs (int) – < index of observation type

• coords_l (ndarray[float]) – < coordinates of current analysis domain; Dimension: ncoord

• locweight (int) – < type of localization function

• cradius (float) – < localization cut-off radius (single or vector)

• sradius (float) – < support radius of localization function (single or vector)

• cnt_obs_l (int) – < local dimension of current observation vector

Returns:

cnt_obs_l – < local dimension of current observation vector

Return type:

int

pyPDAF.PDAF.omi_init_dim_obs_l_noniso(i_obs, coords_l, locweight, cradius, sradius, cnt_obs_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_dim_obs_l_noniso or PDAF source files

Parameters:

• i_obs (int) – < index of observation type

• coords_l (ndarray[float]) – < coordinates of current analysis domain; Dimension: ncoord

• locweight (int) – < type of localization function

• cradius (ndarray[float]) – < vector of localization cut-off radii; Dimension: ncoord

• sradius (ndarray[float]) – < vector of support radii of localization function; Dimension: ncoord

• cnt_obs_l (int) – < local dimension of current observation vector

Returns:

cnt_obs_l – < local dimension of current observation vector

Return type:

int

pyPDAF.PDAF.omi_init_dim_obs_l_noniso_locweights(i_obs, coords_l, locweights, cradius, sradius, cnt_obs_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_dim_obs_l_noniso_locweights or PDAF source files

Parameters:

• i_obs (int) – < index of observation type

• coords_l (ndarray[float]) – < coordinates of current analysis domain; Dimension: ncoord

• locweights (ndarray[int]) – < types of localization function; Dimension: 2

• cradius (ndarray[float]) – < vector of localization cut-off radii; Dimension: ncoord

• sradius (ndarray[float]) – < vector of support radii of localization function; Dimension: ncoord

• cnt_obs_l (int) – < local dimension of current observation vector

Returns:

cnt_obs_l – < local dimension of current observation vector

Return type:

int

pyPDAF.PDAF.omi_init_obs_f_cb(step, dim_obs_f, observation_f)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_obs_f_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs_f (int) – dimension of full observation vector

• observation_f (ndarray[float]) – full observation vector; Dimension: dim_obs_f

Returns:

observation_f – full observation vector; Dimension: dim_obs_f

Return type:

ndarray[float]

pyPDAF.PDAF.omi_init_obs_l_cb(domain_p, step, dim_obs_l, observation_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_obs_l_cb or PDAF source files

Parameters:

• domain_p (int) – index of current local analysis domain index

• step (int) – current time step

• dim_obs_l (int) – local dimension of observation vector

• observation_l (ndarray[float]) – local observation vector; Dimension: dim_obs_l

Returns:

observation_l – local observation vector; Dimension: dim_obs_l

Return type:

ndarray[float]

pyPDAF.PDAF.omi_init_obscovar_cb(step, dim_obs, dim_obs_p, covar, m_state_p, isdiag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_obscovar_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs (int) – dimension of observation vector

• dim_obs_p (int) – pe-local dimension of obs. vector

• covar (ndarray[float]) – observation error covar. matrix; Dimension: dim_obs,dim_obs

• m_state_p (ndarray[float]) – observation vector; Dimension: dim_obs_p

• isdiag (bool) – whether matrix r is diagonal

Returns:

• covar (ndarray[float]) – observation error covar. matrix; Dimension: dim_obs,dim_obs

• isdiag (bool) – whether matrix r is diagonal

pyPDAF.PDAF.omi_init_obserr_f_cb(step, dim_obs_f, obs_f, obserr_f)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_obserr_f_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs_f (int) – full dimension of observation vector

• obs_f (ndarray[float]) – full observation vector; Dimension: dim_obs_f

• obserr_f (ndarray[float]) – full observation error stddev; Dimension: dim_obs_f

Returns:

obserr_f – full observation error stddev; Dimension: dim_obs_f

Return type:

ndarray[float]

pyPDAF.PDAF.omi_init_obsvar_cb(step, dim_obs_p, obs_p, meanvar)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_obsvar_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs_p (int) – pe-local dimension of observation vector

• obs_p (ndarray[float]) – pe-local observation vector; Dimension: dim_obs_p

• meanvar (float) – mean observation error variance

Returns:

meanvar – mean observation error variance

Return type:

float

pyPDAF.PDAF.omi_init_obsvar_l_cb(domain_p, step, dim_obs_l, obs_l, meanvar_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_init_obsvar_l_cb or PDAF source files

Parameters:

• domain_p (int) – index of current local analysis domain

• step (int) – current time step

• dim_obs_l (int) – local dimension of observation vector

• obs_l (ndarray[float]) – local observation vector; Dimension: dim_obs_l

• meanvar_l (float) – mean local observation error variance

Returns:

meanvar_l – mean local observation error variance

Return type:

float

pyPDAF.PDAF.omi_likelihood_cb(step, dim_obs, obs, resid, lhood)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_likelihood_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs (int) – pe-local dimension of obs. vector

• obs (ndarray[float]) – pe-local vector of observations; Dimension: dim_obs

• resid (ndarray[float]) – input vector of residuum; Dimension: dim_obs

• lhood (float) – output vector - log likelihood

Returns:

lhood – output vector - log likelihood

Return type:

float

pyPDAF.PDAF.omi_likelihood_hyb_l_cb(domain_p, step, dim_obs_l, obs_l, resid_l, alpha, lhood_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_likelihood_hyb_l_cb or PDAF source files

Parameters:

• domain_p (int) – current local analysis domain

• step (int) – current time step

• dim_obs_l (int) – pe-local dimension of obs. vector

• obs_l (ndarray[float]) – pe-local vector of observations; Dimension: dim_obs_l

• resid_l (ndarray[float]) – input vector of residuum; Dimension: dim_obs_l

• alpha (float) – hybrid weight

• lhood_l (float) – output vector - log likelihood

Returns:

• resid_l (ndarray[float]) – input vector of residuum; Dimension: dim_obs_l

• lhood_l (float) – output vector - log likelihood

pyPDAF.PDAF.omi_likelihood_l_cb(domain_p, step, dim_obs_l, obs_l, resid_l, lhood_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_likelihood_l_cb or PDAF source files

Parameters:

• domain_p (int) – current local analysis domain

• step (int) – current time step

• dim_obs_l (int) – pe-local dimension of obs. vector

• obs_l (ndarray[float]) – pe-local vector of observations; Dimension: dim_obs_l

• resid_l (ndarray[float]) – input vector of residuum; Dimension: dim_obs_l

• lhood_l (float) – output vector - log likelihood

Returns:

• resid_l (ndarray[float]) – input vector of residuum; Dimension: dim_obs_l

• lhood_l (float) – output vector - log likelihood

pyPDAF.PDAF.omi_localize_covar_iso(i_obs, locweight, cradius, sradius, coords, hp, hph)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_localize_covar_iso or PDAF source files

Parameters:

• i_obs (int) – < index of observation type

• locweight (int) – < localization weight type

• cradius (float) – < localization radius

• sradius (float) – < support radius for weight functions

• coords (ndarray[float]) – < coordinates of state vector elements; Dimension: ncoord,dim_p

• hp (ndarray[float]) – < matrix hp, dimension (nobs, dim); Dimension: dim_obs,dim_p

• hph (ndarray[float]) – < matrix hph, dimension (nobs, nobs); Dimension: dim_obs,dim_obs

Returns:

• hp (ndarray[float]) – < matrix hp, dimension (nobs, dim); Dimension: dim_obs,dim_p

• hph (ndarray[float]) – < matrix hph, dimension (nobs, nobs); Dimension: dim_obs,dim_obs

pyPDAF.PDAF.omi_localize_covar_noniso(i_obs, locweight, cradius, sradius, coords, hp, hph)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_localize_covar_noniso or PDAF source files

Parameters:

• i_obs (int) – < data type with full observation

• locweight (int) – < localization weight type

• cradius (ndarray[float]) – < vector of localization cut-off radii; Dimension: ncoord

• sradius (ndarray[float]) – < vector of support radii of localization function; Dimension: ncoord

• coords (ndarray[float]) – < coordinates of state vector elements; Dimension: ncoord,dim_p

• hp (ndarray[float]) – < matrix hp, dimension (nobs, dim); Dimension: dim_obs,dim_p

• hph (ndarray[float]) – < matrix hph, dimension (nobs, nobs); Dimension: dim_obs,dim_obs

Returns:

• hp (ndarray[float]) – < matrix hp, dimension (nobs, dim); Dimension: dim_obs,dim_p

• hph (ndarray[float]) – < matrix hph, dimension (nobs, nobs); Dimension: dim_obs,dim_obs

pyPDAF.PDAF.omi_localize_covar_noniso_locweights(i_obs, locweights, cradius, sradius, coords, hp, hph)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_localize_covar_noniso_locweights or PDAF source files

Parameters:

• i_obs (int) – < index of observation type

• locweights (ndarray[int]) – < types of localization function; Dimension: 2

• cradius (ndarray[float]) – < vector of localization cut-off radii; Dimension: ncoord

• sradius (ndarray[float]) – < vector of support radii of localization function; Dimension: ncoord

• coords (ndarray[float]) – < coordinates of state vector elements; Dimension: ncoord,dim_p

• hp (ndarray[float]) – < matrix hp, dimension (nobs, dim); Dimension: dim_obs,dim_p

• hph (ndarray[float]) – < matrix hph, dimension (nobs, nobs); Dimension: dim_obs,dim_obs

Returns:

• hp (ndarray[float]) – < matrix hp, dimension (nobs, dim); Dimension: dim_obs,dim_p

• hph (ndarray[float]) – < matrix hph, dimension (nobs, nobs); Dimension: dim_obs,dim_obs

pyPDAF.PDAF.omi_obs_op_adj_gridavg(i_obs, nrows, state_p, obs_f_all)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obs_op_adj_gridavg or PDAF source files

Parameters:

• i_obs (int) – index of observations

• nrows (int) – number of values to be averaged

• state_p (ndarray[float]) – pe-local model state (dim_p); Dimension: dim_p

• obs_f_all (ndarray[float]) – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Returns:

state_p – pe-local model state (dim_p); Dimension: dim_p

Return type:

ndarray[float]

pyPDAF.PDAF.omi_obs_op_adj_gridpoint(i_obs, state_p, obs_f_all)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obs_op_adj_gridpoint or PDAF source files

Parameters:

• i_obs (int) – index of observations

• state_p (ndarray[float]) – pe-local model state (dim_p); Dimension: dim_p

• obs_f_all (ndarray[float]) – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Returns:

state_p – pe-local model state (dim_p); Dimension: dim_p

Return type:

ndarray[float]

pyPDAF.PDAF.omi_obs_op_adj_interp_lin(i_obs, nrows, state_p, obs_f_all)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obs_op_adj_interp_lin or PDAF source files

Parameters:

• i_obs (int) – index of observations

• nrows (int) – number of values to be averaged

• state_p (ndarray[float]) – pe-local model state (dim_p); Dimension: dim_p

• obs_f_all (ndarray[float]) – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Returns:

state_p – pe-local model state (dim_p); Dimension: dim_p

Return type:

ndarray[float]

pyPDAF.PDAF.omi_obs_op_gridavg(i_obs, nrows, state_p, obs_f_all)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obs_op_gridavg or PDAF source files

Parameters:

• i_obs (int) – index of observations

• nrows (int) – number of values to be averaged

• state_p (ndarray[float]) – pe-local model state (dim_p); Dimension: dim_p

• obs_f_all (ndarray[float]) – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Returns:

obs_f_all – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Return type:

ndarray[float]

pyPDAF.PDAF.omi_obs_op_gridpoint(i_obs, state_p, obs_f_all)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obs_op_gridpoint or PDAF source files

Parameters:

• i_obs (int) – index of observations

• state_p (ndarray[float]) – pe-local model state (dim_p); Dimension: dim_p

• obs_f_all (ndarray[float]) – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Returns:

obs_f_all – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Return type:

ndarray[float]

pyPDAF.PDAF.omi_obs_op_interp_lin(i_obs, nrows, state_p, obs_f_all)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obs_op_interp_lin or PDAF source files

Parameters:

• i_obs (int) – index of observations

• nrows (int) – number of values to be averaged

• state_p (ndarray[float]) – pe-local model state (dim_p); Dimension: dim_p

• obs_f_all (ndarray[float]) – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Returns:

obs_f_all – full observed state for all observation types (nobs_f_all); Dimension: nobs_f_all

Return type:

ndarray[float]

pyPDAF.PDAF.omi_obsstats(screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obsstats or PDAF source files

Parameters:

screen (int) – < verbosity flag

pyPDAF.PDAF.omi_obsstats_l(screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_obsstats_l or PDAF source files

Parameters:

screen (int) – < verbosity flag

pyPDAF.PDAF.omi_omit_by_inno_cb(dim_obs_f, resid_f, obs_f)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_omit_by_inno_cb or PDAF source files

Parameters:

• dim_obs_f (int) – < full dimension of obs. vector

• resid_f (ndarray[float]) – < input vector of residuum; Dimension: dim_obs_f

• obs_f (ndarray[float]) – < input vector of full observations; Dimension: dim_obs_f

Returns:

• resid_f (ndarray[float]) – < input vector of residuum; Dimension: dim_obs_f

• obs_f (ndarray[float]) – < input vector of full observations; Dimension: dim_obs_f

pyPDAF.PDAF.omi_omit_by_inno_l_cb(domain_p, dim_obs_l, resid_l, obs_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_omit_by_inno_l_cb or PDAF source files

Parameters:

• domain_p (int) – < current local analysis domain

• dim_obs_l (int) – < pe-local dimension of obs. vector

• resid_l (ndarray[float]) – < input vector of residuum; Dimension: dim_obs_l

• obs_l (ndarray[float]) – < input vector of local observations; Dimension: dim_obs_l

Returns:

• resid_l (ndarray[float]) – < input vector of residuum; Dimension: dim_obs_l

• obs_l (ndarray[float]) – < input vector of local observations; Dimension: dim_obs_l

pyPDAF.PDAF.omi_prodrinva_cb(step, dim_obs_p, ncol, obs_p, a_p, c_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_prodRinvA_cb or PDAF source files

Parameters:

• step (int) – current time step

• dim_obs_p (int) – dimension of pe-local observation vector

• ncol (int) – number of columns in a_p and c_p

• obs_p (ndarray[float]) – pe-local vector of observations; Dimension: dim_obs_p

• a_p (ndarray[float]) – input matrix; Dimension: dim_obs_p,ncol

• c_p (ndarray[float]) – output matrix; Dimension: dim_obs_p,ncol

Returns:

c_p – output matrix; Dimension: dim_obs_p,ncol

Return type:

ndarray[float]

pyPDAF.PDAF.omi_prodrinva_hyb_l_cb(domain_p, step, dim_obs_l, rank, obs_l, alpha, a_l, c_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_prodRinvA_hyb_l_cb or PDAF source files

Parameters:

• domain_p (int) – index of current local analysis domain

• step (int) – current time step

• dim_obs_l (int) – dimension of local observation vector

• rank (int) – rank of initial covariance matrix

• obs_l (ndarray[float]) – local vector of observations; Dimension: dim_obs_l

• alpha (float) – hybrid weight

• a_l (ndarray[float]) – input matrix; Dimension: dim_obs_l,rank

• c_l (ndarray[float]) – output matrix; Dimension: dim_obs_l,rank

Returns:

• a_l (ndarray[float]) – input matrix; Dimension: dim_obs_l,rank

• c_l (ndarray[float]) – output matrix; Dimension: dim_obs_l,rank

pyPDAF.PDAF.omi_prodrinva_l_cb(domain_p, step, dim_obs_l, rank, obs_l, a_l, c_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_prodRinvA_l_cb or PDAF source files

Parameters:

• domain_p (int) – index of current local analysis domain

• step (int) – current time step

• dim_obs_l (int) – dimension of local observation vector

• rank (int) – rank of initial covariance matrix

• obs_l (ndarray[float]) – local vector of observations; Dimension: dim_obs_l

• a_l (ndarray[float]) – input matrix; Dimension: dim_obs_l,rank

• c_l (ndarray[float]) – output matrix; Dimension: dim_obs_l,rank

Returns:

• a_l (ndarray[float]) – input matrix; Dimension: dim_obs_l,rank

• c_l (ndarray[float]) – output matrix; Dimension: dim_obs_l,rank

pyPDAF.PDAF.omi_put_state_3dvar(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_3dvar or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_en3dvar_estkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_en3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__cvt_ens_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_en3dvar_lestkf(py__collect_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__prepoststep_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_en3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of full observation vector

• py__obs_op_f_pdaf (func) – full observation operator

• py__cvt_ens_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize local dimimension of obs. vector

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from local state

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_generate_obs(py__collect_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__get_obs_f_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_generate_obs or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__get_obs_f_pdaf (func) – provide observation vector to user

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_global(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_global or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_hyb3dvar_estkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_hyb3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__cvt_ens_pdaf (func) – apply ensemble control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint ensemble control vector transform matrix

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_hyb3dvar_lestkf(py__collect_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__prepoststep_pdaf, outflag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_hyb3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of full observation vector

• py__obs_op_f_pdaf (func) – full observation operator

• py__cvt_ens_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize local dimimension of obs. vector

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from local state

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• outflag (int) – status flag

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_lenkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__prepoststep_pdaf, py__localize_covar_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_lenkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__localize_covar_pdaf (func) – apply localization to hp and hph^t

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_put_state_local(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__prepoststep_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_put_state_local or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.omi_set_debug_flag(debugval)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_debug_flag or PDAF source files

Parameters:

debugval (int) – value for debugging flag

pyPDAF.PDAF.omi_set_disttype(i_obs, disttype)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_disttype or PDAF source files

Parameters:

• i_obs (int) – index of observations

• disttype (int) – setter value

pyPDAF.PDAF.omi_set_doassim(i_obs, doassim)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_doassim or PDAF source files

Parameters:

• i_obs (int) – index of observations

• doassim (int) – setter value

pyPDAF.PDAF.omi_set_domain_limits(lim_coords)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_domain_limits or PDAF source files

Parameters:

lim_coords (ndarray[float]) – geographic coordinate array (1: longitude, 2: latitude); Dimension: 2,2

pyPDAF.PDAF.omi_set_domainsize(i_obs, domainsize)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_domainsize or PDAF source files

Parameters:

• i_obs (int) – index of observations

• domainsize (ndarray[float]) – setter value; Dimension: ncoord

pyPDAF.PDAF.omi_set_icoeff_p(i_obs, icoeff_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_icoeff_p or PDAF source files

Parameters:

• i_obs (int) – index of observations

• icoeff_p (ndarray[float]) – setter value; Dimension: nrows,dim_obs_p

pyPDAF.PDAF.omi_set_id_obs_p(i_obs, id_obs_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_id_obs_p or PDAF source files

Parameters:

• i_obs (int) – index of observations

• id_obs_p (ndarray[int]) – setter value; Dimension: nrows,dim_obs_p

pyPDAF.PDAF.omi_set_inno_omit(i_obs, inno_omit)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_inno_omit or PDAF source files

Parameters:

• i_obs (int) – index of observations

• inno_omit (float) – setter value

pyPDAF.PDAF.omi_set_inno_omit_ivar(i_obs, inno_omit_ivar)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_inno_omit_ivar or PDAF source files

Parameters:

• i_obs (int) – index of observations

• inno_omit_ivar (float) – setter value

pyPDAF.PDAF.omi_set_ncoord(i_obs, ncoord)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_ncoord or PDAF source files

Parameters:

• i_obs (int) – index of observations

• ncoord (int) – setter value

pyPDAF.PDAF.omi_set_obs_err_type(i_obs, obs_err_type)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_obs_err_type or PDAF source files

Parameters:

• i_obs (int) – index of observations

• obs_err_type (int) – setter value

pyPDAF.PDAF.omi_set_use_global_obs(i_obs, use_global_obs)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_set_use_global_obs or PDAF source files

Parameters:

• i_obs (int) – index of observations

• use_global_obs (int) – setter value

pyPDAF.PDAF.omi_weights_l(verbose, locweight, cradius, sradius, mata, ivar_obs_l, dist_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_weights_l or PDAF source files

Parameters:

• verbose (int) – < verbosity flag

• locweight (int) – < localization weight type

• cradius (ndarray[float]) – < localization cut-off radius; Dimension: nobs_l

• sradius (ndarray[float]) – < support radius for weight functions; Dimension: nobs_l

• mata (ndarray[float]) – <; Dimension: nobs_l,ncols

• ivar_obs_l (ndarray[float]) – < local vector of inverse obs. variances (nobs_l); Dimension: nobs_l

• dist_l (ndarray[float]) – < local vector of obs. distances (nobs_l); Dimension: nobs_l

Returns:

weight_l – < output: vector of weights; Dimension: nobs_l

Return type:

ndarray[float]

pyPDAF.PDAF.omi_weights_l_sgnl(verbose, locweight, cradius, sradius, mata, ivar_obs_l, dist_l)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAFomi_weights_l_sgnl or PDAF source files

Parameters:

• verbose (int) – < verbosity flag

• locweight (int) – < localization weight type

• cradius (float) – < localization cut-off radius

• sradius (float) – < support radius for weight functions

• mata (ndarray[float]) – <; Dimension: nobs_l,ncols

• ivar_obs_l (ndarray[float]) – < local vector of inverse obs. variances (nobs_l); Dimension: nobs_l

• dist_l (ndarray[float]) – < local vector of obs. distances (nobs_l); Dimension: nobs_l

Returns:

weight_l – < output: vector of weights; Dimension: nobs_l

Return type:

ndarray[float]

pyPDAF.PDAF.omit_obs_omi(state_p, ens_p, obs_p, py__init_obs_pdaf, py__obs_op_pdaf, compute_mean, screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_omit_obs_omi or PDAF source files

Parameters:

• state_p (ndarray[float]) – on exit: pe-local forecast mean state; Dimension: dim_p

• ens_p (ndarray[float]) – pe-local state ensemble; Dimension: dim_p,dim_ens

• obs_p (ndarray[float]) – pe-local observation vector; Dimension: dim_obs_p

• py__init_obs_pdaf (func) – initialize observation vector

• py__obs_op_pdaf (func) – observation operator

• compute_mean (int) –

  1. compute mean; (0) state_p holds mean

• screen (int) – verbosity flag

Returns:

• state_p (ndarray[float]) – on exit: pe-local forecast mean state; Dimension: dim_p

• obs_p (ndarray[float]) – pe-local observation vector; Dimension: dim_obs_p

pyPDAF.PDAF.prepost(py__collect_state_pdaf, py__distribute_state_pdaf, py__prepoststep_pdaf, py__next_observation_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_prepost or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__distribute_state_pdaf (func) – routine to distribute a state vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__next_observation_pdaf (func) – routine to provide time step, time and dimension of next observation

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.print_domain_stats(n_domains_p)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_print_domain_stats or PDAF source files

Parameters:

n_domains_p (int) – number of pe-local analysis domains

pyPDAF.PDAF.print_info(printtype)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_print_info or PDAF source files

Parameters:

printtype (int) – type of screen output

pyPDAF.PDAF.print_local_obsstats(screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_print_local_obsstats or PDAF source files

Parameters:

screen (int) – verbosity flag

Returns:

n_domains_with_obs – number of domains with observations

Return type:

int

pyPDAF.PDAF.put_state_3dvar(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_3dvar or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_en3dvar_estkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_obsvar_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_en3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_en3dvar_lestkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__init_obs_f_pdaf, py__init_obs_l_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_en3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__init_obs_f_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_enkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__add_obs_err_pdaf, py__init_obs_covar_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_enkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__add_obs_err_pdaf (func) – add obs error covariance r to hph in enkf

• py__init_obs_covar_pdaf (func) – initialize obs. error cov. matrix r in enkf

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_estkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__init_obsvar_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_etkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__init_obsvar_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_etkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_generate_obs(py__collect_state_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__get_obs_f_pdaf, py__init_obserr_f_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_generate_obs or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__get_obs_f_pdaf (func) – provide observation vector to user

• py__init_obserr_f_pdaf (func) – initialize vector of observation errors

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_hyb3dvar_estkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_obsvar_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_hyb3dvar_estkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_hyb3dvar_lestkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prodrinva_pdaf, py__cvt_ens_pdaf, py__cvt_adj_ens_pdaf, py__cvt_pdaf, py__cvt_adj_pdaf, py__obs_op_lin_pdaf, py__obs_op_adj_pdaf, py__init_dim_obs_f_pdaf, py__obs_op_f_pdaf, py__init_obs_f_pdaf, py__init_obs_l_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_hyb3dvar_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__cvt_ens_pdaf (func) – apply control vector transform matrix (ensemble)

• py__cvt_adj_ens_pdaf (func) – apply adjoint control vector transform matrix (ensemble var)

• py__cvt_pdaf (func) – apply control vector transform matrix to control vector

• py__cvt_adj_pdaf (func) – apply adjoint control vector transform matrix

• py__obs_op_lin_pdaf (func) – linearized observation operator

• py__obs_op_adj_pdaf (func) – adjoint observation operator

• py__init_dim_obs_f_pdaf (func) – initialize dimension of observation vector

• py__obs_op_f_pdaf (func) – observation operator

• py__init_obs_f_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_lenkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__localize_covar_pdaf, py__add_obs_err_pdaf, py__init_obs_covar_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_lenkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__localize_covar_pdaf (func) – apply localization to hp and hph^t

• py__add_obs_err_pdaf (func) – add obs error covariance r to hph in enkf

• py__init_obs_covar_pdaf (func) – initialize obs. error cov. matrix r in enkf

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_lestkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_lestkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_letkf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_letkf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_lknetf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__prodrinva_hyb_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf, py__likelihood_l_pdaf, py__likelihood_hyb_l_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_lknetf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__prodrinva_hyb_l_pdaf (func) – provide product r^-1 a on local analysis domain with hybrid weight

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

• py__likelihood_l_pdaf (func) – compute likelihood

• py__likelihood_hyb_l_pdaf (func) – compute likelihood with hybrid weight

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_lnetf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__likelihood_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_lnetf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__likelihood_l_pdaf (func) – compute observation likelihood for an ensemble member

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

Returns:

outflag – status flag

Return type:

int

pyPDAF.PDAF.put_state_lseik(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__init_obs_l_pdaf, py__prepoststep_pdaf, py__prodrinva_l_pdaf, py__init_n_domains_p_pdaf, py__init_dim_l_pdaf, py__init_dim_obs_l_pdaf, py__g2l_state_pdaf, py__l2g_state_pdaf, py__g2l_obs_pdaf, py__init_obsvar_pdaf, py__init_obsvar_l_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_lseik or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize pe-local observation vector

• py__init_obs_l_pdaf (func) – init. observation vector on local analysis domain

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_l_pdaf (func) – provide product r^-1 a on local analysis domain

• py__init_n_domains_p_pdaf (func) – provide number of local analysis domains

• py__init_dim_l_pdaf (func) – init state dimension for local ana. domain

• py__init_dim_obs_l_pdaf (func) – initialize dim. of obs. vector for local ana. domain

• py__g2l_state_pdaf (func) – get state on local ana. domain from full state

• py__l2g_state_pdaf (func) – init full state from state on local analysis domain

• py__g2l_obs_pdaf (func) – restrict full obs. vector to local analysis domain

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

• py__init_obsvar_l_pdaf (func) – initialize local mean observation error variance

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_netf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__likelihood_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_netf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__likelihood_pdaf (func) – compute observation likelihood for an ensemble member

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_pf(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__likelihood_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_pf or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__likelihood_pdaf (func) – compute observation likelihood for an ensemble member

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_prepost(py__collect_state_pdaf, py__prepoststep_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_prepost or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_seek(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_seek or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 hv

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.put_state_seik(py__collect_state_pdaf, py__init_dim_obs_pdaf, py__obs_op_pdaf, py__init_obs_pdaf, py__prepoststep_pdaf, py__prodrinva_pdaf, py__init_obsvar_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_put_state_seik or PDAF source files

Parameters:

• py__collect_state_pdaf (func) – routine to collect a state vector

• py__init_dim_obs_pdaf (func) – initialize dimension of observation vector

• py__obs_op_pdaf (func) – observation operator

• py__init_obs_pdaf (func) – initialize observation vector

• py__prepoststep_pdaf (func) – user supplied pre/poststep routine

• py__prodrinva_pdaf (func) – provide product r^-1 a

• py__init_obsvar_pdaf (func) – initialize mean observation error variance

Returns:

flag – status flag

Return type:

int

pyPDAF.PDAF.reset_forget(forget_in)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_reset_forget or PDAF source files

Parameters:

forget_in (float) – new value of forgetting factor

pyPDAF.PDAF.sampleens(modes, svals, state, verbose, flag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_SampleEns or PDAF source files

Parameters:

• modes (ndarray[float]) – array of eof modes; Dimension: dim,dim_ens-1

• svals (ndarray[float]) – vector of singular values; Dimension: dim_ens-1

• state (ndarray[float]) – pe-local model state; Dimension: dim

• verbose (int) – verbosity flag

• flag (int) – status flag

Returns:

• modes (ndarray[float]) – array of eof modes; Dimension: dim,dim_ens-1

• state (ndarray[float]) – pe-local model state; Dimension: dim

• ens (ndarray[float]) – state ensemble; Dimension: dim,dim_ens

• flag (int) – status flag

pyPDAF.PDAF.seik_omega(omega, omegatype, screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_seik_omega or PDAF source files

Parameters:

• omega (ndarray[float]) – matrix omega; Dimension: rank+1,rank

• omegatype (int) – select type of omega

• screen (int) – verbosity flag

Returns:

omega – matrix omega; Dimension: rank+1,rank

Return type:

ndarray[float]

pyPDAF.PDAF.seik_ttimesa(a)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_seik_TtimesA or PDAF source files

Parameters:

a (ndarray[float]) – input matrix; Dimension: rank,dim_col

Returns:

b – output matrix (ta); Dimension: rank+1,dim_col

Return type:

ndarray[float]

pyPDAF.PDAF.set_comm_pdaf(in_comm_pdaf)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_set_comm_pdaf or PDAF source files

Parameters:

in_comm_pdaf (int) – mpi communicator for pdaf

pyPDAF.PDAF.set_debug_flag(debugval)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_set_debug_flag or PDAF source files

Parameters:

debugval (int) – value of debugging flag; print debug information for >0

pyPDAF.PDAF.set_ens_pointer()

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_set_ens_pointer or PDAF source files

Returns:

• c_ens_point (ndarray[float]) – pointer to smoother array

• dims (ndarray[int]) – dimension of the pointer; Dimension: 2

• status (int) – status flag

pyPDAF.PDAF.set_memberid(memberid)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_set_memberid or PDAF source files

Parameters:

memberid (int) – index in the local ensemble

Returns:

memberid – index in the local ensemble

Return type:

int

pyPDAF.PDAF.set_offline_mode(screen)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_set_offline_mode or PDAF source files

Parameters:

screen (int) – verbosity flag

pyPDAF.PDAF.set_smootherens(maxlag)

See detailed explanation of the routine in https://pdaf.awi.de/trac/wiki/PDAF_set_smootherens or PDAF source files

Parameters:

maxlag (int) – number of past timesteps processed in sens

Returns:

• c_sens_point (ndarray[float]) – pointer to smoother array

• dims (ndarray[int]) – dimension of the pointer; Dimension: 3

• status (int) – status flag