Changes between Initial Version and Version 1 of ImplementGenerateObs_noOMI


Ignore:
Timestamp:
Nov 30, 2020, 12:45:16 PM (2 years ago)
Author:
lnerger
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • ImplementGenerateObs_noOMI

    v1 v1  
     1= Implementation of Observation Generation with PDAF =
     2
     3[[PageOutline(2-3,Contents of this page)]]
     4
     5The observation generation functionality was added with Version 1.14 of PDAF.
     6
     7== Overview ==
     8
     9Twin data assimilation experiments are a common approach to assess data assimilation methods. In twin experiments one uses the model to generate a ''true'' model state. Further one generates synthetic observations by adding random perturbations to the true state. The, in the actual twin experiment one starts the data assimilation with a state estimate that is different from the true state and assimilates the synthetic observations. One can analyze the assimilation result by comparing the state estimate from the twin experiment with the previously generated true state.
     10
     11Starting with version 1.14, PDAF provides functionality to generate synthetic observations. The functionality bases on the normal implementation of the assimilation used with PDAF. However, one can run the observation generation with an ensemble of just one member, which should be initialized with the initial true state. PDAF provides the routines `PDAF_generate_obs` and `PDAF_put_state_generate_obs` to perform the observation generation. These routines use the observation operator routines which the user implements e.g. for assimilating real observations.
     12
     13Here we describes the steps need to generate synthetic obsrvations.
     14
     15== Initialization ==
     16
     17The implementation of the initialization of PDAF is explained on the [wikiInitPdaf page on `init_pdaf` and `PDAF_init`].
     18
     19For the observation generation one just has to set `filtertype = 11`.
     20
     21There are no particular options for the observation generation functionality. So for `filter_param_i` one just has to specify the mandatory values of the state dimension and the ensemble size. For `filter_param_r` one has to specify the mandatory values of the forgetting factor (even though, this value is ignored for the observation generation)
     22
     23== Observation Generation Step ==
     24
     25This step replaces the analysis step. The implementation is analogous to implementing the analysis step as described on the [wiki:ImplementationofAnalysisStep page on implementing the analysis step].
     26
     27== `PDAF_generate_obs` ==
     28
     29This routine is used in the same way as the filter specific routines `PDAF_assimilate_*`. Thus the general aspect have been described on the page [ModifyModelforEnsembleIntegration Modification of the model code for the ensemble integration] and its sub-page on [InsertAnalysisStep inserting the analysis step]. The routine `PDAF_generate_obs` is used in the fully-parallel implementation variant of the data assimilation system. When the 'flexible' implementation variant is used, the routines `PDAF_put_state_generate_obs' is used as described further below. Here, we list once more the full interface. Subsequently, the full set of user-supplied routines specified in the call to `PDAF_generate_obs` is explained. Apart from two call-back routines, the routines are idnetical to e.g. those used for the LESTKF and LETKF filters.
     30
     31{{{
     32  SUBROUTINE PDAF_generate_obs(U_collect_state, U_distribute_state, &
     33                                  U_init_dim_obs_f, U_obs_op_f, U_init_obserr_f, U_get_obs_f, &
     34                                  U_prepoststep, U_next_observation, status_pdaf)
     35}}}
     36with the following arguments:
     37 * `U_collect_state`: The name of the user-supplied routine that initializes a state vector from the array holding the ensemble of model states from the model fields. This is basically the inverse operation to `U_distribute_state` used in [ModifyModelforEnsembleIntegration#PDAF_get_state PDAF_get_state]
     38 * `U_distribute_state`:  The name of a user supplied routine that initializes the model fields from the array holding the ensemble of model state vectors.
     39 * `U_init_dim_obs_f`: The name of the user-supplied routine that provides the size of the full observation vector
     40 * `U_obs_op_f`: The name of the user-supplied routine that acts as the full observation operator on some state vector
     41 * `U_init_obserr_f`: The name of the user-supplied routine that initializes the vector of observations error standard deviations for full observation vector
     42 * `U_get_obs_f`: The name of the user-supplied routine that receives the full vector of generated synthetic observations from PDAF
     43 * `U_prepoststep`: The name of the pre/poststep routine as in `PDAF_get_state`
     44 * `U_next_observation`: The name of a user supplied routine that initializes the variables `nsteps`, `timenow`, and `doexit`. The same routine is also used in `PDAF_get_state`.
     45 * `status_pdaf`: The integer status flag. It is zero, if `PDAF_assimilate_lestkf` is exited without errors.
     46
     47
     48== `PDAF_put_state_generate_obs` ==
     49
     50When the 'flexible' implementation variant is chosen for the assimilation system, the routine `PDAF_put_state_generate_obs` has to be used instead of `PDAF_generate_obs`. The general aspects of the filter specific routines `PDAF_put_state_*` have been described on the page [ModifyModelforEnsembleIntegration Modification of the model code for the ensemble integration]. The interface of the routine is identical with that of `PDAF_generate_obs` with the exception the specification of the user-supplied routines `U_distribute_state` and `U_next_observation` are missing.
     51
     52The interface is the following:
     53{{{
     54  SUBROUTINE PDAF_put_state_generate_obs(U_collect_state, U_init_dim_obs_f, U_obs_op_f, U_init_obserr_f, &
     55                                  U_get_obs_f, U_prepoststep, status_pdaf)
     56}}}
     57
     58
     59
     60== User-supplied routines ==
     61
     62Here, all user-supplied routines are described that are required in the call to `PDAF_generate_obs`. For some of the generic routines, we link to the page on [ModifyModelforEnsembleIntegration modifying the model code for the ensemble integration].
     63
     64To indicate user-supplied routines we use the prefix `U_`. In the template directory `templates/` as well as in the example implementation in `testsuite/src/dummymodel_1D` these routines exist without the prefix, but with the extension `_pdaf.F90`. In the section titles below we provide the name of the template file in parentheses.
     65
     66In the subroutine interfaces some variables appear with the suffix `_p` (short for 'process'). This suffix indicates that the variable is particular to a model sub-domain, if a domain decomposed model is used. Thus, the value(s) in the variable will be different for different model sub-domains. In addition, there will be variables with the suffix `_f` (for 'full').
     67
     68=== `U_collect_state` (collect_state_pdaf.F90) ===
     69
     70This routine is independent from the filter algorithm used.
     71See the page on [InsertAnalysisStep#U_collect_statecollect_state_pdaf.F90 inserting the analysis step] for the description of this routine.
     72
     73=== `U_distribute_state` (distribute_state_pdaf.F90) ===
     74
     75This routine is independent of the filter algorithm used.
     76See the page on [InsertAnalysisStep#U_distribute_statedistribute_state_pdaf.F90 inserting the analysis step] for the description of this routine.
     77
     78
     79=== `U_init_dim_obs_f` (init_dim_obs_f_pdaf.F90) ===
     80
     81This routine 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. The routine is described in detail on the [wiki:ImplementAnalysislestkf page on implementing the analysis step for LESKTF].
     82
     83=== `U_obs_op_f` (obs_obs_f_pdaf.F90) ===
     84
     85This routine has to perform the operation of the observation operator acting on a state vector, which 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. The routine is described in detail on the [wiki:ImplementAnalysislestkf page on implementing the analysis step for LESKTF].
     86
     87=== `U_init_obserr_f` (init_obserr_f_pdaf.F90) ===
     88
     89This routine is specific for the observation generation. The routine is called by PDAF during the observation generation. Its purpose is to fill the provided vector of observation error standard deviations.
     90
     91The interface is the following:
     92{{{
     93SUBROUTINE init_obserr_f_pdaf(step, dim_obs_f, obs_f, rms_obs)
     94}}}
     95with
     96 * `step` : `integer, intent(in)`[[BR]] Current time step
     97 * `dim_obs_f` : `integer, intent(in)`[[BR]] Size of full observation vector
     98 * `obs_f` : `real, intent(in), dimension(dim_obs_f)`[[BR]] Full vector of observations
     99 * `rms_obs` : `real, intent(out), dimension(dim_obs_f)`[[BR]] Full vector of observation error standard deviations
     100
     101Notes:
     102 * The routines handles the 'full' observation vector as in localizated filters. As described for the observation generation functionality one can also use it for global filters. In this case the 'full' vector would just contain the observations local to a process sub-domain.
     103 * The observation vector `obs_f` is provided to the routine for the case that the observation error is relative to the value of the observations.
     104
     105=== `U_get_obs_f` (get_obs_f_pdaf.F90) ===
     106
     107This routine is specific for the observation generation. In this routine PDAF provides the user with the vector of synthetic observations generated by PDAF. One can then e.g. write the observation vector into a file so that one can use it later in a twin experiment (The template file `readwrite_obs.F90` provides functionality for reading and writing as described on the [wiki:readwrite_obs page on readwrite_obs].
     108
     109The interface is the following:
     110{{{
     111SUBROUTINE get_obs_f_pdaf(step, dim_obs_f, observation_f)
     112}}}
     113with
     114 * `step` : `integer, intent(in)`[[BR]] Current time step
     115 * `dim_obs_f` : `integer, intent(in)`[[BR]] Size of the full observation vector
     116 * `observation_f` : `real, intent(out), dimension(dim_obs_f)`[[BR]] Full vector of synthetic observations (process-local)
     117
     118Hints:
     119 * For the generation of synthetic observations, PDAF does not distinguish between local and global filters. Without parallelization, the full observation vector would be the same for both types of filters. With parallelization the implementation of the observation operator used for generating the observations will define whether different process-domain have the same or distinct observation vectors (i.e. covering the global domain or different process-specific domains).
     120 * In case of the global filters, one uses the functionality of the observation operator for this filter type. With parallelization, the observation operator will initialize an observation vector specifically for each process-domain.
     121 * The usual operation performed in this routine is to write the generated synthetic observation into a file. The PDAF package provides the template routine [wiki:readwrite_obs readwrite_obs] for this. Depending on the parallelization, discussed above, one either writes a single file (of the full observation vector is the same for all processes. In this case one a single process calls the writing routine) or a different file for each process (in this case, each process call the routine with a different file name; usually indicating the process-rank number).
     122
     123
     124=== `U_prepoststep` (prepoststep_ens_pdaf.F90) ===
     125
     126This routine can be identical to that used for the global ESTKF algorithm, which has already been described on the [ModifyModelforEnsembleIntegration#U_prepoststepprepoststep_ens.F90 page on modifying the model code for the ensemble integration].
     127
     128=== `U_next_observation` (next_observation_pdaf.F90) ===
     129
     130This routine is independent of the filter algorithm used.
     131See the page on [InsertAnalysisStep#U_next_observationnext_observation_pdaf.F90 inserting the analysis step] for the description of this routine.
     132
     133
     134== Recommendations for using `PDAF_generate_obs` ==
     135
     136The observation-generation with `PDAF_generate_obs` or `PDAF_put_state_generate_obs` works analogously to the observation handling in the localized filters like LESTKF and LETKF. However, the observation generation does not modify the ensemble states and `prepoststep_pdaf` is only called once before the each observation generation, but not afterwards. The routine `init_dim_obs_f_pdaf` can be identical to the actuall assimilation case. It initializes the full observation dimension and usually also some more observation information (as described e.g. on the [wikio:init_dim_obs_f_pdaf detail page on init_dim_obs_f_pdaf]. Subsequently `obs_op_f_pdaf` is applied. One can run the ensemble generation with a single ensemble member (dim_ens=1) or a larger ensemble. If dim_ens>1, the observation operator is applied to the ensemble mean state. The routine `init_obserr_f_pdaf` provides PDAF with the vector of observation error standard deviations. This is used in combination with Gaussian random noise to compute the perturbations that are added to the true state to generate the observations. Finally `get_obs_f_pdaf` gives the user access to the generated synthetic observation vector so that one can write it to a file for later use (See the [wiki:readwrite_obs page on the template file readwrite_obs.F90] for a description how the observations can be written to a file and used later on).
     137
     138If one has access to real observations, one can use the implementation of `init_dim_obs_f_pdaf` and `obs_ob_f_pdaf` for these observations to generate synthetic observations simulating these real observations. Thus one runs the observation generation using these routines without any modifications.
     139
     140
     141== Using the synthetic observations in twin experiments ==
     142
     143To perform a twin experiment using the synthetic observations generated by PDAF, one runs the data assimilation as one would with real observations. If one already initializes the vector of actual observations in the routine `init_dim_obs_f` one only needs to small modification of this routine. Namely, only required modification is that at the end of `init_dim_obs_f` one overwrites the vector of real observations with the values from the synthetic observations. If one uses the template file `readwrite_obs.F90` for this, one can use `read_syn_obs` from this file at the end of `init_dim_obs_f` to overwrite the observatio vector. To allow for a flexible switching between the case using real observations and the twin experiment, one can for example introduce a flag `twin_experiment` that controls whether the real observation values are overwritten.
     144
     145Example implementations using `PDAF_put_state_generate_obs` and `readwrite_obs.F90` are provided by the two test cases `testsuite/src/dummymodel_1D` and `testsuite/src/lorenz96`. These also use the flag `twin_experiment` to actiavate the twin experiment (Note: These two test cases always use simulated observations. Nonetheless, they allow to see how the synthetic observations are generated with PDAF and how they are used in a twin experiment).