[Dart-dev] DART/branches Revision: 11730

[dart at ucar.edu]

nancy at ucar.edu
2017-06-14 12:53:32 -0600 (Wed, 14 Jun 2017)
106
remove ens_size array dimension and do the interpolation
in a loop.   still fails right now in z2zint().




Modified: DART/branches/coamps/models/coamps_nest/coamps_interp_mod.f90
===================================================================
--- DART/branches/coamps/models/coamps_nest/coamps_interp_mod.f90	2017-06-14 18:02:12 UTC (rev 11729)
+++ DART/branches/coamps/models/coamps_nest/coamps_interp_mod.f90	2017-06-14 18:53:32 UTC (rev 11730)
@@ -27,8 +27,7 @@
                                      get_nest_size, get_nest_level,             &
                                      in_this_nest
 
-    use coamps_statevar_mod,  only : state_variable, get_var_substate, is_sigma_level, &
-                                     state_limits
+    use coamps_statevar_mod,  only : state_variable, get_var_start, is_sigma_level
 
     use coamps_statevec_mod,  only : state_vector, find_state_variable
 
@@ -50,7 +49,8 @@
     use obs_kind_mod
     use types_mod,            only : MISSING_I,        &
                                      MISSING_R8,       &
-                                     r8
+                                     r8,               &
+                                     i8
     use utilities_mod,        only : do_output,        &
                                      E_ERR,            &
                                      E_MSG,            &
@@ -157,9 +157,9 @@
     ! I can keep them straight: 
     !  "values" arrays index as (neighbor, level)
     !  availability array index as (level, variable)
-    integer, parameter :: VALUES_DIM_ENSEMBLE       = 1
-    integer, parameter :: VALUES_DIM_NEIGHBOR       = 2
-    integer, parameter :: VALUES_DIM_LEVEL          = 3
+    integer, parameter :: VALUES_DIM_NEIGHBOR       = 1
+    integer, parameter :: VALUES_DIM_LEVEL          = 2
+    integer, parameter :: VALUES_DIM_ENSEMBLE       = 3
     integer, parameter :: AVAILABILITY_DIM_LEVEL    = 1
     integer, parameter :: AVAILABILITY_DIM_VARIABLE = 2
   
@@ -177,10 +177,11 @@
         ! NEW:
         type(ensemble_type),         pointer :: state_handle
         integer                              :: ensemble_size
+        integer                              :: ensemble_number   ! TEMP SOLUTION - slow!!!
+
         type(coamps_domain),         pointer :: model_domain
         type(coamps_nest),           pointer :: interp_nest
         type(state_vector),          pointer :: state_definition
-        type(state_limits)                   :: state_limits 
 
         ! Location (horizontal and vertical) of where we will interpolate
         type(nest_point)  :: interp_point
@@ -192,9 +193,9 @@
         integer, dimension(NUM_NEIGHBORS) :: neighbors_j
 
         ! OLD Raw values - indexed by (neighbor, sigma level)
-        ! Raw values - indexed by (ens_size, neighbor, sigma level)
-        real(kind=r8), dimension(:,:,:), pointer :: target_values
-        real(kind=r8), dimension(:,:,:), pointer :: vcoord_values
+        ! Raw values - indexed by (ens_size, neighbor, sigma level)?  or (neighbor, sigma level, ensemble number)?
+        real(kind=r8), dimension(:,:), pointer :: target_values
+        real(kind=r8), dimension(:,:), pointer :: vcoord_values
 
         ! Variable availability is stored as an (# of levels) x (# of vars)
         ! array - if the value at (level, variable) is .true., then that
@@ -205,11 +206,11 @@
         integer                          :: num_levels_available
 
         ! Filtered raw values only on levels that have all data available
-        real(kind=r8), dimension(:,:,:), pointer :: available_target_values
-        real(kind=r8), dimension(:,:,:), pointer :: available_vcoord_values
+        real(kind=r8), dimension(:,:), pointer :: available_target_values
+        real(kind=r8), dimension(:,:), pointer :: available_vcoord_values
 
         ! Results of vertical interpolation
-        real(kind=r8), dimension(:,:,:),        pointer :: vinterp_values
+        real(kind=r8), dimension(:,:),          pointer :: vinterp_values
         real(kind=r8), dimension(SINGLE_LEVEL)          :: vinterp_level
 
         ! Weights for the horizontal interpolation
@@ -262,22 +263,24 @@
     !   IN  state             big ol' DART state vector
     ! NOW: state_handle       handle to entire ensemble of state
     !   IN  ens_size          ensemble size
+    !   IN  ens_num           ensemble_number - FIXME: doing one at a time
     !   IN  domain            COAMPS domain to interpolate on
     !   IN  state_def         COAMPS state vector definition
     !   IN  obs_loc           DART location structure to interpolate to
     !   IN  obs_kind          integer version of raw variable type
     !   OUT obs_value         result of interpolation
     !   OUT interp_worked     true if interpolation was successful
-    subroutine interpolate(state_handle, ens_size, domain, state_def, obs_loc, obs_kind, &
+    subroutine interpolate(state_handle, ens_size, ens_num, domain, state_def, obs_loc, obs_kind, &
                            obs_value, interp_worked)
         type(ensemble_type),         intent(in)  :: state_handle
         integer,                     intent(in)  :: ens_size
+        integer,                     intent(in)  :: ens_num
         type(coamps_domain),         intent(in)  :: domain
         type(state_vector),          intent(in)  :: state_def
         type(location_type),         intent(in)  :: obs_loc
         integer,                     intent(in)  :: obs_kind
-        real(kind=r8),               intent(out) :: obs_value(ens_size)
-        logical, optional,           intent(out) :: interp_worked(ens_size)