Changes between Version 6 and Version 7 of ImplementAnalysislseik

Timestamp:

Sep 1, 2010, 4:45:37 PM (14 years ago)

Author:

lnerger

Comment:

--

ImplementAnalysislseik

@@ -50 +50 @@
 with the following arguments:
  * `U_collect_state`: The name of the user-supplied routine that initializes a state vector from the array holding the ensembel of model states from the model fields. This is basically the inverse operation to `U_distribute_state` used in `PDAF_get_state`
- * `U_init_dim_obs_f`: The name of the user-supplied routine that provides the size of observation vector
- * `U_obs_op_f`: The name of the user-supplied routine that acts as the observation operator on some state vector
- * `U_init_obs_f`: The name of the user-supplied routine that initializes the vector of observations
+ * `U_init_dim_obs_full`: The name of the user-supplied routine that provides the size of observation vector
+ * `U_obs_op_full`: The name of the user-supplied routine that acts as the observation operator on some state vector
+ * `U_init_obs_full`: The name of the user-supplied routine that initializes the vector of observations
  * `U_init_obs_l`: The name of the user-supplied routine that initializes the vector of observations for a local analysis domain
  * `U_prepoststep`: The name of the pre/poststep routine as in `PDAF_get_state`
@@ -83 +83 @@
 The interface for this routine is:
 {{{
-SUBROUTINE init_dim_obs_f(step, dim_obs_f)
+SUBROUTINE init_dim_obs_full(step, dim_obs_f)
 
   INTEGER, INTENT(in)  :: step       ! Current time step
@@ -90 +90 @@
 
 The routine is called at the beginning of each analysis step, before the loop over all local analysis domains is entered.  It has to initialize the size `dim_obs_f` of the full observation vector according to the current time step. For simplicity, `dim_obs_f` can be the size for the global model domain.
-When a domain-decomposed model is used, `dim_obs_f` will be the size of the observation vector for the sub-domain of the calling process plus .
 
 Some hints:
- * It can be useful if not only the size of the observation vector is determined at this point. One can also already gather information about the location of the observations, which will be used later, e.g. to implement the observation operator. An array for the locations can be defined in a module like `mod_assimilation`.
+ * It can be useful to not only determine the size of the observation vector at this point. One can also already gather information about the location of the observations, which will be used later, e.g. to implement the observation operator. An array for the locations can be defined in a module like `mod_assimilation`.
+ * The routine is similar to `init_dim_obs` used in the global filters. However, if the global filter is used with a domain-decomposed model, it only initializes the size of the observation vector for the local model sub-domain. This is different for the local filters, as the local analysis also requires observational data from neighboring model sub-domains. Anyway, one can base on an implemented routine `init_dim_obs` to implement `init_dim_obs_full`.
 
-== `U_obs_op` (obs_op.F90) ==
+== `U_obs_op_full` (obs_op_full.F90) ==
 
-This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF).
+This routine is used by all local filter algorithms (LSEIK, LETKF).
 
 The interface for this routine is:
 {{{
-SUBROUTINE obs_op(step, dim_p, dim_obs_p, state_p, m_state_p)
-
+SUBROUTINE obs_op_full(step, dim_p, dim_obs_f, state_p, m_state_f)
   INTEGER, INTENT(in) :: step               ! Currrent time step
   INTEGER, INTENT(in) :: dim_p              ! PE-local dimension of state
-  INTEGER, INTENT(in) :: dim_obs_p          ! Dimension of observed state
+  INTEGER, INTENT(in) :: dim_obs_f          ! Dimension of the full observed state
   REAL, INTENT(in)    :: state_p(dim_p)     ! PE-local model state
-  REAL, INTENT(out) :: m_state_p(dim_obs_p) ! PE-local observed state
+  REAL, INTENT(out) :: m_state_f(dim_obs_f) ! Full observed state
 }}}
 
-The routine is called during the analysis step. It has to perform the operation of the observation operator acting on a state vector that is provided as `state_p`. The observed state has to be returned in `m_state_p`.
-
-For a model using domain decomposition, the operation is on the PE-local sub-domain of the model and has to provide the observed sub-state for the PE-local domain.
+The routine is called during the analysis step, before the loop over the local analysis domain is entered. It has to perform the operation of the observation operator acting on a state vector that is provided as `state_p`. The observed state has to be returned in `m_state_f`. It is the observed state corresponding to the 'full' observation vector.
 
 Hint:
  * If the observation operator involves a global operation, e.g. some global integration, while using domain-decompostion one has to gather the information from the other model domains using MPI communication. 
+ * Analogously to the situation with `init_dim_obs_full`, the routine is similar to `init_dim_obs` used for the global filters. However, with a domain-decompoared model also here `m_state_f` will contain parts of the state vector from neighboring model sub-domains. To make these parts accessible, some parallel communication will be necessary (The state information for a neighboring model sub-domain, will be in the memory of the process that handles that sub-domain). The example implementation in `testsuite/dummymodel_1d` uses the function `MPI_AllGatherV` for this communication.
 
-== `U_init_obs` (init_obs.F90) ==
+== `U_init_obs_full` (init_obs_full.F90) ==
 
-This routine is used by all global filter algorithms (SEEK, SEIK, EnKF, ETKF).
+This routine is used by all local filter algorithms (LSEIK, LETKF).
 
 The interface for this routine is:
 {{{
-SUBROUTINE init_obs(step, dim_obs_p, observation_p)
+SUBROUTINE init_obs_full(step, dim_obs_f, observation_f)
 
   INTEGER, INTENT(in) :: step             ! Current time step
-  INTEGER, INTENT(in) :: dim_obs_p        ! PE-local dimension of obs. vector
-  REAL, INTENT(out)   :: observation_p(dim_obs_p) ! PE-local observation vector
+  INTEGER, INTENT(in) :: dim_obs_f        ! Dimension of full observation vector
+  REAL, INTENT(out)   :: observation_f(dim_obs_f) ! Full observation vector
 }}}
 
-The routine is called during the analysis step. 
-It has to provide the vector of observations in `observation_p` for the current time step. 
+The routine is called during the analysis step before the loop over the local analysis domains is entered. 
+It has to provide the full vector of observations in `observation_f` for the current time step. 
 
-For a model using domain decomposition, the vector of observations that exist on the model sub-domain for the calling process has to be initialized.
-
+Hints:
+ * As for the other 'full' routines: While the global counterpart of this routine (`init_obs`) has to initialize the observation vector for the local model sub-domain, the 'full' routine has to include observations that spatially belong to neighboring model sub-domains. As an easy choice one can simply initialize a vector of all globally available observations.
 
 == `U_prodRinvA` (prodrinva.F90) ==