INTERFACE / PUBLIC COMPONENTS / FILES / REFERENCES / ERRORS / BUGS / PLANS /

MODULE obs_model_mod

Contact: Jeff Anderson
Reviewers:  
Revision: $Revision: 1.6 $
Release Name: $Name: $
Change Date: $Date: 2006/09/11 14:35:32 $
Change history: see CVS log

OVERVIEW

This is the highest level in DART where a module has access to details of both the assim_model structure and the observation structure. Operations like the evaluation of forward operators that require a knowledge of both the observations and the model details are computed here.




OTHER MODULES USED

types_mod
utilities_mod
assim_model_mod
obs_sequence_mod
obs_def_mod
time_manager_mod
ensemble_manager_mod
mpi_utilities_mod



PUBLIC INTERFACE

use obs_model_mod, only : advance_state
 move_ahead

NOTES




PUBLIC COMPONENTS



call move_ahead(ens_handle, ens_size, seq, last_key_used, key_bounds, num_obs_in_set, async, adv_ens_command)
 type(ensemble_type),     intent(in)  :: ens_handle
 integer,                 intent(in)  :: ens_size
 type(obs_sequence_type), intent(in)  :: seq
 integer,                 intent(in)  :: last_key_used
 integer, dimension(2),   intent(out) :: key_bounds
 integer,                 intent(out) :: num_obs_in_set
 integer,                 intent(in)  :: async
 character(len=129),      intent(in)  :: adv_ens_command
 

Description

Given an observation sequence and an ensemble, determines how to advance the model so that the next set of observations can be assimilated. Also returns the first and last keys and the number of observations to be assimilated at this time. The algorithm implemented here (one might want to have other variants) first finds the time of the next observation that has not been assimilated at a previous time. It also determines the time of the ensemble state vectors. It then uses information about the model's time stepping capabilities to determine the time to which the model can be advanced that is CLOSEST to the time of the next observation. For now, this algorithm assumes that the model's timestep is a constant. A window of width equal to the model timestep is centered around the closest model time to the next observation and all observations in this window are added to the set to be assimilated.

ens_handle    Identifies the model state ensemble
ens_size    Number of ensemble members
seq    An observation sequence
last_key_used    Identifies the last observation from the sequence that has been used
key_bounds    Returned lower and upper bound on observations to be used at this time
num_obs_in_set    Number of observations to be used at this time
async    Controls how model is advanced (see filter)
adv_ens_command    Command issued by shell for async option 2 (see filter)


call advance_state(ens_handle,ens_size,target_time,async,adv_en s_command)
 type(ensemble_type), intent(inout) :: ens_handle
 integer, intent(in)                :: ens_size
 type(time_type), intent(in)        :: target_time
 integer, intent(in)                :: async
 character(len=*), intent(in)       :: adv_ens_command
 

Description

Advances all ensemble size copies of an ensemble stored in ens_handle to the target_time. If async=0 this is done by repeated calls to adv_1step subroutine. If async=2, a call to the shell with the command adv_ens_command is used.

ens_handle    Structure for holding ensemble information and data
ens_size    Ensemble size.
target_time    Time to which model is to be advanced.
async    How to advance model: 0=subroutine adv_1step; 2=use shell of adv_ens_co mmand.
adv_ens_command    Command to be issued to shell to advance model if async=2.




FILES




REFERENCES


ERROR CODES and CONDITIONS

RoutineMessageComment
move_ahead next obs time not in model time window Error in algorithm to compute observation window
advance_state target time ###,### is before model_time ###,### Target time must not be before current model time.
advance_state Trying to use ### model states -- too many. Use less than 10000 member ensemble. Maximum of 9999 ensemble members is allowed.
advance_state Can only have 10000 processes. No more than 9999 processes can run.
advance_state input.nml - async is #, must be 0, or 2. Only 0 or 2 work for async.



KNOWN BUGS




FUTURE PLANS